void AudioBody::pause (void)
{
if (destroyed) THROW_DEAD(className);
// presumably does nothing if the track is not playing
alSourcePause(alSourceLeft);
alSourcePause(alSourceRight);
}
void OGMPlayer::Pause()
{
if (isStreamMode_)
{
if (isRunning()) { alSourcePause(source_); }
}
else { alSourcePause(source_); }
}
void OpenALRenderer::pause()
{
if (isPlaying())
{
alSourcePause(m_AudioSource);
}
}
AUD_NAMESPACE_BEGIN
/******************************************************************************/
/*********************** OpenALHandle Handle Code *************************/
/******************************************************************************/
bool OpenALDevice::OpenALHandle::pause(bool keep)
{
if(m_status)
{
std::lock_guard<ILockable> lock(*m_device);
if(m_status == STATUS_PLAYING)
{
for(auto it = m_device->m_playingSounds.begin(); it != m_device->m_playingSounds.end(); it++)
{
if(it->get() == this)
{
std::shared_ptr<OpenALHandle> This = *it;
m_device->m_playingSounds.erase(it);
m_device->m_pausedSounds.push_back(This);
alSourcePause(m_source);
m_status = keep ? STATUS_STOPPED : STATUS_PAUSED;
return true;
}
}
}
}
return false;
}
void
AudioManager::Player::Pause()
{
boost::recursive_mutex::scoped_lock lock( *m_UpdateMutex );
alSourcePause( m_Source );
}
//Pause a source
bool SoundManager::PauseSource(unsigned int source)
{
if (source >= 0 && (unsigned int)source<mSources.size() && mSources[source].reserved)
{
ALint state;
alGetSourcei(mSources[source].source,AL_SOURCE_STATE, &state);
if (state == AL_PLAYING)
{
alSourcePause(mSources[source].source);
}
else if (state == AL_PAUSED)
{
alSourcePlay(mSources[source].source);
}
//Check errors
ALenum error(alGetError());
if(error != AL_NO_ERROR)
{
SingletonLogMgr::Instance()->AddNewLine("SoundManager::PauseSource","Failure while pausing/playing source (" + GetALErrorString(error,false) + ")",LOGEXCEPTION);
}
return true;
}
else
{
SingletonLogMgr::Instance()->AddNewLine("SoundManager::PauseSource(","Can't pause source. Invalid source " + source,LOGEXCEPTION);
return false;
}
}
//Pause sound playing
void SoundManager::Pause()
{
ALint state;
SourcesVector::iterator it;
mPause = !mPause;
//LOOP - For each source registerd
for( it = mSources.begin(); it != mSources.end(); ++it )
{
alGetSourcei( (*it).source, AL_SOURCE_STATE, &state);
if (state == AL_PLAYING && mPause)
{
alSourcePause((*it).source);
}
else if (state == AL_PAUSED && !mPause)
{
alSourcePlay((*it).source);
}
}//LOOP END
//Check errors
ALenum error(alGetError());
if(error != AL_NO_ERROR)
{
SingletonLogMgr::Instance()->AddNewLine("SoundManager::Pause","Failure while pausing/playing source (" + GetALErrorString(error,false) + ")",LOGEXCEPTION);
}
}
void plDSoundBuffer::Pause()
{
if (!source)
return;
alSourcePause(source);
alGetError();
}
//-----------------------------------------------------------------------------
void MusicStream::_pause(float aFadeOut)
{
if (mMusic != 0)
{
ALenum srcState;
// Checks whether the source is playing before pausing it
alGetSourcei(mMusicSrc,AL_SOURCE_STATE,&srcState);
mAudioMan->_alErrorCheck("MusicStream::_pause()",
"Failed getting music source state");
if (srcState == AL_PLAYING)
{
float fadeOut = Math::clamp(aFadeOut,0.0f,1.0f);
if (fadeOut == 0.0f) {
alSourcePause(mMusicSrc);
mAudioMan->_alErrorCheck("MusicStream::_pause()",
"Failed pausing music source");
} else {
mState = MSS_PAUSING;
mFadeSpd = fadeOut;
mFade = MF_FADE_OUT;
}
}
}
}
void OpenALChannel::suspend()
{
if (mUseStream)
{
if (mStream)
{
mStream->suspend();
mWasPlaying = true;
}
else
{
mWasPlaying = false;
}
}
else
{
ALint state;
alGetSourcei(mSourceID, AL_SOURCE_STATE, &state);
if (state == AL_PLAYING)
{
alSourcePause(mSourceID);
mWasPlaying = true;
return;
}
mWasPlaying = false;
}
}
void OpenALSound::Pause()
{
_wasPlaying = false;
if ( _isActive ) {
alSourcePause( _sourceId );
}
}
/*
==================
Sound::Pause
==================
*/
bool Sound::Pause() {
if (IsPlaying()) {
alSourcePause(source);
return true;
}
return false;
}
void CALL HGE_Impl::Channel_Pause(HCHANNEL chn)
{
if(hOpenAL)
{
alSourcePause((ALuint) chn);
}
}
AL_API signed char OPENAL_SetPaused(int channel, signed char paused)
{
if (!initialized) return false;
if (channel == OPENAL_ALL)
{
for (int i = 0; i < num_channels; i++)
OPENAL_SetPaused(i, paused);
return true;
}
if ((channel < 0) || (channel >= num_channels)) return false;
ALint state = 0;
if (channels[channel].startpaused)
state = AL_PAUSED;
else
alGetSourceiv(channels[channel].sid, AL_SOURCE_STATE, &state);
if ((paused) && (state == AL_PLAYING))
alSourcePause(channels[channel].sid);
else if ((!paused) && (state == AL_PAUSED))
{
alSourcePlay(channels[channel].sid);
channels[channel].startpaused = false;
}
return true;
}
//*
// =======================================================================================================================
// =======================================================================================================================
//
void sound_PauseSample( AUDIO_SAMPLE *psSample )
{
#ifndef WZ_NOSOUND
alSourcePause( psSample->iSample );
sound_GetError();
#endif
}
void
pause( const string &id )
{
OpenALData *data = m_buffers[ id ];
BK_ASSERT( data != NULL, "nothing with the given id " << id << " could be found!" );
alSourcePause( data->m_source );
}
void ALSound::Pause(){
if(GetState() == AL_PAUSED){
Play();
return;
}
alSourcePause(m_uiSource);
}
void Play()
{
// 播放
alSourcePlay(Source);
/*printf("Press Enter To Stop Sound\n");
getchar();
alSourceStop(Source);*/
ALubyte c = ' ';
printf("Press Enter h To Pause \np To Begin\ns To Stop Sound\n ");
while (c != 'q')
{
c = getchar();
switch (c)
{
// Pressing 'p' will begin playing the sample.
case 'p': alSourcePlay(Source); break;
// Pressing 's' will stop the sample from playing.
case 's': alSourceStop(Source); break;
// Pressing 'h' will pause (hold) the sample.
case 'h': alSourcePause(Source); break;
};
}
}
//=================================================================================================
void Sounds::pause()
{
if (!file)
return;
alSourcePause( source );
}
void OpenALBackend::Pause()
{
AUDIT(alIsSource(m_source));
alSourcePause(m_source);
checkForAlError("Pause->alSourcePause");
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void SoundVoice::Pause( bool pause )
{
if (pause) {
alSourcePause(m_source);
} else {
alSourcePlay(m_source);
}
}
void Source::pauseAtomic()
{
if (valid)
{
alSourcePause(source);
paused = true;
}
}
void OpenALSound::OnPause()
{
if (!IsFinished())
{
alSourcePause(source);
check_openal_error();
}
}
void SimpleAudioEngine::pauseEffect(unsigned int nSoundId)
{
ALint state;
alGetSourcei(nSoundId, AL_SOURCE_STATE, &state);
if (state == AL_PLAYING)
alSourcePause(nSoundId);
checkALError("pauseEffect:alSourcePause");
}
void audio_output::pause()
{
alSourcePause(_source);
if (alGetError() != AL_NO_ERROR)
{
throw exc(_("Cannot pause OpenAL source playback."));
}
}
void Sound::Impl::PauseMusic() {
if (!m_initialized)
return;
if (alcGetCurrentContext()) {
alSourcePause(m_sources[0]);
}
}
void CCAudioPlayer::pause() {
if(!m_paused && m_playing) {
if(m_source != 0) {
alSourcePause(m_source);
m_paused = true;
}
}
}
void SimpleAudioEngine::pauseBackgroundMusic()
{
ALint state;
alGetSourcei(s_backgroundSource, AL_SOURCE_STATE, &state);
if (state == AL_PLAYING)
alSourcePause(s_backgroundSource);
checkALError("pauseBackgroundMusic");
}
/*/////////////////////////////////////////////////////////////////*/
void OgreOggStreamSound::_pauseImpl() {
if(mSource == AL_NONE) return;
alSourcePause(mSource);
// Notify listener
if(mSoundListener) mSoundListener->soundPaused(this);
}
void AudioSource::pause()
{
alSourcePause(m_sourceID);
#if NORI_DEBUG
checkAL("Failed to pause source");
#endif
}
