jackaudio
/
jack1
mirror of https://github.com/jackaudio/jack1
1
0
Fork 0
Code Releases 19 Activity
jack1 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
818 Commits
4 Branches
8.0MB
Tree: f0bfb84688
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f0bfb84688'
${ noResults }
jack1/drivers/coreaudio/coreaudio_driver.c

1208 lines
42KB
Raw Blame History 

  1. /*

  2.  Copyright � Grame, 2003.

  3.  Copyright � Johnny Petrantoni, 2003.

  4.  

  5.  This program is free software; you can redistribute it and/or modify

  6.  it under the terms of the GNU General Public License as published by

  7.  the Free Software Foundation; either version 2 of the License, or

  8.  (at your option) any later version.

  9.  

  10.  This program is distributed in the hope that it will be useful,

  11.  but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13.  GNU General Public License for more details.

  14.  

  15.  You should have received a copy of the GNU General Public License

  16.  along with this program; if not, write to the Free Software

  17.  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  18.  

  19.  Grame Research Laboratory, 9, rue du Garet 69001 Lyon - France

  20.  grame@rd.grame.fr

  21. 	

  22.  Johnny Petrantoni, johnny@lato-b.com - Italy, Rome.

  23.  

  24.  Jan 30, 2004: Johnny Petrantoni: first code of the coreaudio driver, based on portaudio driver by Stephane Letz.

  25.  Feb 02, 2004: Johnny Petrantoni: fixed null cycle, removed double copy of buffers in AudioRender, the driver works fine (tested with Built-in Audio and Hammerfall RME), but no cpu load is displayed.

  26.  Feb 03, 2004: Johnny Petrantoni: some little fix.

  27.  Feb 03, 2004: Stephane Letz: some fix in AudioRender.cpp code.

  28.  Feb 03, 2004: Johnny Petrantoni: removed the default device stuff (useless, in jackosx, because JackPilot manages this behavior), the device must be specified. and all parameter must be correct.

  29.  Feb 04, 2004: Johnny Petrantoni: now the driver supports interfaces with multiple interleaved streams (such as the MOTU 828).

  30.  Nov 05, 2004: S.Letz: correct management of -I option for use with JackPilot.

  31.  Nov 15, 2004: S.Letz: Set a default value for deviceID.

  32.  Nov 30, 2004: S.Letz: In coreaudio_driver_write : clear to avoid playing dirty buffers when the client does not produce output anymore.

  33.  Dec 05, 2004: S.Letz: XRun detection 

  34.  Dec 09, 2004: S.Letz: Dynamic buffer size change

  35.  Dec 23, 2004: S.Letz: Correct bug in dynamic buffer size change : update period_usecs

  36.  Jan 20, 2005: S.Letz: Almost complete rewrite using AUHAL.

  37.  May 20, 2005: S.Letz: Add "systemic" latencies management.

  38.  Jun 06, 2005: S.Letz: Remove the "-I" parameter, change the semantic of "-n" parameter : -n (driver name) now correctly uses the PropertyDeviceUID

  39. 					   (persistent accross reboot...) as the identifier for the used coreaudio driver.

  40.  Jun 14, 2005: S.Letz: Since the "-I" parameter is not used anymore, rename the "systemic" latencies management parametes "-I" and "-O" like for the ALSA driver.

  41.  Aug 16, 2005: S.Letz: Remove get_device_id_from_num, use get_default_device instead. If the -n option is not used or the device name cannot

  42. 					   be found, the default device is used. Note: the default device can be used only if both default input and default output are the same.

  43.  Dec 19, 2005: S.Letz: Add -d option (display_device_names).

  44.  Apri 7, 2006: S.Letz: Synchronization with the jackdmp coreaudio driver version: improve half-duplex management.

  45.  May 17, 2006: S.Letz: Minor fix in driver_initialize.

  46.  May 18, 2006: S.Letz: Document sample rate default value.

  47.  May 31, 2006: S.Letz: Apply Rui patch for more consistent driver parameter naming.

  48.  Dec 04, 2007: S.Letz: Fix a bug in sample rate management (occuring in particular with "aggregate" devices).

  49.  Dec 05, 2007: S.Letz: Correct sample_rate management in Open. Better handling in sample_rate change listener.

  50.  */

  51. 

  52. #include <stdio.h>

  53. #include <string.h>

  54. #include <jack/engine.h>

  55. #include "coreaudio_driver.h"

  56. 

  57. const int CAVersion = 3;

  58. 

  59. //#define PRINTDEBUG 1

  60. 

  61. static void JCALog(char *fmt, ...)

  62. {

  63. #ifdef PRINTDEBUG

  64.     va_list ap;

  65.     va_start(ap, fmt);

  66.     fprintf(stderr, "JCA: ");

  67.     vfprintf(stderr, fmt, ap);

  68.     va_end(ap);

  69. #endif

  70. }

  71. 

  72. static void printError(OSStatus err)

  73. {

  74. #ifdef DEBUG

  75.     switch (err) {

  76.         case kAudioHardwareNoError:

  77.             JCALog("error code : kAudioHardwareNoError\n");

  78.             break;

  79.         case kAudioHardwareNotRunningError:

  80.             JCALog("error code : kAudioHardwareNotRunningError\n");

  81.             break;

  82.         case kAudioHardwareUnspecifiedError:

  83.             JCALog("error code : kAudioHardwareUnspecifiedError\n");

  84.             break;

  85.         case kAudioHardwareUnknownPropertyError:

  86.             JCALog("error code : kAudioHardwareUnknownPropertyError\n");

  87.             break;

  88.         case kAudioHardwareBadPropertySizeError:

  89.             JCALog("error code : kAudioHardwareBadPropertySizeError\n");

  90.             break;

  91.         case kAudioHardwareIllegalOperationError:

  92.             JCALog("error code : kAudioHardwareIllegalOperationError\n");

  93.             break;

  94.         case kAudioHardwareBadDeviceError:

  95.             JCALog("error code : kAudioHardwareBadDeviceError\n");

  96.             break;

  97.         case kAudioHardwareBadStreamError:

  98.             JCALog("error code : kAudioHardwareBadStreamError\n");

  99.             break;

  100.         case kAudioDeviceUnsupportedFormatError:

  101.             JCALog("error code : kAudioDeviceUnsupportedFormatError\n");

  102.             break;

  103.         case kAudioDevicePermissionsError:

  104.             JCALog("error code : kAudioDevicePermissionsError\n");

  105.             break;

  106.         default:

  107.             JCALog("error code : unknown %ld\n", err);

  108.             break;

  109.     }

  110. #endif

  111. }

  112. 

  113. static OSStatus get_device_name_from_id(AudioDeviceID id, char name[256])

  114. {

  115.     UInt32 size = sizeof(char) * 256;

  116.     OSStatus res = AudioDeviceGetProperty(id, 0, false,

  117. 					   kAudioDevicePropertyDeviceName,

  118. 					   &size,

  119. 					   &name[0]);

  120.     return res;

  121. }

  122. 

  123. static OSStatus get_device_id_from_uid(char* UID, AudioDeviceID* id)

  124. {

  125. 	UInt32 size = sizeof(AudioValueTranslation);

  126. 	CFStringRef inIUD = CFStringCreateWithCString(NULL, UID, CFStringGetSystemEncoding());

  127. 	AudioValueTranslation value = { &inIUD, sizeof(CFStringRef), id, sizeof(AudioDeviceID) };

  128. 	if (inIUD == NULL) {

  129. 		return kAudioHardwareUnspecifiedError;

  130. 	} else {

  131. 		OSStatus res = AudioHardwareGetProperty(kAudioHardwarePropertyDeviceForUID, &size, &value);

  132. 		CFRelease(inIUD);

  133. 		JCALog("get_device_id_from_uid %s %ld \n", UID, *id);

  134. 		return (*id == kAudioDeviceUnknown) ? kAudioHardwareBadDeviceError : res;

  135. 	}

  136. }

  137. 

  138. static OSStatus get_default_device(AudioDeviceID * id)

  139. {

  140.     OSStatus res;

  141.     UInt32 theSize = sizeof(UInt32);

  142. 	AudioDeviceID inDefault;

  143. 	AudioDeviceID outDefault;

  144.   

  145. 	if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, 

  146. 					&theSize, &inDefault)) != noErr)

  147. 		return res;

  148. 	

  149. 	if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, 

  150. 					&theSize, &outDefault)) != noErr)

  151. 		return res;

  152. 		

  153. 	JCALog("get_default_device: input %ld output %ld\n", inDefault, outDefault);

  154. 	

  155. 	// Get the device only if default input and ouput are the same

  156. 	if (inDefault == outDefault) {

  157. 		*id = inDefault;

  158. 		return noErr;

  159. 	} else {

  160. 		jack_error("Default input and output devices are not the same !!");

  161. 		return kAudioHardwareBadDeviceError;

  162. 	}

  163. }

  164. 

  165. static OSStatus get_default_input_device(AudioDeviceID* id)

  166. {

  167.     OSStatus res;

  168.     UInt32 theSize = sizeof(UInt32);

  169.     AudioDeviceID inDefault;

  170.   

  171.     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice,

  172.                                         &theSize, &inDefault)) != noErr)

  173.         return res;

  174. 

  175.     JCALog("get_default_input_device: input = %ld \n", inDefault);

  176.     *id = inDefault;

  177. 	return noErr;

  178. }

  179. 

  180. static OSStatus get_default_output_device(AudioDeviceID* id)

  181. {

  182.     OSStatus res;

  183.     UInt32 theSize = sizeof(UInt32);

  184.     AudioDeviceID outDefault;

  185. 

  186.     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice,

  187.                                         &theSize, &outDefault)) != noErr)

  188.         return res;

  189. 

  190.     JCALog("get_default_output_device: output = %ld\n", outDefault);

  191. 	*id = outDefault;

  192. 	return noErr;

  193. }

  194. 

  195. OSStatus get_total_channels(AudioDeviceID device, int* channelCount, bool isInput) 

  196. {

  197.     OSStatus			err = noErr;

  198.     UInt32				outSize;

  199.     Boolean				outWritable;

  200.     AudioBufferList*	bufferList = 0;

  201. 	AudioStreamID*		streamList = 0;

  202.     int					i, numStream;

  203. 	

  204. 	err = AudioDeviceGetPropertyInfo(device, 0, isInput, kAudioDevicePropertyStreams, &outSize, &outWritable);

  205. 	if (err == noErr) {

  206. 		streamList = (AudioStreamID*)malloc(outSize);

  207. 		numStream = outSize/sizeof(AudioStreamID);

  208. 		JCALog("get_total_channels device stream number = %ld numStream = %ld\n", device, numStream);

  209. 		err = AudioDeviceGetProperty(device, 0, isInput, kAudioDevicePropertyStreams, &outSize, streamList);

  210. 		if (err == noErr) {

  211. 			AudioStreamBasicDescription streamDesc;

  212. 			outSize = sizeof(AudioStreamBasicDescription);

  213. 			for (i = 0; i < numStream; i++) {

  214. 				err = AudioStreamGetProperty(streamList[i], 0, kAudioDevicePropertyStreamFormat, &outSize, &streamDesc);

  215. 				JCALog("get_total_channels streamDesc mFormatFlags = %ld mChannelsPerFrame = %ld\n", streamDesc.mFormatFlags, streamDesc.mChannelsPerFrame);

  216. 			}

  217. 		}

  218. 	}

  219. 	

  220.     *channelCount = 0;

  221.     err = AudioDeviceGetPropertyInfo(device, 0, isInput, kAudioDevicePropertyStreamConfiguration, &outSize, &outWritable);

  222.     if (err == noErr) {

  223.         bufferList = (AudioBufferList*)malloc(outSize);

  224.         err = AudioDeviceGetProperty(device, 0, isInput, kAudioDevicePropertyStreamConfiguration, &outSize, bufferList);

  225.         if (err == noErr) {								

  226.             for (i = 0; i < bufferList->mNumberBuffers; i++) 

  227.                 *channelCount += bufferList->mBuffers[i].mNumberChannels;

  228.         }

  229.     }

  230. 	

  231. 	if (streamList) 

  232. 		free(streamList);

  233. 	if (bufferList) 

  234. 		free(bufferList);	

  235. 		

  236.     return err;

  237. }

  238. 

  239. static OSStatus display_device_names()

  240. {

  241. 	UInt32 size;

  242. 	Boolean isWritable;

  243. 	int i, deviceNum;

  244. 	OSStatus err;

  245. 	CFStringRef UIname;

  246. 	

  247. 	err = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &size, &isWritable);

  248.     if (err != noErr) 

  249. 		return err;

  250. 		

  251. 	deviceNum = size/sizeof(AudioDeviceID);

  252. 	AudioDeviceID devices[deviceNum];

  253. 	

  254. 	err = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &size, devices);

  255.     if (err != noErr) 

  256. 		return err;

  257. 	

  258. 	for (i = 0; i < deviceNum; i++) {

  259.         char device_name[256];

  260. 		char internal_name[256];

  261. 		

  262. 		size = sizeof(CFStringRef);

  263. 		UIname = NULL;

  264. 		err = AudioDeviceGetProperty(devices[i], 0, false, kAudioDevicePropertyDeviceUID, &size, &UIname);

  265. 		if (err == noErr) {

  266. 			CFStringGetCString(UIname, internal_name, 256, CFStringGetSystemEncoding());

  267. 		} else {

  268. 			goto error;

  269. 		}

  270. 		

  271. 		size = 256;

  272. 		err = AudioDeviceGetProperty(devices[i], 0, false, kAudioDevicePropertyDeviceName, &size, device_name);

  273. 		if (err != noErr) 

  274. 			return err; 

  275. 		jack_info("ICI");

  276. 		jack_info("Device name = \'%s\', internal_name = \'%s\' (to be used as -d parameter)", device_name, internal_name); 

  277. 	}

  278. 	

  279. 	return noErr;

  280. 

  281. error:

  282. 	if (UIname != NULL)

  283. 		CFRelease(UIname);

  284. 	return err;

  285. }

  286. 

  287. static OSStatus render(void *inRefCon, 

  288. 						AudioUnitRenderActionFlags 	*ioActionFlags, 

  289. 						const AudioTimeStamp 		*inTimeStamp, 

  290. 						UInt32 						inBusNumber, 

  291. 						UInt32 						inNumberFrames, 

  292. 						AudioBufferList 			*ioData)

  293. {

  294. 	int res, i;

  295. 	JSList *node;

  296. 	coreaudio_driver_t* ca_driver = (coreaudio_driver_t*)inRefCon;

  297. 	AudioUnitRender(ca_driver->au_hal, ioActionFlags, inTimeStamp, 1, inNumberFrames, ca_driver->input_list);

  298. 	

  299. 	if (ca_driver->xrun_detected > 0) { /* XRun was detected */

  300. 		jack_time_t current_time = jack_get_microseconds();

  301. 		ca_driver->engine->delay(ca_driver->engine, current_time - 

  302. 			(ca_driver->last_wait_ust + ca_driver->period_usecs));

  303. 		ca_driver->last_wait_ust = current_time;

  304. 		ca_driver->xrun_detected = 0;

  305. 		return 0;

  306.     } else {

  307. 		ca_driver->last_wait_ust = jack_get_microseconds();

  308. 		ca_driver->engine->transport_cycle_start(ca_driver->engine,

  309. 					  jack_get_microseconds());

  310. 		res = ca_driver->engine->run_cycle(ca_driver->engine, inNumberFrames, 0);

  311. 	}

  312. 	

  313. 	if (ca_driver->null_cycle_occured) {

  314. 		ca_driver->null_cycle_occured = 0;

  315. 		for (i = 0; i < ca_driver->playback_nchannels; i++) {

  316. 			memset((float*)ioData->mBuffers[i].mData, 0, sizeof(float) * inNumberFrames);

  317. 		}

  318. 	} else {

  319. 		for (i = 0, node = ca_driver->playback_ports; i < ca_driver->playback_nchannels; i++, node = jack_slist_next(node)) {

  320. 			memcpy((float*)ioData->mBuffers[i].mData,

  321. 					(jack_default_audio_sample_t*)jack_port_get_buffer(((jack_port_t *) node->data), inNumberFrames), 

  322. 					sizeof(float) * inNumberFrames);

  323. 		}

  324. 	}

  325. 	

  326. 	return res;

  327. }

  328. 

  329. static OSStatus render_input(void *inRefCon, 

  330. 							AudioUnitRenderActionFlags 	*ioActionFlags, 

  331. 							const AudioTimeStamp 		*inTimeStamp, 

  332. 							UInt32 						inBusNumber, 

  333. 							UInt32 						inNumberFrames, 

  334. 							AudioBufferList 			*ioData)

  335. 

  336. {

  337. 	coreaudio_driver_t* ca_driver = (coreaudio_driver_t*)inRefCon;

  338. 	AudioUnitRender(ca_driver->au_hal, ioActionFlags, inTimeStamp, 1, inNumberFrames, ca_driver->input_list);

  339. 	if (ca_driver->xrun_detected > 0) { /* XRun was detected */

  340. 		jack_time_t current_time = jack_get_microseconds();

  341. 		ca_driver->engine->delay(ca_driver->engine, current_time - 

  342. 			(ca_driver->last_wait_ust + ca_driver->period_usecs));

  343. 		ca_driver->last_wait_ust = current_time;

  344. 		ca_driver->xrun_detected = 0;

  345. 		return 0;

  346.     } else {

  347. 		ca_driver->last_wait_ust = jack_get_microseconds();

  348. 		ca_driver->engine->transport_cycle_start(ca_driver->engine,

  349. 					  jack_get_microseconds());

  350. 		return ca_driver->engine->run_cycle(ca_driver->engine, inNumberFrames, 0);

  351. 	}

  352. }

  353. 

  354. 

  355. static OSStatus sr_notification(AudioDeviceID inDevice,

  356.         UInt32 inChannel,

  357.         Boolean	isInput,

  358.         AudioDevicePropertyID inPropertyID,

  359.         void* inClientData)

  360. {

  361. 	coreaudio_driver_t* driver = (coreaudio_driver_t*)inClientData;

  362. 	

  363. 	switch (inPropertyID) {

  364. 

  365. 		case kAudioDevicePropertyNominalSampleRate: {

  366. 			JCALog("JackCoreAudioDriver::SRNotificationCallback kAudioDevicePropertyNominalSampleRate \n");

  367. 			driver->state = 1;

  368. 			break;

  369. 		}

  370. 	}

  371. 	

  372. 	return noErr;

  373. }

  374. 

  375. static OSStatus notification(AudioDeviceID inDevice,

  376. 							UInt32 inChannel,

  377. 							Boolean	isInput,

  378. 							AudioDevicePropertyID inPropertyID,

  379. 							void* inClientData)

  380. {

  381.     coreaudio_driver_t* driver = (coreaudio_driver_t*)inClientData;

  382.     switch (inPropertyID) {

  383. 	

  384. 		case kAudioDeviceProcessorOverload:

  385. 			driver->xrun_detected = 1;

  386. 			break;

  387. 			

  388. 		case kAudioDevicePropertyNominalSampleRate: {

  389. 			UInt32 outSize =  sizeof(Float64);

  390. 			Float64 sampleRate;

  391. 			AudioStreamBasicDescription srcFormat, dstFormat;

  392. 			OSStatus err = AudioDeviceGetProperty(driver->device_id, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &sampleRate);

  393. 			if (err != noErr) {

  394. 				jack_error("Cannot get current sample rate");

  395. 				return kAudioHardwareUnsupportedOperationError;

  396. 			}

  397. 			JCALog("JackCoreAudioDriver::NotificationCallback kAudioDevicePropertyNominalSampleRate %ld\n", (long)sampleRate);

  398. 			outSize = sizeof(AudioStreamBasicDescription);

  399. 			

  400. 			// Update SR for input

  401. 			err = AudioUnitGetProperty(driver->au_hal, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &srcFormat, &outSize);

  402. 			if (err != noErr) {

  403. 				jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Input");

  404. 			}

  405. 			srcFormat.mSampleRate = sampleRate;

  406. 			err = AudioUnitSetProperty(driver->au_hal, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &srcFormat, outSize);

  407. 			if (err != noErr) {

  408. 				jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Input");

  409. 			}

  410. 		

  411. 			// Update SR for output

  412. 			err = AudioUnitGetProperty(driver->au_hal, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &dstFormat, &outSize);

  413. 			if (err != noErr) {

  414. 				jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Output");

  415. 			}

  416. 			dstFormat.mSampleRate = sampleRate;

  417. 			err = AudioUnitSetProperty(driver->au_hal, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &dstFormat, outSize);

  418. 			if (err != noErr) {

  419. 				jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Output");

  420. 			}

  421. 			break;

  422. 		}

  423.     }

  424.     return noErr;

  425. }

  426. 

  427. static int

  428. coreaudio_driver_attach(coreaudio_driver_t * driver, jack_engine_t * engine)

  429. {

  430.     jack_port_t *port;

  431. 	JSList *node;

  432.     int port_flags;

  433.     channel_t chn;

  434.     char buf[JACK_PORT_NAME_SIZE];

  435. 	char channel_name[64];

  436. 	OSStatus err;

  437. 	UInt32 size;

  438. 	UInt32 value1,value2;

  439.     Boolean isWritable;

  440. 	

  441.     driver->engine = engine;

  442. 

  443.     driver->engine->set_buffer_size(engine, driver->frames_per_cycle);

  444.     driver->engine->set_sample_rate(engine, driver->frame_rate);

  445. 

  446.     port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

  447. 

  448.     /*

  449.        if (driver->has_hw_monitoring) {

  450. 			port_flags |= JackPortCanMonitor;

  451.        }

  452. 	*/

  453. 

  454.     for (chn = 0; chn < driver->capture_nchannels; chn++) {

  455. 		err = AudioDeviceGetPropertyInfo(driver->device_id, chn + 1, true, kAudioDevicePropertyChannelName, &size, &isWritable);

  456. 		if (err == noErr && size > 0)  {

  457. 			err = AudioDeviceGetProperty(driver->device_id, chn + 1, true, kAudioDevicePropertyChannelName, &size, channel_name);	

  458. 			if (err != noErr) 

  459. 				JCALog("AudioDeviceGetProperty kAudioDevicePropertyChannelName error \n");

  460. 			snprintf(buf, sizeof(buf) - 1, "%s:out_%s%lu", driver->capture_driver_name, channel_name, chn + 1);

  461. 		} else {

  462. 			snprintf(buf, sizeof(buf) - 1, "%s:out%lu", driver->capture_driver_name, chn + 1);

  463. 		}

  464. 	

  465. 		if ((port = jack_port_register(driver->client, buf,

  466. 					JACK_DEFAULT_AUDIO_TYPE, port_flags,

  467. 					0)) == NULL) {

  468. 			jack_error("coreaudio: cannot register port for %s", buf);

  469. 			break;

  470. 		}

  471. 

  472. 		size = sizeof(UInt32);

  473. 		value1 = value2 = 0;

  474. 		err = AudioDeviceGetProperty(driver->device_id, 0, true, kAudioDevicePropertyLatency, &size, &value1);	

  475. 		if (err != noErr) 

  476. 			JCALog("AudioDeviceGetProperty kAudioDevicePropertyLatency error \n");

  477. 		err = AudioDeviceGetProperty(driver->device_id, 0, true, kAudioDevicePropertySafetyOffset, &size, &value2);	

  478. 		if (err != noErr) 

  479. 			JCALog("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error \n");

  480. 		

  481. 		jack_port_set_latency(port, driver->frames_per_cycle + value1 + value2 + driver->capture_frame_latency);

  482. 		driver->capture_ports =

  483. 			jack_slist_append(driver->capture_ports, port);

  484.     }

  485. 

  486.     port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  487. 

  488. 	for (chn = 0; chn < driver->playback_nchannels; chn++) {

  489. 		err = AudioDeviceGetPropertyInfo(driver->device_id, chn + 1, false, kAudioDevicePropertyChannelName, &size, &isWritable);

  490. 		if (err == noErr && size > 0)  {

  491. 			err = AudioDeviceGetProperty(driver->device_id, chn + 1, false, kAudioDevicePropertyChannelName, &size, channel_name);	

  492. 			if (err != noErr) 

  493. 				JCALog("AudioDeviceGetProperty kAudioDevicePropertyChannelName error \n");

  494. 			snprintf(buf, sizeof(buf) - 1, "%s:in_%s%lu", driver->playback_driver_name, channel_name, chn + 1);

  495. 		} else {

  496. 			snprintf(buf, sizeof(buf) - 1, "%s:in%lu", driver->playback_driver_name, chn + 1);

  497. 		}

  498. 

  499. 		if ((port = jack_port_register(driver->client, buf,

  500. 					JACK_DEFAULT_AUDIO_TYPE, port_flags,

  501. 					0)) == NULL) {

  502. 			jack_error("coreaudio: cannot register port for %s", buf);

  503. 			break;

  504. 		}

  505. 

  506. 		size = sizeof(UInt32);

  507. 		value1 = value2 = 0;

  508. 		err = AudioDeviceGetProperty(driver->device_id, 0, false, kAudioDevicePropertyLatency, &size, &value1);	

  509. 		if (err != noErr) 

  510. 			JCALog("AudioDeviceGetProperty kAudioDevicePropertyLatency error \n");

  511. 		err = AudioDeviceGetProperty(driver->device_id, 0, false, kAudioDevicePropertySafetyOffset, &size, &value2);	

  512. 		if (err != noErr) 

  513. 			JCALog("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error \n");

  514. 	

  515. 		jack_port_set_latency(port, driver->frames_per_cycle + value1 + value2 + driver->playback_frame_latency);

  516. 		driver->playback_ports =

  517. 			jack_slist_append(driver->playback_ports, port);

  518. 	}

  519. 	

  520. 	// Input buffers do no change : prepare them only once

  521. 	for (chn = 0, node = driver->capture_ports; chn < driver->capture_nchannels; chn++, node = jack_slist_next(node)) {

  522. 		driver->input_list->mBuffers[chn].mData 

  523. 			= (jack_default_audio_sample_t*)jack_port_get_buffer(((jack_port_t *) node->data), driver->frames_per_cycle);

  524.     }

  525. 

  526.     jack_activate(driver->client);

  527.     return 0;

  528. }

  529. 

  530. static int

  531. coreaudio_driver_detach(coreaudio_driver_t * driver, jack_engine_t * engine)

  532. {

  533.     JSList *node;

  534. 

  535.     if (driver->engine == 0) {

  536. 		return -1;

  537.     }

  538. 

  539.     for (node = driver->capture_ports; node; node = jack_slist_next(node)) {

  540. 		jack_port_unregister(driver->client, ((jack_port_t *) node->data));

  541.     }

  542. 

  543.     jack_slist_free(driver->capture_ports);

  544.     driver->capture_ports = 0;

  545. 

  546.     for (node = driver->playback_ports; node; node = jack_slist_next(node)) {

  547. 		jack_port_unregister(driver->client, ((jack_port_t *) node->data));

  548.     }

  549. 

  550.     jack_slist_free(driver->playback_ports);

  551.     driver->playback_ports = 0;

  552. 

  553.     driver->engine = 0;

  554.     return 0;

  555. }

  556. 

  557. static int

  558. coreaudio_driver_null_cycle(coreaudio_driver_t * driver, jack_nframes_t nframes)

  559. {

  560. 	driver->null_cycle_occured = 1;

  561.     return 0;

  562. }

  563. 

  564. static int

  565. coreaudio_driver_read(coreaudio_driver_t * driver, jack_nframes_t nframes)

  566. {

  567.     return 0;

  568. }

  569. 

  570. static int

  571. coreaudio_driver_write(coreaudio_driver_t * driver, jack_nframes_t nframes)

  572. {

  573. 	return 0;

  574. }

  575. 

  576. static int coreaudio_driver_audio_start(coreaudio_driver_t * driver)

  577. {

  578. 	return (AudioOutputUnitStart(driver->au_hal) == noErr) ? 0 : -1;

  579. }

  580. 

  581. static int coreaudio_driver_audio_stop(coreaudio_driver_t * driver)

  582. {

  583. 	return (AudioOutputUnitStop(driver->au_hal) == noErr) ? 0 : -1;

  584. }

  585. 

  586. static int

  587. coreaudio_driver_bufsize(coreaudio_driver_t * driver,

  588. 			 jack_nframes_t nframes)

  589. {

  590. 

  591.     /* This gets called from the engine server thread, so it must

  592.      * be serialized with the driver thread. Stopping the audio

  593.      * also stops that thread. */

  594. 	/*

  595. 	TO DO

  596. 	*/

  597. 	return 0;

  598. }

  599. 

  600. /** create a new driver instance

  601. */

  602. static jack_driver_t *coreaudio_driver_new(char* name,

  603. 										   jack_client_t* client,

  604. 										   jack_nframes_t nframes,

  605. 										   jack_nframes_t samplerate,

  606. 										   int capturing,

  607. 										   int playing,

  608. 										   int inchannels,

  609. 										   int outchannels,

  610. 										   char* capture_driver_uid,

  611. 										   char* playback_driver_uid,

  612. 										   jack_nframes_t capture_latency, 

  613. 										   jack_nframes_t playback_latency)

  614. {

  615.     coreaudio_driver_t *driver;

  616. 	OSStatus err = noErr;

  617. 	ComponentResult err1;

  618.     UInt32 outSize;

  619. 	UInt32 enableIO;

  620. 	AudioStreamBasicDescription srcFormat, dstFormat;

  621. 	Float64 sampleRate;

  622. 	int in_nChannels = 0;

  623. 	int out_nChannels = 0;

  624. 	int i;

  625. 	

  626.     driver = (coreaudio_driver_t *) calloc(1, sizeof(coreaudio_driver_t));

  627.     jack_driver_init((jack_driver_t *) driver);

  628. 

  629.     if (!jack_power_of_two(nframes)) {

  630. 		jack_error("CA: -p must be a power of two.");

  631. 		goto error;

  632.     }

  633. 

  634. 	driver->state = 0;

  635.     driver->frames_per_cycle = nframes;

  636.     driver->frame_rate = samplerate;

  637.     driver->capturing = capturing;

  638.     driver->playing = playing;

  639. 	driver->xrun_detected = 0;

  640. 	driver->null_cycle = 0;

  641. 

  642.     driver->attach = (JackDriverAttachFunction) coreaudio_driver_attach;

  643.     driver->detach = (JackDriverDetachFunction) coreaudio_driver_detach;

  644.     driver->read = (JackDriverReadFunction) coreaudio_driver_read;

  645.     driver->write = (JackDriverReadFunction) coreaudio_driver_write;

  646.     driver->null_cycle =

  647. 	(JackDriverNullCycleFunction) coreaudio_driver_null_cycle;

  648.     driver->bufsize = (JackDriverBufSizeFunction) coreaudio_driver_bufsize;

  649.     driver->start = (JackDriverStartFunction) coreaudio_driver_audio_start;

  650.     driver->stop = (JackDriverStopFunction) coreaudio_driver_audio_stop;

  651. 	driver->capture_frame_latency = capture_latency;

  652. 	driver->playback_frame_latency = playback_latency;

  653. 	

  654. 	// Duplex

  655.     if (strcmp(capture_driver_uid, "") != 0 && strcmp(playback_driver_uid, "") != 0) {

  656. 		JCALog("Open duplex \n");

  657.         if (get_device_id_from_uid(playback_driver_uid, &driver->device_id) != noErr) {

  658.             if (get_default_device(&driver->device_id) != noErr) {

  659. 				jack_error("Cannot open default device");

  660. 				goto error;

  661. 			}

  662. 		}

  663. 		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) {

  664. 			jack_error("Cannot get device name from device ID");

  665. 			goto error;

  666. 		}

  667. 		

  668. 	// Capture only

  669. 	} else if (strcmp(capture_driver_uid, "") != 0) {

  670. 		JCALog("Open capture only \n");

  671. 		if (get_device_id_from_uid(capture_driver_uid, &driver->device_id) != noErr) {

  672.             if (get_default_input_device(&driver->device_id) != noErr) {

  673. 				jack_error("Cannot open default device");

  674.                 goto error;

  675. 			}

  676. 		}

  677. 		if (get_device_name_from_id(driver->device_id, driver->capture_driver_name) != noErr) {

  678. 			jack_error("Cannot get device name from device ID");

  679. 			goto error;

  680. 		}

  681. 		

  682.   	// Playback only

  683. 	} else if (playback_driver_uid != NULL) {

  684. 		JCALog("Open playback only \n");

  685. 		if (get_device_id_from_uid(playback_driver_uid, &driver->device_id) != noErr) {

  686.             if (get_default_output_device(&driver->device_id) != noErr) {

  687. 				jack_error("Cannot open default device");

  688.                 goto error;

  689. 			}

  690.         }

  691. 		if (get_device_name_from_id(driver->device_id, driver->playback_driver_name) != noErr) {

  692. 			jack_error("Cannot get device name from device ID");

  693. 			goto error;

  694. 		}

  695. 		

  696. 	// Use default driver in duplex mode

  697. 	} else {

  698. 		JCALog("Open default driver \n");

  699. 		if (get_default_device(&driver->device_id) != noErr) {

  700. 			jack_error("Cannot open default device");

  701. 			goto error;

  702. 		}

  703. 		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) {

  704. 			jack_error("Cannot get device name from device ID");

  705. 			goto error;

  706. 		}

  707. 	}

  708. 	

  709. 	driver->client = client;

  710.     driver->period_usecs =

  711. 		(((float) driver->frames_per_cycle) / driver->frame_rate) *

  712. 		1000000.0f;

  713. 	

  714. 	if (capturing) {

  715. 		err = get_total_channels(driver->device_id, &in_nChannels, true);

  716. 		if (err != noErr) { 

  717. 			jack_error("Cannot get input channel number");

  718. 			printError(err);

  719. 			goto error;

  720. 		} 

  721. 	}

  722. 	

  723. 	if (playing) {

  724. 		err = get_total_channels(driver->device_id, &out_nChannels, false);

  725. 		if (err != noErr) { 

  726. 			jack_error("Cannot get output channel number");

  727. 			printError(err);

  728. 			goto error;

  729. 		} 

  730. 	}

  731. 	

  732. 	if (inchannels > in_nChannels) {

  733.         jack_error("This device hasn't required input channels inchannels = %ld in_nChannels = %ld", inchannels, in_nChannels);

  734. 		goto error;

  735.     }

  736. 	

  737. 	if (outchannels > out_nChannels) {

  738.         jack_error("This device hasn't required output channels outchannels = %ld out_nChannels = %ld", outchannels, out_nChannels);

  739. 		goto error;

  740.     }

  741. 

  742. 	if (inchannels == 0) {

  743. 		JCALog("Setup max in channels = %ld\n", in_nChannels);

  744. 		inchannels = in_nChannels; 

  745. 	}

  746. 		

  747. 	if (outchannels == 0) {

  748. 		JCALog("Setup max out channels = %ld\n", out_nChannels);

  749. 		outchannels = out_nChannels; 

  750. 	}

  751. 

  752.     // Setting buffer size

  753.     outSize = sizeof(UInt32);

  754.     err = AudioDeviceSetProperty(driver->device_id, NULL, 0, false, kAudioDevicePropertyBufferFrameSize, outSize, &nframes);

  755.     if (err != noErr) {

  756.         jack_error("Cannot set buffer size %ld", nframes);

  757.         printError(err);

  758. 		goto error;

  759.     }

  760. 

  761. 	// Set sample rate

  762. 	outSize =  sizeof(Float64);

  763. 	err = AudioDeviceGetProperty(driver->device_id, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &sampleRate);

  764. 	if (err != noErr) {

  765. 		jack_error("Cannot get current sample rate");

  766. 		printError(err);

  767. 		goto error;

  768. 	}

  769. 

  770. 	if (samplerate != (jack_nframes_t)sampleRate) {

  771. 		sampleRate = (Float64)samplerate;

  772. 		

  773. 		// To get SR change notification

  774. 		err = AudioDeviceAddPropertyListener(driver->device_id, 0, true, kAudioDevicePropertyNominalSampleRate, sr_notification, driver);

  775. 		if (err != noErr) {

  776. 			jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyNominalSampleRate");

  777. 			printError(err);

  778. 			return -1;

  779. 		}

  780. 		err = AudioDeviceSetProperty(driver->device_id, NULL, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, outSize, &sampleRate);

  781. 		if (err != noErr) {

  782. 			jack_error("Cannot set sample rate = %ld", samplerate);

  783. 			printError(err);

  784. 			return -1;

  785. 		}

  786. 		

  787. 		// Waiting for SR change notification

  788. 		int count = 0;

  789. 		while (!driver->state && count++ < 100) {

  790. 			usleep(100000);

  791. 			JCALog("Wait count = %ld\n", count);

  792. 		}

  793. 		

  794. 		// Remove SR change notification

  795. 		AudioDeviceRemovePropertyListener(driver->device_id, 0, true, kAudioDevicePropertyNominalSampleRate, sr_notification);

  796. 	}

  797. 

  798.     // AUHAL

  799.     ComponentDescription cd = {kAudioUnitType_Output, kAudioUnitSubType_HALOutput, kAudioUnitManufacturer_Apple, 0, 0};

  800.     Component HALOutput = FindNextComponent(NULL, &cd);

  801. 

  802.     err1 = OpenAComponent(HALOutput, &driver->au_hal);

  803.     if (err1 != noErr) {

  804. 		jack_error("Error calling OpenAComponent");

  805.         printError(err1);

  806.         goto error;

  807. 	}

  808. 

  809.     err1 = AudioUnitInitialize(driver->au_hal);

  810.     if (err1 != noErr) {

  811. 		jack_error("Cannot initialize AUHAL unit");

  812. 		printError(err1);

  813.         goto error;

  814. 	}

  815. 

  816.  	// Start I/O

  817. 	enableIO = 1;

  818. 	if (capturing && inchannels > 0) {

  819. 		JCALog("Setup AUHAL input\n");

  820.         err1 = AudioUnitSetProperty(driver->au_hal, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, &enableIO, sizeof(enableIO));

  821.         if (err1 != noErr) {

  822.             jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input");

  823.             printError(err1);

  824.             goto error;

  825.         }

  826.     }

  827. 	

  828. 	if (playing && outchannels > 0) {

  829. 		JCALog("Setup AUHAL output\n");

  830. 		err1 = AudioUnitSetProperty(driver->au_hal, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, &enableIO, sizeof(enableIO));

  831. 		if (err1 != noErr) {

  832. 			jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_EnableIO,kAudioUnitScope_Output");

  833. 			printError(err1);

  834. 			goto error;

  835. 		}

  836. 	}

  837. 	

  838. 	// Setup up choosen device, in both input and output cases

  839. 	err1 = AudioUnitSetProperty(driver->au_hal, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &driver->device_id, sizeof(AudioDeviceID));

  840. 	if (err1 != noErr) {

  841. 		jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_CurrentDevice");

  842. 		printError(err1);

  843. 		goto error;

  844. 	}

  845. 

  846. 	// Set buffer size

  847. 	if (capturing && inchannels > 0) {

  848. 		err1 = AudioUnitSetProperty(driver->au_hal, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 1, (UInt32*)&nframes, sizeof(UInt32));

  849. 		if (err1 != noErr) {

  850. 			jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_MaximumFramesPerSlice");

  851. 			printError(err1);

  852. 			goto error;

  853. 		}

  854. 	}

  855. 	

  856. 	if (playing && outchannels > 0) {

  857. 		err1 = AudioUnitSetProperty(driver->au_hal, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 0, (UInt32*)&nframes, sizeof(UInt32));

  858. 		if (err1 != noErr) {

  859. 			jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_MaximumFramesPerSlice");

  860. 			printError(err1);

  861. 			goto error;

  862. 		}

  863. 	}

  864. 

  865. 	// Setup channel map

  866. 	if (capturing && inchannels > 0 && inchannels < in_nChannels) {

  867.         SInt32 chanArr[in_nChannels];

  868.         for (i = 0; i < in_nChannels; i++) {

  869.             chanArr[i] = -1;

  870.         }

  871.         for (i = 0; i < inchannels; i++) {

  872.             chanArr[i] = i;

  873.         }

  874.         AudioUnitSetProperty(driver->au_hal, kAudioOutputUnitProperty_ChannelMap , kAudioUnitScope_Input, 1, chanArr, sizeof(SInt32) * in_nChannels);

  875.         if (err1 != noErr) {

  876.             jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_ChannelMap 1");

  877.             printError(err1);

  878.         }

  879.     }

  880. 

  881.     if (playing && outchannels > 0 && outchannels < out_nChannels) {

  882.         SInt32 chanArr[out_nChannels];

  883.         for (i = 0;	i < out_nChannels; i++) {

  884.             chanArr[i] = -1;

  885.         }

  886.         for (i = 0; i < outchannels; i++) {

  887.             chanArr[i] = i;

  888.         }

  889.         err1 = AudioUnitSetProperty(driver->au_hal, kAudioOutputUnitProperty_ChannelMap, kAudioUnitScope_Output, 0, chanArr, sizeof(SInt32) * out_nChannels);

  890.         if (err1 != noErr) {

  891.             jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_ChannelMap 0");

  892.             printError(err1);

  893.         }

  894.     }

  895. 

  896. 	// Setup stream converters

  897.   	srcFormat.mSampleRate = samplerate;

  898. 	srcFormat.mFormatID = kAudioFormatLinearPCM;

  899. 	srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  900. 	srcFormat.mBytesPerPacket = sizeof(float);

  901. 	srcFormat.mFramesPerPacket = 1;

  902. 	srcFormat.mBytesPerFrame = sizeof(float);

  903. 	srcFormat.mChannelsPerFrame = outchannels;

  904. 	srcFormat.mBitsPerChannel = 32;

  905. 

  906. 	err1 = AudioUnitSetProperty(driver->au_hal, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &srcFormat, sizeof(AudioStreamBasicDescription));

  907. 	if (err1 != noErr) {

  908. 		jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Input");

  909. 		printError(err1);

  910. 	}

  911. 

  912. 	dstFormat.mSampleRate = samplerate;

  913. 	dstFormat.mFormatID = kAudioFormatLinearPCM;

  914. 	dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  915. 	dstFormat.mBytesPerPacket = sizeof(float);

  916. 	dstFormat.mFramesPerPacket = 1;

  917. 	dstFormat.mBytesPerFrame = sizeof(float);

  918. 	dstFormat.mChannelsPerFrame = inchannels;

  919. 	dstFormat.mBitsPerChannel = 32;

  920. 

  921. 	err1 = AudioUnitSetProperty(driver->au_hal, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &dstFormat, sizeof(AudioStreamBasicDescription));

  922. 	if (err1 != noErr) {

  923. 		jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Output");

  924. 		printError(err1);

  925. 	}

  926. 

  927. 	// Setup callbacks

  928.     if (inchannels > 0 && outchannels == 0) {

  929.         AURenderCallbackStruct output;

  930.         output.inputProc = render_input;

  931.         output.inputProcRefCon = driver;

  932.     	err1 = AudioUnitSetProperty(driver->au_hal, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &output, sizeof(output));

  933.         if (err1 != noErr) {

  934.             jack_error("Error calling  AudioUnitSetProperty - kAudioUnitProperty_SetRenderCallback 1");

  935.             printError(err1);

  936.             goto error;

  937.         }

  938.     } else {

  939.         AURenderCallbackStruct output;

  940.         output.inputProc = render;

  941.         output.inputProcRefCon = driver;

  942.         err1 = AudioUnitSetProperty(driver->au_hal, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &output, sizeof(output));

  943.         if (err1 != noErr) {

  944.             jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_SetRenderCallback 0");

  945.             printError(err1);

  946.             goto error;

  947.         }

  948.     }

  949. 

  950. 	if (capturing && inchannels > 0) {

  951. 		driver->input_list = (AudioBufferList*)malloc(sizeof(UInt32) + inchannels * sizeof(AudioBuffer));

  952. 		if (driver->input_list == 0)

  953. 			goto error;

  954. 		driver->input_list->mNumberBuffers = inchannels;

  955. 		

  956. 		// Prepare buffers

  957. 		for (i = 0; i < driver->capture_nchannels; i++) {

  958. 			driver->input_list->mBuffers[i].mNumberChannels = 1;

  959. 			driver->input_list->mBuffers[i].mDataByteSize = nframes * sizeof(float);

  960. 		}

  961. 	}

  962. 

  963. 	err = AudioDeviceAddPropertyListener(driver->device_id, 0, true, kAudioDeviceProcessorOverload, notification, driver);

  964.     if (err != noErr) {

  965. 		jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDeviceProcessorOverload");

  966.         goto error;

  967. 	}

  968. 		

  969. 	err = AudioDeviceAddPropertyListener(driver->device_id, 0, true, kAudioDevicePropertyNominalSampleRate, notification, driver);

  970.     if (err != noErr) {

  971.         jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyNominalSampleRate");

  972.         goto error;

  973.     }

  974.  

  975. 	driver->playback_nchannels = outchannels;

  976.     driver->capture_nchannels = inchannels;

  977. 	return ((jack_driver_t *) driver);

  978. 

  979.   error:

  980. 	AudioUnitUninitialize(driver->au_hal);

  981. 	CloseComponent(driver->au_hal);

  982.     jack_error("Cannot open the coreaudio driver");

  983.     free(driver);

  984.     return NULL;

  985. }

  986. 

  987. /** free all memory allocated by a driver instance

  988. */

  989. static void coreaudio_driver_delete(coreaudio_driver_t * driver)

  990. {

  991.  	AudioDeviceRemovePropertyListener(driver->device_id, 0, true, kAudioDeviceProcessorOverload, notification);

  992.     free(driver->input_list);

  993.  	AudioUnitUninitialize(driver->au_hal);

  994. 	CloseComponent(driver->au_hal);

  995.     free(driver);

  996. }

  997. 

  998. //== driver "plugin" interface =================================================

  999. 

  1000. /* DRIVER "PLUGIN" INTERFACE */

  1001. 

  1002. const char driver_client_name[] = "coreaudio";

  1003. 

  1004. jack_driver_desc_t *driver_get_descriptor()

  1005. {

  1006.     jack_driver_desc_t *desc;

  1007.     unsigned int i;

  1008.     desc = calloc(1, sizeof(jack_driver_desc_t));

  1009. 

  1010.     strcpy(desc->name, "coreaudio");

  1011.     desc->nparams = 12;

  1012.     desc->params = calloc(desc->nparams, sizeof(jack_driver_param_desc_t));

  1013. 

  1014.     i = 0;

  1015.     strcpy(desc->params[i].name, "channels");

  1016.     desc->params[i].character = 'c';

  1017.     desc->params[i].type = JackDriverParamInt;

  1018.     desc->params[i].value.ui = 2;

  1019.     strcpy(desc->params[i].short_desc, "Maximum number of channels");

  1020.     strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1021. 

  1022.     i++;

  1023.     strcpy(desc->params[i].name, "inchannels");

  1024.     desc->params[i].character = 'i';

  1025.     desc->params[i].type = JackDriverParamInt;

  1026.     desc->params[i].value.ui = 2;

  1027.     strcpy(desc->params[i].short_desc, "Maximum number of input channels");

  1028.     strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1029. 

  1030.     i++;

  1031.     strcpy(desc->params[i].name, "outchannels");

  1032.     desc->params[i].character = 'o';

  1033.     desc->params[i].type = JackDriverParamInt;

  1034.     desc->params[i].value.ui = 2;

  1035.     strcpy(desc->params[i].short_desc, "Maximum number of output channels");

  1036.     strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1037. 

  1038.     i++;

  1039. 	strcpy(desc->params[i].name, "capture");

  1040. 	desc->params[i].character = 'C';

  1041. 	desc->params[i].type = JackDriverParamString;

  1042. 	strcpy(desc->params[i].value.str, "will take default CoreAudio input device");

  1043. 	strcpy(desc->params[i].short_desc, "Provide capture ports. Optionally set CoreAudio device name");

  1044. 	strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1045. 

  1046. 	i++;

  1047. 	strcpy(desc->params[i].name, "playback");

  1048. 	desc->params[i].character = 'P';

  1049. 	desc->params[i].type = JackDriverParamString;

  1050. 	strcpy(desc->params[i].value.str, "will take default CoreAudio output device");

  1051. 	strcpy(desc->params[i].short_desc, "Provide playback ports. Optionally set CoreAudio device name");

  1052. 	strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1053. 

  1054.     i++;

  1055.     strcpy(desc->params[i].name, "duplex");

  1056.     desc->params[i].character = 'D';

  1057.     desc->params[i].type = JackDriverParamBool;

  1058.     desc->params[i].value.i = TRUE;

  1059.     strcpy(desc->params[i].short_desc, "Capture and playback");

  1060.     strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1061. 

  1062.     i++;

  1063.     strcpy(desc->params[i].name, "rate");

  1064.     desc->params[i].character = 'r';

  1065.     desc->params[i].type = JackDriverParamUInt;

  1066.     desc->params[i].value.ui = 44100U;

  1067.     strcpy(desc->params[i].short_desc, "Sample rate");

  1068.     strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1069. 

  1070.     i++;

  1071.     strcpy(desc->params[i].name, "period");

  1072.     desc->params[i].character = 'p';

  1073.     desc->params[i].type = JackDriverParamUInt;

  1074.     desc->params[i].value.ui = 128U;

  1075.     strcpy(desc->params[i].short_desc, "Frames per period");

  1076.     strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1077. 

  1078.     i++;

  1079. 	strcpy(desc->params[i].name, "device");

  1080. 	desc->params[i].character = 'd';

  1081. 	desc->params[i].type = JackDriverParamString;

  1082. 	desc->params[i].value.ui = 128U;

  1083. 	strcpy(desc->params[i].value.str, "will take default CoreAudio device name");

  1084. 	strcpy(desc->params[i].short_desc, "CoreAudio device name");

  1085. 	strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1086. 

  1087.  	i++;

  1088. 	strcpy(desc->params[i].name, "input-latency");

  1089. 	desc->params[i].character  = 'I';

  1090. 	desc->params[i].type = JackDriverParamUInt;

  1091. 	desc->params[i].value.i = 0;

  1092. 	strcpy(desc->params[i].short_desc, "Extra input latency");

  1093. 	strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1094. 

  1095. 	i++;

  1096. 	strcpy(desc->params[i].name, "output-latency");

  1097. 	desc->params[i].character  = 'O';

  1098. 	desc->params[i].type = JackDriverParamUInt;

  1099. 	desc->params[i].value.i  = 0;

  1100. 	strcpy(desc->params[i].short_desc, "Extra output latency");

  1101. 	strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1102. 	

  1103. 	i++;

  1104. 	strcpy(desc->params[i].name, "list-devices");

  1105. 	desc->params[i].character  = 'l';

  1106. 	desc->params[i].type = JackDriverParamBool;

  1107. 	desc->params[i].value.i  = FALSE;

  1108. 	strcpy(desc->params[i].short_desc, "Display available CoreAudio devices");

  1109. 	strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1110. 	

  1111.     return desc;

  1112. }

  1113. 

  1114. jack_driver_t *driver_initialize(jack_client_t * client,

  1115. 				 const JSList * params)

  1116. {

  1117.     jack_nframes_t srate = 44100; /* Some older Mac models only support this value */

  1118.     jack_nframes_t frames_per_interrupt = 128;

  1119.     int capture = FALSE;

  1120.     int playback = FALSE;

  1121.     int chan_in = 0;

  1122.     int chan_out = 0;

  1123.     char* capture_pcm_name = "";

  1124. 	char* playback_pcm_name = "";

  1125.     const JSList *node;

  1126.     const jack_driver_param_t *param;

  1127. 	jack_nframes_t systemic_input_latency = 0;

  1128. 	jack_nframes_t systemic_output_latency = 0;

  1129. 

  1130.     for (node = params; node; node = jack_slist_next(node)) {

  1131. 	param = (const jack_driver_param_t *) node->data;

  1132. 

  1133. 	switch (param->character) {

  1134. 

  1135. 		case 'd':

  1136. 			capture_pcm_name = strdup(param->value.str);

  1137. 			playback_pcm_name = strdup(param->value.str);

  1138. 			break;

  1139. 

  1140. 		case 'D':

  1141. 			capture = TRUE;

  1142. 			playback = TRUE;

  1143. 			break;

  1144. 

  1145. 		case 'c':

  1146. 			chan_in = chan_out = (int) param->value.ui;

  1147. 			break;

  1148. 

  1149. 		case 'i':

  1150. 			chan_in = (int) param->value.ui;

  1151. 			break;

  1152. 

  1153. 		case 'o':

  1154. 			chan_out = (int) param->value.ui;

  1155. 			break;

  1156. 

  1157. 		case 'C':

  1158. 			capture = TRUE;

  1159. 			if (strcmp(param->value.str, "none") != 0) {

  1160. 				capture_pcm_name = strdup(param->value.str);

  1161. 			}

  1162. 			break;

  1163. 

  1164. 		case 'P':

  1165. 			playback = TRUE;

  1166. 			if (strcmp(param->value.str, "none") != 0) {

  1167. 				playback_pcm_name = strdup(param->value.str);

  1168. 			}

  1169. 			break;

  1170. 

  1171. 		case 'r':

  1172. 			srate = param->value.ui;

  1173. 			break;

  1174. 

  1175. 		case 'p':

  1176. 			frames_per_interrupt = (unsigned int) param->value.ui;

  1177. 			break;

  1178. 

  1179. 		case 'I':

  1180. 			systemic_input_latency = param->value.ui;

  1181. 			break;

  1182. 

  1183. 		case 'O':

  1184. 			systemic_output_latency = param->value.ui;

  1185. 			break;

  1186. 			

  1187. 		case 'l':

  1188. 			display_device_names();

  1189. 			break;

  1190. 		}

  1191.     }

  1192. 

  1193.     /* duplex is the default */

  1194.     if (!capture && !playback) {

  1195. 		capture = TRUE;

  1196. 		playback = TRUE;

  1197.     }

  1198. 	

  1199. 	return coreaudio_driver_new("coreaudio", client, frames_per_interrupt,

  1200. 								srate, capture, playback, chan_in,

  1201. 								chan_out, capture_pcm_name, playback_pcm_name, systemic_input_latency, systemic_output_latency);

  1202. }

  1203. 

  1204. void driver_finish(jack_driver_t * driver)

  1205. {

  1206.     coreaudio_driver_delete((coreaudio_driver_t *) driver);

  1207. }