static OSStatus get_default_device(AudioDeviceID * id)
{
OSStatus res;
UInt32 theSize = sizeof(UInt32);
AudioDeviceID inDefault;
AudioDeviceID outDefault;
if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice,
&theSize, &inDefault)) != noErr)
return res;
if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice,
&theSize, &outDefault)) != noErr)
return res;
JCALog("get_default_device: input %ld output %ld\n", inDefault, outDefault);
// Get the device only if default input and ouput are the same
if (inDefault == outDefault) {
*id = inDefault;
return noErr;
} else {
jack_error("Default input and output devices are not the same !!");
return kAudioHardwareBadDeviceError;
}
}
OSStatus get_total_channels(AudioDeviceID device, int* channelCount, bool isInput)
{
OSStatus err = noErr;
UInt32 outSize;
Boolean outWritable;
AudioBufferList* bufferList = 0;
AudioStreamID* streamList = 0;
int i, numStream;
err = AudioDeviceGetPropertyInfo(device, 0, isInput, kAudioDevicePropertyStreams, &outSize, &outWritable);
if (err == noErr) {
streamList = (AudioStreamID*)malloc(outSize);
numStream = outSize/sizeof(AudioStreamID);
JCALog("get_total_channels device stream number = %ld numStream = %ld\n", device, numStream);
err = AudioDeviceGetProperty(device, 0, isInput, kAudioDevicePropertyStreams, &outSize, streamList);
if (err == noErr) {
AudioStreamBasicDescription streamDesc;
outSize = sizeof(AudioStreamBasicDescription);
for (i = 0; i < numStream; i++) {
err = AudioStreamGetProperty(streamList[i], 0, kAudioDevicePropertyStreamFormat, &outSize, &streamDesc);
JCALog("get_total_channels streamDesc mFormatFlags = %ld mChannelsPerFrame = %ld\n", streamDesc.mFormatFlags, streamDesc.mChannelsPerFrame);
}
}
}
*channelCount = 0;
err = AudioDeviceGetPropertyInfo(device, 0, isInput, kAudioDevicePropertyStreamConfiguration, &outSize, &outWritable);
if (err == noErr) {
bufferList = (AudioBufferList*)malloc(outSize);
err = AudioDeviceGetProperty(device, 0, isInput, kAudioDevicePropertyStreamConfiguration, &outSize, bufferList);
if (err == noErr) {
for (i = 0; i < bufferList->mNumberBuffers; i++)
*channelCount += bufferList->mBuffers[i].mNumberChannels;
}
}
if (streamList)
free(streamList);
if (bufferList)
free(bufferList);
return err;
}
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;
}
static OSStatus get_default_output_device(AudioDeviceID* id)
{
OSStatus res;
UInt32 theSize = sizeof(UInt32);
AudioDeviceID outDefault;
if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice,
&theSize, &outDefault)) != noErr)
return res;
JCALog("get_default_output_device: output = %ld\n", outDefault);
*id = outDefault;
return noErr;
}
static OSStatus get_device_id_from_uid(char* UID, AudioDeviceID* id)
{
UInt32 size = sizeof(AudioValueTranslation);
CFStringRef inIUD = CFStringCreateWithCString(NULL, UID, CFStringGetSystemEncoding());
AudioValueTranslation value = { &inIUD, sizeof(CFStringRef), id, sizeof(AudioDeviceID) };
if (inIUD == NULL) {
return kAudioHardwareUnspecifiedError;
} else {
OSStatus res = AudioHardwareGetProperty(kAudioHardwarePropertyDeviceForUID, &size, &value);
CFRelease(inIUD);
JCALog("get_device_id_from_uid %s %ld \n", UID, *id);
return (*id == kAudioDeviceUnknown) ? kAudioHardwareBadDeviceError : res;
}
}
static OSStatus sr_notification(AudioDeviceID inDevice,
UInt32 inChannel,
Boolean isInput,
AudioDevicePropertyID inPropertyID,
void* inClientData)
{
coreaudio_driver_t* driver = (coreaudio_driver_t*)inClientData;
switch (inPropertyID) {
case kAudioDevicePropertyNominalSampleRate: {
JCALog("JackCoreAudioDriver::SRNotificationCallback kAudioDevicePropertyNominalSampleRate \n");
driver->state = 1;
break;
}
}
return noErr;
}
/** create a new driver instance
*/
static jack_driver_t *
coreaudio_driver_new (char *name,
jack_client_t* client,
jack_nframes_t frames_per_cycle,
jack_nframes_t rate,
int capturing,
int playing,
int chan_in,
int chan_out,
DitherAlgorithm dither,
char* driver_name,AudioDeviceID deviceID)
{
coreaudio_driver_t *driver;
JCALog ("coreaudio beta %d driver\n",CAVersion);
driver = (coreaudio_driver_t *) calloc (1, sizeof (coreaudio_driver_t));
jack_driver_init ((jack_driver_t *) driver);
if (!jack_power_of_two(frames_per_cycle)) {
JCALog (" -p must be a power of two.\n");
goto error;
}
driver->frames_per_cycle = frames_per_cycle;
driver->device_frame_rate = rate;
driver->capturing = capturing;
driver->playing = playing;
driver->needsChangeBufferSize = FALSE;
driver->new_bsize = frames_per_cycle;
driver->attach = (JackDriverAttachFunction) coreaudio_driver_attach;
driver->detach = (JackDriverDetachFunction) coreaudio_driver_detach;
driver->read = (JackDriverReadFunction) coreaudio_driver_read;
driver->write = (JackDriverReadFunction) coreaudio_driver_write;
driver->null_cycle = (JackDriverNullCycleFunction) coreaudio_driver_null_cycle;
//driver->bufsize = (JackDriverBufSizeFunction) coreaudio_driver_bufsize;
driver->start = (JackDriverStartFunction) coreaudio_driver_audio_start;
driver->stop = (JackDriverStopFunction) coreaudio_driver_audio_stop;
driver->stream = NULL;
char deviceName[60];
bzero(&deviceName[0],sizeof(char)*60);
if(!driver_name) {
if (GetDeviceNameFromID(deviceID,deviceName) != noErr) goto error;
} else {
strcpy(&deviceName[0],driver_name);
}
driver->stream = openAudioInstance((float)rate,frames_per_cycle,chan_in,chan_out,&deviceName[0]);
if(!driver->stream) goto error;
driver->client = client;
driver->period_usecs = (((float)driver->frames_per_cycle) / driver->device_frame_rate) * 1000000.0f;
setHostData(driver->stream,driver);
setCycleFun(driver->stream,coreaudio_runCycle);
driver->incoreaudio = NULL;
driver->outcoreaudio = NULL;
driver->playback_nchannels = chan_out;
driver->capture_nchannels = chan_in;
strcpy(&driver->driver_name[0],&deviceName[0]);
jack_init_time();
return((jack_driver_t *) driver);
error:
JCALog("Cannot open the coreaudio stream\n");
free(driver);
return NULL;
}
static void printError(OSStatus err)
{
#ifdef DEBUG
switch (err) {
case kAudioHardwareNoError:
JCALog("error code : kAudioHardwareNoError\n");
break;
case kAudioHardwareNotRunningError:
JCALog("error code : kAudioHardwareNotRunningError\n");
break;
case kAudioHardwareUnspecifiedError:
JCALog("error code : kAudioHardwareUnspecifiedError\n");
break;
case kAudioHardwareUnknownPropertyError:
JCALog("error code : kAudioHardwareUnknownPropertyError\n");
break;
case kAudioHardwareBadPropertySizeError:
JCALog("error code : kAudioHardwareBadPropertySizeError\n");
break;
case kAudioHardwareIllegalOperationError:
JCALog("error code : kAudioHardwareIllegalOperationError\n");
break;
case kAudioHardwareBadDeviceError:
JCALog("error code : kAudioHardwareBadDeviceError\n");
break;
case kAudioHardwareBadStreamError:
JCALog("error code : kAudioHardwareBadStreamError\n");
break;
case kAudioDeviceUnsupportedFormatError:
JCALog("error code : kAudioDeviceUnsupportedFormatError\n");
break;
case kAudioDevicePermissionsError:
JCALog("error code : kAudioDevicePermissionsError\n");
break;
default:
JCALog("error code : unknown %ld\n", err);
break;
}
#endif
}
/** create a new driver instance
*/
static jack_driver_t *coreaudio_driver_new(char* name,
jack_client_t* client,
jack_nframes_t nframes,
jack_nframes_t samplerate,
int capturing,
int playing,
int inchannels,
int outchannels,
char* capture_driver_uid,
char* playback_driver_uid,
jack_nframes_t capture_latency,
jack_nframes_t playback_latency)
{
coreaudio_driver_t *driver;
OSStatus err = noErr;
ComponentResult err1;
UInt32 outSize;
UInt32 enableIO;
AudioStreamBasicDescription srcFormat, dstFormat;
Float64 sampleRate;
int in_nChannels = 0;
int out_nChannels = 0;
int i;
driver = (coreaudio_driver_t *) calloc(1, sizeof(coreaudio_driver_t));
jack_driver_init((jack_driver_t *) driver);
if (!jack_power_of_two(nframes)) {
jack_error("CA: -p must be a power of two.");
goto error;
}
driver->state = 0;
driver->frames_per_cycle = nframes;
driver->frame_rate = samplerate;
driver->capturing = capturing;
driver->playing = playing;
driver->xrun_detected = 0;
driver->null_cycle = 0;
driver->attach = (JackDriverAttachFunction) coreaudio_driver_attach;
driver->detach = (JackDriverDetachFunction) coreaudio_driver_detach;
driver->read = (JackDriverReadFunction) coreaudio_driver_read;
driver->write = (JackDriverReadFunction) coreaudio_driver_write;
driver->null_cycle =
(JackDriverNullCycleFunction) coreaudio_driver_null_cycle;
driver->bufsize = (JackDriverBufSizeFunction) coreaudio_driver_bufsize;
driver->start = (JackDriverStartFunction) coreaudio_driver_audio_start;
driver->stop = (JackDriverStopFunction) coreaudio_driver_audio_stop;
driver->capture_frame_latency = capture_latency;
driver->playback_frame_latency = playback_latency;
// Duplex
if (strcmp(capture_driver_uid, "") != 0 && strcmp(playback_driver_uid, "") != 0) {
JCALog("Open duplex \n");
if (get_device_id_from_uid(playback_driver_uid, &driver->device_id) != noErr) {
if (get_default_device(&driver->device_id) != noErr) {
jack_error("Cannot open default device");
goto error;
}
}
if (get_device_name_from_id(driver->device_id, driver->capture_driver_name) != noErr || get_device_name_from_id(driver->device_id, driver->playback_driver_name) != noErr) {
jack_error("Cannot get device name from device ID");
goto error;
}
// Capture only
} else if (strcmp(capture_driver_uid, "") != 0) {
JCALog("Open capture only \n");
if (get_device_id_from_uid(capture_driver_uid, &driver->device_id) != noErr) {
if (get_default_input_device(&driver->device_id) != noErr) {
jack_error("Cannot open default device");
goto error;
}
}
if (get_device_name_from_id(driver->device_id, driver->capture_driver_name) != noErr) {
jack_error("Cannot get device name from device ID");
goto error;
}
// Playback only
} else if (playback_driver_uid != NULL) {
JCALog("Open playback only \n");
if (get_device_id_from_uid(playback_driver_uid, &driver->device_id) != noErr) {
if (get_default_output_device(&driver->device_id) != noErr) {
jack_error("Cannot open default device");
goto error;
}
}
if (get_device_name_from_id(driver->device_id, driver->playback_driver_name) != noErr) {
jack_error("Cannot get device name from device ID");
goto error;
}
// Use default driver in duplex mode
} else {
JCALog("Open default driver \n");
if (get_default_device(&driver->device_id) != noErr) {
jack_error("Cannot open default device");
goto error;
}
if (get_device_name_from_id(driver->device_id, driver->capture_driver_name) != noErr || get_device_name_from_id(driver->device_id, driver->playback_driver_name) != noErr) {
jack_error("Cannot get device name from device ID");
goto error;
}
}
driver->client = client;
driver->period_usecs =
(((float) driver->frames_per_cycle) / driver->frame_rate) *
1000000.0f;
if (capturing) {
err = get_total_channels(driver->device_id, &in_nChannels, true);
if (err != noErr) {
jack_error("Cannot get input channel number");
printError(err);
goto error;
}
}
if (playing) {
err = get_total_channels(driver->device_id, &out_nChannels, false);
if (err != noErr) {
jack_error("Cannot get output channel number");
printError(err);
goto error;
}
}
if (inchannels > in_nChannels) {
jack_error("This device hasn't required input channels inchannels = %ld in_nChannels = %ld", inchannels, in_nChannels);
goto error;
}
if (outchannels > out_nChannels) {
jack_error("This device hasn't required output channels outchannels = %ld out_nChannels = %ld", outchannels, out_nChannels);
goto error;
}
if (inchannels == 0) {
JCALog("Setup max in channels = %ld\n", in_nChannels);
inchannels = in_nChannels;
}
if (outchannels == 0) {
JCALog("Setup max out channels = %ld\n", out_nChannels);
outchannels = out_nChannels;
}
// Setting buffer size
outSize = sizeof(UInt32);
err = AudioDeviceSetProperty(driver->device_id, NULL, 0, false, kAudioDevicePropertyBufferFrameSize, outSize, &nframes);
if (err != noErr) {
jack_error("Cannot set buffer size %ld", nframes);
printError(err);
goto error;
}
// Set sample rate
outSize = sizeof(Float64);
err = AudioDeviceGetProperty(driver->device_id, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &sampleRate);
if (err != noErr) {
jack_error("Cannot get current sample rate");
printError(err);
goto error;
}
if (samplerate != (jack_nframes_t)sampleRate) {
sampleRate = (Float64)samplerate;
// To get SR change notification
err = AudioDeviceAddPropertyListener(driver->device_id, 0, true, kAudioDevicePropertyNominalSampleRate, sr_notification, driver);
if (err != noErr) {
jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyNominalSampleRate");
printError(err);
return -1;
}
err = AudioDeviceSetProperty(driver->device_id, NULL, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, outSize, &sampleRate);
if (err != noErr) {
jack_error("Cannot set sample rate = %ld", samplerate);
printError(err);
return -1;
}
// Waiting for SR change notification
int count = 0;
while (!driver->state && count++ < 100) {
usleep(100000);
JCALog("Wait count = %ld\n", count);
}
// Remove SR change notification
AudioDeviceRemovePropertyListener(driver->device_id, 0, true, kAudioDevicePropertyNominalSampleRate, sr_notification);
}
// AUHAL
ComponentDescription cd = {kAudioUnitType_Output, kAudioUnitSubType_HALOutput, kAudioUnitManufacturer_Apple, 0, 0};
Component HALOutput = FindNextComponent(NULL, &cd);
err1 = OpenAComponent(HALOutput, &driver->au_hal);
if (err1 != noErr) {
jack_error("Error calling OpenAComponent");
printError(err1);
goto error;
}
err1 = AudioUnitInitialize(driver->au_hal);
if (err1 != noErr) {
jack_error("Cannot initialize AUHAL unit");
printError(err1);
goto error;
}
// Start I/O
enableIO = 1;
if (capturing && inchannels > 0) {
JCALog("Setup AUHAL input\n");
err1 = AudioUnitSetProperty(driver->au_hal, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, &enableIO, sizeof(enableIO));
if (err1 != noErr) {
jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input");
printError(err1);
goto error;
}
}
if (playing && outchannels > 0) {
JCALog("Setup AUHAL output\n");
err1 = AudioUnitSetProperty(driver->au_hal, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, &enableIO, sizeof(enableIO));
if (err1 != noErr) {
jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_EnableIO,kAudioUnitScope_Output");
printError(err1);
goto error;
}
}
// Setup up choosen device, in both input and output cases
err1 = AudioUnitSetProperty(driver->au_hal, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &driver->device_id, sizeof(AudioDeviceID));
if (err1 != noErr) {
jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_CurrentDevice");
printError(err1);
goto error;
}
// Set buffer size
if (capturing && inchannels > 0) {
err1 = AudioUnitSetProperty(driver->au_hal, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 1, (UInt32*)&nframes, sizeof(UInt32));
if (err1 != noErr) {
jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_MaximumFramesPerSlice");
printError(err1);
goto error;
}
}
if (playing && outchannels > 0) {
err1 = AudioUnitSetProperty(driver->au_hal, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 0, (UInt32*)&nframes, sizeof(UInt32));
if (err1 != noErr) {
jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_MaximumFramesPerSlice");
printError(err1);
goto error;
}
}
// Setup channel map
if (capturing && inchannels > 0 && inchannels < in_nChannels) {
SInt32 chanArr[in_nChannels];
for (i = 0; i < in_nChannels; i++) {
chanArr[i] = -1;
}
for (i = 0; i < inchannels; i++) {
chanArr[i] = i;
}
AudioUnitSetProperty(driver->au_hal, kAudioOutputUnitProperty_ChannelMap , kAudioUnitScope_Input, 1, chanArr, sizeof(SInt32) * in_nChannels);
if (err1 != noErr) {
jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_ChannelMap 1");
printError(err1);
}
}
if (playing && outchannels > 0 && outchannels < out_nChannels) {
SInt32 chanArr[out_nChannels];
for (i = 0; i < out_nChannels; i++) {
chanArr[i] = -1;
}
for (i = 0; i < outchannels; i++) {
chanArr[i] = i;
}
err1 = AudioUnitSetProperty(driver->au_hal, kAudioOutputUnitProperty_ChannelMap, kAudioUnitScope_Output, 0, chanArr, sizeof(SInt32) * out_nChannels);
if (err1 != noErr) {
jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_ChannelMap 0");
printError(err1);
}
}
// Setup stream converters
srcFormat.mSampleRate = samplerate;
srcFormat.mFormatID = kAudioFormatLinearPCM;
srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;
srcFormat.mBytesPerPacket = sizeof(float);
srcFormat.mFramesPerPacket = 1;
srcFormat.mBytesPerFrame = sizeof(float);
srcFormat.mChannelsPerFrame = outchannels;
srcFormat.mBitsPerChannel = 32;
err1 = AudioUnitSetProperty(driver->au_hal, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &srcFormat, sizeof(AudioStreamBasicDescription));
if (err1 != noErr) {
jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Input");
printError(err1);
}
dstFormat.mSampleRate = samplerate;
dstFormat.mFormatID = kAudioFormatLinearPCM;
dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;
dstFormat.mBytesPerPacket = sizeof(float);
dstFormat.mFramesPerPacket = 1;
dstFormat.mBytesPerFrame = sizeof(float);
dstFormat.mChannelsPerFrame = inchannels;
dstFormat.mBitsPerChannel = 32;
err1 = AudioUnitSetProperty(driver->au_hal, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &dstFormat, sizeof(AudioStreamBasicDescription));
if (err1 != noErr) {
jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Output");
printError(err1);
}
// Setup callbacks
if (inchannels > 0 && outchannels == 0) {
AURenderCallbackStruct output;
output.inputProc = render_input;
output.inputProcRefCon = driver;
err1 = AudioUnitSetProperty(driver->au_hal, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &output, sizeof(output));
if (err1 != noErr) {
jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_SetRenderCallback 1");
printError(err1);
goto error;
}
} else {
AURenderCallbackStruct output;
output.inputProc = render;
output.inputProcRefCon = driver;
err1 = AudioUnitSetProperty(driver->au_hal, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &output, sizeof(output));
if (err1 != noErr) {
jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_SetRenderCallback 0");
printError(err1);
goto error;
}
}
if (capturing && inchannels > 0) {
driver->input_list = (AudioBufferList*)malloc(sizeof(UInt32) + inchannels * sizeof(AudioBuffer));
if (driver->input_list == 0)
goto error;
driver->input_list->mNumberBuffers = inchannels;
// Prepare buffers
for (i = 0; i < driver->capture_nchannels; i++) {
driver->input_list->mBuffers[i].mNumberChannels = 1;
driver->input_list->mBuffers[i].mDataByteSize = nframes * sizeof(float);
}
}
err = AudioDeviceAddPropertyListener(driver->device_id, 0, true, kAudioDeviceProcessorOverload, notification, driver);
if (err != noErr) {
jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDeviceProcessorOverload");
goto error;
}
err = AudioDeviceAddPropertyListener(driver->device_id, 0, true, kAudioDevicePropertyNominalSampleRate, notification, driver);
if (err != noErr) {
jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyNominalSampleRate");
goto error;
}
driver->playback_nchannels = outchannels;
driver->capture_nchannels = inchannels;
return ((jack_driver_t *) driver);
error:
AudioUnitUninitialize(driver->au_hal);
CloseComponent(driver->au_hal);
jack_error("Cannot open the coreaudio driver");
free(driver);
return NULL;
}
static int
coreaudio_driver_attach(coreaudio_driver_t * driver, jack_engine_t * engine)
{
jack_port_t *port;
JSList *node;
int port_flags;
channel_t chn;
char buf[JACK_PORT_NAME_SIZE];
char channel_name[64];
OSStatus err;
UInt32 size;
UInt32 value1,value2;
Boolean isWritable;
jack_latency_range_t range;
driver->engine = engine;
if (driver->engine->set_buffer_size(engine, driver->frames_per_cycle)) {
jack_error ("coreaudio: cannot set engine buffer size to %d (check MIDI)", driver->frames_per_cycle);
return -1;
}
driver->engine->set_sample_rate(engine, driver->frame_rate);
port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;
/*
if (driver->has_hw_monitoring) {
port_flags |= JackPortCanMonitor;
}
*/
for (chn = 0; chn < driver->capture_nchannels; chn++) {
err = AudioDeviceGetPropertyInfo(driver->device_id, chn + 1, true, kAudioDevicePropertyChannelName, &size, &isWritable);
if (err == noErr && size > 0) {
err = AudioDeviceGetProperty(driver->device_id, chn + 1, true, kAudioDevicePropertyChannelName, &size, channel_name);
if (err != noErr)
JCALog("AudioDeviceGetProperty kAudioDevicePropertyChannelName error \n");
snprintf(buf, sizeof(buf) - 1, "%s:out_%s%lu", driver->capture_driver_name, channel_name, chn + 1);
} else {
snprintf(buf, sizeof(buf) - 1, "%s:out%lu", driver->capture_driver_name, chn + 1);
}
if ((port = jack_port_register(driver->client, buf,
JACK_DEFAULT_AUDIO_TYPE, port_flags,
0)) == NULL) {
jack_error("coreaudio: cannot register port for %s", buf);
break;
}
size = sizeof(UInt32);
value1 = value2 = 0;
err = AudioDeviceGetProperty(driver->device_id, 0, true, kAudioDevicePropertyLatency, &size, &value1);
if (err != noErr)
JCALog("AudioDeviceGetProperty kAudioDevicePropertyLatency error \n");
err = AudioDeviceGetProperty(driver->device_id, 0, true, kAudioDevicePropertySafetyOffset, &size, &value2);
if (err != noErr)
JCALog("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error \n");
range.min = range.max = driver->frames_per_cycle + value1 + value2 + driver->capture_frame_latency;
jack_port_set_latency_range(port, JackCaptureLatency, &range);
driver->capture_ports =
jack_slist_append(driver->capture_ports, port);
}
port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;
for (chn = 0; chn < driver->playback_nchannels; chn++) {
err = AudioDeviceGetPropertyInfo(driver->device_id, chn + 1, false, kAudioDevicePropertyChannelName, &size, &isWritable);
if (err == noErr && size > 0) {
err = AudioDeviceGetProperty(driver->device_id, chn + 1, false, kAudioDevicePropertyChannelName, &size, channel_name);
if (err != noErr)
JCALog("AudioDeviceGetProperty kAudioDevicePropertyChannelName error \n");
snprintf(buf, sizeof(buf) - 1, "%s:in_%s%lu", driver->playback_driver_name, channel_name, chn + 1);
} else {
snprintf(buf, sizeof(buf) - 1, "%s:in%lu", driver->playback_driver_name, chn + 1);
}
if ((port = jack_port_register(driver->client, buf,
JACK_DEFAULT_AUDIO_TYPE, port_flags,
0)) == NULL) {
jack_error("coreaudio: cannot register port for %s", buf);
break;
}
size = sizeof(UInt32);
value1 = value2 = 0;
err = AudioDeviceGetProperty(driver->device_id, 0, false, kAudioDevicePropertyLatency, &size, &value1);
if (err != noErr)
JCALog("AudioDeviceGetProperty kAudioDevicePropertyLatency error \n");
err = AudioDeviceGetProperty(driver->device_id, 0, false, kAudioDevicePropertySafetyOffset, &size, &value2);
if (err != noErr)
JCALog("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error \n");
range.min = range.max = driver->frames_per_cycle + value1 + value2 + driver->playback_frame_latency;
jack_port_set_latency_range(port, JackCaptureLatency, &range);
driver->playback_ports =
jack_slist_append(driver->playback_ports, port);
}
// Input buffers do no change : prepare them only once
for (chn = 0, node = driver->capture_ports; chn < driver->capture_nchannels; chn++, node = jack_slist_next(node)) {
driver->input_list->mBuffers[chn].mData
= (jack_default_audio_sample_t*)jack_port_get_buffer(((jack_port_t *) node->data), driver->frames_per_cycle);
}
jack_activate(driver->client);
return 0;
}
