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); }