void SoundManager::poll()
{
static ticks_t lastUpdate = 0;
ticks_t now = g_clock.millis();
if(now - lastUpdate < POLL_DELAY)
return;
lastUpdate = now;
ensureContext();
for(auto it = m_sources.begin(); it != m_sources.end();) {
SoundSourcePtr source = *it;
source->update();
if(!source->isPlaying())
it = m_sources.erase(it);
else
++it;
}
for(auto it : m_channels) {
it.second->update();
}
if(m_context) {
alcProcessContext(m_context);
}
}
GAudio::~GAudio()
{
// clean the device
Clean();
// push any pending data to the hardware
if(mContext) alcProcessContext(mContext);
// free all of the channels
if(mChannels){GDELETE([]mChannels), mChannels = NULL;}
// destroy the context
if(mContext)
{
alcDestroyContext(mContext);
mContext = NULL;
}
// close the device
if(mDevice)
{
alcCloseDevice(mDevice);
mDevice = NULL;
}
}
void AudioDevice::resume()
{
if (audioContext) {
alcMakeContextCurrent(audioContext);
alcProcessContext(audioContext);
}
}
void
SoundManager::update()
{
if (!sound_enabled)
return;
// check for finished sound sources
for(SoundSources::iterator i = sources.begin(); i != sources.end(); ) {
SoundSource* source = *i;
if(!source->playing()) {
delete source;
i = sources.erase(i);
} else {
++i;
}
}
// check streaming sounds
if(music_source) {
music_source->update();
}
if(next_music_source && (!music_source || !music_source->playing())) {
delete music_source;
music_source = next_music_source;
//music_source->setFading(StreamSoundSource::FadingOn, 1.0f);
music_source->play();
next_music_source = 0;
}
alcProcessContext(context);
check_alc_error("Error while processing audio context: ");
}
ALAPI ALvoid ALAPIENTRY alSourceStop(ALuint source)
{
ALCcontext *Context;
ALsource *Source;
ALbufferlistitem *ALBufferListItem;
Context=alcGetCurrentContext();
alcSuspendContext(Context);
if (alIsSource(source))
{
Source=((ALsource *)source);
if (Source->state!=AL_INITIAL)
{
Source->state=AL_STOPPED;
Source->inuse=AL_FALSE;
Source->BuffersProcessed = Source->BuffersInQueue;
ALBufferListItem= Source->queue;
while (ALBufferListItem != NULL)
{
ALBufferListItem->bufferstate = PROCESSED;
ALBufferListItem = ALBufferListItem->next;
}
}
Source->update1 |= STATE;
alcUpdateContext(Context, ALSOURCE, (ALuint)Source);
}
else alSetError(AL_INVALID_OPERATION);
alcProcessContext(Context);
}
ALAPI ALvoid ALAPIENTRY alSourceRewindv(ALsizei n,ALuint *sources)
{
ALCcontext *Context;
ALsource *Source;
ALsizei i;
ALbufferlistitem *ALBufferListItem;
Context=alcGetCurrentContext();
alcSuspendContext(Context);
for (i=0;i<n;i++)
{
if (alIsSource(sources[i]))
{
Source=((ALsource *)sources[i]);
if (Source->state!=AL_INITIAL)
{
Source->state=AL_INITIAL;
Source->inuse=AL_FALSE;
Source->position=0;
Source->position_fraction=0;
Source->BuffersProcessed = 0;
ALBufferListItem= Source->queue;
while (ALBufferListItem != NULL)
{
ALBufferListItem->bufferstate = PROCESSED;
ALBufferListItem = ALBufferListItem->next;
}
}
Source->update1 |= STATE;
alcUpdateContext(Context, ALSOURCE, (ALuint)Source);
}
else alSetError(AL_INVALID_OPERATION);
}
alcProcessContext(Context);
}
value lime_alc_process_context (value context) {
ALCcontext* alcContext = (ALCcontext*)(intptr_t)val_float (context);
alcProcessContext (alcContext);
return alloc_null ();
}
ALAPI ALvoid ALAPIENTRY alSourcePausev(ALsizei n,ALuint *sources)
{
ALCcontext *Context;
ALsource *Source;
ALsizei i;
Context=alcGetCurrentContext();
alcSuspendContext(Context);
for (i=0;i<n;i++)
{
if (alIsSource(sources[i]))
{
Source=((ALsource *)sources[i]);
if (Source->state==AL_PLAYING)
{
Source->state=AL_PAUSED;
Source->inuse=AL_FALSE;
}
Source->update1 |= STATE;
alcUpdateContext(Context, ALSOURCE, (ALuint)Source);
}
else alSetError(AL_INVALID_OPERATION);
}
alcProcessContext(Context);
}
ALAPI ALvoid ALAPIENTRY alGetSourcefv(ALuint source,ALenum pname,ALfloat *values)
{
ALCcontext *Context;
ALsource *Source;
Context=alcGetCurrentContext();
alcSuspendContext(Context);
if (alIsSource(source))
{
Source=((ALsource *)source);
switch(pname)
{
case AL_POSITION:
case AL_VELOCITY:
case AL_DIRECTION:
if (Source->param[pname-AL_CONE_INNER_ANGLE].valid)
{
values[0]=Source->param[pname-AL_CONE_INNER_ANGLE].data.fv3[0];
values[1]=Source->param[pname-AL_CONE_INNER_ANGLE].data.fv3[1];
values[2]=Source->param[pname-AL_CONE_INNER_ANGLE].data.fv3[2];
}
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else alSetError(AL_INVALID_NAME);
alcProcessContext(Context);
}
void
SoundManager::update()
{
static float lasttime = real_time;
if(real_time - lasttime < 0.3)
return;
lasttime = real_time;
// update and check for finished sound sources
for(SoundSources::iterator i = sources.begin(); i != sources.end(); ) {
SoundSource* source = *i;
source->update();
if(!source->playing()) {
delete source;
i = sources.erase(i);
} else {
++i;
}
}
// check streaming sounds
if(music_source) {
music_source->update();
}
alcProcessContext(context);
check_alc_error("Error while processing audio context: ");
}
//------------------------------------------------------------
void ofOpenALSoundPlayer::update(ofEventArgs & args){
if(bMultiPlay){
for(int i=1; i<int(sources.size())/channels; ){
ALint state;
alGetSourcei(sources[i*channels],AL_SOURCE_STATE,&state);
if(state != AL_PLAYING){
alDeleteSources(channels,&sources[i*channels]);
for(int j=0;j<channels;j++){
sources.erase(sources.begin()+i*channels);
}
}else{
i++;
}
}
}
if(alContext != NULL){
alcProcessContext(alContext);
}
checkErrors("ofOpenALSoundPlayer::update");
timeSet = false;
}
ALAPI ALvoid ALAPIENTRY alGetSourcef(ALuint source,ALenum pname,ALfloat *value)
{
ALCcontext *Context;
ALsource *Source;
Context=alcGetCurrentContext();
alcSuspendContext(Context);
if (alIsSource(source))
{
Source=((ALsource *)source);
switch(pname)
{
case AL_PITCH:
case AL_GAIN:
case AL_MIN_GAIN:
case AL_MAX_GAIN:
case AL_MAX_DISTANCE:
case AL_ROLLOFF_FACTOR:
case AL_CONE_OUTER_GAIN:
case AL_CONE_INNER_ANGLE:
case AL_CONE_OUTER_ANGLE:
case AL_REFERENCE_DISTANCE:
if (Source->param[pname-AL_CONE_INNER_ANGLE].valid)
*value=Source->param[pname-AL_CONE_INNER_ANGLE].data.f;
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else alSetError(AL_INVALID_NAME);
alcProcessContext(Context);
}
void SoundManager::poll()
{
static ticks_t lastUpdate = 0;
ticks_t now = g_clock.millis();
if(now - lastUpdate < POLL_DELAY)
return;
lastUpdate = now;
for(auto it = m_sources.begin(); it != m_sources.end();) {
SoundSourcePtr source = *it;
source->update();
if(!source->isPlaying())
it = m_sources.erase(it);
else
++it;
}
if(m_musicSource) {
m_musicSource->update();
if(!m_musicSource->isPlaying())
m_musicSource = nullptr;
}
if(m_context) {
alcProcessContext(m_context);
}
}
AUD_OpenALDevice::~AUD_OpenALDevice()
{
lock();
alcSuspendContext(m_context);
while(!m_playingSounds.empty())
m_playingSounds.front()->stop();
while(!m_pausedSounds.empty())
m_pausedSounds.front()->stop();
// delete all buffered factories
/*while(!m_bufferedFactories->empty())
{
alDeleteBuffers(1, &(*(m_bufferedFactories->begin()))->buffer);
delete *m_bufferedFactories->begin();
m_bufferedFactories->erase(m_bufferedFactories->begin());
}*/
alcProcessContext(m_context);
// wait for the thread to stop
unlock();
pthread_join(m_thread, NULL);
//delete m_bufferedFactories;
// quit OpenAL
alcMakeContextCurrent(NULL);
alcDestroyContext(m_context);
alcCloseDevice(m_device);
pthread_mutex_destroy(&m_mutex);
}
int ChannelStream::Init()
{
ALCcontext *context;
ALCdevice *device;
if ((device = alcOpenDevice(NULL)) == NULL) {
fprintf(stderr, "failed to open sound device\n");
return -1;
}
s_device = device;
context = alcCreateContext(device, NULL);
alcMakeContextCurrent(context);
alcProcessContext(context);
s_context = context;
atexit(__alexit);
/* allocate buffers and sources here using alGenBuffers() and alGenSources() */
/* ... */
alGetError(); /* clear any AL errors beforehand */
return 0;
}
ALAPI ALubyte * ALAPIENTRY alGetString(ALenum pname)
{
ALCcontext *Context;
ALubyte *value;
Context=alcGetCurrentContext();
alcSuspendContext(Context);
switch(pname)
{
case AL_VENDOR:
value=alVendor;
break;
case AL_VERSION:
value=alVersion;
break;
case AL_RENDERER:
value=alRenderer;
break;
case AL_EXTENSIONS:
value=alExtensions;
break;
default:
alSetError(AL_INVALID_VALUE);
break;
}
alcProcessContext(Context);
return value;
}
ALAPI ALvoid ALAPIENTRY alSourcePlay(ALuint source)
{
ALCcontext *Context;
ALsource *Source;
Context=alcGetCurrentContext();
alcSuspendContext(Context);
if (alIsSource(source))
{
Source=((ALsource *)source);
if (Source->state!=AL_PAUSED)
{
Source->state=AL_PLAYING;
Source->inuse=AL_TRUE;
Source->play=AL_TRUE;
Source->position=0;
Source->position_fraction=0;
Source->BuffersProcessed = 0;
Source->BuffersAddedToDSBuffer = 0;
}
else
{
Source->state=AL_PLAYING;
Source->inuse=AL_TRUE;
Source->play=AL_TRUE;
}
Source->update1 |= STATE;
alcUpdateContext(Context, ALSOURCE, (ALuint)Source);
}
else alSetError(AL_INVALID_OPERATION);
alcProcessContext(Context);
}
void AudioHandlerAl::OnInterruptEnd()
{
if (context_)
{
alcMakeContextCurrent(context_);
alcProcessContext(context_);
}
}
void CALL HGE_Impl::Channel_ResumeAll()
{
if(hOpenAL)
{
ALCcontext *ctx = alcGetCurrentContext();
alcProcessContext(ctx);
}
}
void csSndSysRendererOpenAL::Open()
{
ScopedRendererLock lock (*this);
// First assume we have both a config and a device, but no context.
CS_ASSERT (m_Config != 0);
CS_ASSERT (m_Device != 0);
CS_ASSERT (m_Context == 0);
Report (CS_REPORTER_SEVERITY_DEBUG, "Opening OpenAL sound system");
// Clear any error condition
alcGetError (m_Device);
// Setup the attribute list for the OpenAL context
const ALCint attr[] =
{
ALC_REFRESH, m_Config->GetInt ("SndSys.OpenALRefresh", 10), // How often do we update the mixahead buffer (hz).
ALC_SYNC, AL_FALSE, // We want an asynchronous context.
ALC_STEREO_SOURCES, 12,
ALC_MONO_SOURCES, 120,
0
};
// Note: If the sound is choppy, it may be because your OpenAL
// implementation does not implement async (threaded) contexts and
// your framerate is below SndSys.OpenALRefresh. If this is the case,
// please try to decrease SndSys.OpenALRefresh to below your
// framerate. This however will increase sound latency. Alternatively
// you may attempt to implement the async operation in CS.
// Get an OpenAL context
m_Context = alcCreateContext (m_Device, attr);
if (m_Context == 0)
{
Report (CS_REPORTER_SEVERITY_ERROR, "Unable to get OpenAL context");
CS_ASSERT (m_Context != 0);
}
// Make our new context current
alcMakeContextCurrent (m_Context);
// Set the context processing
alcProcessContext (m_Context);
// Check for any errors
ALCenum err = alcGetError (m_Device);
if (err != ALC_NO_ERROR)
{
Report (CS_REPORTER_SEVERITY_ERROR, "An OpenAL error occured: %s", alcGetString (m_Device, err));
CS_ASSERT (err == ALC_NO_ERROR);
}
// Query available extensions
QueryExtensions ();
// Create a listener
m_Listener.AttachNew(new SndSysListenerOpenAL());
}
void ChannelStream::InterruptEnd()
{
// Restore open al context
alcMakeContextCurrent(s_context);
// 'unpause' my context
alcProcessContext(s_context);
Check("InterruptEnd()");
}
void FALAudioDevice::TeardownHardware( void )
{
// Push any pending data to the hardware
if( &alcProcessContext )
{
alcProcessContext( SoundContext );
}
// Destroy all sound sources
for( int32 i = 0; i < Sources.Num(); i++ )
{
delete Sources[ i ];
}
Sources.Empty();
FreeSources.Empty();
// Destroy OpenAL buffers associated with this audio device
FAudioDeviceManager* AudioDeviceManager = GEngine->GetAudioDeviceManager();
check(AudioDeviceManager != nullptr);
for( int32 i = 0; i < AudioDeviceManager->Buffers.Num(); i++ )
{
FALSoundBuffer* Buffer = static_cast<FALSoundBuffer*>(AudioDeviceManager->Buffers[i]);
if( Buffer->AudioDevice == this )
{
alDeleteBuffers(1, &Buffer->BufferId);
Buffer->AudioDevice = nullptr;
Buffer->BufferId = 0;
}
}
// Disable the context
if( &alcMakeContextCurrent )
{
alcMakeContextCurrent(nullptr);
}
// Destroy the context
if( &alcDestroyContext )
{
alcDestroyContext( SoundContext );
SoundContext = NULL;
}
// Close the hardware device
if( &alcCloseDevice )
{
if (HardwareDevice)
{
const ALCchar* DeviceName = alcGetString(HardwareDevice, ALC_DEVICE_SPECIFIER);
UE_LOG(LogALAudio, Log, TEXT("Closing ALAudio device : %s"), StringCast<TCHAR>(static_cast<const ANSICHAR*>(DeviceName)).Get());
alcCloseDevice(HardwareDevice);
HardwareDevice = nullptr;
}
}
}
AUD_Reference<AUD_IHandle> AUD_OpenALDevice::play(AUD_Reference<AUD_IReader> reader, bool keep)
{
AUD_Specs specs = reader->getSpecs();
// check format
if(specs.channels == AUD_CHANNELS_INVALID)
return AUD_Reference<AUD_IHandle>();
if(m_specs.format != AUD_FORMAT_FLOAT32)
reader = new AUD_ConverterReader(reader, m_specs);
ALenum format;
if(!getFormat(format, specs))
return AUD_Reference<AUD_IHandle>();
lock();
alcSuspendContext(m_context);
AUD_Reference<AUD_OpenALDevice::AUD_OpenALHandle> sound;
try
{
// create the handle
sound = new AUD_OpenALDevice::AUD_OpenALHandle(this, format, reader, keep);
}
catch(AUD_Exception&)
{
alcProcessContext(m_context);
unlock();
throw;
}
alcProcessContext(m_context);
// play sound
m_playingSounds.push_back(sound);
start();
unlock();
return AUD_Reference<AUD_IHandle>(sound);
}
std::shared_ptr<IHandle> OpenALDevice::play(std::shared_ptr<IReader> reader, bool keep)
{
Specs specs = reader->getSpecs();
// check format
if(specs.channels == CHANNELS_INVALID)
return std::shared_ptr<IHandle>();
if(m_specs.format != FORMAT_FLOAT32)
reader = std::shared_ptr<IReader>(new ConverterReader(reader, m_specs));
ALenum format;
if(!getFormat(format, specs))
return std::shared_ptr<IHandle>();
std::lock_guard<std::recursive_mutex> lock(m_mutex);
alcSuspendContext(m_context);
std::shared_ptr<OpenALDevice::OpenALHandle> sound;
try
{
// create the handle
sound = std::shared_ptr<OpenALDevice::OpenALHandle>(new OpenALDevice::OpenALHandle(this, format, reader, keep));
}
catch(Exception&)
{
alcProcessContext(m_context);
throw;
}
alcProcessContext(m_context);
// play sound
m_playingSounds.push_back(sound);
start();
return std::shared_ptr<IHandle>(sound);
}
static PyObject*
_context_process (PyObject *self)
{
PyContext *ctxt = (PyContext*) self;
CLEAR_ALCERROR_STATE ();
alcProcessContext (ctxt->context);
if (SetALCErrorException (alcGetError
(PyDevice_AsDevice (ctxt->device)), 0))
return NULL;
Py_RETURN_NONE;
}
void InitSound()
{
device = alcOpenDevice(NULL);
if(!device)
return;
context = alcCreateContext(device, NULL);
if(!context)
return;
alcMakeContextCurrent(context);
alcProcessContext(context);
source_mixed.Init();
}
ALAPI ALvoid ALAPIENTRY alGetSourcei(ALuint source,ALenum pname,ALint *value)
{
ALCcontext *Context;
ALsource *Source;
Context=alcGetCurrentContext();
alcSuspendContext(Context);
if (alIsSource(source))
{
Source=((ALsource *)source);
switch(pname)
{
case AL_SOURCE_RELATIVE:
*value=Source->relative;
break;
case AL_CONE_INNER_ANGLE:
case AL_CONE_OUTER_ANGLE:
if (Source->param[pname-AL_CONE_INNER_ANGLE].valid)
*value=(ALint)Source->param[pname-AL_CONE_INNER_ANGLE].data.f;
break;
case AL_LOOPING:
if (Source->param[pname-AL_CONE_INNER_ANGLE].valid)
*value = Source->param[pname-AL_CONE_INNER_ANGLE].data.i;
else
*value = 0;
break;
case AL_BUFFER:
// Call UpdateContext to retrieve up-to-date information about the current buffer
Source->update1 |= SUPDATEBUFFERS;
alcUpdateContext(Context, ALSOURCE, source);
if (Source->param[pname-AL_CONE_INNER_ANGLE].valid)
*value=Source->param[pname-AL_CONE_INNER_ANGLE].data.i;
else
*value=0;
break;
case AL_SOURCE_STATE:
*value=Source->state;
break;
case AL_BUFFERS_QUEUED:
*value=Source->BuffersInQueue;
break;
case AL_BUFFERS_PROCESSED:
*value=Source->BuffersProcessed;
break;
default:
alSetError(AL_INVALID_ENUM);
break;
}
}
else alSetError(AL_INVALID_NAME);
alcProcessContext(Context);
}
void AUD_OpenALDevice::stopAll()
{
lock();
alcSuspendContext(m_context);
while(!m_playingSounds.empty())
m_playingSounds.front()->stop();
while(!m_pausedSounds.empty())
m_pausedSounds.front()->stop();
alcProcessContext(m_context);
unlock();
}
ALAPI ALvoid ALAPIENTRY alDisable(ALenum capability)
{
ALCcontext *Context;
Context=alcGetCurrentContext();
alcSuspendContext(Context);
switch (capability)
{
default:
alSetError(AL_INVALID_ENUM);
break;
}
alcProcessContext(Context);
}
AL_API signed char OPENAL_Init(int mixrate, int maxsoftwarechannels, unsigned int flags)
{
if (initialized) return false;
if (maxsoftwarechannels == 0) return false;
if (flags != 0) // unsupported.
return false;
if (!lookup_all_alsyms("./openal.so")) // !!! FIXME: linux specific lib name
{
if (!lookup_all_alsyms("openal.so.1")) // !!! FIXME: linux specific lib name
{
if (!lookup_all_alsyms("openal.so")) // !!! FIXME: linux specific lib name
return false;
}
}
ALCdevice *dev = alcOpenDevice(NULL);
if (!dev)
return false;
ALint caps[] = { ALC_FREQUENCY, mixrate, 0 };
ALCcontext *ctx = alcCreateContext(dev, caps);
if (!ctx)
{
alcCloseDevice(dev);
return false;
}
alcMakeContextCurrent(ctx);
alcProcessContext(ctx);
bool cmdline(const char *cmd);
if (cmdline("openalinfo"))
{
printf("AL_VENDOR: %s\n", (char *) alGetString(AL_VENDOR));
printf("AL_RENDERER: %s\n", (char *) alGetString(AL_RENDERER));
printf("AL_VERSION: %s\n", (char *) alGetString(AL_VERSION));
printf("AL_EXTENSIONS: %s\n", (char *) alGetString(AL_EXTENSIONS));
}
num_channels = maxsoftwarechannels;
channels = new OPENAL_Channels[maxsoftwarechannels];
memset(channels, '\0', sizeof (OPENAL_Channels) * num_channels);
for (int i = 0; i < num_channels; i++)
alGenSources(1, &channels[i].sid); // !!! FIXME: verify this didn't fail!
initialized = true;
return true;
}
