AudioManager::~AudioManager() { MusicStop(); if(m_Initialized) { m_ThreadContinue = false; m_UpdateThread->join(); delete m_UpdateThread; delete[] m_Buffer; alcMakeContextCurrent(nullptr); alcDestroyContext(m_ALContext); alcCloseDevice(m_ALDevice); LOG_TRIVIAL("AudioManager destroyed."); } }
void audio_output::deinit() { if (_initialized) { do { alGetSourcei(_source, AL_SOURCE_STATE, &_state); } while (alGetError() == AL_NO_ERROR && _state == AL_PLAYING); alDeleteSources(1, &_source); alDeleteBuffers(_num_buffers, &(_buffers[0])); alcMakeContextCurrent(NULL); alcDestroyContext(_context); alcCloseDevice(_device); _initialized = false; } }
void audio_close() { ALCdevice *device = NULL; ALCcontext *context = NULL; // Exit context=alcGetCurrentContext(); if (context) { device=alcGetContextsDevice(context); alcMakeContextCurrent(NULL); alcDestroyContext(context); if (device) alcCloseDevice(device); } }
// close audio device static void uninit(int immed) { ALCcontext *ctx = alcGetCurrentContext(); ALCdevice *dev = alcGetContextsDevice(ctx); free(tmpbuf); if (!immed) { ALint state; alGetSourcei(sources[0], AL_SOURCE_STATE, &state); while (state == AL_PLAYING) { usec_sleep(10000); alGetSourcei(sources[0], AL_SOURCE_STATE, &state); } } reset(); alcMakeContextCurrent(NULL); alcDestroyContext(ctx); alcCloseDevice(dev); }
ALboolean alutExit (void) { ALCdevice *device; if (initialisationState == Unintialized) { _alutSetError (ALUT_ERROR_INVALID_OPERATION); return AL_FALSE; } if (initialisationState == ExternalDeviceAndContext) { initialisationState = Unintialized; return AL_TRUE; } if (!_alutSanityCheck ()) { return AL_FALSE; } if (!alcMakeContextCurrent (NULL)) { _alutSetError (ALUT_ERROR_MAKE_CONTEXT_CURRENT); return AL_FALSE; } device = alcGetContextsDevice (alutContext); alcDestroyContext (alutContext); if (alcGetError (device) != ALC_NO_ERROR) { _alutSetError (ALUT_ERROR_DESTROY_CONTEXT); return AL_FALSE; } if (!alcCloseDevice (device)) { _alutSetError (ALUT_ERROR_CLOSE_DEVICE); return AL_FALSE; } initialisationState = Unintialized; return AL_TRUE; }
void SoundEngineOpenAL::destroy() { // Stop thread running = false; while (!threadstopped) usleep(1000); // Delete listener if (listener) delete listener; // Delete recorders while (recorders.size() != 0) recorders[0]->destroy(); // Delete sources std::map<std::string, SoundSource*>::iterator it = sources.begin(); while (it != sources.end()) { it->second->drop(); it++; } // Delete sounds for (unsigned int i = 0; i < sounds.size(); i++) { sounds[i]->drop(); } sounds.clear(); // Destroy OpenAL context unsigned int error = alGetError(); if (error != AL_NO_ERROR) { getLogger()->write(ELL_Error, "AL error on exit: %s!\n", getOpenALErrorString(error)); } ALCcontext *context = alcGetCurrentContext(); ALCdevice *dev = alcGetContextsDevice(context); error = alcGetError(dev); if (error != AL_NO_ERROR) { getLogger()->writeLine(ELL_Error, "ALC error on exit!\n"); } alcMakeContextCurrent(0); alcDestroyContext(context); alcCloseDevice(dev); // Delete engine instance delete this; }
void OpenAL::CloseDevice() { if (s_device) { if (s_context) { alcMakeContextCurrent(nullptr); alcDestroyContext(s_context); s_context = nullptr; } if (!alcCloseDevice(s_device)) // We could not close the close, this means that it's still in use NazaraWarning("Failed to close device"); s_device = nullptr; } }
void shutdown() { alcMakeContextCurrent( NULL ); alcDestroyContext( m_context ); alcCloseDevice( m_device ); alutExit(); OpenALData *data; for( auto i = m_buffers.begin(); i != m_buffers.end(); ++i ) { BK_DEBUG( "releasing OpenAL Data: " << i->first ); data = i->second; alSourcei( data->m_source, AL_BUFFER, 0 ); alDeleteBuffers( 1, &(data->m_buffer) ); alDeleteSources( 1, &(data->m_source) ); } }
void RemoveSound() { alSourceStop(source); checkALError(); alDeleteSources(1, &source); checkALError(); alDeleteBuffers(BUFFER_QUANTITY, buffers); checkALError(); // Reset the current context to NULL. alcMakeContextCurrent(NULL); checkALCError(); // RELEASE the context and the device. alcDestroyContext(pContext); checkALCError(); alcCloseDevice(pDevice); }
spp_AudioManager::~spp_AudioManager() { //deleting all the stored buffers UnloadAllSounds(); RemoveAllProcessingPlugIns(); //deleting the listener delete mpListener; StopDebugMode(); //closing OpenAL alcMakeContextCurrent(NULL); alcDestroyContext(mpContext); alcCloseDevice(mpDevice); alcCaptureCloseDevice(mpRecordingDevice); }
void OpenALAudio::deinit_wav() { this->wav_init_flag = false; this->stop_wav(); if (this->al_context != NULL) { alcDestroyContext(this->al_context); this->al_context = NULL; } if (this->al_device != NULL) { alcCloseDevice(this->al_device); this->al_device = NULL; } }
void cOpenALDeviceContext::shutDown() { if(Initialized) { cAudioMutexBasicLock lock(Mutex); //Reset context to null alcMakeContextCurrent(NULL); //Delete the context alcDestroyContext(Context); Context = NULL; //Close the device alcCloseDevice(Device); checkError(); Device = NULL; Initialized = false; } }
void exitOpenAL() { ALCcontext* pCurContext; ALCdevice* pCurDevice; // Get the current context. pCurContext = alcGetCurrentContext(); // Get the device used by that context. pCurDevice = alcGetContextsDevice(pCurContext); // Reset the current context to NULL. alcMakeContextCurrent(NULL); // Release the context and the device. alcDestroyContext(pCurContext); alcCloseDevice(pCurDevice); }
void DoneSound() { if(device && context) { source_mixed.Done(); } if(context) { alcMakeContextCurrent(NULL); alcDestroyContext(context); context = NULL; } if(device) { alcCloseDevice(device); device = NULL; } }
SoundManager::~SoundManager( void ) { // Delete the sources and buffers alDeleteSources( MAX_AUDIO_SOURCES, mAudioSources ); alDeleteBuffers( MAX_AUDIO_BUFFERS, mAudioBuffers ); // Destroy the sound context and device mSoundContext = alcGetCurrentContext(); mSoundDevice = alcGetContextsDevice( mSoundContext ); alcMakeContextCurrent( NULL ); alcDestroyContext( mSoundContext ); if ( mSoundDevice) alcCloseDevice( mSoundDevice ); alutExit(); printf("SoudManager Destroyed.\n"); }
void SoundManager::deinit() { if (!_ready) return; if (!destroyThread()) warning("SoundManager::deinit(): Sound thread had to be killed"); for (uint16 i = 1; i < kChannelCount; i++) freeChannel(i); if (_hasSound) { alcMakeContextCurrent(0); alcDestroyContext(_ctx); alcCloseDevice(_dev); } _ready = false; }
ALvoid alutExit(ALvoid) { ALCcontext *Context; ALCdevice *Device; //Unregister extensions //Get active context Context=alcGetCurrentContext(); //Get device for active context Device=alcGetContextsDevice(Context); //Disable context alcMakeContextCurrent(NULL); //Release context(s) alcDestroyContext(Context); //Close device alcCloseDevice(Device); }
/*! Frees all memory allocated by the sound device * * @returns ICRESULT Success/failure of the cleanup **/ ICRESULT icSoundDeviceAL::Cleanup(void) { if (m_bInitialized) { icSoundI* temp = icMinHeapDequeue(m_Playing, m_NumPlaying--); while (temp) { temp->Stop(); icMinHeapInsert(m_Sounds,m_NumFreeSounds++,temp); } ALuint temp_buff[ICSND_MAX_SOURCE]; ALuint temp_source[ICSND_MAX_PLAYING]; for (int i=0; i<ICSND_MAX_SOURCE; ++i) { temp_buff[i] = m_SrcBufs[i].buffID; m_SrcBufs[i].buffID = 0; } for (int i=0; i<ICSND_MAX_PLAYING; ++i) { temp_source[i] = ((icSoundAL*)m_Sounds[i])->m_ALsource; ((icSoundAL*)m_Sounds[i])->m_ALsource = 0; ((icSoundAL*)m_Sounds[i])->m_bInitialized = false; delete ((icSoundAL*)m_Sounds[i]); } //Free buffers and source objects alDeleteBuffers(ICSND_MAX_SOURCE, temp_buff); alDeleteSources(ICSND_MAX_PLAYING, temp_source); //Disable context alcMakeContextCurrent(NULL); //Release context alcDestroyContext(m_Context); //Close device alcCloseDevice(m_Device); } return IC_OK; }// END FUNCTION Cleanup(void)
void ALSound::CleanUp() { if (m_enabled) { GetLogger()->Info("Unloading files and closing device...\n"); StopAll(); StopMusic(); for (auto channel : m_channels) { delete channel.second; } if (m_currentMusic) { delete m_currentMusic; } for (auto item : m_oldMusic) { delete item.music; } if (m_previousMusic.music) { delete m_previousMusic.music; } for (auto item : m_sounds) { delete item.second; } for (auto item : m_music) { delete item.second; } m_enabled = false; alcDestroyContext(m_context); alcCloseDevice(m_device); } }
Core::Core(Camera* cam, QThread *coreThread) : tox(nullptr), camera(cam) { videobuf = new uint8_t[videobufsize]; videoBusyness=0; toxTimer = new QTimer(this); toxTimer->setSingleShot(true); connect(toxTimer, &QTimer::timeout, this, &Core::process); //connect(fileTimer, &QTimer::timeout, this, &Core::fileHeartbeat); connect(&Settings::getInstance(), &Settings::dhtServerListChanged, this, &Core::process); connect(this, SIGNAL(fileTransferFinished(ToxFile)), this, SLOT(onFileTransferFinished(ToxFile))); for (int i=0; i<TOXAV_MAX_CALLS;i++) { calls[i].sendAudioTimer = new QTimer(); calls[i].sendVideoTimer = new QTimer(); calls[i].sendAudioTimer->moveToThread(coreThread); calls[i].sendVideoTimer->moveToThread(coreThread); connect(calls[i].sendVideoTimer, &QTimer::timeout, [this,i](){sendCallVideo(i);}); } // OpenAL init alOutDev = alcOpenDevice(nullptr); if (!alOutDev) { qWarning() << "Core: Cannot open output audio device"; } else { alContext=alcCreateContext(alOutDev,nullptr); if (!alcMakeContextCurrent(alContext)) { qWarning() << "Core: Cannot create output audio context"; alcCloseDevice(alOutDev); } else alGenSources(1, &alMainSource); } alInDev = alcCaptureOpenDevice(NULL,av_DefaultSettings.audio_sample_rate, AL_FORMAT_MONO16, (av_DefaultSettings.audio_frame_duration * av_DefaultSettings.audio_sample_rate * 4) / 1000); if (!alInDev) qWarning() << "Core: Cannot open input audio device"; }
static void al_free(void *data) { al_t *al = (al_t*)data; if (al) { alSourceStop(al->source); alDeleteSources(1, &al->source); if (al->buffers) { alDeleteBuffers(al->num_buffers, al->buffers); free(al->buffers); free(al->res_buf); } } alcMakeContextCurrent(NULL); alcDestroyContext(al->ctx); alcCloseDevice(al->handle); free(al); }
CSound::~CSound() { if (!sources.empty()) { soundThread->interrupt(); soundThread->join(); delete soundThread; soundThread = 0; sources.clear(); // delete all sources sounds.clear(); SoundBuffer::Deinitialise(); ALCcontext *curcontext = alcGetCurrentContext(); ALCdevice *curdevice = alcGetContextsDevice(curcontext); alcMakeContextCurrent(NULL); alcDestroyContext(curcontext); alcCloseDevice(curdevice); } }
void OpenALStream::Stop() { SoundStream::Stop(); alSourceStop(uiSource); alSourcei(uiSource, AL_BUFFER, 0); // Clean up buffers and sources alDeleteSources(1, &uiSource); uiSource = 0; alDeleteBuffers(numBuffers, uiBuffers); ALCcontext *pContext = alcGetCurrentContext(); ALCdevice *pDevice = alcGetContextsDevice(pContext); alcMakeContextCurrent(nullptr); alcDestroyContext(pContext); alcCloseDevice(pDevice); }
AudioManagerImpl::~AudioManagerImpl() { stopMusic(); MidiDevice::shutdown(); ALCcontext *context = alcGetCurrentContext(); if (!context) return; for (ALuint source : mFreeSources) alDeleteSources(1, &source); mFreeSources.clear(); ALCdevice *device = alcGetContextsDevice(context); alcMakeContextCurrent(nullptr); alcDestroyContext(context); alcCloseDevice(device); }
ALCvoid ReleaseALC(ALCvoid) { ALCdevice *Dev; #ifdef _DEBUG if(g_ulContextCount > 0) AL_PRINT("exit() %u device(s) and %u context(s) NOT deleted\n", g_ulDeviceCount, g_ulContextCount); #endif while(g_pDeviceList) { Dev = g_pDeviceList; g_pDeviceList = g_pDeviceList->next; if(Dev->IsCaptureDevice) alcCaptureCloseDevice(Dev); else alcCloseDevice(Dev); } }
// // AyuanX: Spec says OpenAL1.1 is thread safe already // bool OpenALStream::Start() { ALDeviceList pDeviceList; if (pDeviceList.GetNumDevices()) { char *defDevName = pDeviceList.GetDeviceName(pDeviceList.GetDefaultDevice()); WARN_LOG(AUDIO, "Found OpenAL device %s", defDevName); ALCdevice *pDevice = alcOpenDevice(defDevName); if (pDevice) { ALCcontext *pContext = alcCreateContext(pDevice, nullptr); if (pContext) { // Used to determine an appropriate period size (2x period = total buffer size) //ALCint refresh; //alcGetIntegerv(pDevice, ALC_REFRESH, 1, &refresh); //period_size_in_millisec = 1000 / refresh; alcMakeContextCurrent(pContext); return SoundStream::Start(); } else { alcCloseDevice(pDevice); PanicAlertT("OpenAL: can't create context for device %s", defDevName); } } else { PanicAlertT("OpenAL: can't open device %s", defDevName); } } else { PanicAlertT("OpenAL: can't find sound devices"); } // Initialize DPL2 parameters return false; }
SoundManager::~SoundManager() { music_source.reset(); sources.clear(); for(SoundBuffers::iterator i = buffers.begin(); i != buffers.end(); ++i) { ALuint buffer = i->second; alDeleteBuffers(1, &buffer); } if(context != NULL) { alcDestroyContext(context); context = NULL; } if(device != NULL) { alcCloseDevice(device); device = NULL; } }
void sound_ShutdownLibrary(void) { AUDIO_STREAM *stream; SAMPLE_LIST *aSample = active_samples, * tmpSample = NULL; if (!openal_initialized) { return; } debug(LOG_SOUND, "starting shutdown"); // Stop all streams, sound_UpdateStreams() will deallocate all stopped streams for (stream = active_streams; stream != NULL; stream = stream->next) { sound_StopStream(stream); } sound_UpdateStreams(); alcGetError(device); // clear error codes /* On Linux since this caused some versions of OpenAL to hang on exit. - Per */ debug(LOG_SOUND, "make default context NULL"); alcMakeContextCurrent(NULL); sound_GetContextError(device); debug(LOG_SOUND, "destroy previous context"); alcDestroyContext(context); // this gives a long delay on some impl. sound_GetContextError(device); debug(LOG_SOUND, "close device"); if (alcCloseDevice(device) == ALC_FALSE) { debug(LOG_SOUND, "OpenAl could not close the audio device."); } while (aSample) { tmpSample = aSample->next; free(aSample); aSample = tmpSample; } active_samples = NULL; }
ALboolean ALFWInitOpenAL() { ALDeviceList *pDeviceList = NULL; ALCcontext *pContext = NULL; ALCdevice *pDevice = NULL; ALint i; ALboolean bReturn = AL_FALSE; pDeviceList = new ALDeviceList(); if ((pDeviceList) && (pDeviceList->GetNumDevices())) { ALFWprintf("\nSelect OpenAL Device:\n"); for (i = 0; i < pDeviceList->GetNumDevices(); i++) ALFWprintf("%d. %s%s\n", i + 1, pDeviceList->GetDeviceName(i), i == pDeviceList->GetDefaultDevice() ? "(DEFAULT)" : ""); do { // ALchar ch = _getch(); ALchar ch = '1' ; i = atoi(&ch); } while ((i < 1) || (i > pDeviceList->GetNumDevices())); pDevice = alcOpenDevice(pDeviceList->GetDeviceName(i - 1)); if (pDevice) { pContext = alcCreateContext(pDevice, NULL); if (pContext) { ALFWprintf("\nOpened %s Device\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER)); alcMakeContextCurrent(pContext); bReturn = AL_TRUE; } else { alcCloseDevice(pDevice); } } delete pDeviceList; } return bReturn; }
void clAudioSubsystem_OpenAL::Start() { m_AudioThread = std::make_shared<std::thread>( [this]() { m_Device = alcOpenDevice( nullptr ); m_Context = alcCreateContext( m_Device, nullptr ); alcMakeContextCurrent( m_Context ); if ( IsVerbose() ) DebugPrintVersion(); m_IsInitialized = true; while ( !m_IsPendingExit ) { std::this_thread::sleep_for(std::chrono::milliseconds(10)); { auto sources = this->GetLockedSources(); for (auto i : sources) { i->UpdateBuffers(); } } } // A dirty workaround for a possible bug in OpenAL Soft // http://openal.org/pipermail/openal/2015-January/000312.html #if !defined(_WIN32) alcDestroyContext( m_Context ); alcCloseDevice( m_Device ); #endif m_IsInitialized = false; } ); // wait while ( !m_IsInitialized ); }