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

1124 lines
38KB
Raw Blame History 

  1. /*

  2.  Copyright � Grame, 2003.

  3.  Copyright � Johnny Petrantoni, 2003.

  4.  

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

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

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

  8.  (at your option) any later version.

  9.  

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

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

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

  13.  GNU General Public License for more details.

  14.  

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

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

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

  18.  

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

  20.  grame@rd.grame.fr

  21. 	

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

  23.  

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  49.  */

  50. 

  51. #include <stdio.h>

  52. #include <string.h>

  53. #include <jack/engine.h>

  54. #include "coreaudio_driver.h"

  55. 

  56. const int CAVersion = 3;

  57. 

  58. //#define PRINTDEBUG 1

  59. 

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

  61. {

  62. #ifdef PRINTDEBUG

  63.     va_list ap;

  64.     va_start(ap, fmt);

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

  66.     vfprintf(stderr, fmt, ap);

  67.     va_end(ap);

  68. #endif

  69. }

  70. 

  71. static void printError(OSStatus err)

  72. {

  73. #ifdef DEBUG

  74.     switch (err) {

  75.         case kAudioHardwareNoError:

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

  77.             break;

  78.         case kAudioHardwareNotRunningError:

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

  80.             break;

  81.         case kAudioHardwareUnspecifiedError:

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

  83.             break;

  84.         case kAudioHardwareUnknownPropertyError:

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

  86.             break;

  87.         case kAudioHardwareBadPropertySizeError:

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

  89.             break;

  90.         case kAudioHardwareIllegalOperationError:

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

  92.             break;

  93.         case kAudioHardwareBadDeviceError:

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

  95.             break;

  96.         case kAudioHardwareBadStreamError:

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

  98.             break;

  99.         case kAudioDeviceUnsupportedFormatError:

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

  101.             break;

  102.         case kAudioDevicePermissionsError:

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

  104.             break;

  105.         default:

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

  107.             break;

  108.     }

  109. #endif

  110. }

  111. 

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

  113. {

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

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

  116. 					   kAudioDevicePropertyDeviceName,

  117. 					   &size,

  118. 					   &name[0]);

  119.     return res;

  120. }

  121. 

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

  123. {

  124. 	UInt32 size = sizeof(AudioValueTranslation);

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

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

  127. 	if (inIUD == NULL) {

  128. 		return kAudioHardwareUnspecifiedError;

  129. 	} else {

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

  131. 		CFRelease(inIUD);

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

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

  134. 	}

  135. }

  136. 

  137. static OSStatus get_default_device(AudioDeviceID * id)

  138. {

  139.     OSStatus res;

  140.     UInt32 theSize = sizeof(UInt32);

  141. 	AudioDeviceID inDefault;

  142. 	AudioDeviceID outDefault;

  143.   

  144. 	if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, 

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

  146. 		return res;

  147. 	

  148. 	if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, 

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

  150. 		return res;

  151. 		

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

  153. 	

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

  155. 	if (inDefault == outDefault) {

  156. 		*id = inDefault;

  157. 		return noErr;

  158. 	} else {

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

  160. 		return kAudioHardwareBadDeviceError;

  161. 	}

  162. }

  163. 

  164. static OSStatus get_default_input_device(AudioDeviceID* id)

  165. {

  166.     OSStatus res;

  167.     UInt32 theSize = sizeof(UInt32);

  168.     AudioDeviceID inDefault;

  169.   

  170.     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice,

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

  172.         return res;

  173. 

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

  175.     *id = inDefault;

  176. 	return noErr;

  177. }

  178. 

  179. static OSStatus get_default_output_device(AudioDeviceID* id)

  180. {

  181.     OSStatus res;

  182.     UInt32 theSize = sizeof(UInt32);

  183.     AudioDeviceID outDefault;

  184. 

  185.     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice,

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

  187.         return res;

  188. 

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

  190. 	*id = outDefault;

  191. 	return noErr;

  192. }

  193. 

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

  195. {

  196.     OSStatus			err = noErr;

  197.     UInt32				outSize;

  198.     Boolean				outWritable;

  199.     AudioBufferList*	bufferList = 0;

  200. 	AudioStreamID*		streamList = 0;

  201.     int					i, numStream;

  202. 	

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

  204. 	if (err == noErr) {

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

  206. 		numStream = outSize/sizeof(AudioStreamID);

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

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

  209. 		if (err == noErr) {

  210. 			AudioStreamBasicDescription streamDesc;

  211. 			outSize = sizeof(AudioStreamBasicDescription);

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

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

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

  215. 			}

  216. 		}

  217. 	}

  218. 	

  219.     *channelCount = 0;

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

  221.     if (err == noErr) {

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

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

  224.         if (err == noErr) {								

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

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

  227.         }

  228.     }

  229. 	

  230. 	if (streamList) 

  231. 		free(streamList);

  232. 	if (bufferList) 

  233. 		free(bufferList);	

  234. 		

  235.     return err;

  236. }

  237. 

  238. static OSStatus display_device_names()

  239. {

  240. 	UInt32 size;

  241. 	Boolean isWritable;

  242. 	int i, deviceNum;

  243. 	OSStatus err;

  244. 	CFStringRef UIname;

  245. 	

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

  247.     if (err != noErr) 

  248. 		return err;

  249. 		

  250. 	deviceNum = size/sizeof(AudioDeviceID);

  251. 	AudioDeviceID devices[deviceNum];

  252. 	

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

  254.     if (err != noErr) 

  255. 		return err;

  256. 	

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

  258.         char device_name[256];

  259. 		char internal_name[256];

  260. 		

  261. 		size = sizeof(CFStringRef);

  262. 		UIname = NULL;

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

  264. 		if (err == noErr) {

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

  266. 		} else {

  267. 			goto error;

  268. 		}

  269. 		

  270. 		size = 256;

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

  272. 		if (err != noErr) 

  273. 			return err; 

  274. 		printf("ICI\n");

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

  276. 	}

  277. 	

  278. 	return noErr;

  279. 

  280. error:

  281. 	if (UIname != NULL)

  282. 		CFRelease(UIname);

  283. 	return err;

  284. }

  285. 

  286. static OSStatus render(void *inRefCon, 

  287. 						AudioUnitRenderActionFlags 	*ioActionFlags, 

  288. 						const AudioTimeStamp 		*inTimeStamp, 

  289. 						UInt32 						inBusNumber, 

  290. 						UInt32 						inNumberFrames, 

  291. 						AudioBufferList 			*ioData)

  292. {

  293. 	int res, i;

  294. 	JSList *node;

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

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

  297. 	

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

  299. 		jack_time_t current_time = jack_get_microseconds();

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

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

  302. 		ca_driver->last_wait_ust = current_time;

  303. 		ca_driver->xrun_detected = 0;

  304. 		return 0;

  305.     } else {

  306. 		ca_driver->last_wait_ust = jack_get_microseconds();

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

  308. 					  jack_get_microseconds());

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

  310. 	}

  311. 	

  312. 	if (ca_driver->null_cycle_occured) {

  313. 		ca_driver->null_cycle_occured = 0;

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

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

  316. 		}

  317. 	} else {

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

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

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

  321. 					sizeof(float) * inNumberFrames);

  322. 		}

  323. 	}

  324. 	

  325. 	return res;

  326. }

  327. 

  328. static OSStatus render_input(void *inRefCon, 

  329. 							AudioUnitRenderActionFlags 	*ioActionFlags, 

  330. 							const AudioTimeStamp 		*inTimeStamp, 

  331. 							UInt32 						inBusNumber, 

  332. 							UInt32 						inNumberFrames, 

  333. 							AudioBufferList 			*ioData)

  334. 

  335. {

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

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

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

  339. 		jack_time_t current_time = jack_get_microseconds();

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

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

  342. 		ca_driver->last_wait_ust = current_time;

  343. 		ca_driver->xrun_detected = 0;

  344. 		return 0;

  345.     } else {

  346. 		ca_driver->last_wait_ust = jack_get_microseconds();

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

  348. 					  jack_get_microseconds());

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

  350. 	}

  351. }

  352. 

  353. static OSStatus notification(AudioDeviceID inDevice,

  354. 							UInt32 inChannel,

  355. 							Boolean	isInput,

  356. 							AudioDevicePropertyID inPropertyID,

  357. 							void* inClientData)

  358. {

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

  360.     if (inPropertyID == kAudioDeviceProcessorOverload) {

  361. 		ca_driver->xrun_detected = 1;

  362.     }

  363.     return noErr;

  364. }

  365. 

  366. static int

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

  368. {

  369.     jack_port_t *port;

  370. 	JSList *node;

  371.     int port_flags;

  372.     channel_t chn;

  373.     char buf[JACK_PORT_NAME_SIZE];

  374. 	char channel_name[64];

  375. 	OSStatus err;

  376. 	UInt32 size;

  377. 	UInt32 value1,value2;

  378.     Boolean isWritable;

  379. 	

  380.     driver->engine = engine;

  381. 

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

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

  384. 

  385.     port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

  386. 

  387.     /*

  388.        if (driver->has_hw_monitoring) {

  389. 			port_flags |= JackPortCanMonitor;

  390.        }

  391. 	*/

  392. 

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

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

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

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

  397. 			if (err != noErr) 

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

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

  400. 		} else {

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

  402. 		}

  403. 	

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

  405. 					JACK_DEFAULT_AUDIO_TYPE, port_flags,

  406. 					0)) == NULL) {

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

  408. 			break;

  409. 		}

  410. 

  411. 		size = sizeof(UInt32);

  412. 		value1 = value2 = 0;

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

  414. 		if (err != noErr) 

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

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

  417. 		if (err != noErr) 

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

  419. 		

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

  421. 		driver->capture_ports =

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

  423.     }

  424. 

  425.     port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  426. 

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

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

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

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

  431. 			if (err != noErr) 

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

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

  434. 		} else {

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

  436. 		}

  437. 

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

  439. 					JACK_DEFAULT_AUDIO_TYPE, port_flags,

  440. 					0)) == NULL) {

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

  442. 			break;

  443. 		}

  444. 

  445. 		size = sizeof(UInt32);

  446. 		value1 = value2 = 0;

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

  448. 		if (err != noErr) 

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

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

  451. 		if (err != noErr) 

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

  453. 	

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

  455. 		driver->playback_ports =

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

  457. 	}

  458. 	

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

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

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

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

  463.     }

  464. 

  465.     jack_activate(driver->client);

  466.     return 0;

  467. }

  468. 

  469. static int

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

  471. {

  472.     JSList *node;

  473. 

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

  475. 		return -1;

  476.     }

  477. 

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

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

  480.     }

  481. 

  482.     jack_slist_free(driver->capture_ports);

  483.     driver->capture_ports = 0;

  484. 

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

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

  487.     }

  488. 

  489.     jack_slist_free(driver->playback_ports);

  490.     driver->playback_ports = 0;

  491. 

  492.     driver->engine = 0;

  493.     return 0;

  494. }

  495. 

  496. static int

  497. coreaudio_driver_null_cycle(coreaudio_driver_t * driver, jack_nframes_t nframes)

  498. {

  499. 	driver->null_cycle_occured = 1;

  500.     return 0;

  501. }

  502. 

  503. static int

  504. coreaudio_driver_read(coreaudio_driver_t * driver, jack_nframes_t nframes)

  505. {

  506.     return 0;

  507. }

  508. 

  509. static int

  510. coreaudio_driver_write(coreaudio_driver_t * driver, jack_nframes_t nframes)

  511. {

  512. 	return 0;

  513. }

  514. 

  515. static int coreaudio_driver_audio_start(coreaudio_driver_t * driver)

  516. {

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

  518. }

  519. 

  520. static int coreaudio_driver_audio_stop(coreaudio_driver_t * driver)

  521. {

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

  523. }

  524. 

  525. static int

  526. coreaudio_driver_bufsize(coreaudio_driver_t * driver,

  527. 			 jack_nframes_t nframes)

  528. {

  529. 

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

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

  532.      * also stops that thread. */

  533. 	/*

  534. 	TO DO

  535. 	*/

  536. 	return 0;

  537. }

  538. 

  539. /** create a new driver instance

  540. */

  541. static jack_driver_t *coreaudio_driver_new(char* name,

  542. 										   jack_client_t* client,

  543. 										   jack_nframes_t nframes,

  544. 										   jack_nframes_t samplerate,

  545. 										   int capturing,

  546. 										   int playing,

  547. 										   int inchannels,

  548. 										   int outchannels,

  549. 										   char* capture_driver_uid,

  550. 										   char* playback_driver_uid,

  551. 										   jack_nframes_t capture_latency, 

  552. 										   jack_nframes_t playback_latency)

  553. {

  554.     coreaudio_driver_t *driver;

  555. 	OSStatus err = noErr;

  556. 	ComponentResult err1;

  557.     UInt32 outSize;

  558. 	UInt32 enableIO;

  559. 	AudioStreamBasicDescription srcFormat, dstFormat;

  560. 	Float64 sampleRate;

  561. 	int in_nChannels = 0;

  562. 	int out_nChannels = 0;

  563. 	int i;

  564. 	

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

  566.     jack_driver_init((jack_driver_t *) driver);

  567. 

  568.     if (!jack_power_of_two(nframes)) {

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

  570. 		goto error;

  571.     }

  572. 

  573.     driver->frames_per_cycle = nframes;

  574.     driver->frame_rate = samplerate;

  575.     driver->capturing = capturing;

  576.     driver->playing = playing;

  577. 	driver->xrun_detected = 0;

  578. 	driver->null_cycle = 0;

  579. 

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

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

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

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

  584.     driver->null_cycle =

  585. 	(JackDriverNullCycleFunction) coreaudio_driver_null_cycle;

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

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

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

  589. 	driver->capture_frame_latency = capture_latency;

  590. 	driver->playback_frame_latency = playback_latency;

  591. 	

  592. 	// Duplex

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

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

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

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

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

  598. 				goto error;

  599. 			}

  600. 		}

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

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

  603. 			goto error;

  604. 		}

  605. 		

  606. 	// Capture only

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

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

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

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

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

  612.                 goto error;

  613. 			}

  614. 		}

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

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

  617. 			goto error;

  618. 		}

  619. 		

  620.   	// Playback only

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

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

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

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

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

  626.                 goto error;

  627. 			}

  628.         }

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

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

  631. 			goto error;

  632. 		}

  633. 		

  634. 	// Use default driver in duplex mode

  635. 	} else {

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

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

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

  639. 			goto error;

  640. 		}

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

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

  643. 			goto error;

  644. 		}

  645. 	}

  646. 	

  647. 	driver->client = client;

  648.     driver->period_usecs =

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

  650. 		1000000.0f;

  651. 	

  652. 	if (capturing) {

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

  654. 		if (err != noErr) { 

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

  656. 			printError(err);

  657. 			goto error;

  658. 		} 

  659. 	}

  660. 	

  661. 	if (playing) {

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

  663. 		if (err != noErr) { 

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

  665. 			printError(err);

  666. 			goto error;

  667. 		} 

  668. 	}

  669. 	

  670. 	if (inchannels > in_nChannels) {

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

  672. 		goto error;

  673.     }

  674. 	

  675. 	if (outchannels > out_nChannels) {

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

  677. 		goto error;

  678.     }

  679. 

  680. 	if (inchannels == 0) {

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

  682. 		inchannels = in_nChannels; 

  683. 	}

  684. 		

  685. 	if (outchannels == 0) {

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

  687. 		outchannels = out_nChannels; 

  688. 	}

  689. 

  690.     // Setting buffer size

  691.     outSize = sizeof(UInt32);

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

  693.     if (err != noErr) {

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

  695.         printError(err);

  696. 		goto error;

  697.     }

  698. 

  699. 	// Set sample rate

  700. 	outSize =  sizeof(Float64);

  701. 	err = AudioDeviceGetProperty(driver->device_id, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &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 != (jack_nframes_t)sampleRate) {

  709. 		sampleRate = (Float64)samplerate;

  710. 		err = AudioDeviceSetProperty(driver->device_id, NULL, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, 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.     // AUHAL

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

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

  721. 

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

  723.     if (err1 != noErr) {

  724. 		jack_error("Error calling OpenAComponent");

  725.         printError(err1);

  726.         goto error;

  727. 	}

  728. 

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

  730.     if (err1 != noErr) {

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

  732. 		printError(err1);

  733.         goto error;

  734. 	}

  735. 

  736.  	// Start I/O

  737. 	enableIO = 1;

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

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

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

  741.         if (err1 != noErr) {

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

  743.             printError(err1);

  744.             goto error;

  745.         }

  746.     }

  747. 	

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

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

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

  751. 		if (err1 != noErr) {

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

  753. 			printError(err1);

  754. 			goto error;

  755. 		}

  756. 	}

  757. 	

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

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

  760. 	if (err1 != noErr) {

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

  762. 		printError(err1);

  763. 		goto error;

  764. 	}

  765. 

  766. 	// Set buffer size

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

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

  769. 		if (err1 != noErr) {

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

  771. 			printError(err1);

  772. 			goto error;

  773. 		}

  774. 	}

  775. 	

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

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

  778. 		if (err1 != noErr) {

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

  780. 			printError(err1);

  781. 			goto error;

  782. 		}

  783. 	}

  784. 

  785. 	// Setup channel map

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

  787.         SInt32 chanArr[in_nChannels];

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

  789.             chanArr[i] = -1;

  790.         }

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

  792.             chanArr[i] = i;

  793.         }

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

  795.         if (err1 != noErr) {

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

  797.             printError(err1);

  798.         }

  799.     }

  800. 

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

  802.         SInt32 chanArr[out_nChannels];

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

  804.             chanArr[i] = -1;

  805.         }

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

  807.             chanArr[i] = i;

  808.         }

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

  810.         if (err1 != noErr) {

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

  812.             printError(err1);

  813.         }

  814.     }

  815. 

  816. 	// Setup stream converters

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

  818. 		srcFormat.mSampleRate = samplerate;

  819. 		srcFormat.mFormatID = kAudioFormatLinearPCM;

  820. 		srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  821. 		srcFormat.mBytesPerPacket = sizeof(float);

  822. 		srcFormat.mFramesPerPacket = 1;

  823. 		srcFormat.mBytesPerFrame = sizeof(float);

  824. 		srcFormat.mChannelsPerFrame = outchannels;

  825. 		srcFormat.mBitsPerChannel = 32;

  826. 

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

  828. 		if (err1 != noErr) {

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

  830. 			printError(err1);

  831. 		}

  832. 	}

  833. 

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

  835. 		dstFormat.mSampleRate = samplerate;

  836. 		dstFormat.mFormatID = kAudioFormatLinearPCM;

  837. 		dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  838. 		dstFormat.mBytesPerPacket = sizeof(float);

  839. 		dstFormat.mFramesPerPacket = 1;

  840. 		dstFormat.mBytesPerFrame = sizeof(float);

  841. 		dstFormat.mChannelsPerFrame = inchannels;

  842. 		dstFormat.mBitsPerChannel = 32;

  843. 

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

  845. 		if (err1 != noErr) {

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

  847. 			printError(err1);

  848. 		}

  849. 	}

  850. 

  851. 	// Setup callbacks

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

  853.         AURenderCallbackStruct output;

  854.         output.inputProc = render_input;

  855.         output.inputProcRefCon = driver;

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

  857.         if (err1 != noErr) {

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

  859.             printError(err1);

  860.             goto error;

  861.         }

  862.     } else {

  863.         AURenderCallbackStruct output;

  864.         output.inputProc = render;

  865.         output.inputProcRefCon = driver;

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

  867.         if (err1 != noErr) {

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

  869.             printError(err1);

  870.             goto error;

  871.         }

  872.     }

  873. 

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

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

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

  877. 			goto error;

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

  879. 		

  880. 		// Prepare buffers

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

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

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

  884. 		}

  885. 	}

  886. 

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

  888.     if (err != noErr)

  889.         goto error;

  890.  

  891. 	driver->playback_nchannels = outchannels;

  892.     driver->capture_nchannels = inchannels;

  893. 	return ((jack_driver_t *) driver);

  894. 

  895.   error:

  896. 	AudioUnitUninitialize(driver->au_hal);

  897. 	CloseComponent(driver->au_hal);

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

  899.     free(driver);

  900.     return NULL;

  901. }

  902. 

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

  904. */

  905. static void coreaudio_driver_delete(coreaudio_driver_t * driver)

  906. {

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

  908.     free(driver->input_list);

  909.  	AudioUnitUninitialize(driver->au_hal);

  910. 	CloseComponent(driver->au_hal);

  911.     free(driver);

  912. }

  913. 

  914. //== driver "plugin" interface =================================================

  915. 

  916. /* DRIVER "PLUGIN" INTERFACE */

  917. 

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

  919. 

  920. jack_driver_desc_t *driver_get_descriptor()

  921. {

  922.     jack_driver_desc_t *desc;

  923.     unsigned int i;

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

  925. 

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

  927.     desc->nparams = 12;

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

  929. 

  930.     i = 0;

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

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

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

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

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

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

  937. 

  938.     i++;

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

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

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

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

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

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

  945. 

  946.     i++;

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

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

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

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

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

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

  953. 

  954.     i++;

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

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

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

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

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

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

  961. 

  962. 	i++;

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

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

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

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

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

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

  969. 

  970.     i++;

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

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

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

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

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

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

  977. 

  978.     i++;

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

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

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

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

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

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

  985. 

  986.     i++;

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

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

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

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

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

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

  993. 

  994.     i++;

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

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

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

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

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

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

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

  1002. 

  1003.  	i++;

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

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

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

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

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

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

  1010. 

  1011. 	i++;

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

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

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

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

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

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

  1018. 	

  1019. 	i++;

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

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

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

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

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

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

  1026. 	

  1027.     return desc;

  1028. }

  1029. 

  1030. jack_driver_t *driver_initialize(jack_client_t * client,

  1031. 				 const JSList * params)

  1032. {

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

  1034.     jack_nframes_t frames_per_interrupt = 128;

  1035.     int capture = FALSE;

  1036.     int playback = FALSE;

  1037.     int chan_in = 0;

  1038.     int chan_out = 0;

  1039.     char* capture_pcm_name = NULL;

  1040. 	char* playback_pcm_name = NULL;

  1041.     const JSList *node;

  1042.     const jack_driver_param_t *param;

  1043. 	jack_nframes_t systemic_input_latency = 0;

  1044. 	jack_nframes_t systemic_output_latency = 0;

  1045. 

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

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

  1048. 

  1049. 	switch (param->character) {

  1050. 

  1051. 		case 'd':

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

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

  1054. 			break;

  1055. 

  1056. 		case 'D':

  1057. 			capture = TRUE;

  1058. 			playback = TRUE;

  1059. 			break;

  1060. 

  1061. 		case 'c':

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

  1063. 			break;

  1064. 

  1065. 		case 'i':

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

  1067. 			break;

  1068. 

  1069. 		case 'o':

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

  1071. 			break;

  1072. 

  1073. 		case 'C':

  1074. 			capture = TRUE;

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

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

  1077. 			}

  1078. 			break;

  1079. 

  1080. 		case 'P':

  1081. 			playback = TRUE;

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

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

  1084. 			}

  1085. 			break;

  1086. 

  1087. 		case 'r':

  1088. 			srate = param->value.ui;

  1089. 			break;

  1090. 

  1091. 		case 'p':

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

  1093. 			break;

  1094. 

  1095. 		case 'I':

  1096. 			systemic_input_latency = param->value.ui;

  1097. 			break;

  1098. 

  1099. 		case 'O':

  1100. 			systemic_output_latency = param->value.ui;

  1101. 			break;

  1102. 			

  1103. 		case 'l':

  1104. 			display_device_names();

  1105. 			break;

  1106. 		}

  1107.     }

  1108. 

  1109.     /* duplex is the default */

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

  1111. 		capture = TRUE;

  1112. 		playback = TRUE;

  1113.     }

  1114. 	

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

  1116. 				srate, capture, playback, chan_in,

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

  1118. }

  1119. 

  1120. void driver_finish(jack_driver_t * driver)

  1121. {

  1122.     coreaudio_driver_delete((coreaudio_driver_t *) driver);

  1123. }