jackaudio
/
jack2
mirror of https://github.com/jackaudio/jack2
1
0
Fork 0
Code Releases 45 Activity
jack2 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.
413 Commits
7 Branches
58MB
Tree: caee59aed3
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'caee59aed3'
${ noResults }
jack2/macosx/JackCoreAudioDriver.cpp

1192 lines
45KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2004-2006 Grame

  3. 

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

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

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

  7. (at your option) any later version.

  8. 

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

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

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

  12. GNU General Public License for more details.

  13. 

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

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

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

  17. 

  18. */

  19. 

  20. #include "JackCoreAudioDriver.h"

  21. #include "JackEngineControl.h"

  22. #include "JackMachThread.h"

  23. #include "JackGraphManager.h"

  24. #include "JackError.h"

  25. #include "JackClientControl.h"

  26. #include "JackDriverLoader.h"

  27. #include "JackGlobals.h"

  28. #include "driver_interface.h"

  29. #include <iostream>

  30. 

  31. namespace Jack

  32. {

  33. 

  34. static void PrintStreamDesc(AudioStreamBasicDescription *inDesc)

  35. {

  36.     JackLog("- - - - - - - - - - - - - - - - - - - -\n");

  37.     JackLog("  Sample Rate:%f\n", inDesc->mSampleRate);

  38.     JackLog("  Format ID:%.*s\n", (int) sizeof(inDesc->mFormatID), (char*)&inDesc->mFormatID);

  39.     JackLog("  Format Flags:%lX\n", inDesc->mFormatFlags);

  40.     JackLog("  Bytes per Packet:%ld\n", inDesc->mBytesPerPacket);

  41.     JackLog("  Frames per Packet:%ld\n", inDesc->mFramesPerPacket);

  42.     JackLog("  Bytes per Frame:%ld\n", inDesc->mBytesPerFrame);

  43.     JackLog("  Channels per Frame:%ld\n", inDesc->mChannelsPerFrame);

  44.     JackLog("  Bits per Channel:%ld\n", inDesc->mBitsPerChannel);

  45.     JackLog("- - - - - - - - - - - - - - - - - - - -\n");

  46. }

  47. 

  48. static void printError(OSStatus err)

  49. {

  50.     switch (err) {

  51.         case kAudioHardwareNoError:

  52.             JackLog("error code : kAudioHardwareNoError\n");

  53.             break;

  54.         case kAudioConverterErr_FormatNotSupported:

  55.             JackLog("error code : kAudioConverterErr_FormatNotSupported\n");

  56.             break;

  57.         case kAudioConverterErr_OperationNotSupported:

  58.             JackLog("error code : kAudioConverterErr_OperationNotSupported\n");

  59.             break;

  60.         case kAudioConverterErr_PropertyNotSupported:

  61.             JackLog("error code : kAudioConverterErr_PropertyNotSupported\n");

  62.             break;

  63.         case kAudioConverterErr_InvalidInputSize:

  64.             JackLog("error code : kAudioConverterErr_InvalidInputSize\n");

  65.             break;

  66.         case kAudioConverterErr_InvalidOutputSize:

  67.             JackLog("error code : kAudioConverterErr_InvalidOutputSize\n");

  68.             break;

  69.         case kAudioConverterErr_UnspecifiedError:

  70.             JackLog("error code : kAudioConverterErr_UnspecifiedError\n");

  71.             break;

  72.         case kAudioConverterErr_BadPropertySizeError:

  73.             JackLog("error code : kAudioConverterErr_BadPropertySizeError\n");

  74.             break;

  75.         case kAudioConverterErr_RequiresPacketDescriptionsError:

  76.             JackLog("error code : kAudioConverterErr_RequiresPacketDescriptionsError\n");

  77.             break;

  78.         case kAudioConverterErr_InputSampleRateOutOfRange:

  79.             JackLog("error code : kAudioConverterErr_InputSampleRateOutOfRange\n");

  80.             break;

  81.         case kAudioConverterErr_OutputSampleRateOutOfRange:

  82.             JackLog("error code : kAudioConverterErr_OutputSampleRateOutOfRange\n");

  83.             break;

  84.         case kAudioHardwareNotRunningError:

  85.             JackLog("error code : kAudioHardwareNotRunningError\n");

  86.             break;

  87.         case kAudioHardwareUnknownPropertyError:

  88.             JackLog("error code : kAudioHardwareUnknownPropertyError\n");

  89.             break;

  90.         case kAudioHardwareIllegalOperationError:

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

  92.             break;

  93.         case kAudioHardwareBadDeviceError:

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

  95.             break;

  96.         case kAudioHardwareBadStreamError:

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

  98.             break;

  99.         case kAudioDeviceUnsupportedFormatError:

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

  101.             break;

  102.         case kAudioDevicePermissionsError:

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

  104.             break;

  105. 		case kAudioHardwareBadObjectError:

  106.             JackLog("error code : kAudioHardwareBadObjectError\n");

  107.             break;

  108. 			case kAudioHardwareUnsupportedOperationError:

  109.             JackLog("error code : kAudioHardwareUnsupportedOperationError\n");

  110.             break;

  111.         default:

  112.             JackLog("error code : unknown\n");

  113.             break;

  114.     }

  115. }

  116. 

  117. static OSStatus DisplayDeviceNames()

  118. {

  119.     UInt32 size;

  120.     Boolean isWritable;

  121.     int i, deviceNum;

  122.     OSStatus err;

  123.     CFStringRef UIname;

  124. 

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

  126.     if (err != noErr)

  127.         return err;

  128. 

  129.     deviceNum = size / sizeof(AudioDeviceID);

  130.     AudioDeviceID devices[deviceNum];

  131. 

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

  133.     if (err != noErr)

  134.         return err;

  135. 

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

  137.         char device_name[256];

  138.         char internal_name[256];

  139. 

  140.         size = sizeof(CFStringRef);

  141.         UIname = NULL;

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

  143.         if (err == noErr) {

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

  145.         } else {

  146.             goto error;

  147.         }

  148. 

  149.         size = 256;

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

  151.         if (err != noErr)

  152.             return err;

  153. 

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

  155.     }

  156. 

  157.     return noErr;

  158. 

  159. error:

  160.     if (UIname != NULL)

  161.         CFRelease(UIname);

  162.     return err;

  163. }

  164. 

  165. #if IO_CPU

  166. 

  167. OSStatus JackCoreAudioDriver::Render(void *inRefCon,

  168.                                      AudioUnitRenderActionFlags *ioActionFlags,

  169.                                      const AudioTimeStamp *inTimeStamp,

  170.                                      UInt32 inBusNumber,

  171.                                      UInt32 inNumberFrames,

  172.                                      AudioBufferList *ioData)

  173. {

  174.     JackCoreAudioDriver* driver = (JackCoreAudioDriver*)inRefCon;

  175.     driver->fLastWaitUst = GetMicroSeconds(); // Take callback date here

  176.     memcpy(&driver->fActionFags, ioActionFlags, sizeof(AudioUnitRenderActionFlags));

  177.     memcpy(&driver->fCurrentTime, inTimeStamp, sizeof(AudioTimeStamp));

  178.     driver->fDriverOutputData = ioData;

  179.     float delta;

  180.     OSStatus res = driver->Process();

  181.     if ((delta = float(GetMicroSeconds() - driver->fLastWaitUst) / float(driver->fEngineControl->fPeriodUsecs)) > 0.1) {

  182.         JackLog("IO CPU %f\n", delta);

  183.     }

  184.     return res;

  185. }

  186. 

  187. #else

  188. 

  189. OSStatus JackCoreAudioDriver::Render(void *inRefCon,

  190.                                      AudioUnitRenderActionFlags *ioActionFlags,

  191.                                      const AudioTimeStamp *inTimeStamp,

  192.                                      UInt32 inBusNumber,

  193.                                      UInt32 inNumberFrames,

  194.                                      AudioBufferList *ioData)

  195. {

  196.     JackCoreAudioDriver* driver = (JackCoreAudioDriver*)inRefCon;

  197.     driver->fLastWaitUst = GetMicroSeconds(); // Take callback date here

  198.     memcpy(&driver->fActionFags, ioActionFlags, sizeof(AudioUnitRenderActionFlags));

  199.     memcpy(&driver->fCurrentTime, inTimeStamp, sizeof(AudioTimeStamp));

  200.     driver->fDriverOutputData = ioData;

  201.     return driver->Process();

  202. }

  203. 

  204. #endif

  205. 

  206. int JackCoreAudioDriver::Read()

  207. {

  208.     AudioUnitRender(fAUHAL, &fActionFags, &fCurrentTime, 1, fEngineControl->fBufferSize, fJackInputData);

  209.     return 0;

  210. }

  211. 

  212. int JackCoreAudioDriver::Write()

  213. {

  214.     for (int i = 0; i < fPlaybackChannels; i++) {

  215.         if (fGraphManager->GetConnectionsNum(fPlaybackPortList[i]) > 0) {

  216.             float* buffer = GetOutputBuffer(i);

  217.             int size = sizeof(float) * fEngineControl->fBufferSize;

  218.             memcpy((float*)fDriverOutputData->mBuffers[i].mData, buffer, size);

  219.             // Monitor ports

  220.             if (fWithMonitorPorts && fGraphManager->GetConnectionsNum(fMonitorPortList[i]) > 0)

  221.                 memcpy(GetMonitorBuffer(i), buffer, size);

  222.         } else {

  223.             memset((float*)fDriverOutputData->mBuffers[i].mData, 0, sizeof(float) * fEngineControl->fBufferSize);

  224.         }

  225.     }

  226.     return 0;

  227. }

  228. 

  229. // Will run only once

  230. OSStatus JackCoreAudioDriver::MeasureCallback(AudioDeviceID inDevice,

  231.         const AudioTimeStamp* inNow,

  232.         const AudioBufferList* inInputData,

  233.         const AudioTimeStamp* inInputTime,

  234.         AudioBufferList* outOutputData,

  235.         const AudioTimeStamp* inOutputTime,

  236.         void* inClientData)

  237. {

  238.     JackCoreAudioDriver* driver = (JackCoreAudioDriver*)inClientData;

  239.     AudioDeviceStop(driver->fDeviceID, MeasureCallback);

  240.     AudioDeviceRemoveIOProc(driver->fDeviceID, MeasureCallback);

  241.     JackLog("JackCoreAudioDriver::MeasureCallback called\n");

  242.     JackMachThread::GetParams(&driver->fEngineControl->fPeriod, &driver->fEngineControl->fComputation, &driver->fEngineControl->fConstraint);

  243.     return noErr;

  244. }

  245. 

  246. OSStatus JackCoreAudioDriver::DeviceNotificationCallback(AudioDeviceID inDevice,

  247.         UInt32 inChannel,

  248.         Boolean	isInput,

  249.         AudioDevicePropertyID inPropertyID,

  250.         void* inClientData)

  251. {

  252.     JackCoreAudioDriver* driver = (JackCoreAudioDriver*)inClientData;

  253. 	switch (inPropertyID) {

  254. 	

  255. 		case kAudioDeviceProcessorOverload:

  256. 			JackLog("JackCoreAudioDriver::NotificationCallback kAudioDeviceProcessorOverload\n");

  257. 		#ifdef DEBUG

  258. 			//driver->fLogFile->Capture(AudioGetCurrentHostTime() - AudioConvertNanosToHostTime(LOG_SAMPLE_DURATION * 1000000), AudioGetCurrentHostTime(), true, "Captured Latency Log for I/O Cycle Overload\n");

  259. 		#endif

  260. 			driver->NotifyXRun(GetMicroSeconds());

  261. 			break;

  262. 			

  263. 		case kAudioDevicePropertyNominalSampleRate: {

  264. 			UInt32 outSize =  sizeof(Float64);

  265. 			Float64 sampleRate;

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

  267. 			if (err != noErr) {

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

  269. 				printError(err);

  270. 				return kAudioHardwareUnsupportedOperationError;

  271. 			}

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

  273. 			if (jack_nframes_t(sampleRate) != driver->fEngineControl->fSampleRate) {

  274. 				jack_error("Critical error : new %ld sample rate, engine will not run correctly anymore", long(sampleRate));

  275. 			}

  276. 			break;

  277. 		}

  278. 	}

  279.     return noErr;

  280. }

  281. 

  282. OSStatus JackCoreAudioDriver::GetDeviceIDFromUID(const char* UID, AudioDeviceID* id)

  283. {

  284.     UInt32 size = sizeof(AudioValueTranslation);

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

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

  287. 

  288.     if (inIUD == NULL) {

  289.         return kAudioHardwareUnspecifiedError;

  290.     } else {

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

  292.         CFRelease(inIUD);

  293.         JackLog("get_device_id_from_uid %s %ld \n", UID, *id);

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

  295.     }

  296. }

  297. 

  298. OSStatus JackCoreAudioDriver::GetDefaultDevice(AudioDeviceID* id)

  299. {

  300.     OSStatus res;

  301.     UInt32 theSize = sizeof(UInt32);

  302.     AudioDeviceID inDefault;

  303.     AudioDeviceID outDefault;

  304. 

  305.     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &theSize, &inDefault)) != noErr)

  306.         return res;

  307. 

  308.     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &theSize, &outDefault)) != noErr)

  309.         return res;

  310. 

  311.     JackLog("GetDefaultDevice: input = %ld output = %ld\n", inDefault, outDefault);

  312. 

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

  314.     if (inDefault == outDefault) {

  315.         *id = inDefault;

  316.         return noErr;

  317.     } else {

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

  319.         return kAudioHardwareBadDeviceError;

  320.     }

  321. }

  322. 

  323. OSStatus JackCoreAudioDriver::GetDefaultInputDevice(AudioDeviceID* id)

  324. {

  325.     OSStatus res;

  326.     UInt32 theSize = sizeof(UInt32);

  327.     AudioDeviceID inDefault;

  328. 

  329.     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &theSize, &inDefault)) != noErr)

  330.         return res;

  331. 

  332.     JackLog("GetDefaultInputDevice: input = %ld \n", inDefault);

  333.     *id = inDefault;

  334.     return noErr;

  335. }

  336. 

  337. OSStatus JackCoreAudioDriver::GetDefaultOutputDevice(AudioDeviceID* id)

  338. {

  339.     OSStatus res;

  340.     UInt32 theSize = sizeof(UInt32);

  341.     AudioDeviceID outDefault;

  342. 

  343.     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &theSize, &outDefault)) != noErr)

  344.         return res;

  345. 

  346.     JackLog("GetDefaultOutputDevice: output = %ld\n", outDefault);

  347.     *id = outDefault;

  348.     return noErr;

  349. }

  350. 

  351. OSStatus JackCoreAudioDriver::GetDeviceNameFromID(AudioDeviceID id, char* name)

  352. {

  353.     UInt32 size = 256;

  354.     return AudioDeviceGetProperty(id, 0, false, kAudioDevicePropertyDeviceName, &size, name);

  355. }

  356. 

  357. OSStatus JackCoreAudioDriver::GetTotalChannels(AudioDeviceID device, long* channelCount, bool isInput)

  358. {

  359.     OSStatus	err = noErr;

  360.     UInt32	outSize;

  361.     Boolean	outWritable;

  362.     AudioBufferList*	bufferList = 0;

  363.     AudioStreamID*	streamList = 0;

  364.     int	i, numStream;

  365. 

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

  367.     if (err == noErr) {

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

  369.         numStream = outSize / sizeof(AudioStreamID);

  370.         JackLog("GetTotalChannels device stream number = %ld numStream = %ld\n", device, numStream);

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

  372.         if (err == noErr) {

  373.             AudioStreamBasicDescription streamDesc;

  374.             outSize = sizeof(AudioStreamBasicDescription);

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

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

  377.                 JackLog("GetTotalChannels streamDesc mFormatFlags = %ld mChannelsPerFrame = %ld\n", streamDesc.mFormatFlags, streamDesc.mChannelsPerFrame);

  378.             }

  379.         }

  380.     }

  381. 

  382.     *channelCount = 0;

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

  384.     if (err == noErr) {

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

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

  387.         if (err == noErr) {

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

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

  390.         }

  391.     }

  392. 

  393.     if (streamList)

  394.         free(streamList);

  395.     if (bufferList)

  396.         free(bufferList);

  397. 

  398.     return err;

  399. }

  400. 

  401. JackCoreAudioDriver::JackCoreAudioDriver(const char* name, JackEngine* engine, JackSynchro** table)

  402.         : JackAudioDriver(name, engine, table), fJackInputData(NULL), fDriverOutputData(NULL)

  403. {

  404. #ifdef DEBUG

  405.     //fLogFile = new CALatencyLog("jackmp_latency", ".txt");

  406. #endif

  407. }

  408. 

  409. JackCoreAudioDriver::~JackCoreAudioDriver()

  410. {

  411. #ifdef DEBUG

  412.     //delete fLogFile;

  413. #endif

  414. }

  415. 

  416. int JackCoreAudioDriver::Open(jack_nframes_t nframes,

  417.                               jack_nframes_t samplerate,

  418.                               int capturing,

  419.                               int playing,

  420.                               int inchannels,

  421.                               int outchannels,

  422.                               bool monitor,

  423.                               const char* capture_driver_uid,

  424.                               const char* playback_driver_uid,

  425.                               jack_nframes_t capture_latency,

  426.                               jack_nframes_t playback_latency)

  427. {

  428.     OSStatus err = noErr;

  429.     ComponentResult err1;

  430.     UInt32 outSize;

  431.     UInt32 enableIO;

  432.     AudioStreamBasicDescription srcFormat, dstFormat;

  433. 	Float64 sampleRate;

  434. 

  435.     long in_nChannels = 0;

  436.     long out_nChannels = 0;

  437.     char capture_driver_name[256];

  438.     char playback_driver_name[256];

  439.     float iousage;

  440. 

  441.     capture_driver_name[0] = 0;

  442.     playback_driver_name[0] = 0;

  443. 

  444.     JackLog("JackCoreAudioDriver::Open nframes = %ld in = %ld out = %ld capture name = %s playback name = %s\n",

  445.             nframes, inchannels, outchannels, capture_driver_uid, playback_driver_uid);

  446. 

  447.     // Duplex

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

  449.         JackLog("JackCoreAudioDriver::Open duplex \n");

  450.         if (GetDeviceIDFromUID(playback_driver_uid, &fDeviceID) != noErr) {

  451.             if (GetDefaultDevice(&fDeviceID) != noErr) {

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

  453.                 return -1;

  454.             }

  455.         }

  456.         if (GetDeviceNameFromID(fDeviceID, capture_driver_name) != noErr || GetDeviceNameFromID(fDeviceID, playback_driver_name) != noErr) {

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

  458.             return -1;

  459.         }

  460. 

  461.         // Capture only

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

  463.         JackLog("JackCoreAudioDriver::Open capture only \n");

  464.         if (GetDeviceIDFromUID(capture_driver_uid, &fDeviceID) != noErr) {

  465.             if (GetDefaultInputDevice(&fDeviceID) != noErr) {

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

  467.                 return -1;

  468.             }

  469.         }

  470.         if (GetDeviceNameFromID(fDeviceID, capture_driver_name) != noErr) {

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

  472.             return -1;

  473.         }

  474. 

  475.         // Playback only

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

  477.         JackLog("JackCoreAudioDriver::Open playback only \n");

  478.         if (GetDeviceIDFromUID(playback_driver_uid, &fDeviceID) != noErr) {

  479.             if (GetDefaultOutputDevice(&fDeviceID) != noErr) {

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

  481.                 return -1;

  482.             }

  483.         }

  484.         if (GetDeviceNameFromID(fDeviceID, playback_driver_name) != noErr) {

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

  486.             return -1;

  487.         }

  488. 

  489.         // Use default driver in duplex mode

  490.     } else {

  491.         JackLog("JackCoreAudioDriver::Open default driver \n");

  492.         if (GetDefaultDevice(&fDeviceID) != noErr) {

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

  494.             return -1;

  495.         }

  496.         if (GetDeviceNameFromID(fDeviceID, capture_driver_name) != noErr || GetDeviceNameFromID(fDeviceID, playback_driver_name) != noErr) {

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

  498.             return -1;

  499.         }

  500.     }

  501. 

  502.     // Generic JackAudioDriver Open

  503.     if (JackAudioDriver::Open(nframes, samplerate, capturing, playing, inchannels, outchannels, monitor, capture_driver_name, playback_driver_name, capture_latency, playback_latency) != 0) {

  504.         return -1;

  505.     }

  506. 

  507.     if (capturing) {

  508.         err = GetTotalChannels(fDeviceID, &in_nChannels, true);

  509.         if (err != noErr) {

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

  511.             printError(err);

  512.             return -1;

  513.         }

  514.     }

  515. 

  516.     if (playing) {

  517.         err = GetTotalChannels(fDeviceID, &out_nChannels, false);

  518.         if (err != noErr) {

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

  520.             printError(err);

  521.             return -1;

  522.         }

  523.     }

  524. 

  525.     if (inchannels > in_nChannels) {

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

  527.         return -1;

  528.     }

  529. 

  530.     if (outchannels > out_nChannels) {

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

  532.         return -1;

  533.     }

  534. 

  535.     if (inchannels == 0) {

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

  537.         inchannels = in_nChannels;

  538.     }

  539. 

  540.     if (outchannels == 0) {

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

  542.         outchannels = out_nChannels;

  543.     }

  544. 

  545.     // Setting buffer size

  546.     outSize = sizeof(UInt32);

  547.     err = AudioDeviceSetProperty(fDeviceID, NULL, 0, false, kAudioDevicePropertyBufferFrameSize, outSize, &fEngineControl->fBufferSize);

  548.     if (err != noErr) {

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

  550.         printError(err);

  551.         return -1;

  552.     }

  553. 

  554.     // Set sample rate

  555. 	outSize =  sizeof(Float64);

  556. 	err = AudioDeviceGetProperty(fDeviceID, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &sampleRate);

  557. 	if (err != noErr) {

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

  559. 		printError(err);

  560. 		return -1;

  561. 	}

  562. 

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

  564. 		sampleRate = (Float64)samplerate;

  565. 		err = AudioDeviceSetProperty(fDeviceID, NULL, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, outSize, &sampleRate);

  566. 		if (err != noErr) {

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

  568. 			printError(err);

  569. 			return -1;

  570. 		}

  571. 	}

  572.  

  573.     // AUHAL

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

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

  576. 

  577.     err1 = OpenAComponent(HALOutput, &fAUHAL);

  578.     if (err1 != noErr) {

  579.         jack_error("Error calling OpenAComponent");

  580.         printError(err1);

  581.         goto error;

  582.     }

  583. 

  584.     err1 = AudioUnitInitialize(fAUHAL);

  585.     if (err1 != noErr) {

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

  587.         printError(err1);

  588.         goto error;

  589.     }

  590. 

  591.     // Start I/O

  592.     enableIO = 1;

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

  594.         JackLog("Setup AUHAL input\n");

  595.         err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, &enableIO, sizeof(enableIO));

  596.         if (err1 != noErr) {

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

  598.             printError(err1);

  599.             goto error;

  600.         }

  601.     }

  602. 

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

  604.         JackLog("Setup AUHAL output\n");

  605.         err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, &enableIO, sizeof(enableIO));

  606.         if (err1 != noErr) {

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

  608.             printError(err1);

  609.             goto error;

  610.         }

  611.     }

  612. 

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

  614.     err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &fDeviceID, sizeof(AudioDeviceID));

  615.     if (err1 != noErr) {

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

  617.         printError(err1);

  618.         goto error;

  619.     }

  620. 

  621.     // Set buffer size

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

  623.         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 1, (UInt32*) & nframes, sizeof(UInt32));

  624.         if (err1 != noErr) {

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

  626.             printError(err1);

  627.             goto error;

  628.         }

  629.     }

  630. 

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

  632.         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 0, (UInt32*) & nframes, sizeof(UInt32));

  633.         if (err1 != noErr) {

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

  635.             printError(err1);

  636.             goto error;

  637.         }

  638.     }

  639. 

  640.     // Setup channel map

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

  642.         SInt32 chanArr[in_nChannels];

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

  644.             chanArr[i] = -1;

  645.         }

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

  647.             chanArr[i] = i;

  648.         }

  649.         AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_ChannelMap , kAudioUnitScope_Input, 1, chanArr, sizeof(SInt32) * in_nChannels);

  650.         if (err1 != noErr) {

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

  652.             printError(err1);

  653.         }

  654.     }

  655. 

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

  657.         SInt32 chanArr[out_nChannels];

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

  659.             chanArr[i] = -1;

  660.         }

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

  662.             chanArr[i] = i;

  663.         }

  664.         err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_ChannelMap, kAudioUnitScope_Output, 0, chanArr, sizeof(SInt32) * out_nChannels);

  665.         if (err1 != noErr) {

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

  667.             printError(err1);

  668.         }

  669.     }

  670. 

  671.     // Setup stream converters

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

  673.         srcFormat.mSampleRate = samplerate;

  674.         srcFormat.mFormatID = kAudioFormatLinearPCM;

  675.         srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  676.         srcFormat.mBytesPerPacket = sizeof(float);

  677.         srcFormat.mFramesPerPacket = 1;

  678.         srcFormat.mBytesPerFrame = sizeof(float);

  679.         srcFormat.mChannelsPerFrame = outchannels;

  680.         srcFormat.mBitsPerChannel = 32;

  681. 

  682.         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &srcFormat, sizeof(AudioStreamBasicDescription));

  683.         if (err1 != noErr) {

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

  685.             printError(err1);

  686.         }

  687.     }

  688. 

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

  690.         dstFormat.mSampleRate = samplerate;

  691.         dstFormat.mFormatID = kAudioFormatLinearPCM;

  692.         dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  693.         dstFormat.mBytesPerPacket = sizeof(float);

  694.         dstFormat.mFramesPerPacket = 1;

  695.         dstFormat.mBytesPerFrame = sizeof(float);

  696.         dstFormat.mChannelsPerFrame = inchannels;

  697.         dstFormat.mBitsPerChannel = 32;

  698. 

  699.         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &dstFormat, sizeof(AudioStreamBasicDescription));

  700.         if (err1 != noErr) {

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

  702.             printError(err1);

  703.         }

  704.     }

  705. 

  706.     // Setup callbacks

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

  708.         AURenderCallbackStruct output;

  709.         output.inputProc = Render;

  710.         output.inputProcRefCon = this;

  711.         err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &output, sizeof(output));

  712.         if (err1 != noErr) {

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

  714.             printError(err1);

  715.             goto error;

  716.         }

  717.     } else {

  718.         AURenderCallbackStruct output;

  719.         output.inputProc = Render;

  720.         output.inputProcRefCon = this;

  721.         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &output, sizeof(output));

  722.         if (err1 != noErr) {

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

  724.             printError(err1);

  725.             goto error;

  726.         }

  727.     }

  728. 

  729.     // Prepare buffers

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

  731.         fJackInputData = (AudioBufferList*)malloc(sizeof(UInt32) + inchannels * sizeof(AudioBuffer));

  732.         if (fJackInputData == 0) {

  733.             jack_error("Cannot allocate memory for input buffers");

  734.             goto error;

  735.         }

  736.         fJackInputData->mNumberBuffers = inchannels;

  737.         for (int i = 0; i < fCaptureChannels; i++) {

  738.             fJackInputData->mBuffers[i].mNumberChannels = 1;

  739.             fJackInputData->mBuffers[i].mDataByteSize = fEngineControl->fBufferSize * sizeof(float);

  740.         }

  741.     }

  742. 

  743.     // Add listeners

  744.     err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioDeviceProcessorOverload, DeviceNotificationCallback, this);

  745.     if (err != noErr) {

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

  747.         printError(err1);

  748.         goto error;

  749.     }

  750. 

  751.     err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioHardwarePropertyDevices, DeviceNotificationCallback, this);

  752.     if (err != noErr) {

  753.         jack_error("Error calling AudioDeviceAddPropertyListener with kAudioHardwarePropertyDevices");

  754.         printError(err1);

  755.         goto error;

  756.     }

  757. 	

  758. 	err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioDevicePropertyNominalSampleRate, DeviceNotificationCallback, this);

  759.     if (err != noErr) {

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

  761.         printError(err1);

  762.         goto error;

  763.     }

  764. 

  765.     fDriverOutputData = 0;

  766. 

  767. #if IO_CPU

  768.    outSize = sizeof(float);

  769.     iousage = 0.4f;

  770.     err = AudioDeviceSetProperty(fDeviceID, NULL, 0, false, kAudioDevicePropertyIOCycleUsage, outSize, &iousage);

  771.     if (err != noErr) {

  772.         jack_error("Error calling AudioDeviceSetProperty kAudioDevicePropertyIOCycleUsage");

  773.         printError(err);

  774.     }

  775. #endif

  776. 

  777.     // Core driver may have changed the in/out values

  778.     fCaptureChannels = inchannels;

  779.     fPlaybackChannels = outchannels;

  780.     return 0;

  781. 

  782. error:

  783.     AudioUnitUninitialize(fAUHAL);

  784.     CloseComponent(fAUHAL);

  785.     return -1;

  786. }

  787. 

  788. int JackCoreAudioDriver::Close()

  789. {

  790. 	JackLog("JackCoreAudioDriver::Close\n");

  791.     JackAudioDriver::Close();

  792.     // Possibly (if MeasureCallback has not been called)

  793.     AudioDeviceStop(fDeviceID, MeasureCallback);

  794.     AudioDeviceRemoveIOProc(fDeviceID, MeasureCallback);

  795.     AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDeviceProcessorOverload, DeviceNotificationCallback);

  796. 	AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioHardwarePropertyDevices, DeviceNotificationCallback);

  797. 	AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDevicePropertyNominalSampleRate, DeviceNotificationCallback);

  798.     free(fJackInputData);

  799.     AudioUnitUninitialize(fAUHAL);

  800.     CloseComponent(fAUHAL);

  801.     return 0;

  802. }

  803. 

  804. int JackCoreAudioDriver::Attach()

  805. {

  806.     OSStatus err;

  807.     JackPort* port;

  808.     jack_port_id_t port_index;

  809.     UInt32 size;

  810.     Boolean isWritable;

  811.     char channel_name[64];

  812.     char buf[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  813.     unsigned long port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

  814. 

  815.     JackLog("JackCoreAudioDriver::Attach fBufferSize %ld fSampleRate %ld\n", fEngineControl->fBufferSize, fEngineControl->fSampleRate);

  816. 

  817.     for (int i = 0; i < fCaptureChannels; i++) {

  818. 

  819.         err = AudioDeviceGetPropertyInfo(fDeviceID, i + 1, true, kAudioDevicePropertyChannelName, &size, &isWritable);

  820.         if (err != noErr)

  821.             JackLog("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error \n");

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

  823.             err = AudioDeviceGetProperty(fDeviceID, i + 1, true, kAudioDevicePropertyChannelName, &size, channel_name);

  824.             if (err != noErr)

  825.                 JackLog("AudioDeviceGetProperty kAudioDevicePropertyChannelName error \n");

  826.             snprintf(buf, sizeof(buf) - 1, "%s:%s:out_%s%u", fClientControl->fName, fCaptureDriverName, channel_name, i + 1);

  827.         } else {

  828.             snprintf(buf, sizeof(buf) - 1, "%s:%s:out%u", fClientControl->fName, fCaptureDriverName, i + 1);

  829.         }

  830. 

  831.         if ((port_index = fGraphManager->AllocatePort(fClientControl->fRefNum, buf, JACK_DEFAULT_AUDIO_TYPE, (JackPortFlags)port_flags)) == NO_PORT) {

  832.             jack_error("Cannot register port for %s", buf);

  833.             return -1;

  834.         }

  835. 		

  836. 		size = sizeof(UInt32);

  837. 		UInt32 value1 = 0;

  838. 		UInt32 value2 = 0;

  839. 		err = AudioDeviceGetProperty(fDeviceID, 0, true, kAudioDevicePropertyLatency, &size, &value1);	

  840. 		if (err != noErr) 

  841. 			JackLog("AudioDeviceGetProperty kAudioDevicePropertyLatency error \n");

  842. 		err = AudioDeviceGetProperty(fDeviceID, 0, true, kAudioDevicePropertySafetyOffset, &size, &value2);	

  843. 		if (err != noErr) 

  844. 			JackLog("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error \n");

  845. 	

  846.         port = fGraphManager->GetPort(port_index);

  847. 		port->Rename("system:capture_%d", i + 1);

  848.         port->SetLatency(fEngineControl->fBufferSize + value1 + value2 + fCaptureLatency);

  849.         fCapturePortList[i] = port_index;

  850.     }

  851. 

  852.     port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  853. 

  854.     for (int i = 0; i < fPlaybackChannels; i++) {

  855. 

  856.         err = AudioDeviceGetPropertyInfo(fDeviceID, i + 1, false, kAudioDevicePropertyChannelName, &size, &isWritable);

  857.         if (err != noErr)

  858.             JackLog("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error \n");

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

  860.             err = AudioDeviceGetProperty(fDeviceID, i + 1, false, kAudioDevicePropertyChannelName, &size, channel_name);

  861.             if (err != noErr)

  862.                 JackLog("AudioDeviceGetProperty kAudioDevicePropertyChannelName error \n");

  863.             snprintf(buf, sizeof(buf) - 1, "%s:%s:in_%s%u", fClientControl->fName, fPlaybackDriverName, channel_name, i + 1);

  864.         } else {

  865.             snprintf(buf, sizeof(buf) - 1, "%s:%s:in%u", fClientControl->fName, fPlaybackDriverName, i + 1);

  866.         }

  867. 

  868.         if ((port_index = fGraphManager->AllocatePort(fClientControl->fRefNum, buf, JACK_DEFAULT_AUDIO_TYPE, (JackPortFlags)port_flags)) == NO_PORT) {

  869.             jack_error("Cannot register port for %s", buf);

  870.             return -1;

  871.         }

  872. 		

  873. 		size = sizeof(UInt32);

  874. 		UInt32 value1 = 0;

  875. 		UInt32 value2 = 0;

  876. 		err = AudioDeviceGetProperty(fDeviceID, 0, false, kAudioDevicePropertyLatency, &size, &value1);	

  877. 		if (err != noErr) 

  878. 			JackLog("AudioDeviceGetProperty kAudioDevicePropertyLatency error \n");

  879. 		err = AudioDeviceGetProperty(fDeviceID, 0, false, kAudioDevicePropertySafetyOffset, &size, &value2);	

  880. 		if (err != noErr) 

  881. 			JackLog("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error \n");

  882. 

  883. 	    port = fGraphManager->GetPort(port_index);

  884. 		port->Rename("system:playback_%d", i + 1);

  885.         port->SetLatency(fEngineControl->fBufferSize + value1 + value2 + fPlaybackLatency);

  886.         fPlaybackPortList[i] = port_index;

  887. 

  888.         // Monitor ports

  889.         if (fWithMonitorPorts) {

  890.             JackLog("Create monitor port \n");

  891.             snprintf(buf, sizeof(buf) - 1, "%s:%s:monitor_%u", fClientControl->fName, fPlaybackDriverName, i + 1);

  892.             if ((port_index = fGraphManager->AllocatePort(fClientControl->fRefNum, buf, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput)) == NO_PORT) {

  893.                 jack_error("Cannot register monitor port for %s", buf);

  894.                 return -1;

  895.             } else {

  896.                 port = fGraphManager->GetPort(port_index);

  897.                 port->SetLatency(fEngineControl->fBufferSize);

  898.                 fMonitorPortList[i] = port_index;

  899.             }

  900.         }

  901.     }

  902. 

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

  904.     for (int i = 0; i < fCaptureChannels; i++) {

  905.         fJackInputData->mBuffers[i].mData = GetInputBuffer(i);

  906.     }

  907. 

  908.     return 0;

  909. }

  910. 

  911. int JackCoreAudioDriver::Start()

  912. {

  913.     JackLog("JackCoreAudioDriver::Start\n");

  914.     JackAudioDriver::Start();

  915. 

  916.     OSStatus err = AudioDeviceAddIOProc(fDeviceID, MeasureCallback, this);

  917.     if (err != noErr)

  918.         return -1;

  919. 

  920.     err = AudioOutputUnitStart(fAUHAL);

  921.     if (err != noErr)

  922.         return -1;

  923. 

  924.     if ((err = AudioDeviceStart(fDeviceID, MeasureCallback)) != noErr) {

  925.         jack_error("Cannot start MeasureCallback");

  926.         printError(err);

  927.         return -1;

  928.     }

  929. 

  930.     return 0;

  931. }

  932. 

  933. int JackCoreAudioDriver::Stop()

  934. {

  935.     AudioDeviceStop(fDeviceID, MeasureCallback);

  936.     AudioDeviceRemoveIOProc(fDeviceID, MeasureCallback);

  937.     JackLog("JackCoreAudioDriver::Stop\n");

  938.     return (AudioOutputUnitStop(fAUHAL) == noErr) ? 0 : -1;

  939. }

  940. 

  941. int JackCoreAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  942. {

  943.     OSStatus err;

  944.     UInt32 outSize = sizeof(UInt32);

  945. 

  946.     err = AudioDeviceSetProperty(fDeviceID, NULL, 0, false, kAudioDevicePropertyBufferFrameSize, outSize, &buffer_size);

  947.     if (err != noErr) {

  948.         jack_error("Cannot set buffer size %ld", buffer_size);

  949.         printError(err);

  950.         return -1;

  951.     }

  952. 	

  953. 	JackAudioDriver::SetBufferSize(buffer_size); // never fails

  954. 

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

  956.     for (int i = 0; i < fCaptureChannels; i++) {

  957.         fJackInputData->mBuffers[i].mNumberChannels = 1;

  958.         fJackInputData->mBuffers[i].mDataByteSize = fEngineControl->fBufferSize * sizeof(float);

  959.         fJackInputData->mBuffers[i].mData = GetInputBuffer(i);

  960.     }

  961. 

  962.     return 0;

  963. }

  964. 

  965. } // end of namespace

  966. 

  967. 

  968. #ifdef __cplusplus

  969. extern "C"

  970. {

  971. #endif

  972. 

  973.     jack_driver_desc_t* driver_get_descriptor() {

  974.         jack_driver_desc_t *desc;

  975.         unsigned int i;

  976.         desc = (jack_driver_desc_t*)calloc(1, sizeof(jack_driver_desc_t));

  977. 

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

  979.         desc->nparams = 13;

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

  981. 

  982.         i = 0;

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

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

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

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

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

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

  989. 

  990.         i++;

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

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

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

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

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

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

  997. 

  998.         i++;

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

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

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

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

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

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

  1005. 

  1006.         i++;

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

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

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

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

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

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

  1013. 

  1014.         i++;

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

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

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

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

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

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

  1021. 

  1022.         i++;

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

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

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

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

  1027.         strcpy(desc->params[i].short_desc, "Provide monitor ports for the output");

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

  1029. 

  1030.         i++;

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

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

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

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

  1035.         strcpy(desc->params[i].short_desc, "Provide both capture and playback ports");

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

  1037. 

  1038.         i++;

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

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

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

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

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

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

  1045. 

  1046.         i++;

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

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

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

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

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

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

  1053. 

  1054.         i++;

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

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

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

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

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

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

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

  1062. 

  1063.         i++;

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

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

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

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

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

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

  1070. 

  1071.         i++;

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

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

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

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

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

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

  1078. 

  1079.         i++;

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

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

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

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

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

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

  1086. 

  1087.         return desc;

  1088.     }

  1089. 

  1090.     Jack::JackDriverClientInterface* driver_initialize(Jack::JackEngine* engine, Jack::JackSynchro** table, const JSList* params) {

  1091.         jack_nframes_t srate = 44100;

  1092.         jack_nframes_t frames_per_interrupt = 128;

  1093.         int capture = FALSE;

  1094.         int playback = FALSE;

  1095.         int chan_in = 0;

  1096.         int chan_out = 0;

  1097.         bool monitor = false;

  1098.         char* capture_pcm_name = "";

  1099.         char* playback_pcm_name = "";

  1100.         const JSList *node;

  1101.         const jack_driver_param_t *param;

  1102.         jack_nframes_t systemic_input_latency = 0;

  1103.         jack_nframes_t systemic_output_latency = 0;

  1104. 

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

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

  1107. 

  1108.             switch (param->character) {

  1109. 

  1110.                 case 'd':

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

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

  1113.                     break;

  1114. 

  1115.                 case 'D':

  1116.                     capture = TRUE;

  1117.                     playback = TRUE;

  1118.                     break;

  1119. 

  1120.                 case 'c':

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

  1122.                     break;

  1123. 

  1124.                 case 'i':

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

  1126.                     break;

  1127. 

  1128.                 case 'o':

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

  1130.                     break;

  1131. 

  1132.                 case 'C':

  1133.                     capture = TRUE;

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

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

  1136.                     }

  1137.                     break;

  1138. 

  1139.                 case 'P':

  1140.                     playback = TRUE;

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

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

  1143.                     }

  1144.                     break;

  1145. 

  1146.                 case 'm':

  1147.                     monitor = param->value.i;

  1148.                     break;

  1149. 

  1150.                 case 'r':

  1151.                     srate = param->value.ui;

  1152.                     break;

  1153. 

  1154.                 case 'p':

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

  1156.                     break;

  1157. 

  1158.                 case 'I':

  1159.                     systemic_input_latency = param->value.ui;

  1160.                     break;

  1161. 

  1162.                 case 'O':

  1163.                     systemic_output_latency = param->value.ui;

  1164.                     break;

  1165. 

  1166.                 case 'l':

  1167.                     Jack::DisplayDeviceNames();

  1168.                     break;

  1169.             }

  1170.         }

  1171. 

  1172.         /* duplex is the default */

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

  1174.             capture = TRUE;

  1175.             playback = TRUE;

  1176.         }

  1177. 

  1178.         Jack::JackDriverClientInterface* driver = new Jack::JackCoreAudioDriver("coreaudio", engine, table);

  1179.         if (driver->Open(frames_per_interrupt, srate, capture, playback, chan_in, chan_out, monitor, capture_pcm_name, playback_pcm_name, systemic_input_latency, systemic_output_latency) == 0) {

  1180.             return driver;

  1181.         } else {

  1182.             delete driver;

  1183.             return NULL;

  1184.         }

  1185.     }

  1186. 

  1187. #ifdef __cplusplus

  1188. }

  1189. #endif

  1190.