static void gviHardwareStopDevice(GVDevice device, GVDeviceType type)
{
GVIHardwareData * data = (GVIHardwareData *)device->m_data;
GVICapturedFrame * frame;
// lock the device
gviLockDevice(data);
// capture
if((type & GV_CAPTURE) && data->m_capturing)
{
// unlock so the ioproc can stop
gviUnlockDevice(data);
// stop io
AudioDeviceStop((AudioDeviceID)device->m_deviceID, gviHardwareCaptureIOProc);
// relock
gviLockDevice(data);
// remove the IO proc
AudioDeviceRemoveIOProc((AudioDeviceID)device->m_deviceID, gviHardwareCaptureIOProc);
// move captured frames back to the available frames list
while((frame = gviPopFirstFrame(&data->m_capturedFrames)) != NULL)
gviPushFirstFrame(&data->m_captureAvailableFrames, frame);
// no longer capturing
data->m_capturing = GVFalse;
}
// playback
if((type & GV_PLAYBACK) && data->m_playing)
{
// unlock so the ioproc can stop
gviUnlockDevice(data);
// stop io
AudioDeviceStop((AudioDeviceID)device->m_deviceID, gviHardwarePlaybackIOProc);
// relock
gviLockDevice(data);
// remove the IO proc
AudioDeviceRemoveIOProc((AudioDeviceID)device->m_deviceID, gviHardwarePlaybackIOProc);
// clear any pending sources & buffers
gviClearSourceList(data->m_playbackSources);
// no longer playing
data->m_playing = GVFalse;
}
// unlock the device
gviUnlockDevice(data);
}
static void clean_input_device(phastream_t *as) {
ca_dev *cadev = (ca_dev *) as->drvinfo;
verify_noerr(AudioDeviceRemoveIOProc(get_audiodeviceid(cadev->inputID), input_proc));
}
static void coreaudio_fini_out (HWVoiceOut *hw)
{
OSStatus status;
int err;
coreaudioVoiceOut *core = (coreaudioVoiceOut *) hw;
if (!isAtexit) {
/* stop playback */
if (isPlaying(core->outputDeviceID)) {
status = AudioDeviceStop(core->outputDeviceID, audioDeviceIOProc);
if (status != kAudioHardwareNoError) {
coreaudio_logerr (status, "Could not stop playback\n");
}
}
/* remove callback */
status = AudioDeviceRemoveIOProc(core->outputDeviceID,
audioDeviceIOProc);
if (status != kAudioHardwareNoError) {
coreaudio_logerr (status, "Could not remove IOProc\n");
}
}
core->outputDeviceID = kAudioDeviceUnknown;
/* destroy mutex */
err = pthread_mutex_destroy(&core->mutex);
if (err) {
dolog("Could not destroy mutex\nReason: %s\n", strerror (err));
}
}
static void
macosx_close (AUDIO_OUT *audio_out)
{ MACOSX_AUDIO_OUT *macosx_out ;
OSStatus err ;
if ((macosx_out = (MACOSX_AUDIO_OUT*) audio_out) == NULL)
{ printf ("macosx_close : AUDIO_OUT is NULL.\n") ;
return ;
} ;
if (macosx_out->magic != MACOSX_MAGIC)
{ printf ("macosx_close : Bad magic number.\n") ;
return ;
} ;
if ((err = AudioDeviceStop (macosx_out->device, macosx_audio_out_callback)) != noErr)
{ printf ("AudioDeviceStop failed.\n") ;
return ;
} ;
err = AudioDeviceRemoveIOProc (macosx_out->device, macosx_audio_out_callback) ;
if (err != noErr)
{ printf ("AudioDeviceRemoveIOProc failed.\n") ;
return ;
} ;
} /* macosx_close */
static int
ca_free (void) {
if (device_id) {
AudioDeviceStop(device_id, ca_buffer_callback);
AudioDeviceRemovePropertyListener(device_id, 0, 0, kAudioDevicePropertyStreamFormat, ca_fmtchanged);
AudioDeviceRemoveIOProc(device_id, ca_buffer_callback);
}
return 0;
}
// stop the device attached to a stream.
//
static int Stream_stop(Stream *s)
{
AudioDeviceIOProc ioProc= s->direction ? ioProcInput : ioProcOutput;
checkError(AudioDeviceStop(s->id, ioProc),
"DeviceStop", s->direction ? "ioProcIn" : "ioProcOut");
checkError(AudioDeviceRemoveIOProc(s->id, ioProc),
"Remove", s->direction ? "ioProcIn" : "ioProcOut");
debugf("stream %p[%d] stopped\n", s, s->direction);
return 1;
}
enum audio::orchestra::error audio::orchestra::api::Core::closeStream() {
if (m_state == audio::orchestra::state::closed) {
ATA_ERROR("no open stream to close!");
return audio::orchestra::error_warning;
}
if ( m_mode == audio::orchestra::mode_output
|| m_mode == audio::orchestra::mode_duplex) {
if (m_state == audio::orchestra::state::running) {
AudioDeviceStop(m_private->id[0], &audio::orchestra::api::Core::callbackEvent);
}
#if defined(MAC_OS_X_VERSION_10_5) && (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5)
AudioDeviceDestroyIOProcID(m_private->id[0], m_private->procId[0]);
#else
// deprecated in favor of AudioDeviceDestroyIOProcID()
AudioDeviceRemoveIOProc(m_private->id[0], &audio::orchestra::api::Core::callbackEvent);
#endif
}
if ( m_mode == audio::orchestra::mode_input
|| ( m_mode == audio::orchestra::mode_duplex
&& m_device[0] != m_device[1])) {
if (m_state == audio::orchestra::state::running) {
AudioDeviceStop(m_private->id[1], &audio::orchestra::api::Core::callbackEvent);
}
#if defined(MAC_OS_X_VERSION_10_5) && (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5)
AudioDeviceDestroyIOProcID(m_private->id[1], m_private->procId[1]);
#else
// deprecated in favor of AudioDeviceDestroyIOProcID()
AudioDeviceRemoveIOProc(m_private->id[1], &audio::orchestra::api::Core::callbackEvent);
#endif
}
m_userBuffer[0].clear();
m_userBuffer[1].clear();
if (m_deviceBuffer) {
free(m_deviceBuffer);
m_deviceBuffer = nullptr;
}
m_mode = audio::orchestra::mode_unknow;
m_state = audio::orchestra::state::closed;
ATA_VERBOSE("Set state as closed");
return audio::orchestra::error_none;
}
// return whether we were running
bool AudioThruEngine::Stop()
{
if (!mRunning) return false;
mRunning = false;
mInputProcState = kStopRequested;
mOutputProcState = kStopRequested;
while (mInputProcState != kOff || mOutputProcState != kOff)
usleep(5000);
AudioDeviceRemoveIOProc(mInputDevice.mID, InputIOProc);
AudioDeviceRemoveIOProc(mOutputDevice.mID, mOutputIOProc);
if (mWorkBuf) {
delete[] mWorkBuf;
mWorkBuf = NULL;
}
return true;
}
void
audio_output_close(void)
{
AudioDeviceStop(adid, aprocid);
#ifdef MAC_OS_X_VERSION_10_5
AudioDeviceDestroyIOProcID(adid, aprocid);
#else /* !MAC_OS_X_VERSION_10_5 */
AudioDeviceRemoveIOProc(adid, aprocid);
#endif /* MAC_OS_X_VERSION_10_5 */
g_free(abufnew);
g_free(abufcur);
}
// Note: When CloseStream() is called, the multi-api layer ensures that the stream has already been stopped or aborted.
static PaError CloseStream( PaStream* s )
{
PaError err = paNoError;
PaMacCoreStream *stream = (PaMacCoreStream*)s;
PaUtil_ResetCpuLoadMeasurer( &stream->cpuLoadMeasurer );
if (stream->inputDevice != kAudioDeviceUnknown) {
if (stream->outputDevice == kAudioDeviceUnknown || stream->outputDevice == stream->inputDevice) {
err = conv_err(AudioDeviceRemoveIOProc(stream->inputDevice, AudioIOProc));
}
else {
err = conv_err(AudioDeviceRemoveIOProc(stream->inputDevice, AudioInputProc));
err = conv_err(AudioDeviceRemoveIOProc(stream->outputDevice, AudioOutputProc));
}
}
else {
err = conv_err(AudioDeviceRemoveIOProc(stream->outputDevice, AudioIOProc));
}
return err;
}
void CCoreAudioDevice::RemoveIOProc()
{
if (!m_DeviceId || !m_IoProc)
return;
Stop();
OSStatus ret = AudioDeviceRemoveIOProc(m_DeviceId, m_IoProc);
if (ret)
CLog::Log(LOGERROR, "CCoreAudioDevice::RemoveIOProc: Unable to remove IOProc. Error = 0x%08x (%4.4s).", ret, CONVERT_OSSTATUS(ret));
else
CLog::Log(LOGDEBUG, "CCoreAudioDevice::AddIOProc: IOProc removed for device 0x%04x", m_DeviceId);
m_IoProc = NULL; // Clear the reference no matter what
}
void stop (bool leaveInterruptRunning)
{
{
const ScopedLock sl (callbackLock);
callback = nullptr;
}
if (started
&& (deviceID != 0)
&& ! leaveInterruptRunning)
{
OK (AudioDeviceStop (deviceID, audioIOProc));
#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
OK (AudioDeviceRemoveIOProc (deviceID, audioIOProc));
#else
OK (AudioDeviceDestroyIOProcID (deviceID, audioProcID));
audioProcID = 0;
#endif
started = false;
{ const ScopedLock sl (callbackLock); }
// wait until it's definately stopped calling back..
for (int i = 40; --i >= 0;)
{
Thread::sleep (50);
UInt32 running = 0;
UInt32 size = sizeof (running);
AudioObjectPropertyAddress pa;
pa.mSelector = kAudioDevicePropertyDeviceIsRunning;
pa.mScope = kAudioObjectPropertyScopeWildcard;
pa.mElement = kAudioObjectPropertyElementMaster;
OK (AudioObjectGetPropertyData (deviceID, &pa, 0, 0, &size, &running));
if (running == 0)
break;
}
const ScopedLock sl (callbackLock);
}
if (inputDevice != nullptr)
inputDevice->stop (leaveInterruptRunning);
}
/*
==========
idAudioHardwareOSX::Reset
==========
*/
void idAudioHardwareOSX::Reset() {
OSStatus status;
if( activeIOProc ) {
status = AudioDeviceStop( selectedDevice, DeviceIOProc );
if( status != kAudioHardwareNoError ) {
common->Warning( "idAudioHardwareOSX::Reset: AudioDeviceStop failed. status: %s", ExtractStatus( status ) );
}
status = AudioDeviceRemoveIOProc( selectedDevice, DeviceIOProc );
if( status != kAudioHardwareNoError ) {
common->Warning( "idAudioHardwareOSX::Reset: AudioDeviceRemoveIOProc failed. status %s\n", ExtractStatus( status ) );
}
activeIOProc = false;
}
selectedDevice = kAudioDeviceUnknown;
AudioHardwareUnload();
}
static void close_output(void)
{
OSStatus err = 0;
err = AudioDeviceStop(globals.device, appIOProc);
// stop playing sound through the device
if (err != 0) goto Bail;
err = AudioDeviceRemoveIOProc(globals.device, appIOProc);
// remove the IO proc from the device
if (err != 0) goto Bail;
globals.soundPlaying = 0;
// set the playing status global to false
Bail:;
}
CDeviceCoreAudio::~CDeviceCoreAudio()
{
AudioDeviceStop(mAudioDeviceID, HALIOProc);
AudioDeviceRemoveIOProc(mAudioDeviceID, HALIOProc);
if (mppfInputs) {
delete[] mppfInputs;
}
if (mppfOutputs) {
delete[] mppfOutputs;
}
for (int i = 0; i < COREAUDIO_MAX_INPUT_CHANNELS; i++) {
if (mppfInputTmp[i]) {
delete[] mppfInputTmp[i];
}
}
} // destructor
// start the device attached to the stream.
//
static int Stream_startSema(Stream *s, int semaIndex)
{
AudioDeviceIOProc ioProc= s->direction ? ioProcInput : ioProcOutput;
debugf("stream %p[%d] startSema: %d\n", s, s->direction, semaIndex);
s->semaphore= semaIndex; // can be zero
if (checkError(AudioDeviceAddIOProc(s->id, ioProc, (void *)s),
"Add", "ioProcOut"))
return 0;
if (checkError(AudioDeviceStart(s->id, ioProc),
"DeviceStart", "ioProcOut"))
{
AudioDeviceRemoveIOProc(s->id, ioProc);
return 0;
}
debugf("stream %p[%d] running\n", s, s->direction);
return 1;
}
static int audiounits_close(void *usr) {
au_instance_t *p = (au_instance_t*) usr;
p->done = YES;
/* Rprintf(" closing audiounit %p\n", usr); */
if (p->outUnit) {
AudioOutputUnitStop(p->outUnit);
AudioUnitUninitialize(p->outUnit);
CloseComponent(p->outUnit);
p->outUnit = 0;
}
if (p->inDev) {
#if defined(MAC_OS_X_VERSION_10_5) && (MAC_OS_X_VERSION_MIN_REQUIRED>=MAC_OS_X_VERSION_10_5)
AudioDeviceDestroyIOProcID(p->inDev, p->inIOProcID);
#else
AudioDeviceRemoveIOProc(p->inDev, inputRenderProc);
#endif
p->inDev = 0;
}
return 1;
}
void CoreAudioOutDriver::close()
{
if (!this->is_open())
return;
m_impl->m_logger(2, "Closing audio...");
if (!this->is_open())
return;
m_impl->stop_audio();
while (m_impl->m_outputProcState != Impl::kOff)
usleep(5000);
AudioDeviceRemoveIOProc(m_impl->m_ID, Impl::OutputIOProc);
m_impl->m_ID = kAudioDeviceUnknown;
delete m_impl->m_converter;
m_impl->m_converter = 0;
}
void macosx_audio_close(audio_desc_t ad)
{
OSStatus err = noErr;
// Stop the audio devices.
err = AudioDeviceStop(devices[ad].inputDeviceID_, audioIOProc);
if (err != noErr) fprintf(stderr, "Input device error: AudioDeviceStop\n");
err = AudioOutputUnitStop(devices[ad].outputUnit_);
if (err != noErr) fprintf(stderr, "Output device error: AudioOutputUnitStop\n");
// Unregister the AudioDeviceIOProc.
#if defined(MAC_OS_X_VERSION_10_5) && (MAC_OS_X_VERSION_MIN_REQUIRED>=MAC_OS_X_VERSION_10_5)
err = AudioDeviceDestroyIOProcID(devices[ad].inputDeviceID_, devices[ad].inputDeviceProcID_);
if (err != noErr) fprintf(stderr, "Input device error: AudioDeviceDestroyIOProcID\n");
#else
// deprecated in favor of AudioDeviceDestroyIOProcID();
err = AudioDeviceRemoveIOProc(devices[ad].inputDeviceID_, audioIOProc);
if (err != noErr) fprintf(stderr, "Input device error: AudioDeviceRemoveIOProc\n");
#endif
CloseComponent(devices[ad].outputUnit_);
if (readBuffer_ != NULL) free(readBuffer_); readBuffer_ = NULL;
if (writeBuffer_ != NULL) free(writeBuffer_); writeBuffer_ = NULL;
if (zLine_ != NULL) free(zLine_); zLine_ = NULL;
};
int audio_close(error_t *error) {
int ret;
if (audio_started) {
ret = AudioDeviceStop(audio.device, audio_play_proc);
if (ret) {
error_set(error, "Could not stop audio playback");
return 0;
}
audio_started = 0;
}
if (audio_initialized) {
ret = AudioDeviceRemoveIOProc(audio.device, audio_play_proc);
if (ret) {
error_set(error, "Could not remove the IOProc");
return 0;
}
audio_initialized = 0;
}
rb_destroy(&audio.rb);
return 1;
}
bool start (AudioIODeviceCallback* cb)
{
if (! started)
{
callback = nullptr;
if (deviceID != 0)
{
#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
if (OK (AudioDeviceAddIOProc (deviceID, audioIOProc, this)))
#else
if (OK (AudioDeviceCreateIOProcID (deviceID, audioIOProc, this, &audioProcID)))
#endif
{
if (OK (AudioDeviceStart (deviceID, audioIOProc)))
{
started = true;
}
else
{
#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
OK (AudioDeviceRemoveIOProc (deviceID, audioIOProc));
#else
OK (AudioDeviceDestroyIOProcID (deviceID, audioProcID));
audioProcID = 0;
#endif
}
}
}
}
if (started)
{
const ScopedLock sl (callbackLock);
callback = cb;
}
return started && (inputDevice == nullptr || inputDevice->start (cb));
}
static void
coreaudio_voice_fini (coreaudioVoice* core)
{
OSStatus status;
int err;
if (!conf.isAtexit) {
/* stop playback */
coreaudio_voice_ctl(core, VOICE_DISABLE);
/* remove callback */
status = AudioDeviceRemoveIOProc(core->deviceID, core->ioproc);
if (status != kAudioHardwareNoError) {
coreaudio_logerr (status, "Could not remove IOProc\n");
}
}
core->deviceID = kAudioDeviceUnknown;
/* destroy mutex */
err = pthread_mutex_destroy(&core->mutex);
if (err) {
dolog("Could not destroy mutex\nReason: %s\n", strerror (err));
}
}
// Cleanup the BlockSound class
BlockSound::~BlockSound() {
#ifdef __APPLE__
if (sample_size) {
# if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
AudioDeviceStop(device, audio_proc_id);
AudioDeviceDestroyIOProcID(device, audio_proc_id);
# else
AudioDeviceStop(device, audio_cb);
AudioDeviceRemoveIOProc(device, audio_cb);
# endif
}
#elif defined(WIN32)
if (sample_size) {
waveOutClose(device);
GlobalUnlock(header_handle);
GlobalFree(header_handle);
GlobalUnlock(data_handle);
GlobalFree(data_handle);
}
#else
# ifdef HAVE_ALSA_ASOUNDLIB_H
if (handle) {
snd_pcm_drain(handle);
snd_pcm_close(handle);
}
# endif // HAVE_ALSA_ASOUNDLIB_H
#endif // __APPLE__
if (sample_size) {
delete[] sample_data;
}
}
static int
coreaudio_voice_init (coreaudioVoice* core,
struct audsettings* as,
int frameSize,
AudioDeviceIOProc ioproc,
void* hw,
int input)
{
OSStatus status;
UInt32 propertySize;
int err;
int bits = 8;
AudioValueRange frameRange;
const char* typ = input ? "input" : "playback";
core->isInput = input ? true : false;
/* create mutex */
err = pthread_mutex_init(&core->mutex, NULL);
if (err) {
dolog("Could not create mutex\nReason: %s\n", strerror (err));
return -1;
}
if (as->fmt == AUD_FMT_S16 || as->fmt == AUD_FMT_U16) {
bits = 16;
}
// TODO: audio_pcm_init_info (&hw->info, as);
/* open default output device */
/* note: we use DefaultSystemOutputDevice because DefaultOutputDevice seems to
* always link to the internal speakers, and not the ones selected through system properties
* go figure...
*/
propertySize = sizeof(core->deviceID);
status = AudioHardwareGetProperty(
input ? kAudioHardwarePropertyDefaultInputDevice :
kAudioHardwarePropertyDefaultSystemOutputDevice,
&propertySize,
&core->deviceID);
if (status != kAudioHardwareNoError) {
coreaudio_logerr2 (status, typ,
"Could not get default %s device\n", typ);
return -1;
}
if (core->deviceID == kAudioDeviceUnknown) {
dolog ("Could not initialize %s - Unknown Audiodevice\n", typ);
return -1;
}
/* get minimum and maximum buffer frame sizes */
propertySize = sizeof(frameRange);
status = AudioDeviceGetProperty(
core->deviceID,
0,
core->isInput,
kAudioDevicePropertyBufferFrameSizeRange,
&propertySize,
&frameRange);
if (status != kAudioHardwareNoError) {
coreaudio_logerr2 (status, typ,
"Could not get device buffer frame range\n");
return -1;
}
if (frameRange.mMinimum > frameSize) {
core->bufferFrameSize = (UInt32) frameRange.mMinimum;
dolog ("warning: Upsizing Output Buffer Frames to %f\n", frameRange.mMinimum);
}
else if (frameRange.mMaximum < frameSize) {
core->bufferFrameSize = (UInt32) frameRange.mMaximum;
dolog ("warning: Downsizing Output Buffer Frames to %f\n", frameRange.mMaximum);
}
else {
core->bufferFrameSize = frameSize;
}
/* set Buffer Frame Size */
propertySize = sizeof(core->bufferFrameSize);
status = AudioDeviceSetProperty(
core->deviceID,
NULL,
0,
core->isInput,
kAudioDevicePropertyBufferFrameSize,
propertySize,
&core->bufferFrameSize);
if (status != kAudioHardwareNoError) {
coreaudio_logerr2 (status, typ,
"Could not set device buffer frame size %ld\n",
core->bufferFrameSize);
return -1;
}
/* get Buffer Frame Size */
propertySize = sizeof(core->bufferFrameSize);
status = AudioDeviceGetProperty(
core->deviceID,
0,
core->isInput,
kAudioDevicePropertyBufferFrameSize,
&propertySize,
&core->bufferFrameSize);
if (status != kAudioHardwareNoError) {
coreaudio_logerr2 (status, typ,
"Could not get device buffer frame size\n");
return -1;
}
// TODO: hw->samples = *pNBuffers * core->bufferFrameSize;
/* get StreamFormat */
propertySize = sizeof(core->streamBasicDescription);
status = AudioDeviceGetProperty(
core->deviceID,
0,
core->isInput,
kAudioDevicePropertyStreamFormat,
&propertySize,
&core->streamBasicDescription);
if (status != kAudioHardwareNoError) {
coreaudio_logerr2 (status, typ,
"Could not get Device Stream properties\n");
core->deviceID = kAudioDeviceUnknown;
return -1;
}
/* set Samplerate */
core->streamBasicDescription.mSampleRate = (Float64) as->freq;
propertySize = sizeof(core->streamBasicDescription);
status = AudioDeviceSetProperty(
core->deviceID,
0,
0,
core->isInput,
kAudioDevicePropertyStreamFormat,
propertySize,
&core->streamBasicDescription);
if (status != kAudioHardwareNoError) {
coreaudio_logerr2 (status, typ, "Could not set samplerate %d\n",
as->freq);
core->deviceID = kAudioDeviceUnknown;
return -1;
}
/* set Callback */
core->ioproc = ioproc;
status = AudioDeviceAddIOProc(core->deviceID, ioproc, hw);
if (status != kAudioHardwareNoError) {
coreaudio_logerr2 (status, typ, "Could not set IOProc\n");
core->deviceID = kAudioDeviceUnknown;
return -1;
}
/* start Playback */
if (!input && !coreaudio_voice_isPlaying(core)) {
status = AudioDeviceStart(core->deviceID, core->ioproc);
if (status != kAudioHardwareNoError) {
coreaudio_logerr2 (status, typ, "Could not start playback\n");
AudioDeviceRemoveIOProc(core->deviceID, core->ioproc);
core->deviceID = kAudioDeviceUnknown;
return -1;
}
}
return 0;
}
static int coreaudio_init_out(HWVoiceOut *hw, struct audsettings *as,
void *drv_opaque)
{
OSStatus status;
coreaudioVoiceOut *core = (coreaudioVoiceOut *) hw;
UInt32 propertySize;
int err;
const char *typ = "playback";
AudioValueRange frameRange;
CoreaudioConf *conf = drv_opaque;
/* create mutex */
err = pthread_mutex_init(&core->mutex, NULL);
if (err) {
dolog("Could not create mutex\nReason: %s\n", strerror (err));
return -1;
}
audio_pcm_init_info (&hw->info, as);
/* open default output device */
propertySize = sizeof(core->outputDeviceID);
status = AudioHardwareGetProperty(
kAudioHardwarePropertyDefaultOutputDevice,
&propertySize,
&core->outputDeviceID);
if (status != kAudioHardwareNoError) {
coreaudio_logerr2 (status, typ,
"Could not get default output Device\n");
return -1;
}
if (core->outputDeviceID == kAudioDeviceUnknown) {
dolog ("Could not initialize %s - Unknown Audiodevice\n", typ);
return -1;
}
/* get minimum and maximum buffer frame sizes */
propertySize = sizeof(frameRange);
status = AudioDeviceGetProperty(
core->outputDeviceID,
0,
0,
kAudioDevicePropertyBufferFrameSizeRange,
&propertySize,
&frameRange);
if (status != kAudioHardwareNoError) {
coreaudio_logerr2 (status, typ,
"Could not get device buffer frame range\n");
return -1;
}
if (frameRange.mMinimum > conf->buffer_frames) {
core->audioDevicePropertyBufferFrameSize = (UInt32) frameRange.mMinimum;
dolog ("warning: Upsizing Buffer Frames to %f\n", frameRange.mMinimum);
}
else if (frameRange.mMaximum < conf->buffer_frames) {
core->audioDevicePropertyBufferFrameSize = (UInt32) frameRange.mMaximum;
dolog ("warning: Downsizing Buffer Frames to %f\n", frameRange.mMaximum);
}
else {
core->audioDevicePropertyBufferFrameSize = conf->buffer_frames;
}
/* set Buffer Frame Size */
propertySize = sizeof(core->audioDevicePropertyBufferFrameSize);
status = AudioDeviceSetProperty(
core->outputDeviceID,
NULL,
0,
false,
kAudioDevicePropertyBufferFrameSize,
propertySize,
&core->audioDevicePropertyBufferFrameSize);
if (status != kAudioHardwareNoError) {
coreaudio_logerr2 (status, typ,
"Could not set device buffer frame size %" PRIu32 "\n",
(uint32_t)core->audioDevicePropertyBufferFrameSize);
return -1;
}
/* get Buffer Frame Size */
propertySize = sizeof(core->audioDevicePropertyBufferFrameSize);
status = AudioDeviceGetProperty(
core->outputDeviceID,
0,
false,
kAudioDevicePropertyBufferFrameSize,
&propertySize,
&core->audioDevicePropertyBufferFrameSize);
if (status != kAudioHardwareNoError) {
coreaudio_logerr2 (status, typ,
"Could not get device buffer frame size\n");
return -1;
}
hw->samples = conf->nbuffers * core->audioDevicePropertyBufferFrameSize;
/* get StreamFormat */
propertySize = sizeof(core->outputStreamBasicDescription);
status = AudioDeviceGetProperty(
core->outputDeviceID,
0,
false,
kAudioDevicePropertyStreamFormat,
&propertySize,
&core->outputStreamBasicDescription);
if (status != kAudioHardwareNoError) {
coreaudio_logerr2 (status, typ,
"Could not get Device Stream properties\n");
core->outputDeviceID = kAudioDeviceUnknown;
return -1;
}
/* set Samplerate */
core->outputStreamBasicDescription.mSampleRate = (Float64) as->freq;
propertySize = sizeof(core->outputStreamBasicDescription);
status = AudioDeviceSetProperty(
core->outputDeviceID,
0,
0,
0,
kAudioDevicePropertyStreamFormat,
propertySize,
&core->outputStreamBasicDescription);
if (status != kAudioHardwareNoError) {
coreaudio_logerr2 (status, typ, "Could not set samplerate %d\n",
as->freq);
core->outputDeviceID = kAudioDeviceUnknown;
return -1;
}
/* set Callback */
status = AudioDeviceAddIOProc(core->outputDeviceID, audioDeviceIOProc, hw);
if (status != kAudioHardwareNoError) {
coreaudio_logerr2 (status, typ, "Could not set IOProc\n");
core->outputDeviceID = kAudioDeviceUnknown;
return -1;
}
/* start Playback */
if (!isPlaying(core->outputDeviceID)) {
status = AudioDeviceStart(core->outputDeviceID, audioDeviceIOProc);
if (status != kAudioHardwareNoError) {
coreaudio_logerr2 (status, typ, "Could not start playback\n");
AudioDeviceRemoveIOProc(core->outputDeviceID, audioDeviceIOProc);
core->outputDeviceID = kAudioDeviceUnknown;
return -1;
}
}
return 0;
}
static void
macosx_play (int argc, char *argv [])
{ MacOSXAudioData audio_data ;
OSStatus err ;
UInt32 count, buffer_size ;
int k ;
audio_data.fake_stereo = 0 ;
audio_data.device = kAudioDeviceUnknown ;
/* get the default output device for the HAL */
count = sizeof (AudioDeviceID) ;
if ((err = AudioHardwareGetProperty (kAudioHardwarePropertyDefaultOutputDevice,
&count, (void *) &(audio_data.device))) != noErr)
{ printf ("AudioHardwareGetProperty (kAudioDevicePropertyDefaultOutputDevice) failed.\n") ;
return ;
} ;
/* get the buffersize that the default device uses for IO */
count = sizeof (UInt32) ;
if ((err = AudioDeviceGetProperty (audio_data.device, 0, false, kAudioDevicePropertyBufferSize,
&count, &buffer_size)) != noErr)
{ printf ("AudioDeviceGetProperty (kAudioDevicePropertyBufferSize) failed.\n") ;
return ;
} ;
/* get a description of the data format used by the default device */
count = sizeof (AudioStreamBasicDescription) ;
if ((err = AudioDeviceGetProperty (audio_data.device, 0, false, kAudioDevicePropertyStreamFormat,
&count, &(audio_data.format))) != noErr)
{ printf ("AudioDeviceGetProperty (kAudioDevicePropertyStreamFormat) failed.\n") ;
return ;
} ;
/* Base setup completed. Now play files. */
for (k = 1 ; k < argc ; k++)
{ printf ("Playing %s\n", argv [k]) ;
if (! (audio_data.sndfile = sf_open (argv [k], SFM_READ, &(audio_data.sfinfo))))
{ puts (sf_strerror (NULL)) ;
continue ;
} ;
if (audio_data.sfinfo.channels < 1 || audio_data.sfinfo.channels > 2)
{ printf ("Error : channels = %d.\n", audio_data.sfinfo.channels) ;
continue ;
} ;
audio_data.format.mSampleRate = audio_data.sfinfo.samplerate ;
if (audio_data.sfinfo.channels == 1)
{ audio_data.format.mChannelsPerFrame = 2 ;
audio_data.fake_stereo = 1 ;
}
else
audio_data.format.mChannelsPerFrame = audio_data.sfinfo.channels ;
if ((err = AudioDeviceSetProperty (audio_data.device, NULL, 0, false, kAudioDevicePropertyStreamFormat,
sizeof (AudioStreamBasicDescription), &(audio_data.format))) != noErr)
{ printf ("AudioDeviceSetProperty (kAudioDevicePropertyStreamFormat) failed.\n") ;
return ;
} ;
/* we want linear pcm */
if (audio_data.format.mFormatID != kAudioFormatLinearPCM)
return ;
/* Fire off the device. */
if ((err = AudioDeviceAddIOProc (audio_data.device, macosx_audio_out_callback,
(void *) &audio_data)) != noErr)
{ printf ("AudioDeviceAddIOProc failed.\n") ;
return ;
} ;
err = AudioDeviceStart (audio_data.device, macosx_audio_out_callback) ;
if (err != noErr)
return ;
audio_data.done_playing = SF_FALSE ;
while (audio_data.done_playing == SF_FALSE)
usleep (10 * 1000) ; /* 10 000 milliseconds. */
if ((err = AudioDeviceStop (audio_data.device, macosx_audio_out_callback)) != noErr)
{ printf ("AudioDeviceStop failed.\n") ;
return ;
} ;
err = AudioDeviceRemoveIOProc (audio_data.device, macosx_audio_out_callback) ;
if (err != noErr)
{ printf ("AudioDeviceRemoveIOProc failed.\n") ;
return ;
} ;
sf_close (audio_data.sndfile) ;
} ;
return ;
} /* macosx_play */
