ddnet/src/engine/client/sound.cpp

991 lines
21 KiB
C++
Raw Normal View History

2010-11-20 10:37:14 +00:00
/* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
/* If you are missing that file, acquire a complete release at teeworlds.com. */
#include <base/math.h>
2010-05-29 07:25:38 +00:00
#include <base/system.h>
2011-02-27 14:03:57 +00:00
#include <engine/graphics.h>
#include <engine/storage.h>
2010-05-29 07:25:38 +00:00
#include <engine/shared/config.h>
#include "SDL.h"
#include "sound.h"
extern "C" {
#if defined(CONF_VIDEORECORDER)
#include <engine/shared/video.h>
#endif
#include <opusfile.h>
#include <wavpack.h>
2010-05-29 07:25:38 +00:00
}
#include <math.h>
enum
{
NUM_SAMPLES = 512,
2014-10-29 23:14:16 +00:00
NUM_VOICES = 256,
2010-05-29 07:25:38 +00:00
NUM_CHANNELS = 16,
};
struct CSample
{
short *m_pData;
int m_NumFrames;
int m_Rate;
int m_Channels;
int m_LoopStart;
int m_LoopEnd;
int m_PausedAt;
2010-05-29 07:25:38 +00:00
};
struct CChannel
{
int m_Vol;
int m_Pan;
};
2010-05-29 07:25:38 +00:00
struct CVoice
{
CSample *m_pSample;
CChannel *m_pChannel;
2014-10-12 14:12:13 +00:00
int m_Age; // increases when reused
2010-05-29 07:25:38 +00:00
int m_Tick;
int m_Vol; // 0 - 255
int m_Flags;
int m_X, m_Y;
float m_Falloff; // [0.0, 1.0]
int m_Shape;
union
{
ISound::CVoiceShapeCircle m_Circle;
ISound::CVoiceShapeRectangle m_Rectangle;
};
};
2010-05-29 07:25:38 +00:00
static CSample m_aSamples[NUM_SAMPLES] = {{0}};
static CVoice m_aVoices[NUM_VOICES] = {{0}};
static CChannel m_aChannels[NUM_CHANNELS] = {{255, 0}};
2010-05-29 07:25:38 +00:00
static LOCK m_SoundLock = 0;
static int m_CenterX = 0;
static int m_CenterY = 0;
static int m_MixingRate = 48000;
static volatile int m_SoundVolume = 100;
static int m_NextVoice = 0;
static int *m_pMixBuffer = 0; // buffer only used by the thread callback function
static unsigned m_MaxFrames = 0;
2010-05-29 07:25:38 +00:00
static const void *s_pWVBuffer = 0x0;
static int s_WVBufferPosition = 0;
static int s_WVBufferSize = 0;
2014-10-11 12:50:16 +00:00
const int DefaultDistance = 1500;
2019-10-26 11:54:25 +00:00
int m_LastBreak = 0;
2010-05-29 07:25:38 +00:00
// TODO: there should be a faster way todo this
static short Int2Short(int i)
{
if(i > 0x7fff)
return 0x7fff;
else if(i < -0x7fff)
return -0x7fff;
return i;
}
static int IntAbs(int i)
{
if(i < 0)
2010-05-29 07:25:38 +00:00
return -i;
return i;
}
static void Mix(short *pFinalOut, unsigned Frames)
{
int MasterVol;
mem_zero(m_pMixBuffer, m_MaxFrames * 2 * sizeof(int));
2019-04-26 19:36:49 +00:00
Frames = minimum(Frames, m_MaxFrames);
2010-05-29 07:25:38 +00:00
2018-02-04 15:00:47 +00:00
// acquire lock while we are mixing
2010-05-29 07:25:38 +00:00
lock_wait(m_SoundLock);
2011-08-11 08:59:14 +00:00
2010-05-29 07:25:38 +00:00
MasterVol = m_SoundVolume;
2011-08-11 08:59:14 +00:00
2010-05-29 07:25:38 +00:00
for(unsigned i = 0; i < NUM_VOICES; i++)
{
if(m_aVoices[i].m_pSample)
{
// mix voice
CVoice *v = &m_aVoices[i];
int *pOut = m_pMixBuffer;
2010-05-29 07:25:38 +00:00
int Step = v->m_pSample->m_Channels; // setup input sources
short *pInL = &v->m_pSample->m_pData[v->m_Tick * Step];
short *pInR = &v->m_pSample->m_pData[v->m_Tick * Step + 1];
2011-08-11 08:59:14 +00:00
unsigned End = v->m_pSample->m_NumFrames - v->m_Tick;
2010-05-29 07:25:38 +00:00
int Rvol = (int)(v->m_pChannel->m_Vol * (v->m_Vol / 255.0f));
int Lvol = (int)(v->m_pChannel->m_Vol * (v->m_Vol / 255.0f));
2010-05-29 07:25:38 +00:00
// make sure that we don't go outside the sound data
if(Frames < End)
End = Frames;
2011-08-11 08:59:14 +00:00
2010-05-29 07:25:38 +00:00
// check if we have a mono sound
if(v->m_pSample->m_Channels == 1)
pInR = pInL;
// volume calculation
if(v->m_Flags & ISound::FLAG_POS && v->m_pChannel->m_Pan)
2010-05-29 07:25:38 +00:00
{
// TODO: we should respect the channel panning value
int dx = v->m_X - m_CenterX;
int dy = v->m_Y - m_CenterY;
//
2010-05-29 07:25:38 +00:00
int p = IntAbs(dx);
float FalloffX = 0.0f;
float FalloffY = 0.0f;
int RangeX = 0; // for panning
bool InVoiceField = false;
switch(v->m_Shape)
{
case ISound::SHAPE_CIRCLE:
{
float r = v->m_Circle.m_Radius;
RangeX = r;
int Dist = (int)sqrtf((float)dx * dx + dy * dy); // nasty float
if(Dist < r)
{
InVoiceField = true;
// falloff
int FalloffDistance = r * v->m_Falloff;
if(Dist > FalloffDistance)
FalloffX = FalloffY = (r - Dist) / (r - FalloffDistance);
else
FalloffX = FalloffY = 1.0f;
}
else
InVoiceField = false;
break;
}
case ISound::SHAPE_RECTANGLE:
{
RangeX = v->m_Rectangle.m_Width / 2.0f;
int abs_dx = abs(dx);
int abs_dy = abs(dy);
int w = v->m_Rectangle.m_Width / 2.0f;
int h = v->m_Rectangle.m_Height / 2.0f;
if(abs_dx < w && abs_dy < h)
{
InVoiceField = true;
// falloff
int fx = v->m_Falloff * w;
int fy = v->m_Falloff * h;
FalloffX = abs_dx > fx ? (float)(w - abs_dx) / (w - fx) : 1.0f;
FalloffY = abs_dy > fy ? (float)(h - abs_dy) / (h - fy) : 1.0f;
}
else
InVoiceField = false;
break;
}
};
if(InVoiceField)
2010-05-29 07:25:38 +00:00
{
// panning
if(!(v->m_Flags & ISound::FLAG_NO_PANNING))
{
if(dx > 0)
Lvol = ((RangeX - p) * Lvol) / RangeX;
else
Rvol = ((RangeX - p) * Rvol) / RangeX;
}
2011-08-11 08:59:14 +00:00
{
Lvol *= FalloffX * FalloffY;
Rvol *= FalloffX * FalloffY;
}
2010-05-29 07:25:38 +00:00
}
else
{
Lvol = 0;
Rvol = 0;
}
}
// process all frames
for(unsigned s = 0; s < End; s++)
{
*pOut++ += (*pInL) * Lvol;
*pOut++ += (*pInR) * Rvol;
2010-05-29 07:25:38 +00:00
pInL += Step;
pInR += Step;
v->m_Tick++;
}
2011-08-11 08:59:14 +00:00
2010-05-29 07:25:38 +00:00
// free voice if not used any more
if(v->m_Tick == v->m_pSample->m_NumFrames)
{
if(v->m_Flags & ISound::FLAG_LOOP)
v->m_Tick = 0;
else
2014-10-12 14:12:13 +00:00
{
v->m_pSample = 0;
2014-10-12 14:12:13 +00:00
v->m_Age++;
}
}
2010-05-29 07:25:38 +00:00
}
}
2011-08-11 08:59:14 +00:00
2010-05-29 07:25:38 +00:00
// release the lock
lock_unlock(m_SoundLock);
2010-05-29 07:25:38 +00:00
{
// clamp accumulated values
// TODO: this seams slow
for(unsigned i = 0; i < Frames; i++)
{
int j = i << 1;
int vl = ((m_pMixBuffer[j] * MasterVol) / 101) >> 8;
int vr = ((m_pMixBuffer[j + 1] * MasterVol) / 101) >> 8;
2010-05-29 07:25:38 +00:00
pFinalOut[j] = Int2Short(vl);
pFinalOut[j + 1] = Int2Short(vr);
// dbg_msg("sound", "the real shit: %d %d", pFinalOut[j], pFinalOut[j+1]);
2010-05-29 07:25:38 +00:00
}
}
#if defined(CONF_ARCH_ENDIAN_BIG)
swap_endian(pFinalOut, sizeof(short), Frames * 2);
#endif
}
static void SdlCallback(void *pUnused, Uint8 *pStream, int Len)
{
(void)pUnused;
2019-10-26 12:01:09 +00:00
#if defined(CONF_VIDEORECORDER)
if(!(IVideo::Current() && g_Config.m_ClVideoSndEnable))
Mix((short *)pStream, Len / 2 / 2);
else
IVideo::Current()->NextAudioFrame(Mix);
#else
Mix((short *)pStream, Len / 2 / 2);
2019-10-26 12:01:09 +00:00
#endif
2010-05-29 07:25:38 +00:00
}
int CSound::Init()
{
m_SoundEnabled = 0;
2010-05-29 07:25:38 +00:00
m_pGraphics = Kernel()->RequestInterface<IEngineGraphics>();
m_pStorage = Kernel()->RequestInterface<IStorage>();
2011-08-11 08:59:14 +00:00
2014-06-16 11:29:18 +00:00
SDL_AudioSpec Format, FormatOut;
2011-08-11 08:59:14 +00:00
2010-05-29 07:25:38 +00:00
m_SoundLock = lock_create();
2011-08-11 08:59:14 +00:00
2010-05-29 07:25:38 +00:00
if(!g_Config.m_SndEnable)
return 0;
2011-08-11 08:59:14 +00:00
if(SDL_InitSubSystem(SDL_INIT_AUDIO) < 0)
{
dbg_msg("gfx", "unable to init SDL audio: %s", SDL_GetError());
return -1;
}
2010-05-29 07:25:38 +00:00
m_MixingRate = g_Config.m_SndRate;
// Set 16-bit stereo audio at 22Khz
Format.freq = g_Config.m_SndRate; // ignore_convention
Format.format = AUDIO_S16; // ignore_convention
Format.channels = 2; // ignore_convention
Format.samples = g_Config.m_SndBufferSize; // ignore_convention
Format.callback = SdlCallback; // ignore_convention
Format.userdata = NULL; // ignore_convention
// Open the audio device and start playing sound!
m_Device = SDL_OpenAudioDevice(NULL, 0, &Format, &FormatOut, 0);
if(m_Device == 0)
2010-05-29 07:25:38 +00:00
{
dbg_msg("client/sound", "unable to open audio: %s", SDL_GetError());
return -1;
}
else
dbg_msg("client/sound", "sound init successful using audio driver '%s'", SDL_GetCurrentAudioDriver());
2010-05-29 07:25:38 +00:00
m_MaxFrames = FormatOut.samples * 2;
m_pMixBuffer = (int *)calloc(m_MaxFrames * 2, sizeof(int));
SDL_PauseAudioDevice(m_Device, 0);
2011-08-11 08:59:14 +00:00
2010-05-29 07:25:38 +00:00
m_SoundEnabled = 1;
Update(); // update the volume
return 0;
}
int CSound::Update()
{
// update volume
int WantedVolume = g_Config.m_SndVolume;
2011-08-11 08:59:14 +00:00
2010-05-29 07:25:38 +00:00
if(!m_pGraphics->WindowActive() && g_Config.m_SndNonactiveMute)
WantedVolume = 0;
2011-08-11 08:59:14 +00:00
2010-05-29 07:25:38 +00:00
if(WantedVolume != m_SoundVolume)
{
lock_wait(m_SoundLock);
m_SoundVolume = WantedVolume;
lock_unlock(m_SoundLock);
2010-05-29 07:25:38 +00:00
}
//#if defined(CONF_VIDEORECORDER)
// if(IVideo::Current() && g_Config.m_ClVideoSndEnable)
// IVideo::Current()->NextAudioFrame(Mix);
//#endif
2010-05-29 07:25:38 +00:00
return 0;
}
int CSound::Shutdown()
{
2017-07-21 14:37:23 +00:00
for(unsigned SampleID = 0; SampleID < NUM_SAMPLES; SampleID++)
{
UnloadSample(SampleID);
}
SDL_CloseAudioDevice(m_Device);
SDL_QuitSubSystem(SDL_INIT_AUDIO);
2010-05-29 07:25:38 +00:00
lock_destroy(m_SoundLock);
free(m_pMixBuffer);
2017-07-28 13:42:32 +00:00
m_pMixBuffer = 0;
2010-05-29 07:25:38 +00:00
return 0;
}
int CSound::AllocID()
2010-05-29 07:25:38 +00:00
{
// TODO: linear search, get rid of it
for(unsigned SampleID = 0; SampleID < NUM_SAMPLES; SampleID++)
2010-05-29 07:25:38 +00:00
{
if(m_aSamples[SampleID].m_pData == 0x0)
return SampleID;
2010-05-29 07:25:38 +00:00
}
return -1;
}
void CSound::RateConvert(int SampleID)
2010-05-29 07:25:38 +00:00
{
CSample *pSample = &m_aSamples[SampleID];
2010-05-29 07:25:38 +00:00
int NumFrames = 0;
short *pNewData = 0;
2011-08-11 08:59:14 +00:00
2010-05-29 07:25:38 +00:00
// make sure that we need to convert this sound
if(!pSample->m_pData || pSample->m_Rate == m_MixingRate)
return;
// allocate new data
NumFrames = (int)((pSample->m_NumFrames / (float)pSample->m_Rate) * m_MixingRate);
pNewData = (short *)calloc(NumFrames * pSample->m_Channels, sizeof(short));
2011-08-11 08:59:14 +00:00
2010-05-29 07:25:38 +00:00
for(int i = 0; i < NumFrames; i++)
{
2018-07-10 09:29:02 +00:00
// resample TODO: this should be done better, like linear at least
float a = i / (float)NumFrames;
int f = (int)(a * pSample->m_NumFrames);
2010-05-29 07:25:38 +00:00
if(f >= pSample->m_NumFrames)
f = pSample->m_NumFrames - 1;
2011-08-11 08:59:14 +00:00
2010-05-29 07:25:38 +00:00
// set new data
if(pSample->m_Channels == 1)
pNewData[i] = pSample->m_pData[f];
else if(pSample->m_Channels == 2)
{
pNewData[i * 2] = pSample->m_pData[f * 2];
pNewData[i * 2 + 1] = pSample->m_pData[f * 2 + 1];
2010-05-29 07:25:38 +00:00
}
}
2011-08-11 08:59:14 +00:00
2010-05-29 07:25:38 +00:00
// free old data and apply new
free(pSample->m_pData);
2010-05-29 07:25:38 +00:00
pSample->m_pData = pNewData;
pSample->m_NumFrames = NumFrames;
2014-10-18 13:21:13 +00:00
pSample->m_Rate = m_MixingRate;
2010-05-29 07:25:38 +00:00
}
int CSound::DecodeOpus(int SampleID, const void *pData, unsigned DataSize)
{
if(SampleID == -1 || SampleID >= NUM_SAMPLES)
return -1;
CSample *pSample = &m_aSamples[SampleID];
OggOpusFile *OpusFile = op_open_memory((const unsigned char *)pData, DataSize, NULL);
if(OpusFile)
{
int NumChannels = op_channel_count(OpusFile, -1);
2014-10-28 13:01:21 +00:00
int NumSamples = op_pcm_total(OpusFile, -1); // per channel!
pSample->m_Channels = NumChannels;
if(pSample->m_Channels > 2)
{
dbg_msg("sound/opus", "file is not mono or stereo.");
return -1;
}
pSample->m_pData = (short *)calloc(NumSamples * NumChannels, sizeof(short));
int Read;
int Pos = 0;
while(Pos < NumSamples)
{
Read = op_read(OpusFile, pSample->m_pData + Pos * NumChannels, NumSamples * NumChannels, NULL);
Pos += Read;
2014-10-28 13:01:21 +00:00
}
2014-10-28 13:01:21 +00:00
pSample->m_NumFrames = NumSamples; // ?
2014-10-28 11:22:49 +00:00
pSample->m_Rate = 48000;
pSample->m_LoopStart = -1;
pSample->m_LoopEnd = -1;
pSample->m_PausedAt = 0;
}
else
{
2014-10-28 21:42:31 +00:00
dbg_msg("sound/opus", "failed to decode sample");
return -1;
}
return SampleID;
}
static int ReadDataOld(void *pBuffer, int Size)
{
2019-04-26 19:36:49 +00:00
int ChunkSize = minimum(Size, s_WVBufferSize - s_WVBufferPosition);
mem_copy(pBuffer, (const char *)s_pWVBuffer + s_WVBufferPosition, ChunkSize);
s_WVBufferPosition += ChunkSize;
return ChunkSize;
}
2018-02-17 00:35:07 +00:00
#if defined(CONF_WAVPACK_OPEN_FILE_INPUT_EX)
static int ReadData(void *pId, void *pBuffer, int Size)
{
(void)pId;
return ReadDataOld(pBuffer, Size);
}
static int ReturnFalse(void *pId)
{
(void)pId;
return 0;
}
2018-02-17 00:35:07 +00:00
static unsigned int GetPos(void *pId)
{
(void)pId;
return s_WVBufferPosition;
}
2018-02-17 00:35:07 +00:00
static unsigned int GetLength(void *pId)
{
(void)pId;
return s_WVBufferSize;
}
static int PushBackByte(void *pId, int Char)
{
s_WVBufferPosition -= 1;
return 0;
}
#endif
2014-10-11 12:50:16 +00:00
int CSound::DecodeWV(int SampleID, const void *pData, unsigned DataSize)
2010-05-29 07:25:38 +00:00
{
2014-10-11 12:50:16 +00:00
if(SampleID == -1 || SampleID >= NUM_SAMPLES)
2010-05-29 07:25:38 +00:00
return -1;
2014-10-11 12:50:16 +00:00
CSample *pSample = &m_aSamples[SampleID];
char aError[100];
WavpackContext *pContext;
2010-05-29 07:25:38 +00:00
s_pWVBuffer = pData;
s_WVBufferSize = DataSize;
s_WVBufferPosition = 0;
2018-02-17 00:35:07 +00:00
#if defined(CONF_WAVPACK_OPEN_FILE_INPUT_EX)
WavpackStreamReader Callback = {0};
Callback.can_seek = ReturnFalse;
Callback.get_length = GetLength;
Callback.get_pos = GetPos;
Callback.push_back_byte = PushBackByte;
2018-02-17 00:35:07 +00:00
Callback.read_bytes = ReadData;
pContext = WavpackOpenFileInputEx(&Callback, (void *)1, 0, aError, 0, 0);
#else
pContext = WavpackOpenFileInput(ReadDataOld, aError);
#endif
if(pContext)
2010-05-29 07:25:38 +00:00
{
2014-10-11 12:50:16 +00:00
int NumSamples = WavpackGetNumSamples(pContext);
2010-05-29 07:25:38 +00:00
int BitsPerSample = WavpackGetBitsPerSample(pContext);
unsigned int SampleRate = WavpackGetSampleRate(pContext);
2014-10-11 12:50:16 +00:00
int NumChannels = WavpackGetNumChannels(pContext);
2010-05-29 07:25:38 +00:00
int *pSrc;
short *pDst;
int i;
2014-10-11 12:50:16 +00:00
pSample->m_Channels = NumChannels;
2010-05-29 07:25:38 +00:00
pSample->m_Rate = SampleRate;
if(pSample->m_Channels > 2)
{
2014-10-11 12:50:16 +00:00
dbg_msg("sound/wv", "file is not mono or stereo.");
2010-05-29 07:25:38 +00:00
return -1;
}
if(BitsPerSample != 16)
{
2014-10-11 12:50:16 +00:00
dbg_msg("sound/wv", "bps is %d, not 16", BitsPerSample);
2010-05-29 07:25:38 +00:00
return -1;
}
int *pBuffer = (int *)calloc(NumSamples * NumChannels, sizeof(int));
2014-10-11 12:50:16 +00:00
WavpackUnpackSamples(pContext, pBuffer, NumSamples); // TODO: check return value
pSrc = pBuffer;
2011-08-11 08:59:14 +00:00
pSample->m_pData = (short *)calloc(NumSamples * NumChannels, sizeof(short));
2010-05-29 07:25:38 +00:00
pDst = pSample->m_pData;
for(i = 0; i < NumSamples * NumChannels; i++)
2010-05-29 07:25:38 +00:00
*pDst++ = (short)*pSrc++;
free(pBuffer);
#ifdef CONF_WAVPACK_CLOSE_FILE
2020-04-09 10:08:38 +00:00
WavpackCloseFile(pContext);
2020-04-11 11:17:14 +00:00
#endif
2010-05-29 07:25:38 +00:00
2014-10-11 12:50:16 +00:00
pSample->m_NumFrames = NumSamples;
2010-05-29 07:25:38 +00:00
pSample->m_LoopStart = -1;
pSample->m_LoopEnd = -1;
pSample->m_PausedAt = 0;
2010-05-29 07:25:38 +00:00
}
else
{
2014-10-11 12:50:16 +00:00
dbg_msg("sound/wv", "failed to decode sample (%s)", aError);
2014-10-28 21:42:31 +00:00
return -1;
2010-05-29 07:25:38 +00:00
}
2014-10-11 12:50:16 +00:00
return SampleID;
}
int CSound::LoadOpus(const char *pFilename)
{
// don't waste memory on sound when we are stress testing
#ifdef CONF_DEBUG
if(g_Config.m_DbgStress)
return -1;
#endif
// no need to load sound when we are running with no sound
if(!m_SoundEnabled)
return -1;
if(!m_pStorage)
return -1;
IOHANDLE File = m_pStorage->OpenFile(pFilename, IOFLAG_READ, IStorage::TYPE_ALL);
if(!File)
{
dbg_msg("sound/opus", "failed to open file. filename='%s'", pFilename);
return -1;
}
int SampleID = AllocID();
int DataSize = io_length(File);
if(SampleID < 0 || DataSize <= 0)
{
io_close(File);
File = NULL;
dbg_msg("sound/opus", "failed to open file. filename='%s'", pFilename);
return -1;
}
// read the whole file into memory
char *pData = new char[DataSize];
io_read(File, pData, DataSize);
SampleID = DecodeOpus(SampleID, pData, DataSize);
delete[] pData;
io_close(File);
File = NULL;
if(g_Config.m_Debug)
dbg_msg("sound/opus", "loaded %s", pFilename);
RateConvert(SampleID);
return SampleID;
}
2014-10-11 12:50:16 +00:00
int CSound::LoadWV(const char *pFilename)
{
// don't waste memory on sound when we are stress testing
#ifdef CONF_DEBUG
2014-10-11 12:50:16 +00:00
if(g_Config.m_DbgStress)
return -1;
#endif
2014-10-11 12:50:16 +00:00
// no need to load sound when we are running with no sound
if(!m_SoundEnabled)
return -1;
if(!m_pStorage)
return -1;
IOHANDLE File = m_pStorage->OpenFile(pFilename, IOFLAG_READ, IStorage::TYPE_ALL);
if(!File)
2014-10-11 12:50:16 +00:00
{
dbg_msg("sound/wv", "failed to open file. filename='%s'", pFilename);
return -1;
}
int SampleID = AllocID();
int DataSize = io_length(File);
if(SampleID < 0 || DataSize <= 0)
2014-10-24 21:03:16 +00:00
{
io_close(File);
File = NULL;
2014-10-24 21:03:16 +00:00
dbg_msg("sound/wv", "failed to open file. filename='%s'", pFilename);
return -1;
}
// read the whole file into memory
2014-10-11 12:50:16 +00:00
char *pData = new char[DataSize];
io_read(File, pData, DataSize);
2014-10-11 12:50:16 +00:00
SampleID = DecodeWV(SampleID, pData, DataSize);
delete[] pData;
io_close(File);
File = NULL;
2010-05-29 07:25:38 +00:00
if(g_Config.m_Debug)
dbg_msg("sound/wv", "loaded %s", pFilename);
RateConvert(SampleID);
return SampleID;
2010-05-29 07:25:38 +00:00
}
int CSound::LoadOpusFromMem(const void *pData, unsigned DataSize, bool FromEditor = false)
{
// don't waste memory on sound when we are stress testing
#ifdef CONF_DEBUG
if(g_Config.m_DbgStress)
return -1;
#endif
// no need to load sound when we are running with no sound
if(!m_SoundEnabled && !FromEditor)
return -1;
if(!pData)
return -1;
int SampleID = AllocID();
if(SampleID < 0)
return -1;
SampleID = DecodeOpus(SampleID, pData, DataSize);
RateConvert(SampleID);
return SampleID;
}
int CSound::LoadWVFromMem(const void *pData, unsigned DataSize, bool FromEditor = false)
2014-10-11 12:50:16 +00:00
{
// don't waste memory on sound when we are stress testing
#ifdef CONF_DEBUG
2014-10-11 12:50:16 +00:00
if(g_Config.m_DbgStress)
return -1;
#endif
2014-10-11 12:50:16 +00:00
// no need to load sound when we are running with no sound
if(!m_SoundEnabled && !FromEditor)
2014-10-11 12:50:16 +00:00
return -1;
if(!pData)
return -1;
int SampleID = AllocID();
if(SampleID < 0)
return -1;
SampleID = DecodeWV(SampleID, pData, DataSize);
RateConvert(SampleID);
return SampleID;
}
2014-10-11 11:38:08 +00:00
void CSound::UnloadSample(int SampleID)
{
if(SampleID == -1 || SampleID >= NUM_SAMPLES)
return;
Stop(SampleID);
free(m_aSamples[SampleID].m_pData);
2014-10-11 11:38:08 +00:00
m_aSamples[SampleID].m_pData = 0x0;
}
float CSound::GetSampleDuration(int SampleID)
{
if(SampleID == -1 || SampleID >= NUM_SAMPLES)
return 0.0f;
return (m_aSamples[SampleID].m_NumFrames / m_aSamples[SampleID].m_Rate);
}
2010-05-29 07:25:38 +00:00
void CSound::SetListenerPos(float x, float y)
{
m_CenterX = (int)x;
m_CenterY = (int)y;
}
2014-10-12 14:12:13 +00:00
void CSound::SetVoiceVolume(CVoiceHandle Voice, float Volume)
{
2014-10-12 14:12:13 +00:00
if(!Voice.IsValid())
return;
int VoiceID = Voice.Id();
if(m_aVoices[VoiceID].m_Age != Voice.Age())
return;
Volume = clamp(Volume, 0.0f, 1.0f);
m_aVoices[VoiceID].m_Vol = (int)(Volume * 255.0f);
}
void CSound::SetVoiceFalloff(CVoiceHandle Voice, float Falloff)
{
if(!Voice.IsValid())
return;
int VoiceID = Voice.Id();
if(m_aVoices[VoiceID].m_Age != Voice.Age())
return;
Falloff = clamp(Falloff, 0.0f, 1.0f);
m_aVoices[VoiceID].m_Falloff = Falloff;
}
2014-10-12 14:12:13 +00:00
void CSound::SetVoiceLocation(CVoiceHandle Voice, float x, float y)
{
if(!Voice.IsValid())
return;
int VoiceID = Voice.Id();
if(m_aVoices[VoiceID].m_Age != Voice.Age())
return;
m_aVoices[VoiceID].m_X = x;
m_aVoices[VoiceID].m_Y = y;
}
2014-10-18 13:21:13 +00:00
void CSound::SetVoiceTimeOffset(CVoiceHandle Voice, float offset)
{
if(!Voice.IsValid())
return;
int VoiceID = Voice.Id();
if(m_aVoices[VoiceID].m_Age != Voice.Age())
return;
lock_wait(m_SoundLock);
{
if(m_aVoices[VoiceID].m_pSample)
{
int Tick = 0;
bool IsLooping = m_aVoices[VoiceID].m_Flags & ISound::FLAG_LOOP;
uint64 TickOffset = m_aVoices[VoiceID].m_pSample->m_Rate * offset;
if(m_aVoices[VoiceID].m_pSample->m_NumFrames > 0 && IsLooping)
Tick = TickOffset % m_aVoices[VoiceID].m_pSample->m_NumFrames;
2014-10-18 13:21:13 +00:00
else
Tick = clamp(TickOffset, (uint64)0, (uint64)m_aVoices[VoiceID].m_pSample->m_NumFrames);
2014-10-18 13:21:13 +00:00
// at least 200msec off, else depend on buffer size
2019-04-26 19:36:49 +00:00
float Threshold = maximum(0.2f * m_aVoices[VoiceID].m_pSample->m_Rate, (float)m_MaxFrames);
if(abs(m_aVoices[VoiceID].m_Tick - Tick) > Threshold)
2014-11-14 23:13:20 +00:00
{
// take care of looping (modulo!)
if(!(IsLooping && (minimum(m_aVoices[VoiceID].m_Tick, Tick) + m_aVoices[VoiceID].m_pSample->m_NumFrames - maximum(m_aVoices[VoiceID].m_Tick, Tick)) <= Threshold))
{
m_aVoices[VoiceID].m_Tick = Tick;
}
2014-11-14 23:13:20 +00:00
}
2014-10-18 13:21:13 +00:00
}
}
lock_unlock(m_SoundLock);
2014-10-18 13:21:13 +00:00
}
void CSound::SetVoiceCircle(CVoiceHandle Voice, float Radius)
{
if(!Voice.IsValid())
return;
int VoiceID = Voice.Id();
if(m_aVoices[VoiceID].m_Age != Voice.Age())
return;
m_aVoices[VoiceID].m_Shape = ISound::SHAPE_CIRCLE;
2019-04-26 19:36:49 +00:00
m_aVoices[VoiceID].m_Circle.m_Radius = maximum(0.0f, Radius);
}
void CSound::SetVoiceRectangle(CVoiceHandle Voice, float Width, float Height)
{
if(!Voice.IsValid())
return;
int VoiceID = Voice.Id();
if(m_aVoices[VoiceID].m_Age != Voice.Age())
return;
m_aVoices[VoiceID].m_Shape = ISound::SHAPE_RECTANGLE;
2019-04-26 19:36:49 +00:00
m_aVoices[VoiceID].m_Rectangle.m_Width = maximum(0.0f, Width);
m_aVoices[VoiceID].m_Rectangle.m_Height = maximum(0.0f, Height);
}
void CSound::SetChannel(int ChannelID, float Vol, float Pan)
2010-05-29 07:25:38 +00:00
{
m_aChannels[ChannelID].m_Vol = (int)(Vol * 255.0f);
m_aChannels[ChannelID].m_Pan = (int)(Pan * 255.0f); // TODO: this is only on and off right now
2010-05-29 07:25:38 +00:00
}
2014-10-12 14:12:13 +00:00
ISound::CVoiceHandle CSound::Play(int ChannelID, int SampleID, int Flags, float x, float y)
2010-05-29 07:25:38 +00:00
{
int VoiceID = -1;
2014-10-12 14:12:13 +00:00
int Age = -1;
2010-05-29 07:25:38 +00:00
int i;
2011-08-11 08:59:14 +00:00
2010-05-29 07:25:38 +00:00
lock_wait(m_SoundLock);
2011-08-11 08:59:14 +00:00
2010-05-29 07:25:38 +00:00
// search for voice
for(i = 0; i < NUM_VOICES; i++)
{
int id = (m_NextVoice + i) % NUM_VOICES;
if(!m_aVoices[id].m_pSample)
{
VoiceID = id;
m_NextVoice = id + 1;
2010-05-29 07:25:38 +00:00
break;
}
}
2011-08-11 08:59:14 +00:00
2010-05-29 07:25:38 +00:00
// voice found, use it
if(VoiceID != -1)
2010-05-29 07:25:38 +00:00
{
m_aVoices[VoiceID].m_pSample = &m_aSamples[SampleID];
m_aVoices[VoiceID].m_pChannel = &m_aChannels[ChannelID];
if(Flags & FLAG_LOOP)
m_aVoices[VoiceID].m_Tick = m_aSamples[SampleID].m_PausedAt;
else
m_aVoices[VoiceID].m_Tick = 0;
m_aVoices[VoiceID].m_Vol = 255;
m_aVoices[VoiceID].m_Flags = Flags;
m_aVoices[VoiceID].m_X = (int)x;
m_aVoices[VoiceID].m_Y = (int)y;
m_aVoices[VoiceID].m_Falloff = 0.0f;
m_aVoices[VoiceID].m_Shape = ISound::SHAPE_CIRCLE;
m_aVoices[VoiceID].m_Circle.m_Radius = DefaultDistance;
2014-10-12 14:12:13 +00:00
Age = m_aVoices[VoiceID].m_Age;
2010-05-29 07:25:38 +00:00
}
2011-08-11 08:59:14 +00:00
lock_unlock(m_SoundLock);
2014-10-12 14:12:13 +00:00
return CreateVoiceHandle(VoiceID, Age);
2010-05-29 07:25:38 +00:00
}
2014-10-12 14:12:13 +00:00
ISound::CVoiceHandle CSound::PlayAt(int ChannelID, int SampleID, int Flags, float x, float y)
2010-05-29 07:25:38 +00:00
{
return Play(ChannelID, SampleID, Flags | ISound::FLAG_POS, x, y);
2010-05-29 07:25:38 +00:00
}
2014-10-12 14:12:13 +00:00
ISound::CVoiceHandle CSound::Play(int ChannelID, int SampleID, int Flags)
2010-05-29 07:25:38 +00:00
{
return Play(ChannelID, SampleID, Flags, 0, 0);
2010-05-29 07:25:38 +00:00
}
void CSound::Stop(int SampleID)
2010-05-29 07:25:38 +00:00
{
// TODO: a nice fade out
lock_wait(m_SoundLock);
CSample *pSample = &m_aSamples[SampleID];
for(int i = 0; i < NUM_VOICES; i++)
{
if(m_aVoices[i].m_pSample == pSample)
{
if(m_aVoices[i].m_Flags & FLAG_LOOP)
m_aVoices[i].m_pSample->m_PausedAt = m_aVoices[i].m_Tick;
else
m_aVoices[i].m_pSample->m_PausedAt = 0;
m_aVoices[i].m_pSample = 0;
}
}
lock_unlock(m_SoundLock);
2010-05-29 07:25:38 +00:00
}
void CSound::StopAll()
{
// TODO: a nice fade out
lock_wait(m_SoundLock);
for(int i = 0; i < NUM_VOICES; i++)
{
if(m_aVoices[i].m_pSample)
{
if(m_aVoices[i].m_Flags & FLAG_LOOP)
m_aVoices[i].m_pSample->m_PausedAt = m_aVoices[i].m_Tick;
else
m_aVoices[i].m_pSample->m_PausedAt = 0;
}
2010-05-29 07:25:38 +00:00
m_aVoices[i].m_pSample = 0;
}
lock_unlock(m_SoundLock);
2010-05-29 07:25:38 +00:00
}
2014-10-18 13:21:13 +00:00
void CSound::StopVoice(CVoiceHandle Voice)
{
if(!Voice.IsValid())
return;
int VoiceID = Voice.Id();
if(m_aVoices[VoiceID].m_Age != Voice.Age())
return;
lock_wait(m_SoundLock);
{
m_aVoices[VoiceID].m_pSample = 0;
m_aVoices[VoiceID].m_Age++;
}
lock_unlock(m_SoundLock);
2014-10-18 13:21:13 +00:00
}
2010-05-29 07:25:38 +00:00
IEngineSound *CreateEngineSound() { return new CSound; }