static void coreaudio_free(void *data)
{
coreaudio_t *dev = (coreaudio_t*)data;
if (!dev)
return;
if (dev->dev_alive)
{
AudioOutputUnitStop(dev->dev);
#ifdef OSX_PPC
CloseComponent(dev->dev);
#else
AudioComponentInstanceDispose(dev->dev);
#endif
}
if (dev->buffer)
fifo_free(dev->buffer);
slock_free(dev->lock);
scond_free(dev->cond);
free(dev);
}
CoreAudioOutput::~CoreAudioOutput()
{
OSSpinLockLock(_spinlockAU);
if(_au != NULL)
{
AudioOutputUnitStop(_au);
AudioUnitUninitialize(_au);
#if defined(MAC_OS_X_VERSION_10_6) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
if (IsOSXVersionSupported(10, 6, 0))
{
AudioComponentInstanceDispose(_au);
}
else
{
CloseComponent(_au);
}
#else
CloseComponent(_au);
#endif
_au = NULL;
}
OSSpinLockUnlock(_spinlockAU);
delete _buffer;
_buffer = NULL;
free(_spinlockAU);
_spinlockAU = NULL;
}
void CoreAudioDriver::disconnect()
{
OSStatus err = noErr;
err = AudioOutputUnitStop( m_outputUnit );
err = AudioUnitUninitialize( m_outputUnit );
err = AudioComponentInstanceDispose( m_outputUnit );
}
AudioDestinationIOS::~AudioDestinationIOS()
{
audioDestinations().remove(this);
if (m_outputUnit)
AudioComponentInstanceDispose(m_outputUnit);
}
static void coreaudio_free(void *data)
{
coreaudio_t *dev = (coreaudio_t*)data;
if (!dev)
return;
if (dev->dev_alive)
{
AudioOutputUnitStop(dev->dev);
#if (defined(__MACH__) && (defined(__ppc__) || defined(__ppc64__)))
CloseComponent(dev->dev);
#else
AudioComponentInstanceDispose(dev->dev);
#endif
}
if (dev->buffer)
fifo_free(dev->buffer);
slock_free(dev->lock);
scond_free(dev->cond);
free(dev);
}
static int close_coreaudio(audio_output_t *ao)
{
mpg123_coreaudio_t* ca = (mpg123_coreaudio_t*)ao->userptr;
if (ca) {
ca->decode_done = 1;
while(!ca->play_done && ca->play) usleep(10000);
/* No matter the error code, we want to close it
(by brute force if necessary) */
AudioConverterDispose(ca->converter);
AudioOutputUnitStop(ca->outputUnit);
AudioUnitUninitialize(ca->outputUnit);
AudioComponentInstanceDispose(ca->outputUnit);
/* Free the ring buffer */
sfifo_close( &ca->fifo );
/* Free the conversion buffer */
if (ca->buffer) {
free( ca->buffer );
ca->buffer = NULL;
}
}
return 0;
}
gboolean
gst_core_audio_close (GstCoreAudio * core_audio)
{
AudioComponentInstanceDispose (core_audio->audiounit);
core_audio->audiounit = NULL;
return TRUE;
}
gboolean
gst_core_audio_open (GstCoreAudio * core_audio)
{
if (!gst_core_audio_open_impl (core_audio))
return FALSE;
if (core_audio->is_src) {
AudioStreamBasicDescription asbd_in;
UInt32 propertySize;
OSStatus status;
GstOsxAudioSrc *src =
GST_OSX_AUDIO_SRC (GST_OBJECT_PARENT (core_audio->osxbuf));
propertySize = sizeof (asbd_in);
status = AudioUnitGetProperty (core_audio->audiounit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Input, 1, &asbd_in, &propertySize);
if (status) {
AudioComponentInstanceDispose (core_audio->audiounit);
core_audio->audiounit = NULL;
GST_WARNING_OBJECT (core_audio,
"Unable to obtain device properties: %d", (int) status);
return FALSE;
} else {
src->deviceChannels = asbd_in.mChannelsPerFrame;
}
}
return TRUE;
}
gboolean
gst_core_audio_close (GstCoreAudio * core_audio)
{
OSStatus status;
/* Uninitialize the AudioUnit */
status = AudioUnitUninitialize (core_audio->audiounit);
if (status) {
GST_ERROR_OBJECT (core_audio, "Failed to uninitialize AudioUnit: %d",
(int) status);
return FALSE;
}
AudioUnitRemovePropertyListenerWithUserData (core_audio->audiounit,
kAudioUnitProperty_AudioChannelLayout, _audio_unit_property_listener,
core_audio);
AudioUnitRemovePropertyListenerWithUserData (core_audio->audiounit,
kAudioUnitProperty_StreamFormat, _audio_unit_property_listener,
core_audio);
/* core_audio->osxbuf is already locked at this point */
core_audio->cached_caps_valid = FALSE;
gst_caps_replace (&core_audio->cached_caps, NULL);
AudioComponentInstanceDispose (core_audio->audiounit);
core_audio->audiounit = NULL;
return TRUE;
}
AudioDestinationMac::~AudioDestinationMac()
{
if (m_outputUnit)
AudioComponentInstanceDispose(m_outputUnit);
delete m_input; // LabSound
}
static void au_unconfigure(AUData *d) {
if (d->write_started==FALSE && d->read_started==FALSE) {
AudioUnitUninitialize(d->io_unit);
AudioOutputUnitStop(d->io_unit);
AudioComponentInstanceDispose (d->io_unit);
d->started=FALSE;
}
}
void iOSCoreAudioShutdown()
{
if (audioInstance) {
AudioOutputUnitStop(audioInstance);
AudioUnitUninitialize(audioInstance);
AudioComponentInstanceDispose(audioInstance);
audioInstance = nil;
}
}
void AudioLoopImplCocoa::shutdown()
{
if (initialized)
{
AudioOutputUnitStop(audioUnit);
AudioUnitUninitialize(audioUnit);
AudioComponentInstanceDispose(audioUnit);
audioUnit = NULL;
}
}
void AudioDriverCoreAudio::finish() {
capture_finish();
if (audio_unit) {
OSStatus result;
lock();
AURenderCallbackStruct callback;
zeromem(&callback, sizeof(AURenderCallbackStruct));
result = AudioUnitSetProperty(audio_unit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, kOutputBus, &callback, sizeof(callback));
if (result != noErr) {
ERR_PRINT("AudioUnitSetProperty failed");
}
if (active) {
result = AudioOutputUnitStop(audio_unit);
if (result != noErr) {
ERR_PRINT("AudioOutputUnitStop failed");
}
active = false;
}
result = AudioUnitUninitialize(audio_unit);
if (result != noErr) {
ERR_PRINT("AudioUnitUninitialize failed");
}
#ifdef OSX_ENABLED
AudioObjectPropertyAddress prop;
prop.mSelector = kAudioHardwarePropertyDefaultOutputDevice;
prop.mScope = kAudioObjectPropertyScopeGlobal;
prop.mElement = kAudioObjectPropertyElementMaster;
result = AudioObjectRemovePropertyListener(kAudioObjectSystemObject, &prop, &output_device_address_cb, this);
if (result != noErr) {
ERR_PRINT("AudioObjectRemovePropertyListener failed");
}
#endif
result = AudioComponentInstanceDispose(audio_unit);
if (result != noErr) {
ERR_PRINT("AudioComponentInstanceDispose failed");
}
audio_unit = NULL;
unlock();
}
if (mutex) {
memdelete(mutex);
mutex = NULL;
}
}
~Input()
{
if (m_inputUnit)
AudioComponentInstanceDispose(m_inputUnit);
free(m_buffers);
if (m_audioBus)
delete m_audioBus;
}
void
coreaudio_object_close(struct audio_object *object)
{
struct coreaudio_object *self = to_coreaudio_object(object);
if(self->initialized) {
AudioUnitUninitialize(self->outputUnit);
AudioComponentInstanceDispose(self->outputUnit);
TPCircularBufferCleanup(&(self->circularBuffer));
self->initialized = FALSE;
}
}
void CloseDefaultAU () {
OSStatus err = noErr;
err = AudioOutputUnitStop (gOutputUnit);
if (err) { printf ("AudioOutputUnitStop=%ld\n", (long int)err); }
err = AudioUnitUninitialize (gOutputUnit);
if (err) { printf ("AudioUnitUninitialize=%ld\n", (long int)err); }
AudioComponentInstanceDispose (gOutputUnit);
if (inputBuffer) deallocAudioBufferList(inputBuffer);
}
bool coreAudioDevice::localStop(void)
{
if (_inUse)
{
verify_noerr(AudioOutputUnitStop(theOutputUnit));
// Clean up
verify_noerr(AudioUnitUninitialize(theOutputUnit));
verify_noerr(AudioComponentInstanceDispose(theOutputUnit));
}
_inUse=0;
ADM_usleep(10*1000);
return 1;
}
void close()
{
if (isRunning)
{
isRunning = false;
AudioSessionSetActive (false);
if (audioUnit != 0)
{
AudioComponentInstanceDispose (audioUnit);
audioUnit = 0;
}
}
}
void close()
{
if (isRunning)
{
isRunning = false;
AudioSessionRemovePropertyListenerWithUserData (kAudioSessionProperty_AudioRouteChange, routingChangedStatic, this);
AudioSessionSetActive (false);
if (audioUnit != 0)
{
AudioComponentInstanceDispose (audioUnit);
audioUnit = 0;
}
}
}
static tsk_object_t* tdav_audiounit_instance_dtor(tsk_object_t * self)
{
tdav_audiounit_instance_t* inst = self;
if(inst){
tsk_safeobj_lock(inst);
if(inst->audioUnit){
AudioUnitUninitialize(inst->audioUnit);
AudioComponentInstanceDispose(inst->audioUnit);
inst->audioUnit = tsk_null;
}
tsk_safeobj_unlock(inst);
tsk_safeobj_deinit(inst);
}
return self;
}
void close() override
{
if (isRunning)
{
isRunning = false;
setSessionUInt32Property (kAudioSessionProperty_AudioCategory, kAudioSessionCategory_MediaPlayback);
AudioSessionRemovePropertyListenerWithUserData (kAudioSessionProperty_AudioRouteChange, routingChangedStatic, this);
AudioSessionSetActive (false);
if (audioUnit != 0)
{
AudioComponentInstanceDispose (audioUnit);
audioUnit = 0;
}
}
}
InputImplAudioUnit::~InputImplAudioUnit()
{
if( mIsCapturing ) {
stop();
}
if( mInputUnit ) {
AudioComponentInstanceDispose( mInputUnit );
}
for( int i = 0; i < mCircularBuffers.size(); i++ ) {
delete mCircularBuffers[i];
}
if( mInputBuffer )
free( mInputBuffer );
if( mInputBufferData )
free( mInputBufferData );
}
void CAPlayThrough::Cleanup()
{
//clean up
Stop();
delete mBuffer;
mBuffer = 0;
if(mInputBuffer){
for(UInt32 i = 0; i<mInputBuffer->mNumberBuffers; i++)
free(mInputBuffer->mBuffers[i].mData);
free(mInputBuffer);
mInputBuffer = 0;
}
AudioUnitUninitialize(mInputUnit);
AUGraphClose(mGraph);
DisposeAUGraph(mGraph);
AudioComponentInstanceDispose(mInputUnit);
}
static void coreaudio_free(void *data)
{
coreaudio_t *dev = (coreaudio_t*)data;
if (!dev)
return;
if (dev->dev_alive)
{
AudioOutputUnitStop(dev->dev);
AudioComponentInstanceDispose(dev->dev);
}
if (dev->buffer)
fifo_free(dev->buffer);
pthread_mutex_destroy(&dev->lock);
pthread_cond_destroy(&dev->cond);
free(dev);
}
/*
*This function handles a change in the audio's route.
*(TODO) this needs some work, should be a member of the class and call setupIO in place of SetupRemoteIO;
*(TODO) make sure we don't crash when input becomes unavailable on an iPod Touch.
*/
void propListener( void * inClientData, AudioSessionPropertyID inID, UInt32 inDataSize, const void *inData )
{
//NSLog(@"propListener");
MUEAudioIO *THIS = (MUEAudioIO*)inClientData;
if (inID == kAudioSessionProperty_AudioRouteChange)
{
// if there was a route change, we need to dispose the current rio unit and create a new one
AudioComponentInstanceDispose(THIS->rioUnit);
//SetupRemoteIO(THIS->rioUnit, THIS->inputProc, THIS->thruFormat);
THIS->setupIO(); //(TODO) will this work?
UInt32 size = sizeof(THIS->hwSampleRate);
AudioSessionGetProperty(kAudioSessionProperty_CurrentHardwareSampleRate, &size, &THIS->hwSampleRate);
AudioOutputUnitStart(THIS->rioUnit);
//See what the new routing is, and take dependent action...
CFStringRef newRoute;
size = sizeof(CFStringRef);
AudioSessionGetProperty(kAudioSessionProperty_AudioRoute, &size, &newRoute);
if (newRoute)
{
CFShow(newRoute);
if (CFStringCompare(newRoute, CFSTR("Headset"), NULL) == kCFCompareEqualTo) // headset plugged in
{
//Do something if you'd like
}
else if (CFStringCompare(newRoute, CFSTR("Receiver"), NULL) == kCFCompareEqualTo) // headset plugged in
{
//Do something if you'd like
}
else //Something else must be plugged in...Third party?
{
//Do something if you'd like
}
}
}
}
static void
audiounit_stream_destroy(cubeb_stream * stm)
{
int r;
stm->shutdown = 1;
if (stm->unit) {
AudioOutputUnitStop(stm->unit);
AudioUnitUninitialize(stm->unit);
#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060
CloseComponent(stm->unit);
#else
AudioComponentInstanceDispose(stm->unit);
#endif
}
r = pthread_mutex_destroy(&stm->mutex);
assert(r == 0);
free(stm);
}
static void
COREAUDIO_CloseDevice(_THIS)
{
if (this->hidden != NULL) {
if (this->hidden->audioUnitOpened) {
OSStatus result = noErr;
AURenderCallbackStruct callback;
const AudioUnitElement output_bus = 0;
const AudioUnitElement input_bus = 1;
const int iscapture = this->iscapture;
const AudioUnitElement bus =
((iscapture) ? input_bus : output_bus);
const AudioUnitScope scope =
((iscapture) ? kAudioUnitScope_Output :
kAudioUnitScope_Input);
/* stop processing the audio unit */
result = AudioOutputUnitStop(this->hidden->audioUnit);
/* Remove the input callback */
SDL_memset(&callback, 0, sizeof(AURenderCallbackStruct));
result = AudioUnitSetProperty(this->hidden->audioUnit,
kAudioUnitProperty_SetRenderCallback,
scope, bus, &callback,
sizeof(callback));
#if MACOSX_COREAUDIO
CloseComponent(this->hidden->audioUnit);
#else
AudioComponentInstanceDispose(this->hidden->audioUnit);
#endif
this->hidden->audioUnitOpened = 0;
}
SDL_free(this->hidden->buffer);
SDL_free(this->hidden);
this->hidden = NULL;
}
}
void AudioDriverCoreAudio::capture_finish() {
if (input_unit) {
lock();
AURenderCallbackStruct callback;
zeromem(&callback, sizeof(AURenderCallbackStruct));
OSStatus result = AudioUnitSetProperty(input_unit, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &callback, sizeof(callback));
if (result != noErr) {
ERR_PRINT("AudioUnitSetProperty failed");
}
result = AudioUnitUninitialize(input_unit);
if (result != noErr) {
ERR_PRINT("AudioUnitUninitialize failed");
}
#ifdef OSX_ENABLED
AudioObjectPropertyAddress prop;
prop.mSelector = kAudioHardwarePropertyDefaultInputDevice;
prop.mScope = kAudioObjectPropertyScopeGlobal;
prop.mElement = kAudioObjectPropertyElementMaster;
result = AudioObjectRemovePropertyListener(kAudioObjectSystemObject, &prop, &input_device_address_cb, this);
if (result != noErr) {
ERR_PRINT("AudioObjectRemovePropertyListener failed");
}
#endif
result = AudioComponentInstanceDispose(input_unit);
if (result != noErr) {
ERR_PRINT("AudioComponentInstanceDispose failed");
}
input_unit = NULL;
unlock();
}
}
static void
COREAUDIO_CloseDevice(_THIS)
{
if (this->hidden != NULL) {
if (this->hidden->audioUnitOpened) {
#if MACOSX_COREAUDIO
/* Unregister our disconnect callback. */
AudioObjectRemovePropertyListener(this->hidden->deviceID, &alive_address, device_unplugged, this);
#endif
AURenderCallbackStruct callback;
const AudioUnitElement output_bus = 0;
const AudioUnitElement input_bus = 1;
const int iscapture = this->iscapture;
const AudioUnitElement bus =
((iscapture) ? input_bus : output_bus);
const AudioUnitScope scope =
((iscapture) ? kAudioUnitScope_Output :
kAudioUnitScope_Input);
/* stop processing the audio unit */
AudioOutputUnitStop(this->hidden->audioUnit);
/* Remove the input callback */
SDL_memset(&callback, 0, sizeof(AURenderCallbackStruct));
AudioUnitSetProperty(this->hidden->audioUnit,
kAudioUnitProperty_SetRenderCallback,
scope, bus, &callback, sizeof(callback));
AudioComponentInstanceDispose(this->hidden->audioUnit);
this->hidden->audioUnitOpened = 0;
}
SDL_free(this->hidden->buffer);
SDL_free(this->hidden);
this->hidden = NULL;
}
}