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.
708 Commits
4 Branches
14MB
Tree: 9ada7a19d3
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9ada7a19d3'
${ noResults }
jack1/drivers/coreaudio/coreaudio_driver.c

1144 lines
39KB
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.  */

  49. 

  50. #include <stdio.h>

  51. #include <string.h>

  52. #include <jack/engine.h>

  53. #include "coreaudio_driver.h"

  54. 

  55. const int CAVersion = 3;

  56. 

  57. //#define PRINTDEBUG 1

  58. 

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

  60. {

  61. #ifdef PRINTDEBUG

  62.     va_list ap;

  63.     va_start(ap, fmt);

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

  65.     vfprintf(stderr, fmt, ap);

  66.     va_end(ap);

  67. #endif

  68. }

  69. 

  70. static void printError(OSStatus err)

  71. {

  72. #ifdef DEBUG

  73.     switch (err) {

  74.         case kAudioHardwareNoError:

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

  76.             break;

  77.         case kAudioHardwareNotRunningError:

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

  79.             break;

  80.         case kAudioHardwareUnspecifiedError:

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

  82.             break;

  83.         case kAudioHardwareUnknownPropertyError:

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

  85.             break;

  86.         case kAudioHardwareBadPropertySizeError:

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

  88.             break;

  89.         case kAudioHardwareIllegalOperationError:

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

  91.             break;

  92.         case kAudioHardwareBadDeviceError:

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

  94.             break;

  95.         case kAudioHardwareBadStreamError:

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

  97.             break;

  98.         case kAudioDeviceUnsupportedFormatError:

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

  100.             break;

  101.         case kAudioDevicePermissionsError:

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

  103.             break;

  104.         default:

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

  106.             break;

  107.     }

  108. #endif

  109. }

  110. 

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

  112. {

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

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

  115. 					   kAudioDevicePropertyDeviceName,

  116. 					   &size,

  117. 					   &name[0]);

  118.     return res;

  119. }

  120. 

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

  122. {

  123. 	UInt32 size = sizeof(AudioValueTranslation);

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

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

  126. 	if (inIUD == NULL) {

  127. 		return kAudioHardwareUnspecifiedError;

  128. 	} else {

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

  130. 		CFRelease(inIUD);

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

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

  133. 	}

  134. }

  135. 

  136. static OSStatus get_default_device(AudioDeviceID * id)

  137. {

  138.     OSStatus res;

  139.     UInt32 theSize = sizeof(UInt32);

  140. 	AudioDeviceID inDefault;

  141. 	AudioDeviceID outDefault;

  142.   

  143. 	if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, 

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

  145. 		return res;

  146. 	

  147. 	if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, 

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

  149. 		return res;

  150. 		

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

  152. 	

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

  154. 	if (inDefault == outDefault) {

  155. 		*id = inDefault;

  156. 		return noErr;

  157. 	} else {

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

  159. 		return kAudioHardwareBadDeviceError;

  160. 	}

  161. }

  162. 

  163. static OSStatus get_default_input_device(AudioDeviceID* id)

  164. {

  165.     OSStatus res;

  166.     UInt32 theSize = sizeof(UInt32);

  167.     AudioDeviceID inDefault;

  168.   

  169.     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice,

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

  171.         return res;

  172. 

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

  174.     *id = inDefault;

  175. 	return noErr;

  176. }

  177. 

  178. static OSStatus get_default_output_device(AudioDeviceID* id)

  179. {

  180.     OSStatus res;

  181.     UInt32 theSize = sizeof(UInt32);

  182.     AudioDeviceID outDefault;

  183. 

  184.     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice,

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

  186.         return res;

  187. 

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

  189. 	*id = outDefault;

  190. 	return noErr;

  191. }

  192. 

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

  194. {

  195.     OSStatus			err = noErr;

  196.     UInt32				outSize;

  197.     Boolean				outWritable;

  198.     AudioBufferList*	bufferList = 0;

  199. 	AudioStreamID*		streamList = 0;

  200.     int					i, numStream;

  201. 	

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

  203. 	if (err == noErr) {

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

  205. 		numStream = outSize/sizeof(AudioStreamID);

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

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

  208. 		if (err == noErr) {

  209. 			AudioStreamBasicDescription streamDesc;

  210. 			outSize = sizeof(AudioStreamBasicDescription);

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

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

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

  214. 			}

  215. 		}

  216. 	}

  217. 	

  218.     *channelCount = 0;

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

  220.     if (err == noErr) {

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

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

  223.         if (err == noErr) {								

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

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

  226.         }

  227.     }

  228. 	

  229. 	if (streamList) 

  230. 		free(streamList);

  231. 	if (bufferList) 

  232. 		free(bufferList);	

  233. 		

  234.     return err;

  235. }

  236. 

  237. static OSStatus display_device_names()

  238. {

  239. 	UInt32 size;

  240. 	Boolean isWritable;

  241. 	int i, deviceNum;

  242. 	OSStatus err;

  243. 	CFStringRef UIname;

  244. 	

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

  246.     if (err != noErr) 

  247. 		return err;

  248. 		

  249. 	deviceNum = size/sizeof(AudioDeviceID);

  250. 	AudioDeviceID devices[deviceNum];

  251. 	

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

  253.     if (err != noErr) 

  254. 		return err;

  255. 	

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

  257.         char device_name[256];

  258. 		char internal_name[256];

  259. 		

  260. 		size = sizeof(CFStringRef);

  261. 		UIname = NULL;

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

  263. 		if (err == noErr) {

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

  265. 		} else {

  266. 			goto error;

  267. 		}

  268. 		

  269. 		size = 256;

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

  271. 		if (err != noErr) 

  272. 			return err; 

  273. 	

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

  275. 	}

  276. 	

  277. 	return noErr;

  278. 

  279. error:

  280. 	if (UIname != NULL)

  281. 		CFRelease(UIname);

  282. 	return err;

  283. }

  284. 

  285. static OSStatus render(void *inRefCon, 

  286. 						AudioUnitRenderActionFlags 	*ioActionFlags, 

  287. 						const AudioTimeStamp 		*inTimeStamp, 

  288. 						UInt32 						inBusNumber, 

  289. 						UInt32 						inNumberFrames, 

  290. 						AudioBufferList 			*ioData)

  291. {

  292. 	int res, i;

  293. 	JSList *node;

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

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

  296. 	

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

  298. 		jack_time_t current_time = jack_get_microseconds();

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

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

  301. 		ca_driver->last_wait_ust = current_time;

  302. 		ca_driver->xrun_detected = 0;

  303. 		return 0;

  304.     } else {

  305. 		ca_driver->last_wait_ust = jack_get_microseconds();

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

  307. 					  jack_get_microseconds());

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

  309. 	}

  310. 	

  311. 	if (ca_driver->null_cycle_occured) {

  312. 		ca_driver->null_cycle_occured = 0;

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

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

  315. 		}

  316. 	} else {

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

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

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

  320. 					sizeof(float) * inNumberFrames);

  321. 		}

  322. 	}

  323. 	

  324. 	return res;

  325. }

  326. 

  327. static OSStatus render_input(void *inRefCon, 

  328. 							AudioUnitRenderActionFlags 	*ioActionFlags, 

  329. 							const AudioTimeStamp 		*inTimeStamp, 

  330. 							UInt32 						inBusNumber, 

  331. 							UInt32 						inNumberFrames, 

  332. 							AudioBufferList 			*ioData)

  333. 

  334. {

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

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

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

  338. 		jack_time_t current_time = jack_get_microseconds();

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

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

  341. 		ca_driver->last_wait_ust = current_time;

  342. 		ca_driver->xrun_detected = 0;

  343. 		return 0;

  344.     } else {

  345. 		ca_driver->last_wait_ust = jack_get_microseconds();

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

  347. 					  jack_get_microseconds());

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

  349. 	}

  350. }

  351. 

  352. static OSStatus notification(AudioDeviceID inDevice,

  353. 							UInt32 inChannel,

  354. 							Boolean	isInput,

  355. 							AudioDevicePropertyID inPropertyID,

  356. 							void* inClientData)

  357. {

  358.     coreaudio_driver_t* ca_driver = (coreaudio_driver_t*)inClientData;

  359.     if (inPropertyID == kAudioDeviceProcessorOverload) {

  360. 		ca_driver->xrun_detected = 1;

  361.     }

  362.     return noErr;

  363. }

  364. 

  365. static int

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

  367. {

  368.     jack_port_t *port;

  369. 	JSList *node;

  370.     int port_flags;

  371.     channel_t chn;

  372.     char buf[JACK_PORT_NAME_SIZE];

  373. 	char channel_name[64];

  374. 	OSStatus err;

  375. 	UInt32 size;

  376. 	UInt32 value1,value2;

  377.     Boolean isWritable;

  378. 	

  379.     driver->engine = engine;

  380. 

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

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

  383. 

  384.     port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

  385. 

  386.     /*

  387.        if (driver->has_hw_monitoring) {

  388. 			port_flags |= JackPortCanMonitor;

  389.        }

  390. 	*/

  391. 

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

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

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

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

  396. 			if (err != noErr) 

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

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

  399. 		} else {

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

  401. 		}

  402. 	

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

  404. 					JACK_DEFAULT_AUDIO_TYPE, port_flags,

  405. 					0)) == NULL) {

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

  407. 			break;

  408. 		}

  409. 

  410. 		size = sizeof(UInt32);

  411. 		value1 = value2 = 0;

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

  413. 		if (err != noErr) 

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

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

  416. 		if (err != noErr) 

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

  418. 		

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

  420. 		driver->capture_ports =

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

  422.     }

  423. 

  424.     port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  425. 

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

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

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

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

  430. 			if (err != noErr) 

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

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

  433. 		} else {

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

  435. 		}

  436. 

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

  438. 					JACK_DEFAULT_AUDIO_TYPE, port_flags,

  439. 					0)) == NULL) {

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

  441. 			break;

  442. 		}

  443. 

  444. 		size = sizeof(UInt32);

  445. 		value1 = value2 = 0;

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

  447. 		if (err != noErr) 

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

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

  450. 		if (err != noErr) 

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

  452. 	

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

  454. 		driver->playback_ports =

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

  456. 	}

  457. 	

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

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

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

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

  462.     }

  463. 

  464.     jack_activate(driver->client);

  465.     return 0;

  466. }

  467. 

  468. static int

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

  470. {

  471.     JSList *node;

  472. 

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

  474. 		return -1;

  475.     }

  476. 

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

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

  479.     }

  480. 

  481.     jack_slist_free(driver->capture_ports);

  482.     driver->capture_ports = 0;

  483. 

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

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

  486.     }

  487. 

  488.     jack_slist_free(driver->playback_ports);

  489.     driver->playback_ports = 0;

  490. 

  491.     driver->engine = 0;

  492.     return 0;

  493. }

  494. 

  495. static int

  496. coreaudio_driver_null_cycle(coreaudio_driver_t * driver, jack_nframes_t nframes)

  497. {

  498. 	driver->null_cycle_occured = 1;

  499.     return 0;

  500. }

  501. 

  502. static int

  503. coreaudio_driver_read(coreaudio_driver_t * driver, jack_nframes_t nframes)

  504. {

  505.     return 0;

  506. }

  507. 

  508. static int

  509. coreaudio_driver_write(coreaudio_driver_t * driver, jack_nframes_t nframes)

  510. {

  511. 	return 0;

  512. }

  513. 

  514. static int coreaudio_driver_audio_start(coreaudio_driver_t * driver)

  515. {

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

  517. }

  518. 

  519. static int coreaudio_driver_audio_stop(coreaudio_driver_t * driver)

  520. {

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

  522. }

  523. 

  524. static int

  525. coreaudio_driver_bufsize(coreaudio_driver_t * driver,

  526. 			 jack_nframes_t nframes)

  527. {

  528. 

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

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

  531.      * also stops that thread. */

  532. 	/*

  533. 	TO DO

  534. 	*/

  535. 	return 0;

  536. }

  537. 

  538. /** create a new driver instance

  539. */

  540. static jack_driver_t *coreaudio_driver_new(char* name,

  541. 										   jack_client_t* client,

  542. 										   jack_nframes_t nframes,

  543. 										   jack_nframes_t samplerate,

  544. 										   int capturing,

  545. 										   int playing,

  546. 										   int inchannels,

  547. 										   int outchannels,

  548. 										   char* capture_driver_uid,

  549. 										   char* playback_driver_uid,

  550. 										   jack_nframes_t capture_latency, 

  551. 										   jack_nframes_t playback_latency)

  552. {

  553.     coreaudio_driver_t *driver;

  554. 	OSStatus err = noErr;

  555. 	ComponentResult err1;

  556.     UInt32 outSize;

  557. 	UInt32 enableIO;

  558. 	AudioStreamBasicDescription srcFormat, dstFormat, sampleRate;

  559. 	int in_nChannels = 0;

  560. 	int out_nChannels = 0;

  561. 	int i;

  562. 	

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

  564.     jack_driver_init((jack_driver_t *) driver);

  565. 

  566.     if (!jack_power_of_two(nframes)) {

  567. 		fprintf(stderr, "CA: -p must be a power of two.\n");

  568. 		goto error;

  569.     }

  570. 

  571.     driver->frames_per_cycle = nframes;

  572.     driver->frame_rate = samplerate;

  573.     driver->capturing = capturing;

  574.     driver->playing = playing;

  575. 	driver->xrun_detected = 0;

  576. 	driver->null_cycle = 0;

  577. 

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

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

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

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

  582.     driver->null_cycle =

  583. 	(JackDriverNullCycleFunction) coreaudio_driver_null_cycle;

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

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

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

  587. 	driver->capture_frame_latency = capture_latency;

  588. 	driver->playback_frame_latency = playback_latency;

  589. 	

  590. 	// Duplex

  591.     if (capture_driver_uid != NULL && playback_driver_uid != NULL) {

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

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

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

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

  596. 				goto error;

  597. 			}

  598. 		}

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

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

  601. 			goto error;

  602. 		}

  603. 		

  604. 	// Capture only

  605. 	} else if (capture_driver_uid != NULL) {

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

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

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

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

  610.                 goto error;

  611. 			}

  612. 		}

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

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

  615. 			goto error;

  616. 		}

  617. 		

  618.   	// Playback only

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

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

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

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

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

  624.                 goto error;

  625. 			}

  626.         }

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

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

  629. 			goto error;

  630. 		}

  631. 		

  632. 	// Use default driver in duplex mode

  633. 	} else {

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

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

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

  637. 			goto error;

  638. 		}

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

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

  641. 			goto error;

  642. 		}

  643. 	}

  644. 	

  645. 	driver->client = client;

  646.     driver->period_usecs =

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

  648. 		1000000.0f;

  649. 	

  650. 	if (capturing) {

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

  652. 		if (err != noErr) { 

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

  654. 			printError(err);

  655. 			goto error;

  656. 		} 

  657. 	}

  658. 	

  659. 	if (playing) {

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

  661. 		if (err != noErr) { 

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

  663. 			printError(err);

  664. 			goto error;

  665. 		} 

  666. 	}

  667. 	

  668. 	if (inchannels > in_nChannels) {

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

  670. 		goto error;

  671.     }

  672. 	

  673. 	if (outchannels > out_nChannels) {

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

  675. 		goto error;

  676.     }

  677. 

  678. 	if (inchannels == 0) {

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

  680. 		inchannels = in_nChannels; 

  681. 	}

  682. 		

  683. 	if (outchannels == 0) {

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

  685. 		outchannels = out_nChannels; 

  686. 	}

  687. 

  688.     // Setting buffer size

  689.     outSize = sizeof(UInt32);

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

  691.     if (err != noErr) {

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

  693.         printError(err);

  694. 		goto error;

  695.     }

  696. 

  697. 	// Set sample rate

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

  699. 		outSize = sizeof(AudioStreamBasicDescription);

  700. 		err = AudioDeviceGetProperty(driver->device_id, 0, true, kAudioDevicePropertyStreamFormat, &outSize, &sampleRate);

  701. 		if (err != noErr) {

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

  703. 			printError(err);

  704. 			goto error;

  705. 		}

  706. 

  707. 		if (samplerate != (unsigned long)sampleRate.mSampleRate) {

  708. 			sampleRate.mSampleRate = (Float64)samplerate;

  709. 			err = AudioDeviceSetProperty(driver->device_id, NULL, 0, true, kAudioDevicePropertyStreamFormat, outSize, &sampleRate);

  710. 			if (err != noErr) {

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

  712. 				printError(err);

  713. 				goto error;

  714. 			}

  715. 		}

  716. 	}

  717. 	

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

  719. 		outSize = sizeof(AudioStreamBasicDescription);

  720. 		err = AudioDeviceGetProperty(driver->device_id, 0, false, kAudioDevicePropertyStreamFormat, &outSize, &sampleRate);

  721. 		if (err != noErr) {

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

  723. 			printError(err);

  724. 			goto error;

  725. 		}

  726. 

  727. 		if (samplerate != (unsigned long)sampleRate.mSampleRate) {

  728. 			sampleRate.mSampleRate = (Float64)samplerate;

  729. 			err = AudioDeviceSetProperty(driver->device_id, NULL, 0, false, kAudioDevicePropertyStreamFormat, outSize, &sampleRate);

  730. 			if (err != noErr) {

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

  732. 				printError(err);

  733. 				goto error;

  734. 			}

  735. 		}

  736. 	}

  737. 

  738.     // AUHAL

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

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

  741. 

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

  743.     if (err1 != noErr) {

  744. 		jack_error("Error calling OpenAComponent");

  745.         printError(err1);

  746.         goto error;

  747. 	}

  748. 

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

  750.     if (err1 != noErr) {

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

  752. 		printError(err1);

  753.         goto error;

  754. 	}

  755. 

  756.  	// Start I/O

  757. 	enableIO = 1;

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

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

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

  761.         if (err1 != noErr) {

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

  763.             printError(err1);

  764.             goto error;

  765.         }

  766.     }

  767. 	

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

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

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

  771. 		if (err1 != noErr) {

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

  773. 			printError(err1);

  774. 			goto error;

  775. 		}

  776. 	}

  777. 	

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

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

  780. 	if (err1 != noErr) {

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

  782. 		printError(err1);

  783. 		goto error;

  784. 	}

  785. 

  786. 	// Set buffer size

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

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

  789. 		if (err1 != noErr) {

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

  791. 			printError(err1);

  792. 			goto error;

  793. 		}

  794. 	}

  795. 	

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

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

  798. 		if (err1 != noErr) {

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

  800. 			printError(err1);

  801. 			goto error;

  802. 		}

  803. 	}

  804. 

  805. 	// Setup channel map

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

  807.         SInt32 chanArr[in_nChannels];

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

  809.             chanArr[i] = -1;

  810.         }

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

  812.             chanArr[i] = i;

  813.         }

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

  815.         if (err1 != noErr) {

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

  817.             printError(err1);

  818.         }

  819.     }

  820. 

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

  822.         SInt32 chanArr[out_nChannels];

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

  824.             chanArr[i] = -1;

  825.         }

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

  827.             chanArr[i] = i;

  828.         }

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

  830.         if (err1 != noErr) {

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

  832.             printError(err1);

  833.         }

  834.     }

  835. 

  836. 	// Setup stream converters

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

  838. 		srcFormat.mSampleRate = samplerate;

  839. 		srcFormat.mFormatID = kAudioFormatLinearPCM;

  840. 		srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  841. 		srcFormat.mBytesPerPacket = sizeof(float);

  842. 		srcFormat.mFramesPerPacket = 1;

  843. 		srcFormat.mBytesPerFrame = sizeof(float);

  844. 		srcFormat.mChannelsPerFrame = outchannels;

  845. 		srcFormat.mBitsPerChannel = 32;

  846. 

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

  848. 		if (err1 != noErr) {

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

  850. 			printError(err1);

  851. 		}

  852. 	}

  853. 

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

  855. 		dstFormat.mSampleRate = samplerate;

  856. 		dstFormat.mFormatID = kAudioFormatLinearPCM;

  857. 		dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  858. 		dstFormat.mBytesPerPacket = sizeof(float);

  859. 		dstFormat.mFramesPerPacket = 1;

  860. 		dstFormat.mBytesPerFrame = sizeof(float);

  861. 		dstFormat.mChannelsPerFrame = inchannels;

  862. 		dstFormat.mBitsPerChannel = 32;

  863. 

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

  865. 		if (err1 != noErr) {

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

  867. 			printError(err1);

  868. 		}

  869. 	}

  870. 

  871. 	// Setup callbacks

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

  873.         AURenderCallbackStruct output;

  874.         output.inputProc = render_input;

  875.         output.inputProcRefCon = driver;

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

  877.         if (err1 != noErr) {

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

  879.             printError(err1);

  880.             goto error;

  881.         }

  882.     } else {

  883.         AURenderCallbackStruct output;

  884.         output.inputProc = render;

  885.         output.inputProcRefCon = driver;

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

  887.         if (err1 != noErr) {

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

  889.             printError(err1);

  890.             goto error;

  891.         }

  892.     }

  893. 

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

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

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

  897. 			goto error;

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

  899. 		

  900. 		// Prepare buffers

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

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

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

  904. 		}

  905. 	}

  906. 

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

  908.     if (err != noErr)

  909.         goto error;

  910.  

  911. 	driver->playback_nchannels = outchannels;

  912.     driver->capture_nchannels = inchannels;

  913. 	return ((jack_driver_t *) driver);

  914. 

  915.   error:

  916. 	AudioUnitUninitialize(driver->au_hal);

  917. 	CloseComponent(driver->au_hal);

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

  919.     free(driver);

  920.     return NULL;

  921. }

  922. 

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

  924. */

  925. static void coreaudio_driver_delete(coreaudio_driver_t * driver)

  926. {

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

  928.     free(driver->input_list);

  929.  	AudioUnitUninitialize(driver->au_hal);

  930. 	CloseComponent(driver->au_hal);

  931.     free(driver);

  932. }

  933. 

  934. //== driver "plugin" interface =================================================

  935. 

  936. /* DRIVER "PLUGIN" INTERFACE */

  937. 

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

  939. 

  940. jack_driver_desc_t *driver_get_descriptor()

  941. {

  942.     jack_driver_desc_t *desc;

  943.     unsigned int i;

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

  945. 

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

  947.     desc->nparams = 12;

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

  949. 

  950.     i = 0;

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

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

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

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

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

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

  957. 

  958.     i++;

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

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

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

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

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

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

  965. 

  966.     i++;

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

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

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

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

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

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

  973. 

  974.     i++;

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

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

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

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

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

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

  981. 

  982. 	i++;

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

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

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

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

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

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

  989. 

  990.     i++;

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

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

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

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

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

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

  997. 

  998.     i++;

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

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

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

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

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

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

  1005. 

  1006.     i++;

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

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

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

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

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

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

  1013. 

  1014.     i++;

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

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

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

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

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

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

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

  1022. 

  1023.  	i++;

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

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

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

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

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

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

  1030. 

  1031. 	i++;

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

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

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

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

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

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

  1038. 	

  1039. 	i++;

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

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

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

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

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

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

  1046. 	

  1047.     return desc;

  1048. }

  1049. 

  1050. jack_driver_t *driver_initialize(jack_client_t * client,

  1051. 				 const JSList * params)

  1052. {

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

  1054.     jack_nframes_t frames_per_interrupt = 128;

  1055.     int capture = FALSE;

  1056.     int playback = FALSE;

  1057.     int chan_in = 0;

  1058.     int chan_out = 0;

  1059.     char* capture_pcm_name = NULL;

  1060. 	char* playback_pcm_name = NULL;

  1061.     const JSList *node;

  1062.     const jack_driver_param_t *param;

  1063. 	jack_nframes_t systemic_input_latency = 0;

  1064. 	jack_nframes_t systemic_output_latency = 0;

  1065. 

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

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

  1068. 

  1069. 	switch (param->character) {

  1070. 

  1071. 		case 'd':

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

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

  1074. 			break;

  1075. 

  1076. 		case 'D':

  1077. 			capture = TRUE;

  1078. 			playback = TRUE;

  1079. 			break;

  1080. 

  1081. 		case 'c':

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

  1083. 			break;

  1084. 

  1085. 		case 'i':

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

  1087. 			break;

  1088. 

  1089. 		case 'o':

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

  1091. 			break;

  1092. 

  1093. 		case 'C':

  1094. 			capture = TRUE;

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

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

  1097. 			}

  1098. 			break;

  1099. 

  1100. 		case 'P':

  1101. 			playback = TRUE;

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

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

  1104. 			}

  1105. 			break;

  1106. 

  1107. 		case 'r':

  1108. 			srate = param->value.ui;

  1109. 			break;

  1110. 

  1111. 		case 'p':

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

  1113. 			break;

  1114. 

  1115. 		case 'I':

  1116. 			systemic_input_latency = param->value.ui;

  1117. 			break;

  1118. 

  1119. 		case 'O':

  1120. 			systemic_output_latency = param->value.ui;

  1121. 			break;

  1122. 			

  1123. 		case 'l':

  1124. 			display_device_names();

  1125. 			break;

  1126. 		}

  1127.     }

  1128. 

  1129.     /* duplex is the default */

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

  1131. 		capture = TRUE;

  1132. 		playback = TRUE;

  1133.     }

  1134. 	

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

  1136. 				srate, capture, playback, chan_in,

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

  1138. }

  1139. 

  1140. void driver_finish(jack_driver_t * driver)

  1141. {

  1142.     coreaudio_driver_delete((coreaudio_driver_t *) driver);

  1143. }