/*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;
}
void seekToPacket(uint64_t packet) {
AudioQueueStop(aqData.mQueue, true);
aqData.mCurrentPacket = rand()%1000;
primeBuffer();
AudioQueueStart(aqData.mQueue, NULL);
}
void CL_SoundOutput_MacOSX::mixer_thread_starting()
{
audio_format.mSampleRate = frequency;
audio_format.mFormatID = kAudioFormatLinearPCM;
audio_format.mFormatFlags = kAudioFormatFlagsCanonical;
audio_format.mBytesPerPacket = 2 * sizeof(short);
audio_format.mFramesPerPacket = 1;
audio_format.mBytesPerFrame = 2 * sizeof(short);
audio_format.mChannelsPerFrame = 2;
audio_format.mBitsPerChannel = sizeof(short) * 8;
audio_format.mReserved = 0;
OSStatus result = AudioQueueNewOutput(&audio_format, &CL_SoundOutput_MacOSX::static_audio_queue_callback, this, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 0, &audio_queue);
if (result != 0)
throw CL_Exception("AudioQueueNewOutput failed");
for (int i = 0; i < fragment_buffer_count; i++)
{
result = AudioQueueAllocateBuffer(audio_queue, fragment_size * sizeof(short) * 2, &audio_buffers[i]);
if (result != 0)
throw CL_Exception("AudioQueueAllocateBuffer failed");
audio_queue_callback(audio_queue, audio_buffers[i]);
}
result = AudioQueueStart(audio_queue, 0);
if (result != 0)
throw CL_Exception("AudioQueueStart failed");
}
void
Moose::Sound::CMusicClip::Play()
{
if ( IsPaused())
{
m_bPaused = false;
pthread_mutex_lock(&m_pData->mutex);
AudioQueueStart(m_pData->audioQueue, NULL);
pthread_mutex_unlock(&m_pData->mutex);
}
else
{
if ( IsRunning()) Stop();
if ( m_bHasThread )
{
void *status;
pthread_join(m_thread, &status);
m_bHasThread = false;
}
OSStatus err = pthread_create( &m_thread, NULL, audio_decode_play_proc, this);
if ( err ) {
g_Error << "Could not create thread for music clip, error: " << err << endl;
}
}
}
bool QueueAudioData::start()
{
printf("QueueAudioData::start()\n");
AudioQueueStart(audioQueue, 0);
running = true;
return true;
}
void play() {
int i;
AudioStreamBasicDescription format;
AudioQueueRef queue;
AudioQueueBufferRef buffers[NUM_BUFFERS];
format.mSampleRate = SAMPLE_RATE;
format.mFormatID = kAudioFormatLinearPCM;
format.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger |
kAudioFormatFlagIsPacked;
format.mBitsPerChannel = 8*sizeof(SAMPLE_TYPE);
format.mChannelsPerFrame = NUM_CHANNELS;
format.mBytesPerFrame = sizeof(SAMPLE_TYPE)*NUM_CHANNELS;
format.mFramesPerPacket = 1;
format.mBytesPerPacket = format.mBytesPerFrame*format.mFramesPerPacket;
format.mReserved = 0;
AudioQueueNewOutput(&format, callback, NULL, CFRunLoopGetCurrent(),
kCFRunLoopCommonModes, 0, &queue);
for (i = 0; i < NUM_BUFFERS; i++) {
AudioQueueAllocateBuffer(queue, BUFFER_SIZE, &buffers[i]);
buffers[i]->mAudioDataByteSize = BUFFER_SIZE;
callback(NULL, queue, buffers[i]);
}
AudioQueueStart(queue, NULL);
CFRunLoopRun();
}
void play() {
OSStatus status;
aqData.mIsRunning = true; // 1
aqData.mCurrentPacket = 0; // 1
primeBuffer();
Float32 gain = 1.0; // 1
// Optionally, allow user to override gain setting here
status = AudioQueueSetParameter ( // 2
aqData.mQueue, // 3
kAudioQueueParam_Volume, // 4
gain // 5
);
checkStatus(status);
status = AudioQueueStart ( // 2
aqData.mQueue, // 3
NULL // 4
);
checkStatus(status);
}
void IPhoneSoundDevice::Enable(bool fEnable)
{
base::CritScope cs(&m_crit);
if (fEnable) {
if (!m_fEnable) {
memset(m_achnl, 0, sizeof(m_achnl));
m_tSilence = 0;
m_fEnable = true;
for (int i = 0; i < kcBuffers; i++) {
InitAudioBuffer(m_apaqb[i]);
}
AudioQueuePrime(m_haq, 0, NULL);
AudioQueueStart(m_haq, NULL);
SetSoundServiceDevice(this);
}
} else {
if (m_fEnable) {
m_fEnable = false;
memset(m_achnl, 0, sizeof(m_achnl));
m_tSilence = 0;
AudioQueueStop(m_haq, false);
SetSoundServiceDevice(NULL);
}
}
}
int32_t setup_queue(
ALACMagicCookie cookie,
PlayerInfo *playerInfo,
uint32_t buffer_size,
uint32_t num_buffers,
uint32_t num_packets
) {
// Create Audio Queue for ALAC
AudioStreamBasicDescription inFormat = {0};
inFormat.mSampleRate = ntohl(cookie.sampleRate);
inFormat.mFormatID = kAudioFormatAppleLossless;
inFormat.mFormatFlags = 0; // ALAC uses no flags
inFormat.mBytesPerPacket = 0; // Variable size (must use AudioStreamPacketDescription)
inFormat.mFramesPerPacket = ntohl(cookie.frameLength);
inFormat.mBytesPerFrame = 0; // Compressed
inFormat.mChannelsPerFrame = 2; // Stero TODO: get from fmtp?
inFormat.mBitsPerChannel = 0; // Compressed
inFormat.mReserved = 0;
OSStatus err = AudioQueueNewOutput(
&inFormat,
c_callback,
playerInfo, // User data
NULL, // Run on audio queue's thread
NULL, // Callback run loop's mode
0, // Reserved
&playerInfo->queue);
if (err) return err;
// Need to set the magic cookie too (tail fmtp)
err = AudioQueueSetProperty(playerInfo->queue, kAudioQueueProperty_MagicCookie,
&cookie, sizeof(ALACMagicCookie));
if (err) return err;
// Create input buffers, and enqueue using callback
for (int i = 0; i < num_buffers; i++) {
AudioQueueBufferRef buffer;
err = AudioQueueAllocateBufferWithPacketDescriptions(
playerInfo->queue, buffer_size, num_packets, &buffer);
if (err) return err;
c_callback(playerInfo, playerInfo->queue, buffer);
}
// Volume full
err = AudioQueueSetParameter(playerInfo->queue, kAudioQueueParam_Volume, 1.0);
if (err) return err;
// Prime
err = AudioQueuePrime(playerInfo->queue, 0, NULL);
if (err) return err;
// Start
err = AudioQueueStart(playerInfo->queue, NULL);
if (err) return err;
return 0;
}
static int Open ( vlc_object_t *p_this )
{
audio_output_t *p_aout = (audio_output_t *)p_this;
struct aout_sys_t *p_sys = malloc(sizeof(aout_sys_t));
p_aout->sys = p_sys;
OSStatus status = 0;
// Setup the audio device.
AudioStreamBasicDescription deviceFormat;
deviceFormat.mSampleRate = 44100;
deviceFormat.mFormatID = kAudioFormatLinearPCM;
deviceFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger; // Signed integer, little endian
deviceFormat.mBytesPerPacket = 4;
deviceFormat.mFramesPerPacket = 1;
deviceFormat.mBytesPerFrame = 4;
deviceFormat.mChannelsPerFrame = 2;
deviceFormat.mBitsPerChannel = 16;
deviceFormat.mReserved = 0;
// Create a new output AudioQueue for the device.
status = AudioQueueNewOutput(&deviceFormat, // Format
AudioQueueCallback, // Callback
p_aout, // User data, passed to the callback
CFRunLoopGetMain(), // RunLoop
kCFRunLoopDefaultMode, // RunLoop mode
0, // Flags ; must be zero (per documentation)...
&(p_sys->audioQueue)); // Output
// This will be used for boosting the audio without the need of a mixer (floating-point conversion is expensive on ARM)
// AudioQueueSetParameter(p_sys->audioQueue, kAudioQueueParam_Volume, 12.0); // Defaults to 1.0
msg_Dbg(p_aout, "New AudioQueue output created (status = %i)", status);
// Allocate buffers for the AudioQueue, and pre-fill them.
for (int i = 0; i < NUMBER_OF_BUFFERS; ++i) {
AudioQueueBufferRef buffer = NULL;
status = AudioQueueAllocateBuffer(p_sys->audioQueue, FRAME_SIZE * 4, &buffer);
AudioQueueCallback(NULL, p_sys->audioQueue, buffer);
}
/* Volume is entirely done in software. */
aout_SoftVolumeInit( p_aout );
p_aout->format.i_format = VLC_CODEC_S16L;
p_aout->format.i_physical_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
p_aout->format.i_rate = 44100;
aout_PacketInit(p_aout, &p_sys->packet, FRAME_SIZE);
p_aout->pf_play = aout_PacketPlay;
p_aout->pf_pause = aout_PacketPause;
p_aout->pf_flush = aout_PacketFlush;
msg_Dbg(p_aout, "Starting AudioQueue (status = %i)", status);
status = AudioQueueStart(p_sys->audioQueue, NULL);
return VLC_SUCCESS;
}
int app_OpenSound(int samples_per_sync, int sample_rate) {
Float64 sampleRate = 44100.0;
int i;
LOGDEBUG("app_SoundOpen()");
app_MuteSound();
if(preferences.muted)
{
return 0;
}
soundInit = 0;
in.mDataFormat.mSampleRate = sampleRate;
in.mDataFormat.mFormatID = kAudioFormatLinearPCM;
in.mDataFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger
| kAudioFormatFlagIsPacked;
in.mDataFormat.mBytesPerPacket = 4;
in.mDataFormat.mFramesPerPacket = 1;
in.mDataFormat.mBytesPerFrame = 2;
in.mDataFormat.mChannelsPerFrame = 2;
in.mDataFormat.mBitsPerChannel = 16;
/* Pre-buffer before we turn on audio */
UInt32 err;
err = AudioQueueNewOutput(&in.mDataFormat,
AQBufferCallback,
&in,
NULL,
kCFRunLoopCommonModes,
0,
&in.queue);
if (err) {
LOGDEBUG("AudioQueueNewOutput err %d\n", err);
}
in.frameCount = 512 * 1; //512; //(1024 * (16)) / 4;
UInt32 bufferBytes = in.frameCount * in.mDataFormat.mBytesPerFrame;
for (i=0; i<AUDIO_BUFFERS; i++) {
err = AudioQueueAllocateBuffer(in.queue, bufferBytes, &in.mBuffers[i]);
if (err) {
LOGDEBUG("AudioQueueAllocateBuffer[%d] err %d\n",i, err);
}
/* "Prime" by calling the callback once per buffer */
AQBufferCallback (&in, in.queue, in.mBuffers[i]);
}
soundInit = 1;
LOGDEBUG("app_QueueSample.AudioQueueStart");
err = AudioQueueStart(in.queue, NULL);
return 0;
}
OSStatus Start()
{
OSStatus result = AudioQueuePrime(mQueue, 1, NULL);
if (result)
{
printf("Error priming queue");
return result;
}
return AudioQueueStart(mQueue, NULL);
}
OSStatus StartQueueIfNeeded(struct audioPlayer* player)
{
OSStatus err = noErr;
if (!player->started) { // start the queue if it has not been started already
err = AudioQueueStart(player->audioQueue, NULL);
if (err) { PRINTERROR("AudioQueueStart"); player->failed = true; return err; }
player->started = true;
}
return err;
}
void audio_start(audio_player_t *player) {
state_t *state = (state_t *) player->internal_state;
if (noErr != AudioQueueStart(state->queue, NULL)) puts("AudioQueueStart failed");
state->playing = true;
if (state->running) {
if (player->on_start) {
player->on_start(player);
}
}
}
OSStatus StartQueueIfNeeded(MyData* myData)
{
OSStatus err = noErr;
if (!myData->started) { // start the queue if it has not been started already
err = AudioQueueStart(myData->audioQueue, NULL);
if (err) { PRINTERROR("AudioQueueStart"); myData->failed = true; return err; }
myData->started = true;
printf("started\n");
}
return err;
}
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);
}
}
void CAudioQueueManager::resume() {
if (_isRunning)
return;
if (!_isInitialized) {
_autoStart = true;
return;
}
AudioQueueStart(_queue, NULL);
_isRunning = true;
}
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;
}
void Audio_Queue::startQueueIfNeeded()
{
if (!m_audioQueueStarted) {
// start the queue if it has not been started already
OSStatus err = AudioQueueStart(m_outAQ, NULL);
if (!err) {
m_audioQueueStarted = true;
m_lastError = noErr;
} else {
m_lastError = err;
}
}
}
/**
* 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;
}
void CAudioQueueManager::setupQueue() {
OSStatus res = AudioQueueNewOutput(&_dataFormat, HandleOutputBuffer, this, CFRunLoopGetCurrent(), kCFRunLoopCommonModes, 0, &_queue);
for (int i = 0; i < kNumberBuffers; i++) {
res = AudioQueueAllocateBuffer(_queue, _bytesPerFrame, &_buffers[i]);
HandleOutputBuffer(this, _queue, _buffers[i]);
}
if (_autoStart) {
_isRunning = true;
res = AudioQueueStart(_queue, NULL);
}
_isInitialized = true;
}
static void aq_put(MSFilter * f, mblk_t * m)
{
AQData *d = (AQData *) f->data;
ms_mutex_lock(&d->mutex);
ms_bufferizer_put(d->bufferizer, m);
ms_mutex_unlock(&d->mutex);
int len =
(d->writeBufferByteSize * d->writeAudioFormat.mSampleRate / 1) /
d->devicewriteFormat.mSampleRate /
d->devicewriteFormat.mChannelsPerFrame;
if (d->write_started == FALSE && d->bufferizer->size >= len) {
AudioQueueBufferRef curbuf = d->writeBuffers[d->curWriteBuffer];
#if 0
OSStatus err;
UInt32 bsize = d->writeBufferByteSize;
uint8_t *pData = ms_malloc(len);
ms_bufferizer_read(d->bufferizer, pData, len);
err = AudioConverterConvertBuffer(d->writeAudioConverter,
len,
pData,
&bsize, curbuf->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, curbuf->mAudioData, len);
#endif
curbuf->mAudioDataByteSize = d->writeBufferByteSize;
putWriteAQ(d, d->curWriteBuffer);
++d->curWriteBuffer;
}
if (d->write_started == FALSE
&& d->curWriteBuffer == kNumberAudioOutDataBuffers - 1) {
OSStatus err;
err = AudioQueueStart(d->writeQueue, NULL // start time. NULL means ASAP.
);
if (err != noErr) {
ms_error("AudioQueueStart -write- %d", err);
}
d->write_started = TRUE;
}
}
/** @internal @This creates a new audioqueue
* @param upipe description structure of the pipe
* @param flow description structure of the flow
* @return an error code
*/
static int upipe_osx_audioqueue_sink_set_flow_def(struct upipe *upipe,
struct uref *flow)
{
OSStatus status;
uint64_t sample_rate = 0; /* hush gcc */
uint8_t channels = 0;
uint8_t sample_size = 0;
struct AudioStreamBasicDescription fmt;
struct upipe_osx_audioqueue_sink *osx_audioqueue =
upipe_osx_audioqueue_sink_from_upipe(upipe);
if (unlikely(osx_audioqueue->queue)) {
upipe_osx_audioqueue_sink_remove(upipe);
}
/* retrieve flow format information */
uref_sound_flow_get_rate(flow, &sample_rate);
uref_sound_flow_get_sample_size(flow, &sample_size);
uref_sound_flow_get_channels(flow, &channels);
/* build format description */
memset(&fmt, 0, sizeof(struct AudioStreamBasicDescription));
fmt.mSampleRate = sample_rate;
fmt.mFormatID = kAudioFormatLinearPCM;
fmt.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
fmt.mFramesPerPacket = 1;
fmt.mChannelsPerFrame = channels;
fmt.mBytesPerPacket = fmt.mBytesPerFrame = sample_size * channels;
fmt.mBitsPerChannel = sample_size * 8;
/* create queue */
status = AudioQueueNewOutput(&fmt, upipe_osx_audioqueue_sink_cb, upipe,
NULL, kCFRunLoopCommonModes, 0, &osx_audioqueue->queue);
if (unlikely(status == kAudioFormatUnsupportedDataFormatError)) {
upipe_warn(upipe, "unsupported data format");
return UBASE_ERR_EXTERNAL;
}
/* change volume */
AudioQueueSetParameter(osx_audioqueue->queue, kAudioQueueParam_Volume,
osx_audioqueue->volume);
/* start queue ! */
AudioQueueStart(osx_audioqueue->queue, NULL);
upipe_notice_va(upipe, "audioqueue started (%uHz, %hhuch, %db)",
sample_rate, channels, sample_size*8);
return UBASE_ERR_NONE;
}
int playbuffer(void *pcmbuffer, unsigned long len) {
AQCallbackStruct aqc;
UInt32 err, bufferSize;
int i;
aqc.mDataFormat.mSampleRate = SAMPLE_RATE;
aqc.mDataFormat.mFormatID = kAudioFormatLinearPCM;
aqc.mDataFormat.mFormatFlags =
kLinearPCMFormatFlagIsSignedInteger
| kAudioFormatFlagIsPacked;
aqc.mDataFormat.mBytesPerPacket = 4;
aqc.mDataFormat.mFramesPerPacket = 1;
aqc.mDataFormat.mBytesPerFrame = 4;
aqc.mDataFormat.mChannelsPerFrame = 2;
aqc.mDataFormat.mBitsPerChannel = 16;
aqc.frameCount = FRAME_COUNT;
aqc.sampleLen = len / BYTES_PER_SAMPLE;
aqc.playPtr = 0;
aqc.pcmBuffer = (sampleFrame *)pcmbuffer;
err = AudioQueueNewOutput(&aqc.mDataFormat,
AQBufferCallback,
&aqc,
NULL,
kCFRunLoopCommonModes,
0,
&aqc.queue);
if (err)
return err;
aqc.frameCount = FRAME_COUNT;
bufferSize = aqc.frameCount * aqc.mDataFormat.mBytesPerFrame;
for (i=0; i<AUDIO_BUFFERS; i++) {
err = AudioQueueAllocateBuffer(aqc.queue, bufferSize,
&aqc.mBuffers[i]);
if (err)
return err;
AQBufferCallback(&aqc, aqc.queue, aqc.mBuffers[i]);
}
err = AudioQueueStart(aqc.queue, NULL);
if (err)
return err;
struct timeval tv = {1.0, 0};
while(aqc.playPtr < aqc.sampleLen) { select(0, NULL, NULL, NULL, &tv); }
sleep(1);
return 0;
}
OSStatus DZAudioQueuePlayer::start()
{
if (this->_queue == NULL
|| this->_status == DZAudioQueuePlayerStatus_NotReady
|| this->_status == DZAudioQueuePlayerStatus_Error) {
return dzDebug(!noErr, "Audio queue cannot start because it is not ready.");
}
dzDebug(AudioQueueSetParameter(this->_queue, kAudioQueueParam_Volume, 1.0),
"Fail to set audio queue property: Volumn.");
OSStatus ret = dzDebug(AudioQueueStart(this->_queue, NULL), "Fail to start audio queue.");
if (ret == noErr) {
this->_status = DZAudioQueuePlayerStatus_Running;
}
return ret;
}
int app_OpenSound(int buffersize) {
Float64 sampleRate = 22050.0;
int i;
UInt32 bufferBytes;
soundBufferSize = buffersize;
app_MuteSound();
soundInit = 0;
in.mDataFormat.mSampleRate = sampleRate;
in.mDataFormat.mFormatID = kAudioFormatLinearPCM;
in.mDataFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger
| kAudioFormatFlagIsPacked;
in.mDataFormat.mBytesPerPacket = 4;
in.mDataFormat.mFramesPerPacket = isStereo ? 1 : 2;
in.mDataFormat.mBytesPerFrame = isStereo ? 4 : 2;
in.mDataFormat.mChannelsPerFrame = isStereo ? 2 : 1;
in.mDataFormat.mBitsPerChannel = 16;
/* Pre-buffer before we turn on audio */
UInt32 err;
err = AudioQueueNewOutput(&in.mDataFormat,
AQBufferCallback,
NULL,
NULL,
kCFRunLoopCommonModes,
0,
&in.queue);
bufferBytes = AUDIO_BUFFER_SIZE;
for (i=0; i<AUDIO_BUFFERS; i++)
{
err = AudioQueueAllocateBuffer(in.queue, bufferBytes, &in.mBuffers[i]);
/* "Prime" by calling the callback once per buffer */
//AQBufferCallback (&in, in.queue, in.mBuffers[i]);
in.mBuffers[i]->mAudioDataByteSize = AUDIO_BUFFER_SIZE; //samples_per_frame * 2; //inData->mDataFormat.mBytesPerFrame; //(inData->frameCount * 4 < (sndOutLen) ? inData->frameCount * 4 : (sndOutLen));
AudioQueueEnqueueBuffer(in.queue, in.mBuffers[i], 0, NULL);
}
soundInit = 1;
err = AudioQueueStart(in.queue, NULL);
return 0;
}
int SIOpenSound(int buffersize)
{
SI_SoundIsInit = 0;
SI_AudioOffset = 0;
if(SI_AQCallbackStruct.queue != 0)
AudioQueueDispose(SI_AQCallbackStruct.queue, true);
SI_AQCallbackCount = 0;
memset(&SI_AQCallbackStruct, 0, sizeof(AQCallbackStruct));
Float64 sampleRate = 22050.0;
sampleRate = Settings.SoundPlaybackRate;
SI_SoundBufferSizeBytes = buffersize;
SI_AQCallbackStruct.mDataFormat.mSampleRate = sampleRate;
SI_AQCallbackStruct.mDataFormat.mFormatID = kAudioFormatLinearPCM;
SI_AQCallbackStruct.mDataFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
SI_AQCallbackStruct.mDataFormat.mBytesPerPacket = 4;
SI_AQCallbackStruct.mDataFormat.mFramesPerPacket = SI_IsStereo ? 1 : 2;
SI_AQCallbackStruct.mDataFormat.mBytesPerFrame = SI_IsStereo ? 4 : 2;
SI_AQCallbackStruct.mDataFormat.mChannelsPerFrame = SI_IsStereo ? 2 : 1;
SI_AQCallbackStruct.mDataFormat.mBitsPerChannel = Settings.SixteenBitSound ? 16: 8;
/* Pre-buffer before we turn on audio */
UInt32 err;
err = AudioQueueNewOutput(&SI_AQCallbackStruct.mDataFormat,
AQBufferCallback,
NULL,
NULL,
kCFRunLoopCommonModes,
0,
&SI_AQCallbackStruct.queue);
for(int i=0; i<SI_AUDIO_BUFFER_COUNT; i++)
{
err = AudioQueueAllocateBuffer(SI_AQCallbackStruct.queue, SI_SoundBufferSizeBytes, &SI_AQCallbackStruct.mBuffers[i]);
memset(SI_AQCallbackStruct.mBuffers[i]->mAudioData, 0, SI_SoundBufferSizeBytes);
SI_AQCallbackStruct.mBuffers[i]->mAudioDataByteSize = SI_SoundBufferSizeBytes; //samples_per_frame * 2; //inData->mDataFormat.mBytesPerFrame; //(inData->frameCount * 4 < (sndOutLen) ? inData->frameCount * 4 : (sndOutLen));
AudioQueueEnqueueBuffer(SI_AQCallbackStruct.queue, SI_AQCallbackStruct.mBuffers[i], 0, NULL);
}
SI_SoundIsInit = 1;
err = AudioQueueStart(SI_AQCallbackStruct.queue, NULL);
return 0;
}
void Audio_Queue::start()
{
// start the queue if it has not been started already
if (m_audioQueueStarted) {
return;
}
OSStatus err = AudioQueueStart(m_outAQ, NULL);
if (!err) {
m_audioQueueStarted = true;
m_lastError = noErr;
} else {
AQ_TRACE("%s: AudioQueueStart failed!\n", __PRETTY_FUNCTION__);
m_lastError = err;
}
}
void GbApuEmulator::beginApuPlayback()
{
// Reset the APU and Buffer
// gbAPU->reset(false,0);
gbAPU->reset();
blipBuffer->clear(true);
// Prime the playback buffer
for (int i = 0; i < NUM_BUFFERS; ++i)
{
HandleOutputBuffer(gbAPUState, gbAPUState->queue, gbAPUState->buffers[i]);
}
AudioQueuePrime(gbAPUState->queue, 0, NULL);
gbAPUState->isRunning = true;
AudioQueueStart(gbAPUState->queue, NULL);
}
void SoundRecorder::start(void)
{
/* Do nothing if already started: */
if(active)
return;
/* Reset the packet counter: */
numRecordedPackets=0;
/* Set the audio file's magic cookie: */
setAudioFileMagicCookie();
/* Start recording: */
if(AudioQueueStart(queue,0)==noErr)
active=true;
else
Misc::throwStdErr("SoundRecorder::start: Unable to start recording");
}
