static void record_handler(void *userData, AudioQueueRef inQ,
AudioQueueBufferRef inQB,
const AudioTimeStamp *inStartTime,
UInt32 inNumPackets,
const AudioStreamPacketDescription *inPacketDesc)
{
struct ausrc_st *st = userData;
unsigned int ptime;
ausrc_read_h *rh;
void *arg;
(void)inStartTime;
(void)inNumPackets;
(void)inPacketDesc;
pthread_mutex_lock(&st->mutex);
ptime = st->ptime;
rh = st->rh;
arg = st->arg;
pthread_mutex_unlock(&st->mutex);
if (!rh)
return;
rh(inQB->mAudioData, inQB->mAudioDataByteSize/2, arg);
AudioQueueEnqueueBuffer(inQ, inQB, 0, NULL);
/* Force a sleep here, coreaudio's timing is too fast */
#if !TARGET_OS_IPHONE
#define ENCODE_TIME 1000
usleep((ptime * 1000) - ENCODE_TIME);
#endif
}
bool Device::add(audio::Buffer &buf)
{
# ifdef NNT_MACH
int suc = 0;
for (core::vector<AudioQueueBufferRef>::iterator each = buf.handle().begin();
each != buf.handle().end();
++each)
{
OSStatus sta = AudioQueueEnqueueBuffer(buf.queue, *each, 0, NULL);
if (sta)
{
trace_msg("failed to add audio buffer");
}
else
{
++suc;
}
}
// if success, the buffer will freed when dispose the queue.
buf.need_release = suc == 0;
return suc != 0;
# endif
return false;
}
void auAudioOutputCallback(void *SELF, AudioQueueRef queue, AudioQueueBufferRef buffer)
{
Audio* self = (Audio*) SELF;
int resultFrames = self->audioCallback(SELF, (auSample_t*)buffer->mAudioData, (buffer->mAudioDataBytesCapacity / self->dataFormat.mBytesPerFrame), self->dataFormat.mChannelsPerFrame);
buffer->mAudioDataByteSize = resultFrames * self->dataFormat.mBytesPerFrame;//buffer->mAudioDataBytesCapacity;
AudioQueueEnqueueBuffer(queue, buffer, 0, NULL);
}
/*auStart-------------------------------------------------*/
BOOL auPlay(Audio* self)
{
if(!self->isPlaying)
{
#ifdef __APPLE__
int i;
for(i=0; i<AU_NUM_AUDIO_BUFFERS; i++)
{
if(self->isOutput)
auAudioOutputCallback(self, self->queue, self->buffers[i]);
else
AudioQueueEnqueueBuffer(self->queue, self->buffers[i],0, NULL);
}
OSStatus error = AudioQueueStart(self->queue, NULL);
if(error) fprintf(stderr, "Audio.c: unable to start queue\n");
#elif defined __linux__
int error = pthread_create(&(self->thread), NULL, auAudioCallback, self);
if(error != 0) perror("Audio.c: error creating Audio thread");
#endif
else self->isPlaying = YES;
}
return self->isPlaying;
}
// Audio Queue callback function, called when an input buffer has been filled.
static void MyAQInputCallback(void *inUserData, AudioQueueRef inQueue,
AudioQueueBufferRef inBuffer,
const AudioTimeStamp *inStartTime,
UInt32 inNumPackets,
const AudioStreamPacketDescription *inPacketDesc)
{
MyRecorder *recorder = (MyRecorder *)inUserData;
// if inNumPackets is greater then zero, our buffer contains audio data
// in the format we specified (AAC)
if (inNumPackets > 0)
{
// write packets to file
CheckError(AudioFileWritePackets(recorder->recordFile, FALSE, inBuffer->mAudioDataByteSize,
inPacketDesc, recorder->recordPacket, &inNumPackets,
inBuffer->mAudioData), "AudioFileWritePackets failed");
// increment packet index
recorder->recordPacket += inNumPackets;
}
// if we're not stopping, re-enqueue the buffer so that it gets filled again
if (recorder->running)
CheckError(AudioQueueEnqueueBuffer(inQueue, inBuffer,
0, NULL), "AudioQueueEnqueueBuffer failed");
}
void CAudioQueueManager::_HandleOutputBuffer(AudioQueueBufferRef outBuffer) {
if (!_isRunning || _soundQBuffer.SoundCount() == 0) {
outBuffer->mAudioDataByteSize = outBuffer->mAudioDataBytesCapacity;
bzero(outBuffer->mAudioData, outBuffer->mAudioDataBytesCapacity);
} else {
int neededFrames = _framesPerBuffer;
unsigned char* buf = (unsigned char*)outBuffer->mAudioData;
int bytesInBuffer = 0;
for ( ; _soundQBuffer.SoundCount() && neededFrames; neededFrames--) {
short* buffer = _soundQBuffer.DequeueSoundBuffer();
memcpy(buf, buffer, _bytesPerQueueBuffer);
_soundQBuffer.EnqueueFreeBuffer(buffer);
OSAtomicAdd32(-_sampleFrameCount, &_samplesInQueue);
buf += _bytesPerQueueBuffer;
bytesInBuffer += _bytesPerQueueBuffer;
}
outBuffer->mAudioDataByteSize = bytesInBuffer;
#if defined(DEBUG_SOUND)
if (outBuffer->mAudioDataByteSize == 0)
printf("audio buffer underrun.");
else if (outBuffer->mAudioDataByteSize < outBuffer->mAudioDataBytesCapacity)
printf("audio buffer less than capacity %u < %u.", (unsigned int)outBuffer->mAudioDataByteSize, (unsigned int)outBuffer->mAudioDataBytesCapacity);
#endif
}
OSStatus res = AudioQueueEnqueueBuffer(_queue, outBuffer, 0, NULL);
if (res != 0)
throw "Unable to enqueue buffer";
}
/** @internal @This handles audio input.
*
* @param upipe description structure of the pipe
* @param uref uref structure
* @param upump_p reference to upump structure
*/
static void upipe_osx_audioqueue_sink_input_audio(struct upipe *upipe,
struct uref *uref, struct upump **upump_p)
{
struct upipe_osx_audioqueue_sink *osx_audioqueue =
upipe_osx_audioqueue_sink_from_upipe(upipe);
struct AudioQueueBuffer *qbuf;
size_t size = 0;
if (unlikely(!ubase_check(uref_block_size(uref, &size)))) {
upipe_warn(upipe, "could not get block size");
uref_free(uref);
return;
}
/* TODO block ? */
#if 0
upump_mgr_use(upump->mgr);
upump_mgr_sink_block(upump->mgr);
#endif
/* allocate queue buf, extract block, enqueue
* Audioqueue has no support for "external" buffers */
AudioQueueAllocateBuffer(osx_audioqueue->queue, size, &qbuf);
uref_block_extract(uref, 0, -1, qbuf->mAudioData);
qbuf->mAudioDataByteSize = size;
qbuf->mUserData = (*upump_p)->mgr;
AudioQueueEnqueueBuffer(osx_audioqueue->queue, qbuf, 0, NULL);
uref_free(uref);
}
void AudioPluginOSX::AudioCallback(void * arg, AudioQueueRef queue, AudioQueueBufferRef buffer)
{
AudioPluginOSX * plugin = static_cast<AudioPluginOSX *>(arg);
u32 num_samples = buffer->mAudioDataBytesCapacity / sizeof(Sample);
u32 samples_written = plugin->mAudioBuffer.Drain(static_cast<Sample *>(buffer->mAudioData), num_samples);
u32 remaining_samples = plugin->mAudioBuffer.GetNumBufferedSamples();
plugin->mBufferLenMs = (1000 * remaining_samples) / kOutputFrequency;
float ms = (float)samples_written * 1000.f / (float)kOutputFrequency;
DPF_AUDIO("Playing %d samples @%dHz - %.2fms - bufferlen now %d\n",
samples_written, kOutputFrequency, ms, plugin->mBufferLenMs);
if (samples_written == 0)
{
// Would be nice to sleep here until we have something to play,
// but AudioQueue doesn't seem to like that.
// Leave the buffer untouched, and requeue for now.
DPF_AUDIO("********************* Audio buffer is empty ***********************\n");
}
else
{
buffer->mAudioDataByteSize = samples_written * sizeof(Sample);
}
AudioQueueEnqueueBuffer(queue, buffer, 0, NULL);
if (!plugin->mKeepRunning)
{
CFRunLoopStop(CFRunLoopGetCurrent());
}
}
void AudioQueueCallback(void * inUserData, AudioQueueRef inAQ, AudioQueueBufferRef inBuffer) {
audio_output_t * p_aout = (audio_output_t *)inUserData;
block_t * p_buffer = NULL;
if (p_aout) {
struct aout_sys_t * p_sys = p_aout->sys;
aout_packet_t * packet = &p_sys->packet;
if (packet)
{
vlc_mutex_lock( &packet->lock );
p_buffer = aout_FifoPop2( &packet->fifo );
vlc_mutex_unlock( &packet->lock );
}
}
if ( p_buffer != NULL ) {
memcpy( inBuffer->mAudioData, p_buffer->p_buffer, p_buffer->i_buffer );
inBuffer->mAudioDataByteSize = p_buffer->i_buffer;
block_Release( p_buffer );
} else {
memset( inBuffer->mAudioData, 0, inBuffer->mAudioDataBytesCapacity );
inBuffer->mAudioDataByteSize = inBuffer->mAudioDataBytesCapacity;
}
AudioQueueEnqueueBuffer(inAQ, inBuffer, 0, NULL);
}
static void MyAQOutputCallback(void *inUserData, AudioQueueRef inAQ, AudioQueueBufferRef inCompleteAQBuffer)
{
MyPlayer *aqp = (MyPlayer*)inUserData;
if (aqp->isDone) return;
// read audio data from file into supplied buffer
UInt32 numBytes;
UInt32 nPackets = aqp->numPacketsToRead;
CheckError(AudioFileReadPackets(aqp->playbackFile,
false,
&numBytes,
aqp->packetDescs,
aqp->packetPosition,
&nPackets,
inCompleteAQBuffer->mAudioData),
"AudioFileReadPackets failed");
// enqueue buffer into the Audio Queue
// if nPackets == 0 it means we are EOF (all data has been read from file)
if (nPackets > 0)
{
inCompleteAQBuffer->mAudioDataByteSize = numBytes;
AudioQueueEnqueueBuffer(inAQ,
inCompleteAQBuffer,
(aqp->packetDescs ? nPackets : 0),
aqp->packetDescs);
aqp->packetPosition += nPackets;
}
else
{
CheckError(AudioQueueStop(inAQ, false), "AudioQueueStop failed");
aqp->isDone = true;
}
}
void WavPlayer::aqBufferCallback(void *in, AudioQueueRef inQ, AudioQueueBufferRef outQB)
{
AQCallbackStruct *aqc;
unsigned char *coreAudioBuffer;
aqc = (AQCallbackStruct *) in;
coreAudioBuffer = (unsigned char*) outQB->mAudioData;
printf("Sync: %u / %u\n", (unsigned int)aqc->PlayPtr, (unsigned int)aqc->SampleLen);
if(aqc->FrameCount > 0)
{
outQB->mAudioDataByteSize = aqc->DataFormat.mBytesPerFrame * aqc->FrameCount;
for(int i = 0; i < aqc->FrameCount * aqc->DataFormat.mBytesPerFrame; i++)
{
if(aqc->PlayPtr > aqc->SampleLen)
{
aqc->PlayPtr = 0;
i = 0;
}
coreAudioBuffer[i] = aqc->PCMBuffer[aqc->PlayPtr];
aqc->PlayPtr++;
}
AudioQueueEnqueueBuffer(inQ, outQB, 0, NULL);
}
}
// ____________________________________________________________________________________
// AudioQueue callback function, called when an input buffers has been filled.
static void MyInputBufferHandler( void * inUserData,
AudioQueueRef inAQ,
AudioQueueBufferRef inBuffer,
const AudioTimeStamp * inStartTime,
UInt32 inNumPackets,
const AudioStreamPacketDescription *inPacketDesc)
{
MyRecorder *aqr = (MyRecorder *)inUserData;
try {
if (aqr->verbose) {
printf("buf data %p, 0x%x bytes, 0x%x packets\n", inBuffer->mAudioData,
(int)inBuffer->mAudioDataByteSize, (int)inNumPackets);
}
if (inNumPackets > 0) {
// write packets to file
XThrowIfError(AudioFileWritePackets(aqr->recordFile, FALSE, inBuffer->mAudioDataByteSize,
inPacketDesc, aqr->recordPacket, &inNumPackets, inBuffer->mAudioData),
"AudioFileWritePackets failed");
aqr->recordPacket += inNumPackets;
}
// if we're not stopping, re-enqueue the buffe so that it gets filled again
if (aqr->running)
XThrowIfError(AudioQueueEnqueueBuffer(inAQ, inBuffer, 0, NULL), "AudioQueueEnqueueBuffer failed");
}
catch (CAXException e) {
char buf[256];
fprintf(stderr, "MyInputBufferHandler: %s (%s)\n", e.mOperation, e.FormatError(buf));
}
}
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 AudioEnginePropertyListenerProc (void *inUserData, AudioQueueRef inAQ, AudioQueuePropertyID inID) {
//We are only interested in the property kAudioQueueProperty_IsRunning
if (inID != kAudioQueueProperty_IsRunning) return;
struct myAQStruct *myInfo = (struct myAQStruct *)inUserData;
/* Get the current status of the AQ, running or stopped */
UInt32 isQueueRunning = false;
UInt32 size = sizeof(isQueueRunning);
AudioQueueGetProperty(myInfo->mQueue, kAudioQueueProperty_IsRunning, &isQueueRunning, &size);
/* The callback event is the start of the queue */
if (isQueueRunning) {
/* reset current packet counter */
myInfo->mCurrentPacket = 0;
for (int i = 0; i < 3; i++) {
/*
* For the first time allocate buffers for this AQ.
* Buffers are reused in turns until the AQ stops
*/
AudioQueueAllocateBuffer(myInfo->mQueue, bufferSizeInSamples * 4, &myInfo->mBuffers[i]);
UInt32 bytesRead = bufferSizeInSamples * 4;
UInt32 packetsRead = bufferSizeInSamples;
/*
* Read data from audio source into the buffer of AQ
* supplied in this callback event. Buffers are used in turns
* to hide the latency
*/
AudioFileReadPacketData(
myInfo->mAudioFile,
false, /* isUseCache, set to false */
&bytesRead,
NULL,
myInfo->mCurrentPacket,
&packetsRead,
myInfo->mBuffers[i]->mAudioData);
/* in case the buffer size is smaller than bytes requestd to read */
myInfo->mBuffers[i]->mAudioDataByteSize = bytesRead;
myInfo->mCurrentPacket += packetsRead;
AudioQueueEnqueueBuffer(myInfo->mQueue, myInfo->mBuffers[i], 0, NULL);
}
} else {
/* The callback event is the state of AQ changed to not running */
if (myInfo->mAudioFile != NULL) {
AudioQueueStop(myInfo->mQueue, false);
AudioFileClose(myInfo->mAudioFile);
myInfo->mAudioFile = NULL;
for (int i = 0; i < 3; i++) {
AudioQueueFreeBuffer(myInfo->mQueue, myInfo->mBuffers[i]);
myInfo->mBuffers[i] = NULL;
}
CFRunLoopStop(CFRunLoopGetCurrent());
}
}
}
void AQBufferCallback(void *in,
AudioQueueRef inQ,
AudioQueueBufferRef outQB) {
AQCallbackStruct *aqc;
short *coreAudioBuffer;
short sample;
int i;
aqc = (AQCallbackStruct *) in;
coreAudioBuffer = (short*) outQB->mAudioData;
printf("Sync: %ld / %ld\n", aqc->playPtr, aqc->sampleLen);
if (aqc->playPtr >= aqc->sampleLen) {
AudioQueueDispose(aqc->queue, true);
return;
}
if (aqc->frameCount > 0) {
outQB->mAudioDataByteSize = 4 * aqc->frameCount;
for(i=0; i<aqc->frameCount*2; i+=2) {
if (aqc->playPtr > aqc->sampleLen)
sample = 0;
else
sample = (aqc->pcmBuffer[aqc->playPtr]);
coreAudioBuffer[i] = sample;
coreAudioBuffer[i+1] = sample;
aqc->playPtr++;
}
AudioQueueEnqueueBuffer(inQ, outQB, 0, NULL);
}
}
static void rdpsnd_audio_play(rdpsndDevicePlugin* device, BYTE* data, int size)
{
rdpsndAudioQPlugin* aq_plugin_p = (rdpsndAudioQPlugin *) device;
AudioQueueBufferRef aq_buf_ref;
int len;
if (!aq_plugin_p->is_open) {
return;
}
/* get next empty buffer */
aq_buf_ref = aq_plugin_p->buffers[aq_plugin_p->buf_index];
// fill aq_buf_ref with audio data
len = size > AQ_BUF_SIZE ? AQ_BUF_SIZE : size;
memcpy(aq_buf_ref->mAudioData, (char *) data, len);
aq_buf_ref->mAudioDataByteSize = len;
// add buffer to audioqueue
AudioQueueEnqueueBuffer(aq_plugin_p->aq_ref, aq_buf_ref, 0, 0);
// update buf_index
aq_plugin_p->buf_index++;
if (aq_plugin_p->buf_index >= AQ_NUM_BUFFERS) {
aq_plugin_p->buf_index = 0;
}
}
static void HandleOutputBuffer (void *aqData,
AudioQueueRef inAQ,
AudioQueueBufferRef inBuffer) {
AQPlayerState *pAqData = (AQPlayerState *) aqData;
if (pAqData->mIsRunning == 0) return;
UInt32 numBytesReadFromFile;
UInt32 numPackets = pAqData->mNumPacketsToRead;
AudioFileReadPackets (pAqData->mAudioFile,
false,
&numBytesReadFromFile,
pAqData->mPacketDescs,
pAqData->mCurrentPacket,
&numPackets,
inBuffer->mAudioData);
if (numPackets > 0) {
inBuffer->mAudioDataByteSize = numBytesReadFromFile;
AudioQueueEnqueueBuffer (pAqData->mQueue,
inBuffer,
(pAqData->mPacketDescs ? numPackets : 0),
pAqData->mPacketDescs);
pAqData->mCurrentPacket += numPackets;
} else {
AudioQueueStop (pAqData->mQueue,
false);
//printf("Play Stopped!\n");
pAqData->mIsRunning = false;
}
}
void setupRead(MSFilter * f)
{
AQData *d = (AQData *) f->data;
OSStatus err;
// allocate and enqueue buffers
int bufferIndex;
for (bufferIndex = 0; bufferIndex < kNumberAudioInDataBuffers;
++bufferIndex) {
AudioQueueBufferRef buffer;
err = AudioQueueAllocateBuffer(d->readQueue,
d->readBufferByteSize, &buffer);
if (err != noErr) {
ms_error("setupRead:AudioQueueAllocateBuffer %d", err);
}
err = AudioQueueEnqueueBuffer(d->readQueue, buffer, 0, NULL);
if (err != noErr) {
ms_error("AudioQueueEnqueueBuffer %d", err);
}
}
}
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, false, &numBytes, myInfo->mPacketDescs, myInfo->mCurrentPacket, &nPackets,
inCompleteAQBuffer->mAudioData);
if (result) {
DebugMessageN1 ("Error reading from file: %d\n", (int)result);
exit(1);
}
if (nPackets > 0) {
inCompleteAQBuffer->mAudioDataByteSize = numBytes;
AudioQueueEnqueueBuffer(inAQ, inCompleteAQBuffer, (myInfo->mPacketDescs ? nPackets : 0), myInfo->mPacketDescs);
myInfo->mCurrentPacket += nPackets;
} else {
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;
}
}
// ____________________________________________________________________________________
// AudioQueue callback function, called when an input buffers has been filled.
static void MyInputBufferHandler( void * inUserData,
AudioQueueRef inAQ,
AudioQueueBufferRef inBuffer,
const AudioTimeStamp * inStartTime,
UInt32 inNumPackets,
const AudioStreamPacketDescription *inPacketDesc)
{
MyRecorder *aqr = (MyRecorder *)inUserData;
if (aqr->verbose) {
printf("buf data %p, 0x%x bytes, 0x%x packets\n", inBuffer->mAudioData,
(int)inBuffer->mAudioDataByteSize, (int)inNumPackets);
}
if (inNumPackets > 0) {
// write packets to file
CheckError(AudioFileWritePackets(aqr->recordFile, FALSE, inBuffer->mAudioDataByteSize,
inPacketDesc, aqr->recordPacket, &inNumPackets, inBuffer->mAudioData),
"AudioFileWritePackets failed");
aqr->recordPacket += inNumPackets;
}
// if we're not stopping, re-enqueue the buffe so that it gets filled again
if (aqr->running)
CheckError(AudioQueueEnqueueBuffer(inAQ, inBuffer, 0, NULL), "AudioQueueEnqueueBuffer failed");
}
static GstFlowReturn
gst_atdec_handle_frame (GstAudioDecoder * decoder, GstBuffer * buffer)
{
AudioTimeStamp timestamp = { 0 };
AudioStreamPacketDescription packet;
AudioQueueBufferRef input_buffer, output_buffer;
GstBuffer *out;
GstMapInfo info;
GstAudioInfo *audio_info;
int size, out_frames;
GstFlowReturn flow_ret = GST_FLOW_OK;
GstATDec *atdec = GST_ATDEC (decoder);
if (buffer == NULL)
return GST_FLOW_OK;
audio_info = gst_audio_decoder_get_audio_info (decoder);
/* copy the input buffer into an AudioQueueBuffer */
size = gst_buffer_get_size (buffer);
AudioQueueAllocateBuffer (atdec->queue, size, &input_buffer);
gst_buffer_extract (buffer, 0, input_buffer->mAudioData, size);
input_buffer->mAudioDataByteSize = size;
/* assume framed input */
packet.mStartOffset = 0;
packet.mVariableFramesInPacket = 1;
packet.mDataByteSize = size;
/* enqueue the buffer. It will get free'd once the gst_atdec_buffer_emptied
* callback is called
*/
AudioQueueEnqueueBuffer (atdec->queue, input_buffer, 1, &packet);
/* figure out how many frames we need to pull out of the queue */
out_frames = GST_CLOCK_TIME_TO_FRAMES (GST_BUFFER_DURATION (buffer),
audio_info->rate);
size = out_frames * audio_info->bpf;
AudioQueueAllocateBuffer (atdec->queue, size, &output_buffer);
/* pull the frames */
AudioQueueOfflineRender (atdec->queue, ×tamp, output_buffer, out_frames);
if (output_buffer->mAudioDataByteSize) {
out =
gst_audio_decoder_allocate_output_buffer (decoder,
output_buffer->mAudioDataByteSize);
gst_buffer_map (out, &info, GST_MAP_WRITE);
memcpy (info.data, output_buffer->mAudioData,
output_buffer->mAudioDataByteSize);
gst_buffer_unmap (out, &info);
flow_ret = gst_audio_decoder_finish_frame (decoder, out, 1);
}
AudioQueueFreeBuffer (atdec->queue, output_buffer);
return flow_ret;
}
// Define a playback audio queue callback function
static void AQTestBufferCallback(
void *inUserData,
AudioQueueRef inAQ,
AudioQueueBufferRef inCompleteAQBuffer
)
{
struct myAQStruct *myInfo = (struct myAQStruct *)inUserData;
if (myInfo->mDone) return;
UInt32 numBytes;
UInt32 nPackets = myInfo->mNumPacketsToRead;
printf("called\n");
UInt32 bytesRead = bufferSizeInSamples * 4;
UInt32 packetsRead = bufferSizeInSamples;
AudioFileReadPacketData(
myInfo->mAudioFile,
false,
&bytesRead,
NULL,
currentPacket,
&packetsRead,
inCompleteAQBuffer->mAudioData);
inCompleteAQBuffer->mAudioDataByteSize = bytesRead;
currentPacket += packetsRead;
if (bytesRead == 0) {
AudioQueueStop(inAQ, false);
} else {
AudioQueueEnqueueBuffer(inAQ, inCompleteAQBuffer, 0, NULL);
}
/* printf("called\n"); */
/* AudioFileReadPacketData( */
/* myInfo->mAudioFile, */
/* false, */
/* &numBytes, */
/* myInfo->mPacketDescs, */
/* myInfo->mCurrentPacket, */
/* &nPackets, */
/* inCompleteAQBuffer->mAudioData */
/* ); */
/* printf("read %d packets %d bytes\n", numBytes, nPackets); */
/* if (nPackets > 0) { */
/* inCompleteAQBuffer->mAudioDataByteSize = numBytes; */
/* AudioQueueEnqueueBuffer ( */
/* inAQ, */
/* inCompleteAQBuffer, */
/* (myInfo->mPacketDescs ? nPackets : 0), */
/* myInfo->mPacketDescs */
/* ); */
/* myInfo->mCurrentPacket += nPackets; */
/* } else { */
/* AudioQueueStop ( */
/* myInfo->mQueue, */
/* false */
/* ); */
/* myInfo->mDone = true; */
/* } */
}
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;
}
}
static void writeCallback(void *aqData,
AudioQueueRef inAQ, AudioQueueBufferRef inBuffer)
{
AQData *d = (AQData *) aqData;
OSStatus err;
int len =
(d->writeBufferByteSize * d->writeAudioFormat.mSampleRate / 1) /
d->devicewriteFormat.mSampleRate /
d->devicewriteFormat.mChannelsPerFrame;
ms_mutex_lock(&d->mutex);
if (d->write_started == FALSE) {
ms_mutex_unlock(&d->mutex);
return;
}
if (d->bufferizer->size >= len) {
#if 0
UInt32 bsize = d->writeBufferByteSize;
uint8_t *pData = ms_malloc(len);
ms_bufferizer_read(d->bufferizer, pData, len);
err = AudioConverterConvertBuffer(d->writeAudioConverter,
len,
pData,
&bsize, inBuffer->mAudioData);
if (err != noErr) {
ms_error("writeCallback: AudioConverterConvertBuffer %d", err);
}
ms_free(pData);
if (bsize != d->writeBufferByteSize)
ms_warning("d->writeBufferByteSize = %i len = %i bsize = %i",
d->writeBufferByteSize, len, bsize);
#else
ms_bufferizer_read(d->bufferizer, inBuffer->mAudioData, len);
#endif
} else {
memset(inBuffer->mAudioData, 0, d->writeBufferByteSize);
}
inBuffer->mAudioDataByteSize = d->writeBufferByteSize;
if (gain_changed_out == true)
{
AudioQueueSetParameter (d->writeQueue,
kAudioQueueParam_Volume,
gain_volume_out);
gain_changed_out = false;
}
err = AudioQueueEnqueueBuffer(d->writeQueue, inBuffer, 0, NULL);
if (err != noErr) {
ms_error("AudioQueueEnqueueBuffer %d", err);
}
ms_mutex_unlock(&d->mutex);
}
void putWriteAQ(void *aqData, int queuenum)
{
AQData *d = (AQData *) aqData;
OSStatus err;
err = AudioQueueEnqueueBuffer(d->writeQueue,
d->writeBuffers[queuenum], 0, NULL);
if (err != noErr) {
ms_error("AudioQueueEnqueueBuffer %d", err);
}
}
static void AQBufferCallback(void *userdata,
AudioQueueRef outQ,
AudioQueueBufferRef outQB)
{
unsigned char *coreAudioBuffer;
coreAudioBuffer = (unsigned char*) outQB->mAudioData;
int res = dequeue(coreAudioBuffer, in.mDataFormat.mBytesPerFrame * in.frameCount);
outQB->mAudioDataByteSize = in.mDataFormat.mBytesPerFrame * in.frameCount;
AudioQueueEnqueueBuffer(outQ, outQB, 0, NULL);
}
long AudioStreamDecoder::EnqueueBuffer()
{
bool locked = false;
if (mFinished)
return 0;
long err = AudioQueueEnqueueBuffer(mQueue, *mCurrentBuffer, 0, NULL);
BAIL_IF(err, "AudioQueueEnqueueBuffer returned %ld\n", err);
if (++mCurrentBuffer == mBuffers + kBufferCount)
mCurrentBuffer = mBuffers;
if (!mStarted && !mFinished)
{
mStarted = true;
err = AudioQueueStart(mQueue, NULL);
BAIL_IF(err, "AudioQueueStart returned %ld\n", err);
}
err = pthread_mutex_lock(&mMutex);
BAIL_IF(err, "pthread_mutex_lock returned %ld\n", err);
locked = true;
while ((*mCurrentBuffer)->mUserData && !mFinished)
{
err = pthread_cond_wait(&mCond, &mMutex);
BAIL_IF(err, "pthread_cond_wait returned %ld\n", err);
}
(*mCurrentBuffer)->mUserData = this;
(*mCurrentBuffer)->mAudioDataByteSize = 0;
(*mCurrentBuffer)->mPacketDescriptionCount = 0;
bail:
long err2;
if (locked)
{
err2 = pthread_mutex_unlock(&mMutex);
CARP_IF(err2, "pthread_mutex_unlock returned %ld\n", err2);
}
if (err && mStarted)
{
err2 = SetFinished();
CARP_IF(err2, "SetFinished returned %ld\n", err2);
}
return err;
}
static void AQBufferCallback(void *userdata, AudioQueueRef outQ,
AudioQueueBufferRef outQB)
{
unsigned char *coreAudioBuffer;
coreAudioBuffer = (unsigned char*) outQB->mAudioData;
outQB->mAudioDataByteSize = IPHONE_AUDIO_BUFFER_SIZE;
AudioQueueSetParameter(outQ, kAudioQueueParam_Volume, __audioVolume);
audio_callback(coreAudioBuffer, IPHONE_AUDIO_BUFFER_SIZE);
AudioQueueEnqueueBuffer(outQ, outQB, 0, NULL);
}
void Audio_Queue::enqueueBuffer()
{
AQ_ASSERT(!m_bufferInUse[m_fillBufferIndex]);
Stream_Configuration *config = Stream_Configuration::configuration();
AQ_TRACE("%s: enter\n", __PRETTY_FUNCTION__);
pthread_mutex_lock(&m_bufferInUseMutex);
m_bufferInUse[m_fillBufferIndex] = true;
m_buffersUsed++;
// enqueue buffer
AudioQueueBufferRef fillBuf = m_audioQueueBuffer[m_fillBufferIndex];
fillBuf->mAudioDataByteSize = m_bytesFilled;
pthread_mutex_unlock(&m_bufferInUseMutex);
AQ_ASSERT(m_packetsFilled > 0);
OSStatus err = AudioQueueEnqueueBuffer(m_outAQ, fillBuf, m_packetsFilled, m_packetDescs);
if (!err) {
m_lastError = noErr;
start();
} else {
/* If we get an error here, it very likely means that the audio queue is no longer
running */
AQ_TRACE("%s: error in AudioQueueEnqueueBuffer\n", __PRETTY_FUNCTION__);
m_lastError = err;
return;
}
pthread_mutex_lock(&m_bufferInUseMutex);
// go to next buffer
if (++m_fillBufferIndex >= config->bufferCount) {
m_fillBufferIndex = 0;
}
// reset bytes filled
m_bytesFilled = 0;
// reset packets filled
m_packetsFilled = 0;
// wait until next buffer is not in use
while (m_bufferInUse[m_fillBufferIndex]) {
AQ_TRACE("waiting for buffer %u\n", (unsigned int)m_fillBufferIndex);
pthread_cond_wait(&m_bufferFreeCondition, &m_bufferInUseMutex);
}
pthread_mutex_unlock(&m_bufferInUseMutex);
}
static void audio_callback (void *aux, AudioQueueRef aq, AudioQueueBufferRef bufout)
{
audio_fifo_t *af = aux;
audio_fifo_data_t *afd = audio_get(af);
bufout->mAudioDataByteSize = afd->nsamples * sizeof(short) * afd->channels;
assert(bufout->mAudioDataByteSize <= state.buffer_size);
memcpy(bufout->mAudioData, afd->samples, bufout->mAudioDataByteSize);
AudioQueueEnqueueBuffer(state.queue, bufout, 0, NULL);
free(afd);
}
