void ca_close(phastream_t *as) {
ca_dev *cadev = (ca_dev *) as->drvinfo;
DBG_DYNA_AUDIO_DRV("** Closing audio stream\n");
verify_noerr(AudioDeviceStop(get_audiodeviceid(cadev->inputID), input_proc));
clean_input_device(as);
verify_noerr(AudioOutputUnitStop(cadev->outputAU));
verify_noerr(AudioUnitUninitialize (cadev->outputAU));
printf("phad_coreaudio:ca_close:cleaning cadev\n"); // power pc hack 2/2
if (cadev) {
if (cadev->convertedInputBuffer) {
free(cadev->convertedInputBuffer);
}
cadev->convertedInputBuffer = NULL;
if (cadev->inputConverter) {
AudioConverterDispose(cadev->inputConverter);
cadev->inputConverter = NULL;
}
free(cadev);
as->drvinfo = 0;
}
}
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);
CloseComponent(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;
}
void CoreAudioDriver::disconnect()
{
OSStatus err = noErr;
err = AudioOutputUnitStop( m_outputUnit );
err = AudioUnitUninitialize( m_outputUnit );
err = AudioComponentInstanceDispose( m_outputUnit );
}
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;
}
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 = CloseComponent( m_outputUnit );
}
/** free all memory allocated by a driver instance
*/
static void coreaudio_driver_delete(coreaudio_driver_t * driver)
{
AudioDeviceRemovePropertyListener(driver->device_id, 0, true, kAudioDeviceProcessorOverload, notification);
free(driver->input_list);
AudioUnitUninitialize(driver->au_hal);
CloseComponent(driver->au_hal);
free(driver);
}
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 CCoreAudioUnit::Close()
{
if (m_Initialized)
AudioUnitUninitialize(m_Component);
if (m_Component)
CloseComponent(m_Component);
m_Initialized = false;
m_Component = 0;
}
void AudioLoopImplCocoa::shutdown()
{
if (initialized)
{
AudioOutputUnitStop(audioUnit);
AudioUnitUninitialize(audioUnit);
AudioComponentInstanceDispose(audioUnit);
audioUnit = NULL;
}
}
static void ca_stop_playback(ALCdevice *device)
{
ca_data *data = (ca_data*)device->ExtraData;
OSStatus err;
AudioOutputUnitStop(data->audioUnit);
err = AudioUnitUninitialize(data->audioUnit);
if(err != noErr)
ERR("-- AudioUnitUninitialize failed.\n");
}
static void ca_close_playback(ALCdevice *device)
{
ca_data *data = (ca_data*)device->ExtraData;
AudioUnitUninitialize(data->audioUnit);
CloseComponent(data->audioUnit);
free(data);
device->ExtraData = NULL;
}
void
gst_core_audio_unitialize (GstCoreAudio * core_audio)
{
AudioUnitUninitialize (core_audio->audiounit);
if (core_audio->recBufferList) {
buffer_list_free (core_audio->recBufferList);
core_audio->recBufferList = NULL;
}
}
static void
osx_output_close(struct audio_output *ao)
{
struct osx_output *od = (struct osx_output *)ao;
AudioOutputUnitStop(od->au);
AudioUnitUninitialize(od->au);
fifo_buffer_free(od->buffer);
}
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;
}
}
sint_t aubio_audio_unit_stop(aubio_audio_unit_t *o)
{
if (o->audio_unit == NULL) return -1;
OSStatus err = AudioOutputUnitStop (o->audio_unit);
if (err) { AUBIO_WRN("audio_unit: failed stopping audio unit (%d)\n", (int)err); }
err = AudioUnitUninitialize (o->audio_unit);
if (err) { AUBIO_WRN("audio_unit: failed unitializing audio unit (%d)\n", (int)err); }
err = AudioSessionSetActive(false);
if (err) { AUBIO_WRN("audio_unit: failed stopping audio session (%d)\n", (int)err); }
return err;
}
static void Audio_close(Audio *audio, const char *alias)
{
/* uninitialize audio device */
AudioUnitUninitialize(audio->device);
/* close audio device */
CloseComponent(audio->device);
/* close audio file */
ExtAudioFileDispose(audio->file);
}
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;
}
static void osx_output_close(void *data)
{
struct osx_output *od = data;
g_mutex_lock(od->mutex);
while (od->len) {
g_cond_wait(od->condition, od->mutex);
}
g_mutex_unlock(od->mutex);
AudioOutputUnitStop(od->au);
AudioUnitUninitialize(od->au);
CloseComponent(od->au);
}
int sound_close_AudioUnit(){
if( soundInit == 1 )
{
OSStatus status = AudioOutputUnitStop(audioUnit);
checkStatus(status);
AudioUnitUninitialize(audioUnit);
soundInit = 0;
head = 0;
tail = 0;
}
return 1;
}
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 CoreAudioSound::Stop()
{
OSStatus err;
err = AudioOutputUnitStop(audioUnit);
if (err != noErr)
ERROR_LOG(AUDIO, "error stopping audiounit");
err = AudioUnitUninitialize(audioUnit);
if (err != noErr)
ERROR_LOG(AUDIO, "error uninitializing audiounit");
err = CloseComponent(audioUnit);
if (err != noErr)
ERROR_LOG(AUDIO, "error closing audio component");
}
void
otMacAudioStreamBase::FreeData()
{
if (mAudioUnit) {
AudioUnitUninitialize(mAudioUnit);
//CloseComponent(mAudioUnit);
mAudioUnit = nsnull;
}
if (mBuffer) {
for (UInt32 i = 0; i < mBuffer->mNumberBuffers; i++)
if (mBuffer->mBuffers[i].mData)
nsMemory::Free(mBuffer->mBuffers[i].mData);
nsMemory::Free(mBuffer);
mBuffer = nsnull;
}
}
int
sa_stream_destroy(sa_stream_t *s) {
int result = SA_SUCCESS;
if (s == NULL) {
return SA_SUCCESS;
}
/*
* Shut down the audio output device. Don't hold the mutex when stopping
* the audio device, because it is possible to deadlock with this thread
* holding mutex then waiting on an internal Core Audio lock, and with the
* callback thread holding the Core Audio lock and waiting on the mutex.
* This does not need to be protected by the mutex anyway because
* AudioOutputUnitStop, when called from the non-callback thread, blocks
* until in-flight callbacks complete and the HAL shuts down. See:
* http://lists.apple.com/archives/coreaudio-api/2005/Dec/msg00055.html
*/
if (s->output_unit != NULL) {
if (s->playing && AudioOutputUnitStop(s->output_unit) != 0) {
result = SA_ERROR_SYSTEM;
}
if (AudioUnitUninitialize(s->output_unit) != 0) {
result = SA_ERROR_SYSTEM;
}
if (CloseComponent(s->output_unit) != noErr) {
result = SA_ERROR_SYSTEM;
}
}
/*
* Release resources.
*/
if (pthread_mutex_destroy(&s->mutex) != 0) {
result = SA_ERROR_SYSTEM;
}
while (s->bl_head != NULL) {
sa_buf * next = s->bl_head->next;
free(s->bl_head);
s->bl_head = next;
}
free(s);
return result;
}
static void ca_stop_w(CAData *d){
OSErr err;
if(d->write_started == TRUE) {
if(AudioOutputUnitStop(d->caOutAudioUnit) == noErr)
d->write_started=FALSE;
}
if (d->caOutConverter!=NULL)
{
AudioConverterDispose(d->caOutConverter);
d->caOutConverter=NULL;
}
if (d->caOutAudioUnit!=NULL)
{
AudioUnitUninitialize(d->caOutAudioUnit);
d->caOutAudioUnit=NULL;
}
}
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);
}
void
sound_lowlevel_end( void )
{
OSStatus err;
if( audio_output_started )
verify_noerr( AudioOutputUnitStop( gOutputUnit ) );
err = AudioUnitUninitialize( gOutputUnit );
if( err ) {
printf( "AudioUnitUninitialize=%ld", err );
}
CloseComponent( gOutputUnit );
sfifo_flush( &sound_fifo );
sfifo_close( &sound_fifo );
}
