void AudioDestinationMac::stop() { OSStatus result = AudioOutputUnitStop(m_outputUnit); if (!result) m_isPlaying = false; // LabSound result = AudioOutputUnitStop(m_input->m_inputUnit); }
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 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; } }
/* interruption listeners */ void audio_unit_interruption_listener(void *closure, UInt32 inInterruptionState) { OSStatus err = 0; aubio_audio_unit_t *o = (aubio_audio_unit_t *) closure; AudioUnit this_unit = o->audio_unit; if (inInterruptionState == kAudioSessionEndInterruption) { AUBIO_WRN("audio_unit: session interruption ended\n"); err = AudioSessionSetActive(true); if (err) { AUBIO_ERR("audio_unit: could not make session active after interruption (%d)\n", (int)err); goto fail; } err = AudioOutputUnitStart(this_unit); if (err) { AUBIO_ERR("audio_unit: failed starting unit (%d)\n", (int)err); goto fail; } } if (inInterruptionState == kAudioSessionBeginInterruption) { AUBIO_WRN("audio_unit: session interruption started\n"); err = AudioOutputUnitStop(this_unit); if (err) { AUBIO_ERR("audio_unit: could not stop unit at interruption (%d)\n", (int)err); goto fail; } err = AudioSessionSetActive(false); if (err) { AUBIO_ERR("audio_unit: could not make session inactive after interruption (%d)\n", (int)err); goto fail; } } fail: return; }
static void ca_stop_capture(ALCdevice *device) { ca_data *data = (ca_data*)device->ExtraData; OSStatus err = AudioOutputUnitStop(data->audioUnit); if(err != noErr) ERR("AudioOutputUnitStop failed\n"); }
void CoreAudioDriver::disconnect() { OSStatus err = noErr; err = AudioOutputUnitStop( m_outputUnit ); err = AudioUnitUninitialize( m_outputUnit ); err = AudioComponentInstanceDispose( m_outputUnit ); }
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)); //CloseComponent(this->hidden->audioUnit); this->hidden->audioUnitOpened = 0; } SDL_free(this->hidden->buffer); SDL_free(this->hidden); this->hidden = NULL; } }
void CoreAudioDriver::disconnect() { OSStatus err = noErr; err = AudioOutputUnitStop( m_outputUnit ); err = AudioUnitUninitialize( m_outputUnit ); err = CloseComponent( m_outputUnit ); }
void AudioDestinationMac::stop() { OSStatus result = AudioOutputUnitStop(m_outputUnit); if (!result) setIsPlaying(false); }
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 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 AudioDriverOSX::finish() { if (active) AudioOutputUnitStop(audio_unit); memdelete_arr(samples_in); };
void Core_CloseAudio(_THIS) { OSStatus result; struct AURenderCallbackStruct callback; /* stop processing the audio unit */ result = AudioOutputUnitStop (outputAudioUnit); if (result != noErr) { SDL_SetError("Core_CloseAudio: AudioOutputUnitStop"); return; } /* Remove the input callback */ callback.inputProc = 0; callback.inputProcRefCon = 0; result = AudioUnitSetProperty (outputAudioUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &callback, sizeof(callback)); if (result != noErr) { SDL_SetError("Core_CloseAudio: AudioUnitSetProperty (kAudioUnitProperty_SetInputCallback)"); return; } result = CloseComponent(outputAudioUnit); if (result != noErr) { SDL_SetError("Core_CloseAudio: CloseComponent"); return; } SDL_free(buffer); }
static int coreaudio_pause(void) { state = OUTPUT_STATE_PAUSED; AudioOutputUnitStop(output_unit); return 0; }
static bool coreaudio_stop(void *data) { coreaudio_t *dev = (coreaudio_t*)data; if (!dev) return false; dev->is_paused = (AudioOutputUnitStop(dev->dev) == noErr) ? true : false; return dev->is_paused ? true : false; }
void AudioLoopImplCocoa::stop() { if (initialized) { OSStatus err = AudioOutputUnitStop(audioUnit); if (err) printf("AudioOutputUnitStop ERROR: %d\n", (int)err); } }
int MUEAudioIO::stopIO() { OSStatus err = AudioOutputUnitStop(rioUnit); if(err) printf("MUEAudioIO::stopIO: Couldn't stop audio unit\n"); return 0; }
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 CoreAudioOutput::stop() { OSSpinLockLock(this->_spinlockAU); AudioOutputUnitStop(this->_au); OSSpinLockUnlock(this->_spinlockAU); this->clearBuffer(); }
static int audiounit_stream_stop(cubeb_stream * stm) { OSStatus r; r = AudioOutputUnitStop(stm->unit); assert(r == 0); stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_STOPPED); return CUBEB_OK; }
bool CCoreAudioUnit::Stop() { if (!m_audioUnit) return false; AudioOutputUnitStop(m_audioUnit); return true; }
static void pause_coreaudio(audio_output_t *ao) { mpg123_coreaudio_t* ca = (mpg123_coreaudio_t*)ao->userptr; if (ca->play) { ca->play = 0; AudioOutputUnitStop(ca->outputUnit); } }
void iOSCoreAudioShutdown() { if (audioInstance) { AudioOutputUnitStop(audioInstance); AudioUnitUninitialize(audioInstance); AudioComponentInstanceDispose(audioInstance); audioInstance = nil; } }
// ---------------------------------------------------------- bool ofxAudioUnitInput::stop() // ---------------------------------------------------------- { if(_unit) { OFXAU_RET_BOOL(AudioOutputUnitStop(*_unit), "stopping hardware input unit"); } return false; }
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"); }
void AudioDriverCoreAudio::stop() { if (active) { OSStatus result = AudioOutputUnitStop(audio_unit); if (result != noErr) { ERR_PRINT(("AudioOutputUnitStop failed, code: " + itos(result)).utf8().get_data()); } else { active = false; } } }
int close(){ int res; if (out){ res=AudioOutputUnitStop(out); if (res) return res; out=0; } return 0; }
static void Audio_waitToStop(Audio *audio, const char *alias, bool *m_playing) { /* wait */ while(*m_playing == true && audio->end == false) { MMDAgent_sleep(AUDIOTHREAD_ENDSLEEPMS); } /* stop */ AudioOutputUnitStop(audio->device); }