/** 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;
}
jack_driver_t * driver_initialize (jack_client_t *client,
JSList * params)
{
int bits = OSS_DRIVER_DEF_BITS;
jack_nframes_t sample_rate = OSS_DRIVER_DEF_FS;
jack_nframes_t period_size = OSS_DRIVER_DEF_BLKSIZE;
jack_nframes_t in_latency = 0;
jack_nframes_t out_latency = 0;
unsigned int nperiods = OSS_DRIVER_DEF_NPERIODS;
unsigned int capture_channels = OSS_DRIVER_DEF_INS;
unsigned int playback_channels = OSS_DRIVER_DEF_OUTS;
const JSList *pnode;
const jack_driver_param_t *param;
oss_driver_t *driver;
driver = (oss_driver_t *) malloc(sizeof(oss_driver_t));
if (driver == NULL)
{
jack_error("OSS: malloc() failed: %s@%i, errno=%d",
__FILE__, __LINE__, errno);
return NULL;
}
memset(driver, 0x00, sizeof(oss_driver_t));
jack_driver_init((jack_driver_t *) driver);
driver->attach = (JackDriverAttachFunction) oss_driver_attach;
driver->detach = (JackDriverDetachFunction) oss_driver_detach;
driver->start = (JackDriverStartFunction) oss_driver_start;
driver->stop = (JackDriverStopFunction) oss_driver_stop;
driver->read = (JackDriverReadFunction) oss_driver_read;
driver->write = (JackDriverWriteFunction) oss_driver_write;
driver->null_cycle = (JackDriverNullCycleFunction)
oss_driver_null_cycle;
driver->bufsize = (JackDriverBufSizeFunction) oss_driver_bufsize;
driver->indev = NULL;
driver->outdev = NULL;
driver->ignorehwbuf = 0;
driver->trigger = 0;
pnode = params;
while (pnode != NULL)
{
param = (const jack_driver_param_t *) pnode->data;
switch (param->character)
{
case 'r':
sample_rate = param->value.ui;
break;
case 'p':
period_size = param->value.ui;
break;
case 'n':
nperiods = param->value.ui;
break;
case 'w':
bits = param->value.i;
break;
case 'i':
capture_channels = param->value.ui;
break;
case 'o':
playback_channels = param->value.ui;
break;
case 'C':
driver->indev = strdup(param->value.str);
break;
case 'P':
driver->outdev = strdup(param->value.str);
break;
case 'b':
driver->ignorehwbuf = 1;
break;
case 'I':
in_latency = param->value.ui;
break;
case 'O':
out_latency = param->value.ui;
break;
}
pnode = jack_slist_next(pnode);
}
driver->sample_rate = sample_rate;
driver->period_size = period_size;
driver->nperiods = nperiods;
driver->bits = bits;
driver->capture_channels = capture_channels;
driver->playback_channels = playback_channels;
driver->sys_in_latency = in_latency;
driver->sys_out_latency = out_latency;
/* setting driver->period_usecs & co is delayed until attach */
driver->finish = driver_finish;
if (driver->indev == NULL)
driver->indev = strdup(OSS_DRIVER_DEF_DEV);
if (driver->outdev == NULL)
driver->outdev = strdup(OSS_DRIVER_DEF_DEV);
driver->infd = -1;
driver->outfd = -1;
switch (driver->bits)
{
# ifndef OSS_ENDIAN
# ifdef __GNUC__
# if (defined(__i386__) || defined(__alpha__) || defined(__arm__) || defined(__x86_64__) || (defined(__sh__) && !defined(__LITTLE_ENDIAN__)))
# define OSS_LITTLE_ENDIAN 1234
# define OSS_ENDIAN OSS_LITTLE_ENDIAN
# else
# define OSS_BIG_ENDIAN 4321
# define OSS_ENDIAN OSS_BIG_ENDIAN
# endif
# else /* __GNUC__ */
# if (defined(_AIX) || defined(AIX) || defined(sparc) || defined(__hppa) || defined(PPC) || defined(__powerpc__) && !defined(i386) && !defined(__i386) && !defined(__i386__))
# define OSS_BIG_ENDIAN 4321
# define OSS_ENDIAN OSS_BIG_ENDIAN
# else
# define OSS_LITTLE_ENDIAN 1234
# define OSS_ENDIAN OSS_LITTLE_ENDIAN
# endif
# endif /* __GNUC__ */
# endif /* OSS_ENDIAN */
# if (OSS_ENDIAN == 1234)
/* little-endian architectures */
case 24: /* little-endian LSB aligned 24-bits in 32-bits integer */
driver->format = 0x00008000;
break;
case 32: /* little-endian 32-bit integer */
driver->format = 0x00001000;
break;
case 64: /* native-endian 64-bit float */
driver->format = 0x00004000;
break;
case 16: /* little-endian 16-bit integer */
default:
driver->format = 0x00000010;
break;
/* big-endian architectures */
# else
case 24: /* big-endian LSB aligned 24-bits in 32-bits integer */
break;
driver->format = 0x00010000;
case 32: /* big-endian 32-bit integer */
driver->format = 0x00002000;
break;
case 64: /* native-endian 64-bit float */
driver->format = 0x00004000;
break;
case 16: /* big-endian 16-bit integer */
default:
driver->format = 0x00000020;
# endif
}
driver->indevbuf = driver->outdevbuf = NULL;
driver->capture_ports = NULL;
driver->playback_ports = NULL;
driver->engine = NULL;
driver->client = client;
return ((jack_driver_t *) driver);
}
/** create a new driver instance
*/
static jack_driver_t *
portaudio_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)
{
portaudio_driver_t *driver;
PaError err = paNoError;
int numDevices;
int inputDeviceID,outputDeviceID;
int found;
PALog("portaudio driver version : %d\n", kVersion);
PALog("creating portaudio driver ... %" PRIu32 "|%" PRIu32 "\n",
frames_per_cycle, rate);
driver = (portaudio_driver_t *) calloc (1, sizeof (portaudio_driver_t));
jack_driver_init ((jack_driver_t *) driver);
if (!jack_power_of_two(frames_per_cycle)) {
jack_error ("PA: -p must be a power of two.");
goto error;
}
driver->frames_per_cycle = frames_per_cycle;
driver->frame_rate = rate;
driver->capturing = capturing;
driver->playing = playing;
driver->attach = (JackDriverAttachFunction) portaudio_driver_attach;
driver->detach = (JackDriverDetachFunction) portaudio_driver_detach;
driver->read = (JackDriverReadFunction) portaudio_driver_read;
driver->write = (JackDriverReadFunction) portaudio_driver_write;
driver->null_cycle = (JackDriverNullCycleFunction) portaudio_driver_null_cycle;
driver->bufsize = (JackDriverBufSizeFunction) portaudio_driver_bufsize;
driver->start = (JackDriverStartFunction) portaudio_driver_audio_start;
driver->stop = (JackDriverStopFunction) portaudio_driver_audio_stop;
driver->stream = NULL;
#ifdef JACK_USE_MACH_THREADS
AudioDeviceID device_id;
if (driver_name) {
if (get_device_id_from_uid(driver_name, &device_id) != noErr)
goto error;
if (get_device_name_from_id(device_id, driver->driver_name) != noErr)
goto error;
} else {
if (get_device_id_from_num(0, &device_id) != noErr)
goto error;
if (get_device_name_from_id(device_id, driver->driver_name) != noErr)
goto error;
}
#endif
err = Pa_Initialize();
PALog("Pa_Initialize OK \n");
PALog("Driver name required %s\n",driver->driver_name);
numDevices = Pa_CountDevices();
if( numDevices < 0 ){
PALog("ERROR: Pa_CountDevices returned 0x%x\n", numDevices);
err = numDevices;
goto error;
}
PALog("Number of devices = %d\n", numDevices);
if (strcmp(driver->driver_name,"") == 0) {
found = portaudio_load_default(driver,numDevices,capturing,playing,&inputDeviceID,&outputDeviceID);
if (!found) {
PALog("ERROR : default driver has not been found\n");
err = paHostError;
goto error;
}
}else{
found = portaudio_load_driver(driver,numDevices,capturing,playing,&inputDeviceID,&outputDeviceID,driver->driver_name);
if (!found) {
PALog("ERROR : driver %s has not been found \n",driver->driver_name);
err = paHostError;
goto error;
}
}
if (err != paNoError) goto error;
PALog("Pa_GetDefaultOutputDeviceID() %ld\n", (long)Pa_GetDefaultOutputDeviceID());
PALog("Pa_GetDefaultInputDeviceID() %ld\n", (long)Pa_GetDefaultInputDeviceID());
PALog("--------------------------------------------------\n");
PALog("CoreAudio driver %s will be loaded\n", driver->driver_name);
PALog("inputDeviceID %ld\n", (long)inputDeviceID);
PALog("outputDeviceID %ld\n", (long)outputDeviceID);
PALog("driver->capture_nchannels %ld\n", driver->capture_nchannels);
PALog("driver->playback_nchannels %ld\n", driver->playback_nchannels);
PALog("chan_in, chan_out %ld %ld\n", (long)chan_in, (long)chan_out);
if (chan_in > 0)
driver->capture_nchannels = (driver->capture_nchannels < chan_in) ? driver->capture_nchannels : chan_in;
if (chan_out > 0)
driver->playback_nchannels = (driver->playback_nchannels < chan_out) ? driver->playback_nchannels : chan_out;
PALog("driver->capture_nchannels %ld\n", driver->capture_nchannels);
PALog("driver->playback_nchannels %ld\n", driver->playback_nchannels);
err = Pa_OpenStream(&driver->stream,
((capturing && (driver->capture_nchannels > 0)) ? inputDeviceID : paNoDevice),
((capturing) ? driver->capture_nchannels : 0),
paFloat32, // 32 bit floating point input
NULL,
((playing && (driver->playback_nchannels > 0)) ? outputDeviceID : paNoDevice),
((playing) ? driver->playback_nchannels : 0),
paFloat32, // 32 bit floating point output
NULL,
rate,
frames_per_cycle, // frames per buffer
0, // number of buffers, if zero then use default minimum
paClipOff, // we won't output out of range samples so don't bother clipping them
paCallback,
driver);
if (err != paNoError) goto error;
driver->client = client;
driver->period_usecs = (((float) driver->frames_per_cycle) / driver->frame_rate) * 1000000.0f;
return((jack_driver_t *) driver);
error:
Pa_Terminate();
jack_error("An error occured while using the portaudio stream");
jack_error("Error number: %d", err);
jack_error("Error message: %s", Pa_GetErrorText(err));
free(driver);
return NULL;
}
/** 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;
}
