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.
1111 Commits
8 Branches
339MB
Tree: 99fc35a33c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '99fc35a33c'
${ noResults }
jack2/macosx/JackCoreAudioAdapter.cpp

706 lines
25KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2008 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 "JackCoreAudioAdapter.h"

  21. #include "JackError.h"

  22. #include <unistd.h>

  23. 

  24. namespace Jack

  25. {

  26. 

  27. static void printError(OSStatus err)

  28. {

  29.     switch (err) {

  30.         case kAudioHardwareNoError:

  31.             jack_log("error code : kAudioHardwareNoError");

  32.             break;

  33.         case kAudioConverterErr_FormatNotSupported:

  34.             jack_log("error code : kAudioConverterErr_FormatNotSupported");

  35.             break;

  36.         case kAudioConverterErr_OperationNotSupported:

  37.             jack_log("error code : kAudioConverterErr_OperationNotSupported");

  38.             break;

  39.         case kAudioConverterErr_PropertyNotSupported:

  40.             jack_log("error code : kAudioConverterErr_PropertyNotSupported");

  41.             break;

  42.         case kAudioConverterErr_InvalidInputSize:

  43.             jack_log("error code : kAudioConverterErr_InvalidInputSize");

  44.             break;

  45.         case kAudioConverterErr_InvalidOutputSize:

  46.             jack_log("error code : kAudioConverterErr_InvalidOutputSize");

  47.             break;

  48.         case kAudioConverterErr_UnspecifiedError:

  49.             jack_log("error code : kAudioConverterErr_UnspecifiedError");

  50.             break;

  51.         case kAudioConverterErr_BadPropertySizeError:

  52.             jack_log("error code : kAudioConverterErr_BadPropertySizeError");

  53.             break;

  54.         case kAudioConverterErr_RequiresPacketDescriptionsError:

  55.             jack_log("error code : kAudioConverterErr_RequiresPacketDescriptionsError");

  56.             break;

  57.         case kAudioConverterErr_InputSampleRateOutOfRange:

  58.             jack_log("error code : kAudioConverterErr_InputSampleRateOutOfRange");

  59.             break;

  60.         case kAudioConverterErr_OutputSampleRateOutOfRange:

  61.             jack_log("error code : kAudioConverterErr_OutputSampleRateOutOfRange");

  62.             break;

  63.         case kAudioHardwareNotRunningError:

  64.             jack_log("error code : kAudioHardwareNotRunningError");

  65.             break;

  66.         case kAudioHardwareUnknownPropertyError:

  67.             jack_log("error code : kAudioHardwareUnknownPropertyError");

  68.             break;

  69.         case kAudioHardwareIllegalOperationError:

  70.             jack_log("error code : kAudioHardwareIllegalOperationError");

  71.             break;

  72.         case kAudioHardwareBadDeviceError:

  73.             jack_log("error code : kAudioHardwareBadDeviceError");

  74.             break;

  75.         case kAudioHardwareBadStreamError:

  76.             jack_log("error code : kAudioHardwareBadStreamError");

  77.             break;

  78.         case kAudioDeviceUnsupportedFormatError:

  79.             jack_log("error code : kAudioDeviceUnsupportedFormatError");

  80.             break;

  81.         case kAudioDevicePermissionsError:

  82.             jack_log("error code : kAudioDevicePermissionsError");

  83.             break;

  84.         case kAudioHardwareBadObjectError:

  85.             jack_log("error code : kAudioHardwareBadObjectError");

  86.             break;

  87.         case kAudioHardwareUnsupportedOperationError:

  88.             jack_log("error code : kAudioHardwareUnsupportedOperationError");

  89.             break;

  90.         default:

  91.             jack_log("error code : unknown");

  92.             break;

  93.     }

  94. }

  95. 

  96. OSStatus JackCoreAudioAdapter::SRNotificationCallback(AudioDeviceID inDevice,

  97.                                                         UInt32 inChannel,

  98.                                                         Boolean	isInput,

  99.                                                         AudioDevicePropertyID inPropertyID,

  100.                                                         void* inClientData)

  101. {

  102.     JackCoreAudioAdapter* driver = static_cast<JackCoreAudioAdapter*>(inClientData);

  103. 

  104.     switch (inPropertyID) {

  105. 

  106.         case kAudioDevicePropertyNominalSampleRate: {

  107.             jack_log("JackCoreAudioDriver::SRNotificationCallback kAudioDevicePropertyNominalSampleRate");

  108.             driver->fState = true;

  109.             break;

  110.         }

  111.     }

  112. 

  113.     return noErr;

  114. }

  115.             

  116. OSStatus JackCoreAudioAdapter::Render(void *inRefCon,

  117.                                         AudioUnitRenderActionFlags *ioActionFlags,

  118.                                         const AudioTimeStamp *inTimeStamp,

  119.                                         UInt32 inBusNumber,

  120.                                         UInt32 inNumberFrames,

  121.                                         AudioBufferList *ioData)

  122. {

  123.     JackCoreAudioAdapter* adapter = static_cast<JackCoreAudioAdapter*>(inRefCon);

  124.     AudioUnitRender(adapter->fAUHAL, ioActionFlags, inTimeStamp, 1, inNumberFrames, adapter->fInputData);

  125.     bool failure = false;

  126.       

  127.     jack_nframes_t time1, time2; 

  128.     adapter->ResampleFactor(time1, time2);

  129.      

  130.     for (int i = 0; i < adapter->fCaptureChannels; i++) {

  131.         adapter->fCaptureRingBuffer[i]->SetRatio(time1, time2);

  132.         if (adapter->fCaptureRingBuffer[i]->WriteResample((float*)adapter->fInputData->mBuffers[i].mData, inNumberFrames) < inNumberFrames)

  133.             failure = true;

  134.     }

  135.     

  136.     for (int i = 0; i < adapter->fPlaybackChannels; i++) {

  137.         adapter->fPlaybackRingBuffer[i]->SetRatio(time2, time1);

  138.         if (adapter->fPlaybackRingBuffer[i]->ReadResample((float*)ioData->mBuffers[i].mData, inNumberFrames) < inNumberFrames)

  139.              failure = true;

  140.     }

  141.     

  142. #ifdef DEBUG    

  143.     adapter->fTable.Write(time1, time2,  double(time1) / double(time2), double(time2) / double(time1), 

  144.          adapter->fCaptureRingBuffer[0]->ReadSpace(),  adapter->fPlaybackRingBuffer[0]->WriteSpace());

  145. #endif

  146.     

  147.     // Reset all ringbuffers in case of failure

  148.     if (failure) {

  149.         jack_error("JackCoreAudioAdapter::Render ringbuffer failure... reset");

  150.         adapter->ResetRingBuffers();

  151.     }

  152.     return noErr;

  153. }

  154. 

  155.  JackCoreAudioAdapter::JackCoreAudioAdapter(jack_nframes_t buffer_size, jack_nframes_t sample_rate, const JSList* params)

  156.                 :JackAudioAdapterInterface(buffer_size, sample_rate),fInputData(0),fState(false)

  157. {

  158. 

  159.     const JSList* node;

  160.     const jack_driver_param_t* param;

  161.     

  162.     fCaptureChannels = 2;

  163.     fPlaybackChannels = 2;

  164.     

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

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

  167.         

  168.         switch (param->character) {

  169.         

  170.             case 'c' :

  171.                 break;

  172.                 

  173.             case 'i':

  174.                 fCaptureChannels = param->value.ui;

  175.                 break;

  176.                 

  177.             case 'o':

  178.                 fPlaybackChannels = param->value.ui;

  179.                 break;

  180.                 

  181.             case 'C':

  182.                 break;

  183.                 

  184.             case 'P':

  185.                 break;

  186.                 

  187.             case 'D':

  188.                 break;

  189.                 

  190.             case 'r':

  191.                 SetIntSampleRate(param->value.ui);

  192.                 break;

  193.                 

  194.             case 'l':

  195.                 break;

  196.         }

  197.     }

  198. }

  199. 

  200. OSStatus JackCoreAudioAdapter::GetDefaultDevice(AudioDeviceID* id)

  201. {

  202.     OSStatus res;

  203.     UInt32 theSize = sizeof(UInt32);

  204.     AudioDeviceID inDefault;

  205.     AudioDeviceID outDefault;

  206. 

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

  208.         return res;

  209. 

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

  211.         return res;

  212. 

  213.     jack_log("GetDefaultDevice: input = %ld output = %ld", inDefault, outDefault);

  214. 

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

  216.     if (inDefault == outDefault) {

  217.         *id = inDefault;

  218.         return noErr;

  219.     } else {

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

  221.         return kAudioHardwareBadDeviceError;

  222.     }

  223. }

  224. 

  225. OSStatus JackCoreAudioAdapter::GetTotalChannels(AudioDeviceID device, int* channelCount, bool isInput)

  226. {

  227.     OSStatus err = noErr;

  228.     UInt32	outSize;

  229.     Boolean	outWritable;

  230.     AudioBufferList* bufferList = 0;

  231. 

  232.     *channelCount = 0;

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

  234.     if (err == noErr) {

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

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

  237.         if (err == noErr) {

  238.             for (unsigned int i = 0; i < bufferList->mNumberBuffers; i++)

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

  240.         }

  241. 

  242.         if (bufferList)

  243.             free(bufferList);

  244.     }

  245. 

  246.     return err;

  247. }

  248. 

  249. // Setup

  250. int JackCoreAudioAdapter::SetupDevices(const char* capture_driver_uid,

  251.                                         const char* playback_driver_uid,

  252.                                         char* capture_driver_name,

  253.                                         char* playback_driver_name)

  254. {

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

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

  257.         return -1;

  258.     }

  259.     

  260.     return 0;

  261. }

  262. 

  263. int JackCoreAudioAdapter::SetupChannels(bool capturing,

  264.                                         bool playing,

  265.                                         int& inchannels,

  266.                                         int& outchannels,

  267.                                         int& in_nChannels,

  268.                                         int& out_nChannels,

  269.                                         bool strict)

  270. {

  271.     OSStatus err = noErr;

  272.     

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

  274.     if (err != noErr) {

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

  276.         printError(err);

  277.         return -1;

  278.     }

  279.     

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

  281.     if (err != noErr) {

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

  283.         printError(err);

  284.         return -1;

  285.     }

  286.     

  287.     return 0;

  288. }

  289. 

  290. int JackCoreAudioAdapter::SetupBufferSizeAndSampleRate(jack_nframes_t nframes, jack_nframes_t samplerate)

  291. {

  292.     OSStatus err = noErr;

  293.     UInt32 outSize;

  294.     Float64 sampleRate;

  295. 

  296.     // Setting buffer size

  297.     outSize = sizeof(UInt32);

  298.     err = AudioDeviceSetProperty(fDeviceID, NULL, 0, false, kAudioDevicePropertyBufferFrameSize, outSize, &nframes);

  299.     if (err != noErr) {

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

  301.         printError(err);

  302.         return -1;

  303.     }

  304. 

  305.     // Get sample rate

  306.     outSize =  sizeof(Float64);

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

  308.     if (err != noErr) {

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

  310.         printError(err);

  311.         return -1;

  312.     }

  313. 

  314.     // If needed, set new sample rate

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

  316.         sampleRate = (Float64)samplerate;

  317. 

  318.         // To get SR change notification

  319.         err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioDevicePropertyNominalSampleRate, SRNotificationCallback, this);

  320.         if (err != noErr) {

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

  322.             printError(err);

  323.             return -1;

  324.         }

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

  326.         if (err != noErr) {

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

  328.             printError(err);

  329.             return -1;

  330.         }

  331. 

  332.         // Waiting for SR change notification

  333.         int count = 0;

  334.         while (!fState && count++ < 100) {

  335.             usleep(100000);

  336.             jack_log("Wait count = %ld", count);

  337.         }

  338. 

  339.         // Remove SR change notification

  340.         AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDevicePropertyNominalSampleRate, SRNotificationCallback);

  341.     }

  342. 

  343.     return 0;

  344. }

  345. 

  346. int JackCoreAudioAdapter::SetupBuffers(int inchannels, int outchannels)

  347. {

  348.     jack_log("JackCoreAudioAdapter::SetupBuffers: input = %ld output = %ld", inchannels, outchannels);

  349.     

  350.     // Prepare buffers

  351.     fInputData = (AudioBufferList*)malloc(sizeof(UInt32) + inchannels * sizeof(AudioBuffer));

  352.     if (fInputData == 0) {

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

  354.         return -1;

  355.     }

  356.     fInputData->mNumberBuffers = inchannels;

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

  358.         fInputData->mBuffers[i].mNumberChannels = 1;

  359.         fInputData->mBuffers[i].mDataByteSize = fBufferSize * sizeof(float);

  360.         fInputData->mBuffers[i].mData = malloc(fBufferSize * sizeof(float));

  361.     }

  362.     return 0;

  363. }

  364. 

  365. void JackCoreAudioAdapter::DisposeBuffers()

  366. {

  367.     if (fInputData) {

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

  369.             free(fInputData->mBuffers[i].mData);

  370.         free(fInputData);

  371.         fInputData = 0;

  372.     }

  373. }

  374. 

  375. int JackCoreAudioAdapter::OpenAUHAL(bool capturing,

  376.                                     bool playing,

  377.                                     int inchannels,

  378.                                     int outchannels,

  379.                                     int in_nChannels,

  380.                                     int out_nChannels,

  381.                                     jack_nframes_t nframes,

  382.                                     jack_nframes_t samplerate,

  383.                                     bool strict)

  384. {

  385.     ComponentResult err1;

  386.     UInt32 enableIO;

  387.     AudioStreamBasicDescription srcFormat, dstFormat;

  388. 

  389.     jack_log("OpenAUHAL capturing = %ld playing = %ld playing = %ld outchannels = %ld in_nChannels = %ld out_nChannels = %ld ", capturing, playing, inchannels, inchannels, in_nChannels, out_nChannels);

  390. 

  391.     // AUHAL

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

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

  394. 

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

  396.     if (err1 != noErr) {

  397.         jack_error("Error calling OpenAComponent");

  398.         printError(err1);

  399.         return -1;

  400.     }

  401. 

  402.     err1 = AudioUnitInitialize(fAUHAL);

  403.     if (err1 != noErr) {

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

  405.         printError(err1);

  406.         return -1;

  407.     }

  408. 

  409.     // Start I/O

  410.     enableIO = 1;

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

  412.         jack_log("Setup AUHAL input");

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

  414.         if (err1 != noErr) {

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

  416.             printError(err1);

  417.             if (strict)

  418.                 return -1;

  419.         }

  420.     }

  421. 

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

  423.         jack_log("Setup AUHAL output");

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

  425.         if (err1 != noErr) {

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

  427.             printError(err1);

  428.             if (strict)

  429.                 return -1;

  430.         }

  431.     }

  432. 

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

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

  435.     if (err1 != noErr) {

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

  437.         printError(err1);

  438.         if (strict)

  439.             return -1;

  440.     }

  441. 

  442.     // Set buffer size

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

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

  445.         if (err1 != noErr) {

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

  447.             printError(err1);

  448.             if (strict)

  449.                 return -1;

  450.         }

  451.     }

  452. 

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

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

  455.         if (err1 != noErr) {

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

  457.             printError(err1);

  458.             if (strict)

  459.                 return -1;

  460.         }

  461.     }

  462. 

  463.     // Setup channel map

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

  465.         SInt32 chanArr[in_nChannels];

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

  467.             chanArr[i] = -1;

  468.         }

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

  470.             chanArr[i] = i;

  471.         }

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

  473.         if (err1 != noErr) {

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

  475.             printError(err1);

  476.         }

  477.     }

  478. 

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

  480.         SInt32 chanArr[out_nChannels];

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

  482.             chanArr[i] = -1;

  483.         }

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

  485.             chanArr[i] = i;

  486.         }

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

  488.         if (err1 != noErr) {

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

  490.             printError(err1);

  491.         }

  492.     }

  493. 

  494.     // Setup stream converters

  495.     jack_log("Setup AUHAL input stream converter SR = %ld", samplerate);

  496.     srcFormat.mSampleRate = samplerate;

  497.     srcFormat.mFormatID = kAudioFormatLinearPCM;

  498.     srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  499.     srcFormat.mBytesPerPacket = sizeof(float);

  500.     srcFormat.mFramesPerPacket = 1;

  501.     srcFormat.mBytesPerFrame = sizeof(float);

  502.     srcFormat.mChannelsPerFrame = outchannels;

  503.     srcFormat.mBitsPerChannel = 32;

  504. 

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

  506.     if (err1 != noErr) {

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

  508.         printError(err1);

  509.     }

  510. 

  511.     jack_log("Setup AUHAL output stream converter SR = %ld", samplerate);

  512.     dstFormat.mSampleRate = samplerate;

  513.     dstFormat.mFormatID = kAudioFormatLinearPCM;

  514.     dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  515.     dstFormat.mBytesPerPacket = sizeof(float);

  516.     dstFormat.mFramesPerPacket = 1;

  517.     dstFormat.mBytesPerFrame = sizeof(float);

  518.     dstFormat.mChannelsPerFrame = inchannels;

  519.     dstFormat.mBitsPerChannel = 32;

  520. 

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

  522.     if (err1 != noErr) {

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

  524.         printError(err1);

  525.     }

  526. 

  527.     // Setup callbacks

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

  529.         AURenderCallbackStruct output;

  530.         output.inputProc = Render;

  531.         output.inputProcRefCon = this;

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

  533.         if (err1 != noErr) {

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

  535.             printError(err1);

  536.             return -1;

  537.         }

  538.     } else {

  539.         AURenderCallbackStruct output;

  540.         output.inputProc = Render;

  541.         output.inputProcRefCon = this;

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

  543.         if (err1 != noErr) {

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

  545.             printError(err1);

  546.             return -1;

  547.         }

  548.     }

  549. 

  550.     return 0;

  551. }

  552. 

  553. void JackCoreAudioAdapter::CloseAUHAL()

  554. {

  555.     AudioUnitUninitialize(fAUHAL);

  556.     CloseComponent(fAUHAL);

  557. }

  558.   

  559. int JackCoreAudioAdapter::Open()

  560. {

  561.     OSStatus err;

  562.     int in_nChannels = 0;

  563.     int out_nChannels = 0;

  564.    

  565.     if (SetupDevices("", "", "", "") < 0)

  566.         return -1;

  567. 

  568.     if (SetupChannels(true, true, fCaptureChannels, fPlaybackChannels, in_nChannels, out_nChannels, true) < 0)

  569.         return -1;

  570. 

  571.     if (SetupBufferSizeAndSampleRate(fBufferSize, fSampleRate)  < 0)

  572.         return -1;

  573. 

  574.     if (OpenAUHAL(true, true, fCaptureChannels, fPlaybackChannels, in_nChannels, out_nChannels, fBufferSize, fSampleRate, true) < 0)

  575.         goto error;

  576. 

  577.     if (SetupBuffers(fCaptureChannels, fPlaybackChannels) < 0)

  578.         goto error;

  579.         

  580.     err = AudioOutputUnitStart(fAUHAL);

  581.     if (err != noErr)

  582.         goto error;

  583.   

  584.     return 0;

  585. 

  586. error:

  587.     Close();

  588.     return -1;

  589. }

  590. 

  591. int JackCoreAudioAdapter::Close()

  592. {

  593. #ifdef DEBUG    

  594.     fTable.Save();

  595. #endif

  596.     AudioOutputUnitStop(fAUHAL);

  597.     DisposeBuffers();

  598.     CloseAUHAL();

  599.     return 0;

  600. }

  601. 

  602. int JackCoreAudioAdapter::SetBufferSize(jack_nframes_t buffer_size)

  603. {

  604.     JackAudioAdapterInterface::SetBufferSize(buffer_size);

  605.     Close();

  606.     return Open();

  607. }

  608. 

  609. } // namespace

  610. 

  611. #ifdef __cplusplus

  612. extern "C"

  613. {

  614. #endif

  615. 

  616.    EXPORT jack_driver_desc_t* jack_get_descriptor() 

  617.    {

  618.         jack_driver_desc_t *desc;

  619.         unsigned int i;

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

  621. 

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

  623.         desc->nparams = 9;

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

  625. 

  626.         i = 0;

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

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

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

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

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

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

  633. 

  634.         i++;

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

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

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

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

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

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

  641. 

  642.         i++;

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

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

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

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

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

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

  649. 

  650.         i++;

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

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

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

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

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

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

  657. 

  658.         i++;

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

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

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

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

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

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

  665.         

  666.         i++;

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

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

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

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

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

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

  673. 

  674.         i++;

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

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

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

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

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

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

  681. 

  682.         i++;

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

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

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

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

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

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

  689. 

  690.         i++;

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

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

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

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

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

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

  697.   

  698.         return desc;

  699.     }

  700. 

  701.    

  702. #ifdef __cplusplus

  703. }

  704. #endif