void AudioOutputDeviceCoreAudio::HandleOutputBuffer ( void *aqData, AudioQueueRef inAQ, AudioQueueBufferRef inBuffer ) { AQPlayerState* pAqData = (AQPlayerState*) aqData; if (atomic_read(&(pAqData->mIsRunning)) == 0) { AudioQueueFlush(pAqData->mQueue); AudioQueueStop (pAqData->mQueue, true); return; } if(atomic_read(&(pAqData->pDevice->restartQueue))) return; uint bufferSize = pAqData->pDevice->uiBufferSize; // let all connected engines render 'fragmentSize' sample points pAqData->pDevice->RenderAudio(bufferSize); Float32* pDataBuf = (Float32*)(inBuffer->mAudioData); uint uiCoreAudioChannels = pAqData->pDevice->uiCoreAudioChannels; for (int c = 0; c < uiCoreAudioChannels; c++) { float* in = pAqData->pDevice->Channels[c]->Buffer(); for (int i = 0, o = c; i < bufferSize; i++ , o += uiCoreAudioChannels) { pDataBuf[o] = in[i]; } } inBuffer->mAudioDataByteSize = (uiCoreAudioChannels * 4) * bufferSize; OSStatus res = AudioQueueEnqueueBuffer(pAqData->mQueue, inBuffer, 0, NULL); if(res) std::cerr << "AudioQueueEnqueueBuffer: Error " << res << std::endl; }
void Audio_Queue::stop(bool stopImmediately) { if (!m_audioQueueStarted) { AQ_TRACE("%s: audio queue already stopped, return!\n", __PRETTY_FUNCTION__); return; } m_audioQueueStarted = false; AQ_TRACE("%s: enter\n", __PRETTY_FUNCTION__); if (AudioQueueFlush(m_outAQ) != 0) { AQ_TRACE("%s: AudioQueueFlush failed!\n", __PRETTY_FUNCTION__); } if (stopImmediately) { AudioQueueRemovePropertyListener(m_outAQ, kAudioQueueProperty_IsRunning, audioQueueIsRunningCallback, this); } if (AudioQueueStop(m_outAQ, stopImmediately) != 0) { AQ_TRACE("%s: AudioQueueStop failed!\n", __PRETTY_FUNCTION__); } if (stopImmediately) { setState(IDLE); } AQ_TRACE("%s: leave\n", __PRETTY_FUNCTION__); }
OSStatus DZAudioQueuePlayer::flush() { if (this->_queue == NULL) { return dzDebug(!noErr, "Null audio queue to flush."); } return dzDebug(AudioQueueFlush(this->_queue), "Fail to flush audio queue."); }
static void gst_atdec_flush (GstAudioDecoder * decoder, gboolean hard) { GstATDec *atdec = GST_ATDEC (decoder); AudioQueueFlush (atdec->queue); }
static void AQTestBufferCallback(void *inUserData, AudioQueueRef inAQ, AudioQueueBufferRef inCompleteAQBuffer) { AQTestInfo * myInfo = (AQTestInfo *)inUserData; if (myInfo->mDone) return; UInt32 numBytes; UInt32 nPackets = myInfo->mNumPacketsToRead; OSStatus result = AudioFileReadPackets(myInfo->mAudioFile, // The audio file from which packets of audio data are to be read. false, // Set to true to cache the data. Otherwise, set to false. &numBytes, // On output, a pointer to the number of bytes actually returned. myInfo->mPacketDescs, // A pointer to an array of packet descriptions that have been allocated. myInfo->mCurrentPacket, // The packet index of the first packet you want to be returned. &nPackets, // On input, a pointer to the number of packets to read. On output, the number of packets actually read. inCompleteAQBuffer->mAudioData); // A pointer to user-allocated memory. if (result) { DebugMessageN1 ("Error reading from file: %d\n", (int)result); exit(1); } // we have some data if (nPackets > 0) { inCompleteAQBuffer->mAudioDataByteSize = numBytes; result = AudioQueueEnqueueBuffer(inAQ, // The audio queue that owns the audio queue buffer. inCompleteAQBuffer, // The audio queue buffer to add to the buffer queue. (myInfo->mPacketDescs ? nPackets : 0), // The number of packets of audio data in the inBuffer parameter. See Docs. myInfo->mPacketDescs); // An array of packet descriptions. Or NULL. See Docs. if (result) { DebugMessageN1 ("Error enqueuing buffer: %d\n", (int)result); exit(1); } myInfo->mCurrentPacket += nPackets; } else { // **** This ensures that we flush the queue when done -- ensures you get all the data out **** if (!myInfo->mFlushed) { result = AudioQueueFlush(myInfo->mQueue); if (result) { DebugMessageN1("AudioQueueFlush failed: %d", (int)result); exit(1); } myInfo->mFlushed = true; } result = AudioQueueStop(myInfo->mQueue, false); if (result) { DebugMessageN1("AudioQueueStop(false) failed: %d", (int)result); exit(1); } // reading nPackets == 0 is our EOF condition myInfo->mDone = true; } }
long AudioStreamDecoder::Stop() { long err = 0; if (mStream) { err = AudioFileStreamClose(mStream); CARP_IF(err, "AudioFileStreamClose returned %ld\n", err); mStream = NULL; } if (mStarted) { err = AudioQueueFlush(mQueue); BAIL_IF(err, "AudioQueueFlush returned %ld\n", err); err = AudioQueueStop(mQueue, true); BAIL_IF(err, "AudioQueueStop returned %ld\n", err); err = pthread_mutex_lock(&mMutex); BAIL_IF(err, "pthread_mutex_lock returned %ld\n", err); if (!mFinished) { err = pthread_cond_wait(&mCond, &mMutex); BAIL_IF(err, "pthread_cond_wait returned %ld\n", err); } err = pthread_mutex_unlock(&mMutex); BAIL_IF(err, "pthread_mutex_unlock returned %ld\n", err); mStarted = false; mFinished = false; } if (mQueue) { for (int i = 0; i < kBufferCount; i++) { if (mBuffers[i]) { err = AudioQueueFreeBuffer(mQueue, mBuffers[i]); CARP_IF(err, "AudioQueueFreeBuffer returned %ld\n", err); } } err = AudioQueueDispose(mQueue, true); CARP_IF(err, "AudioQueueDispose returned %ld\n", err); mQueue = NULL; } bail: return err; }
void Audio_Queue::stop() { if (!m_audioQueueStarted) { return; } AQ_TRACE("Audio_Queue::stop(): enter\n"); if (AudioQueueFlush(m_outAQ) != 0) { AQ_TRACE("Audio_Queue::stop(): AudioQueueFlush failed!\n"); } if (AudioQueueStop(m_outAQ, true) != 0) { AQ_TRACE("Audio_Queue::stop(): AudioQueueStop failed!\n"); } m_audioQueueStarted = false; AQ_TRACE("Audio_Queue::stop(): leave\n"); }
/*auPause--------------------------------------------------*/ BOOL auPause(Audio* self) { if(self->isPlaying) { #ifdef __APPLE__ OSStatus error = AudioQueueFlush(self->queue); if(!error) error = AudioQueueStop (self->queue, YES); self->isPlaying = (error != 0); #elif defined __linux__ self->threadShouldContinueRunning = NO; if(self->threadIsRunning) pthread_join(self->thread, NULL); self->isPlaying = NO; #endif } return self->isPlaying; }
void Audio_Queue::stop(bool stopImmediately) { if (!m_audioQueueStarted) { AQ_TRACE("%s: audio queue already stopped, return!\n", __PRETTY_FUNCTION__); return; } m_audioQueueStarted = false; m_levelMeteringEnabled = false; pthread_mutex_lock(&m_bufferInUseMutex); pthread_cond_signal(&m_bufferFreeCondition); pthread_mutex_unlock(&m_bufferInUseMutex); AQ_TRACE("%s: enter\n", __PRETTY_FUNCTION__); if (AudioQueueFlush(m_outAQ) != 0) { AQ_TRACE("%s: AudioQueueFlush failed!\n", __PRETTY_FUNCTION__); } if (stopImmediately) { AudioQueueRemovePropertyListener(m_outAQ, kAudioQueueProperty_IsRunning, audioQueueIsRunningCallback, this); } if (AudioQueueStop(m_outAQ, stopImmediately) != 0) { AQ_TRACE("%s: AudioQueueStop failed!\n", __PRETTY_FUNCTION__); } if (stopImmediately) { setState(IDLE); } AQ_TRACE("%s: leave\n", __PRETTY_FUNCTION__); }
int main (int argc, char * const argv[]) { // allocate a struct for storing our state MyData* myData = (MyData*)calloc(1, sizeof(MyData)); // initialize a mutex and condition so that we can block on buffers in use. pthread_mutex_init(&myData->mutex, NULL); pthread_cond_init(&myData->cond, NULL); pthread_cond_init(&myData->done, NULL); // get connected int connection_socket = MyConnectSocket(); if (connection_socket < 0) return 1; printf("connected\n"); // allocate a buffer for reading data from a socket const size_t kRecvBufSize = 40000; char* buf = (char*)malloc(kRecvBufSize * sizeof(char)); // create an audio file stream parser OSStatus err = AudioFileStreamOpen(myData, MyPropertyListenerProc, MyPacketsProc, kAudioFileAAC_ADTSType, &myData->audioFileStream); if (err) { PRINTERROR("AudioFileStreamOpen"); return 1; } while (!myData->failed) { // read data from the socket printf("->recv\n"); ssize_t bytesRecvd = recv(connection_socket, buf, kRecvBufSize, 0); printf("bytesRecvd %d\n", bytesRecvd); if (bytesRecvd <= 0) break; // eof or failure // parse the data. this will call MyPropertyListenerProc and MyPacketsProc err = AudioFileStreamParseBytes(myData->audioFileStream, bytesRecvd, buf, 0); if (err) { PRINTERROR("AudioFileStreamParseBytes"); break; } } // enqueue last buffer MyEnqueueBuffer(myData); printf("flushing\n"); err = AudioQueueFlush(myData->audioQueue); if (err) { PRINTERROR("AudioQueueFlush"); return 1; } printf("stopping\n"); err = AudioQueueStop(myData->audioQueue, false); if (err) { PRINTERROR("AudioQueueStop"); return 1; } printf("waiting until finished playing..\n"); pthread_mutex_lock(&myData->mutex); pthread_cond_wait(&myData->done, &myData->mutex); pthread_mutex_unlock(&myData->mutex); printf("done\n"); // cleanup free(buf); err = AudioFileStreamClose(myData->audioFileStream); err = AudioQueueDispose(myData->audioQueue, false); close(connection_socket); free(myData); return 0; }
void AudioOutputDeviceCoreAudio::DestroyAudioQueue() { AudioQueueFlush(aqPlayerState.mQueue); AudioQueueStop (aqPlayerState.mQueue, true); AudioQueueDispose(aqPlayerState.mQueue, true); aqPlayerState.mQueue = NULL; }