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

1145 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.  

  46.  */

  47. 

  48. #include <stdio.h>

  49. #include <string.h>

  50. #include <jack/engine.h>

  51. #include "coreaudio_driver.h"

  52. 

  53. const int CAVersion = 3;

  54. 

  55. //#define PRINTDEBUG 1

  56. 

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

  58. {

  59. #ifdef PRINTDEBUG

  60.     va_list ap;

  61.     va_start(ap, fmt);

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

  63.     vfprintf(stderr, fmt, ap);

  64.     va_end(ap);

  65. #endif

  66. }

  67. 

  68. static void printError(OSStatus err)

  69. {

  70. #ifdef DEBUG

  71.     switch (err) {

  72.         case kAudioHardwareNoError:

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

  74.             break;

  75.         case kAudioHardwareNotRunningError:

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

  77.             break;

  78.         case kAudioHardwareUnspecifiedError:

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

  80.             break;

  81.         case kAudioHardwareUnknownPropertyError:

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

  83.             break;

  84.         case kAudioHardwareBadPropertySizeError:

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

  86.             break;

  87.         case kAudioHardwareIllegalOperationError:

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

  89.             break;

  90.         case kAudioHardwareBadDeviceError:

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

  92.             break;

  93.         case kAudioHardwareBadStreamError:

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

  95.             break;

  96.         case kAudioDeviceUnsupportedFormatError:

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

  98.             break;

  99.         case kAudioDevicePermissionsError:

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

  101.             break;

  102.         default:

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

  104.             break;

  105.     }

  106. #endif

  107. }

  108. 

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

  110. {

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

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

  113. 					   kAudioDevicePropertyDeviceName,

  114. 					   &size,

  115. 					   &name[0]);

  116.     return res;

  117. }

  118. 

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

  120. {

  121. 	UInt32 size = sizeof(AudioValueTranslation);

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

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

  124. 	if (inIUD == NULL) {

  125. 		return kAudioHardwareUnspecifiedError;

  126. 	} else {

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

  128. 		CFRelease(inIUD);

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

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

  131. 	}

  132. }

  133. 

  134. static OSStatus get_default_device(AudioDeviceID * id)

  135. {

  136.     OSStatus res;

  137.     UInt32 theSize = sizeof(UInt32);

  138. 	AudioDeviceID inDefault;

  139. 	AudioDeviceID outDefault;

  140.   

  141. 	if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, 

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

  143. 		return res;

  144. 	

  145. 	if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, 

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

  147. 		return res;

  148. 		

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

  150. 	

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

  152. 	if (inDefault == outDefault) {

  153. 		*id = inDefault;

  154. 		return noErr;

  155. 	} else {

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

  157. 		return kAudioHardwareBadDeviceError;

  158. 	}

  159. }

  160. 

  161. static OSStatus get_default_input_device(AudioDeviceID* id)

  162. {

  163.     OSStatus res;

  164.     UInt32 theSize = sizeof(UInt32);

  165.     AudioDeviceID inDefault;

  166.   

  167.     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice,

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

  169.         return res;

  170. 

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

  172.     *id = inDefault;

  173. 	return noErr;

  174. }

  175. 

  176. static OSStatus get_default_output_device(AudioDeviceID* id)

  177. {

  178.     OSStatus res;

  179.     UInt32 theSize = sizeof(UInt32);

  180.     AudioDeviceID outDefault;

  181. 

  182.     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice,

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

  184.         return res;

  185. 

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

  187. 	*id = outDefault;

  188. 	return noErr;

  189. }

  190. 

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

  192. {

  193.     OSStatus			err = noErr;

  194.     UInt32				outSize;

  195.     Boolean				outWritable;

  196.     AudioBufferList*	bufferList = 0;

  197. 	AudioStreamID*		streamList = 0;

  198.     int					i, numStream;

  199. 	

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

  201. 	if (err == noErr) {

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

  203. 		numStream = outSize/sizeof(AudioStreamID);

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

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

  206. 		if (err == noErr) {

  207. 			AudioStreamBasicDescription streamDesc;

  208. 			outSize = sizeof(AudioStreamBasicDescription);

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

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

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

  212. 			}

  213. 		}

  214. 	}

  215. 	

  216.     *channelCount = 0;

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

  218.     if (err == noErr) {

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

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

  221.         if (err == noErr) {								

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

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

  224.         }

  225.     }

  226. 	

  227. 	if (streamList) 

  228. 		free(streamList);

  229. 	if (bufferList) 

  230. 		free(bufferList);	

  231. 		

  232.     return err;

  233. }

  234. 

  235. 

  236. static OSStatus display_device_names()

  237. {

  238. 	UInt32 size;

  239. 	Boolean isWritable;

  240. 	int i, deviceNum;

  241. 	OSStatus err;

  242. 	CFStringRef UIname;

  243. 	

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

  245.     if (err != noErr) 

  246. 		return err;

  247. 		

  248. 	deviceNum = size/sizeof(AudioDeviceID);

  249. 	AudioDeviceID devices[deviceNum];

  250. 	

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

  252.     if (err != noErr) 

  253. 		return err;

  254. 	

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

  256.         char device_name[256];

  257. 		char internal_name[256];

  258. 		

  259. 		size = sizeof(CFStringRef);

  260. 		UIname = NULL;

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

  262. 		if (err == noErr) {

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

  264. 		} else {

  265. 			goto error;

  266. 		}

  267. 		

  268. 		size = 256;

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

  270. 		if (err != noErr) 

  271. 			return err; 

  272. 	

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

  274. 	}

  275. 	

  276. 	return noErr;

  277. 

  278. error:

  279. 	if (UIname != NULL)

  280. 		CFRelease(UIname);

  281. 	return err;

  282. }

  283. 

  284. static OSStatus render(void *inRefCon, 

  285. 						AudioUnitRenderActionFlags 	*ioActionFlags, 

  286. 						const AudioTimeStamp 		*inTimeStamp, 

  287. 						UInt32 						inBusNumber, 

  288. 						UInt32 						inNumberFrames, 

  289. 						AudioBufferList 			*ioData)

  290. 

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

  554.     coreaudio_driver_t *driver;

  555. 	OSStatus err = noErr;

  556. 	ComponentResult err1;

  557.     UInt32 outSize;

  558. 	UInt32 enableIO;

  559. 	AudioStreamBasicDescription srcFormat, dstFormat, sampleRate;

  560. 	int in_nChannels = 0;

  561. 	int out_nChannels = 0;

  562. 	int i;

  563. 	

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

  565.     jack_driver_init((jack_driver_t *) driver);

  566. 

  567.     if (!jack_power_of_two(nframes)) {

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

  569. 		goto error;

  570.     }

  571. 

  572.     driver->frames_per_cycle = nframes;

  573.     driver->frame_rate = samplerate;

  574.     driver->capturing = capturing;

  575.     driver->playing = playing;

  576. 	driver->xrun_detected = 0;

  577. 	driver->null_cycle = 0;

  578. 

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

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

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

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

  583.     driver->null_cycle =

  584. 	(JackDriverNullCycleFunction) coreaudio_driver_null_cycle;

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

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

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

  588. 	driver->capture_frame_latency = capture_latency;

  589. 	driver->playback_frame_latency = playback_latency;

  590. 	

  591. 	// Duplex

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

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

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

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

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

  597. 				goto error;

  598. 			}

  599. 		}

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

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

  602. 			goto error;

  603. 		}

  604. 		

  605. 	// Capture only

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

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

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

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

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

  611.                 goto error;

  612. 			}

  613. 		}

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

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

  616. 			goto error;

  617. 		}

  618. 		

  619.   	// Playback only

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

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

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

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

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

  625.                 goto error;

  626. 			}

  627.         }

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

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

  630. 			goto error;

  631. 		}

  632. 		

  633. 	// Use default driver in duplex mode

  634. 	} else {

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

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

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

  638. 			goto error;

  639. 		}

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

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

  642. 			goto error;

  643. 		}

  644. 	}

  645. 	

  646. 	driver->client = client;

  647.     driver->period_usecs =

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

  649. 		1000000.0f;

  650. 	

  651. 	if (capturing) {

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

  653. 		if (err != noErr) { 

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

  655. 			printError(err);

  656. 			goto error;

  657. 		} 

  658. 	}

  659. 	

  660. 	if (playing) {

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

  662. 		if (err != noErr) { 

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

  664. 			printError(err);

  665. 			goto error;

  666. 		} 

  667. 	}

  668. 	

  669. 	if (inchannels > in_nChannels) {

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

  671. 		goto error;

  672.     }

  673. 	

  674. 	if (outchannels > out_nChannels) {

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

  676. 		goto error;

  677.     }

  678. 

  679. 	if (inchannels == 0) {

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

  681. 		inchannels = in_nChannels; 

  682. 	}

  683. 		

  684. 	if (outchannels == 0) {

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

  686. 		outchannels = out_nChannels; 

  687. 	}

  688. 

  689.     // Setting buffer size

  690.     outSize = sizeof(UInt32);

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

  692.     if (err != noErr) {

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

  694.         printError(err);

  695. 		goto error;

  696.     }

  697. 

  698. 	// Set sample rate

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

  700. 		outSize = sizeof(AudioStreamBasicDescription);

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

  702. 		if (err != noErr) {

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

  704. 			printError(err);

  705. 			goto error;

  706. 		}

  707. 

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

  709. 			sampleRate.mSampleRate = (Float64)samplerate;

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

  711. 			if (err != noErr) {

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

  713. 				printError(err);

  714. 				goto error;

  715. 			}

  716. 		}

  717. 	}

  718. 	

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

  720. 		outSize = sizeof(AudioStreamBasicDescription);

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

  722. 		if (err != noErr) {

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

  724. 			printError(err);

  725. 			goto error;

  726. 		}

  727. 

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

  729. 			sampleRate.mSampleRate = (Float64)samplerate;

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

  731. 			if (err != noErr) {

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

  733. 				printError(err);

  734. 				goto error;

  735. 			}

  736. 		}

  737. 	}

  738. 

  739.     // AUHAL

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

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

  742. 

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

  744.     if (err1 != noErr) {

  745. 		jack_error("Error calling OpenAComponent");

  746.         printError(err1);

  747.         goto error;

  748. 	}

  749. 

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

  751.     if (err1 != noErr) {

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

  753. 		printError(err1);

  754.         goto error;

  755. 	}

  756. 

  757.  	// Start I/O

  758. 	enableIO = 1;

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

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

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

  762.         if (err1 != noErr) {

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

  764.             printError(err1);

  765.             goto error;

  766.         }

  767.     }

  768. 	

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

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

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

  772. 		if (err1 != noErr) {

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

  774. 			printError(err1);

  775. 			goto error;

  776. 		}

  777. 	}

  778. 	

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

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

  781. 	if (err1 != noErr) {

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

  783. 		printError(err1);

  784. 		goto error;

  785. 	}

  786. 

  787. 	// Set buffer size

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

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

  790. 		if (err1 != noErr) {

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

  792. 			printError(err1);

  793. 			goto error;

  794. 		}

  795. 	}

  796. 	

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

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

  799. 		if (err1 != noErr) {

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

  801. 			printError(err1);

  802. 			goto error;

  803. 		}

  804. 	}

  805. 

  806. 	// Setup channel map

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

  808.         SInt32 chanArr[in_nChannels];

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

  810.             chanArr[i] = -1;

  811.         }

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

  813.             chanArr[i] = i;

  814.         }

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

  816.         if (err1 != noErr) {

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

  818.             printError(err1);

  819.         }

  820.     }

  821. 

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

  823.         SInt32 chanArr[out_nChannels];

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

  825.             chanArr[i] = -1;

  826.         }

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

  828.             chanArr[i] = i;

  829.         }

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

  831.         if (err1 != noErr) {

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

  833.             printError(err1);

  834.         }

  835.     }

  836. 

  837. 	// Setup stream converters

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

  839. 		srcFormat.mSampleRate = samplerate;

  840. 		srcFormat.mFormatID = kAudioFormatLinearPCM;

  841. 		srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  842. 		srcFormat.mBytesPerPacket = sizeof(float);

  843. 		srcFormat.mFramesPerPacket = 1;

  844. 		srcFormat.mBytesPerFrame = sizeof(float);

  845. 		srcFormat.mChannelsPerFrame = outchannels;

  846. 		srcFormat.mBitsPerChannel = 32;

  847. 

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

  849. 		if (err1 != noErr) {

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

  851. 			printError(err1);

  852. 		}

  853. 	}

  854. 

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

  856. 		dstFormat.mSampleRate = samplerate;

  857. 		dstFormat.mFormatID = kAudioFormatLinearPCM;

  858. 		dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  859. 		dstFormat.mBytesPerPacket = sizeof(float);

  860. 		dstFormat.mFramesPerPacket = 1;

  861. 		dstFormat.mBytesPerFrame = sizeof(float);

  862. 		dstFormat.mChannelsPerFrame = inchannels;

  863. 		dstFormat.mBitsPerChannel = 32;

  864. 

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

  866. 		if (err1 != noErr) {

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

  868. 			printError(err1);

  869. 		}

  870. 	}

  871. 

  872. 	// Setup callbacks

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

  874.         AURenderCallbackStruct output;

  875.         output.inputProc = render_input;

  876.         output.inputProcRefCon = driver;

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

  878.         if (err1 != noErr) {

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

  880.             printError(err1);

  881.             goto error;

  882.         }

  883.     } else {

  884.         AURenderCallbackStruct output;

  885.         output.inputProc = render;

  886.         output.inputProcRefCon = driver;

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

  888.         if (err1 != noErr) {

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

  890.             printError(err1);

  891.             goto error;

  892.         }

  893.     }

  894. 

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

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

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

  898. 			goto error;

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

  900. 		

  901. 		// Prepare buffers

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

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

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

  905. 		}

  906. 	}

  907. 

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

  909.     if (err != noErr)

  910.         goto error;

  911.  

  912. 	driver->playback_nchannels = outchannels;

  913.     driver->capture_nchannels = inchannels;

  914. 	return ((jack_driver_t *) driver);

  915. 

  916.   error:

  917. 	AudioUnitUninitialize(driver->au_hal);

  918. 	CloseComponent(driver->au_hal);

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

  920.     free(driver);

  921.     return NULL;

  922. }

  923. 

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

  925. */

  926. static void coreaudio_driver_delete(coreaudio_driver_t * driver)

  927. {

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

  929.     free(driver->input_list);

  930.  	AudioUnitUninitialize(driver->au_hal);

  931. 	CloseComponent(driver->au_hal);

  932.     free(driver);

  933. }

  934. 

  935. //== driver "plugin" interface =================================================

  936. 

  937. /* DRIVER "PLUGIN" INTERFACE */

  938. 

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

  940. 

  941. jack_driver_desc_t *driver_get_descriptor()

  942. {

  943.     jack_driver_desc_t *desc;

  944.     unsigned int i;

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

  946. 

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

  948.     desc->nparams = 12;

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

  950. 

  951.     i = 0;

  952.     strcpy(desc->params[i].name, "channel");

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

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

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

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

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

  958. 

  959.     i++;

  960.     strcpy(desc->params[i].name, "channelin");

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

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

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

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

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

  966. 

  967.     i++;

  968.     strcpy(desc->params[i].name, "channelout");

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

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

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

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

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

  974. 

  975.     i++;

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

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

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

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

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

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

  982. 

  983. 	i++;

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

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

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

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

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

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

  990. 

  991.     i++;

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

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

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

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

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

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

  998. 

  999.     i++;

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

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

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

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

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

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

  1006. 

  1007.     i++;

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

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

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

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

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

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

  1014. 

  1015.     i++;

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

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

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

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

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

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

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

  1023. 

  1024.  	i++;

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

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

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

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

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

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

  1031. 

  1032. 	i++;

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

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

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

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

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

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

  1039. 	

  1040. 	i++;

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

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

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

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

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

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

  1047. 	

  1048.     return desc;

  1049. }

  1050. 

  1051. jack_driver_t *driver_initialize(jack_client_t * client,

  1052. 				 const JSList * params)

  1053. {

  1054.     jack_nframes_t srate = 44100;

  1055.     jack_nframes_t frames_per_interrupt = 128;

  1056.     int capture = FALSE;

  1057.     int playback = FALSE;

  1058.     int chan_in = 0;

  1059.     int chan_out = 0;

  1060.     char* capture_pcm_name = NULL;

  1061. 	char* playback_pcm_name = NULL;

  1062.     const JSList *node;

  1063.     const jack_driver_param_t *param;

  1064. 	jack_nframes_t systemic_input_latency = 0;

  1065. 	jack_nframes_t systemic_output_latency = 0;

  1066. 

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

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

  1069. 

  1070. 	switch (param->character) {

  1071. 

  1072. 		case 'n':

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

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

  1075. 			break;

  1076. 

  1077. 		case 'D':

  1078. 			capture = TRUE;

  1079. 			playback = TRUE;

  1080. 			break;

  1081. 

  1082. 		case 'c':

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

  1084. 			break;

  1085. 

  1086. 		case 'i':

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

  1088. 			break;

  1089. 

  1090. 		case 'o':

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

  1092. 			break;

  1093. 

  1094. 		case 'C':

  1095. 			capture = TRUE;

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

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

  1098. 			}

  1099. 			break;

  1100. 

  1101. 		case 'P':

  1102. 			playback = TRUE;

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

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

  1105. 			}

  1106. 			break;

  1107. 

  1108. 		case 'r':

  1109. 			srate = param->value.ui;

  1110. 			break;

  1111. 

  1112. 		case 'p':

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

  1114. 			break;

  1115. 

  1116. 		case 'I':

  1117. 			systemic_input_latency = param->value.ui;

  1118. 			break;

  1119. 

  1120. 		case 'O':

  1121. 			systemic_output_latency = param->value.ui;

  1122. 			break;

  1123. 			

  1124. 		case 'd':

  1125. 			display_device_names();

  1126. 			break;

  1127. 		}

  1128.     }

  1129. 

  1130.     /* duplex is the default */

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

  1132. 		capture = TRUE;

  1133. 		playback = TRUE;

  1134.     }

  1135. 	

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

  1137. 				srate, capture, playback, chan_in,

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

  1139. }

  1140. 

  1141. void driver_finish(jack_driver_t * driver)

  1142. {

  1143.     coreaudio_driver_delete((coreaudio_driver_t *) driver);

  1144. }