Error AudioDriverIphone::init() {
active = false;
channels = 2;
AudioStreamBasicDescription strdesc;
strdesc.mFormatID = kAudioFormatLinearPCM;
strdesc.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsPacked;
strdesc.mChannelsPerFrame = channels;
strdesc.mSampleRate = 44100;
strdesc.mFramesPerPacket = 1;
strdesc.mBitsPerChannel = 16;
strdesc.mBytesPerFrame =
strdesc.mBitsPerChannel * strdesc.mChannelsPerFrame / 8;
strdesc.mBytesPerPacket =
strdesc.mBytesPerFrame * strdesc.mFramesPerPacket;
OSStatus result = noErr;
AURenderCallbackStruct callback;
AudioComponentDescription desc;
AudioComponent comp = NULL;
const AudioUnitElement output_bus = 0;
const AudioUnitElement bus = output_bus;
const AudioUnitScope scope = kAudioUnitScope_Input;
zeromem(&desc, sizeof(desc));
desc.componentType = kAudioUnitType_Output;
desc.componentSubType = kAudioUnitSubType_RemoteIO; /* !!! FIXME: ? */
comp = AudioComponentFindNext(NULL, &desc);
desc.componentManufacturer = kAudioUnitManufacturer_Apple;
result = AudioComponentInstanceNew(comp, &audio_unit);
ERR_FAIL_COND_V(result != noErr, FAILED);
ERR_FAIL_COND_V(comp == NULL, FAILED);
result = AudioUnitSetProperty(audio_unit,
kAudioUnitProperty_StreamFormat,
scope, bus, &strdesc, sizeof(strdesc));
ERR_FAIL_COND_V(result != noErr, FAILED);
zeromem(&callback, sizeof(AURenderCallbackStruct));
callback.inputProc = &AudioDriverIphone::output_callback;
callback.inputProcRefCon = this;
result = AudioUnitSetProperty(audio_unit,
kAudioUnitProperty_SetRenderCallback,
scope, bus, &callback, sizeof(callback));
ERR_FAIL_COND_V(result != noErr, FAILED);
result = AudioUnitInitialize(audio_unit);
ERR_FAIL_COND_V(result != noErr, FAILED);
result = AudioOutputUnitStart(audio_unit);
ERR_FAIL_COND_V(result != noErr, FAILED);
const int samples = 1024;
samples_in = memnew_arr(int32_t, samples); // whatever
buffer_frames = samples / channels;
return FAILED;
};
OSStatus FCoreAudioSoundSource::CreateAudioUnit( OSType Type, OSType SubType, OSType Manufacturer, AudioStreamBasicDescription* InputFormat, AudioStreamBasicDescription* OutputFormat, AUNode* OutNode, AudioUnit* OutUnit )
{
AudioComponentDescription Desc;
Desc.componentFlags = 0;
Desc.componentFlagsMask = 0;
Desc.componentType = Type;
Desc.componentSubType = SubType;
Desc.componentManufacturer = Manufacturer;
OSStatus Status = AUGraphAddNode( AudioDevice->GetAudioUnitGraph(), &Desc, OutNode );
if( Status == noErr )
{
Status = AUGraphNodeInfo( AudioDevice->GetAudioUnitGraph(), *OutNode, NULL, OutUnit );
}
if( Status == noErr )
{
if( InputFormat )
{
Status = AudioUnitSetProperty( *OutUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, InputFormat, sizeof( AudioStreamBasicDescription ) );
}
if( Status == noErr )
{
if( OutputFormat )
{
Status = AudioUnitSetProperty( *OutUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 0, OutputFormat, sizeof( AudioStreamBasicDescription ) );
}
}
}
return Status;
}
// ----------------------------------------------------------
void ofxAudioUnitNetReceive::connectToHost(const std::string &address, unsigned long port)
// ----------------------------------------------------------
{
stringstream ss;
ss << address << ":" << port;
CFStringRef hostName = CFStringCreateWithCString(kCFAllocatorDefault,
ss.str().c_str(),
kCFStringEncodingUTF8);
OFXAU_PRINT(AudioUnitSetProperty(*_unit,
kAUNetReceiveProperty_Hostname,
kAudioUnitScope_Global,
0,
&hostName,
sizeof(hostName)),
"setting net receive host name");
// setting net send disconnect to 0 to connect net receive because that makes sense
UInt32 connect = 0;
OFXAU_PRINT(AudioUnitSetProperty(*_unit,
kAUNetSendProperty_Disconnect,
kAudioUnitScope_Global,
0,
&connect,
sizeof(connect)),
"connecting net receive");
CFRelease(hostName);
}
static int audiounits_start(void *usr) {
au_instance_t *ap = (au_instance_t*) usr;
OSStatus err;
if (ap->kind == AI_RECORDER) {
#if defined(MAC_OS_X_VERSION_10_5) && (MAC_OS_X_VERSION_MIN_REQUIRED>=MAC_OS_X_VERSION_10_5)
err = AudioDeviceStart(ap->inDev, ap->inIOProcID);
#else
err = AudioDeviceStart(ap->inDev, inputRenderProc);
#endif
if (err) Rf_error("unable to start recording (%08x)", err);
} else {
AURenderCallbackStruct renderCallback = { outputRenderProc, usr };
ap->done = NO;
/* set format */
ap->fmtOut.mSampleRate = ap->sample_rate;
err = AudioUnitSetProperty(ap->outUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &ap->fmtOut, sizeof(ap->fmtOut));
if (err) Rf_error("unable to set output audio format (%08x)", err);
/* set callback */
err = AudioUnitSetProperty(ap->outUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &renderCallback, sizeof(renderCallback));
if (err) Rf_error("unable to register audio callback (%08x)", err);
/* start audio */
err = AudioOutputUnitStart(ap->outUnit);
if (err) Rf_error("unable to start playback (%08x)", err);
}
return 1;
}
void AudioDestinationIOS::configure()
{
// Set render callback
AURenderCallbackStruct input;
input.inputProc = inputProc;
input.inputProcRefCon = this;
OSStatus result = AudioUnitSetProperty(m_outputUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &input, sizeof(input));
ASSERT(!result);
// Set stream format
AudioStreamBasicDescription streamFormat;
UInt32 size = sizeof(AudioStreamBasicDescription);
result = AudioUnitGetProperty(m_outputUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 0, (void*)&streamFormat, &size);
ASSERT(!result);
const int bytesPerFloat = sizeof(Float32);
const int bitsPerByte = 8;
streamFormat.mSampleRate = m_sampleRate;
streamFormat.mFormatID = kAudioFormatLinearPCM;
streamFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kAudioFormatFlagIsNonInterleaved;
streamFormat.mBytesPerPacket = bytesPerFloat;
streamFormat.mFramesPerPacket = 1;
streamFormat.mBytesPerFrame = bytesPerFloat;
streamFormat.mChannelsPerFrame = 2;
streamFormat.mBitsPerChannel = bitsPerByte * bytesPerFloat;
result = AudioUnitSetProperty(m_outputUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, (void*)&streamFormat, sizeof(AudioStreamBasicDescription));
ASSERT(!result);
AudioSession::sharedSession().setPreferredBufferSize(kPreferredBufferSize);
}
OSStatus CAPlayThrough::EnableIO()
{
OSStatus err = noErr;
UInt32 enableIO;
///////////////
//ENABLE IO (INPUT)
//You must enable the Audio Unit (AUHAL) for input and disable output
//BEFORE setting the AUHAL's current device.
//Enable input on the AUHAL
enableIO = 1;
err = AudioUnitSetProperty(mInputUnit,
kAudioOutputUnitProperty_EnableIO,
kAudioUnitScope_Input,
1, // input element
&enableIO,
sizeof(enableIO));
checkErr(err);
//disable Output on the AUHAL
enableIO = 0;
err = AudioUnitSetProperty(mInputUnit,
kAudioOutputUnitProperty_EnableIO,
kAudioUnitScope_Output,
0, //output element
&enableIO,
sizeof(enableIO));
return err;
}
bool CAUOutputDevice::EnableInputOuput()
{
if (!m_audioUnit)
return false;
OSStatus ret;
UInt32 enable;
UInt32 hasio;
UInt32 size=sizeof(UInt32);
ret = AudioUnitGetProperty(m_audioUnit,kAudioOutputUnitProperty_HasIO,kAudioUnitScope_Input, 1, &hasio, &size);
if (hasio)
{
enable = 1;
ret = AudioUnitSetProperty(m_audioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, kInputBus, &enable, sizeof(enable));
if (ret)
{
CLog::Log(LOGERROR, "CAUOutputDevice::EnableInputOuput:: Unable to enable input on bus 1. Error = %s", GetError(ret).c_str());
return false;
}
enable = 1;
ret = AudioUnitSetProperty(m_audioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, kOutputBus, &enable, sizeof(enable));
if (ret)
{
CLog::Log(LOGERROR, "CAUOutputDevice::EnableInputOuput:: Unable to disable output on bus 0. Error = %s", GetError(ret).c_str());
return false;
}
}
return true;
}
void AudioDestinationMac::configure()
{
// Set render callback
AURenderCallbackStruct input;
input.inputProc = inputProc;
input.inputProcRefCon = this;
OSStatus result = AudioUnitSetProperty(m_outputUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Global, 0, &input, sizeof(input));
ASSERT(!result);
// Set stream format
AudioStreamBasicDescription streamFormat;
streamFormat.mSampleRate = m_sampleRate;
streamFormat.mFormatID = kAudioFormatLinearPCM;
streamFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kAudioFormatFlagIsNonInterleaved;
streamFormat.mBitsPerChannel = 8 * sizeof(Float32);
streamFormat.mChannelsPerFrame = 2;
streamFormat.mFramesPerPacket = 1;
streamFormat.mBytesPerPacket = sizeof(Float32);
streamFormat.mBytesPerFrame = sizeof(Float32);
result = AudioUnitSetProperty(m_outputUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, (void*)&streamFormat, sizeof(AudioStreamBasicDescription));
ASSERT(!result);
// Set the buffer frame size.
UInt32 bufferSize = kBufferSize;
result = AudioUnitSetProperty(m_outputUnit, kAudioDevicePropertyBufferFrameSize, kAudioUnitScope_Output, 0, (void*)&bufferSize, sizeof(bufferSize));
ASSERT(!result);
m_input->configure(streamFormat, bufferSize);
}
void ofxAudioUnitFilePlayer::prime() {
_region = RegionForEntireFile(_fileID[0]);
if(_seekSampleTime) {
_region.mStartFrame = _seekSampleTime;
_pauseTimeAccumulator += _seekSampleTime;
} else if(_pauseTimeStamp.mSampleTime > 0) {
_region.mStartFrame = _pauseTimeStamp.mSampleTime + _pauseTimeAccumulator;
_pauseTimeAccumulator += _pauseTimeStamp.mSampleTime;
} else {
_pauseTimeAccumulator = 0;
}
if(_loopCount > 0) {
_region.mLoopCount = _loopCount;
}
// resetting time-tracking members
memset(&_pauseTimeStamp, 0, sizeof(_pauseTimeStamp));
_loopCount = 0;
_seekSampleTime = 0;
if(!(_region.mTimeStamp.mFlags & kAudioTimeStampHostTimeValid)) {
cout << "ofxAudioUnitFilePlayer has no file to play" << endl;
return;
}
OFXAU_RETURN(AudioUnitSetProperty(*_unit,
kAudioUnitProperty_ScheduledFileIDs,
kAudioUnitScope_Global,
0,
_fileID,
sizeof(_fileID)),
"setting file player's file ID");
OFXAU_RETURN(AudioUnitSetProperty(*_unit,
kAudioUnitProperty_ScheduledFileRegion,
kAudioUnitScope_Global,
0,
&_region,
sizeof(_region)),
"setting file player region");
UInt32 framesToPrime = 0; // 0 = "use the default"
OFXAU_RETURN(AudioUnitSetProperty(*_unit,
kAudioUnitProperty_ScheduledFilePrime,
kAudioUnitScope_Global,
0,
&framesToPrime,
sizeof(framesToPrime)),
"priming file player");
_primed = true;
}
int SetupRemoteIO (AudioUnit& inRemoteIOUnit, Float64 sampleRate, AURenderCallbackStruct inRenderProc, CAStreamBasicDescription& outFormat)
{
try {
// Open the output unit
AudioComponentDescription desc;
desc.componentType = kAudioUnitType_Output;
desc.componentSubType = kAudioUnitSubType_RemoteIO;
desc.componentManufacturer = kAudioUnitManufacturer_Apple;
desc.componentFlags = 0;
desc.componentFlagsMask = 0;
AudioComponent comp = AudioComponentFindNext(NULL, &desc);
XThrowIfError(AudioComponentInstanceNew(comp, &inRemoteIOUnit), "couldn't open the remote I/O unit");
UInt32 zero = 0;
UInt32 one = 1;
//enable input
XThrowIfError(AudioUnitSetProperty(inRemoteIOUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, &one, sizeof(one)), "couldn't enable input on the remote I/O unit");
//disable output
XThrowIfError(AudioUnitSetProperty(inRemoteIOUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, &zero, sizeof(zero)), "couldn't disable output ");
//set input callback
XThrowIfError(AudioUnitSetProperty(inRemoteIOUnit, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 1, &inRenderProc, sizeof(inRenderProc)), "couldn't set remote i/o input callback");
// set our required format - LPCM non-interleaved 32 bit floating point
AudioStreamBasicDescription outFormat;
outFormat.mSampleRate = sampleRate;
outFormat.mFormatID = kAudioFormatLinearPCM;
outFormat.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked | kAudioFormatFlagIsFloat | kAudioFormatFlagIsNonInterleaved;
outFormat.mFramesPerPacket = 1;
outFormat.mBytesPerPacket= 4;
outFormat.mChannelsPerFrame = 1;
outFormat.mBitsPerChannel = 32;
outFormat.mBytesPerFrame = 4;
XThrowIfError(AudioUnitSetProperty(inRemoteIOUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &outFormat, sizeof(outFormat)), "couldn't set the remote I/O unit's output client format");
XThrowIfError(AudioUnitInitialize(inRemoteIOUnit), "couldn't initialize the remote I/O unit");
}
catch (CAXException &e) {
char buf[256];
fprintf(stderr, "Error: %s (%s)\n", e.mOperation, e.FormatError(buf));
return 1;
}
catch (...) {
fprintf(stderr, "An unknown error occurred\n");
return 1;
}
return 0;
}
OSStatus CAAudioUnit::SetPresentPreset (AUPreset &inData)
{
OSStatus result = AudioUnitSetProperty (AU(), kAudioUnitProperty_PresentPreset,
kAudioUnitScope_Global, 0,
&inData, sizeof (AUPreset));
if (result == kAudioUnitErr_InvalidProperty) {
result = AudioUnitSetProperty (AU(), kAudioUnitProperty_CurrentPreset,
kAudioUnitScope_Global, 0,
&inData, sizeof (AUPreset));
}
return result;
}
static OSStatus notification(AudioDeviceID inDevice,
UInt32 inChannel,
Boolean isInput,
AudioDevicePropertyID inPropertyID,
void* inClientData)
{
coreaudio_driver_t* driver = (coreaudio_driver_t*)inClientData;
switch (inPropertyID) {
case kAudioDeviceProcessorOverload:
driver->xrun_detected = 1;
break;
case kAudioDevicePropertyNominalSampleRate: {
UInt32 outSize = sizeof(Float64);
Float64 sampleRate;
AudioStreamBasicDescription srcFormat, dstFormat;
OSStatus err = AudioDeviceGetProperty(driver->device_id, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &sampleRate);
if (err != noErr) {
jack_error("Cannot get current sample rate");
return kAudioHardwareUnsupportedOperationError;
}
JCALog("JackCoreAudioDriver::NotificationCallback kAudioDevicePropertyNominalSampleRate %ld\n", (long)sampleRate);
outSize = sizeof(AudioStreamBasicDescription);
// Update SR for input
err = AudioUnitGetProperty(driver->au_hal, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &srcFormat, &outSize);
if (err != noErr) {
jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Input");
}
srcFormat.mSampleRate = sampleRate;
err = AudioUnitSetProperty(driver->au_hal, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &srcFormat, outSize);
if (err != noErr) {
jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Input");
}
// Update SR for output
err = AudioUnitGetProperty(driver->au_hal, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &dstFormat, &outSize);
if (err != noErr) {
jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Output");
}
dstFormat.mSampleRate = sampleRate;
err = AudioUnitSetProperty(driver->au_hal, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &dstFormat, outSize);
if (err != noErr) {
jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Output");
}
break;
}
}
return noErr;
}
// ----------------------------------------------------------
ofxAudioUnit& ofxAudioUnitInput::connectTo(ofxAudioUnit &otherUnit, int destinationBus, int sourceBus)
// ----------------------------------------------------------
{
AudioStreamBasicDescription ASBD;
UInt32 ASBDSize = sizeof(ASBD);
OFXAU_PRINT(AudioUnitGetProperty(otherUnit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Input,
destinationBus,
&ASBD,
&ASBDSize),
"getting hardware input destination's format");
OFXAU_PRINT(AudioUnitSetProperty(*_unit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Output,
1,
&ASBD,
sizeof(ASBD)),
"setting hardware input's output format");
AURenderCallbackStruct callback = {PullCallback, &_impl->ctx};
otherUnit.setRenderCallback(callback, destinationBus);
return otherUnit;
}
OSStatus CAAudioUnit::ClearChannelLayout (AudioUnitScope inScope,
AudioUnitElement inEl)
{
return AudioUnitSetProperty (AU(),
kAudioUnitProperty_AudioChannelLayout,
inScope, inEl, NULL, 0);
}
OSStatus CAPlayThrough::SetInputDeviceAsCurrent(AudioDeviceID in)
{
UInt32 size = sizeof(AudioDeviceID);
OSStatus err = noErr;
if(in == kAudioDeviceUnknown) //get the default input device if device is unknown
{
err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice,
&size,
&in);
checkErr(err);
}
mInputDevice.Init(in, true);
//Set the Current Device to the AUHAL.
//this should be done only after IO has been enabled on the AUHAL.
err = AudioUnitSetProperty(mInputUnit,
kAudioOutputUnitProperty_CurrentDevice,
kAudioUnitScope_Global,
0,
&mInputDevice.mID,
sizeof(mInputDevice.mID));
checkErr(err);
return err;
}
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);
}
void AUVPresets::HandleControlChange ()
{
#if !__LP64__
SInt32 i = GetControl32BitValue(mControl);
if (i > 0)
{
AUPreset* preset = (AUPreset*) CFArrayGetValueAtIndex (mPresets, i-1);
verify_noerr(AudioUnitSetProperty (mView->GetEditAudioUnit(),
mPropertyID, // either currentPreset or PresentPreset depending on which is supported
kAudioUnitScope_Global,
0,
preset,
sizeof(AUPreset)));
// when we change a preset we can't expect the AU to update its state
// as it isn't meant to know that its being viewed!
// so we broadcast a notification to all listeners that all parameters on this AU have changed
AudioUnitParameter changedUnit;
changedUnit.mAudioUnit = mView->GetEditAudioUnit();
changedUnit.mParameterID = kAUParameterListener_AnyParameter;
verify_noerr (AUParameterListenerNotify (NULL, NULL, &changedUnit) );
}
#endif
}
gboolean
gst_core_audio_bind_device (GstCoreAudio * core_audio)
{
OSStatus status;
/* Specify which device we're using. */
GST_DEBUG_OBJECT (core_audio->osxbuf, "Bind AudioUnit to device %d",
(int) core_audio->device_id);
status = AudioUnitSetProperty (core_audio->audiounit,
kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0,
&core_audio->device_id, sizeof (AudioDeviceID));
if (status) {
GST_ERROR_OBJECT (core_audio->osxbuf, "Failed binding to device: %"
GST_FOURCC_FORMAT, GST_FOURCC_ARGS (status));
goto audiounit_error;
}
return TRUE;
audiounit_error:
if (core_audio->recBufferList) {
buffer_list_free (core_audio->recBufferList);
core_audio->recBufferList = NULL;
}
return FALSE;
}
bool ofxAudioUnitFilePlayer::setFile(const std::string &filePath) {
CFURLRef fileURL;
fileURL = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault,
(const UInt8 *)filePath.c_str(),
filePath.length(),
NULL);
if(_fileID[0]) {
AudioFileClose(_fileID[0]);
_fileID[0] = NULL;
}
OSStatus s = AudioFileOpenURL(fileURL, kAudioFileReadPermission, 0, _fileID);
CFRelease(fileURL);
_primed = false;
if(s != noErr) {
cout << "Error " << s << " while opening file at " << filePath << endl;
return false;
} else {
// setting the file ID now since it seems to have some overhead.
// Doing it now ensures you'll get sound pretty much instantly after
// calling play() (subsequent calls don't have the overhead)
OFXAU_RET_BOOL(AudioUnitSetProperty(*_unit,
kAudioUnitProperty_ScheduledFileIDs,
kAudioUnitScope_Global,
0,
_fileID,
sizeof(_fileID)),
"setting file player's file ID");
}
}
static int AudioFilePlayer_Connect(AudioFilePlayer *afp)
{
#if DEBUG
printf ("Connect:%x, engaged=%d\n", (int)afp->mPlayUnit, (afp->mConnected ? 1 : 0));
#endif
if (!afp->mConnected)
{
if (!afp->mAudioFileManager->DoConnect(afp->mAudioFileManager))
return 0;
/* set the render callback for the file data to be supplied to the sound converter AU */
afp->mInputCallback.inputProc = afp->mAudioFileManager->FileInputProc;
afp->mInputCallback.inputProcRefCon = afp->mAudioFileManager;
OSStatus result = AudioUnitSetProperty (afp->mPlayUnit,
kAudioUnitProperty_SetRenderCallback,
kAudioUnitScope_Input,
0,
&afp->mInputCallback,
sizeof(afp->mInputCallback));
if (result) return 0; /*THROW_RESULT("AudioUnitSetProperty")*/
afp->mConnected = 1;
}
return 1;
}
// ----------------------------------------------------------
bool ofxAudioUnitSampler::setSamples(const std::vector<std::string> &samplePaths)
// ----------------------------------------------------------
{
CFURLRef sampleURLs[samplePaths.size()];
for(int i = 0; i < samplePaths.size(); i++)
{
sampleURLs[i] = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault,
(const UInt8 *)samplePaths[i].c_str(),
samplePaths[i].length(),
NULL);
}
CFArrayRef samples = CFArrayCreate(NULL, (const void **)&sampleURLs, samplePaths.size(), &kCFTypeArrayCallBacks);
OSStatus s = AudioUnitSetProperty(*_unit,
kAUSamplerProperty_LoadAudioFiles,
kAudioUnitScope_Global,
0,
&samples,
sizeof(samples));
OFXAU_PRINT(s, "setting ofxAudioUnitSampler's source samples");
for(int i = 0; i < samplePaths.size(); i++) CFRelease(sampleURLs[i]);
CFRelease(samples);
return s == noErr;
}
OSStatus CAAudioUnit::SetBypass (bool inBypass) const
{
UInt32 bypass = inBypass ? 1 : 0;
return AudioUnitSetProperty (AU(), kAudioUnitProperty_BypassEffect,
kAudioUnitScope_Global, 0,
&bypass, sizeof (UInt32));
}
void CoreAudioDrv_PCM_Shutdown(void)
{
OSStatus result;
struct AURenderCallbackStruct callback;
if (!Initialised) {
return;
}
// stop processing the audio unit
CoreAudioDrv_PCM_StopPlayback();
// Remove the input callback
callback.inputProc = 0;
callback.inputProcRefCon = 0;
result = AudioUnitSetProperty(output_audio_unit,
kAudioUnitProperty_SetRenderCallback,
kAudioUnitScope_Input,
0,
&callback,
sizeof(callback));
//result = CloseComponent(output_audio_unit);
pthread_mutex_destroy(&mutex);
Initialised = 0;
}
gboolean
gst_core_audio_set_format (GstCoreAudio * core_audio,
AudioStreamBasicDescription format)
{
/* Configure the output stream and allocate ringbuffer memory */
OSStatus status;
UInt32 propertySize;
int element;
AudioUnitScope scope;
GST_DEBUG_OBJECT (core_audio->osxbuf, "Setting format for AudioUnit");
scope = core_audio->is_src ? kAudioUnitScope_Output : kAudioUnitScope_Input;
element = core_audio->is_src ? 1 : 0;
propertySize = sizeof (AudioStreamBasicDescription);
status = AudioUnitSetProperty (core_audio->audiounit,
kAudioUnitProperty_StreamFormat, scope, element, &format, propertySize);
if (status) {
GST_WARNING_OBJECT (core_audio->osxbuf,
"Failed to set audio description: %" GST_FOURCC_FORMAT,
GST_FOURCC_ARGS (status));
return FALSE;;
}
return TRUE;
}
void
gst_core_audio_remove_render_callback (GstCoreAudio * core_audio)
{
AURenderCallbackStruct input;
OSStatus status;
/* Deactivate the render callback by calling SetRenderCallback
* with a NULL inputProc.
*/
input.inputProc = NULL;
input.inputProcRefCon = NULL;
status = AudioUnitSetProperty (core_audio->audiounit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Global, 0, /* N/A for global */
&input, sizeof (input));
if (status) {
GST_WARNING_OBJECT (core_audio->osxbuf, "Failed to remove render callback %"
GST_FOURCC_FORMAT, GST_FOURCC_ARGS (status));
}
/* Remove the RenderNotify too */
status = AudioUnitRemoveRenderNotify (core_audio->audiounit,
(AURenderCallback) gst_core_audio_render_notify, core_audio);
if (status) {
GST_WARNING_OBJECT (core_audio->osxbuf,
"Failed to remove render notify callback %" GST_FOURCC_FORMAT,
GST_FOURCC_ARGS (status));
}
/* We're deactivated.. */
core_audio->io_proc_needs_deactivation = FALSE;
core_audio->io_proc_active = FALSE;
}
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;
}
}
bool CCoreAudioUnit::RemoveRenderProc()
{
if (!m_audioUnit || !m_renderProc)
return false;
AURenderCallbackStruct callbackInfo;
callbackInfo.inputProc = nil;
callbackInfo.inputProcRefCon = nil;
OSStatus ret = AudioUnitSetProperty(m_audioUnit, kAudioUnitProperty_SetRenderCallback,
kAudioUnitScope_Input, 0, &callbackInfo, sizeof(AURenderCallbackStruct));
if (ret)
{
CLog::Log(LOGERROR, "CCoreAudioUnit::RemoveRenderProc: Unable to remove AudioUnit render callback. Error = %s", GetError(ret).c_str());
return false;
}
CLog::Log(LOGDEBUG, "CCoreAudioUnit::RemoveRenderProc: Remove RenderProc 0x%08x for unit 0x%08x.", (unsigned int)m_renderProc, (unsigned int)m_audioUnit);
m_renderProc = NULL;
Sleep(100);
return true;
}
// ----------------------------------------------------------
void ofxAudioUnitInput::connectTo(ofxAudioUnit &otherUnit, int destinationBus, int sourceBus)
// ----------------------------------------------------------
{
AURenderCallbackStruct callback;
callback.inputProc = pullCallback;
callback.inputProcRefCon = &_renderContext;
AudioStreamBasicDescription ASBD;
UInt32 ASBDSize = sizeof(ASBD);
OFXAU_RETURN(AudioUnitGetProperty(*otherUnit.getUnit(),
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Input,
destinationBus,
&ASBD,
&ASBDSize),
"getting hardware input destination's format");
OFXAU_RETURN(AudioUnitSetProperty(*_unit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Output,
1,
&ASBD,
sizeof(ASBD)),
"setting hardware input's output format");
otherUnit.setRenderCallback(callback, destinationBus);
}
OSStatus OutputImplAudioUnit::Track::renderNotifyCallback( void * audioTrack, AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber, UInt32 inNumberFrames, AudioBufferList *ioData )
{
OSStatus err = noErr;
if( *ioActionFlags &= kAudioUnitRenderAction_PostRender ) {
OutputImplAudioUnit::Track * theTrack = reinterpret_cast<OutputImplAudioUnit::Track *>( audioTrack );
if( ! theTrack->isPlaying() ) {
//disable render callback
AURenderCallbackStruct rcbs;
rcbs.inputProc = NULL;
rcbs.inputProcRefCon = NULL;
err = AudioUnitSetProperty( theTrack->mOutput->mMixerUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, theTrack->mInputBus, &rcbs, sizeof(rcbs) );
if( err ) {
}
err = AudioUnitRemoveRenderNotify( theTrack->mOutput->mMixerUnit, OutputImplAudioUnit::Track::renderNotifyCallback, audioTrack );
if( err ) {
}
theTrack->mOutput->removeTrack( theTrack->getTrackId() );
//now the track should be dead
}
}
return err;
}
OSStatus CAPlayThrough::SetOutputDeviceAsCurrent(AudioDeviceID out)
{
UInt32 size = sizeof(AudioDeviceID);;
OSStatus err = noErr;
// UInt32 propsize = sizeof(Float32);
//AudioObjectPropertyScope theScope = mIsInput ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput;
AudioObjectPropertyAddress theAddress = { kAudioHardwarePropertyDefaultOutputDevice,
kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMaster };
if(out == kAudioDeviceUnknown) //Retrieve the default output device
{
err = AudioObjectGetPropertyData(kAudioObjectSystemObject, &theAddress, 0, NULL, &size, &out);
checkErr(err);
}
mOutputDevice.Init(out, false);
//Set the Current Device to the Default Output Unit.
err = AudioUnitSetProperty(mOutputUnit,
kAudioOutputUnitProperty_CurrentDevice,
kAudioUnitScope_Global,
0,
&mOutputDevice.mID,
sizeof(mOutputDevice.mID));
return err;
}
