static void auplay_destructor(void *arg)
{
struct auplay_st *st = arg;
uint32_t i;
pthread_mutex_lock(&st->mutex);
st->wh = NULL;
pthread_mutex_unlock(&st->mutex);
audio_session_disable();
if (st->queue) {
AudioQueuePause(st->queue);
AudioQueueStop(st->queue, true);
for (i=0; i<ARRAY_SIZE(st->buf); i++)
if (st->buf[i])
AudioQueueFreeBuffer(st->queue, st->buf[i]);
AudioQueueDispose(st->queue, true);
}
mem_deref(st->ap);
pthread_mutex_destroy(&st->mutex);
}
void CAudioQueueManager::pause() {
if (!_isRunning || !_isInitialized)
return;
AudioQueuePause(_queue);
_isRunning = false;
}
void
Moose::Sound::CMusicClip::Pause()
{
m_bPaused = true;
//pthread_mutex_lock(&m_pData->mutex);
AudioQueuePause(m_pData->audioQueue);
//pthread_mutex_unlock(&m_pData->mutex);
}
void audio_pause(audio_player_t *player) {
state_t *state = (state_t *) player->internal_state;
AudioQueuePause(state->queue);
state->playing = false;
if (player->on_stop) {
player->on_stop(player);
}
}
OSStatus DZAudioQueuePlayer::pause()
{
if (this->_queue == NULL || this->_status != DZAudioQueuePlayerStatus_Running) {
return dzDebug(!noErr, "Audio queue cannot pause because it is not running.");
}
OSStatus ret = dzDebug(AudioQueuePause(this->_queue), "Fail to pause audio queue.");
if (ret == noErr) {
this->_status = DZAudioQueuePlayerStatus_Paused;
}
return ret;
}
void Audio_Queue::pause()
{
if (m_state == RUNNING) {
if (AudioQueuePause(m_outAQ) != 0) {
AQ_TRACE("Audio_Queue::pause(): AudioQueuePause failed!\n");
}
setState(PAUSED);
} else if (m_state == PAUSED) {
AudioQueueStart(m_outAQ, NULL);
setState(RUNNING);
}
}
/**
* Entry point for the thread.
*/
int AudioOutputDeviceCoreAudio::Main() {
dmsg(1,("CoreAudio thread started\n"));
OSStatus res;
if(aqPlayerState.mQueue == NULL) {
/*
* Need to be run from this thread because of CFRunLoopGetCurrent()
* which returns the CFRunLoop object for the current thread.
*/
try { CreateAndStartAudioQueue(); }
catch(Exception e) {
std::cerr << "Failed to star audio queue: " + e.Message() << std::endl;
return 0;
}
}
destroyMutex.Lock();
do {
if(atomic_read(&pausedNew) != pausedOld) {
pausedOld = atomic_read(&pausedNew);
if(pausedOld) {
res = AudioQueuePause(aqPlayerState.mQueue);
if(res) std::cerr << "AudioQueuePause: Error " << res << std::endl;
} else {
res = AudioQueuePrime(aqPlayerState.mQueue, 0, NULL);
if(res) std::cerr << "AudioQueuePrime: Error " << res << std::endl;
res = AudioQueueStart(aqPlayerState.mQueue, NULL);
if(res) std::cerr << "AudioQueueStart: Error " << res << std::endl;
}
}
if(atomic_read(&restartQueue)) {
DestroyAudioQueue();
try { CreateAndStartAudioQueue(); }
catch(Exception e) {
destroyMutex.Unlock();
throw e;
}
atomic_set(&restartQueue, 0);
dmsg(1,("Audio queue restarted"));
}
CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.2, false);
} while (atomic_read(&(aqPlayerState.mIsRunning)));
destroyMutex.Unlock();
dmsg(2,("CoreAudio thread stopped\n"));
pthread_exit(NULL);
return 0;
}
static int tdav_producer_audioqueue_pause(tmedia_producer_t* self)
{
OSStatus ret;
tdav_producer_audioqueue_t* producer = (tdav_producer_audioqueue_t*)self;
if(!producer){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
ret = AudioQueuePause(producer->queue);
return ret;
}
int tdav_consumer_audioqueue_pause(tmedia_consumer_t* self)
{
OSStatus ret;
tdav_consumer_audioqueue_t* consumer = (tdav_consumer_audioqueue_t*)self;
if(!consumer){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
ret = AudioQueuePause(consumer->queue);
return ret;
}
bool AudioQueueStreamOut::SetPlayState( MUSIKEngine::PlayState state)
{
if(!mInfo.mQueue)
return false;
switch (state )
{
case MUSIKEngine::Paused:
return m_bPaused = (AudioQueuePause(mInfo.mQueue) == 0);
case MUSIKEngine::Playing:
m_bPaused = false;
return AudioQueueStart(mInfo.mQueue, NULL) == 0;
case MUSIKEngine::Stopped:
m_bPaused = false;
mInfo.mCurrentPacket = 0;
return AudioQueueStop(mInfo.mQueue, true) == 0;
default:
break;
}
return false;
}
void music_obj<audio_queue_driver>::pause()
{
AudioQueuePause(queue_);
is_paused_ = true;
}
