interpretor/faust-0.9.47mr3/architecture/audio/coreaudio-dsp.h

   1 /************************************************************************
   2
   3         IMPORTANT NOTE : this file contains two clearly delimited sections :
   4         the ARCHITECTURE section (in two parts) and the USER section. Each section
   5         is governed by its own copyright and license. Please check individually
   6         each section for license and copyright information.
   7 *************************************************************************/
   8
   9 #ifndef __coreaudio_dsp__
  10 #define __coreaudio_dsp__
  11
  12 /*******************BEGIN ARCHITECTURE SECTION (part 1/2)****************/
  13
  14 /************************************************************************
  15     FAUST Architecture File
  16         Copyright (C) 2003-2011 GRAME, Centre National de Creation Musicale
  17     ---------------------------------------------------------------------
  18     This Architecture section is free software; you can redistribute it
  19     and/or modify it under the terms of the GNU General Public License
  20         as published by the Free Software Foundation; either version 3 of
  21         the License, or (at your option) any later version.
  22
  23     This program is distributed in the hope that it will be useful,
  24     but WITHOUT ANY WARRANTY; without even the implied warranty of
  25     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26     GNU General Public License for more details.
  27
  28     You should have received a copy of the GNU General Public License
  29         along with this program; If not, see <http://www.gnu.org/licenses/>.
  30
  31         EXCEPTION : As a special exception, you may create a larger work
  32         that contains this FAUST architecture section and distribute
  33         that work under terms of your choice, so long as this FAUST
  34         architecture section is not modified.
  35
  36
  37  ************************************************************************
  38  ************************************************************************/
  39
  40 #include <math.h>
  41 #include <stdlib.h>
  42 #include <stdio.h>
  43
  44 #include <vector>
  45 #include <iostream>
  46 #include <libgen.h>
  47
  48 #include <AudioToolbox/AudioConverter.h>
  49 #include <CoreAudio/CoreAudio.h>
  50 #include <AudioUnit/AudioUnit.h>
  51 #include <CoreServices/CoreServices.h>
  52
  53 #include "audio.h"
  54 #include "dsp.h"
  55
  56 using namespace std;
  57
  58 /******************************************************************************
  59 *******************************************************************************
  60
  61                                                         COREAUDIO INTERFACE
  62
  63 *******************************************************************************
  64 *******************************************************************************/
  65
  66 //----------------------------------------------------------------------------
  67 //      number of physical input and output channels of the CA device
  68 //----------------------------------------------------------------------------
  69
  70 int     gDevNumInChans;
  71 int     gDevNumOutChans;
  72
  73 //----------------------------------------------------------------------------
  74 // tables of noninterleaved input and output channels for FAUST
  75 //----------------------------------------------------------------------------
  76
  77 float*  gInChannel[256];
  78 float*  gOutChannel[256];
  79
  80 #define OPEN_ERR -1
  81 #define NO_ERR 0
  82
  83 #define WAIT_COUNTER 60
  84
  85 typedef UInt8   CAAudioHardwareDeviceSectionID;
  86 #define kAudioDeviceSectionInput        ((CAAudioHardwareDeviceSectionID)0x01)
  87 #define kAudioDeviceSectionOutput       ((CAAudioHardwareDeviceSectionID)0x00)
  88 #define kAudioDeviceSectionGlobal       ((CAAudioHardwareDeviceSectionID)0x00)
  89 #define kAudioDeviceSectionWildcard     ((CAAudioHardwareDeviceSectionID)0xFF)
  90
  91 dsp * gDsp;
  92
  93 class TCoreAudioRenderer
  94 {
  95     private:
  96                 AudioBufferList* fInputData;
  97                 AudioDeviceID fDeviceID;
  98                 AudioUnit fAUHAL;
  99         AudioObjectID fPluginID;    // Used for aggregate device
 100          bool fState;
 101
 102                 OSStatus GetDefaultDevice(int inChan, int outChan, int samplerate, AudioDeviceID* id);
 103
 104         OSStatus CreateAggregateDevice(AudioDeviceID captureDeviceID, AudioDeviceID playbackDeviceID, int samplerate, AudioDeviceID* outAggregateDevice);
 105         OSStatus CreateAggregateDeviceAux(vector<AudioDeviceID> captureDeviceID, vector<AudioDeviceID> playbackDeviceID, int samplerate, AudioDeviceID* outAggregateDevice);
 106         OSStatus DestroyAggregateDevice();
 107
 108         OSStatus GetDeviceNameFromID(AudioDeviceID id, char* name);
 109
 110         int SetupSampleRateAux(AudioDeviceID inDevice, int samplerate);
 111
 112                 static OSStatus Render(void *inRefCon,
 113                                AudioUnitRenderActionFlags *ioActionFlags,
 114                                const AudioTimeStamp *inTimeStamp,
 115                                UInt32 inBusNumber,
 116                                UInt32 inNumberFrames,
 117                                AudioBufferList *ioData);
 118
 119
 120         static OSStatus SRNotificationCallback(AudioDeviceID inDevice,
 121                                             UInt32 inChannel,
 122                                             Boolean     isInput,
 123                                             AudioDevicePropertyID inPropertyID,
 124                                             void* inClientData);
 125
 126     public:
 127
 128         TCoreAudioRenderer()
 129             :fInputData(0),fDeviceID(0),fAUHAL(0),fPluginID(0),fState(false)
 130         {}
 131         virtual ~TCoreAudioRenderer()
 132         {}
 133
 134         long OpenDefault(long inChan, long outChan, long bufferSize, long sampleRate);
 135         long Close();
 136
 137         long Start();
 138         long Stop();
 139
 140 };
 141
 142 typedef TCoreAudioRenderer * TCoreAudioRendererPtr;
 143
 144 static void PrintStreamDesc(AudioStreamBasicDescription *inDesc)
 145 {
 146     cout << "- - - - - - - - - - - - - - - - - - - -" << endl;
 147     cout << "  Sample Rate: "           << inDesc->mSampleRate  << endl;
 148     cout << "  Format ID:%.*s\n"        << sizeof(inDesc->mFormatID) << (char*)&inDesc->mFormatID << endl;
 149     cout << "  Format Flags "           << inDesc->mFormatFlags << endl;
 150     cout << "  Bytes per Packet: "      << inDesc->mBytesPerPacket << endl;
 151     cout << "  Frames per Packet: "     << inDesc->mFramesPerPacket << endl;
 152     cout << "  Bytes per Frame: "       << inDesc->mBytesPerFrame << endl;
 153     cout << "  Channels per Frame: "<< inDesc->mChannelsPerFrame << endl;
 154     cout << "  Bits per Channel: "      << inDesc->mBitsPerChannel << endl;
 155     cout << "- - - - - - - - - - - - - - - - - - - -" << endl;
 156 }
 157
 158 static void printError(OSStatus err)
 159 {
 160     switch (err) {
 161         case kAudioHardwareNoError:
 162             printf("error code : kAudioHardwareNoError\n");
 163             break;
 164                 case kAudioConverterErr_FormatNotSupported:
 165             printf("error code : kAudioConverterErr_FormatNotSupported\n");
 166             break;
 167         case kAudioConverterErr_OperationNotSupported:
 168             printf("error code : kAudioConverterErr_OperationNotSupported\n");
 169             break;
 170         case kAudioConverterErr_PropertyNotSupported:
 171             printf("error code : kAudioConverterErr_PropertyNotSupported\n");
 172             break;
 173         case kAudioConverterErr_InvalidInputSize:
 174             printf("error code : kAudioConverterErr_InvalidInputSize\n");
 175             break;
 176         case kAudioConverterErr_InvalidOutputSize:
 177             printf("error code : kAudioConverterErr_InvalidOutputSize\n");
 178             break;
 179         case kAudioConverterErr_UnspecifiedError:
 180             printf("error code : kAudioConverterErr_UnspecifiedError\n");
 181             break;
 182         case kAudioConverterErr_BadPropertySizeError:
 183             printf("error code : kAudioConverterErr_BadPropertySizeError\n");
 184             break;
 185         case kAudioConverterErr_RequiresPacketDescriptionsError:
 186             printf("error code : kAudioConverterErr_RequiresPacketDescriptionsError\n");
 187             break;
 188         case kAudioConverterErr_InputSampleRateOutOfRange:
 189             printf("error code : kAudioConverterErr_InputSampleRateOutOfRange\n");
 190             break;
 191         case kAudioConverterErr_OutputSampleRateOutOfRange:
 192             printf("error code : kAudioConverterErr_OutputSampleRateOutOfRange\n");
 193             break;
 194                 case kAudioHardwareNotRunningError:
 195             printf("error code : kAudioHardwareNotRunningError\n");
 196             break;
 197         case kAudioHardwareUnknownPropertyError:
 198             printf("error code : kAudioHardwareUnknownPropertyError\n");
 199             break;
 200         case kAudioHardwareIllegalOperationError:
 201             printf("error code : kAudioHardwareIllegalOperationError\n");
 202             break;
 203         case kAudioHardwareBadDeviceError:
 204             printf("error code : kAudioHardwareBadDeviceError\n");
 205             break;
 206         case kAudioHardwareBadStreamError:
 207             printf("error code : kAudioHardwareBadStreamError\n");
 208             break;
 209         case kAudioDeviceUnsupportedFormatError:
 210             printf("error code : kAudioDeviceUnsupportedFormatError\n");
 211             break;
 212         case kAudioDevicePermissionsError:
 213             printf("error code : kAudioDevicePermissionsError\n");
 214             break;
 215         default:
 216             printf("error code : unknown\n");
 217             break;
 218     }
 219 }
 220
 221 OSStatus TCoreAudioRenderer::Render(void *inRefCon,
 222                                      AudioUnitRenderActionFlags *ioActionFlags,
 223                                      const AudioTimeStamp *inTimeStamp,
 224                                      UInt32,
 225                                      UInt32 inNumberFrames,
 226                                      AudioBufferList *ioData)
 227 {
 228     TCoreAudioRendererPtr renderer = (TCoreAudioRendererPtr)inRefCon;
 229     AudioUnitRender(renderer->fAUHAL, ioActionFlags, inTimeStamp, 1, inNumberFrames, renderer->fInputData);
 230     for (int i = 0; i < gDevNumInChans; i++) {
 231         gInChannel[i] = (float*)renderer->fInputData->mBuffers[i].mData;
 232     }
 233     for (int i = 0; i < gDevNumOutChans; i++) {
 234         gOutChannel[i] = (float*)ioData->mBuffers[i].mData;
 235     }
 236     gDsp->compute((int)inNumberFrames, gInChannel, gOutChannel);
 237         return 0;
 238 }
 239
 240 static CFStringRef GetDeviceName(AudioDeviceID id)
 241 {
 242     UInt32 size = sizeof(CFStringRef);
 243     CFStringRef UIname;
 244     OSStatus err = AudioDeviceGetProperty(id, 0, false, kAudioDevicePropertyDeviceUID, &size, &UIname);
 245     return (err == noErr) ? UIname : NULL;
 246 }
 247
 248 OSStatus TCoreAudioRenderer::GetDeviceNameFromID(AudioDeviceID id, char* name)
 249 {
 250     UInt32 size = 256;
 251     return AudioDeviceGetProperty(id, 0, false, kAudioDevicePropertyDeviceName, &size, name);
 252 }
 253
 254 OSStatus TCoreAudioRenderer::GetDefaultDevice(int inChan, int outChan, int samplerate, AudioDeviceID* id)
 255 {
 256     UInt32 theSize = sizeof(UInt32);
 257     AudioDeviceID inDefault;
 258     AudioDeviceID outDefault;
 259         OSStatus res;
 260
 261     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice,
 262                                         &theSize, &inDefault)) != noErr)
 263         return res;
 264
 265     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice,
 266                                         &theSize, &outDefault)) != noErr)
 267         return res;
 268
 269         // Duplex mode
 270         if (inChan > 0 && outChan > 0) {
 271                 // Get the device only if default input and output are the same
 272                 if (inDefault == outDefault) {
 273                         *id = inDefault;
 274                         return noErr;
 275                 } else {
 276             printf("GetDefaultDevice : input = %ld and output = %ld are not the same, create aggregate device...\n", inDefault, outDefault);
 277             if (CreateAggregateDevice(inDefault, outDefault, samplerate, id) != noErr)
 278                 return kAudioHardwareBadDeviceError;
 279         }
 280         } else if (inChan > 0) {
 281                 *id = inDefault;
 282                 return noErr;
 283         } else if (outChan > 0) {
 284                 *id = outDefault;
 285                 return noErr;
 286         } else {
 287                 return kAudioHardwareBadDeviceError;
 288         }
 289
 290         return noErr;
 291 }
 292
 293 OSStatus TCoreAudioRenderer::CreateAggregateDevice(AudioDeviceID captureDeviceID, AudioDeviceID playbackDeviceID, int samplerate, AudioDeviceID* outAggregateDevice)
 294 {
 295     OSStatus err = noErr;
 296     AudioObjectID sub_device[32];
 297     UInt32 outSize = sizeof(sub_device);
 298
 299     err = AudioDeviceGetProperty(captureDeviceID, 0, kAudioDeviceSectionGlobal, kAudioAggregateDevicePropertyActiveSubDeviceList, &outSize, sub_device);
 300     vector<AudioDeviceID> captureDeviceIDArray;
 301
 302     if (err != noErr) {
 303         printf("Input device does not have subdevices\n");
 304         captureDeviceIDArray.push_back(captureDeviceID);
 305     } else {
 306         int num_devices = outSize / sizeof(AudioObjectID);
 307         printf("Input device has %d subdevices\n", num_devices);
 308         for (int i = 0; i < num_devices; i++) {
 309             captureDeviceIDArray.push_back(sub_device[i]);
 310         }
 311     }
 312
 313     err = AudioDeviceGetProperty(playbackDeviceID, 0, kAudioDeviceSectionGlobal, kAudioAggregateDevicePropertyActiveSubDeviceList, &outSize, sub_device);
 314     vector<AudioDeviceID> playbackDeviceIDArray;
 315
 316     if (err != noErr) {
 317         printf("Output device does not have subdevices\n");
 318         playbackDeviceIDArray.push_back(playbackDeviceID);
 319     } else {
 320         int num_devices = outSize / sizeof(AudioObjectID);
 321         printf("Output device has %d subdevices\n", num_devices);
 322         for (int i = 0; i < num_devices; i++) {
 323             playbackDeviceIDArray.push_back(sub_device[i]);
 324         }
 325     }
 326
 327     return CreateAggregateDeviceAux(captureDeviceIDArray, playbackDeviceIDArray, samplerate, outAggregateDevice);
 328 }
 329
 330
 331 OSStatus TCoreAudioRenderer::SRNotificationCallback(AudioDeviceID inDevice,
 332                                                     UInt32 /*inChannel*/,
 333                                                     Boolean     /*isInput*/,
 334                                                     AudioDevicePropertyID inPropertyID,
 335                                                     void* inClientData)
 336 {
 337     TCoreAudioRenderer* driver = (TCoreAudioRenderer*)inClientData;
 338
 339     switch (inPropertyID) {
 340
 341         case kAudioDevicePropertyNominalSampleRate: {
 342             printf("JackCoreAudioDriver::SRNotificationCallback kAudioDevicePropertyNominalSampleRate\n");
 343             driver->fState = true;
 344             // Check new sample rate
 345             Float64 sampleRate;
 346             UInt32 outSize =  sizeof(Float64);
 347             OSStatus err = AudioDeviceGetProperty(inDevice, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &sampleRate);
 348             if (err != noErr) {
 349                 printf("Cannot get current sample rate\n");
 350                 printError(err);
 351             } else {
 352                 printf("SRNotificationCallback : checked sample rate = %f\n", sampleRate);
 353             }
 354             break;
 355         }
 356     }
 357
 358     return noErr;
 359 }
 360
 361 int TCoreAudioRenderer::SetupSampleRateAux(AudioDeviceID inDevice, int samplerate)
 362 {
 363     OSStatus err = noErr;
 364     UInt32 outSize;
 365     Float64 sampleRate;
 366
 367     // Get sample rate
 368     outSize =  sizeof(Float64);
 369     err = AudioDeviceGetProperty(inDevice, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &sampleRate);
 370     if (err != noErr) {
 371         printf("Cannot get current sample rate\n");
 372         printError(err);
 373         return -1;
 374     } else {
 375         printf("Current sample rate = %f\n", sampleRate);
 376     }
 377
 378     // If needed, set new sample rate
 379     if (samplerate != (int)sampleRate) {
 380         sampleRate = (Float64)samplerate;
 381
 382         // To get SR change notification
 383         err = AudioDeviceAddPropertyListener(inDevice, 0, true, kAudioDevicePropertyNominalSampleRate, SRNotificationCallback, this);
 384         if (err != noErr) {
 385             printf("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyNominalSampleRate\n");
 386             printError(err);
 387             return -1;
 388         }
 389         err = AudioDeviceSetProperty(inDevice, NULL, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, outSize, &sampleRate);
 390         if (err != noErr) {
 391             printf("Cannot set sample rate = %d\n", samplerate);
 392             printError(err);
 393             return -1;
 394         }
 395
 396         // Waiting for SR change notification
 397         int count = 0;
 398         while (!fState && count++ < WAIT_COUNTER) {
 399             usleep(100000);
 400             printf("Wait count = %d\n", count);
 401         }
 402
 403         // Check new sample rate
 404         outSize =  sizeof(Float64);
 405         err = AudioDeviceGetProperty(inDevice, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &sampleRate);
 406         if (err != noErr) {
 407             printf("Cannot get current sample rate\n");
 408             printError(err);
 409         } else {
 410             printf("Checked sample rate = %f\n", sampleRate);
 411         }
 412
 413         // Remove SR change notification
 414         AudioDeviceRemovePropertyListener(inDevice, 0, true, kAudioDevicePropertyNominalSampleRate, SRNotificationCallback);
 415     }
 416
 417     return 0;
 418 }
 419
 420 OSStatus TCoreAudioRenderer::CreateAggregateDeviceAux(vector<AudioDeviceID> captureDeviceID, vector<AudioDeviceID> playbackDeviceID, int samplerate, AudioDeviceID* outAggregateDevice)
 421 {
 422     OSStatus osErr = noErr;
 423     UInt32 outSize;
 424     Boolean outWritable;
 425
 426     bool fClockDriftCompensate = true;
 427
 428     // Prepare sub-devices for clock drift compensation
 429     // Workaround for bug in the HAL : until 10.6.2
 430     AudioObjectPropertyAddress theAddressOwned = { kAudioObjectPropertyOwnedObjects, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
 431     AudioObjectPropertyAddress theAddressDrift = { kAudioSubDevicePropertyDriftCompensation, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
 432     UInt32 theQualifierDataSize = sizeof(AudioObjectID);
 433     AudioClassID inClass = kAudioSubDeviceClassID;
 434     void* theQualifierData = &inClass;
 435     UInt32 subDevicesNum = 0;
 436
 437     //---------------------------------------------------------------------------
 438     // Setup SR of both devices otherwise creating AD may fail...
 439     //---------------------------------------------------------------------------
 440     UInt32 keptclockdomain = 0;
 441     UInt32 clockdomain = 0;
 442     outSize = sizeof(UInt32);
 443     bool need_clock_drift_compensation = false;
 444
 445     for (UInt32 i = 0; i < captureDeviceID.size(); i++) {
 446         if (SetupSampleRateAux(captureDeviceID[i], samplerate) < 0) {
 447             printf("TCoreAudioRenderer::CreateAggregateDevice : cannot set SR of input device\n");
 448         } else  {
 449             // Check clock domain
 450             osErr = AudioDeviceGetProperty(captureDeviceID[i], 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyClockDomain, &outSize, &clockdomain);
 451             if (osErr != 0) {
 452                 printf("TCoreAudioRenderer::CreateAggregateDevice : kAudioDevicePropertyClockDomain error\n");
 453                 printError(osErr);
 454             } else {
 455                 keptclockdomain = (keptclockdomain == 0) ? clockdomain : keptclockdomain;
 456                 printf("TCoreAudioRenderer::CreateAggregateDevice : input clockdomain = %d\n", clockdomain);
 457                 if (clockdomain != 0 && clockdomain != keptclockdomain) {
 458                     printf("TCoreAudioRenderer::CreateAggregateDevice : devices do not share the same clock!! clock drift compensation would be needed...\n");
 459                     need_clock_drift_compensation = true;
 460                 }
 461             }
 462         }
 463     }
 464
 465     for (UInt32 i = 0; i < playbackDeviceID.size(); i++) {
 466         if (SetupSampleRateAux(playbackDeviceID[i], samplerate) < 0) {
 467             printf("TCoreAudioRenderer::CreateAggregateDevice : cannot set SR of output device\n");
 468         } else {
 469             // Check clock domain
 470             osErr = AudioDeviceGetProperty(playbackDeviceID[i], 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyClockDomain, &outSize, &clockdomain);
 471             if (osErr != 0) {
 472                 printf("TCoreAudioRenderer::CreateAggregateDevice : kAudioDevicePropertyClockDomain error\n");
 473                 printError(osErr);
 474             } else {
 475                 keptclockdomain = (keptclockdomain == 0) ? clockdomain : keptclockdomain;
 476                 printf("TCoreAudioRenderer::CreateAggregateDevice : output clockdomain = %d", clockdomain);
 477                 if (clockdomain != 0 && clockdomain != keptclockdomain) {
 478                     printf("TCoreAudioRenderer::CreateAggregateDevice : devices do not share the same clock!! clock drift compensation would be needed...\n");
 479                     need_clock_drift_compensation = true;
 480                 }
 481             }
 482         }
 483     }
 484
 485     // If no valid clock domain was found, then assume we have to compensate...
 486     if (keptclockdomain == 0) {
 487         need_clock_drift_compensation = true;
 488     }
 489
 490     //---------------------------------------------------------------------------
 491     // Start to create a new aggregate by getting the base audio hardware plugin
 492     //---------------------------------------------------------------------------
 493
 494     char device_name[256];
 495     for (UInt32 i = 0; i < captureDeviceID.size(); i++) {
 496         GetDeviceNameFromID(captureDeviceID[i], device_name);
 497         printf("Separated input = '%s' \n", device_name);
 498     }
 499
 500     for (UInt32 i = 0; i < playbackDeviceID.size(); i++) {
 501         GetDeviceNameFromID(playbackDeviceID[i], device_name);
 502         printf("Separated output = '%s' \n", device_name);
 503     }
 504
 505     osErr = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyPlugInForBundleID, &outSize, &outWritable);
 506     if (osErr != noErr) {
 507         printf("TCoreAudioRenderer::CreateAggregateDevice : AudioHardwareGetPropertyInfo kAudioHardwarePropertyPlugInForBundleID error\n");
 508         printError(osErr);
 509         return osErr;
 510     }
 511
 512     AudioValueTranslation pluginAVT;
 513
 514     CFStringRef inBundleRef = CFSTR("com.apple.audio.CoreAudio");
 515
 516     pluginAVT.mInputData = &inBundleRef;
 517     pluginAVT.mInputDataSize = sizeof(inBundleRef);
 518     pluginAVT.mOutputData = &fPluginID;
 519     pluginAVT.mOutputDataSize = sizeof(fPluginID);
 520
 521     osErr = AudioHardwareGetProperty(kAudioHardwarePropertyPlugInForBundleID, &outSize, &pluginAVT);
 522     if (osErr != noErr) {
 523         printf("TCoreAudioRenderer::CreateAggregateDevice : AudioHardwareGetProperty kAudioHardwarePropertyPlugInForBundleID error\n");
 524         printError(osErr);
 525         return osErr;
 526     }
 527
 528     //-------------------------------------------------
 529     // Create a CFDictionary for our aggregate device
 530     //-------------------------------------------------
 531
 532     CFMutableDictionaryRef aggDeviceDict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 533
 534     CFStringRef AggregateDeviceNameRef = CFSTR("JackDuplex");
 535     CFStringRef AggregateDeviceUIDRef = CFSTR("com.grame.JackDuplex");
 536
 537     // add the name of the device to the dictionary
 538     CFDictionaryAddValue(aggDeviceDict, CFSTR(kAudioAggregateDeviceNameKey), AggregateDeviceNameRef);
 539
 540     // add our choice of UID for the aggregate device to the dictionary
 541     CFDictionaryAddValue(aggDeviceDict, CFSTR(kAudioAggregateDeviceUIDKey), AggregateDeviceUIDRef);
 542
 543     // add a "private aggregate key" to the dictionary
 544     int value = 1;
 545     CFNumberRef AggregateDeviceNumberRef = CFNumberCreate(NULL, kCFNumberIntType, &value);
 546
 547     SInt32 system;
 548     Gestalt(gestaltSystemVersion, &system);
 549
 550     printf("TCoreAudioRenderer::CreateAggregateDevice : system version = %x limit = %x\n", system, 0x00001054);
 551
 552     // Starting with 10.5.4 systems, the AD can be internal... (better)
 553     if (system < 0x00001054) {
 554         printf("TCoreAudioRenderer::CreateAggregateDevice : public aggregate device....\n");
 555     } else {
 556         printf("TCoreAudioRenderer::CreateAggregateDevice : private aggregate device....\n");
 557         CFDictionaryAddValue(aggDeviceDict, CFSTR(kAudioAggregateDeviceIsPrivateKey), AggregateDeviceNumberRef);
 558     }
 559
 560     // Prepare sub-devices for clock drift compensation
 561     CFMutableArrayRef subDevicesArrayClock = NULL;
 562
 563     /*
 564     if (fClockDriftCompensate) {
 565         if (need_clock_drift_compensation) {
 566             jack_info("Clock drift compensation activated...");
 567             subDevicesArrayClock = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 568
 569             for (UInt32 i = 0; i < captureDeviceID.size(); i++) {
 570                 CFStringRef UID = GetDeviceName(captureDeviceID[i]);
 571                 if (UID) {
 572                     CFMutableDictionaryRef subdeviceAggDeviceDict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 573                     CFDictionaryAddValue(subdeviceAggDeviceDict, CFSTR(kAudioSubDeviceUIDKey), UID);
 574                     CFDictionaryAddValue(subdeviceAggDeviceDict, CFSTR(kAudioSubDeviceDriftCompensationKey), AggregateDeviceNumberRef);
 575                     //CFRelease(UID);
 576                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);
 577                 }
 578             }
 579
 580             for (UInt32 i = 0; i < playbackDeviceID.size(); i++) {
 581                 CFStringRef UID = GetDeviceName(playbackDeviceID[i]);
 582                 if (UID) {
 583                     CFMutableDictionaryRef subdeviceAggDeviceDict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 584                     CFDictionaryAddValue(subdeviceAggDeviceDict, CFSTR(kAudioSubDeviceUIDKey), UID);
 585                     CFDictionaryAddValue(subdeviceAggDeviceDict, CFSTR(kAudioSubDeviceDriftCompensationKey), AggregateDeviceNumberRef);
 586                     //CFRelease(UID);
 587                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);
 588                 }
 589             }
 590
 591             // add sub-device clock array for the aggregate device to the dictionary
 592             CFDictionaryAddValue(aggDeviceDict, CFSTR(kAudioAggregateDeviceSubDeviceListKey), subDevicesArrayClock);
 593         } else {
 594             jack_info("Clock drift compensation was asked but is not needed (devices use the same clock domain)");
 595         }
 596     }
 597     */
 598
 599     //-------------------------------------------------
 600     // Create a CFMutableArray for our sub-device list
 601     //-------------------------------------------------
 602
 603     // we need to append the UID for each device to a CFMutableArray, so create one here
 604     CFMutableArrayRef subDevicesArray = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 605
 606     vector<CFStringRef> captureDeviceUID;
 607     for (UInt32 i = 0; i < captureDeviceID.size(); i++) {
 608         CFStringRef ref = GetDeviceName(captureDeviceID[i]);
 609         if (ref == NULL)
 610             return -1;
 611         captureDeviceUID.push_back(ref);
 612         // input sub-devices in this example, so append the sub-device's UID to the CFArray
 613         CFArrayAppendValue(subDevicesArray, ref);
 614    }
 615
 616     vector<CFStringRef> playbackDeviceUID;
 617     for (UInt32 i = 0; i < playbackDeviceID.size(); i++) {
 618         CFStringRef ref = GetDeviceName(playbackDeviceID[i]);
 619         if (ref == NULL)
 620             return -1;
 621         playbackDeviceUID.push_back(ref);
 622         // output sub-devices in this example, so append the sub-device's UID to the CFArray
 623         CFArrayAppendValue(subDevicesArray, ref);
 624     }
 625
 626     //-----------------------------------------------------------------------
 627     // Feed the dictionary to the plugin, to create a blank aggregate device
 628     //-----------------------------------------------------------------------
 629
 630     AudioObjectPropertyAddress pluginAOPA;
 631     pluginAOPA.mSelector = kAudioPlugInCreateAggregateDevice;
 632     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;
 633     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;
 634     UInt32 outDataSize;
 635
 636     osErr = AudioObjectGetPropertyDataSize(fPluginID, &pluginAOPA, 0, NULL, &outDataSize);
 637     if (osErr != noErr) {
 638         printf("TCoreAudioRenderer::CreateAggregateDevice : AudioObjectGetPropertyDataSize error\n");
 639         printError(osErr);
 640         goto error;
 641     }
 642
 643     osErr = AudioObjectGetPropertyData(fPluginID, &pluginAOPA, sizeof(aggDeviceDict), &aggDeviceDict, &outDataSize, outAggregateDevice);
 644     if (osErr != noErr) {
 645         printf("TCoreAudioRenderer::CreateAggregateDevice : AudioObjectGetPropertyData error\n");
 646         printError(osErr);
 647         goto error;
 648     }
 649
 650     // pause for a bit to make sure that everything completed correctly
 651     // this is to work around a bug in the HAL where a new aggregate device seems to disappear briefly after it is created
 652     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);
 653
 654     //-------------------------
 655     // Set the sub-device list
 656     //-------------------------
 657
 658     pluginAOPA.mSelector = kAudioAggregateDevicePropertyFullSubDeviceList;
 659     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;
 660     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;
 661     outDataSize = sizeof(CFMutableArrayRef);
 662     osErr = AudioObjectSetPropertyData(*outAggregateDevice, &pluginAOPA, 0, NULL, outDataSize, &subDevicesArray);
 663     if (osErr != noErr) {
 664         printf("TCoreAudioRenderer::CreateAggregateDevice : AudioObjectSetPropertyData for sub-device list error\n");
 665         printError(osErr);
 666         goto error;
 667     }
 668
 669     // pause again to give the changes time to take effect
 670     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);
 671
 672     //-----------------------
 673     // Set the master device
 674     //-----------------------
 675
 676     // set the master device manually (this is the device which will act as the master clock for the aggregate device)
 677     // pass in the UID of the device you want to use
 678     pluginAOPA.mSelector = kAudioAggregateDevicePropertyMasterSubDevice;
 679     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;
 680     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;
 681     outDataSize = sizeof(CFStringRef);
 682     osErr = AudioObjectSetPropertyData(*outAggregateDevice, &pluginAOPA, 0, NULL, outDataSize, &captureDeviceUID[0]);  // First apture is master...
 683     if (osErr != noErr) {
 684         printf("TCoreAudioRenderer::CreateAggregateDevice : AudioObjectSetPropertyData for master device error\n");
 685         printError(osErr);
 686         goto error;
 687     }
 688
 689     // pause again to give the changes time to take effect
 690     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);
 691
 692     // Prepare sub-devices for clock drift compensation
 693     // Workaround for bug in the HAL : until 10.6.2
 694
 695     if (fClockDriftCompensate) {
 696         if (need_clock_drift_compensation) {
 697             printf("Clock drift compensation activated...\n");
 698
 699             // Get the property data size
 700             osErr = AudioObjectGetPropertyDataSize(*outAggregateDevice, &theAddressOwned, theQualifierDataSize, theQualifierData, &outSize);
 701             if (osErr != noErr) {
 702                 printf("TCoreAudioRenderer::CreateAggregateDevice kAudioObjectPropertyOwnedObjects error\n");
 703                 printError(osErr);
 704             }
 705
 706             //  Calculate the number of object IDs
 707             subDevicesNum = outSize / sizeof(AudioObjectID);
 708             printf("TCoreAudioRenderer::CreateAggregateDevice clock drift compensation, number of sub-devices = %d\n", subDevicesNum);
 709             AudioObjectID subDevices[subDevicesNum];
 710             outSize = sizeof(subDevices);
 711
 712             osErr = AudioObjectGetPropertyData(*outAggregateDevice, &theAddressOwned, theQualifierDataSize, theQualifierData, &outSize, subDevices);
 713             if (osErr != noErr) {
 714                 printf("TCoreAudioRenderer::CreateAggregateDevice kAudioObjectPropertyOwnedObjects error\n");
 715                 printError(osErr);
 716             }
 717
 718             // Set kAudioSubDevicePropertyDriftCompensation property...
 719             for (UInt32 index = 0; index < subDevicesNum; ++index) {
 720                 UInt32 theDriftCompensationValue = 1;
 721                 osErr = AudioObjectSetPropertyData(subDevices[index], &theAddressDrift, 0, NULL, sizeof(UInt32), &theDriftCompensationValue);
 722                 if (osErr != noErr) {
 723                     printf("TCoreAudioRenderer::CreateAggregateDevice kAudioSubDevicePropertyDriftCompensation error\n");
 724                     printError(osErr);
 725                 }
 726             }
 727         } else {
 728             printf("Clock drift compensation was asked but is not needed (devices use the same clock domain)\n");
 729         }
 730     }
 731
 732     // pause again to give the changes time to take effect
 733     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);
 734
 735     //----------
 736     // Clean up
 737     //----------
 738
 739     // release the private AD key
 740     CFRelease(AggregateDeviceNumberRef);
 741
 742     // release the CF objects we have created - we don't need them any more
 743     CFRelease(aggDeviceDict);
 744     CFRelease(subDevicesArray);
 745
 746     if (subDevicesArrayClock)
 747         CFRelease(subDevicesArrayClock);
 748
 749     // release the device UID
 750     for (UInt32 i = 0; i < captureDeviceUID.size(); i++) {
 751         CFRelease(captureDeviceUID[i]);
 752     }
 753
 754     for (UInt32 i = 0; i < playbackDeviceUID.size(); i++) {
 755         CFRelease(playbackDeviceUID[i]);
 756     }
 757
 758     printf("New aggregate device %d\n", *outAggregateDevice);
 759     return noErr;
 760
 761 error:
 762     DestroyAggregateDevice();
 763     return -1;
 764 }
 765
 766 OSStatus TCoreAudioRenderer::DestroyAggregateDevice()
 767 {
 768     OSStatus osErr = noErr;
 769     AudioObjectPropertyAddress pluginAOPA;
 770     pluginAOPA.mSelector = kAudioPlugInDestroyAggregateDevice;
 771     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;
 772     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;
 773     UInt32 outDataSize;
 774
 775     if (fPluginID > 0)   {
 776
 777         osErr = AudioObjectGetPropertyDataSize(fPluginID, &pluginAOPA, 0, NULL, &outDataSize);
 778         if (osErr != noErr) {
 779             printf("TCoreAudioRenderer::DestroyAggregateDevice : AudioObjectGetPropertyDataSize error\n");
 780             printError(osErr);
 781             return osErr;
 782         }
 783
 784         osErr = AudioObjectGetPropertyData(fPluginID, &pluginAOPA, 0, NULL, &outDataSize, &fDeviceID);
 785         if (osErr != noErr) {
 786             printf("TCoreAudioRenderer::DestroyAggregateDevice : AudioObjectGetPropertyData error\n");
 787             printError(osErr);
 788             return osErr;
 789         }
 790
 791     }
 792
 793     return noErr;
 794 }
 795
 796
 797 long TCoreAudioRenderer::OpenDefault(long inChan, long outChan, long bufferSize, long samplerate)
 798 {
 799         OSStatus err = noErr;
 800     ComponentResult err1;
 801     UInt32 outSize;
 802     UInt32 enableIO;
 803         Boolean isWritable;
 804         AudioStreamBasicDescription srcFormat, dstFormat, sampleRate;
 805     long in_nChannels, out_nChannels;
 806
 807     printf("OpenDefault inChan = %ld outChan = %ld bufferSize = %ld samplerate = %ld\n", inChan, outChan, bufferSize, samplerate);
 808
 809     SInt32 major;
 810     SInt32 minor;
 811     Gestalt(gestaltSystemVersionMajor, &major);
 812     Gestalt(gestaltSystemVersionMinor, &minor);
 813
 814     // Starting with 10.6 systems, the HAL notification thread is created internally
 815     if (major == 10 && minor >= 6) {
 816         CFRunLoopRef theRunLoop = NULL;
 817         AudioObjectPropertyAddress theAddress = { kAudioHardwarePropertyRunLoop, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
 818         OSStatus osErr = AudioObjectSetPropertyData (kAudioObjectSystemObject, &theAddress, 0, NULL, sizeof(CFRunLoopRef), &theRunLoop);
 819         if (osErr != noErr) {
 820             printf("TCoreAudioRenderer::Open kAudioHardwarePropertyRunLoop error\n");
 821             printError(osErr);
 822         }
 823     }
 824
 825         if (GetDefaultDevice(inChan, outChan, samplerate,&fDeviceID) != noErr) {
 826                 printf("Cannot open default device\n");
 827                 return OPEN_ERR;
 828         }
 829
 830         // Setting buffer size
 831     outSize = sizeof(UInt32);
 832     err = AudioDeviceSetProperty(fDeviceID, NULL, 0, false, kAudioDevicePropertyBufferFrameSize, outSize, &bufferSize);
 833     if (err != noErr) {
 834         printf("Cannot set buffer size %ld\n", bufferSize);
 835         printError(err);
 836         return OPEN_ERR;
 837     }
 838
 839     // Setting sample rate
 840     outSize = sizeof(AudioStreamBasicDescription);
 841     err = AudioDeviceGetProperty(fDeviceID, 0, false, kAudioDevicePropertyStreamFormat, &outSize, &sampleRate);
 842     if (err != noErr) {
 843         printf("Cannot get current sample rate\n");
 844         printError(err);
 845         return OPEN_ERR;
 846     }
 847
 848     if (samplerate != long(sampleRate.mSampleRate)) {
 849         sampleRate.mSampleRate = (Float64)(samplerate);
 850         err = AudioDeviceSetProperty(fDeviceID, NULL, 0, false, kAudioDevicePropertyStreamFormat, outSize, &sampleRate);
 851         if (err != noErr) {
 852             printf("Cannot set sample rate = %ld\n", samplerate);
 853             printError(err);
 854             return OPEN_ERR;
 855         }
 856     }
 857
 858     // AUHAL
 859     ComponentDescription cd = {kAudioUnitType_Output, kAudioUnitSubType_HALOutput, kAudioUnitManufacturer_Apple, 0, 0};
 860     Component HALOutput = FindNextComponent(NULL, &cd);
 861
 862     err1 = OpenAComponent(HALOutput, &fAUHAL);
 863     if (err1 != noErr) {
 864                 printf("Error calling OpenAComponent\n");
 865         printError(err1);
 866         goto error;
 867         }
 868
 869     err1 = AudioUnitInitialize(fAUHAL);
 870     if (err1 != noErr) {
 871                 printf("Cannot initialize AUHAL unit\n");
 872                 printError(err1);
 873         goto error;
 874         }
 875
 876     enableIO = 1;
 877     err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, &enableIO, sizeof(enableIO));
 878     if (err1 != noErr) {
 879         printf("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output\n");
 880         printError(err1);
 881         goto error;
 882     }
 883
 884     enableIO = 1;
 885     err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, &enableIO, sizeof(enableIO));
 886     if (err1 != noErr) {
 887         printf("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input\n");
 888         printError(err1);
 889         goto error;
 890     }
 891
 892     err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &fDeviceID, sizeof(AudioDeviceID));
 893     if (err1 != noErr) {
 894         printf("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_CurrentDevice\n");
 895         printError(err1);
 896         goto error;
 897     }
 898
 899     err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 1, (UInt32*)&bufferSize, sizeof(UInt32));
 900     if (err1 != noErr) {
 901         printf("Error calling AudioUnitSetProperty - kAudioUnitProperty_MaximumFramesPerSlice\n");
 902         printError(err1);
 903         goto error;
 904     }
 905
 906     err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 0, (UInt32*)&bufferSize, sizeof(UInt32));
 907     if (err1 != noErr) {
 908         printf("Error calling AudioUnitSetProperty - kAudioUnitProperty_MaximumFramesPerSlice\n");
 909         printError(err1);
 910         goto error;
 911     }
 912
 913     err1 = AudioUnitGetPropertyInfo(fAUHAL, kAudioOutputUnitProperty_ChannelMap, kAudioUnitScope_Input, 1, &outSize, &isWritable);
 914     if (err1 != noErr) {
 915         printf("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_ChannelMap-INFO 1\n");
 916         printError(err1);
 917     }
 918
 919     in_nChannels = (err1 == noErr) ? outSize / sizeof(SInt32) : 0;
 920     printf("in_nChannels = %ld\n", in_nChannels);
 921
 922     err1 = AudioUnitGetPropertyInfo(fAUHAL, kAudioOutputUnitProperty_ChannelMap, kAudioUnitScope_Output, 0, &outSize, &isWritable);
 923     if (err1 != noErr) {
 924         printf("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_ChannelMap-INFO 0\n");
 925         printError(err1);
 926     }
 927
 928     out_nChannels = (err1 == noErr) ? outSize / sizeof(SInt32) : 0;
 929     printf("out_nChannels = %ld\n", out_nChannels);
 930
 931     /*
 932     Just ignore this case : seems to work without any further change...
 933
 934     if (outChan > out_nChannels) {
 935         printf("This device hasn't required output channels\n");
 936         goto error;
 937     }
 938     if (inChan > in_nChannels) {
 939         printf("This device hasn't required input channels\n");
 940         goto error;
 941     }
 942     */
 943
 944     if (outChan < out_nChannels) {
 945         SInt32 chanArr[out_nChannels];
 946         for (int i = 0; i < out_nChannels; i++) {
 947             chanArr[i] = -1;
 948         }
 949         for (int i = 0; i < outChan; i++) {
 950             chanArr[i] = i;
 951         }
 952         err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_ChannelMap, kAudioUnitScope_Output, 0, chanArr, sizeof(SInt32) * out_nChannels);
 953         if (err1 != noErr) {
 954             printf("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_ChannelMap 0\n");
 955             printError(err1);
 956         }
 957     }
 958
 959     if (inChan < in_nChannels) {
 960         SInt32 chanArr[in_nChannels];
 961         for (int i = 0; i < in_nChannels; i++) {
 962             chanArr[i] = -1;
 963         }
 964         for (int i = 0; i < inChan; i++) {
 965             chanArr[i] = i;
 966         }
 967         AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_ChannelMap , kAudioUnitScope_Input, 1, chanArr, sizeof(SInt32) * in_nChannels);
 968         if (err1 != noErr) {
 969             printf("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_ChannelMap 1\n");
 970             printError(err1);
 971         }
 972     }
 973
 974     if (inChan > 0) {
 975         outSize = sizeof(AudioStreamBasicDescription);
 976         err1 = AudioUnitGetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &srcFormat, &outSize);
 977         if (err1 != noErr) {
 978             printf("Error calling AudioUnitGetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Output\n");
 979             printError(err1);
 980         }
 981         PrintStreamDesc(&srcFormat);
 982
 983         srcFormat.mSampleRate = samplerate;
 984         srcFormat.mFormatID = kAudioFormatLinearPCM;
 985         srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;
 986         srcFormat.mBytesPerPacket = sizeof(float);
 987         srcFormat.mFramesPerPacket = 1;
 988         srcFormat.mBytesPerFrame = sizeof(float);
 989         srcFormat.mChannelsPerFrame = inChan;
 990         srcFormat.mBitsPerChannel = 32;
 991
 992         PrintStreamDesc(&srcFormat);
 993
 994         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &srcFormat, sizeof(AudioStreamBasicDescription));
 995         if (err1 != noErr) {
 996             printf("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Output\n");
 997             printError(err1);
 998         }
 999     }
