5658 lines
156 KiB
C++
5658 lines
156 KiB
C++
/*****************************************************************************
|
|
* name: snd_dma.c
|
|
*
|
|
* desc: main control for any streaming sound output device
|
|
*
|
|
*
|
|
*****************************************************************************/
|
|
// leave this as first line for PCH reasons...
|
|
//
|
|
#include "../server/exe_headers.h"
|
|
|
|
#include "snd_local.h"
|
|
#include "cl_mp3.h"
|
|
#include "snd_music.h"
|
|
|
|
static void S_Play_f(void);
|
|
static void S_SoundList_f(void);
|
|
static void S_Music_f(void);
|
|
static void S_SetDynamicMusic_f(void);
|
|
|
|
void S_Update_();
|
|
void S_StopAllSounds(void);
|
|
static void S_UpdateBackgroundTrack( void );
|
|
sfx_t *S_FindName( const char *name );
|
|
static int SND_FreeSFXMem(sfx_t *sfx);
|
|
|
|
extern qboolean Sys_LowPhysicalMemory();
|
|
|
|
//////////////////////////
|
|
//
|
|
// vars for bgrnd music track...
|
|
//
|
|
const int iMP3MusicStream_DiskBytesToRead = 10000;//4096;
|
|
const int iMP3MusicStream_DiskBufferSize = iMP3MusicStream_DiskBytesToRead*2; //*10;
|
|
|
|
typedef struct
|
|
{
|
|
qboolean bIsMP3;
|
|
//
|
|
// MP3 specific...
|
|
//
|
|
sfx_t sfxMP3_Bgrnd;
|
|
MP3STREAM streamMP3_Bgrnd; // this one is pointed at by the sfx_t's ptr, and is NOT the one the decoder uses every cycle
|
|
channel_t chMP3_Bgrnd; // ... but the one in this struct IS.
|
|
//
|
|
// MP3 disk streamer stuff... (if music is non-dynamic)
|
|
//
|
|
byte byMP3MusicStream_DiskBuffer[iMP3MusicStream_DiskBufferSize];
|
|
int iMP3MusicStream_DiskReadPos;
|
|
int iMP3MusicStream_DiskWindowPos;
|
|
//
|
|
// MP3 disk-load stuff (for use during dynamic music, which is mem-resident)
|
|
//
|
|
byte *pLoadedData; // Z_Malloc, Z_Free // these two MUST be kept as valid/invalid together
|
|
char sLoadedDataName[MAX_QPATH]; // " " " " "
|
|
int iLoadedDataLen;
|
|
//
|
|
// remaining dynamic fields...
|
|
//
|
|
int iXFadeVolumeSeekTime;
|
|
int iXFadeVolumeSeekTo; // when changing this, set the above timer to Sys_Milliseconds().
|
|
// Note that this should be thought of more as an up/down bool rather than as a
|
|
// number now, in other words set it only to 0 or 255. I'll probably change this
|
|
// to actually be a bool later.
|
|
int iXFadeVolume; // 0 = silent, 255 = max mixer vol, though still modulated via overall music_volume
|
|
float fSmoothedOutVolume;
|
|
qboolean bActive; // whether playing or not
|
|
qboolean bExists; // whether was even loaded for this level (ie don't try and start playing it)
|
|
//
|
|
// new dynamic fields...
|
|
//
|
|
qboolean bTrackSwitchPending;
|
|
MusicState_e eTS_NewState;
|
|
float fTS_NewTime;
|
|
//
|
|
// Generic...
|
|
//
|
|
fileHandle_t s_backgroundFile; // valid handle, else -1 if an MP3 (so that NZ compares still work)
|
|
wavinfo_t s_backgroundInfo;
|
|
int s_backgroundSamples;
|
|
|
|
void Rewind()
|
|
{
|
|
MP3Stream_Rewind( &chMP3_Bgrnd );
|
|
s_backgroundSamples = sfxMP3_Bgrnd.iSoundLengthInSamples;
|
|
}
|
|
|
|
void SeekTo(float fTime)
|
|
{
|
|
chMP3_Bgrnd.iMP3SlidingDecodeWindowPos = 0;
|
|
chMP3_Bgrnd.iMP3SlidingDecodeWritePos = 0;
|
|
MP3Stream_SeekTo( &chMP3_Bgrnd, fTime );
|
|
s_backgroundSamples = sfxMP3_Bgrnd.iSoundLengthInSamples;
|
|
}
|
|
|
|
} MusicInfo_t;
|
|
|
|
static void S_SetDynamicMusicState( MusicState_e musicState );
|
|
|
|
#define fDYNAMIC_XFADE_SECONDS (1.0f)
|
|
|
|
static MusicInfo_t tMusic_Info[eBGRNDTRACK_NUMBEROF] = {0};
|
|
static qboolean bMusic_IsDynamic = qfalse;
|
|
static MusicState_e eMusic_StateActual = eBGRNDTRACK_EXPLORE; // actual state, can be any enum
|
|
static MusicState_e eMusic_StateRequest = eBGRNDTRACK_EXPLORE; // requested state, can only be explore, action, boss, or silence
|
|
static char sMusic_BackgroundLoop[MAX_QPATH] = {0}; // only valid for non-dynamic music
|
|
static char sInfoOnly_CurrentDynamicMusicSet[64]; // any old reasonable size, only has to fit stuff like "kejim_post"
|
|
//
|
|
//////////////////////////
|
|
|
|
|
|
// =======================================================================
|
|
// Internal sound data & structures
|
|
// =======================================================================
|
|
|
|
// only begin attenuating sound volumes when outside the FULLVOLUME range
|
|
#define SOUND_FULLVOLUME 256
|
|
|
|
#define SOUND_ATTENUATE 0.0008f
|
|
#define VOICE_ATTENUATE 0.004f
|
|
|
|
const float SOUND_FMAXVOL=0.75;//1.0;
|
|
const int SOUND_MAXVOL=255;
|
|
|
|
channel_t s_channels[MAX_CHANNELS];
|
|
|
|
int s_soundStarted;
|
|
qboolean s_soundMuted;
|
|
|
|
dma_t dma;
|
|
|
|
int listener_number;
|
|
vec3_t listener_origin;
|
|
vec3_t listener_axis[3];
|
|
|
|
int s_soundtime; // sample PAIRS
|
|
int s_paintedtime; // sample PAIRS
|
|
|
|
// MAX_SFX may be larger than MAX_SOUNDS because
|
|
// of custom player sounds
|
|
#define MAX_SFX 10000 //512 * 2
|
|
sfx_t s_knownSfx[MAX_SFX];
|
|
int s_numSfx;
|
|
|
|
#define LOOP_HASH 128
|
|
static sfx_t *sfxHash[LOOP_HASH];
|
|
|
|
|
|
cvar_t *s_volume;
|
|
cvar_t *s_volumeVoice;
|
|
cvar_t *s_testsound;
|
|
cvar_t *s_khz;
|
|
cvar_t *s_allowDynamicMusic;
|
|
cvar_t *s_show;
|
|
cvar_t *s_mixahead;
|
|
cvar_t *s_mixPreStep;
|
|
cvar_t *s_musicVolume;
|
|
cvar_t *s_separation;
|
|
cvar_t *s_lip_threshold_1;
|
|
cvar_t *s_lip_threshold_2;
|
|
cvar_t *s_lip_threshold_3;
|
|
cvar_t *s_lip_threshold_4;
|
|
cvar_t *s_CPUType;
|
|
cvar_t *s_language; // note that this is distinct from "g_language"
|
|
cvar_t *s_dynamix;
|
|
cvar_t *s_debugdynamic;
|
|
|
|
typedef struct
|
|
{
|
|
unsigned char volume;
|
|
vec3_t origin;
|
|
vec3_t velocity;
|
|
/* const*/ sfx_t *sfx;
|
|
int mergeFrame;
|
|
int entnum;
|
|
|
|
// For Open AL
|
|
bool bProcessed;
|
|
bool bRelative;
|
|
} loopSound_t;
|
|
|
|
#define MAX_LOOP_SOUNDS 32
|
|
int numLoopSounds;
|
|
loopSound_t loopSounds[MAX_LOOP_SOUNDS];
|
|
|
|
|
|
int s_rawend;
|
|
portable_samplepair_t s_rawsamples[MAX_RAW_SAMPLES];
|
|
vec3_t s_entityPosition[MAX_GENTITIES];
|
|
int s_entityWavVol[MAX_GENTITIES];
|
|
int s_entityWavVol_back[MAX_GENTITIES];
|
|
|
|
|
|
/**************************************************************************************************\
|
|
*
|
|
* Open AL Specific
|
|
*
|
|
\**************************************************************************************************/
|
|
|
|
int s_UseOpenAL = false; // Determines if using Open AL or the default software mixer
|
|
|
|
ALfloat listener_pos[3]; // Listener Position
|
|
ALfloat listener_ori[6]; // Listener Orientation
|
|
int s_numChannels; // Number of AL Sources == Num of Channels
|
|
short s_rawdata[MAX_RAW_SAMPLES*2]; // Used for Raw Samples (Music etc...)
|
|
|
|
channel_t *S_OpenALPickChannel(int entnum, int entchannel);
|
|
int S_MP3PreProcessLipSync(channel_t *ch, short *data);
|
|
void UpdateSingleShotSounds();
|
|
void UpdateLoopingSounds();
|
|
void AL_UpdateRawSamples();
|
|
void S_SetLipSyncs();
|
|
|
|
// EAX Related
|
|
ALboolean s_bEAX; // Is EAX 3.0 support is available
|
|
bool s_bEALFileLoaded; // Has an .eal file been loaded for the current level
|
|
bool s_bInWater; // Underwater effect currently active
|
|
int s_EnvironmentID; // EAGLE ID of current environment
|
|
LPEAXMANAGER s_lpEAXManager; // Pointer to EAXManager object
|
|
HINSTANCE s_hEAXManInst; // Handle of EAXManager DLL
|
|
EAXSet s_eaxSet; // EAXSet() function
|
|
EAXGet s_eaxGet; // EAXGet() function
|
|
bool s_eaxMorphing; // Is EAX Morphing in progress
|
|
int s_eaxMorphStartTime;// EAX Morph start time
|
|
int s_eaxMorphCount; // EAX Morph count (1 ... 10)
|
|
EAXLISTENERPROPERTIES s_eaxLPSource; // Source EAX Parameters
|
|
EAXLISTENERPROPERTIES s_eaxLPCur; // Current EAX Parameters
|
|
EAXLISTENERPROPERTIES s_eaxLPDest; // Destination EAX Parameters
|
|
|
|
void InitEAXManager();
|
|
void ReleaseEAXManager();
|
|
bool LoadEALFile(char *szEALFilename);
|
|
void UnloadEALFile();
|
|
void UpdateEAXListener(bool bUseDefault, bool bUseMorphing);
|
|
void UpdateEAXBuffer(channel_t *ch);
|
|
void EALFileInit(char *level);
|
|
void EAXMorph();
|
|
void Clamp(EAXVECTOR *eaxVector);
|
|
bool CheckEAX3LP(LPEAXLISTENERPROPERTIES lpEAX3LP);
|
|
bool EAX3ListenerInterpolate(EAXLISTENERPROPERTIES *lpStartEAX3LP, EAXLISTENERPROPERTIES *lpFinishEAX3LP,
|
|
float flRatio, EAXLISTENERPROPERTIES *lpResultEAX3LP, bool bCheckValues = false);
|
|
|
|
|
|
|
|
// EAX 3.0 GUIDS ... confidential information ...
|
|
|
|
const GUID DSPROPSETID_EAX30_ListenerProperties
|
|
= { 0xa8fa6882, 0xb476, 0x11d3, { 0xbd, 0xb9, 0x00, 0xc0, 0xf0, 0x2d, 0xdf, 0x87} };
|
|
|
|
const GUID DSPROPSETID_EAX30_BufferProperties
|
|
= { 0xa8fa6881, 0xb476, 0x11d3, { 0xbd, 0xb9, 0x0, 0xc0, 0xf0, 0x2d, 0xdf, 0x87} };
|
|
|
|
/**************************************************************************************************\
|
|
*
|
|
* End of Open AL Specific
|
|
*
|
|
\**************************************************************************************************/
|
|
|
|
// instead of clearing a whole channel_t struct, we're going to skip the MP3SlidingDecodeBuffer[] buffer in the middle...
|
|
//
|
|
static inline void Channel_Clear(channel_t *ch)
|
|
{
|
|
// memset (ch, 0, sizeof(*ch));
|
|
|
|
memset(ch,0,offsetof(channel_t,MP3SlidingDecodeBuffer));
|
|
|
|
byte *const p = (byte *)ch + offsetof(channel_t,MP3SlidingDecodeBuffer) + sizeof(ch->MP3SlidingDecodeBuffer);
|
|
|
|
memset(p,0,(sizeof(*ch) - offsetof(channel_t,MP3SlidingDecodeBuffer)) - sizeof(ch->MP3SlidingDecodeBuffer));
|
|
}
|
|
|
|
// ====================================================================
|
|
// User-setable variables
|
|
// ====================================================================
|
|
static void DynamicMusicInfoPrint(void)
|
|
{
|
|
if (bMusic_IsDynamic)
|
|
{
|
|
// horribly lazy... ;-)
|
|
//
|
|
LPCSTR psRequestMusicState = Music_BaseStateToString( eMusic_StateRequest );
|
|
LPCSTR psActualMusicState = Music_BaseStateToString( eMusic_StateActual, qtrue );
|
|
if (psRequestMusicState == NULL)
|
|
{
|
|
psRequestMusicState = "<unknown>";
|
|
}
|
|
if (psActualMusicState == NULL)
|
|
{
|
|
psActualMusicState = "<unknown>";
|
|
}
|
|
|
|
Com_Printf("( Dynamic music ON, request state: '%s'(%d), actual: '%s' (%d) )\n", psRequestMusicState, eMusic_StateRequest, psActualMusicState, eMusic_StateActual);
|
|
}
|
|
else
|
|
{
|
|
Com_Printf("( Dynamic music OFF )\n");
|
|
}
|
|
}
|
|
|
|
void S_SoundInfo_f(void) {
|
|
Com_Printf("----- Sound Info -----\n" );
|
|
|
|
if (!s_soundStarted) {
|
|
Com_Printf ("sound system not started\n");
|
|
} else {
|
|
if ( s_soundMuted ) {
|
|
Com_Printf ("sound system is muted\n");
|
|
}
|
|
|
|
Com_Printf("%5d stereo\n", dma.channels - 1);
|
|
Com_Printf("%5d samples\n", dma.samples);
|
|
Com_Printf("%5d samplebits\n", dma.samplebits);
|
|
Com_Printf("%5d submission_chunk\n", dma.submission_chunk);
|
|
Com_Printf("%5d speed\n", dma.speed);
|
|
Com_Printf("0x%x dma buffer\n", dma.buffer);
|
|
|
|
if (bMusic_IsDynamic)
|
|
{
|
|
DynamicMusicInfoPrint();
|
|
Com_Printf("( Dynamic music set name: \"%s\" )\n",sInfoOnly_CurrentDynamicMusicSet);
|
|
}
|
|
else
|
|
{
|
|
if (!s_allowDynamicMusic->integer)
|
|
{
|
|
Com_Printf("( Dynamic music inhibited (s_allowDynamicMusic == 0) )\n", sMusic_BackgroundLoop );
|
|
}
|
|
if ( tMusic_Info[eBGRNDTRACK_NONDYNAMIC].s_backgroundFile )
|
|
{
|
|
Com_Printf("Background file: %s\n", sMusic_BackgroundLoop );
|
|
}
|
|
else
|
|
{
|
|
Com_Printf("No background file.\n" );
|
|
}
|
|
}
|
|
}
|
|
S_DisplayFreeMemory();
|
|
Com_Printf("----------------------\n" );
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
================
|
|
S_Init
|
|
================
|
|
*/
|
|
void S_Init( void ) {
|
|
ALCcontext *ALCContext = NULL;
|
|
ALCdevice *ALCDevice = NULL;
|
|
ALfloat listenerPos[]={0.0,0.0,0.0};
|
|
ALfloat listenerVel[]={0.0,0.0,0.0};
|
|
ALfloat listenerOri[]={0.0,0.0,-1.0, 0.0,1.0,0.0};
|
|
cvar_t *cv;
|
|
qboolean r;
|
|
int i, j;
|
|
channel_t *ch;
|
|
|
|
Com_Printf("\n------- sound initialization -------\n");
|
|
|
|
s_volume = Cvar_Get ("s_volume", "0.5", CVAR_ARCHIVE);
|
|
s_volumeVoice= Cvar_Get ("s_volumeVoice", "1.0", CVAR_ARCHIVE);
|
|
s_musicVolume = Cvar_Get ("s_musicvolume", "0.25", CVAR_ARCHIVE);
|
|
s_separation = Cvar_Get ("s_separation", "0.5", CVAR_ARCHIVE);
|
|
s_khz = Cvar_Get ("s_khz", "22", CVAR_ARCHIVE|CVAR_LATCH);
|
|
s_allowDynamicMusic = Cvar_Get ("s_allowDynamicMusic", "1", CVAR_ARCHIVE);
|
|
s_mixahead = Cvar_Get ("s_mixahead", "0.2", CVAR_ARCHIVE);
|
|
|
|
s_mixPreStep = Cvar_Get ("s_mixPreStep", "0.05", CVAR_ARCHIVE);
|
|
s_show = Cvar_Get ("s_show", "0", CVAR_CHEAT);
|
|
s_testsound = Cvar_Get ("s_testsound", "0", CVAR_CHEAT);
|
|
s_debugdynamic = Cvar_Get("s_debugdynamic","0", CVAR_CHEAT);
|
|
s_lip_threshold_1 = Cvar_Get("s_threshold1" , "0.5",0);
|
|
s_lip_threshold_2 = Cvar_Get("s_threshold2" , "4.0",0);
|
|
s_lip_threshold_3 = Cvar_Get("s_threshold3" , "7.0",0);
|
|
s_lip_threshold_4 = Cvar_Get("s_threshold4" , "8.0",0);
|
|
|
|
s_language = Cvar_Get("s_language","english",CVAR_ARCHIVE | CVAR_NORESTART);
|
|
|
|
MP3_InitCvars();
|
|
|
|
s_CPUType = Cvar_Get("sys_cpuid","",0);
|
|
|
|
#if !(defined __linux__ && defined __i386__)
|
|
#if !id386
|
|
#else
|
|
extern unsigned int uiMMXAvailable;
|
|
uiMMXAvailable = !!(s_CPUType->integer >= CPUID_INTEL_MMX);
|
|
#endif
|
|
#endif
|
|
|
|
cv = Cvar_Get ("s_initsound", "1", CVAR_ROM);
|
|
if ( !cv->integer ) {
|
|
s_soundStarted = 0; // needed in case you set s_initsound to 0 midgame then snd_restart (div0 err otherwise later)
|
|
Com_Printf ("not initializing.\n");
|
|
Com_Printf("------------------------------------\n");
|
|
return;
|
|
}
|
|
|
|
Cmd_AddCommand("play", S_Play_f);
|
|
Cmd_AddCommand("music", S_Music_f);
|
|
Cmd_AddCommand("soundlist", S_SoundList_f);
|
|
Cmd_AddCommand("soundinfo", S_SoundInfo_f);
|
|
Cmd_AddCommand("soundstop", S_StopAllSounds);
|
|
Cmd_AddCommand("mp3_calcvols", S_MP3_CalcVols_f);
|
|
Cmd_AddCommand("s_dynamic", S_SetDynamicMusic_f);
|
|
|
|
cv = Cvar_Get("s_UseOpenAL" , "0",CVAR_ARCHIVE|CVAR_LATCH);
|
|
s_UseOpenAL = !!(cv->integer);
|
|
|
|
|
|
if (s_UseOpenAL)
|
|
{
|
|
ALCDevice = alcOpenDevice((ALubyte*)"DirectSound3D");
|
|
if (!ALCDevice)
|
|
return;
|
|
|
|
//Create context(s)
|
|
ALCContext = alcCreateContext(ALCDevice, NULL);
|
|
if (!ALCContext)
|
|
return;
|
|
|
|
//Set active context
|
|
alcMakeContextCurrent(ALCContext);
|
|
if (alcGetError(ALCDevice) != ALC_NO_ERROR)
|
|
return;
|
|
|
|
s_soundStarted = 1;
|
|
s_soundMuted = 1;
|
|
s_soundtime = 0;
|
|
s_paintedtime = 0;
|
|
s_rawend = 0;
|
|
|
|
S_StopAllSounds();
|
|
|
|
S_SoundInfo_f();
|
|
|
|
// Set Listener attributes
|
|
alListenerfv(AL_POSITION,listenerPos);
|
|
alListenerfv(AL_VELOCITY,listenerVel);
|
|
alListenerfv(AL_ORIENTATION,listenerOri);
|
|
|
|
InitEAXManager();
|
|
|
|
memset(s_channels, 0, sizeof(s_channels));
|
|
|
|
s_numChannels = 0;
|
|
|
|
// Create as many AL Sources (up to Max) as possible
|
|
for (i = 0; i < MAX_CHANNELS; i++)
|
|
{
|
|
alGenSources(1, &s_channels[i].alSource); // &g_Sources[i]);
|
|
if (alGetError() != AL_NO_ERROR)
|
|
{
|
|
// Reached limit of sources
|
|
break;
|
|
}
|
|
alSourcef(s_channels[i].alSource, AL_REFERENCE_DISTANCE, 400.0f);
|
|
if (alGetError() != AL_NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
s_numChannels++;
|
|
}
|
|
|
|
// Generate AL Buffers for streaming audio playback (used for MP3s)
|
|
ch = s_channels + 1;
|
|
for (i = 1; i < s_numChannels; i++, ch++)
|
|
{
|
|
for (j = 0; j < NUM_STREAMING_BUFFERS; j++)
|
|
{
|
|
alGenBuffers(1, &(ch->buffers[j].BufferID));
|
|
ch->buffers[j].Status = UNQUEUED;
|
|
ch->buffers[j].Data = (char *)Z_Malloc(STREAMING_BUFFER_SIZE, TAG_SND_RAWDATA, qfalse);
|
|
}
|
|
}
|
|
|
|
// clear out the lip synching override array
|
|
memset(s_entityWavVol, 0, sizeof(s_entityWavVol));
|
|
|
|
/*
|
|
if (s_khz->integer == 44)
|
|
dma.speed = 44100;
|
|
else if (s_khz->integer == 22)
|
|
dma.speed = 22050;
|
|
else
|
|
dma.speed = 11025;
|
|
*/
|
|
// Always at 22KHz for OpenAL
|
|
dma.speed = 22050;
|
|
|
|
// These aren't really relevant for Open AL, but for completeness ...
|
|
dma.channels = 2;
|
|
dma.samplebits = 16;
|
|
dma.samples = 0;
|
|
dma.submission_chunk = 0;
|
|
dma.buffer = NULL;
|
|
|
|
// Clamp sound volumes between 0.0f and 1.0f
|
|
if (s_volume->value < 0.f)
|
|
s_volume->value = 0.f;
|
|
if (s_volume->value > 1.f)
|
|
s_volume->value = 1.f;
|
|
|
|
if (s_volumeVoice->value < 0.f)
|
|
s_volumeVoice->value = 0.f;
|
|
if (s_volumeVoice->value > 1.f)
|
|
s_volumeVoice->value = 1.f;
|
|
|
|
if (s_musicVolume->value < 0.f)
|
|
s_musicVolume->value = 0.f;
|
|
if (s_musicVolume->value > 1.f)
|
|
s_musicVolume->value = 1.f;
|
|
}
|
|
else
|
|
{
|
|
r = SNDDMA_Init();
|
|
|
|
if ( r ) {
|
|
s_soundStarted = 1;
|
|
s_soundMuted = 1;
|
|
// s_numSfx = 0; // do NOT do this here now!!!
|
|
|
|
s_soundtime = 0;
|
|
s_paintedtime = 0;
|
|
|
|
S_StopAllSounds ();
|
|
|
|
S_SoundInfo_f();
|
|
}
|
|
}
|
|
|
|
Com_Printf("------------------------------------\n");
|
|
|
|
Com_Printf("\n--- ambient sound initialization ---\n");
|
|
|
|
AS_Init();
|
|
}
|
|
|
|
// only called from snd_restart. QA request...
|
|
//
|
|
void S_ReloadAllUsedSounds(void)
|
|
{
|
|
if (s_soundStarted && !s_soundMuted )
|
|
{
|
|
// new bit, reload all soundsthat are used on the current level...
|
|
//
|
|
for (int i=1 ; i < s_numSfx ; i++) // start @ 1 to skip freeing default sound
|
|
{
|
|
sfx_t *sfx = &s_knownSfx[i];
|
|
|
|
if (!sfx->bInMemory && !sfx->bDefaultSound && sfx->iLastLevelUsedOn == RE_RegisterMedia_GetLevel()){
|
|
S_memoryLoad(sfx);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// =======================================================================
|
|
// Shutdown sound engine
|
|
// =======================================================================
|
|
|
|
void S_Shutdown( void )
|
|
{
|
|
ALCcontext *ALCContext;
|
|
ALCdevice *ALCDevice;
|
|
channel_t *ch;
|
|
int i, j;
|
|
|
|
if ( !s_soundStarted ) {
|
|
return;
|
|
}
|
|
|
|
S_FreeAllSFXMem();
|
|
S_UnCacheDynamicMusic();
|
|
|
|
if (s_UseOpenAL)
|
|
{
|
|
// Release all the AL Sources (including Music channel (Source 0))
|
|
for (i = 0; i < s_numChannels; i++)
|
|
{
|
|
alDeleteSources(1, &(s_channels[i].alSource));
|
|
}
|
|
|
|
// Release Streaming AL Buffers
|
|
ch = s_channels + 1;
|
|
for (i = 1; i < s_numChannels; i++, ch++)
|
|
{
|
|
for (j = 0; j < NUM_STREAMING_BUFFERS; j++)
|
|
{
|
|
alDeleteBuffers(1, &(ch->buffers[j].BufferID));
|
|
ch->buffers[j].BufferID = 0;
|
|
ch->buffers[j].Status = UNQUEUED;
|
|
if (ch->buffers[j].Data)
|
|
{
|
|
Z_Free(ch->buffers[j].Data);
|
|
ch->buffers[j].Data = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get active context
|
|
ALCContext = alcGetCurrentContext();
|
|
// Get device for active context
|
|
ALCDevice = alcGetContextsDevice(ALCContext);
|
|
// Release context(s)
|
|
alcDestroyContext(ALCContext);
|
|
// Close device
|
|
alcCloseDevice(ALCDevice);
|
|
|
|
ReleaseEAXManager();
|
|
|
|
s_numChannels = 0;
|
|
|
|
}
|
|
else
|
|
{
|
|
SNDDMA_Shutdown();
|
|
}
|
|
|
|
s_soundStarted = 0;
|
|
|
|
Cmd_RemoveCommand("play");
|
|
Cmd_RemoveCommand("music");
|
|
Cmd_RemoveCommand("stopsound");
|
|
Cmd_RemoveCommand("soundlist");
|
|
Cmd_RemoveCommand("soundinfo");
|
|
Cmd_RemoveCommand("mp3_calcvols");
|
|
Cmd_RemoveCommand("s_dynamic");
|
|
AS_Free();
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
Mutes / Unmutes all OpenAL sound
|
|
*/
|
|
void S_AL_MuteAllSounds(qboolean bMute)
|
|
{
|
|
if (!s_soundStarted)
|
|
return;
|
|
|
|
if (!s_UseOpenAL)
|
|
return;
|
|
|
|
if (bMute)
|
|
{
|
|
alListenerf(AL_GAIN, 0.0f);
|
|
}
|
|
else
|
|
{
|
|
alListenerf(AL_GAIN, 1.0f);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// =======================================================================
|
|
// Load a sound
|
|
// =======================================================================
|
|
/*
|
|
================
|
|
return a hash value for the sfx name
|
|
================
|
|
*/
|
|
static long S_HashSFXName(const char *name) {
|
|
int i;
|
|
long hash;
|
|
char letter;
|
|
|
|
hash = 0;
|
|
i = 0;
|
|
while (name[i] != '\0') {
|
|
letter = tolower(name[i]);
|
|
if (letter =='.') break; // don't include extension
|
|
if (letter =='\\') letter = '/'; // damn path names
|
|
hash+=(long)(letter)*(i+119);
|
|
i++;
|
|
}
|
|
hash &= (LOOP_HASH-1);
|
|
return hash;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
S_FindName
|
|
|
|
Will allocate a new sfx if it isn't found
|
|
==================
|
|
*/
|
|
sfx_t *S_FindName( const char *name ) {
|
|
int i;
|
|
int hash;
|
|
|
|
sfx_t *sfx;
|
|
|
|
if (!name) {
|
|
Com_Error (ERR_FATAL, "S_FindName: NULL\n");
|
|
}
|
|
if (!name[0]) {
|
|
Com_Error (ERR_FATAL, "S_FindName: empty name\n");
|
|
}
|
|
|
|
if (strlen(name) >= MAX_QPATH) {
|
|
Com_Error (ERR_FATAL, "Sound name too long: %s", name);
|
|
}
|
|
|
|
char sSoundNameNoExt[MAX_QPATH];
|
|
COM_StripExtension(name,sSoundNameNoExt);
|
|
|
|
hash = S_HashSFXName(sSoundNameNoExt);
|
|
|
|
sfx = sfxHash[hash];
|
|
// see if already loaded
|
|
while (sfx) {
|
|
if (!Q_stricmp(sfx->sSoundName, sSoundNameNoExt) ) {
|
|
return sfx;
|
|
}
|
|
sfx = sfx->next;
|
|
}
|
|
/*
|
|
// find a free sfx
|
|
for (i=0 ; i < s_numSfx ; i++) {
|
|
if (!s_knownSfx[i].soundName[0]) {
|
|
break;
|
|
}
|
|
}
|
|
*/
|
|
i = s_numSfx; //we don't clear the soundName after failed loads any more, so it'll always be the last entry
|
|
|
|
if (s_numSfx == MAX_SFX)
|
|
{
|
|
// ok, no sfx's free, but are there any with defaultSound set? (which the registering ent will never
|
|
// see because he gets zero returned if it's default...)
|
|
//
|
|
for (i=0 ; i < s_numSfx ; i++) {
|
|
if (s_knownSfx[i].bDefaultSound) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i==s_numSfx)
|
|
{
|
|
// genuinely out of handles...
|
|
|
|
// if we ever reach this, let me know and I'll either boost the array or put in a map-used-on
|
|
// reference to enable sfx_t recycling. TA codebase relies on being able to have structs for every sound
|
|
// used anywhere, ever, all at once (though audio bit-buffer gets recycled). SOF1 used about 1900 distinct
|
|
// events, so current MAX_SFX limit should do, or only need a small boost... -ste
|
|
//
|
|
|
|
Com_Error (ERR_FATAL, "S_FindName: out of sfx_t");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
s_numSfx++;
|
|
}
|
|
|
|
sfx = &s_knownSfx[i];
|
|
memset (sfx, 0, sizeof(*sfx));
|
|
Q_strncpyz(sfx->sSoundName, sSoundNameNoExt, sizeof(sfx->sSoundName));
|
|
|
|
sfx->next = sfxHash[hash];
|
|
sfxHash[hash] = sfx;
|
|
|
|
return sfx;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
S_DefaultSound
|
|
=================
|
|
*/
|
|
void S_DefaultSound( sfx_t *sfx ) {
|
|
|
|
int i;
|
|
|
|
sfx->iSoundLengthInSamples = 512; // #samples, ie shorts
|
|
sfx->pSoundData = (short *) SND_malloc(512*2, sfx); // ... so *2 for alloc bytes
|
|
sfx->bInMemory = qtrue;
|
|
|
|
for ( i=0 ; i < sfx->iSoundLengthInSamples ; i++ )
|
|
{
|
|
sfx->pSoundData[i] = i;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
===================
|
|
S_DisableSounds
|
|
|
|
Disables sounds until the next S_BeginRegistration.
|
|
This is called when the hunk is cleared and the sounds
|
|
are no longer valid.
|
|
===================
|
|
*/
|
|
void S_DisableSounds( void ) {
|
|
S_StopAllSounds();
|
|
s_soundMuted = qtrue;
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
S_BeginRegistration
|
|
|
|
=====================
|
|
*/
|
|
void S_BeginRegistration( void )
|
|
{
|
|
char *mapname;
|
|
|
|
s_soundMuted = qfalse; // we can play again
|
|
|
|
// Find name of level so we can load in the appropriate EAL file
|
|
if (s_UseOpenAL)
|
|
{
|
|
mapname = Cvar_VariableString( "mapname" );
|
|
EALFileInit(mapname);
|
|
}
|
|
|
|
if (s_numSfx == 0) {
|
|
SND_setup();
|
|
|
|
s_numSfx = 0;
|
|
memset( s_knownSfx, 0, sizeof( s_knownSfx ) );
|
|
memset(sfxHash, 0, sizeof(sfx_t *)*LOOP_HASH);
|
|
|
|
#ifdef _DEBUG
|
|
sfx_t *sfx = S_FindName( "***DEFAULT***" );
|
|
S_DefaultSound( sfx );
|
|
#else
|
|
S_RegisterSound("sound/null.wav");
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
void EALFileInit(char *level)
|
|
{
|
|
long lRoom;
|
|
char name[MAX_QPATH];
|
|
char szEALFilename[MAX_QPATH];
|
|
|
|
// If an EAL File is already unloaded, remove it
|
|
if (s_bEALFileLoaded)
|
|
{
|
|
UnloadEALFile();
|
|
}
|
|
|
|
// Reset variables
|
|
s_bInWater = false;
|
|
|
|
// Try and load an EAL file for the new level
|
|
COM_StripExtension(level, name);
|
|
Com_sprintf(szEALFilename, MAX_QPATH, "eagle/%s.eal", name);
|
|
|
|
s_bEALFileLoaded = LoadEALFile(szEALFilename);
|
|
|
|
if (s_bEALFileLoaded)
|
|
{
|
|
UpdateEAXListener(true, false);
|
|
}
|
|
else
|
|
{
|
|
if ((s_bEAX)&&(s_eaxSet))
|
|
{
|
|
lRoom = -10000;
|
|
s_eaxSet(&DSPROPSETID_EAX_ListenerProperties, DSPROPERTY_EAXLISTENER_ROOM,
|
|
NULL, &lRoom, sizeof(long));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
==================
|
|
S_RegisterSound
|
|
|
|
Creates a default buzz sound if the file can't be loaded
|
|
==================
|
|
*/
|
|
sfxHandle_t S_RegisterSound( const char *name)
|
|
{
|
|
sfx_t *sfx;
|
|
|
|
if (!s_soundStarted) {
|
|
return 0;
|
|
}
|
|
|
|
if ( strlen( name ) >= MAX_QPATH ) {
|
|
Com_Printf( S_COLOR_RED"Sound name exceeds MAX_QPATH - %s\n", name );
|
|
return 0;
|
|
}
|
|
|
|
sfx = S_FindName( name );
|
|
|
|
SND_TouchSFX(sfx);
|
|
|
|
if ( sfx->bDefaultSound )
|
|
return 0;
|
|
|
|
if (s_UseOpenAL)
|
|
{
|
|
if ((sfx->pSoundData) || (sfx->Buffer))
|
|
return sfx - s_knownSfx;
|
|
}
|
|
else
|
|
{
|
|
if ( sfx->pSoundData )
|
|
{
|
|
return sfx - s_knownSfx;
|
|
}
|
|
}
|
|
|
|
sfx->bInMemory = qfalse;
|
|
|
|
S_memoryLoad(sfx);
|
|
|
|
if ( sfx->bDefaultSound ) {
|
|
#ifndef FINAL_BUILD
|
|
Com_Printf( S_COLOR_YELLOW "WARNING: could not find %s - using default\n", sfx->sSoundName );
|
|
#endif
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
return sfx - s_knownSfx;
|
|
}
|
|
|
|
void S_memoryLoad(sfx_t *sfx)
|
|
{
|
|
// load the sound file...
|
|
//
|
|
if ( !S_LoadSound( sfx ) )
|
|
{
|
|
// Com_Printf( S_COLOR_YELLOW "WARNING: couldn't load sound: %s\n", sfx->sSoundName );
|
|
sfx->bDefaultSound = qtrue;
|
|
}
|
|
sfx->bInMemory = qtrue;
|
|
}
|
|
|
|
|
|
|
|
//=============================================================================
|
|
static qboolean S_CheckChannelStomp( int chan1, int chan2 )
|
|
{
|
|
if ( chan1 == chan2 )
|
|
{
|
|
return qtrue;
|
|
}
|
|
|
|
if ( ( chan1 == CHAN_VOICE || chan1 == CHAN_VOICE_ATTEN || chan1 == CHAN_VOICE_GLOBAL ) && ( chan2 == CHAN_VOICE || chan2 == CHAN_VOICE_ATTEN || chan2 == CHAN_VOICE_GLOBAL ) )
|
|
{
|
|
return qtrue;
|
|
}
|
|
|
|
return qfalse;
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
S_PickChannel
|
|
=================
|
|
*/
|
|
// there were 2 versions of this, one for A3D and one normal, but the normal one wouldn't compile because
|
|
// it hadn't been updated for some time, so rather than risk anything weird/out of date, I just removed the
|
|
// A3D lines from this version and deleted the other one.
|
|
//
|
|
// If this really bothers you then feel free to play with it. -Ste.
|
|
//
|
|
channel_t *S_PickChannel(int entnum, int entchannel)
|
|
{
|
|
int ch_idx;
|
|
channel_t *ch, *firstToDie;
|
|
qboolean foundChan = qfalse;
|
|
|
|
if (s_UseOpenAL)
|
|
return S_OpenALPickChannel(entnum, entchannel);
|
|
|
|
if ( entchannel<0 ) {
|
|
Com_Error (ERR_DROP, "S_PickChannel: entchannel<0");
|
|
}
|
|
|
|
// Check for replacement sound, or find the best one to replace
|
|
|
|
firstToDie = &s_channels[0];
|
|
|
|
for ( int pass = 0; (pass < ((entchannel == CHAN_AUTO || entchannel == CHAN_LESS_ATTEN)?1:2)) && !foundChan; pass++ )
|
|
{
|
|
for (ch_idx = 0, ch = &s_channels[0]; ch_idx < MAX_CHANNELS ; ch_idx++, ch++ )
|
|
{
|
|
if ( entchannel == CHAN_AUTO || entchannel == CHAN_LESS_ATTEN || pass > 0 )
|
|
{//if we're on the second pass, just find the first open chan
|
|
if ( !ch->thesfx )
|
|
{//grab the first open channel
|
|
firstToDie = ch;
|
|
break;
|
|
}
|
|
|
|
}
|
|
else if ( ch->entnum == entnum && S_CheckChannelStomp( ch->entchannel, entchannel ) )
|
|
{
|
|
// always override sound from same entity
|
|
if ( s_show->integer == 1 && ch->thesfx ) {
|
|
Com_Printf( S_COLOR_YELLOW"...overrides %s\n", ch->thesfx->sSoundName );
|
|
ch->thesfx = 0; //just to clear the next error msg
|
|
}
|
|
firstToDie = ch;
|
|
foundChan = qtrue;
|
|
break;
|
|
}
|
|
|
|
// don't let anything else override local player sounds
|
|
if ( ch->entnum == listener_number && entnum != listener_number && ch->thesfx) {
|
|
continue;
|
|
}
|
|
|
|
// don't override loop sounds
|
|
if ( ch->loopSound ) {
|
|
continue;
|
|
}
|
|
|
|
if ( ch->startSample < firstToDie->startSample ) {
|
|
firstToDie = ch;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( s_show->integer == 1 && firstToDie->thesfx ) {
|
|
Com_Printf( S_COLOR_RED"***kicking %s\n", firstToDie->thesfx->sSoundName );
|
|
}
|
|
|
|
Channel_Clear(firstToDie); // memset(firstToDie, 0, sizeof(*firstToDie));
|
|
|
|
return firstToDie;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
For use with Open AL
|
|
|
|
Allows more than one sound of the same type to emanate from the same entity - sounds much better
|
|
on hardware this way esp. rapid fire modes of weapons!
|
|
*/
|
|
channel_t *S_OpenALPickChannel(int entnum, int entchannel)
|
|
{
|
|
int ch_idx;
|
|
channel_t *ch, *ch_firstToDie;
|
|
bool foundChan = false;
|
|
float source_pos[3];
|
|
|
|
if ( entchannel < 0 )
|
|
{
|
|
Com_Error (ERR_DROP, "S_PickChannel: entchannel<0");
|
|
}
|
|
|
|
// Check for replacement sound, or find the best one to replace
|
|
|
|
ch_firstToDie = s_channels + 1; // channel 0 is reserved for Music
|
|
|
|
for (ch_idx = 1, ch = s_channels + ch_idx; ch_idx < s_numChannels; ch_idx++, ch++)
|
|
{
|
|
// See if the channel is free
|
|
if (!ch->thesfx)
|
|
{
|
|
ch_firstToDie = ch;
|
|
foundChan = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!foundChan)
|
|
{
|
|
for (ch_idx = 1, ch = s_channels + ch_idx; ch_idx < s_numChannels; ch_idx++, ch++)
|
|
{
|
|
if ( (ch->entnum == entnum) && (ch->entchannel == entchannel) && (ch->entchannel != CHAN_AMBIENT)
|
|
&& (ch->entnum != listener_number) )
|
|
{
|
|
// Same entity and same type of sound effect (entchannel)
|
|
ch_firstToDie = ch;
|
|
foundChan = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
int longestDist;
|
|
int dist;
|
|
|
|
if (!foundChan)
|
|
{
|
|
// Find sound effect furthest from listener
|
|
ch = s_channels + 1;
|
|
|
|
if (ch->fixed_origin)
|
|
{
|
|
// Convert to Open AL co-ordinates
|
|
source_pos[0] = ch->origin[0];
|
|
source_pos[1] = ch->origin[2];
|
|
source_pos[2] = -ch->origin[1];
|
|
|
|
longestDist = ((listener_pos[0] - source_pos[0]) * (listener_pos[0] - source_pos[0])) +
|
|
((listener_pos[1] - source_pos[1]) * (listener_pos[1] - source_pos[1])) +
|
|
((listener_pos[2] - source_pos[2]) * (listener_pos[2] - source_pos[2]));
|
|
}
|
|
else
|
|
{
|
|
if (ch->entnum == listener_number)
|
|
longestDist = 0;
|
|
else
|
|
{
|
|
if (ch->bLooping)
|
|
{
|
|
// Convert to Open AL co-ordinates
|
|
source_pos[0] = loopSounds[ch->entnum].origin[0];
|
|
source_pos[1] = loopSounds[ch->entnum].origin[2];
|
|
source_pos[2] = -loopSounds[ch->entnum].origin[1];
|
|
}
|
|
else
|
|
{
|
|
// Convert to Open AL co-ordinates
|
|
source_pos[0] = s_entityPosition[ch->entnum][0];
|
|
source_pos[1] = s_entityPosition[ch->entnum][2];
|
|
source_pos[2] = -s_entityPosition[ch->entnum][1];
|
|
}
|
|
|
|
longestDist = ((listener_pos[0] - source_pos[0]) * (listener_pos[0] - source_pos[0])) +
|
|
((listener_pos[1] - source_pos[1]) * (listener_pos[1] - source_pos[1])) +
|
|
((listener_pos[2] - source_pos[2]) * (listener_pos[2] - source_pos[2]));
|
|
}
|
|
}
|
|
|
|
for (ch_idx = 2, ch = s_channels + ch_idx; ch_idx < s_numChannels; ch_idx++, ch++)
|
|
{
|
|
if (ch->fixed_origin)
|
|
{
|
|
// Convert to Open AL co-ordinates
|
|
source_pos[0] = ch->origin[0];
|
|
source_pos[1] = ch->origin[2];
|
|
source_pos[2] = -ch->origin[1];
|
|
|
|
dist = ((listener_pos[0] - source_pos[0]) * (listener_pos[0] - source_pos[0])) +
|
|
((listener_pos[1] - source_pos[1]) * (listener_pos[1] - source_pos[1])) +
|
|
((listener_pos[2] - source_pos[2]) * (listener_pos[2] - source_pos[2]));
|
|
}
|
|
else
|
|
{
|
|
if (ch->entnum == listener_number)
|
|
dist = 0;
|
|
else
|
|
{
|
|
if (ch->bLooping)
|
|
{
|
|
// Convert to Open AL co-ordinates
|
|
source_pos[0] = loopSounds[ch->entnum].origin[0];
|
|
source_pos[1] = loopSounds[ch->entnum].origin[2];
|
|
source_pos[2] = -loopSounds[ch->entnum].origin[1];
|
|
}
|
|
else
|
|
{
|
|
// Convert to Open AL co-ordinates
|
|
source_pos[0] = s_entityPosition[ch->entnum][0];
|
|
source_pos[1] = s_entityPosition[ch->entnum][2];
|
|
source_pos[2] = -s_entityPosition[ch->entnum][1];
|
|
}
|
|
|
|
dist = ((listener_pos[0] - source_pos[0]) * (listener_pos[0] - source_pos[0])) +
|
|
((listener_pos[1] - source_pos[1]) * (listener_pos[1] - source_pos[1])) +
|
|
((listener_pos[2] - source_pos[2]) * (listener_pos[2] - source_pos[2]));
|
|
}
|
|
}
|
|
|
|
if (dist > longestDist)
|
|
{
|
|
longestDist = dist;
|
|
ch_firstToDie = ch;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ch_firstToDie->bPlaying)
|
|
{
|
|
if (s_show->integer == 1)
|
|
{
|
|
Com_Printf(S_COLOR_RED"***kicking %s\n", ch_firstToDie->thesfx->sSoundName );
|
|
}
|
|
// Stop sound
|
|
alSourceStop(ch_firstToDie->alSource);
|
|
ch_firstToDie->bPlaying = false;
|
|
}
|
|
|
|
// Reset channel variables
|
|
memset(&ch_firstToDie->MP3StreamHeader, 0, sizeof(MP3STREAM));
|
|
ch_firstToDie->bLooping = false;
|
|
ch_firstToDie->bProcessed = false;
|
|
ch_firstToDie->bStreaming = false;
|
|
|
|
return ch_firstToDie;
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
S_SpatializeOrigin
|
|
|
|
Used for spatializing s_channels
|
|
=================
|
|
*/
|
|
void S_SpatializeOrigin (const vec3_t origin, float master_vol, int *left_vol, int *right_vol, int channel)
|
|
{
|
|
vec_t dot;
|
|
vec_t dist;
|
|
vec_t lscale, rscale, scale;
|
|
vec3_t source_vec;
|
|
float dist_mult = SOUND_ATTENUATE;
|
|
|
|
// calculate stereo seperation and distance attenuation
|
|
VectorSubtract(origin, listener_origin, source_vec);
|
|
|
|
dist = VectorNormalize(source_vec);
|
|
if ( channel == CHAN_VOICE )
|
|
{
|
|
dist -= SOUND_FULLVOLUME * 3.0f;
|
|
// dist_mult = VOICE_ATTENUATE; // tweak added (this fixes an NPC dialogue "in your ears" bug, but we're not sure if it'll make a bunch of others fade too early. Too close to shipping...)
|
|
}
|
|
else if ( channel == CHAN_LESS_ATTEN )
|
|
{
|
|
dist -= SOUND_FULLVOLUME * 8.0f; // maybe is too large
|
|
}
|
|
else if ( channel == CHAN_VOICE_ATTEN )
|
|
{
|
|
dist -= SOUND_FULLVOLUME * 1.35f; // used to be 0.15f, dropped off too sharply - dmv
|
|
dist_mult = VOICE_ATTENUATE;
|
|
}
|
|
else if ( channel == CHAN_VOICE_GLOBAL )
|
|
{
|
|
dist = -1;
|
|
}
|
|
else // use normal attenuation.
|
|
{
|
|
dist -= SOUND_FULLVOLUME;
|
|
}
|
|
|
|
if (dist < 0)
|
|
{
|
|
dist = 0; // close enough to be at full volume
|
|
}
|
|
dist *= dist_mult; // different attenuation levels
|
|
|
|
dot = -DotProduct(listener_axis[1], source_vec);
|
|
|
|
if (dma.channels == 1) // || !dist_mult)
|
|
{ // no attenuation = no spatialization
|
|
rscale = SOUND_FMAXVOL;
|
|
lscale = SOUND_FMAXVOL;
|
|
}
|
|
else
|
|
{
|
|
//rscale = 0.5 * (1.0 + dot);
|
|
//lscale = 0.5 * (1.0 - dot);
|
|
rscale = s_separation->value + ( 1.0f - s_separation->value ) * dot;
|
|
lscale = s_separation->value - ( 1.0f - s_separation->value ) * dot;
|
|
if ( rscale < 0 )
|
|
{
|
|
rscale = 0;
|
|
}
|
|
if ( lscale < 0 )
|
|
{
|
|
lscale = 0;
|
|
}
|
|
}
|
|
|
|
// add in distance effect
|
|
scale = (1.0f - dist) * rscale;
|
|
*right_vol = (int) (master_vol * scale);
|
|
if (*right_vol < 0)
|
|
{
|
|
*right_vol = 0;
|
|
}
|
|
|
|
scale = (1.0f - dist) * lscale;
|
|
*left_vol = (int) (master_vol * scale);
|
|
if (*left_vol < 0)
|
|
{
|
|
*left_vol = 0;
|
|
}
|
|
}
|
|
|
|
|
|
// =======================================================================
|
|
// Start a sound effect
|
|
// =======================================================================
|
|
|
|
/*
|
|
====================
|
|
S_StartAmbientSound
|
|
|
|
Starts an ambient, 'one-shot" sound.
|
|
====================
|
|
*/
|
|
|
|
void S_StartAmbientSound( const vec3_t origin, int entityNum, unsigned char volume, sfxHandle_t sfxHandle )
|
|
{
|
|
channel_t *ch;
|
|
/*const*/ sfx_t *sfx;
|
|
|
|
if ( !s_soundStarted || s_soundMuted ) {
|
|
return;
|
|
}
|
|
if ( !origin && ( entityNum < 0 || entityNum > MAX_GENTITIES ) )
|
|
Com_Error( ERR_DROP, "S_StartAmbientSound: bad entitynum %i", entityNum );
|
|
|
|
if ( sfxHandle < 0 || sfxHandle >= s_numSfx )
|
|
Com_Error( ERR_DROP, "S_StartAmbientSound: handle %i out of range", sfxHandle );
|
|
|
|
sfx = &s_knownSfx[ sfxHandle ];
|
|
if (sfx->bInMemory == qfalse){
|
|
S_memoryLoad(sfx);
|
|
}
|
|
SND_TouchSFX(sfx);
|
|
|
|
if ( s_show->integer == 1 ) {
|
|
Com_Printf( "%i : %s on (%d) Ambient\n", s_paintedtime, sfx->sSoundName, entityNum );
|
|
}
|
|
|
|
// pick a channel to play on
|
|
ch = S_PickChannel( entityNum, CHAN_AMBIENT );
|
|
if (!ch) {
|
|
return;
|
|
}
|
|
|
|
if (origin)
|
|
{
|
|
VectorCopy (origin, ch->origin);
|
|
ch->fixed_origin = qtrue;
|
|
}
|
|
else
|
|
{
|
|
ch->fixed_origin = qfalse;
|
|
}
|
|
|
|
ch->master_vol = volume;
|
|
ch->entnum = entityNum;
|
|
ch->entchannel = CHAN_AMBIENT;
|
|
ch->thesfx = sfx;
|
|
ch->startSample = START_SAMPLE_IMMEDIATE;
|
|
|
|
ch->leftvol = ch->master_vol; // these will get calced at next spatialize
|
|
ch->rightvol = ch->master_vol; // unless the game isn't running
|
|
|
|
if (sfx->pMP3StreamHeader)
|
|
{
|
|
memcpy(&ch->MP3StreamHeader,sfx->pMP3StreamHeader, sizeof(ch->MP3StreamHeader));
|
|
//ch->iMP3SlidingDecodeWritePos = 0; // These will be zero from the memset in S_PickChannel(), but keep them here for reference...
|
|
//ch->iMP3SlidingDecodeWindowPos= 0; //
|
|
}
|
|
else
|
|
{
|
|
memset(&ch->MP3StreamHeader,0, sizeof(ch->MP3StreamHeader));
|
|
}
|
|
}
|
|
|
|
/*
|
|
====================
|
|
S_StartSound
|
|
|
|
Validates the parms and ques the sound up
|
|
if pos is NULL, the sound will be dynamically sourced from the entity
|
|
Entchannel 0 will never override a playing sound
|
|
====================
|
|
*/
|
|
void S_StartSound(const vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfxHandle )
|
|
{
|
|
int i;
|
|
channel_t *ch;
|
|
/*const*/ sfx_t *sfx;
|
|
|
|
if ( !s_soundStarted || s_soundMuted ) {
|
|
return;
|
|
}
|
|
|
|
if ( !origin && ( entityNum < 0 || entityNum > MAX_GENTITIES ) ) {
|
|
Com_Error( ERR_DROP, "S_StartSound: bad entitynum %i", entityNum );
|
|
}
|
|
|
|
if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
|
|
Com_Error( ERR_DROP, "S_StartSound: handle %i out of range", sfxHandle );
|
|
}
|
|
|
|
sfx = &s_knownSfx[ sfxHandle ];
|
|
if (sfx->bInMemory == qfalse){
|
|
S_memoryLoad(sfx);
|
|
}
|
|
SND_TouchSFX(sfx);
|
|
|
|
if ( s_show->integer == 1 ) {
|
|
Com_Printf( "%i : %s on (%d)\n", s_paintedtime, sfx->sSoundName, entityNum );
|
|
}
|
|
|
|
if (s_UseOpenAL)
|
|
{
|
|
if (entchannel == CHAN_WEAPON)
|
|
{
|
|
// Check if we are playing a 'charging' sound, if so, stop it now ..
|
|
ch = s_channels + 1;
|
|
for (i = 1; i < s_numChannels; i++, ch++)
|
|
{
|
|
if ((ch->entnum == entityNum) && (ch->entchannel == CHAN_WEAPON) && (ch->thesfx) && (strstr(strlwr(ch->thesfx->sSoundName), "altcharge") != NULL))
|
|
{
|
|
// Stop this sound
|
|
alSourceStop(ch->alSource);
|
|
alSourcei(ch->alSource, AL_BUFFER, NULL);
|
|
ch->bPlaying = false;
|
|
ch->thesfx = NULL;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ch = s_channels + 1;
|
|
for (i = 1; i < s_numChannels; i++, ch++)
|
|
{
|
|
if ((ch->entnum == entityNum) && (ch->thesfx) && (strstr(strlwr(ch->thesfx->sSoundName), "falling") != NULL))
|
|
{
|
|
// Stop this sound
|
|
alSourceStop(ch->alSource);
|
|
alSourcei(ch->alSource, AL_BUFFER, NULL);
|
|
ch->bPlaying = false;
|
|
ch->thesfx = NULL;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// pick a channel to play on
|
|
|
|
ch = S_PickChannel( entityNum, entchannel );
|
|
if (!ch) {
|
|
return;
|
|
}
|
|
|
|
if (origin) {
|
|
VectorCopy (origin, ch->origin);
|
|
ch->fixed_origin = qtrue;
|
|
} else {
|
|
ch->fixed_origin = qfalse;
|
|
}
|
|
|
|
ch->master_vol = SOUND_MAXVOL; //FIXME: Um.. control?
|
|
ch->entnum = entityNum;
|
|
ch->entchannel = entchannel;
|
|
ch->thesfx = sfx;
|
|
ch->startSample = START_SAMPLE_IMMEDIATE;
|
|
|
|
ch->leftvol = ch->master_vol; // these will get calced at next spatialize
|
|
ch->rightvol = ch->master_vol; // unless the game isn't running
|
|
|
|
if (entchannel < CHAN_AMBIENT && entityNum == listener_number) { //only do it for body sounds not local sounds
|
|
ch->master_vol = SOUND_MAXVOL * SOUND_FMAXVOL; //this won't be attenuated so let it scale down
|
|
}
|
|
if ( entchannel == CHAN_VOICE || entchannel == CHAN_VOICE_ATTEN || entchannel == CHAN_VOICE_GLOBAL )
|
|
{
|
|
s_entityWavVol[ ch->entnum ] = -1; //we've started the sound but it's silent for now
|
|
}
|
|
|
|
if (sfx->pMP3StreamHeader)
|
|
{
|
|
memcpy(&ch->MP3StreamHeader,sfx->pMP3StreamHeader, sizeof(ch->MP3StreamHeader));
|
|
//ch->iMP3SlidingDecodeWritePos = 0; // These will be zero from the memset in S_PickChannel(), but keep them here for reference...
|
|
//ch->iMP3SlidingDecodeWindowPos= 0; //
|
|
}
|
|
else
|
|
{
|
|
memset(&ch->MP3StreamHeader,0, sizeof(ch->MP3StreamHeader));
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
S_StartLocalSound
|
|
==================
|
|
*/
|
|
void S_StartLocalSound( sfxHandle_t sfxHandle, int channelNum ) {
|
|
if ( !s_soundStarted || s_soundMuted ) {
|
|
return;
|
|
}
|
|
|
|
if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
|
|
Com_Error( ERR_DROP, "S_StartLocalSound: handle %i out of range", sfxHandle );
|
|
}
|
|
|
|
S_StartSound (NULL, listener_number, channelNum, sfxHandle );
|
|
}
|
|
|
|
|
|
/*
|
|
==================
|
|
S_StartLocalLoopingSound
|
|
==================
|
|
*/
|
|
void S_StartLocalLoopingSound( sfxHandle_t sfxHandle) {
|
|
vec3_t nullVec = {0,0,0};
|
|
|
|
if ( !s_soundStarted || s_soundMuted ) {
|
|
return;
|
|
}
|
|
|
|
if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
|
|
Com_Error( ERR_DROP, "S_StartLocalLoopingSound: handle %i out of range", sfxHandle );
|
|
}
|
|
|
|
S_AddLoopingSound( listener_number, nullVec, nullVec, sfxHandle );
|
|
|
|
}
|
|
|
|
// returns length in milliseconds of supplied sound effect... (else 0 for bad handle now)
|
|
//
|
|
float S_GetSampleLengthInMilliSeconds( sfxHandle_t sfxHandle)
|
|
{
|
|
sfx_t *sfx;
|
|
|
|
if (!s_soundStarted)
|
|
{ //we have no sound, so let's just make a reasonable guess
|
|
return 512 * 1000;
|
|
}
|
|
|
|
if ( sfxHandle < 0 || sfxHandle >= s_numSfx )
|
|
return 0.0f;
|
|
|
|
sfx = &s_knownSfx[ sfxHandle ];
|
|
|
|
float f = (float)sfx->iSoundLengthInSamples / (float)dma.speed;
|
|
|
|
return (f * 1000);
|
|
}
|
|
|
|
|
|
/*
|
|
==================
|
|
S_ClearSoundBuffer
|
|
|
|
If we are about to perform file access, clear the buffer
|
|
so sound doesn't stutter.
|
|
==================
|
|
*/
|
|
void S_ClearSoundBuffer( void ) {
|
|
int clear;
|
|
|
|
if ( !s_soundStarted || s_soundMuted ) {
|
|
return;
|
|
}
|
|
#if 0 //this causes scripts to freak when the sounds get cut...
|
|
// clear all the sounds so they don't
|
|
// start back up after the load finishes
|
|
memset( s_channels, 0, sizeof( s_channels ) );
|
|
// clear out the lip synching override array
|
|
memset(s_entityWavVol, 0,sizeof(s_entityWavVol));
|
|
#endif
|
|
s_rawend = 0;
|
|
|
|
if (!s_UseOpenAL)
|
|
{
|
|
if (dma.samplebits == 8)
|
|
clear = 0x80;
|
|
else
|
|
clear = 0;
|
|
|
|
SNDDMA_BeginPainting ();
|
|
if (dma.buffer)
|
|
memset(dma.buffer, clear, dma.samples * dma.samplebits/8);
|
|
SNDDMA_Submit ();
|
|
}
|
|
else
|
|
{
|
|
s_paintedtime = 0;
|
|
s_soundtime = 0;
|
|
}
|
|
}
|
|
|
|
|
|
// kinda kludgy way to stop a special-use sfx_t playing...
|
|
//
|
|
void S_CIN_StopSound(sfxHandle_t sfxHandle)
|
|
{
|
|
if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
|
|
Com_Error( ERR_DROP, "S_CIN_StopSound: handle %i out of range", sfxHandle );
|
|
}
|
|
|
|
sfx_t *sfx = &s_knownSfx[ sfxHandle ];
|
|
channel_t *ch = s_channels;
|
|
int i;
|
|
|
|
for ( i = 0; i < MAX_CHANNELS ; i++, ch++ )
|
|
{
|
|
if ( !ch->thesfx || (ch->leftvol<0.25 && ch->rightvol<0.25 )) {
|
|
continue;
|
|
}
|
|
if (ch->thesfx == sfx)
|
|
{
|
|
if (s_UseOpenAL)
|
|
{
|
|
alSourceStop(s_channels[i].alSource);
|
|
}
|
|
SND_FreeSFXMem(ch->thesfx); // heh, may as well...
|
|
ch->thesfx = NULL;
|
|
memset(&ch->MP3StreamHeader, 0, sizeof(MP3STREAM));
|
|
ch->bLooping = false;
|
|
ch->bProcessed = false;
|
|
ch->bPlaying = false;
|
|
ch->bStreaming = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
==================
|
|
S_StopAllSounds
|
|
==================
|
|
*/
|
|
void S_StopSounds(void)
|
|
{
|
|
int i; //, j;
|
|
channel_t *ch;
|
|
|
|
if ( !s_soundStarted ) {
|
|
return;
|
|
}
|
|
|
|
// stop looping sounds
|
|
S_ClearLoopingSounds();
|
|
|
|
// clear all the s_channels
|
|
if (s_UseOpenAL)
|
|
{
|
|
ch = s_channels;
|
|
for (i = 0; i < s_numChannels; i++, ch++)
|
|
{
|
|
alSourceStop(s_channels[i].alSource);
|
|
alSourcei(s_channels[i].alSource, AL_BUFFER, NULL);
|
|
ch->thesfx = NULL;
|
|
memset(&ch->MP3StreamHeader, 0, sizeof(MP3STREAM));
|
|
ch->bLooping = false;
|
|
ch->bProcessed = false;
|
|
ch->bPlaying = false;
|
|
ch->bStreaming = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
memset(s_channels, 0, sizeof(s_channels));
|
|
}
|
|
|
|
// clear out the lip synching override array
|
|
memset(s_entityWavVol, 0,sizeof(s_entityWavVol));
|
|
|
|
S_ClearSoundBuffer ();
|
|
}
|
|
|
|
/*
|
|
==================
|
|
S_StopAllSounds
|
|
and music
|
|
==================
|
|
*/
|
|
void S_StopAllSounds(void) {
|
|
if ( !s_soundStarted ) {
|
|
return;
|
|
}
|
|
// stop the background music
|
|
S_StopBackgroundTrack();
|
|
|
|
S_StopSounds();
|
|
}
|
|
|
|
/*
|
|
==============================================================
|
|
|
|
continuous looping sounds are added each frame
|
|
|
|
==============================================================
|
|
*/
|
|
|
|
/*
|
|
==================
|
|
S_ClearLoopingSounds
|
|
|
|
==================
|
|
*/
|
|
void S_ClearLoopingSounds( void )
|
|
{
|
|
int i;
|
|
|
|
if (s_UseOpenAL)
|
|
{
|
|
for (i = 0; i < MAX_LOOP_SOUNDS; i++)
|
|
loopSounds[i].bProcessed = false;
|
|
}
|
|
numLoopSounds = 0;
|
|
|
|
}
|
|
|
|
/*
|
|
==================
|
|
S_AddLoopingSound
|
|
|
|
Called during entity generation for a frame
|
|
Include velocity in case I get around to doing doppler...
|
|
==================
|
|
*/
|
|
void S_AddLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfxHandle ) {
|
|
/*const*/ sfx_t *sfx;
|
|
|
|
if ( !s_soundStarted || s_soundMuted ) {
|
|
return;
|
|
}
|
|
if ( numLoopSounds >= MAX_LOOP_SOUNDS ) {
|
|
return;
|
|
}
|
|
|
|
if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
|
|
Com_Error( ERR_DROP, "S_AddLoopingSound: handle %i out of range", sfxHandle );
|
|
}
|
|
|
|
sfx = &s_knownSfx[ sfxHandle ];
|
|
if (sfx->bInMemory == qfalse){
|
|
S_memoryLoad(sfx);
|
|
}
|
|
SND_TouchSFX(sfx);
|
|
|
|
if ( !sfx->iSoundLengthInSamples ) {
|
|
Com_Error( ERR_DROP, "%s has length 0", sfx->sSoundName );
|
|
}
|
|
assert(!sfx->pMP3StreamHeader);
|
|
VectorCopy( origin, loopSounds[numLoopSounds].origin );
|
|
VectorCopy( velocity, loopSounds[numLoopSounds].velocity );
|
|
loopSounds[numLoopSounds].sfx = sfx;
|
|
loopSounds[numLoopSounds].volume = SOUND_MAXVOL;
|
|
loopSounds[numLoopSounds].entnum = entityNum;
|
|
numLoopSounds++;
|
|
}
|
|
|
|
|
|
/*
|
|
==================
|
|
S_AddAmbientLoopingSound
|
|
==================
|
|
*/
|
|
void S_AddAmbientLoopingSound( const vec3_t origin, unsigned char volume, sfxHandle_t sfxHandle )
|
|
{
|
|
/*const*/ sfx_t *sfx;
|
|
|
|
if ( !s_soundStarted || s_soundMuted ) {
|
|
return;
|
|
}
|
|
if ( numLoopSounds >= MAX_LOOP_SOUNDS ) {
|
|
return;
|
|
}
|
|
|
|
if (s_UseOpenAL)
|
|
{
|
|
if (volume == 0)
|
|
return;
|
|
}
|
|
|
|
if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
|
|
Com_Error( ERR_DROP, "S_StartSound: handle %i out of range", sfxHandle );
|
|
}
|
|
|
|
sfx = &s_knownSfx[ sfxHandle ];
|
|
if (sfx->bInMemory == qfalse){
|
|
S_memoryLoad(sfx);
|
|
}
|
|
SND_TouchSFX(sfx);
|
|
|
|
if ( !sfx->iSoundLengthInSamples ) {
|
|
Com_Error( ERR_DROP, "%s has length 0", sfx->sSoundName );
|
|
}
|
|
VectorCopy( origin, loopSounds[numLoopSounds].origin );
|
|
loopSounds[numLoopSounds].sfx = sfx;
|
|
assert(!sfx->pMP3StreamHeader);
|
|
|
|
//TODO: Calculate the distance falloff
|
|
loopSounds[numLoopSounds].volume = volume;
|
|
numLoopSounds++;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
==================
|
|
S_AddLoopSounds
|
|
|
|
Spatialize all of the looping sounds.
|
|
All sounds are on the same cycle, so any duplicates can just
|
|
sum up the channel multipliers.
|
|
==================
|
|
*/
|
|
void S_AddLoopSounds (void)
|
|
{
|
|
int i, j;
|
|
int left, right, left_total, right_total;
|
|
channel_t *ch;
|
|
loopSound_t *loop, *loop2;
|
|
static int loopFrame;
|
|
|
|
loopFrame++;
|
|
for ( i = 0 ; i < numLoopSounds ; i++) {
|
|
loop = &loopSounds[i];
|
|
if ( loop->mergeFrame == loopFrame ) {
|
|
continue; // already merged into an earlier sound
|
|
}
|
|
|
|
// find the total contribution of all sounds of this type
|
|
left_total = right_total = 0;
|
|
|
|
for ( j = i ; j < numLoopSounds ; j++) {
|
|
loop2 = &loopSounds[j];
|
|
if ( loop2->sfx != loop->sfx ) {
|
|
continue;
|
|
}
|
|
loop2->mergeFrame = loopFrame; // don't check this again later
|
|
|
|
S_SpatializeOrigin( loop2->origin, loop2->volume, &left, &right, CHAN_AUTO); //FIXME: Allow for volume change!!
|
|
|
|
left_total += left;
|
|
right_total += right;
|
|
}
|
|
|
|
if (left_total == 0 && right_total == 0)
|
|
continue; // not audible
|
|
|
|
// allocate a channel
|
|
ch = S_PickChannel(0, 0);
|
|
if (!ch)
|
|
return;
|
|
|
|
if (left_total > SOUND_MAXVOL)
|
|
left_total = SOUND_MAXVOL;
|
|
if (right_total > SOUND_MAXVOL)
|
|
right_total = SOUND_MAXVOL;
|
|
ch->leftvol = left_total;
|
|
ch->rightvol = right_total;
|
|
ch->loopSound = qtrue; // remove next frame
|
|
ch->thesfx = loop->sfx;
|
|
|
|
// you cannot use MP3 files here because they offer only streaming access, not random
|
|
//
|
|
if (loop->sfx->pMP3StreamHeader)
|
|
{
|
|
Com_Error( ERR_DROP, "S_AddLoopSounds(): Cannot use streamed MP3 files here for random access (%s)\n",loop->sfx->sSoundName );
|
|
}
|
|
else
|
|
{
|
|
memset(&ch->MP3StreamHeader,0, sizeof(ch->MP3StreamHeader));
|
|
}
|
|
}
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
/*
|
|
=================
|
|
S_ByteSwapRawSamples
|
|
|
|
If raw data has been loaded in little endien binary form, this must be done.
|
|
If raw data was calculated, as with ADPCM, this should not be called.
|
|
=================
|
|
*/
|
|
void S_ByteSwapRawSamples( int samples, int width, int s_channels, const byte *data ) {
|
|
int i;
|
|
|
|
if ( width != 2 ) {
|
|
return;
|
|
}
|
|
if ( LittleShort( 256 ) == 256 ) {
|
|
return;
|
|
}
|
|
|
|
if ( s_channels == 2 ) {
|
|
samples <<= 1;
|
|
}
|
|
for ( i = 0 ; i < samples ; i++ ) {
|
|
((short *)data)[i] = LittleShort( ((short *)data)[i] );
|
|
}
|
|
}
|
|
|
|
|
|
portable_samplepair_t *S_GetRawSamplePointer() {
|
|
return s_rawsamples;
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
S_RawSamples
|
|
|
|
Music streaming
|
|
============
|
|
*/
|
|
void S_RawSamples( int samples, int rate, int width, int s_channels, const byte *data, float volume, qboolean bFirstOrOnlyUpdateThisFrame )
|
|
{
|
|
int i;
|
|
int src, dst;
|
|
float scale;
|
|
int intVolume;
|
|
|
|
if ( !s_soundStarted || s_soundMuted ) {
|
|
return;
|
|
}
|
|
|
|
intVolume = 256 * volume;
|
|
|
|
if ( s_rawend < s_soundtime ) {
|
|
Com_DPrintf( "S_RawSamples: resetting minimum: %i < %i\n", s_rawend, s_soundtime );
|
|
s_rawend = s_soundtime;
|
|
}
|
|
|
|
scale = (float)rate / dma.speed;
|
|
|
|
//Com_Printf ("%i < %i < %i\n", s_soundtime, s_paintedtime, s_rawend);
|
|
if (s_channels == 2 && width == 2)
|
|
{
|
|
if (scale == 1.0)
|
|
{ // optimized case
|
|
if (bFirstOrOnlyUpdateThisFrame)
|
|
{
|
|
for (i=0 ; i<samples ; i++)
|
|
{
|
|
dst = s_rawend&(MAX_RAW_SAMPLES-1);
|
|
s_rawend++;
|
|
s_rawsamples[dst].left = ((short *)data)[i*2] * intVolume;
|
|
s_rawsamples[dst].right = ((short *)data)[i*2+1] * intVolume;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i=0 ; i<samples ; i++)
|
|
{
|
|
dst = s_rawend&(MAX_RAW_SAMPLES-1);
|
|
s_rawend++;
|
|
s_rawsamples[dst].left += ((short *)data)[i*2] * intVolume;
|
|
s_rawsamples[dst].right += ((short *)data)[i*2+1] * intVolume;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bFirstOrOnlyUpdateThisFrame)
|
|
{
|
|
for (i=0 ; ; i++)
|
|
{
|
|
src = i*scale;
|
|
if (src >= samples)
|
|
break;
|
|
dst = s_rawend&(MAX_RAW_SAMPLES-1);
|
|
s_rawend++;
|
|
s_rawsamples[dst].left = ((short *)data)[src*2] * intVolume;
|
|
s_rawsamples[dst].right = ((short *)data)[src*2+1] * intVolume;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i=0 ; ; i++)
|
|
{
|
|
src = i*scale;
|
|
if (src >= samples)
|
|
break;
|
|
dst = s_rawend&(MAX_RAW_SAMPLES-1);
|
|
s_rawend++;
|
|
s_rawsamples[dst].left += ((short *)data)[src*2] * intVolume;
|
|
s_rawsamples[dst].right += ((short *)data)[src*2+1] * intVolume;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (s_channels == 1 && width == 2)
|
|
{
|
|
if (bFirstOrOnlyUpdateThisFrame)
|
|
{
|
|
for (i=0 ; ; i++)
|
|
{
|
|
src = i*scale;
|
|
if (src >= samples)
|
|
break;
|
|
dst = s_rawend&(MAX_RAW_SAMPLES-1);
|
|
s_rawend++;
|
|
s_rawsamples[dst].left = ((short *)data)[src] * intVolume;
|
|
s_rawsamples[dst].right = ((short *)data)[src] * intVolume;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i=0 ; ; i++)
|
|
{
|
|
src = i*scale;
|
|
if (src >= samples)
|
|
break;
|
|
dst = s_rawend&(MAX_RAW_SAMPLES-1);
|
|
s_rawend++;
|
|
s_rawsamples[dst].left += ((short *)data)[src] * intVolume;
|
|
s_rawsamples[dst].right += ((short *)data)[src] * intVolume;
|
|
}
|
|
}
|
|
}
|
|
else if (s_channels == 2 && width == 1)
|
|
{
|
|
intVolume *= 256;
|
|
|
|
if (bFirstOrOnlyUpdateThisFrame)
|
|
{
|
|
for (i=0 ; ; i++)
|
|
{
|
|
src = i*scale;
|
|
if (src >= samples)
|
|
break;
|
|
dst = s_rawend&(MAX_RAW_SAMPLES-1);
|
|
s_rawend++;
|
|
s_rawsamples[dst].left = ((char *)data)[src*2] * intVolume;
|
|
s_rawsamples[dst].right = ((char *)data)[src*2+1] * intVolume;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i=0 ; ; i++)
|
|
{
|
|
src = i*scale;
|
|
if (src >= samples)
|
|
break;
|
|
dst = s_rawend&(MAX_RAW_SAMPLES-1);
|
|
s_rawend++;
|
|
s_rawsamples[dst].left += ((char *)data)[src*2] * intVolume;
|
|
s_rawsamples[dst].right += ((char *)data)[src*2+1] * intVolume;
|
|
}
|
|
}
|
|
}
|
|
else if (s_channels == 1 && width == 1)
|
|
{
|
|
intVolume *= 256;
|
|
|
|
if (bFirstOrOnlyUpdateThisFrame)
|
|
{
|
|
for (i=0 ; ; i++)
|
|
{
|
|
src = i*scale;
|
|
if (src >= samples)
|
|
break;
|
|
dst = s_rawend&(MAX_RAW_SAMPLES-1);
|
|
s_rawend++;
|
|
s_rawsamples[dst].left = (((byte *)data)[src]-128) * intVolume;
|
|
s_rawsamples[dst].right = (((byte *)data)[src]-128) * intVolume;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i=0 ; ; i++)
|
|
{
|
|
src = i*scale;
|
|
if (src >= samples)
|
|
break;
|
|
dst = s_rawend&(MAX_RAW_SAMPLES-1);
|
|
s_rawend++;
|
|
s_rawsamples[dst].left += (((byte *)data)[src]-128) * intVolume;
|
|
s_rawsamples[dst].right += (((byte *)data)[src]-128) * intVolume;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( s_rawend > s_soundtime + MAX_RAW_SAMPLES ) {
|
|
Com_DPrintf( "S_RawSamples: overflowed %i > %i\n", s_rawend, s_soundtime );
|
|
}
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
/*
|
|
=====================
|
|
S_UpdateEntityPosition
|
|
|
|
let the sound system know where an entity currently is
|
|
======================
|
|
*/
|
|
void S_UpdateEntityPosition( int entityNum, const vec3_t origin )
|
|
{
|
|
ALfloat pos[3];
|
|
channel_t *ch;
|
|
int i;
|
|
|
|
if ( entityNum < 0 || entityNum > MAX_GENTITIES ) {
|
|
Com_Error( ERR_DROP, "S_UpdateEntityPosition: bad entitynum %i", entityNum );
|
|
}
|
|
|
|
if (s_UseOpenAL)
|
|
{
|
|
if (entityNum == 0)
|
|
return;
|
|
|
|
ch = s_channels;
|
|
for (i = 0; i < s_numChannels; i++, ch++)
|
|
{
|
|
if ((s_channels[i].bPlaying) & (s_channels[i].entnum == entityNum) & (!s_channels[i].bLooping))
|
|
{
|
|
pos[0] = origin[0];
|
|
pos[1] = origin[2];
|
|
pos[2] = -origin[1];
|
|
alSourcefv(s_channels[i].alSource, AL_POSITION, pos);
|
|
|
|
if ((s_bEALFileLoaded) && !( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL ) )
|
|
{
|
|
UpdateEAXBuffer(ch);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
VectorCopy( origin, s_entityPosition[entityNum] );
|
|
}
|
|
|
|
|
|
// Given a current wav we are playing, and our position within it, lets figure out its volume...
|
|
//
|
|
// (this is mostly Jake's code from EF1, which explains a lot...:-)
|
|
//
|
|
static int next_amplitude = 0;
|
|
static int S_CheckAmplitude(channel_t *ch, const unsigned int s_oldpaintedtime )
|
|
{
|
|
// now, is this a cycle - or have we just started a new sample - where we should update the backup table, and write this value
|
|
// into the new table? or should we just take the value FROM the back up table and feed it out.
|
|
assert( ch->startSample != START_SAMPLE_IMMEDIATE );
|
|
if ( ch->startSample == s_oldpaintedtime || (next_amplitude < s_soundtime) )//(ch->startSample == START_SAMPLE_IMMEDIATE)//!s_entityWavVol_back[ch->entnum]
|
|
{
|
|
int sample;
|
|
int sample_total = 0;
|
|
int count = 0;
|
|
short *current_pos_s;
|
|
// char *current_pos_c;
|
|
int offset = 0;
|
|
|
|
// if we haven't started the sample yet, we must be at the beginning
|
|
current_pos_s = ((short*)ch->thesfx->pSoundData);
|
|
// current_pos_c = ((char*)ch->thesfx->data);
|
|
|
|
//if (ch->startSample != START_SAMPLE_IMMEDIATE)
|
|
//{
|
|
// figure out where we are in the sample right now.
|
|
offset = s_oldpaintedtime - ch->startSample;//s_paintedtime
|
|
current_pos_s += offset;
|
|
// current_pos_c += offset;
|
|
//}
|
|
|
|
// scan through 10 samples 100( at 11hz or 200 at 22hz) samples apart.
|
|
//
|
|
for (int i=0; i<10; i++)
|
|
{
|
|
//
|
|
// have we run off the end?
|
|
if ((offset + (i*100)) > ch->thesfx->iSoundLengthInSamples)
|
|
{
|
|
break;
|
|
}
|
|
// if (ch->thesfx->width == 1)
|
|
// {
|
|
// sample = current_pos_c[i*100];
|
|
// }
|
|
// else
|
|
{
|
|
switch (ch->thesfx->eSoundCompressionMethod)
|
|
{
|
|
case ct_16:
|
|
{
|
|
sample = LittleShort(current_pos_s[i*100]);
|
|
}
|
|
break;
|
|
|
|
case ct_MP3:
|
|
{
|
|
const int iIndex = (i*100) + ((offset * /*ch->thesfx->width*/2) - ch->iMP3SlidingDecodeWindowPos);
|
|
const short* pwSamples = (short*) (ch->MP3SlidingDecodeBuffer + iIndex);
|
|
|
|
sample = LittleShort(*pwSamples);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
assert(0);
|
|
sample = 0;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// if (sample < 0)
|
|
// sample = -sample;
|
|
sample = sample>>8;
|
|
}
|
|
// square it for better accuracy
|
|
sample_total += (sample * sample);
|
|
count++;
|
|
}
|
|
|
|
// if we are already done with this sample, then its silence
|
|
if (!count)
|
|
{
|
|
return(0);
|
|
}
|
|
sample_total /= count;
|
|
|
|
// I hate doing this, but its the simplest way
|
|
if (sample_total < ch->thesfx->fVolRange * s_lip_threshold_1->value)
|
|
{
|
|
// tell the scripts that are relying on this that we are still going, but actually silent right now.
|
|
sample = -1;
|
|
}
|
|
else
|
|
if (sample_total < ch->thesfx->fVolRange * s_lip_threshold_2->value)
|
|
{
|
|
sample = 1;
|
|
}
|
|
else
|
|
if (sample_total < ch->thesfx->fVolRange * s_lip_threshold_3->value)
|
|
{
|
|
sample = 2;
|
|
}
|
|
else
|
|
if (sample_total < ch->thesfx->fVolRange * s_lip_threshold_4->value)
|
|
{
|
|
sample = 3;
|
|
}
|
|
else
|
|
{
|
|
sample = 4;
|
|
}
|
|
|
|
// OutputDebugString(va("Returning sample %d\n",sample));
|
|
|
|
// store away the value we got into the back up table
|
|
s_entityWavVol_back[ ch->entnum ] = sample;
|
|
return (sample);
|
|
}
|
|
// no, just get last value calculated from backup table
|
|
assert( s_entityWavVol_back[ch->entnum] );
|
|
return (s_entityWavVol_back[ ch->entnum]);
|
|
}
|
|
/*
|
|
============
|
|
S_Respatialize
|
|
|
|
Change the volumes of all the playing sounds for changes in their positions
|
|
============
|
|
*/
|
|
void S_Respatialize( int entityNum, const vec3_t head, vec3_t axis[3], qboolean inwater )
|
|
{
|
|
EAXOCCLUSIONPROPERTIES eaxOCProp;
|
|
unsigned int ulEnvironment;
|
|
int i;
|
|
channel_t *ch;
|
|
vec3_t origin;
|
|
|
|
if ( !s_soundStarted || s_soundMuted ) {
|
|
return;
|
|
}
|
|
|
|
if (s_UseOpenAL)
|
|
{
|
|
listener_pos[0] = head[0];
|
|
listener_pos[1] = head[2];
|
|
listener_pos[2] = -head[1];
|
|
alListenerfv(AL_POSITION, listener_pos);
|
|
|
|
listener_ori[0] = axis[0][0];
|
|
listener_ori[1] = axis[0][2];
|
|
listener_ori[2] = -axis[0][1];
|
|
listener_ori[3] = axis[2][0];
|
|
listener_ori[4] = axis[2][2];
|
|
listener_ori[5] = -axis[2][1];
|
|
alListenerfv(AL_ORIENTATION, listener_ori);
|
|
|
|
// Update EAX effects here
|
|
if (s_bEALFileLoaded)
|
|
{
|
|
// Check if the Listener is underwater
|
|
if (inwater)
|
|
{
|
|
// Check if we have already applied Underwater effect
|
|
if (!s_bInWater)
|
|
{
|
|
// Apply Underwater Reverb effect, and occlude *all* Sources
|
|
ulEnvironment = EAX_ENVIRONMENT_UNDERWATER;
|
|
s_eaxSet(&DSPROPSETID_EAX_ListenerProperties, DSPROPERTY_EAXLISTENER_ENVIRONMENT,
|
|
NULL, &ulEnvironment, sizeof(unsigned int));
|
|
s_EnvironmentID = 999;
|
|
|
|
eaxOCProp.lOcclusion = -3000;
|
|
eaxOCProp.flOcclusionLFRatio = 0.0f;
|
|
eaxOCProp.flOcclusionRoomRatio = 1.37f;
|
|
eaxOCProp.flOcclusionDirectRatio = 1.0f;
|
|
|
|
ch = s_channels + 1;
|
|
for (i = 1; i < s_numChannels; i++, ch++)
|
|
{
|
|
s_eaxSet(&DSPROPSETID_EAX_BufferProperties, DSPROPERTY_EAXBUFFER_OCCLUSIONPARAMETERS,
|
|
ch->alSource, &eaxOCProp, sizeof(EAXOCCLUSIONPROPERTIES));
|
|
}
|
|
|
|
s_bInWater = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Not underwater ... check if the underwater effect is still present
|
|
if (s_bInWater)
|
|
{
|
|
// Remove underwater Reverb effect, and reset Occlusion / Obstruction amount on all Sources
|
|
UpdateEAXListener(false, false);
|
|
|
|
ch = s_channels + 1;
|
|
for (i = 1; i < s_numChannels; i++, ch++)
|
|
{
|
|
UpdateEAXBuffer(ch);
|
|
}
|
|
|
|
s_bInWater = false;
|
|
}
|
|
else
|
|
{
|
|
UpdateEAXListener(false, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
listener_number = entityNum;
|
|
VectorCopy(head, listener_origin);
|
|
VectorCopy(axis[0], listener_axis[0]);
|
|
VectorCopy(axis[1], listener_axis[1]);
|
|
VectorCopy(axis[2], listener_axis[2]);
|
|
|
|
// update spatialization for dynamic sounds
|
|
ch = s_channels;
|
|
for ( i = 0 ; i < MAX_CHANNELS ; i++, ch++ ) {
|
|
if ( !ch->thesfx ) {
|
|
continue;
|
|
}
|
|
if ( ch->loopSound ) { // loopSounds are regenerated fresh each frame
|
|
Channel_Clear(ch); // memset (ch, 0, sizeof(*ch));
|
|
continue;
|
|
}
|
|
|
|
// anything coming from the view entity will always be full volume
|
|
if (ch->entnum == listener_number) {
|
|
ch->leftvol = ch->master_vol;
|
|
ch->rightvol = ch->master_vol;
|
|
} else {
|
|
if (ch->fixed_origin) {
|
|
VectorCopy( ch->origin, origin );
|
|
} else {
|
|
VectorCopy( s_entityPosition[ ch->entnum ], origin );
|
|
}
|
|
|
|
S_SpatializeOrigin (origin, (float)ch->master_vol, &ch->leftvol, &ch->rightvol, ch->entchannel);
|
|
}
|
|
|
|
//NOTE: Made it so that voice sounds keep playing, even out of range
|
|
// so that tasks waiting for sound completion keep proper timing
|
|
if ( !( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL ) && !ch->leftvol && !ch->rightvol ) {
|
|
Channel_Clear(ch); // memset (ch, 0, sizeof(*ch));
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// add loopsounds
|
|
S_AddLoopSounds ();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
========================
|
|
S_ScanChannelStarts
|
|
|
|
Returns qtrue if any new sounds were started since the last mix
|
|
========================
|
|
*/
|
|
qboolean S_ScanChannelStarts( void ) {
|
|
channel_t *ch;
|
|
int i;
|
|
qboolean newSamples;
|
|
|
|
newSamples = qfalse;
|
|
ch = s_channels;
|
|
for (i=0; i<MAX_CHANNELS ; i++, ch++) {
|
|
if ( !ch->thesfx ) {
|
|
continue;
|
|
}
|
|
if ( ch->loopSound ) {
|
|
continue;
|
|
}
|
|
|
|
// if this channel was just started this frame,
|
|
// set the sample count to it begins mixing
|
|
// into the very first sample
|
|
if ( ch->startSample == START_SAMPLE_IMMEDIATE ) {
|
|
ch->startSample = s_paintedtime;
|
|
newSamples = qtrue;
|
|
continue;
|
|
}
|
|
|
|
// if it is completely finished by now, clear it
|
|
if ( ch->startSample + ch->thesfx->iSoundLengthInSamples <= s_paintedtime ) {
|
|
ch->thesfx = NULL;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
return newSamples;
|
|
}
|
|
|
|
// this is now called AFTER the DMA painting, since it's only the painter calls that cause the MP3s to be unpacked,
|
|
// and therefore to have data readable by the lip-sync volume calc code.
|
|
//
|
|
void S_DoLipSynchs( const unsigned s_oldpaintedtime )
|
|
{
|
|
channel_t *ch;
|
|
int i;
|
|
qboolean newSamples;
|
|
|
|
// clear out the lip synching override array for this frame
|
|
memset(s_entityWavVol, 0,(MAX_GENTITIES * 4));
|
|
|
|
newSamples = qfalse;
|
|
ch = s_channels;
|
|
for (i=0; i<MAX_CHANNELS ; i++, ch++) {
|
|
if ( !ch->thesfx ) {
|
|
continue;
|
|
}
|
|
if ( ch->loopSound ) {
|
|
continue;
|
|
}
|
|
|
|
// if we are playing a sample that should override the lip texture on its owning model, lets figure out
|
|
// what the amplitude is, stick it in a table, then return it
|
|
if ( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
|
|
{
|
|
// go away and work out amplitude for this sound we are playing right now.
|
|
s_entityWavVol[ ch->entnum ] = S_CheckAmplitude( ch, s_oldpaintedtime );
|
|
if ( s_show->integer == 3 ) {
|
|
Com_Printf( "(%i)%i %s vol = %i\n", ch->entnum, i, ch->thesfx->sSoundName, s_entityWavVol[ ch->entnum ] );
|
|
}
|
|
}
|
|
}
|
|
|
|
if (next_amplitude < s_soundtime) {
|
|
next_amplitude = s_soundtime + 800;
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
S_Update
|
|
|
|
Called once each time through the main loop
|
|
============
|
|
*/
|
|
void S_Update( void ) {
|
|
int i;
|
|
int total;
|
|
channel_t *ch;
|
|
|
|
if ( !s_soundStarted || s_soundMuted ) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// debugging output
|
|
//
|
|
if ( s_show->integer == 2 ) {
|
|
total = 0;
|
|
int totalMeg =0;
|
|
ch = s_channels;
|
|
for (i=0 ; i<MAX_CHANNELS; i++, ch++) {
|
|
if (ch->thesfx && (ch->leftvol || ch->rightvol) ) {
|
|
Com_Printf ("(%i) %3i %3i %s\n", ch->entnum, ch->leftvol, ch->rightvol, ch->thesfx->sSoundName);
|
|
total++;
|
|
totalMeg += Z_Size(ch->thesfx->pSoundData);
|
|
if (ch->thesfx->pMP3StreamHeader)
|
|
{
|
|
totalMeg += sizeof(*ch->thesfx->pMP3StreamHeader);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (total)
|
|
Com_Printf ("----(%i)---- painted: %i, SND %.2fMB\n", total, s_paintedtime, totalMeg/1024.0f/1024.0f);
|
|
}
|
|
|
|
// The Open AL code, handles background music in the S_UpdateRawSamples function
|
|
if (!s_UseOpenAL)
|
|
{
|
|
// add raw data from streamed samples
|
|
S_UpdateBackgroundTrack();
|
|
}
|
|
|
|
// mix some sound
|
|
S_Update_();
|
|
}
|
|
|
|
void S_GetSoundtime(void)
|
|
{
|
|
int samplepos;
|
|
static int buffers;
|
|
static int oldsamplepos;
|
|
int fullsamples;
|
|
|
|
fullsamples = dma.samples / dma.channels;
|
|
|
|
// it is possible to miscount buffers if it has wrapped twice between
|
|
// calls to S_Update. Oh well.
|
|
samplepos = SNDDMA_GetDMAPos();
|
|
if (samplepos < oldsamplepos)
|
|
{
|
|
buffers++; // buffer wrapped
|
|
|
|
if (s_paintedtime > 0x40000000)
|
|
{ // time to chop things off to avoid 32 bit limits
|
|
buffers = 0;
|
|
s_paintedtime = fullsamples;
|
|
S_StopAllSounds ();
|
|
}
|
|
}
|
|
oldsamplepos = samplepos;
|
|
|
|
s_soundtime = buffers*fullsamples + samplepos/dma.channels;
|
|
|
|
#if 0
|
|
// check to make sure that we haven't overshot
|
|
if (s_paintedtime < s_soundtime)
|
|
{
|
|
Com_DPrintf ("S_Update_ : overflow\n");
|
|
s_paintedtime = s_soundtime;
|
|
}
|
|
#endif
|
|
|
|
if ( dma.submission_chunk < 256 ) {
|
|
s_paintedtime = (int)(s_soundtime + s_mixPreStep->value * dma.speed);
|
|
} else {
|
|
s_paintedtime = s_soundtime + dma.submission_chunk;
|
|
}
|
|
}
|
|
|
|
|
|
void S_Update_(void) {
|
|
unsigned endtime;
|
|
int samps;
|
|
channel_t *ch;
|
|
int i,j;
|
|
int source;
|
|
float pos[3];
|
|
EAXOBSTRUCTIONPROPERTIES eaxOBProp;
|
|
EAXOCCLUSIONPROPERTIES eaxOCProp;
|
|
#ifdef _DEBUG
|
|
char szString[256];
|
|
#endif
|
|
|
|
if ( !s_soundStarted || s_soundMuted ) {
|
|
return;
|
|
}
|
|
|
|
if (s_UseOpenAL)
|
|
{
|
|
UpdateSingleShotSounds();
|
|
|
|
ch = s_channels;
|
|
for ( i = 0; i < MAX_CHANNELS ; i++, ch++ )
|
|
{
|
|
if ( !ch->thesfx || (ch->bPlaying))
|
|
continue;
|
|
|
|
source = ch - s_channels;
|
|
|
|
// Get position of source
|
|
if (ch->fixed_origin)
|
|
{
|
|
pos[0] = ch->origin[0];
|
|
pos[1] = ch->origin[2];
|
|
pos[2] = -ch->origin[1];
|
|
alSourcei(s_channels[source].alSource, AL_SOURCE_RELATIVE, AL_FALSE);
|
|
}
|
|
else
|
|
{
|
|
if (ch->entnum == listener_number)
|
|
{
|
|
pos[0] = 0.0f;
|
|
pos[1] = 0.0f;
|
|
pos[2] = 0.0f;
|
|
alSourcei(s_channels[source].alSource, AL_SOURCE_RELATIVE, AL_TRUE);
|
|
}
|
|
else
|
|
{
|
|
// Get position of Entity
|
|
if (ch->bLooping)
|
|
{
|
|
pos[0] = loopSounds[ ch->entnum ].origin[0];
|
|
pos[1] = loopSounds[ ch->entnum ].origin[2];
|
|
pos[2] = -loopSounds[ ch->entnum ].origin[1];
|
|
}
|
|
else
|
|
{
|
|
pos[0] = s_entityPosition[ch->entnum][0];
|
|
pos[1] = s_entityPosition[ch->entnum][2];
|
|
pos[2] = -s_entityPosition[ch->entnum][1];
|
|
}
|
|
alSourcei(s_channels[source].alSource, AL_SOURCE_RELATIVE, AL_FALSE);
|
|
}
|
|
}
|
|
|
|
alSourcefv(s_channels[source].alSource, AL_POSITION, pos);
|
|
alSourcei(s_channels[source].alSource, AL_LOOPING, AL_FALSE);
|
|
|
|
if ( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
|
|
{
|
|
alSourcef(s_channels[source].alSource, AL_REFERENCE_DISTANCE, 1500.0f);
|
|
alSourcef(s_channels[source].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volumeVoice->value) / 255.0f);
|
|
|
|
if (s_bEAX)
|
|
{
|
|
// Switch-off Occlusion + Obstruction
|
|
eaxOBProp.lObstruction = EAXBUFFER_DEFAULTOBSTRUCTION;
|
|
eaxOBProp.flObstructionLFRatio = EAXBUFFER_DEFAULTOBSTRUCTIONLFRATIO;
|
|
|
|
eaxOCProp.lOcclusion = EAXBUFFER_DEFAULTOCCLUSION;
|
|
eaxOCProp.flOcclusionLFRatio = EAXBUFFER_DEFAULTOCCLUSIONLFRATIO;
|
|
eaxOCProp.flOcclusionRoomRatio = EAXBUFFER_DEFAULTOCCLUSIONROOMRATIO;
|
|
eaxOCProp.flOcclusionDirectRatio = EAXBUFFER_DEFAULTOCCLUSIONDIRECTRATIO;
|
|
|
|
s_eaxSet(&DSPROPSETID_EAX_BufferProperties, DSPROPERTY_EAXBUFFER_OBSTRUCTIONPARAMETERS,
|
|
ch->alSource, &eaxOBProp, sizeof(EAXOBSTRUCTIONPROPERTIES));
|
|
|
|
s_eaxSet(&DSPROPSETID_EAX_BufferProperties, DSPROPERTY_EAXBUFFER_OCCLUSIONPARAMETERS,
|
|
ch->alSource, &eaxOCProp, sizeof(EAXOCCLUSIONPROPERTIES));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
alSourcef(s_channels[source].alSource, AL_REFERENCE_DISTANCE, 400.f);
|
|
alSourcef(s_channels[source].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.f);
|
|
|
|
if (s_bEALFileLoaded)
|
|
UpdateEAXBuffer(ch);
|
|
}
|
|
|
|
|
|
int nBytesDecoded = 0;
|
|
int nTotalBytesDecoded = 0;
|
|
int nBuffersToAdd = 0;
|
|
|
|
if (ch->thesfx->pMP3StreamHeader)
|
|
{
|
|
memcpy(&ch->MP3StreamHeader, ch->thesfx->pMP3StreamHeader, sizeof(ch->MP3StreamHeader));
|
|
ch->iMP3SlidingDecodeWritePos = 0;
|
|
ch->iMP3SlidingDecodeWindowPos= 0;
|
|
|
|
// Reset streaming buffers status's
|
|
for (i = 0; i < NUM_STREAMING_BUFFERS; i++)
|
|
ch->buffers[i].Status = UNQUEUED;
|
|
|
|
// Decode (STREAMING_BUFFER_SIZE / 1152) MP3 frames for each of the NUM_STREAMING_BUFFERS AL Buffers
|
|
for (i = 0; i < NUM_STREAMING_BUFFERS; i++)
|
|
{
|
|
nTotalBytesDecoded = 0;
|
|
|
|
for (j = 0; j < (STREAMING_BUFFER_SIZE / 1152); j++)
|
|
{
|
|
nBytesDecoded = C_MP3Stream_Decode(&ch->MP3StreamHeader, 0); // added ,0 ?
|
|
|
|
memcpy(ch->buffers[i].Data + nTotalBytesDecoded, ch->MP3StreamHeader.bDecodeBuffer, nBytesDecoded);
|
|
if (ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
|
|
{
|
|
if (ch->thesfx->lipSyncData)
|
|
{
|
|
ch->thesfx->lipSyncData[(i*NUM_STREAMING_BUFFERS)+j] = S_MP3PreProcessLipSync(ch, (short *)(ch->MP3StreamHeader.bDecodeBuffer));
|
|
}
|
|
else
|
|
{
|
|
#ifdef _DEBUG
|
|
sprintf(szString, "Missing lip-sync info. for %s\n", ch->thesfx->sSoundName);
|
|
OutputDebugString(szString);
|
|
#endif
|
|
}
|
|
}
|
|
nTotalBytesDecoded += nBytesDecoded;
|
|
}
|
|
|
|
if (nTotalBytesDecoded != STREAMING_BUFFER_SIZE)
|
|
{
|
|
memset(ch->buffers[i].Data + nTotalBytesDecoded, 0, (STREAMING_BUFFER_SIZE - nTotalBytesDecoded));
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i >= NUM_STREAMING_BUFFERS)
|
|
nBuffersToAdd = NUM_STREAMING_BUFFERS;
|
|
else
|
|
nBuffersToAdd = i + 1;
|
|
|
|
// Make sure queue is empty first
|
|
alSourcei(s_channels[source].alSource, AL_BUFFER, NULL);
|
|
|
|
for (i = 0; i < nBuffersToAdd; i++)
|
|
{
|
|
// Copy decoded data to AL Buffer
|
|
alBufferData(ch->buffers[i].BufferID, AL_FORMAT_MONO16, ch->buffers[i].Data, STREAMING_BUFFER_SIZE, 22050);
|
|
|
|
// Queue AL Buffer on Source
|
|
alSourceQueueBuffers(s_channels[source].alSource, 1, &(ch->buffers[i].BufferID));
|
|
if (alGetError() == AL_NO_ERROR)
|
|
{
|
|
ch->buffers[i].Status = QUEUED;
|
|
}
|
|
}
|
|
|
|
// Clear error state, and check for successful Play call
|
|
alGetError();
|
|
alSourcePlay(s_channels[source].alSource);
|
|
if (alGetError() == AL_NO_ERROR)
|
|
s_channels[source].bPlaying = true;
|
|
|
|
// Record start time for Lip-syncing
|
|
s_channels[source].iStartTime = Com_Milliseconds();
|
|
|
|
ch->bStreaming = true;
|
|
|
|
if ( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
|
|
{
|
|
if (ch->thesfx->lipSyncData)
|
|
{
|
|
// Prepare lipsync value(s)
|
|
s_entityWavVol[ ch->entnum ] = ch->thesfx->lipSyncData[0];
|
|
}
|
|
else
|
|
{
|
|
#ifdef _DEBUG
|
|
sprintf(szString, "Missing lip-sync info. for %s\n", ch->thesfx->sSoundName);
|
|
OutputDebugString(szString);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
// Attach buffer to source
|
|
alSourcei(s_channels[source].alSource, AL_BUFFER, ch->thesfx->Buffer);
|
|
|
|
ch->bStreaming = false;
|
|
|
|
// Clear error state, and check for successful Play call
|
|
alGetError();
|
|
alSourcePlay(s_channels[source].alSource);
|
|
if (alGetError() == AL_NO_ERROR)
|
|
s_channels[source].bPlaying = true;
|
|
}
|
|
}
|
|
|
|
|
|
S_SetLipSyncs();
|
|
|
|
UpdateLoopingSounds();
|
|
|
|
AL_UpdateRawSamples();
|
|
|
|
EAXMorph();
|
|
}
|
|
else
|
|
{
|
|
// Updates s_soundtime
|
|
S_GetSoundtime();
|
|
|
|
const unsigned s_oldpaintedtime = s_paintedtime;
|
|
|
|
// clear any sound effects that end before the current time,
|
|
// and start any new sounds
|
|
S_ScanChannelStarts();
|
|
|
|
// mix ahead of current position
|
|
endtime = (int)(s_soundtime + s_mixahead->value * dma.speed);
|
|
|
|
// mix to an even submission block size
|
|
endtime = (endtime + dma.submission_chunk-1)
|
|
& ~(dma.submission_chunk-1);
|
|
|
|
// never mix more than the complete buffer
|
|
samps = dma.samples >> (dma.channels-1);
|
|
if (endtime - s_soundtime > samps)
|
|
endtime = s_soundtime + samps;
|
|
|
|
|
|
SNDDMA_BeginPainting ();
|
|
|
|
S_PaintChannels (endtime);
|
|
|
|
SNDDMA_Submit ();
|
|
|
|
S_DoLipSynchs( s_oldpaintedtime );
|
|
}
|
|
}
|
|
|
|
|
|
void UpdateSingleShotSounds()
|
|
{
|
|
int i, j, k;
|
|
ALint state;
|
|
ALint processed;
|
|
channel_t *ch;
|
|
#ifdef _DEBUG
|
|
char szString[256];
|
|
#endif
|
|
|
|
// Firstly, check if any single-shot sounds have completed, or if they need more data (for streaming Sources),
|
|
// and/or if any of the currently playing (non-Ambient) looping sounds need to be stopped
|
|
ch = s_channels ;
|
|
for (i = 0; i < s_numChannels; i++, ch++)
|
|
{
|
|
ch->bProcessed = false;
|
|
if ((s_channels[i].bPlaying) && (!ch->bLooping))
|
|
{
|
|
// Single-shot
|
|
if (s_channels[i].bStreaming == false)
|
|
{
|
|
alGetSourcei(s_channels[i].alSource, AL_SOURCE_STATE, &state);
|
|
if (state == AL_STOPPED)
|
|
{
|
|
s_channels[i].thesfx = NULL;
|
|
s_channels[i].bPlaying = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Process streaming sample
|
|
|
|
// Procedure :-
|
|
// if more data to play
|
|
// if any UNQUEUED Buffers
|
|
// fill them with data
|
|
// (else ?)
|
|
// get number of buffers processed
|
|
// fill them with data
|
|
// restart playback if it has stopped (buffer underrun)
|
|
// else
|
|
// free channel
|
|
|
|
int nBytesDecoded;
|
|
|
|
if (ch->thesfx->pMP3StreamHeader)
|
|
{
|
|
if (ch->MP3StreamHeader.iSourceBytesRemaining == 0)
|
|
{
|
|
// Finished decoding data - if the source has finished playing then we're done
|
|
alGetSourcei(ch->alSource, AL_SOURCE_STATE, &state);
|
|
if (state == AL_STOPPED)
|
|
{
|
|
// Attach NULL buffer to Source to remove any buffers left in the queue
|
|
alSourcei(ch->alSource, AL_BUFFER, NULL);
|
|
ch->thesfx = NULL;
|
|
ch->bPlaying = false;
|
|
|
|
}
|
|
// Move on to next channel ...
|
|
continue;
|
|
}
|
|
|
|
// Check to see if any Buffers have been processed
|
|
alGetSourcei(ch->alSource, AL_BUFFERS_PROCESSED, &processed);
|
|
|
|
ALuint buffer;
|
|
while (processed)
|
|
{
|
|
alSourceUnqueueBuffers(ch->alSource, 1, &buffer);
|
|
for (j = 0; j < NUM_STREAMING_BUFFERS; j++)
|
|
{
|
|
if (ch->buffers[j].BufferID == buffer)
|
|
{
|
|
ch->buffers[j].Status = UNQUEUED;
|
|
break;
|
|
}
|
|
}
|
|
processed--;
|
|
}
|
|
|
|
int nTotalBytesDecoded = 0;
|
|
|
|
for (j = 0; j < NUM_STREAMING_BUFFERS; j++)
|
|
{
|
|
if ((ch->buffers[j].Status == UNQUEUED) & (ch->MP3StreamHeader.iSourceBytesRemaining > 0))
|
|
{
|
|
nTotalBytesDecoded = 0;
|
|
|
|
for (k = 0; k < (STREAMING_BUFFER_SIZE / 1152); k++)
|
|
{
|
|
nBytesDecoded = C_MP3Stream_Decode(&ch->MP3StreamHeader, 0); // added ,0
|
|
if (nBytesDecoded > 0)
|
|
{
|
|
memcpy(ch->buffers[j].Data + nTotalBytesDecoded, ch->MP3StreamHeader.bDecodeBuffer, nBytesDecoded);
|
|
|
|
if (ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
|
|
{
|
|
if (ch->thesfx->lipSyncData)
|
|
{
|
|
ch->thesfx->lipSyncData[(j*4)+k] = S_MP3PreProcessLipSync(ch, (short *)(ch->buffers[j].Data));
|
|
}
|
|
else
|
|
{
|
|
#ifdef _DEBUG
|
|
sprintf(szString, "Missing lip-sync info. for %s\n", ch->thesfx->sSoundName);
|
|
OutputDebugString(szString);
|
|
#endif
|
|
}
|
|
}
|
|
nTotalBytesDecoded += nBytesDecoded;
|
|
}
|
|
else
|
|
{
|
|
// Make sure that iSourceBytesRemaining is 0
|
|
if (ch->MP3StreamHeader.iSourceBytesRemaining != 0)
|
|
{
|
|
ch->MP3StreamHeader.iSourceBytesRemaining = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nTotalBytesDecoded != STREAMING_BUFFER_SIZE)
|
|
{
|
|
memset(ch->buffers[j].Data + nTotalBytesDecoded, 0, (STREAMING_BUFFER_SIZE - nTotalBytesDecoded));
|
|
|
|
// Move data to buffer
|
|
alBufferData(ch->buffers[j].BufferID, AL_FORMAT_MONO16, ch->buffers[j].Data, STREAMING_BUFFER_SIZE, 22050);
|
|
|
|
// Queue Buffer on Source
|
|
alSourceQueueBuffers(ch->alSource, 1, &(ch->buffers[j].BufferID));
|
|
|
|
// Update status of Buffer
|
|
ch->buffers[j].Status = QUEUED;
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
// Move data to buffer
|
|
alBufferData(ch->buffers[j].BufferID, AL_FORMAT_MONO16, ch->buffers[j].Data, STREAMING_BUFFER_SIZE, 22050);
|
|
|
|
// Queue Buffer on Source
|
|
alSourceQueueBuffers(ch->alSource, 1, &(ch->buffers[j].BufferID));
|
|
|
|
// Update status of Buffer
|
|
ch->buffers[j].Status = QUEUED;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get state of Buffer
|
|
alGetSourcei(ch->alSource, AL_SOURCE_STATE, &state);
|
|
if (state != AL_PLAYING)
|
|
{
|
|
alSourcePlay(ch->alSource);
|
|
#ifdef _DEBUG
|
|
char szString[256];
|
|
sprintf(szString,"[%d] Restarting playback of single-shot streaming MP3 sample - still have %d bytes to decode\n", i, ch->MP3StreamHeader.iSourceBytesRemaining);
|
|
OutputDebugString(szString);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
void UpdateLoopingSounds()
|
|
{
|
|
int i,j;
|
|
ALuint source;
|
|
channel_t *ch;
|
|
loopSound_t *loop;
|
|
float pos[3];
|
|
|
|
// First check to see if any of the looping sounds are already playing at the correct positions
|
|
ch = s_channels + 1;
|
|
for (i = 1; i < s_numChannels; i++, ch++)
|
|
{
|
|
if (ch->bLooping && s_channels[i].bPlaying)
|
|
{
|
|
for (j = 0; j < numLoopSounds; j++)
|
|
{
|
|
loop = &loopSounds[j];
|
|
|
|
// If this channel is playing the right sound effect at the right position then mark this channel and looping sound
|
|
// as processed
|
|
if ((loop->bProcessed == false) && (ch->thesfx == loop->sfx) )
|
|
{
|
|
if ( (loop->origin[0] == listener_pos[0]) && (loop->origin[1] == -listener_pos[2])
|
|
&& (loop->origin[2] == listener_pos[1]) )
|
|
{
|
|
// Assume that this sound is head relative
|
|
if (!loop->bRelative)
|
|
{
|
|
// Set position to 0,0,0 and turn on Head Relative Mode
|
|
float pos[3];
|
|
pos[0] = 0.f;
|
|
pos[1] = 0.f;
|
|
pos[2] = 0.f;
|
|
|
|
alSourcefv(s_channels[i].alSource, AL_POSITION, pos);
|
|
alSourcei(s_channels[i].alSource, AL_SOURCE_RELATIVE, AL_TRUE);
|
|
loop->bRelative = true;
|
|
}
|
|
|
|
// Make sure Gain is set correctly
|
|
if (ch->master_vol != loop->volume)
|
|
{
|
|
ch->master_vol = loop->volume;
|
|
alSourcef(s_channels[i].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.f);
|
|
}
|
|
|
|
ch->bProcessed = true;
|
|
loop->bProcessed = true;
|
|
}
|
|
else if ((loop->bProcessed == false) && (ch->thesfx == loop->sfx) && (!memcmp(ch->origin, loop->origin, sizeof(ch->origin))))
|
|
{
|
|
// Match !
|
|
ch->bProcessed = true;
|
|
loop->bProcessed = true;
|
|
|
|
// Make sure Gain is set correctly
|
|
if (ch->master_vol != loop->volume)
|
|
{
|
|
ch->master_vol = loop->volume;
|
|
alSourcef(s_channels[i].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.f);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Next check if the correct looping sound is playing, but at the wrong position
|
|
ch = s_channels + 1;
|
|
for (i = 1; i < s_numChannels; i++, ch++)
|
|
{
|
|
if ((ch->bLooping) && (ch->bProcessed == false) && s_channels[i].bPlaying)
|
|
{
|
|
for (j = 0; j < numLoopSounds; j++)
|
|
{
|
|
loop = &loopSounds[j];
|
|
|
|
if ((loop->bProcessed == false) && (ch->thesfx == loop->sfx))
|
|
{
|
|
// Same sound - wrong position
|
|
ch->origin[0] = loop->origin[0];
|
|
ch->origin[1] = loop->origin[1];
|
|
ch->origin[2] = loop->origin[2];
|
|
|
|
pos[0] = loop->origin[0];
|
|
pos[1] = loop->origin[2];
|
|
pos[2] = -loop->origin[1];
|
|
alSourcefv(s_channels[i].alSource, AL_POSITION, pos);
|
|
|
|
ch->master_vol = loop->volume;
|
|
alSourcef(s_channels[i].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.f);
|
|
|
|
if (s_bEALFileLoaded)
|
|
UpdateEAXBuffer(ch);
|
|
|
|
ch->bProcessed = true;
|
|
loop->bProcessed = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If any non-procesed looping sounds are still playing on a channel, they can be removed as they are no longer
|
|
// required
|
|
ch = s_channels + 1;
|
|
for (i = 1; i < s_numChannels; i++, ch++)
|
|
{
|
|
if (s_channels[i].bPlaying && ch->bLooping && !ch->bProcessed)
|
|
{
|
|
// Sound no longer needed
|
|
alSourceStop(s_channels[i].alSource);
|
|
ch->thesfx = NULL;
|
|
ch->bPlaying = false;
|
|
}
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
alGetError();
|
|
#endif
|
|
// Finally if there are any non-processed sounds left, we need to try and play them
|
|
for (j = 0; j < numLoopSounds; j++)
|
|
{
|
|
loop = &loopSounds[j];
|
|
|
|
if (loop->bProcessed == false)
|
|
{
|
|
ch = S_PickChannel(0,0);
|
|
|
|
ch->master_vol = loop->volume;
|
|
ch->entnum = loop->entnum;
|
|
ch->entchannel = CHAN_AMBIENT; // Make sure this gets set to something
|
|
ch->thesfx = loop->sfx;
|
|
ch->bLooping = true;
|
|
|
|
// Check if the Source is positioned at exactly the same location as the listener
|
|
if ( (loop->origin[0] == listener_pos[0]) && (loop->origin[1] == -listener_pos[2])
|
|
&& (loop->origin[2] == listener_pos[1]) )
|
|
{
|
|
// Assume that this sound is head relative
|
|
loop->bRelative = true;
|
|
ch->origin[0] = 0.f;
|
|
ch->origin[1] = 0.f;
|
|
ch->origin[2] = 0.f;
|
|
}
|
|
else
|
|
{
|
|
ch->origin[0] = loop->origin[0];
|
|
ch->origin[1] = loop->origin[1];
|
|
ch->origin[2] = loop->origin[2];
|
|
loop->bRelative = false;
|
|
}
|
|
|
|
ch->fixed_origin = loop->bRelative;
|
|
pos[0] = ch->origin[0];
|
|
pos[1] = ch->origin[2];
|
|
pos[2] = -ch->origin[1];
|
|
|
|
source = ch - s_channels;
|
|
alSourcei(s_channels[source].alSource, AL_BUFFER, ch->thesfx->Buffer);
|
|
alSourcefv(s_channels[source].alSource, AL_POSITION, pos);
|
|
alSourcei(s_channels[source].alSource, AL_LOOPING, AL_TRUE);
|
|
alSourcef(s_channels[source].alSource, AL_REFERENCE_DISTANCE, 400.f);
|
|
alSourcef(s_channels[source].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.0f);
|
|
alSourcei(s_channels[source].alSource, AL_SOURCE_RELATIVE, ch->fixed_origin ? AL_TRUE : AL_FALSE);
|
|
|
|
if (s_bEALFileLoaded)
|
|
UpdateEAXBuffer(ch);
|
|
|
|
alGetError();
|
|
alSourcePlay(s_channels[source].alSource);
|
|
if (alGetError() == AL_NO_ERROR)
|
|
s_channels[source].bPlaying = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void AL_UpdateRawSamples()
|
|
{
|
|
ALuint buffer;
|
|
ALint size;
|
|
ALint processed;
|
|
ALint state;
|
|
int i,j,src;
|
|
|
|
#ifdef _DEBUG
|
|
// Clear Open AL Error
|
|
alGetError();
|
|
#endif
|
|
|
|
S_UpdateBackgroundTrack();
|
|
|
|
// Find out how many buffers have been processed (played) by the Source
|
|
alGetSourcei(s_channels[0].alSource, AL_BUFFERS_PROCESSED, &processed);
|
|
|
|
while (processed)
|
|
{
|
|
// Unqueue each buffer, determine the length of the buffer, and then delete it
|
|
alSourceUnqueueBuffers(s_channels[0].alSource, 1, &buffer);
|
|
alGetBufferi(buffer, AL_SIZE, &size);
|
|
alDeleteBuffers(1, &buffer);
|
|
|
|
// Update sg.soundtime (+= number of samples played (number of bytes / 4))
|
|
s_soundtime += (size >> 2);
|
|
|
|
processed--;
|
|
}
|
|
|
|
// Add new data to a new Buffer and queue it on the Source
|
|
if (s_rawend > s_paintedtime)
|
|
{
|
|
size = (s_rawend - s_paintedtime)<<2;
|
|
if (size > (MAX_RAW_SAMPLES<<2))
|
|
{
|
|
OutputDebugString("UpdateRawSamples :- Raw Sample buffer has overflowed !!!\n");
|
|
size = MAX_RAW_SAMPLES<<2;
|
|
s_paintedtime = s_rawend - MAX_RAW_SAMPLES;
|
|
}
|
|
|
|
// Copy samples from RawSamples to audio buffer (sg.rawdata)
|
|
for (i = s_paintedtime, j = 0; i < s_rawend; i++, j+=2)
|
|
{
|
|
src = i & (MAX_RAW_SAMPLES - 1);
|
|
s_rawdata[j] = (short)(s_rawsamples[src].left>>8);
|
|
s_rawdata[j+1] = (short)(s_rawsamples[src].right>>8);
|
|
}
|
|
|
|
// Need to generate more than 1 buffer for music playback
|
|
// iterations = 0;
|
|
// largestBufferSize = (MAX_RAW_SAMPLES / 4) * 4
|
|
// while (size)
|
|
// generate a buffer
|
|
// if size > largestBufferSize
|
|
// copy sg.rawdata + ((iterations * largestBufferSize)>>1) to buffer
|
|
// size -= largestBufferSize
|
|
// else
|
|
// copy remainder
|
|
// size = 0
|
|
// queue the buffer
|
|
// iterations++;
|
|
|
|
int iterations = 0;
|
|
int largestBufferSize = MAX_RAW_SAMPLES; // in bytes (== quarter of Raw Samples data)
|
|
while (size)
|
|
{
|
|
alGenBuffers(1, &buffer);
|
|
|
|
if (size > largestBufferSize)
|
|
{
|
|
alBufferData(buffer, AL_FORMAT_STEREO16, (char*)(s_rawdata + ((iterations * largestBufferSize)>>1)), largestBufferSize, 22050);
|
|
size -= largestBufferSize;
|
|
}
|
|
else
|
|
{
|
|
alBufferData(buffer, AL_FORMAT_STEREO16, (char*)(s_rawdata + ((iterations * largestBufferSize)>>1)), size, 22050);
|
|
size = 0;
|
|
}
|
|
|
|
alSourceQueueBuffers(s_channels[0].alSource, 1, &buffer);
|
|
iterations++;
|
|
}
|
|
|
|
// Update paintedtime
|
|
s_paintedtime = s_rawend;
|
|
|
|
// Check that the Source is actually playing
|
|
alGetSourcei(s_channels[0].alSource, AL_SOURCE_STATE, &state);
|
|
if (state != AL_PLAYING)
|
|
{
|
|
// Stopped playing ... due to buffer underrun
|
|
// Unqueue any buffers still on the Source (they will be PROCESSED), and restart playback
|
|
alGetSourcei(s_channels[0].alSource, AL_BUFFERS_PROCESSED, &processed);
|
|
while (processed)
|
|
{
|
|
alSourceUnqueueBuffers(s_channels[0].alSource, 1, &buffer);
|
|
processed--;
|
|
alGetBufferi(buffer, AL_SIZE, &size);
|
|
alDeleteBuffers(1, &buffer);
|
|
|
|
// Update sg.soundtime (+= number of samples played (number of bytes / 4))
|
|
s_soundtime += (size >> 2);
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
OutputDebugString("Restarting / Starting playback of Raw Samples\n");
|
|
#endif
|
|
alSourcePlay(s_channels[0].alSource);
|
|
}
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
if (alGetError() != AL_NO_ERROR)
|
|
OutputDebugString("OAL Error : UpdateRawSamples\n");
|
|
#endif
|
|
}
|
|
|
|
|
|
int S_MP3PreProcessLipSync(channel_t *ch, short *data)
|
|
{
|
|
int i;
|
|
int sample;
|
|
int sampleTotal = 0;
|
|
|
|
for (i = 0; i < 576; i += 100)
|
|
{
|
|
sample = LittleShort(data[i]);
|
|
sample = sample >> 8;
|
|
sampleTotal += sample * sample;
|
|
}
|
|
|
|
sampleTotal /= 6;
|
|
|
|
if (sampleTotal < ch->thesfx->fVolRange * s_lip_threshold_1->value)
|
|
sample = -1;
|
|
else if (sampleTotal < ch->thesfx->fVolRange * s_lip_threshold_2->value)
|
|
sample = 1;
|
|
else if (sampleTotal < ch->thesfx->fVolRange * s_lip_threshold_3->value)
|
|
sample = 2;
|
|
else if (sampleTotal < ch->thesfx->fVolRange * s_lip_threshold_4->value)
|
|
sample = 3;
|
|
else
|
|
sample = 4;
|
|
|
|
return sample;
|
|
}
|
|
|
|
|
|
void S_SetLipSyncs()
|
|
{
|
|
int i;
|
|
int samples;
|
|
int currentTime, timePlayed;
|
|
channel_t *ch;
|
|
#ifdef _DEBUG
|
|
char szString[256];
|
|
#endif
|
|
|
|
memset(s_entityWavVol, 0, sizeof(s_entityWavVol));
|
|
|
|
ch = s_channels + 1;
|
|
for (i = 1; i < s_numChannels; i++, ch++)
|
|
{
|
|
if (!ch->thesfx)
|
|
continue;
|
|
|
|
if ( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
|
|
{
|
|
// Get current time
|
|
currentTime = Com_Milliseconds();
|
|
|
|
// Calculate how much time has passed since the sample was started
|
|
timePlayed = currentTime - ch->iStartTime;
|
|
|
|
if (ch->thesfx->eSoundCompressionMethod==ct_16)
|
|
{
|
|
// There is a new computed lip-sync value every 1000 samples - so find out how many samples
|
|
// have been played and lookup the value in the lip-sync table
|
|
samples = (timePlayed * 22050) / 1000;
|
|
|
|
if (ch->thesfx->lipSyncData == NULL)
|
|
{
|
|
#ifdef _DEBUG
|
|
sprintf(szString, "Missing lip-sync info. for %s\n", ch->thesfx->sSoundName);
|
|
OutputDebugString(szString);
|
|
#endif
|
|
}
|
|
|
|
if ((ch->thesfx->lipSyncData) && (samples < ch->thesfx->iSoundLengthInSamples))
|
|
{
|
|
s_entityWavVol[ ch->entnum ] = ch->thesfx->lipSyncData[samples / 1000];
|
|
if ( s_show->integer == 3 )
|
|
{
|
|
Com_Printf( "(%i)%i %s vol = %i\n", ch->entnum, i, ch->thesfx->sSoundName, s_entityWavVol[ ch->entnum ] );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// MP3
|
|
|
|
// There is a new computed lip-sync value every 576 samples - so find out how many samples
|
|
// have been played and lookup the value in the lip-sync table
|
|
samples = (timePlayed * 22050) / 1000;
|
|
|
|
if (ch->thesfx->lipSyncData == NULL)
|
|
{
|
|
#ifdef _DEBUG
|
|
sprintf(szString, "Missing lip-sync info. for %s\n", ch->thesfx->sSoundName);
|
|
OutputDebugString(szString);
|
|
#endif
|
|
}
|
|
|
|
if ((ch->thesfx->lipSyncData) && (samples < ch->thesfx->iSoundLengthInSamples))
|
|
{
|
|
s_entityWavVol[ ch->entnum ] = ch->thesfx->lipSyncData[(samples / 576) % 16];
|
|
if ( s_show->integer == 3 )
|
|
{
|
|
Com_Printf( "(%i)%i %s vol = %i\n", ch->entnum, i, ch->thesfx->sSoundName, s_entityWavVol[ ch->entnum ] );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
console functions
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
static void S_Play_f( void ) {
|
|
int i;
|
|
sfxHandle_t h;
|
|
char name[256];
|
|
|
|
i = 1;
|
|
while ( i<Cmd_Argc() ) {
|
|
if ( !strrchr(Cmd_Argv(i), '.') ) {
|
|
Com_sprintf( name, sizeof(name), "%s.wav", Cmd_Argv(1) );
|
|
} else {
|
|
Q_strncpyz( name, Cmd_Argv(i), sizeof(name) );
|
|
}
|
|
h = S_RegisterSound( name );
|
|
if( h ) {
|
|
S_StartLocalSound( h, CHAN_LOCAL_SOUND );
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
static void S_Music_f( void ) {
|
|
int c;
|
|
|
|
c = Cmd_Argc();
|
|
|
|
if ( c == 2 ) {
|
|
S_StartBackgroundTrack( Cmd_Argv(1), Cmd_Argv(1), qfalse );
|
|
} else if ( c == 3 ) {
|
|
S_StartBackgroundTrack( Cmd_Argv(1), Cmd_Argv(2), qfalse );
|
|
} else {
|
|
Com_Printf ("music <musicfile> [loopfile]\n");
|
|
return;
|
|
}
|
|
}
|
|
|
|
// a debug function, but no harm to leave in...
|
|
//
|
|
static void S_SetDynamicMusic_f(void)
|
|
{
|
|
int c = Cmd_Argc();
|
|
|
|
if ( c == 2 )
|
|
{
|
|
if (bMusic_IsDynamic)
|
|
{
|
|
// don't need to check existance of 'explore' or 'action' music, since music wouldn't
|
|
// be counted as dynamic if either were missing, but other types are optional...
|
|
//
|
|
if (!Q_stricmp(Cmd_Argv(1),"explore"))
|
|
{
|
|
S_SetDynamicMusicState( eBGRNDTRACK_EXPLORE );
|
|
return;
|
|
}
|
|
else
|
|
if (!Q_stricmp(Cmd_Argv(1),"action"))
|
|
{
|
|
S_SetDynamicMusicState( eBGRNDTRACK_ACTION );
|
|
return;
|
|
}
|
|
else
|
|
if (!Q_stricmp(Cmd_Argv(1),"silence"))
|
|
{
|
|
S_SetDynamicMusicState( eBGRNDTRACK_SILENCE );
|
|
return;
|
|
}
|
|
else
|
|
if (!Q_stricmp(Cmd_Argv(1),"boss"))
|
|
{
|
|
if (tMusic_Info[ eBGRNDTRACK_BOSS ].bExists)
|
|
{
|
|
S_SetDynamicMusicState( eBGRNDTRACK_BOSS );
|
|
}
|
|
else
|
|
{
|
|
Com_Printf("No 'boss' music defined in current dynamic set\n");
|
|
}
|
|
return;
|
|
}
|
|
else
|
|
if (!Q_stricmp(Cmd_Argv(1),"death"))
|
|
{
|
|
if (tMusic_Info[ eBGRNDTRACK_DEATH ].bExists)
|
|
{
|
|
S_SetDynamicMusicState( eBGRNDTRACK_DEATH );
|
|
}
|
|
else
|
|
{
|
|
Com_Printf("No 'death' music defined in current dynamic set\n");
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DynamicMusicInfoPrint(); // print "inactive" string
|
|
return;
|
|
}
|
|
}
|
|
|
|
// show usage...
|
|
//
|
|
Com_Printf("Usage: s_dynamic <explore/action/silence/boss/death>\n");
|
|
DynamicMusicInfoPrint();
|
|
}
|
|
|
|
|
|
// this table needs to be in-sync with the typedef'd enum "SoundCompressionMethod_t"... -ste
|
|
//
|
|
static const char *sSoundCompressionMethodStrings[ct_NUMBEROF] =
|
|
{
|
|
"16b", // ct_16
|
|
"mp3" // ct_MP3
|
|
};
|
|
void S_SoundList_f( void ) {
|
|
int i;
|
|
sfx_t *sfx;
|
|
int size, total;
|
|
int iVariantCap = -1; // for %d-inquiry stuff
|
|
int iTotalBytes = 0;
|
|
|
|
qboolean bWavOnly = qfalse;
|
|
qboolean bShouldBeMP3 = qfalse;
|
|
|
|
if ( Cmd_Argc() == 2 )
|
|
{
|
|
if (!stricmp(Cmd_Argv(1), "shouldbeMP3"))
|
|
{
|
|
bShouldBeMP3 = qtrue;
|
|
}
|
|
else
|
|
if (!stricmp(Cmd_Argv(1), "wavonly"))
|
|
{
|
|
bWavOnly = qtrue;
|
|
}
|
|
else
|
|
{
|
|
if (!stricmp(Cmd_Argv(1), "1"))
|
|
{
|
|
iVariantCap = 1;
|
|
}
|
|
else
|
|
if (!stricmp(Cmd_Argv(1), "2"))
|
|
{
|
|
iVariantCap = 2;
|
|
}
|
|
else
|
|
if (!stricmp(Cmd_Argv(1), "3"))
|
|
{
|
|
iVariantCap = 3;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Com_Printf("( additional (mutually exclusive) options available:\n'wavonly', 'ShouldBeMP3', '1'/'2'/'3' for %%d-variant capping )\n" );
|
|
}
|
|
|
|
|
|
|
|
total = 0;
|
|
|
|
Com_Printf("\n");
|
|
Com_Printf(" InMemory?\n");
|
|
Com_Printf(" |\n");
|
|
Com_Printf(" | LevelLastUsedOn\n");
|
|
Com_Printf(" | |\n");
|
|
Com_Printf(" | |\n");
|
|
Com_Printf(" Slot Smpls Type | | Name\n");
|
|
// Com_Printf(" Slot Smpls Type InMem? Name\n");
|
|
|
|
for (sfx=s_knownSfx, i=0 ; i<s_numSfx ; i++, sfx++)
|
|
{
|
|
extern cvar_t *cv_MP3overhead;
|
|
qboolean bMP3DumpOverride = bShouldBeMP3 && cv_MP3overhead && !sfx->bDefaultSound && !sfx->pMP3StreamHeader && sfx->pSoundData && (Z_Size(sfx->pSoundData) > cv_MP3overhead->integer);
|
|
|
|
if (bMP3DumpOverride || (!bShouldBeMP3 && (!bWavOnly || sfx->eSoundCompressionMethod == ct_16)))
|
|
{
|
|
qboolean bDumpThisOne = qtrue;
|
|
if (iVariantCap >= 1 && iVariantCap <= 3)
|
|
{
|
|
int iStrLen = strlen(sfx->sSoundName);
|
|
if (iStrLen > 2) // crash-safety, jic.
|
|
{
|
|
char c = sfx->sSoundName[iStrLen-1];
|
|
char c2 = sfx->sSoundName[iStrLen-2];
|
|
if (!isdigit(c2) // quick-avoid of stuff like "pain75"
|
|
&& isdigit(c) && atoi(va("%c",c)) > iVariantCap)
|
|
{
|
|
// need to see if this %d-variant should be omitted, in other words if there's a %1 version then skip this...
|
|
//
|
|
char sFindName[MAX_QPATH];
|
|
Q_strncpyz(sFindName,sfx->sSoundName,sizeof(sFindName));
|
|
sFindName[iStrLen-1] = '1';
|
|
int i2;
|
|
sfx_t *sfx2;
|
|
for (sfx2 = s_knownSfx, i2=0 ; i2<s_numSfx ; i2++, sfx2++)
|
|
{
|
|
if (!stricmp(sFindName,sfx2->sSoundName))
|
|
{
|
|
bDumpThisOne = qfalse; // found a %1-variant of this, so use variant capping and ignore this sfx_t
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
size = sfx->iSoundLengthInSamples;
|
|
if (sfx->bDefaultSound)
|
|
{
|
|
Com_Printf("%5d Missing file: \"%s\"\n", i, sfx->sSoundName );
|
|
}
|
|
else
|
|
{
|
|
if (bDumpThisOne)
|
|
{
|
|
iTotalBytes += (sfx->bInMemory && sfx->pSoundData) ? Z_Size(sfx->pSoundData) : 0;
|
|
iTotalBytes += (sfx->bInMemory && sfx->pMP3StreamHeader) ? sizeof(*sfx->pMP3StreamHeader) : 0;
|
|
total += sfx->bInMemory ? size : 0;
|
|
}
|
|
Com_Printf("%5d %7i [%s] %s %2d %s", i, size, sSoundCompressionMethodStrings[sfx->eSoundCompressionMethod], sfx->bInMemory?"y":"n", sfx->iLastLevelUsedOn, sfx->sSoundName );
|
|
|
|
if (!bDumpThisOne)
|
|
{
|
|
Com_Printf(" ( Skipping, variant capped )");
|
|
//OutputDebugString(va("Variant capped: %s\n",sfx->sSoundName));
|
|
}
|
|
Com_Printf("\n");
|
|
}
|
|
}
|
|
}
|
|
Com_Printf(" Slot Smpls Type In? Lev Name\n");
|
|
|
|
|
|
Com_Printf ("Total resident samples: %i %s ( not mem usage, see 'meminfo' ).\n", total, bWavOnly?"(WAV only)":"");
|
|
Com_Printf ("%d out of %d sfx_t slots used\n", s_numSfx, MAX_SFX);
|
|
Com_Printf ("%.2fMB bytes used when counting sfx_t->pSoundData + MP3 headers (if any)\n", (float)iTotalBytes / 1024.0f / 1024.0f);
|
|
S_DisplayFreeMemory();
|
|
}
|
|
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
background music functions
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
int FGetLittleLong( fileHandle_t f ) {
|
|
int v;
|
|
|
|
FS_Read( &v, sizeof(v), f );
|
|
|
|
return LittleLong( v);
|
|
}
|
|
|
|
int FGetLittleShort( fileHandle_t f ) {
|
|
short v;
|
|
|
|
FS_Read( &v, sizeof(v), f );
|
|
|
|
return LittleShort( v);
|
|
}
|
|
|
|
// returns the length of the data in the chunk, or 0 if not found
|
|
int S_FindWavChunk( fileHandle_t f, char *chunk ) {
|
|
char name[5];
|
|
int len;
|
|
int r;
|
|
|
|
name[4] = 0;
|
|
len = 0;
|
|
r = FS_Read( name, 4, f );
|
|
if ( r != 4 ) {
|
|
return 0;
|
|
}
|
|
len = FGetLittleLong( f );
|
|
if ( len < 0 || len > 0xfffffff ) {
|
|
len = 0;
|
|
return 0;
|
|
}
|
|
len = (len + 1 ) & ~1; // pad to word boundary
|
|
// s_nextWavChunk += len + 8;
|
|
|
|
if ( strcmp( name, chunk ) ) {
|
|
return 0;
|
|
}
|
|
return len;
|
|
}
|
|
|
|
// fixme: need to move this into qcommon sometime?, but too much stuff altered by other people and I won't be able
|
|
// to compile again for ages if I check that out...
|
|
//
|
|
// DO NOT replace this with a call to FS_FileExists, that's for checking about writing out, and doesn't work for this.
|
|
//
|
|
qboolean S_FileExists( const char *psFilename )
|
|
{
|
|
fileHandle_t fhTemp;
|
|
|
|
FS_FOpenFileRead (psFilename, &fhTemp, qtrue); // qtrue so I can fclose the handle without closing a PAK
|
|
if (!fhTemp)
|
|
return qfalse;
|
|
|
|
FS_FCloseFile(fhTemp);
|
|
return qtrue;
|
|
}
|
|
|
|
// some stuff for streaming MP3 files from disk (not pleasant, but nothing about MP3 is, other than compression ratios...)
|
|
//
|
|
static void MP3MusicStream_Reset(MusicInfo_t *pMusicInfo)
|
|
{
|
|
pMusicInfo->iMP3MusicStream_DiskReadPos = 0;
|
|
pMusicInfo->iMP3MusicStream_DiskWindowPos = 0;
|
|
}
|
|
|
|
//
|
|
// return is where the decoder should read from...
|
|
//
|
|
static byte *MP3MusicStream_ReadFromDisk(MusicInfo_t *pMusicInfo, int iReadOffset, int iReadBytesNeeded)
|
|
{
|
|
if (iReadOffset < pMusicInfo->iMP3MusicStream_DiskWindowPos)
|
|
{
|
|
assert(0); // should never happen
|
|
return pMusicInfo->byMP3MusicStream_DiskBuffer; // ...but return something safe anyway
|
|
}
|
|
|
|
while (iReadOffset + iReadBytesNeeded > pMusicInfo->iMP3MusicStream_DiskReadPos)
|
|
{
|
|
int iBytesRead = FS_Read( pMusicInfo->byMP3MusicStream_DiskBuffer + (pMusicInfo->iMP3MusicStream_DiskReadPos - pMusicInfo->iMP3MusicStream_DiskWindowPos), iMP3MusicStream_DiskBytesToRead, pMusicInfo->s_backgroundFile );
|
|
|
|
pMusicInfo->iMP3MusicStream_DiskReadPos += iBytesRead;
|
|
|
|
if (iBytesRead != iMP3MusicStream_DiskBytesToRead) // quietly ignore any requests to read past file end
|
|
{
|
|
break; // we need to do this because the disk read code can't know how much source data we need to
|
|
// read for a given number of requested output bytes, so we'll always be asking for too many
|
|
}
|
|
}
|
|
|
|
// if reached halfway point in buffer (approx 20k), backscroll it...
|
|
//
|
|
if (pMusicInfo->iMP3MusicStream_DiskReadPos - pMusicInfo->iMP3MusicStream_DiskWindowPos > iMP3MusicStream_DiskBufferSize/2)
|
|
{
|
|
int iMoveSrcOffset = iReadOffset - pMusicInfo->iMP3MusicStream_DiskWindowPos;
|
|
int iMoveCount = (pMusicInfo->iMP3MusicStream_DiskReadPos - pMusicInfo->iMP3MusicStream_DiskWindowPos ) - iMoveSrcOffset;
|
|
memmove( &pMusicInfo->byMP3MusicStream_DiskBuffer, &pMusicInfo->byMP3MusicStream_DiskBuffer[iMoveSrcOffset], iMoveCount);
|
|
pMusicInfo->iMP3MusicStream_DiskWindowPos += iMoveSrcOffset;
|
|
}
|
|
|
|
return pMusicInfo->byMP3MusicStream_DiskBuffer + (iReadOffset - pMusicInfo->iMP3MusicStream_DiskWindowPos);
|
|
}
|
|
|
|
|
|
// does NOT set s_rawend!...
|
|
//
|
|
static void S_StopBackgroundTrack_Actual( MusicInfo_t *pMusicInfo )
|
|
{
|
|
if ( pMusicInfo->s_backgroundFile )
|
|
{
|
|
if ( pMusicInfo->s_backgroundFile != -1)
|
|
{
|
|
Sys_EndStreamedFile( pMusicInfo->s_backgroundFile );
|
|
FS_FCloseFile( pMusicInfo->s_backgroundFile );
|
|
}
|
|
pMusicInfo->s_backgroundFile = 0;
|
|
}
|
|
}
|
|
|
|
static void FreeMusic( MusicInfo_t *pMusicInfo )
|
|
{
|
|
if (pMusicInfo->pLoadedData)
|
|
{
|
|
Z_Free(pMusicInfo->pLoadedData);
|
|
pMusicInfo->pLoadedData = NULL; // these two MUST be kept as valid/invalid together
|
|
pMusicInfo->sLoadedDataName[0]= '\0'; //
|
|
pMusicInfo->iLoadedDataLen = 0;
|
|
}
|
|
}
|
|
|
|
// called only by snd_shutdown (from snd_restart or app exit)
|
|
//
|
|
void S_UnCacheDynamicMusic( void )
|
|
{
|
|
for (int i = eBGRNDTRACK_DATABEGIN; i != eBGRNDTRACK_DATAEND; i++)
|
|
{
|
|
FreeMusic( &tMusic_Info[i]);
|
|
}
|
|
}
|
|
|
|
static qboolean S_StartBackgroundTrack_Actual( MusicInfo_t *pMusicInfo, qboolean qbDynamic, const char *intro, const char *loop )
|
|
{
|
|
int len;
|
|
char dump[16];
|
|
char name[MAX_QPATH];
|
|
|
|
Q_strncpyz( sMusic_BackgroundLoop, loop, sizeof( sMusic_BackgroundLoop ));
|
|
|
|
Q_strncpyz( name, intro, sizeof( name ) - 4 ); // this seems to be so that if the filename hasn't got an extension
|
|
// but doesn't have the room to append on either then you'll just
|
|
// get the "soft" fopen() error, rather than the ERR_DROP you'd get
|
|
// if COM_DefaultExtension didn't have room to add it on.
|
|
COM_DefaultExtension( name, sizeof( name ), ".mp3" );
|
|
|
|
// close the background track, but DON'T reset s_rawend (or remaining music bits that haven't been output yet will be cut off)
|
|
//
|
|
S_StopBackgroundTrack_Actual( pMusicInfo );
|
|
|
|
pMusicInfo->bIsMP3 = qfalse;
|
|
|
|
if ( !intro[0] ) {
|
|
return qfalse;
|
|
}
|
|
|
|
// new bit, if file requested is not same any loaded one (if prev was in-mem), ditch it...
|
|
//
|
|
if (Q_stricmp(name, pMusicInfo->sLoadedDataName))
|
|
{
|
|
FreeMusic( pMusicInfo );
|
|
}
|
|
|
|
if (!Q_stricmpn(name+(strlen(name)-4),".mp3",4))
|
|
{
|
|
if (pMusicInfo->pLoadedData)
|
|
{
|
|
pMusicInfo->s_backgroundFile = -1;
|
|
}
|
|
else
|
|
{
|
|
pMusicInfo->iLoadedDataLen = FS_FOpenFileRead( name, &pMusicInfo->s_backgroundFile, qtrue );
|
|
}
|
|
|
|
if (!pMusicInfo->s_backgroundFile)
|
|
{
|
|
Com_Printf( S_COLOR_RED"Couldn't open music file %s\n", name );
|
|
return qfalse;
|
|
}
|
|
|
|
MP3MusicStream_Reset( pMusicInfo );
|
|
|
|
byte *pbMP3DataSegment = NULL;
|
|
int iInitialMP3ReadSize = 8192; // fairly arbitrary, whatever size this is then the decoder is allowed to
|
|
// scan up to halfway of it to find floating headers, so don't make it
|
|
// too small. 8k works fine.
|
|
qboolean bMusicSucceeded = qfalse;
|
|
if (qbDynamic)
|
|
{
|
|
if (!pMusicInfo->pLoadedData)
|
|
{
|
|
pMusicInfo->pLoadedData = (byte *) Z_Malloc(pMusicInfo->iLoadedDataLen, TAG_SND_DYNAMICMUSIC, qfalse);
|
|
|
|
S_ClearSoundBuffer();
|
|
FS_Read(pMusicInfo->pLoadedData, pMusicInfo->iLoadedDataLen, pMusicInfo->s_backgroundFile);
|
|
Q_strncpyz(pMusicInfo->sLoadedDataName, name, sizeof(pMusicInfo->sLoadedDataName));
|
|
}
|
|
|
|
// enable the rest of the code to work as before...
|
|
//
|
|
pbMP3DataSegment = pMusicInfo->pLoadedData;
|
|
iInitialMP3ReadSize = pMusicInfo->iLoadedDataLen;
|
|
}
|
|
else
|
|
{
|
|
pbMP3DataSegment = MP3MusicStream_ReadFromDisk(pMusicInfo, 0, iInitialMP3ReadSize);
|
|
}
|
|
|
|
if (MP3_IsValid(name, pbMP3DataSegment, iInitialMP3ReadSize, qtrue /*bStereoDesired*/))
|
|
{
|
|
// init stream struct...
|
|
//
|
|
memset(&pMusicInfo->streamMP3_Bgrnd,0,sizeof(pMusicInfo->streamMP3_Bgrnd));
|
|
char *psError = C_MP3Stream_DecodeInit( &pMusicInfo->streamMP3_Bgrnd, pbMP3DataSegment, pMusicInfo->iLoadedDataLen,
|
|
dma.speed,
|
|
16, // sfx->width * 8,
|
|
qtrue // bStereoDesired
|
|
);
|
|
|
|
|
|
if (psError == NULL)
|
|
{
|
|
// init sfx struct & setup the few fields I actually need...
|
|
//
|
|
memset( &pMusicInfo->sfxMP3_Bgrnd,0,sizeof(pMusicInfo->sfxMP3_Bgrnd));
|
|
// pMusicInfo->sfxMP3_Bgrnd.width = 2; // read by MP3_GetSamples()
|
|
pMusicInfo->sfxMP3_Bgrnd.iSoundLengthInSamples = 0x7FFFFFFF; // max possible +ve int, since music finishes when decoder stops
|
|
pMusicInfo->sfxMP3_Bgrnd.pMP3StreamHeader = &pMusicInfo->streamMP3_Bgrnd;
|
|
Q_strncpyz( pMusicInfo->sfxMP3_Bgrnd.sSoundName, name, sizeof(pMusicInfo->sfxMP3_Bgrnd.sSoundName) );
|
|
|
|
if (qbDynamic)
|
|
{
|
|
MP3Stream_InitPlayingTimeFields ( &pMusicInfo->streamMP3_Bgrnd, name, pbMP3DataSegment, pMusicInfo->iLoadedDataLen, qtrue);
|
|
}
|
|
|
|
pMusicInfo->s_backgroundInfo.format = WAV_FORMAT_MP3; // not actually used this way, but just ensures we don't match one of the legit formats
|
|
pMusicInfo->s_backgroundInfo.channels = 2; // always, for our MP3s when used for music (else 1 for FX)
|
|
pMusicInfo->s_backgroundInfo.rate = dma.speed;
|
|
pMusicInfo->s_backgroundInfo.width = 2; // always, for our MP3s
|
|
pMusicInfo->s_backgroundInfo.samples = pMusicInfo->sfxMP3_Bgrnd.iSoundLengthInSamples;
|
|
pMusicInfo->s_backgroundSamples = pMusicInfo->sfxMP3_Bgrnd.iSoundLengthInSamples;
|
|
|
|
memset(&pMusicInfo->chMP3_Bgrnd,0,sizeof(pMusicInfo->chMP3_Bgrnd));
|
|
pMusicInfo->chMP3_Bgrnd.thesfx = &pMusicInfo->sfxMP3_Bgrnd;
|
|
memcpy(&pMusicInfo->chMP3_Bgrnd.MP3StreamHeader, pMusicInfo->sfxMP3_Bgrnd.pMP3StreamHeader, sizeof(*pMusicInfo->sfxMP3_Bgrnd.pMP3StreamHeader));
|
|
|
|
if (qbDynamic)
|
|
{
|
|
if (pMusicInfo->s_backgroundFile != -1)
|
|
{
|
|
FS_FCloseFile( pMusicInfo->s_backgroundFile );
|
|
pMusicInfo->s_backgroundFile = -1; // special mp3 value for "valid, but not a real file"
|
|
}
|
|
}
|
|
|
|
pMusicInfo->bIsMP3 = qtrue;
|
|
bMusicSucceeded = qtrue;
|
|
}
|
|
else
|
|
{
|
|
Com_Printf(S_COLOR_RED"Error streaming file %s: %s\n", name, psError);
|
|
if (pMusicInfo->s_backgroundFile != -1)
|
|
{
|
|
FS_FCloseFile( pMusicInfo->s_backgroundFile );
|
|
}
|
|
pMusicInfo->s_backgroundFile = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// MP3_IsValid() will already have printed any errors via Com_Printf at this point...
|
|
//
|
|
if (pMusicInfo->s_backgroundFile != -1)
|
|
{
|
|
FS_FCloseFile( pMusicInfo->s_backgroundFile );
|
|
}
|
|
pMusicInfo->s_backgroundFile = 0;
|
|
}
|
|
|
|
return bMusicSucceeded;
|
|
}
|
|
else // not an mp3 file
|
|
{
|
|
//
|
|
// open up a wav file and get all the info
|
|
//
|
|
FS_FOpenFileRead( name, &pMusicInfo->s_backgroundFile, qtrue );
|
|
if ( !pMusicInfo->s_backgroundFile ) {
|
|
Com_Printf( S_COLOR_YELLOW "WARNING: couldn't open music file %s\n", name );
|
|
return qfalse;
|
|
}
|
|
|
|
// skip the riff wav header
|
|
|
|
FS_Read(dump, 12, pMusicInfo->s_backgroundFile);
|
|
|
|
if ( !S_FindWavChunk( pMusicInfo->s_backgroundFile, "fmt " ) ) {
|
|
Com_Printf( S_COLOR_YELLOW "WARNING: No fmt chunk in %s\n", name );
|
|
FS_FCloseFile( pMusicInfo->s_backgroundFile );
|
|
pMusicInfo->s_backgroundFile = 0;
|
|
return qfalse;
|
|
}
|
|
|
|
// save name for soundinfo
|
|
pMusicInfo->s_backgroundInfo.format = FGetLittleShort( pMusicInfo->s_backgroundFile );
|
|
pMusicInfo->s_backgroundInfo.channels = FGetLittleShort( pMusicInfo->s_backgroundFile );
|
|
pMusicInfo->s_backgroundInfo.rate = FGetLittleLong( pMusicInfo->s_backgroundFile );
|
|
FGetLittleLong( pMusicInfo->s_backgroundFile );
|
|
FGetLittleShort( pMusicInfo->s_backgroundFile );
|
|
pMusicInfo->s_backgroundInfo.width = FGetLittleShort( pMusicInfo->s_backgroundFile ) / 8;
|
|
|
|
if ( pMusicInfo->s_backgroundInfo.format != WAV_FORMAT_PCM ) {
|
|
FS_FCloseFile( pMusicInfo->s_backgroundFile );
|
|
pMusicInfo->s_backgroundFile = 0;
|
|
Com_Printf(S_COLOR_YELLOW "WARNING: Not a microsoft PCM format wav: %s\n", name);
|
|
return qfalse;
|
|
}
|
|
|
|
if ( pMusicInfo->s_backgroundInfo.channels != 2 || pMusicInfo->s_backgroundInfo.rate != 22050 ) {
|
|
Com_Printf(S_COLOR_YELLOW "WARNING: music file %s is not 22k stereo\n", name );
|
|
}
|
|
|
|
if ( ( len = S_FindWavChunk( pMusicInfo->s_backgroundFile, "data" ) ) == 0 ) {
|
|
FS_FCloseFile( pMusicInfo->s_backgroundFile );
|
|
pMusicInfo->s_backgroundFile = 0;
|
|
Com_Printf(S_COLOR_YELLOW "WARNING: No data chunk in %s\n", name);
|
|
return qfalse;
|
|
}
|
|
|
|
pMusicInfo->s_backgroundInfo.samples = len / (pMusicInfo->s_backgroundInfo.width * pMusicInfo->s_backgroundInfo.channels);
|
|
|
|
pMusicInfo->s_backgroundSamples = pMusicInfo->s_backgroundInfo.samples;
|
|
|
|
//
|
|
// start the background streaming
|
|
//
|
|
Sys_BeginStreamedFile( pMusicInfo->s_backgroundFile, 0x10000 );
|
|
}
|
|
|
|
return qtrue;
|
|
}
|
|
|
|
|
|
static void S_SwitchDynamicTracks( MusicState_e eOldState, MusicState_e eNewState, qboolean bNewTrackStartsFullVolume )
|
|
{
|
|
// copy old track into fader...
|
|
//
|
|
tMusic_Info[ eBGRNDTRACK_FADE ] = tMusic_Info[ eOldState ];
|
|
// tMusic_Info[ eBGRNDTRACK_FADE ].bActive = qtrue; // inherent
|
|
// tMusic_Info[ eBGRNDTRACK_FADE ].bExists = qtrue; // inherent
|
|
tMusic_Info[ eBGRNDTRACK_FADE ].iXFadeVolumeSeekTime= Sys_Milliseconds();
|
|
tMusic_Info[ eBGRNDTRACK_FADE ].iXFadeVolumeSeekTo = 0;
|
|
//
|
|
// ... and deactivate...
|
|
//
|
|
tMusic_Info[ eOldState ].bActive = qfalse;
|
|
//
|
|
// set new track to either full volume or fade up...
|
|
//
|
|
tMusic_Info[eNewState].bActive = qtrue;
|
|
tMusic_Info[eNewState].iXFadeVolumeSeekTime = Sys_Milliseconds();
|
|
tMusic_Info[eNewState].iXFadeVolumeSeekTo = 255;
|
|
tMusic_Info[eNewState].iXFadeVolume = bNewTrackStartsFullVolume ? 255 : 0;
|
|
|
|
eMusic_StateActual = eNewState;
|
|
|
|
|
|
if (s_debugdynamic->integer)
|
|
{
|
|
LPCSTR psNewStateString = Music_BaseStateToString( eNewState, qtrue );
|
|
psNewStateString = psNewStateString?psNewStateString:"<unknown>";
|
|
|
|
Com_Printf( S_COLOR_MAGENTA "S_SwitchDynamicTracks( \"%s\" )\n", psNewStateString );
|
|
}
|
|
}
|
|
|
|
// called by both the config-string parser and the console-command state-changer...
|
|
//
|
|
// This either changes the music right now (copying track structures etc), or leaves the new state as pending
|
|
// so it gets picked up by the general music player if in a transition that can't be overridden...
|
|
//
|
|
static void S_SetDynamicMusicState( MusicState_e eNewState )
|
|
{
|
|
if (eMusic_StateRequest != eNewState)
|
|
{
|
|
eMusic_StateRequest = eNewState;
|
|
|
|
if (s_debugdynamic->integer)
|
|
{
|
|
LPCSTR psNewStateString = Music_BaseStateToString( eNewState, qtrue );
|
|
psNewStateString = psNewStateString?psNewStateString:"<unknown>";
|
|
|
|
Com_Printf( S_COLOR_MAGENTA "S_SetDynamicMusicState( Request: \"%s\" )\n", psNewStateString );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void S_HandleDynamicMusicStateChange( void )
|
|
{
|
|
if (eMusic_StateRequest != eMusic_StateActual)
|
|
{
|
|
// check whether or not the new request can be honoured, given what's currently playing...
|
|
//
|
|
if (Music_StateCanBeInterrupted( eMusic_StateActual, eMusic_StateRequest ))
|
|
{
|
|
LP_MP3STREAM pMP3StreamActual = &tMusic_Info[ eMusic_StateActual ].chMP3_Bgrnd.MP3StreamHeader;
|
|
|
|
switch (eMusic_StateRequest)
|
|
{
|
|
case eBGRNDTRACK_EXPLORE: // ... from action or silence
|
|
{
|
|
switch (eMusic_StateActual)
|
|
{
|
|
case eBGRNDTRACK_ACTION: // action->explore
|
|
{
|
|
// find the transition track to play, and the entry point for explore when we get there,
|
|
// and also see if we're at a permitted exit point to switch at all...
|
|
//
|
|
float fPlayingTimeElapsed = MP3Stream_GetPlayingTimeInSeconds( pMP3StreamActual ) - MP3Stream_GetRemainingTimeInSeconds( pMP3StreamActual );
|
|
|
|
// supply:
|
|
//
|
|
// playing point in float seconds
|
|
// enum of track being queried
|
|
//
|
|
// get:
|
|
//
|
|
// enum of transition track to switch to
|
|
// float time of entry point of new track *after* transition
|
|
|
|
MusicState_e eTransition;
|
|
float fNewTrackEntryTime = 0.0f;
|
|
if (Music_AllowedToTransition( fPlayingTimeElapsed, eBGRNDTRACK_ACTION, &eTransition, &fNewTrackEntryTime))
|
|
{
|
|
S_SwitchDynamicTracks( eMusic_StateActual, eTransition, qfalse ); // qboolean bNewTrackStartsFullVolume
|
|
|
|
tMusic_Info[eTransition].Rewind();
|
|
tMusic_Info[eTransition].bTrackSwitchPending = qtrue;
|
|
tMusic_Info[eTransition].eTS_NewState = eMusic_StateRequest;
|
|
tMusic_Info[eTransition].fTS_NewTime = fNewTrackEntryTime;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case eBGRNDTRACK_SILENCE: // silence->explore
|
|
{
|
|
S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qfalse ); // qboolean bNewTrackStartsFullVolume
|
|
|
|
// float fEntryTime = Music_GetRandomEntryTime( eMusic_StateRequest );
|
|
// tMusic_Info[ eMusic_StateRequest ].SeekTo(fEntryTime);
|
|
tMusic_Info[ eMusic_StateRequest ].Rewind();
|
|
}
|
|
break;
|
|
|
|
default: // trying to transition from some state I wasn't aware you could transition from (shouldn't happen), so ignore
|
|
{
|
|
assert(0);
|
|
S_SwitchDynamicTracks( eMusic_StateActual, eBGRNDTRACK_SILENCE, qfalse ); // qboolean bNewTrackStartsFullVolume
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case eBGRNDTRACK_SILENCE: // from explore or action
|
|
{
|
|
switch (eMusic_StateActual)
|
|
{
|
|
case eBGRNDTRACK_ACTION: // action->silence
|
|
case eBGRNDTRACK_EXPLORE: // explore->silence
|
|
{
|
|
// find the transition track to play, and the entry point for explore when we get there,
|
|
// and also see if we're at a permitted exit point to switch at all...
|
|
//
|
|
float fPlayingTimeElapsed = MP3Stream_GetPlayingTimeInSeconds( pMP3StreamActual ) - MP3Stream_GetRemainingTimeInSeconds( pMP3StreamActual );
|
|
|
|
MusicState_e eTransition;
|
|
float fNewTrackEntryTime = 0.0f;
|
|
if (Music_AllowedToTransition( fPlayingTimeElapsed, eMusic_StateActual, &eTransition, &fNewTrackEntryTime))
|
|
{
|
|
S_SwitchDynamicTracks( eMusic_StateActual, eTransition, qfalse ); // qboolean bNewTrackStartsFullVolume
|
|
|
|
tMusic_Info[eTransition].Rewind();
|
|
tMusic_Info[eTransition].bTrackSwitchPending = qtrue;
|
|
tMusic_Info[eTransition].eTS_NewState = eMusic_StateRequest;
|
|
tMusic_Info[eTransition].fTS_NewTime = 0.0f; //fNewTrackEntryTime; irrelevant when switching to silence
|
|
}
|
|
}
|
|
break;
|
|
|
|
default: // some unhandled type switching to silence
|
|
assert(0); // fall through since boss case just does silence->switch anyway
|
|
|
|
case eBGRNDTRACK_BOSS: // boss->silence
|
|
{
|
|
S_SwitchDynamicTracks( eMusic_StateActual, eBGRNDTRACK_SILENCE, qfalse ); // qboolean bNewTrackStartsFullVolume
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case eBGRNDTRACK_ACTION: // anything->action
|
|
{
|
|
switch (eMusic_StateActual)
|
|
{
|
|
case eBGRNDTRACK_SILENCE: // silence->action
|
|
{
|
|
S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qfalse ); // qboolean bNewTrackStartsFullVolume
|
|
tMusic_Info[ eMusic_StateRequest ].Rewind();
|
|
}
|
|
break;
|
|
|
|
default: // !silence->action
|
|
{
|
|
S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qtrue ); // qboolean bNewTrackStartsFullVolume
|
|
float fEntryTime = Music_GetRandomEntryTime( eMusic_StateRequest );
|
|
tMusic_Info[ eMusic_StateRequest ].SeekTo(fEntryTime);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case eBGRNDTRACK_BOSS:
|
|
{
|
|
S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qfalse ); // qboolean bNewTrackStartsFullVolume
|
|
//
|
|
// ( no need to fast forward or rewind, boss track is only entered into once, at start, and can't exit )
|
|
//
|
|
}
|
|
break;
|
|
|
|
case eBGRNDTRACK_DEATH:
|
|
{
|
|
S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qtrue ); // qboolean bNewTrackStartsFullVolume
|
|
//
|
|
// ( no need to fast forward or rewind, death track is only entered into once, at start, and can't exit or loop)
|
|
//
|
|
}
|
|
break;
|
|
|
|
default: assert(0); break; // unknown new mode request, so just ignore it
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static char gsIntroMusic[MAX_QPATH]={0};
|
|
static char gsLoopMusic [MAX_QPATH]={0};
|
|
|
|
void S_RestartMusic( void )
|
|
{
|
|
if (s_soundStarted && !s_soundMuted )
|
|
{
|
|
//if (gsIntroMusic[0] || gsLoopMusic[0]) // dont test this anymore (but still *use* them), they're blank for JK2 dynamic-music levels anyway
|
|
{
|
|
MusicState_e ePrevState = eMusic_StateRequest;
|
|
S_StartBackgroundTrack( gsIntroMusic, gsLoopMusic, qfalse ); // ( default music start will set the state to EXPLORE )
|
|
S_SetDynamicMusicState( ePrevState ); // restore to prev state
|
|
}
|
|
}
|
|
}
|
|
|
|
// Basic logic here is to see if the intro file specified actually exists, and if so, then it's not dynamic music,
|
|
// When called by the cgame start it loads up, then stops the playback (because of stutter issues), so that when the
|
|
// actual snapshot is received and the real play request is processed the data has already been loaded so will be quicker.
|
|
//
|
|
void S_StartBackgroundTrack( const char *intro, const char *loop, qboolean bCalledByCGameStart )
|
|
{
|
|
bMusic_IsDynamic = qfalse;
|
|
|
|
if (!s_soundStarted)
|
|
{ //we have no sound, so don't even bother trying
|
|
return;
|
|
}
|
|
|
|
if ( !intro ) {
|
|
intro = "";
|
|
}
|
|
if ( !loop || !loop[0] ) {
|
|
loop = intro;
|
|
}
|
|
|
|
Q_strncpyz(gsIntroMusic,intro, sizeof(gsIntroMusic));
|
|
Q_strncpyz(gsLoopMusic, loop, sizeof(gsLoopMusic));
|
|
|
|
char sName[MAX_QPATH];
|
|
Q_strncpyz(sName,intro,sizeof(sName));
|
|
|
|
COM_DefaultExtension( sName, sizeof( sName ), ".mp3" );
|
|
|
|
// if dynamic music not allowed, then just stream the explore music instead of playing dynamic...
|
|
//
|
|
if (!s_allowDynamicMusic->integer && Music_DynamicDataAvailable(intro)) // "intro", NOT "sName" (i.e. don't use version with ".mp3" extension)
|
|
{
|
|
LPCSTR psMusicName = Music_GetFileNameForState( eBGRNDTRACK_DATABEGIN );
|
|
if (psMusicName && S_FileExists( psMusicName ))
|
|
{
|
|
Q_strncpyz(sName,psMusicName,sizeof(sName));
|
|
}
|
|
}
|
|
|
|
// conceptually we always play the 'intro'[/sName] track, intro-to-loop transition is handled in UpdateBackGroundTrack().
|
|
//
|
|
if ( (strstr(sName,"/") && S_FileExists( sName )) ) // strstr() check avoids extra file-exists check at runtime if reverting from streamed music to dynamic since literal files all need at least one slash in their name (eg "music/blah")
|
|
{
|
|
Com_DPrintf("S_StartBackgroundTrack: Found/using non-dynamic music track '%s'\n", sName);
|
|
S_StartBackgroundTrack_Actual( &tMusic_Info[eBGRNDTRACK_NONDYNAMIC], bMusic_IsDynamic, sName, sName );
|
|
}
|
|
else
|
|
{
|
|
if (Music_DynamicDataAvailable(intro)) // "intro", NOT "sName" (i.e. don't use version with ".mp3" extension)
|
|
{
|
|
extern const char *Music_GetLevelSetName(void);
|
|
Q_strncpyz(sInfoOnly_CurrentDynamicMusicSet, Music_GetLevelSetName(), sizeof(sInfoOnly_CurrentDynamicMusicSet));
|
|
for (int i = eBGRNDTRACK_DATABEGIN; i != eBGRNDTRACK_DATAEND; i++)
|
|
{
|
|
qboolean bOk = qfalse;
|
|
LPCSTR psMusicName = Music_GetFileNameForState( (MusicState_e) i);
|
|
if (psMusicName && (!Q_stricmp(tMusic_Info[i].sLoadedDataName, psMusicName) || S_FileExists( psMusicName )) )
|
|
{
|
|
bOk = S_StartBackgroundTrack_Actual( &tMusic_Info[i], qtrue, psMusicName, loop );
|
|
}
|
|
|
|
tMusic_Info[i].bExists = bOk;
|
|
|
|
if (!tMusic_Info[i].bExists)
|
|
{
|
|
FreeMusic( &tMusic_Info[i] );
|
|
}
|
|
}
|
|
|
|
//
|
|
// default all tracks to OFF first (and set any other vars)
|
|
//
|
|
for (i=0; i<eBGRNDTRACK_NUMBEROF; i++)
|
|
{
|
|
tMusic_Info[i].bActive = qfalse;
|
|
tMusic_Info[i].bTrackSwitchPending = qfalse;
|
|
tMusic_Info[i].fSmoothedOutVolume = 0.25f;
|
|
}
|
|
|
|
if (tMusic_Info[eBGRNDTRACK_EXPLORE].bExists &&
|
|
tMusic_Info[eBGRNDTRACK_ACTION ].bExists
|
|
)
|
|
{
|
|
Com_DPrintf("S_StartBackgroundTrack: Found dynamic music tracks\n");
|
|
bMusic_IsDynamic = qtrue;
|
|
|
|
//
|
|
// ... then start the default music state...
|
|
//
|
|
eMusic_StateActual = eMusic_StateRequest = eBGRNDTRACK_EXPLORE;
|
|
|
|
MusicInfo_t *pMusicInfo = &tMusic_Info[ eMusic_StateActual ];
|
|
|
|
pMusicInfo->bActive = qtrue;
|
|
pMusicInfo->iXFadeVolumeSeekTime= Sys_Milliseconds();
|
|
pMusicInfo->iXFadeVolumeSeekTo = 255;
|
|
pMusicInfo->iXFadeVolume = 0;
|
|
|
|
//#ifdef _DEBUG
|
|
// float fRemaining = MP3Stream_GetPlayingTimeInSeconds( &pMusicInfo->chMP3_Bgrnd.MP3StreamHeader);
|
|
//#endif
|
|
}
|
|
else
|
|
{
|
|
Com_Printf( S_COLOR_RED "Dynamic music did not have both 'action' and 'explore' versions, inhibiting...\n");
|
|
S_StopBackgroundTrack();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (sName[0]!='.') // blank name with ".mp3" or whatever attached - no error print out
|
|
{
|
|
Com_Printf( S_COLOR_RED "Unable to find music \"%s\" as explicit track or dynamic music entry!\n",sName);
|
|
S_StopBackgroundTrack();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bCalledByCGameStart)
|
|
{
|
|
S_StopBackgroundTrack();
|
|
}
|
|
}
|
|
|
|
void S_StopBackgroundTrack( void )
|
|
{
|
|
for (int i=0; i<eBGRNDTRACK_NUMBEROF; i++)
|
|
{
|
|
S_StopBackgroundTrack_Actual( &tMusic_Info[i] );
|
|
}
|
|
|
|
s_rawend = 0;
|
|
}
|
|
|
|
|
|
|
|
// qboolean return is true only if we're changing from a streamed intro to a dynamic loop...
|
|
//
|
|
static qboolean S_UpdateBackgroundTrack_Actual( MusicInfo_t *pMusicInfo, qboolean bFirstOrOnlyMusicTrack, float fDefaultVolume)
|
|
{
|
|
int bufferSamples;
|
|
int fileSamples;
|
|
byte raw[30000]; // just enough to fit in a mac stack frame (note that MP3 doesn't use full size of it)
|
|
int fileBytes;
|
|
int r;
|
|
|
|
float fMasterVol = fDefaultVolume; // s_musicVolume->value;
|
|
|
|
if (bMusic_IsDynamic)
|
|
{
|
|
// step xfade volume...
|
|
//
|
|
if ( pMusicInfo->iXFadeVolume != pMusicInfo->iXFadeVolumeSeekTo )
|
|
{
|
|
int iFadeMillisecondsElapsed = Sys_Milliseconds() - pMusicInfo->iXFadeVolumeSeekTime;
|
|
|
|
if (iFadeMillisecondsElapsed > (fDYNAMIC_XFADE_SECONDS * 1000))
|
|
{
|
|
pMusicInfo->iXFadeVolume = pMusicInfo->iXFadeVolumeSeekTo;
|
|
}
|
|
else
|
|
{
|
|
pMusicInfo->iXFadeVolume = (int) (255.0f * ((float)iFadeMillisecondsElapsed/(fDYNAMIC_XFADE_SECONDS * 1000.0f)));
|
|
if (pMusicInfo->iXFadeVolumeSeekTo == 0) // bleurgh
|
|
pMusicInfo->iXFadeVolume = 255 - pMusicInfo->iXFadeVolume;
|
|
}
|
|
}
|
|
fMasterVol *= (float)((float)pMusicInfo->iXFadeVolume / 255.0f);
|
|
}
|
|
|
|
// this is to work around an obscure issue to do with sliding decoder windows and amounts being requested, since the
|
|
// original MP3 stream-decoder wrapper was designed to work with audio-paintbuffer sized pieces... Basically 30000
|
|
// is far too big for the window decoder to handle in one request because of the time-travel issue associated with
|
|
// normal sfx buffer painting, and allowing sufficient sliding room, even though the music file never goes back in time.
|
|
//
|
|
#define SIZEOF_RAW_BUFFER_FOR_MP3 4096
|
|
#define RAWSIZE (pMusicInfo->bIsMP3?SIZEOF_RAW_BUFFER_FOR_MP3:sizeof(raw))
|
|
|
|
if ( !pMusicInfo->s_backgroundFile ) {
|
|
return qfalse;
|
|
}
|
|
|
|
pMusicInfo->fSmoothedOutVolume = (pMusicInfo->fSmoothedOutVolume + fMasterVol)/2.0f;
|
|
// OutputDebugString(va("%f\n",pMusicInfo->fSmoothedOutVolume));
|
|
|
|
// don't bother playing anything if musicvolume is 0
|
|
if ( pMusicInfo->fSmoothedOutVolume <= 0 ) {
|
|
return qfalse;
|
|
}
|
|
|
|
// see how many samples should be copied into the raw buffer
|
|
if ( s_rawend < s_soundtime ) {
|
|
s_rawend = s_soundtime;
|
|
}
|
|
|
|
while ( s_rawend < s_soundtime + MAX_RAW_SAMPLES )
|
|
{
|
|
bufferSamples = MAX_RAW_SAMPLES - (s_rawend - s_soundtime);
|
|
|
|
// decide how much data needs to be read from the file
|
|
fileSamples = bufferSamples * pMusicInfo->s_backgroundInfo.rate / dma.speed;
|
|
|
|
// don't try and read past the end of the file
|
|
if ( fileSamples > pMusicInfo->s_backgroundSamples ) {
|
|
fileSamples = pMusicInfo->s_backgroundSamples;
|
|
}
|
|
|
|
// our max buffer size
|
|
fileBytes = fileSamples * (pMusicInfo->s_backgroundInfo.width * pMusicInfo->s_backgroundInfo.channels);
|
|
if (fileBytes > RAWSIZE ) {
|
|
fileBytes = RAWSIZE;
|
|
fileSamples = fileBytes / (pMusicInfo->s_backgroundInfo.width * pMusicInfo->s_backgroundInfo.channels);
|
|
}
|
|
|
|
qboolean qbForceFinish = qfalse;
|
|
if (pMusicInfo->bIsMP3)
|
|
{
|
|
int iStartingSampleNum = pMusicInfo->chMP3_Bgrnd.thesfx->iSoundLengthInSamples - pMusicInfo->s_backgroundSamples; // but this IS relevant
|
|
// Com_Printf(S_COLOR_YELLOW "Requesting MP3 samples: sample %d\n",iStartingSampleNum);
|
|
|
|
|
|
if (pMusicInfo->s_backgroundFile == -1)
|
|
{
|
|
// in-mem...
|
|
//
|
|
qbForceFinish = (MP3Stream_GetSamples( &pMusicInfo->chMP3_Bgrnd, iStartingSampleNum, fileBytes/2, (short*) raw, qtrue ))?qfalse:qtrue;
|
|
|
|
//Com_Printf(S_COLOR_YELLOW "Music time remaining: %f seconds\n", MP3Stream_GetRemainingTimeInSeconds( &pMusicInfo->chMP3_Bgrnd.MP3StreamHeader ));
|
|
}
|
|
else
|
|
{
|
|
// streaming an MP3 file instead... (note that the 'fileBytes' request size isn't that relevant for MP3s,
|
|
// since code here can't know how much the MP3 needs to decompress)
|
|
//
|
|
byte *pbScrolledStreamData = MP3MusicStream_ReadFromDisk(pMusicInfo, pMusicInfo->chMP3_Bgrnd.MP3StreamHeader.iSourceReadIndex, fileBytes);
|
|
|
|
pMusicInfo->chMP3_Bgrnd.MP3StreamHeader.pbSourceData = pbScrolledStreamData - pMusicInfo->chMP3_Bgrnd.MP3StreamHeader.iSourceReadIndex;
|
|
|
|
qbForceFinish = (MP3Stream_GetSamples( &pMusicInfo->chMP3_Bgrnd, iStartingSampleNum, fileBytes/2, (short*) raw, qtrue ))?qfalse:qtrue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// streaming a WAV off disk...
|
|
//
|
|
r = Sys_StreamedRead( raw, 1, fileBytes, pMusicInfo->s_backgroundFile );
|
|
if ( r != fileBytes ) {
|
|
Com_Printf(S_COLOR_RED"StreamedRead failure on music track\n");
|
|
S_StopBackgroundTrack();
|
|
return qfalse;
|
|
}
|
|
|
|
// byte swap if needed (do NOT do for MP3 decoder, that has an internal big/little endian handler)
|
|
//
|
|
S_ByteSwapRawSamples( fileSamples, pMusicInfo->s_backgroundInfo.width, pMusicInfo->s_backgroundInfo.channels, raw );
|
|
}
|
|
|
|
// add to raw buffer
|
|
S_RawSamples( fileSamples, pMusicInfo->s_backgroundInfo.rate,
|
|
pMusicInfo->s_backgroundInfo.width, pMusicInfo->s_backgroundInfo.channels, raw, pMusicInfo->fSmoothedOutVolume,
|
|
bFirstOrOnlyMusicTrack
|
|
);
|
|
|
|
pMusicInfo->s_backgroundSamples -= fileSamples;
|
|
if ( !pMusicInfo->s_backgroundSamples || qbForceFinish )
|
|
{
|
|
// loop the music, or play the next piece if we were on the intro...
|
|
// (but not for dynamic, that can only be used for loop music)
|
|
//
|
|
if (bMusic_IsDynamic) // needs special logic for this, different call
|
|
{
|
|
pMusicInfo->Rewind();
|
|
}
|
|
else
|
|
{
|
|
// for non-dynamic music we need to check if "sMusic_BackgroundLoop" is an actual filename,
|
|
// or if it's a dynamic music specifier (which can't literally exist), in which case it should set
|
|
// a return flag then exit...
|
|
//
|
|
char sTestName[MAX_QPATH*2];// *2 so COM_DefaultExtension doesn't do an ERR_DROP if there was no space
|
|
// for an extension, since this is a "soft" test
|
|
Q_strncpyz( sTestName, sMusic_BackgroundLoop, sizeof(sTestName));
|
|
COM_DefaultExtension(sTestName, sizeof(sTestName), ".mp3");
|
|
|
|
if (S_FileExists( sTestName ))
|
|
{
|
|
S_StartBackgroundTrack_Actual( pMusicInfo, qfalse, sMusic_BackgroundLoop, sMusic_BackgroundLoop );
|
|
}
|
|
else
|
|
{
|
|
// proposed file doesn't exist, but this may be a dynamic track we're wanting to loop,
|
|
// so exit with a special flag...
|
|
//
|
|
return qtrue;
|
|
}
|
|
}
|
|
if ( !pMusicInfo->s_backgroundFile )
|
|
{
|
|
return qfalse; // loop failed to restart
|
|
}
|
|
}
|
|
}
|
|
|
|
#undef SIZEOF_RAW_BUFFER_FOR_MP3
|
|
#undef RAWSIZE
|
|
|
|
return qfalse;
|
|
}
|
|
|
|
|
|
// used to be just for dynamic, but now even non-dynamic music has to know whether it should be silent or not...
|
|
//
|
|
static LPCSTR S_Music_GetRequestedState(void)
|
|
{
|
|
int iStringOffset = cl.gameState.stringOffsets[CS_DYNAMIC_MUSIC_STATE];
|
|
if (iStringOffset)
|
|
{
|
|
LPCSTR psCommand = cl.gameState.stringData+iStringOffset;
|
|
|
|
return psCommand;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
// scan the configstring to see if there's been a state-change requested...
|
|
// (note that even if the state doesn't change it still gets here, so do a same-state check for applying)
|
|
//
|
|
// then go on to do transition handling etc...
|
|
//
|
|
static void S_CheckDynamicMusicState(void)
|
|
{
|
|
LPCSTR psCommand = S_Music_GetRequestedState();
|
|
|
|
if (psCommand)
|
|
{
|
|
MusicState_e eNewState;
|
|
|
|
if ( !Q_stricmpn( psCommand, "silence", 7) )
|
|
{
|
|
eNewState = eBGRNDTRACK_SILENCE;
|
|
}
|
|
else if ( !Q_stricmpn( psCommand, "action", 6) )
|
|
{
|
|
eNewState = eBGRNDTRACK_ACTION;
|
|
}
|
|
else if ( !Q_stricmpn( psCommand, "boss", 4) )
|
|
{
|
|
// special case, boss music is optional and may not be defined...
|
|
//
|
|
if (tMusic_Info[ eBGRNDTRACK_BOSS ].bExists)
|
|
{
|
|
eNewState = eBGRNDTRACK_BOSS;
|
|
}
|
|
else
|
|
{
|
|
// ( leave it playing current track )
|
|
//
|
|
eNewState = eMusic_StateActual;
|
|
}
|
|
}
|
|
else if ( !Q_stricmpn( psCommand, "death", 5) )
|
|
{
|
|
// special case, death music is optional and may not be defined...
|
|
//
|
|
if (tMusic_Info[ eBGRNDTRACK_DEATH ].bExists)
|
|
{
|
|
eNewState = eBGRNDTRACK_DEATH;
|
|
}
|
|
else
|
|
{
|
|
// ( leave it playing current track, typically either boss or action )
|
|
//
|
|
eNewState = eMusic_StateActual;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// seems a reasonable default...
|
|
//
|
|
eNewState = eBGRNDTRACK_EXPLORE;
|
|
}
|
|
|
|
S_SetDynamicMusicState( eNewState );
|
|
}
|
|
|
|
S_HandleDynamicMusicStateChange();
|
|
}
|
|
|
|
static void S_UpdateBackgroundTrack( void )
|
|
{
|
|
if (bMusic_IsDynamic)
|
|
{
|
|
if (s_debugdynamic->integer == 2)
|
|
{
|
|
DynamicMusicInfoPrint();
|
|
}
|
|
|
|
S_CheckDynamicMusicState();
|
|
|
|
if (eMusic_StateActual != eBGRNDTRACK_SILENCE)
|
|
{
|
|
MusicInfo_t *pMusicInfoCurrent = &tMusic_Info[ (eMusic_StateActual == eBGRNDTRACK_FADE)?eBGRNDTRACK_EXPLORE:eMusic_StateActual ];
|
|
MusicInfo_t *pMusicInfoFadeOut = &tMusic_Info[ eBGRNDTRACK_FADE ];
|
|
|
|
if ( pMusicInfoCurrent->s_backgroundFile == -1)
|
|
{
|
|
int iRawEnd = s_rawend;
|
|
S_UpdateBackgroundTrack_Actual( pMusicInfoCurrent, qtrue, s_musicVolume->value );
|
|
|
|
/* static int iPrevFrontVol = 0;
|
|
if (iPrevFrontVol != pMusicInfoCurrent->iXFadeVolume)
|
|
{
|
|
iPrevFrontVol = pMusicInfoCurrent->iXFadeVolume;
|
|
Com_Printf("front vol = %d\n",pMusicInfoCurrent->iXFadeVolume);
|
|
}
|
|
*/
|
|
if (pMusicInfoFadeOut->bActive)
|
|
{
|
|
s_rawend = iRawEnd;
|
|
S_UpdateBackgroundTrack_Actual( pMusicInfoFadeOut, qfalse, s_musicVolume->value ); // inactive-checked internally
|
|
/*
|
|
static int iPrevFadeVol = 0;
|
|
if (iPrevFadeVol != pMusicInfoFadeOut->iXFadeVolume)
|
|
{
|
|
iPrevFadeVol = pMusicInfoFadeOut->iXFadeVolume;
|
|
Com_Printf("fade vol = %d\n",pMusicInfoFadeOut->iXFadeVolume);
|
|
}
|
|
*/
|
|
//
|
|
// only do this for the fader!...
|
|
//
|
|
if (pMusicInfoFadeOut->iXFadeVolume == 0)
|
|
{
|
|
pMusicInfoFadeOut->bActive = qfalse;
|
|
}
|
|
}
|
|
|
|
float fRemainingTimeInSeconds = MP3Stream_GetRemainingTimeInSeconds( &pMusicInfoCurrent->chMP3_Bgrnd.MP3StreamHeader );
|
|
// Com_Printf("Remaining: %3.3f\n",fRemainingTimeInSeconds);
|
|
|
|
if ( fRemainingTimeInSeconds < fDYNAMIC_XFADE_SECONDS*2 )
|
|
{
|
|
// now either loop current track, switch if finishing a transition, or stop if finished a death...
|
|
//
|
|
if (pMusicInfoCurrent->bTrackSwitchPending)
|
|
{
|
|
pMusicInfoCurrent->bTrackSwitchPending = qfalse; // ack
|
|
S_SwitchDynamicTracks( eMusic_StateActual, pMusicInfoCurrent->eTS_NewState, qfalse); // qboolean bNewTrackStartsFullVolume
|
|
if (tMusic_Info[ pMusicInfoCurrent->eTS_NewState ].bExists) // don't do this if switching to silence
|
|
{
|
|
tMusic_Info[ pMusicInfoCurrent->eTS_NewState ].SeekTo(pMusicInfoCurrent->fTS_NewTime);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// normal looping, so set rewind current track, set volume to 0 and fade up to full (unless death track playing, then stays quiet)
|
|
// (while fader copy of end-section fades down)
|
|
//
|
|
// copy current track to fader...
|
|
//
|
|
*pMusicInfoFadeOut = *pMusicInfoCurrent; // struct copy
|
|
pMusicInfoFadeOut->iXFadeVolumeSeekTime = Sys_Milliseconds();
|
|
pMusicInfoFadeOut->iXFadeVolumeSeekTo = 0;
|
|
//
|
|
pMusicInfoCurrent->Rewind();
|
|
pMusicInfoCurrent->iXFadeVolumeSeekTime = Sys_Milliseconds();
|
|
pMusicInfoCurrent->iXFadeVolumeSeekTo = (eMusic_StateActual == eBGRNDTRACK_DEATH) ? 0: 255;
|
|
pMusicInfoCurrent->iXFadeVolume = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// special case, when foreground music is shut off but fader still running to fade off previous track...
|
|
//
|
|
MusicInfo_t *pMusicInfoFadeOut = &tMusic_Info[ eBGRNDTRACK_FADE ];
|
|
if (pMusicInfoFadeOut->bActive)
|
|
{
|
|
S_UpdateBackgroundTrack_Actual( pMusicInfoFadeOut, qtrue, s_musicVolume->value );
|
|
if (pMusicInfoFadeOut->iXFadeVolume == 0)
|
|
{
|
|
pMusicInfoFadeOut->bActive = qfalse;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// standard / non-dynamic one-track music...
|
|
//
|
|
LPCSTR psCommand = S_Music_GetRequestedState(); // special check just for "silence" case...
|
|
qboolean bShouldBeSilent = (psCommand && !stricmp(psCommand,"silence"));
|
|
float fDesiredVolume = bShouldBeSilent ? 0.0f : s_musicVolume->value;
|
|
//
|
|
// internal to this code is a volume-smoother...
|
|
//
|
|
qboolean bNewTrackDesired = S_UpdateBackgroundTrack_Actual(&tMusic_Info[eBGRNDTRACK_NONDYNAMIC], qtrue, fDesiredVolume);
|
|
|
|
if (bNewTrackDesired)
|
|
{
|
|
S_StartBackgroundTrack( sMusic_BackgroundLoop, sMusic_BackgroundLoop, qfalse );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
cvar_t *s_soundpoolmegs = NULL;
|
|
|
|
|
|
// currently passing in sfx as a param in case I want to do something with it later.
|
|
//
|
|
byte *SND_malloc(int iSize, sfx_t *sfx)
|
|
{
|
|
byte *pData = (byte *) Z_Malloc(iSize, TAG_SND_RAWDATA, qfalse); // don't bother asking for zeroed mem
|
|
|
|
// if "s_soundpoolmegs" is < 0, then the -ve of the value is the maximum amount of sounds we're allowed to have loaded...
|
|
//
|
|
if (s_soundpoolmegs && s_soundpoolmegs->integer < 0)
|
|
{
|
|
while ( (Z_MemSize(TAG_SND_RAWDATA) + Z_MemSize(TAG_SND_MP3STREAMHDR)) > ((-s_soundpoolmegs->integer) * 1024 * 1024))
|
|
{
|
|
int iBytesFreed = SND_FreeOldestSound(sfx);
|
|
if (iBytesFreed == 0)
|
|
break; // sanity
|
|
}
|
|
}
|
|
|
|
return pData;
|
|
}
|
|
|
|
|
|
// called once-only in EXE lifetime...
|
|
//
|
|
void SND_setup()
|
|
{
|
|
s_soundpoolmegs = Cvar_Get("s_soundpoolmegs", "25", CVAR_ARCHIVE);
|
|
if (Sys_LowPhysicalMemory() )
|
|
{
|
|
Cvar_Set("s_soundpoolmegs", "0");
|
|
}
|
|
|
|
Com_Printf("Sound memory manager started\n");
|
|
}
|
|
|
|
|
|
// ask how much mem an sfx has allocated...
|
|
//
|
|
static int SND_MemUsed(sfx_t *sfx)
|
|
{
|
|
int iSize = 0;
|
|
if (sfx->pSoundData){
|
|
iSize += Z_Size(sfx->pSoundData);
|
|
}
|
|
|
|
if (sfx->pMP3StreamHeader) {
|
|
iSize += Z_Size(sfx->pMP3StreamHeader);
|
|
}
|
|
|
|
return iSize;
|
|
}
|
|
|
|
// free any allocated sfx mem...
|
|
//
|
|
// now returns # bytes freed to help with z_malloc()-fail recovery
|
|
//
|
|
static int SND_FreeSFXMem(sfx_t *sfx)
|
|
{
|
|
int iBytesFreed = 0;
|
|
|
|
if (s_UseOpenAL)
|
|
{
|
|
alGetError();
|
|
if (sfx->Buffer)
|
|
{
|
|
alDeleteBuffers(1, &(sfx->Buffer));
|
|
#ifdef _DEBUG
|
|
char szString[256];
|
|
if (alGetError() != AL_NO_ERROR)
|
|
{
|
|
sprintf(szString, "Failed to delete AL Buffer (%s) ... !\n", sfx->sSoundName);
|
|
OutputDebugString(szString);
|
|
}
|
|
#endif
|
|
sfx->Buffer = 0;
|
|
}
|
|
|
|
if (sfx->lipSyncData)
|
|
{
|
|
iBytesFreed += Z_Size( sfx->lipSyncData);
|
|
Z_Free( sfx->lipSyncData);
|
|
sfx->lipSyncData = NULL;
|
|
}
|
|
}
|
|
|
|
if ( sfx->pSoundData) {
|
|
iBytesFreed += Z_Size( sfx->pSoundData);
|
|
Z_Free( sfx->pSoundData );
|
|
sfx->pSoundData = NULL;
|
|
}
|
|
|
|
sfx->bInMemory = qfalse;
|
|
|
|
if ( sfx->pMP3StreamHeader) {
|
|
iBytesFreed += Z_Size( sfx->pMP3StreamHeader);
|
|
Z_Free( sfx->pMP3StreamHeader );
|
|
sfx->pMP3StreamHeader = NULL;
|
|
}
|
|
|
|
return iBytesFreed;
|
|
}
|
|
|
|
void S_DisplayFreeMemory()
|
|
{
|
|
int iSoundDataSize = Z_MemSize ( TAG_SND_RAWDATA ) + Z_MemSize( TAG_SND_MP3STREAMHDR );
|
|
int iMusicDataSize = Z_MemSize ( TAG_SND_DYNAMICMUSIC );
|
|
|
|
if (iSoundDataSize || iMusicDataSize)
|
|
{
|
|
Com_Printf("\n%.2fMB audio data: ( %.2fMB WAV/MP3 ) + ( %.2fMB Music )\n",
|
|
((float)(iSoundDataSize+iMusicDataSize))/1024.0f/1024.0f,
|
|
((float)(iSoundDataSize))/1024.0f/1024.0f,
|
|
((float)(iMusicDataSize))/1024.0f/1024.0f
|
|
);
|
|
|
|
// now count up amount used on this level...
|
|
//
|
|
iSoundDataSize = 0;
|
|
for (int i=1; i<s_numSfx; i++)
|
|
{
|
|
sfx_t *sfx = &s_knownSfx[i];
|
|
|
|
if (sfx->iLastLevelUsedOn == RE_RegisterMedia_GetLevel()){
|
|
iSoundDataSize += SND_MemUsed(sfx);
|
|
}
|
|
}
|
|
|
|
Com_Printf("%.2fMB in sfx_t alloc data (WAV/MP3) loaded this level\n",(float)iSoundDataSize/1024.0f/1024.0f);
|
|
}
|
|
}
|
|
|
|
void SND_TouchSFX(sfx_t *sfx)
|
|
{
|
|
sfx->iLastTimeUsed = Com_Milliseconds()+1;
|
|
sfx->iLastLevelUsedOn = RE_RegisterMedia_GetLevel();
|
|
}
|
|
|
|
|
|
// currently this is only called during snd_shutdown or snd_restart
|
|
//
|
|
void S_FreeAllSFXMem(void)
|
|
{
|
|
for (int i=1 ; i < s_numSfx ; i++) // start @ 1 to skip freeing default sound
|
|
{
|
|
SND_FreeSFXMem(&s_knownSfx[i]);
|
|
}
|
|
}
|
|
|
|
// returns number of bytes freed up...
|
|
//
|
|
// new param is so we can be usre of not freeing ourselves (without having to rely on possible uninitialised timers etc)
|
|
//
|
|
int SND_FreeOldestSound(sfx_t *pButNotThisOne /* = NULL */)
|
|
{
|
|
int iBytesFreed = 0;
|
|
sfx_t *sfx;
|
|
|
|
int iOldest = Com_Milliseconds();
|
|
int iUsed = 0;
|
|
|
|
// start on 1 so we never dump the default sound...
|
|
//
|
|
for (int i=1 ; i < s_numSfx ; i++)
|
|
{
|
|
sfx = &s_knownSfx[i];
|
|
|
|
if (sfx != pButNotThisOne)
|
|
{
|
|
if (!sfx->bDefaultSound && sfx->bInMemory && sfx->iLastTimeUsed < iOldest)
|
|
{
|
|
// new bit, we can't throw away any sfx_t struct in use by a channel, else the paint code will crash...
|
|
//
|
|
for (int iChannel=0; iChannel<MAX_CHANNELS; iChannel++)
|
|
{
|
|
channel_t *ch = & s_channels[iChannel];
|
|
|
|
if (ch->thesfx == sfx)
|
|
break; // damn, being used
|
|
}
|
|
if (iChannel == MAX_CHANNELS)
|
|
{
|
|
// this sfx_t struct wasn't used by any channels, so we can lose it...
|
|
//
|
|
iUsed = i;
|
|
iOldest = sfx->iLastTimeUsed;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (iUsed)
|
|
{
|
|
sfx = &s_knownSfx[ iUsed ];
|
|
|
|
Com_DPrintf("SND_FreeOldestSound: freeing sound %s\n", sfx->sSoundName);
|
|
|
|
iBytesFreed = SND_FreeSFXMem(sfx);
|
|
}
|
|
|
|
return iBytesFreed;
|
|
}
|
|
int SND_FreeOldestSound(void)
|
|
{
|
|
return SND_FreeOldestSound(NULL); // I had to add a void-arg version of this because of link issues, sigh
|
|
}
|
|
|
|
|
|
// just before we drop into a level, ensure the audio pool is under whatever the maximum
|
|
// pool size is (but not by dropping out sounds used by the current level)...
|
|
//
|
|
// returns qtrue if at least one sound was dropped out, so z_malloc-fail recovery code knows if anything changed
|
|
//
|
|
extern qboolean gbInsideLoadSound;
|
|
qboolean SND_RegisterAudio_LevelLoadEnd(qboolean bDeleteEverythingNotUsedThisLevel /* 99% qfalse */)
|
|
{
|
|
qboolean bAtLeastOneSoundDropped = qfalse;
|
|
|
|
Com_DPrintf( "SND_RegisterAudio_LevelLoadEnd():\n");
|
|
|
|
if (gbInsideLoadSound)
|
|
{
|
|
Com_DPrintf( "(Inside S_LoadSound (z_malloc recovery?), exiting...\n");
|
|
}
|
|
else
|
|
{
|
|
int iLoadedAudioBytes = Z_MemSize ( TAG_SND_RAWDATA ) + Z_MemSize( TAG_SND_MP3STREAMHDR );
|
|
const int iMaxAudioBytes = s_soundpoolmegs->integer * 1024 * 1024;
|
|
|
|
for (int i=1; i<s_numSfx && ( iLoadedAudioBytes > iMaxAudioBytes || bDeleteEverythingNotUsedThisLevel) ; i++) // i=1 so we never page out default sound
|
|
{
|
|
sfx_t *sfx = &s_knownSfx[i];
|
|
|
|
if (sfx->bInMemory)
|
|
{
|
|
qboolean bDeleteThis = qfalse;
|
|
|
|
if (bDeleteEverythingNotUsedThisLevel)
|
|
{
|
|
bDeleteThis = (sfx->iLastLevelUsedOn != RE_RegisterMedia_GetLevel());
|
|
}
|
|
else
|
|
{
|
|
bDeleteThis = (sfx->iLastLevelUsedOn < RE_RegisterMedia_GetLevel());
|
|
}
|
|
|
|
if (bDeleteThis)
|
|
{
|
|
Com_DPrintf( "Dumping sfx_t \"%s\"\n",sfx->sSoundName);
|
|
|
|
if (SND_FreeSFXMem(sfx))
|
|
{
|
|
bAtLeastOneSoundDropped = qtrue;
|
|
}
|
|
|
|
iLoadedAudioBytes = Z_MemSize ( TAG_SND_RAWDATA ) + Z_MemSize( TAG_SND_MP3STREAMHDR );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Com_DPrintf( "SND_RegisterAudio_LevelLoadEnd(): Ok\n");
|
|
|
|
return bAtLeastOneSoundDropped;
|
|
}
|
|
|
|
|
|
/****************************************************************************************************\
|
|
*
|
|
* EAX Related
|
|
*
|
|
\****************************************************************************************************/
|
|
|
|
/*
|
|
Initialize the EAX Manager
|
|
*/
|
|
void InitEAXManager()
|
|
{
|
|
LPEAXMANAGERCREATE lpEAXManagerCreateFn;
|
|
HRESULT hr;
|
|
|
|
// Check for EAX 3.0 support
|
|
s_bEAX = alIsExtensionPresent((ALubyte*)"EAX3.0");
|
|
if (s_bEAX)
|
|
{
|
|
s_eaxSet = (EAXSet)alGetProcAddress((ALubyte*)"EAXSet");
|
|
if (s_eaxSet == NULL)
|
|
s_bEAX = false;
|
|
s_eaxGet = (EAXGet)alGetProcAddress((ALubyte*)"EAXGet");
|
|
if (s_eaxGet == NULL)
|
|
s_bEAX = false;
|
|
}
|
|
|
|
// If we have detected EAX support, then try and load the EAX Manager DLL
|
|
if (s_bEAX)
|
|
{
|
|
s_hEAXManInst = LoadLibrary("EAXMan.dll");
|
|
if (s_hEAXManInst)
|
|
{
|
|
lpEAXManagerCreateFn = (LPEAXMANAGERCREATE)GetProcAddress(s_hEAXManInst, "EaxManagerCreate");
|
|
if (lpEAXManagerCreateFn)
|
|
{
|
|
hr = lpEAXManagerCreateFn(&s_lpEAXManager);
|
|
if (hr == EM_OK)
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the EAXManager library was loaded (and there was a problem), then unload it
|
|
if (s_hEAXManInst)
|
|
{
|
|
FreeLibrary(s_hEAXManInst);
|
|
s_hEAXManInst = NULL;
|
|
}
|
|
|
|
s_lpEAXManager = NULL;
|
|
s_bEAX = false;
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
Release the EAX Manager
|
|
*/
|
|
void ReleaseEAXManager()
|
|
{
|
|
s_bEAX = false;
|
|
if (s_lpEAXManager)
|
|
{
|
|
s_lpEAXManager->Release();
|
|
s_lpEAXManager = NULL;
|
|
}
|
|
if (s_hEAXManInst)
|
|
{
|
|
FreeLibrary(s_hEAXManInst);
|
|
s_hEAXManInst = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
Try to load the given .eal file
|
|
*/
|
|
bool LoadEALFile(char *szEALFilename)
|
|
{
|
|
char *ealData = NULL;
|
|
int result;
|
|
HRESULT hr;
|
|
|
|
if ((!s_lpEAXManager) || (!s_bEAX))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
s_EnvironmentID = 0xFFFFFFFF;
|
|
|
|
// Load EAL file from PAK file
|
|
result = FS_ReadFile(szEALFilename, (void **)&ealData);
|
|
|
|
if ((ealData) && (result != -1))
|
|
{
|
|
hr = s_lpEAXManager->LoadDataSet(ealData, EMFLAG_LOADFROMMEMORY);
|
|
|
|
// Unload EAL file
|
|
FS_FreeFile (ealData);
|
|
|
|
if (hr == EM_OK)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
Unload current .eal file
|
|
*/
|
|
void UnloadEALFile()
|
|
{
|
|
HRESULT hr;
|
|
|
|
if ((!s_lpEAXManager) || (!s_bEAX))
|
|
return;
|
|
|
|
hr = s_lpEAXManager->FreeDataSet(0);
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
Updates the current EAX Reverb setting, based on the location of the listener
|
|
*/
|
|
void UpdateEAXListener(bool bUseDefault, bool bUseMorphing)
|
|
{
|
|
HRESULT hr;
|
|
EMPOINT EMPoint;
|
|
long lID;
|
|
|
|
if ((!s_lpEAXManager) || (!s_bEAX))
|
|
return;
|
|
|
|
if (bUseDefault)
|
|
{
|
|
// Get Default EAX Listener attributes
|
|
hr = s_lpEAXManager->GetEnvironmentAttributes(EMFLAG_IDDEFAULT, &s_eaxLPSource);
|
|
if (hr == EM_OK)
|
|
{
|
|
s_eaxLPSource.flAirAbsorptionHF = 0.0f;
|
|
s_eaxSet(&DSPROPSETID_EAX_ListenerProperties, DSPROPERTY_EAXLISTENER_ALLPARAMETERS,
|
|
NULL, &s_eaxLPSource, sizeof(EAXLISTENERPROPERTIES));
|
|
|
|
s_eaxLPCur = s_eaxLPSource;
|
|
s_eaxLPDest = s_eaxLPSource;
|
|
|
|
s_EnvironmentID = EMFLAG_IDDEFAULT;
|
|
|
|
s_eaxMorphStartTime = 0;
|
|
s_eaxMorphCount = 0;
|
|
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Convert Listener co-ordinate to left-handed system
|
|
EMPoint.fX = listener_pos[0];
|
|
EMPoint.fY = listener_pos[1];
|
|
EMPoint.fZ = -listener_pos[2];
|
|
|
|
hr = s_lpEAXManager->GetListenerDynamicAttributes(0, &EMPoint, &lID, EMFLAG_LOCKPOSITION);
|
|
if (hr == EM_OK)
|
|
{
|
|
if (lID != s_EnvironmentID)
|
|
{
|
|
// Get EAX Preset info.
|
|
hr = s_lpEAXManager->GetEnvironmentAttributes(lID, &s_eaxLPDest);
|
|
s_eaxLPDest.flAirAbsorptionHF = 0.0f;
|
|
if (hr == EM_OK)
|
|
{
|
|
if (bUseMorphing)
|
|
{
|
|
// Morph to the new Destination from the Current Settings
|
|
s_eaxLPSource = s_eaxLPCur;
|
|
s_eaxMorphCount = 0;
|
|
s_eaxMorphStartTime = Com_Milliseconds();
|
|
s_eaxMorphing = true;
|
|
}
|
|
else
|
|
{
|
|
// Set Environment
|
|
s_eaxSet(&DSPROPSETID_EAX_ListenerProperties, DSPROPERTY_EAXLISTENER_ALLPARAMETERS,
|
|
NULL, &s_eaxLPDest, sizeof(EAXLISTENERPROPERTIES));
|
|
|
|
s_eaxLPSource = s_eaxLPCur = s_eaxLPDest;
|
|
s_eaxMorphing = false;
|
|
}
|
|
|
|
s_EnvironmentID = lID;
|
|
}
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
Updates the EAX Buffer related effects on the given Source
|
|
*/
|
|
void UpdateEAXBuffer(channel_t *ch)
|
|
{
|
|
HRESULT hr;
|
|
EMPOINT EMSourcePoint;
|
|
EMPOINT EMVirtualSourcePoint;
|
|
EAXOBSTRUCTIONPROPERTIES eaxOBProp;
|
|
EAXOCCLUSIONPROPERTIES eaxOCProp;
|
|
|
|
// If EAX Manager is not initialized, or there is no EAX support, or the listener
|
|
// is underwater, return
|
|
if ((!s_lpEAXManager) || (!s_bEAX) || (s_bInWater))
|
|
return;
|
|
|
|
// Set Occlusion Direct Ratio to the default value (it won't get set by the current version of
|
|
// EAX Manager)
|
|
eaxOCProp.flOcclusionDirectRatio = EAXBUFFER_DEFAULTOCCLUSIONDIRECTRATIO;
|
|
|
|
// Convert Source co-ordinate to left-handed system
|
|
if (ch->fixed_origin)
|
|
{
|
|
// Converting from Quake -> DS3D (for EAGLE) ... swap Y and Z
|
|
EMSourcePoint.fX = ch->origin[0];
|
|
EMSourcePoint.fY = ch->origin[2];
|
|
EMSourcePoint.fZ = ch->origin[1];
|
|
}
|
|
else
|
|
{
|
|
if (ch->entnum == listener_number)
|
|
{
|
|
// Source at same position as listener
|
|
// Probably won't be any Occlusion / Obstruction effect -- unless the listener is underwater
|
|
// Converting from Open AL -> DS3D (for EAGLE) ... invert Z
|
|
EMSourcePoint.fX = listener_pos[0];
|
|
EMSourcePoint.fY = listener_pos[1];
|
|
EMSourcePoint.fZ = -listener_pos[2];
|
|
}
|
|
else
|
|
{
|
|
// Get position of Entity
|
|
// Converting from Quake -> DS3D (for EAGLE) ... swap Y and Z
|
|
if (ch->bLooping)
|
|
{
|
|
EMSourcePoint.fX = loopSounds[ ch->entnum ].origin[0];
|
|
EMSourcePoint.fY = loopSounds[ ch->entnum ].origin[2];
|
|
EMSourcePoint.fZ = loopSounds[ ch->entnum ].origin[1];
|
|
}
|
|
else
|
|
{
|
|
EMSourcePoint.fX = s_entityPosition[ch->entnum][0];
|
|
EMSourcePoint.fY = s_entityPosition[ch->entnum][2];
|
|
EMSourcePoint.fZ = s_entityPosition[ch->entnum][1];
|
|
}
|
|
}
|
|
}
|
|
|
|
hr = s_lpEAXManager->GetSourceDynamicAttributes(0, &EMSourcePoint, &eaxOBProp.lObstruction, &eaxOBProp.flObstructionLFRatio,
|
|
&eaxOCProp.lOcclusion, &eaxOCProp.flOcclusionLFRatio, &eaxOCProp.flOcclusionRoomRatio, &EMVirtualSourcePoint, 0);
|
|
if (hr == EM_OK)
|
|
{
|
|
// Set EAX effect !
|
|
s_eaxSet(&DSPROPSETID_EAX_BufferProperties, DSPROPERTY_EAXBUFFER_OBSTRUCTIONPARAMETERS,
|
|
ch->alSource, &eaxOBProp, sizeof(EAXOBSTRUCTIONPROPERTIES));
|
|
|
|
s_eaxSet(&DSPROPSETID_EAX_BufferProperties, DSPROPERTY_EAXBUFFER_OCCLUSIONPARAMETERS,
|
|
ch->alSource, &eaxOCProp, sizeof(EAXOCCLUSIONPROPERTIES));
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
void EAXMorph()
|
|
{
|
|
int curPos;
|
|
int curTime;
|
|
float flRatio;
|
|
|
|
if ((!s_bEAX) || (!s_eaxMorphing))
|
|
return;
|
|
|
|
// Get current time
|
|
curTime = Com_Milliseconds();
|
|
|
|
curPos = ((curTime - s_eaxMorphStartTime) / 100);
|
|
|
|
if (curPos >= 10)
|
|
{
|
|
// Finished morphing
|
|
s_eaxMorphing = false;
|
|
s_eaxLPSource = s_eaxLPDest;
|
|
s_eaxLPCur = s_eaxLPDest;
|
|
|
|
s_eaxSet(&DSPROPSETID_EAX_ListenerProperties, DSPROPERTY_EAXLISTENER_ALLPARAMETERS,
|
|
NULL, &s_eaxLPSource, sizeof(EAXLISTENERPROPERTIES));
|
|
}
|
|
else
|
|
{
|
|
if (curPos > s_eaxMorphCount)
|
|
{
|
|
// Next morph step
|
|
flRatio = (float)curPos / 10.f;
|
|
|
|
EAX3ListenerInterpolate(&s_eaxLPSource, &s_eaxLPDest, flRatio, &s_eaxLPCur);
|
|
|
|
s_eaxSet(&DSPROPSETID_EAX_ListenerProperties, DSPROPERTY_EAXLISTENER_ALLPARAMETERS,
|
|
NULL, &s_eaxLPCur, sizeof(EAXLISTENERPROPERTIES));
|
|
|
|
s_eaxMorphCount = curPos;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************************************\
|
|
*
|
|
* Definition of the EAXMorph function - EAX3ListenerInterpolate
|
|
*
|
|
\***********************************************************************************************/
|
|
|
|
/*
|
|
EAX3ListenerInterpolate
|
|
lpStart - Initial EAX 3 Listener parameters
|
|
lpFinish - Final EAX 3 Listener parameters
|
|
flRatio - Ratio Destination : Source (0.0 == Source, 1.0 == Destination)
|
|
lpResult - Interpolated EAX 3 Listener parameters
|
|
bCheckValues - Check EAX 3.0 parameters are in range, default = false (no checking)
|
|
*/
|
|
bool EAX3ListenerInterpolate(LPEAXLISTENERPROPERTIES lpStart, LPEAXLISTENERPROPERTIES lpFinish,
|
|
float flRatio, LPEAXLISTENERPROPERTIES lpResult, bool bCheckValues)
|
|
{
|
|
EAXVECTOR StartVector, FinalVector;
|
|
|
|
float flInvRatio;
|
|
|
|
if (bCheckValues)
|
|
{
|
|
if (!CheckEAX3LP(lpStart))
|
|
return false;
|
|
|
|
if (!CheckEAX3LP(lpFinish))
|
|
return false;
|
|
}
|
|
|
|
if (flRatio >= 1.0f)
|
|
{
|
|
memcpy(lpResult, lpFinish, sizeof(EAXLISTENERPROPERTIES));
|
|
return true;
|
|
}
|
|
else if (flRatio <= 0.0f)
|
|
{
|
|
memcpy(lpResult, lpStart, sizeof(EAXLISTENERPROPERTIES));
|
|
return true;
|
|
}
|
|
|
|
flInvRatio = (1.0f - flRatio);
|
|
|
|
// Environment
|
|
lpResult->ulEnvironment = 26; // (UNDEFINED environment)
|
|
|
|
// Environment Size
|
|
if (lpStart->flEnvironmentSize == lpFinish->flEnvironmentSize)
|
|
lpResult->flEnvironmentSize = lpStart->flEnvironmentSize;
|
|
else
|
|
lpResult->flEnvironmentSize = (float)exp( (log(lpStart->flEnvironmentSize) * flInvRatio) + (log(lpFinish->flEnvironmentSize) * flRatio) );
|
|
|
|
// Environment Diffusion
|
|
if (lpStart->flEnvironmentDiffusion == lpFinish->flEnvironmentDiffusion)
|
|
lpResult->flEnvironmentDiffusion = lpStart->flEnvironmentDiffusion;
|
|
else
|
|
lpResult->flEnvironmentDiffusion = (lpStart->flEnvironmentDiffusion * flInvRatio) + (lpFinish->flEnvironmentDiffusion * flRatio);
|
|
|
|
// Room
|
|
if (lpStart->lRoom == lpFinish->lRoom)
|
|
lpResult->lRoom = lpStart->lRoom;
|
|
else
|
|
lpResult->lRoom = (int)( ((float)lpStart->lRoom * flInvRatio) + ((float)lpFinish->lRoom * flRatio) );
|
|
|
|
// Room HF
|
|
if (lpStart->lRoomHF == lpFinish->lRoomHF)
|
|
lpResult->lRoomHF = lpStart->lRoomHF;
|
|
else
|
|
lpResult->lRoomHF = (int)( ((float)lpStart->lRoomHF * flInvRatio) + ((float)lpFinish->lRoomHF * flRatio) );
|
|
|
|
// Room LF
|
|
if (lpStart->lRoomLF == lpFinish->lRoomLF)
|
|
lpResult->lRoomLF = lpStart->lRoomLF;
|
|
else
|
|
lpResult->lRoomLF = (int)( ((float)lpStart->lRoomLF * flInvRatio) + ((float)lpFinish->lRoomLF * flRatio) );
|
|
|
|
// Decay Time
|
|
if (lpStart->flDecayTime == lpFinish->flDecayTime)
|
|
lpResult->flDecayTime = lpStart->flDecayTime;
|
|
else
|
|
lpResult->flDecayTime = (float)exp( (log(lpStart->flDecayTime) * flInvRatio) + (log(lpFinish->flDecayTime) * flRatio) );
|
|
|
|
// Decay HF Ratio
|
|
if (lpStart->flDecayHFRatio == lpFinish->flDecayHFRatio)
|
|
lpResult->flDecayHFRatio = lpStart->flDecayHFRatio;
|
|
else
|
|
lpResult->flDecayHFRatio = (float)exp( (log(lpStart->flDecayHFRatio) * flInvRatio) + (log(lpFinish->flDecayHFRatio) * flRatio) );
|
|
|
|
// Decay LF Ratio
|
|
if (lpStart->flDecayLFRatio == lpFinish->flDecayLFRatio)
|
|
lpResult->flDecayLFRatio = lpStart->flDecayLFRatio;
|
|
else
|
|
lpResult->flDecayLFRatio = (float)exp( (log(lpStart->flDecayLFRatio) * flInvRatio) + (log(lpFinish->flDecayLFRatio) * flRatio) );
|
|
|
|
// Reflections
|
|
if (lpStart->lReflections == lpFinish->lReflections)
|
|
lpResult->lReflections = lpStart->lReflections;
|
|
else
|
|
lpResult->lReflections = (int)( ((float)lpStart->lReflections * flInvRatio) + ((float)lpFinish->lReflections * flRatio) );
|
|
|
|
// Reflections Delay
|
|
if (lpStart->flReflectionsDelay == lpFinish->flReflectionsDelay)
|
|
lpResult->flReflectionsDelay = lpStart->flReflectionsDelay;
|
|
else
|
|
lpResult->flReflectionsDelay = (float)exp( (log(lpStart->flReflectionsDelay+0.0001) * flInvRatio) + (log(lpFinish->flReflectionsDelay+0.0001) * flRatio) );
|
|
|
|
// Reflections Pan
|
|
|
|
// To interpolate the vector correctly we need to ensure that both the initial and final vectors vectors are clamped to a length of 1.0f
|
|
StartVector = lpStart->vReflectionsPan;
|
|
FinalVector = lpFinish->vReflectionsPan;
|
|
|
|
Clamp(&StartVector);
|
|
Clamp(&FinalVector);
|
|
|
|
if (lpStart->vReflectionsPan.x == lpFinish->vReflectionsPan.x)
|
|
lpResult->vReflectionsPan.x = lpStart->vReflectionsPan.x;
|
|
else
|
|
lpResult->vReflectionsPan.x = FinalVector.x + (flInvRatio * (StartVector.x - FinalVector.x));
|
|
|
|
if (lpStart->vReflectionsPan.y == lpFinish->vReflectionsPan.y)
|
|
lpResult->vReflectionsPan.y = lpStart->vReflectionsPan.y;
|
|
else
|
|
lpResult->vReflectionsPan.y = FinalVector.y + (flInvRatio * (StartVector.y - FinalVector.y));
|
|
|
|
if (lpStart->vReflectionsPan.z == lpFinish->vReflectionsPan.z)
|
|
lpResult->vReflectionsPan.z = lpStart->vReflectionsPan.z;
|
|
else
|
|
lpResult->vReflectionsPan.z = FinalVector.z + (flInvRatio * (StartVector.z - FinalVector.z));
|
|
|
|
// Reverb
|
|
if (lpStart->lReverb == lpFinish->lReverb)
|
|
lpResult->lReverb = lpStart->lReverb;
|
|
else
|
|
lpResult->lReverb = (int)( ((float)lpStart->lReverb * flInvRatio) + ((float)lpFinish->lReverb * flRatio) );
|
|
|
|
// Reverb Delay
|
|
if (lpStart->flReverbDelay == lpFinish->flReverbDelay)
|
|
lpResult->flReverbDelay = lpStart->flReverbDelay;
|
|
else
|
|
lpResult->flReverbDelay = (float)exp( (log(lpStart->flReverbDelay+0.0001) * flInvRatio) + (log(lpFinish->flReverbDelay+0.0001) * flRatio) );
|
|
|
|
// Reverb Pan
|
|
|
|
// To interpolate the vector correctly we need to ensure that both the initial and final vectors are clamped to a length of 1.0f
|
|
StartVector = lpStart->vReverbPan;
|
|
FinalVector = lpFinish->vReverbPan;
|
|
|
|
Clamp(&StartVector);
|
|
Clamp(&FinalVector);
|
|
|
|
if (lpStart->vReverbPan.x == lpFinish->vReverbPan.x)
|
|
lpResult->vReverbPan.x = lpStart->vReverbPan.x;
|
|
else
|
|
lpResult->vReverbPan.x = FinalVector.x + (flInvRatio * (StartVector.x - FinalVector.x));
|
|
|
|
if (lpStart->vReverbPan.y == lpFinish->vReverbPan.y)
|
|
lpResult->vReverbPan.y = lpStart->vReverbPan.y;
|
|
else
|
|
lpResult->vReverbPan.y = FinalVector.y + (flInvRatio * (StartVector.y - FinalVector.y));
|
|
|
|
if (lpStart->vReverbPan.z == lpFinish->vReverbPan.z)
|
|
lpResult->vReverbPan.z = lpStart->vReverbPan.z;
|
|
else
|
|
lpResult->vReverbPan.z = FinalVector.z + (flInvRatio * (StartVector.z - FinalVector.z));
|
|
|
|
// Echo Time
|
|
if (lpStart->flEchoTime == lpFinish->flEchoTime)
|
|
lpResult->flEchoTime = lpStart->flEchoTime;
|
|
else
|
|
lpResult->flEchoTime = (float)exp( (log(lpStart->flEchoTime) * flInvRatio) + (log(lpFinish->flEchoTime) * flRatio) );
|
|
|
|
// Echo Depth
|
|
if (lpStart->flEchoDepth == lpFinish->flEchoDepth)
|
|
lpResult->flEchoDepth = lpStart->flEchoDepth;
|
|
else
|
|
lpResult->flEchoDepth = (lpStart->flEchoDepth * flInvRatio) + (lpFinish->flEchoDepth * flRatio);
|
|
|
|
// Modulation Time
|
|
if (lpStart->flModulationTime == lpFinish->flModulationTime)
|
|
lpResult->flModulationTime = lpStart->flModulationTime;
|
|
else
|
|
lpResult->flModulationTime = (float)exp( (log(lpStart->flModulationTime) * flInvRatio) + (log(lpFinish->flModulationTime) * flRatio) );
|
|
|
|
// Modulation Depth
|
|
if (lpStart->flModulationDepth == lpFinish->flModulationDepth)
|
|
lpResult->flModulationDepth = lpStart->flModulationDepth;
|
|
else
|
|
lpResult->flModulationDepth = (lpStart->flModulationDepth * flInvRatio) + (lpFinish->flModulationDepth * flRatio);
|
|
|
|
// Air Absorption HF
|
|
if (lpStart->flAirAbsorptionHF == lpFinish->flAirAbsorptionHF)
|
|
lpResult->flAirAbsorptionHF = lpStart->flAirAbsorptionHF;
|
|
else
|
|
lpResult->flAirAbsorptionHF = (lpStart->flAirAbsorptionHF * flInvRatio) + (lpFinish->flAirAbsorptionHF * flRatio);
|
|
|
|
// HF Reference
|
|
if (lpStart->flHFReference == lpFinish->flHFReference)
|
|
lpResult->flHFReference = lpStart->flHFReference;
|
|
else
|
|
lpResult->flHFReference = (float)exp( (log(lpStart->flHFReference) * flInvRatio) + (log(lpFinish->flHFReference) * flRatio) );
|
|
|
|
// LF Reference
|
|
if (lpStart->flLFReference == lpFinish->flLFReference)
|
|
lpResult->flLFReference = lpStart->flLFReference;
|
|
else
|
|
lpResult->flLFReference = (float)exp( (log(lpStart->flLFReference) * flInvRatio) + (log(lpFinish->flLFReference) * flRatio) );
|
|
|
|
// Room Rolloff Factor
|
|
if (lpStart->flRoomRolloffFactor == lpFinish->flRoomRolloffFactor)
|
|
lpResult->flRoomRolloffFactor = lpStart->flRoomRolloffFactor;
|
|
else
|
|
lpResult->flRoomRolloffFactor = (lpStart->flRoomRolloffFactor * flInvRatio) + (lpFinish->flRoomRolloffFactor * flRatio);
|
|
|
|
// Flags
|
|
lpResult->ulFlags = (lpStart->ulFlags & lpFinish->ulFlags);
|
|
|
|
// Clamp Delays
|
|
if (lpResult->flReflectionsDelay > EAXLISTENER_MAXREFLECTIONSDELAY)
|
|
lpResult->flReflectionsDelay = EAXLISTENER_MAXREFLECTIONSDELAY;
|
|
|
|
if (lpResult->flReverbDelay > EAXLISTENER_MAXREVERBDELAY)
|
|
lpResult->flReverbDelay = EAXLISTENER_MAXREVERBDELAY;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/*
|
|
CheckEAX3LP
|
|
Checks that the parameters in the EAX 3 Listener Properties structure are in-range
|
|
*/
|
|
bool CheckEAX3LP(LPEAXLISTENERPROPERTIES lpEAX3LP)
|
|
{
|
|
if ( (lpEAX3LP->lRoom < EAXLISTENER_MINROOM) || (lpEAX3LP->lRoom > EAXLISTENER_MAXROOM) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->lRoomHF < EAXLISTENER_MINROOMHF) || (lpEAX3LP->lRoomHF > EAXLISTENER_MAXROOMHF) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->lRoomLF < EAXLISTENER_MINROOMLF) || (lpEAX3LP->lRoomLF > EAXLISTENER_MAXROOMLF) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->ulEnvironment < EAXLISTENER_MINENVIRONMENT) || (lpEAX3LP->ulEnvironment > EAXLISTENER_MAXENVIRONMENT) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->flEnvironmentSize < EAXLISTENER_MINENVIRONMENTSIZE) || (lpEAX3LP->flEnvironmentSize > EAXLISTENER_MAXENVIRONMENTSIZE) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->flEnvironmentDiffusion < EAXLISTENER_MINENVIRONMENTDIFFUSION) || (lpEAX3LP->flEnvironmentDiffusion > EAXLISTENER_MAXENVIRONMENTDIFFUSION) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->flDecayTime < EAXLISTENER_MINDECAYTIME) || (lpEAX3LP->flDecayTime > EAXLISTENER_MAXDECAYTIME) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->flDecayHFRatio < EAXLISTENER_MINDECAYHFRATIO) || (lpEAX3LP->flDecayHFRatio > EAXLISTENER_MAXDECAYHFRATIO) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->flDecayLFRatio < EAXLISTENER_MINDECAYLFRATIO) || (lpEAX3LP->flDecayLFRatio > EAXLISTENER_MAXDECAYLFRATIO) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->lReflections < EAXLISTENER_MINREFLECTIONS) || (lpEAX3LP->lReflections > EAXLISTENER_MAXREFLECTIONS) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->flReflectionsDelay < EAXLISTENER_MINREFLECTIONSDELAY) || (lpEAX3LP->flReflectionsDelay > EAXLISTENER_MAXREFLECTIONSDELAY) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->lReverb < EAXLISTENER_MINREVERB) || (lpEAX3LP->lReverb > EAXLISTENER_MAXREVERB) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->flReverbDelay < EAXLISTENER_MINREVERBDELAY) || (lpEAX3LP->flReverbDelay > EAXLISTENER_MAXREVERBDELAY) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->flEchoTime < EAXLISTENER_MINECHOTIME) || (lpEAX3LP->flEchoTime > EAXLISTENER_MAXECHOTIME) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->flEchoDepth < EAXLISTENER_MINECHODEPTH) || (lpEAX3LP->flEchoDepth > EAXLISTENER_MAXECHODEPTH) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->flModulationTime < EAXLISTENER_MINMODULATIONTIME) || (lpEAX3LP->flModulationTime > EAXLISTENER_MAXMODULATIONTIME) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->flModulationDepth < EAXLISTENER_MINMODULATIONDEPTH) || (lpEAX3LP->flModulationDepth > EAXLISTENER_MAXMODULATIONDEPTH) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->flAirAbsorptionHF < EAXLISTENER_MINAIRABSORPTIONHF) || (lpEAX3LP->flAirAbsorptionHF > EAXLISTENER_MAXAIRABSORPTIONHF) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->flHFReference < EAXLISTENER_MINHFREFERENCE) || (lpEAX3LP->flHFReference > EAXLISTENER_MAXHFREFERENCE) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->flLFReference < EAXLISTENER_MINLFREFERENCE) || (lpEAX3LP->flLFReference > EAXLISTENER_MAXLFREFERENCE) )
|
|
return false;
|
|
|
|
if ( (lpEAX3LP->flRoomRolloffFactor < EAXLISTENER_MINROOMROLLOFFFACTOR) || (lpEAX3LP->flRoomRolloffFactor > EAXLISTENER_MAXROOMROLLOFFFACTOR) )
|
|
return false;
|
|
|
|
if (lpEAX3LP->ulFlags & EAXLISTENERFLAGS_RESERVED)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
Clamp
|
|
Clamps the length of the vector to 1.0f
|
|
*/
|
|
void Clamp(EAXVECTOR *eaxVector)
|
|
{
|
|
float flMagnitude;
|
|
float flInvMagnitude;
|
|
|
|
flMagnitude = (float)sqrt((eaxVector->x*eaxVector->x) + (eaxVector->y*eaxVector->y) + (eaxVector->z*eaxVector->z));
|
|
|
|
if (flMagnitude <= 1.0f)
|
|
return;
|
|
|
|
flInvMagnitude = 1.0f / flMagnitude;
|
|
|
|
eaxVector->x *= flInvMagnitude;
|
|
eaxVector->y *= flInvMagnitude;
|
|
eaxVector->z *= flInvMagnitude;
|
|
}
|
|
|