1000
1001     if (outChan > 0) {
1002         outSize = sizeof(AudioStreamBasicDescription);
1003         err1 = AudioUnitGetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &dstFormat, &outSize);
1004         if (err1 != noErr) {
1005             printf("Error calling AudioUnitGetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Output\n");
1006             printError(err1);
1007         }
1008         PrintStreamDesc(&dstFormat);
1009
1010         dstFormat.mSampleRate = samplerate;
1011         dstFormat.mFormatID = kAudioFormatLinearPCM;
1012         dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;
1013         dstFormat.mBytesPerPacket = sizeof(float);
1014         dstFormat.mFramesPerPacket = 1;
1015         dstFormat.mBytesPerFrame = sizeof(float);
1016         dstFormat.mChannelsPerFrame = outChan;
1017         dstFormat.mBitsPerChannel = 32;
1018
1019         PrintStreamDesc(&dstFormat);
1020
1021         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &dstFormat, sizeof(AudioStreamBasicDescription));
1022         if (err1 != noErr) {
1023             printf("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Output\n");
1024             printError(err1);
1025         }
1026     }
1027
1028     if (inChan > 0 && outChan == 0) {
1029         AURenderCallbackStruct output;
1030         output.inputProc = Render;
1031         output.inputProcRefCon = this;
1032         err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &output, sizeof(output));
1033         if (err1 != noErr) {
1034             printf("Error calling AudioUnitSetProperty - kAudioUnitProperty_SetRenderCallback 1\n");
1035             printError(err1);
1036             goto error;
1037         }
1038     } else {
1039         AURenderCallbackStruct output;
1040         output.inputProc = Render;
1041         output.inputProcRefCon = this;
1042         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &output, sizeof(output));
1043         if (err1 != noErr) {
1044             printf("Error calling AudioUnitSetProperty - kAudioUnitProperty_SetRenderCallback 0\n");
1045             printError(err1);
1046             goto error;
1047         }
1048     }
1049
1050     fInputData = (AudioBufferList*)malloc(sizeof(UInt32) + inChan * sizeof(AudioBuffer));
1051     if (fInputData == 0) {
1052                 printf("Cannot allocate memory for input buffers\n");
1053         goto error;
1054         }
1055     fInputData->mNumberBuffers = inChan;
1056
1057     // Prepare buffers
1058     for (int i = 0; i < inChan; i++) {
1059         fInputData->mBuffers[i].mNumberChannels = 1;
1060         fInputData->mBuffers[i].mData = malloc(bufferSize * sizeof(float));
1061         fInputData->mBuffers[i].mDataByteSize = bufferSize * sizeof(float);
1062     }
1063
1064     return NO_ERR;
1065
1066 error:
1067     AudioUnitUninitialize(fAUHAL);
1068     CloseComponent(fAUHAL);
1069     return OPEN_ERR;
1070 }
1071
1072 long TCoreAudioRenderer::Close()
1073 {
1074     for (int i = 0; i < gDevNumInChans; i++) {
1075         free(fInputData->mBuffers[i].mData);
1076     }
1077         free(fInputData);
1078         AudioUnitUninitialize(fAUHAL);
1079     CloseComponent(fAUHAL);
1080     DestroyAggregateDevice();
1081     return NO_ERR;
1082 }
1083
1084 long TCoreAudioRenderer::Start()
1085 {
1086         OSStatus err = AudioOutputUnitStart(fAUHAL);
1087
1088     if (err != noErr) {
1089         printf("Error while opening device : device open error \n");
1090         return OPEN_ERR;
1091     } else {
1092         return NO_ERR;
1093         }
1094 }
1095
1096 long TCoreAudioRenderer::Stop()
1097 {
1098     OSStatus err = AudioOutputUnitStop(fAUHAL);
1099
1100     if (err != noErr) {
1101         printf("Error while closing device : device close error \n");
1102         return OPEN_ERR;
1103     } else {
1104         return NO_ERR;
1105         }
1106 }
1107
1108
1109
1110 /******************************************************************************
1111 *******************************************************************************
1112
1113                                                         CORE AUDIO INTERFACE
1114
1115 *******************************************************************************
1116 *******************************************************************************/
1117 class coreaudio : public audio {
1118
1119     TCoreAudioRenderer audio_device;
1120         long                    fSampleRate, fFramesPerBuf;
1121
1122  public:
1123                          coreaudio(long srate, long fpb) : fSampleRate(srate), fFramesPerBuf(fpb) {}
1124         virtual ~coreaudio() {}
1125
1126         virtual bool init(const char* /*name*/, dsp* DSP) {
1127                 gDsp = DSP;
1128                 DSP->init (fSampleRate);
1129                 gDevNumInChans = DSP->getNumInputs();
1130                 gDevNumOutChans = DSP->getNumOutputs();
1131                 if (audio_device.OpenDefault(gDevNumInChans, gDevNumOutChans, fFramesPerBuf, fSampleRate) < 0) {
1132                         printf("Cannot open CoreAudio device\n");
1133                         return false;
1134                 }
1135         return true;
1136     }
1137
1138         virtual bool start() {
1139                 if (audio_device.Start() < 0) {
1140                         printf("Cannot start CoreAudio device\n");
1141                         return false;
1142                 }
1143                 return true;
1144         }
1145
1146         virtual void stop() {
1147                 audio_device.Stop();
1148                 audio_device.Close();
1149         }
1150
1151 };
1152
1153 #endif
1154
1155 /********************END ARCHITECTURE SECTION (part 2/2)****************/
1156
1157