libs/ardour/audio_unit.cc

   1 /*
   2     Copyright (C) 2006 Paul Davis
   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 <sstream>
  21 #include <errno.h>
  22 #include <string.h>
  23
  24 #include "pbd/transmitter.h"
  25 #include "pbd/xml++.h"
  26 #include "pbd/whitespace.h"
  27 #include "pbd/pathscanner.h"
  28
  29 #include <glibmm/thread.h>
  30 #include <glibmm/fileutils.h>
  31 #include <glibmm/miscutils.h>
  32
  33 #include "ardour/ardour.h"
  34 #include "ardour/audioengine.h"
  35 #include "ardour/io.h"
  36 #include "ardour/audio_unit.h"
  37 #include "ardour/session.h"
  38 #include "ardour/utils.h"
  39
  40 #include <appleutility/CAAudioUnit.h>
  41 #include <appleutility/CAAUParameter.h>
  42
  43 #include <CoreFoundation/CoreFoundation.h>
  44 #include <CoreServices/CoreServices.h>
  45
  46 #include "i18n.h"
  47
  48 using namespace std;
  49 using namespace PBD;
  50 using namespace ARDOUR;
  51
  52 #ifndef AU_STATE_SUPPORT
  53 static bool seen_get_state_message = false;
  54 static bool seen_set_state_message = false;
  55 static bool seen_loading_message = false;
  56 static bool seen_saving_message = false;
  57 #endif
  58
  59 AUPluginInfo::CachedInfoMap AUPluginInfo::cached_info;
  60
  61 static string preset_search_path = "/Library/Audio/Presets:/Network/Library/Audio/Presets";
  62 static string preset_suffix = ".aupreset";
  63 static bool preset_search_path_initialized = false;
  64
  65 static OSStatus
  66 _render_callback(void *userData,
  67                  AudioUnitRenderActionFlags *ioActionFlags,
  68                  const AudioTimeStamp    *inTimeStamp,
  69                  UInt32       inBusNumber,
  70                  UInt32       inNumberFrames,
  71                  AudioBufferList*       ioData)
  72 {
  73         return ((AUPlugin*)userData)->render_callback (ioActionFlags, inTimeStamp, inBusNumber, inNumberFrames, ioData);
  74 }
  75
  76 static int
  77 save_property_list (CFPropertyListRef propertyList, Glib::ustring path)
  78
  79 {
  80         CFDataRef xmlData;
  81         int fd;
  82
  83         // Convert the property list into XML data.
  84
  85         xmlData = CFPropertyListCreateXMLData( kCFAllocatorDefault, propertyList);
  86
  87         if (!xmlData) {
  88                 error << _("Could not create XML version of property list") << endmsg;
  89                 return -1;
  90         }
  91
  92         // Write the XML data to the file.
  93
  94         fd = open (path.c_str(), O_WRONLY|O_CREAT|O_EXCL, 0664);
  95         while (fd < 0) {
  96                 if (errno == EEXIST) {
  97                         /* tell any UI's that this file already exists and ask them what to do */
  98                         bool overwrite = Plugin::PresetFileExists(); // EMIT SIGNAL
  99                         if (overwrite) {
 100                                 fd = open (path.c_str(), O_WRONLY, 0664);
 101                                 continue;
 102                         } else {
 103                                 return 0;
 104                         }
 105                 }
 106                 error << string_compose (_("Cannot open preset file %1 (%2)"), path, strerror (errno)) << endmsg;
 107                 CFRelease (xmlData);
 108                 return -1;
 109         }
 110
 111         size_t cnt = CFDataGetLength (xmlData);
 112
 113         if (write (fd, CFDataGetBytePtr (xmlData), cnt) != cnt) {
 114                 CFRelease (xmlData);
 115                 close (fd);
 116                 return -1;
 117         }
 118
 119         close (fd);
 120         return 0;
 121 }
 122
 123
 124 static CFPropertyListRef
 125 load_property_list (Glib::ustring path)
 126 {
 127         int fd;
 128         CFPropertyListRef propertyList;
 129         CFDataRef         xmlData;
 130         CFStringRef       errorString;
 131
 132         // Read the XML file.
 133
 134         if ((fd = open (path.c_str(), O_RDONLY)) < 0) {
 135                 return propertyList;
 136
 137         }
 138
 139         off_t len = lseek (fd, 0, SEEK_END);
 140         char* buf = new char[len];
 141         lseek (fd, 0, SEEK_SET);
 142
 143         if (read (fd, buf, len) != len) {
 144                 delete [] buf;
 145                 close (fd);
 146                 return propertyList;
 147         }
 148
 149         close (fd);
 150
 151         xmlData = CFDataCreateWithBytesNoCopy (kCFAllocatorDefault, (UInt8*) buf, len, kCFAllocatorNull);
 152
 153         // Reconstitute the dictionary using the XML data.
 154
 155         propertyList = CFPropertyListCreateFromXMLData( kCFAllocatorDefault,
 156                                                         xmlData,
 157                                                         kCFPropertyListImmutable,
 158                                                         &errorString);
 159
 160         CFRelease (xmlData);
 161         delete [] buf;
 162
 163         return propertyList;
 164 }
 165
 166 //-----------------------------------------------------------------------------
 167 static void
 168 set_preset_name_in_plist (CFPropertyListRef plist, string preset_name)
 169 {
 170         if (!plist) {
 171                 return;
 172         }
 173         CFStringRef pn = CFStringCreateWithCString (kCFAllocatorDefault, preset_name.c_str(), kCFStringEncodingUTF8);
 174
 175         if (CFGetTypeID (plist) == CFDictionaryGetTypeID()) {
 176                 CFDictionarySetValue ((CFMutableDictionaryRef)plist, CFSTR(kAUPresetNameKey), pn);
 177         }
 178
 179         CFRelease (pn);
 180 }
 181
 182 //-----------------------------------------------------------------------------
 183 static std::string
 184 get_preset_name_in_plist (CFPropertyListRef plist)
 185 {
 186         std::string ret;
 187
 188         if (!plist) {
 189                 return ret;
 190         }
 191
 192         if (CFGetTypeID (plist) == CFDictionaryGetTypeID()) {
 193                 const void *p = CFDictionaryGetValue ((CFMutableDictionaryRef)plist, CFSTR(kAUPresetNameKey));
 194                 if (p) {
 195                         CFStringRef str = (CFStringRef) p;
 196                         int len = CFStringGetLength(str);
 197                         len =  (len * 2) + 1;
 198                         char local_buffer[len];
 199                         if (CFStringGetCString (str, local_buffer, len, kCFStringEncodingUTF8)) {
 200                                 ret = local_buffer;
 201                         }
 202                 }
 203         }
 204         return ret;
 205 }
 206
 207 //--------------------------------------------------------------------------
 208 // general implementation for ComponentDescriptionsMatch() and ComponentDescriptionsMatch_Loosely()
 209 // if inIgnoreType is true, then the type code is ignored in the ComponentDescriptions
 210 Boolean ComponentDescriptionsMatch_General(const ComponentDescription * inComponentDescription1, const ComponentDescription * inComponentDescription2, Boolean inIgnoreType);
 211 Boolean ComponentDescriptionsMatch_General(const ComponentDescription * inComponentDescription1, const ComponentDescription * inComponentDescription2, Boolean inIgnoreType)
 212 {
 213         if ( (inComponentDescription1 == NULL) || (inComponentDescription2 == NULL) )
 214                 return FALSE;
 215
 216         if ( (inComponentDescription1->componentSubType == inComponentDescription2->componentSubType)
 217                         && (inComponentDescription1->componentManufacturer == inComponentDescription2->componentManufacturer) )
 218         {
 219                 // only sub-type and manufacturer IDs need to be equal
 220                 if (inIgnoreType)
 221                         return TRUE;
 222                 // type, sub-type, and manufacturer IDs all need to be equal in order to call this a match
 223                 else if (inComponentDescription1->componentType == inComponentDescription2->componentType)
 224                         return TRUE;
 225         }
 226
 227         return FALSE;
 228 }
 229
 230 //--------------------------------------------------------------------------
 231 // general implementation for ComponentAndDescriptionMatch() and ComponentAndDescriptionMatch_Loosely()
 232 // if inIgnoreType is true, then the type code is ignored in the ComponentDescriptions
 233 Boolean ComponentAndDescriptionMatch_General(Component inComponent, const ComponentDescription * inComponentDescription, Boolean inIgnoreType);
 234 Boolean ComponentAndDescriptionMatch_General(Component inComponent, const ComponentDescription * inComponentDescription, Boolean inIgnoreType)
 235 {
 236         OSErr status;
 237         ComponentDescription desc;
 238
 239         if ( (inComponent == NULL) || (inComponentDescription == NULL) )
 240                 return FALSE;
 241
 242         // get the ComponentDescription of the input Component
 243         status = GetComponentInfo(inComponent, &desc, NULL, NULL, NULL);
 244         if (status != noErr)
 245                 return FALSE;
 246
 247         // check if the Component's ComponentDescription matches the input ComponentDescription
 248         return ComponentDescriptionsMatch_General(&desc, inComponentDescription, inIgnoreType);
 249 }
 250
 251 //--------------------------------------------------------------------------
 252 // determine if 2 ComponentDescriptions are basically equal
 253 // (by that, I mean that the important identifying values are compared,
 254 // but not the ComponentDescription flags)
 255 Boolean ComponentDescriptionsMatch(const ComponentDescription * inComponentDescription1, const ComponentDescription * inComponentDescription2)
 256 {
 257         return ComponentDescriptionsMatch_General(inComponentDescription1, inComponentDescription2, FALSE);
 258 }
 259
 260 //--------------------------------------------------------------------------
 261 // determine if 2 ComponentDescriptions have matching sub-type and manufacturer codes
 262 Boolean ComponentDescriptionsMatch_Loose(const ComponentDescription * inComponentDescription1, const ComponentDescription * inComponentDescription2)
 263 {
 264         return ComponentDescriptionsMatch_General(inComponentDescription1, inComponentDescription2, TRUE);
 265 }
 266
 267 //--------------------------------------------------------------------------
 268 // determine if a ComponentDescription basically matches that of a particular Component
 269 Boolean ComponentAndDescriptionMatch(Component inComponent, const ComponentDescription * inComponentDescription)
 270 {
 271         return ComponentAndDescriptionMatch_General(inComponent, inComponentDescription, FALSE);
 272 }
 273
 274 //--------------------------------------------------------------------------
 275 // determine if a ComponentDescription matches only the sub-type and manufacturer codes of a particular Component
 276 Boolean ComponentAndDescriptionMatch_Loosely(Component inComponent, const ComponentDescription * inComponentDescription)
 277 {
 278         return ComponentAndDescriptionMatch_General(inComponent, inComponentDescription, TRUE);
 279 }
 280
 281
 282 AUPlugin::AUPlugin (AudioEngine& engine, Session& session, boost::shared_ptr<CAComponent> _comp)
 283         : Plugin (engine, session),
 284           comp (_comp),
 285           unit (new CAAudioUnit),
 286           initialized (false),
 287           buffers (0),
 288           current_maxbuf (0),
 289           current_offset (0),
 290           current_buffers (0),
 291         frames_processed (0)
 292 {
 293         if (!preset_search_path_initialized) {
 294                 Glib::ustring p = Glib::get_home_dir();
 295                 p += "/Library/Audio/Presets:";
 296                 p += preset_search_path;
 297                 preset_search_path = p;
 298                 preset_search_path_initialized = true;
 299         }
 300
 301         init ();
 302 }
 303
 304 AUPlugin::AUPlugin (const AUPlugin& other)
 305         : Plugin (other)
 306         , comp (other.get_comp())
 307         , unit (new CAAudioUnit)
 308         , initialized (false)
 309         , buffers (0)
 310         , current_maxbuf (0)
 311         , current_offset (0)
 312         , current_buffers (0)
 313         , frames_processed (0)
 314
 315 {
 316         init ();
 317 }
 318
 319 AUPlugin::~AUPlugin ()
 320 {
 321         if (unit) {
 322                 unit->Uninitialize ();
 323         }
 324
 325         if (buffers) {
 326                 free (buffers);
 327         }
 328 }
 329
 330
 331 void
 332 AUPlugin::init ()
 333 {
 334         OSErr err;
 335
 336         try {
 337                 err = CAAudioUnit::Open (*(comp.get()), *unit);
 338         } catch (...) {
 339                 error << _("Exception thrown during AudioUnit plugin loading - plugin ignored") << endmsg;
 340                 throw failed_constructor();
 341         }
 342
 343         if (err != noErr) {
 344                 error << _("AudioUnit: Could not convert CAComponent to CAAudioUnit") << endmsg;
 345                 throw failed_constructor ();
 346         }
 347
 348         AURenderCallbackStruct renderCallbackInfo;
 349
 350         renderCallbackInfo.inputProc = _render_callback;
 351         renderCallbackInfo.inputProcRefCon = this;
 352
 353         if ((err = unit->SetProperty (kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input,
 354                                          0, (void*) &renderCallbackInfo, sizeof(renderCallbackInfo))) != 0) {
 355                 cerr << "cannot install render callback (err = " << err << ')' << endl;
 356                 throw failed_constructor();
 357         }
 358
 359         unit->GetElementCount (kAudioUnitScope_Global, global_elements);
 360         unit->GetElementCount (kAudioUnitScope_Input, input_elements);
 361         unit->GetElementCount (kAudioUnitScope_Output, output_elements);
 362
 363         /* these keep track of *configured* channel set up,
 364            not potential set ups.
 365         */
 366
 367         input_channels = -1;
 368         output_channels = -1;
 369
 370         if (_set_block_size (_session.get_block_size())) {
 371                 error << _("AUPlugin: cannot set processing block size") << endmsg;
 372                 throw failed_constructor();
 373         }
 374
 375         discover_parameters ();
 376
 377         Plugin::setup_controls ();
 378 }
 379
 380 void
 381 AUPlugin::discover_parameters ()
 382 {
 383         /* discover writable parameters */
 384
 385         AudioUnitScope scopes[] = {
 386                 kAudioUnitScope_Global,
 387                 kAudioUnitScope_Output,
 388                 kAudioUnitScope_Input
 389         };
 390
 391         descriptors.clear ();
 392
 393         for (uint32_t i = 0; i < sizeof (scopes) / sizeof (scopes[0]); ++i) {
 394
 395                 AUParamInfo param_info (unit->AU(), false, false, scopes[i]);
 396
 397                 for (uint32_t i = 0; i < param_info.NumParams(); ++i) {
 398
 399                         AUParameterDescriptor d;
 400
 401                         d.id = param_info.ParamID (i);
 402
 403                         const CAAUParameter* param = param_info.GetParamInfo (d.id);
 404                         const AudioUnitParameterInfo& info (param->ParamInfo());
 405
 406                         const int len = CFStringGetLength (param->GetName());;
 407                         char local_buffer[len*2];
 408                         Boolean good = CFStringGetCString(param->GetName(),local_buffer,len*2,kCFStringEncodingMacRoman);
 409                         if (!good) {
 410                                 d.label = "???";
 411                         } else {
 412                                 d.label = local_buffer;
 413                         }
 414
 415                         d.scope = param_info.GetScope ();
 416                         d.element = param_info.GetElement ();
 417
 418                         /* info.units to consider */
 419                         /*
 420                           kAudioUnitParameterUnit_Generic             = 0
 421                           kAudioUnitParameterUnit_Indexed             = 1
 422                           kAudioUnitParameterUnit_Boolean             = 2
 423                           kAudioUnitParameterUnit_Percent             = 3
 424                           kAudioUnitParameterUnit_Seconds             = 4
 425                           kAudioUnitParameterUnit_SampleFrames        = 5
 426                           kAudioUnitParameterUnit_Phase               = 6
 427                           kAudioUnitParameterUnit_Rate                = 7
 428                           kAudioUnitParameterUnit_Hertz               = 8
 429                           kAudioUnitParameterUnit_Cents               = 9
 430                           kAudioUnitParameterUnit_RelativeSemiTones   = 10
 431                           kAudioUnitParameterUnit_MIDINoteNumber      = 11
 432                           kAudioUnitParameterUnit_MIDIController      = 12
 433                           kAudioUnitParameterUnit_Decibels            = 13
 434                           kAudioUnitParameterUnit_LinearGain          = 14
 435                           kAudioUnitParameterUnit_Degrees             = 15
 436                           kAudioUnitParameterUnit_EqualPowerCrossfade = 16
 437                           kAudioUnitParameterUnit_MixerFaderCurve1    = 17
 438                           kAudioUnitParameterUnit_Pan                 = 18
 439                           kAudioUnitParameterUnit_Meters              = 19
 440                           kAudioUnitParameterUnit_AbsoluteCents       = 20
 441                           kAudioUnitParameterUnit_Octaves             = 21
 442                           kAudioUnitParameterUnit_BPM                 = 22
 443                           kAudioUnitParameterUnit_Beats               = 23
 444                           kAudioUnitParameterUnit_Milliseconds        = 24
 445                           kAudioUnitParameterUnit_Ratio               = 25
 446                         */
 447
 448                         /* info.flags to consider */
 449
 450                         /*
 451
 452                           kAudioUnitParameterFlag_CFNameRelease       = (1L << 4)
 453                           kAudioUnitParameterFlag_HasClump            = (1L << 20)
 454                           kAudioUnitParameterFlag_HasName             = (1L << 21)
 455                           kAudioUnitParameterFlag_DisplayLogarithmic  = (1L << 22)
 456                           kAudioUnitParameterFlag_IsHighResolution    = (1L << 23)
 457                           kAudioUnitParameterFlag_NonRealTime         = (1L << 24)
 458                           kAudioUnitParameterFlag_CanRamp             = (1L << 25)
 459                           kAudioUnitParameterFlag_ExpertMode          = (1L << 26)
 460                           kAudioUnitParameterFlag_HasCFNameString     = (1L << 27)
 461                           kAudioUnitParameterFlag_IsGlobalMeta        = (1L << 28)
 462                           kAudioUnitParameterFlag_IsElementMeta       = (1L << 29)
 463                           kAudioUnitParameterFlag_IsReadable          = (1L << 30)
 464                           kAudioUnitParameterFlag_IsWritable          = (1L << 31)
 465                         */
 466
 467                         d.lower = info.minValue;
 468                         d.upper = info.maxValue;
 469                         d.default_value = info.defaultValue;
 470
 471                         d.integer_step = (info.unit & kAudioUnitParameterUnit_Indexed);
 472                         d.toggled = (info.unit & kAudioUnitParameterUnit_Boolean) ||
 473                                 (d.integer_step && ((d.upper - d.lower) == 1.0));
 474                         d.sr_dependent = (info.unit & kAudioUnitParameterUnit_SampleFrames);
 475                         d.automatable = !d.toggled &&
 476                                 !(info.flags & kAudioUnitParameterFlag_NonRealTime) &&
 477                                 (info.flags & kAudioUnitParameterFlag_IsWritable);
 478
 479                         d.logarithmic = (info.flags & kAudioUnitParameterFlag_DisplayLogarithmic);
 480                         d.unit = info.unit;
 481
 482                         d.step = 1.0;
 483                         d.smallstep = 0.1;
 484                         d.largestep = 10.0;
 485                         d.min_unbound = 0; // lower is bound
 486                         d.max_unbound = 0; // upper is bound
 487
 488                         descriptors.push_back (d);
 489                 }
 490         }
 491 }
 492
 493
 494 string
 495 AUPlugin::unique_id () const
 496 {
 497         return AUPluginInfo::stringify_descriptor (comp->Desc());
 498 }
 499
 500 const char *
 501 AUPlugin::label () const
 502 {
 503         return _info->name.c_str();
 504 }
 505
 506 uint32_t
 507 AUPlugin::parameter_count () const
 508 {
 509         return descriptors.size();
 510 }
 511
 512 float
 513 AUPlugin::default_value (uint32_t port)
 514 {
 515         if (port < descriptors.size()) {
 516                 return descriptors[port].default_value;
 517         }
 518
 519         return 0;
 520 }
 521
 522 nframes_t
 523 AUPlugin::latency () const
 524 {
 525         return unit->Latency() * _session.frame_rate();
 526 }
 527
 528 void
 529 AUPlugin::set_parameter (uint32_t which, float val)
 530 {
 531         if (which < descriptors.size()) {
 532                 const AUParameterDescriptor& d (descriptors[which]);
 533                 unit->SetParameter (d.id, d.scope, d.element, val);
 534         }
 535 }
 536
 537 float
 538 AUPlugin::get_parameter (uint32_t which) const
 539 {
 540         float val = 0.0;
 541         if (which < descriptors.size()) {
 542                 const AUParameterDescriptor& d (descriptors[which]);
 543                 unit->GetParameter(d.id, d.scope, d.element, val);
 544         }
 545         return val;
 546 }
 547
 548 int
 549 AUPlugin::get_parameter_descriptor (uint32_t which, ParameterDescriptor& pd) const
 550 {
 551         if (which < descriptors.size()) {
 552                 pd = descriptors[which];
 553                 return 0;
 554         }
 555         return -1;
 556 }
 557
 558 uint32_t
 559 AUPlugin::nth_parameter (uint32_t which, bool& ok) const
 560 {
 561         if (which < descriptors.size()) {
 562                 ok = true;
 563                 return which;
 564         }
 565         ok = false;
 566         return 0;
 567 }
 568
 569 void
 570 AUPlugin::activate ()
 571 {
 572         if (!initialized) {
 573                 OSErr err;
 574                 if ((err = unit->Initialize()) != noErr) {
 575                         error << string_compose (_("AUPlugin: %1 cannot initialize plugin (err = %2)"), name(), err) << endmsg;
 576                 } else {
 577                         frames_processed = 0;
 578                         initialized = true;
 579                 }
 580         }
 581 }
 582
 583 void
 584 AUPlugin::deactivate ()
 585 {
 586         unit->GlobalReset ();
 587 }
 588
 589 void
 590 AUPlugin::set_block_size (nframes_t nframes)
 591 {
 592         _set_block_size (nframes);
 593 }
 594
 595 int
 596 AUPlugin::_set_block_size (nframes_t nframes)
 597 {
 598         bool was_initialized = initialized;
 599         UInt32 numFrames = nframes;
 600         OSErr err;
 601
 602         if (initialized) {
 603                 unit->Uninitialize ();
 604                 initialized = false;
 605         }
 606
 607         if ((err = unit->SetProperty (kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global,
 608                                       0, &numFrames, sizeof (numFrames))) != noErr) {
 609                 cerr << "cannot set max frames (err = " << err << ')' << endl;
 610                 return -1;
 611         }
 612
 613         if (was_initialized) {
 614                 activate ();
 615         }
 616
 617         return 0;
 618 }
 619
 620 int32_t
 621 AUPlugin::configure_io (int32_t in, int32_t out)
 622 {
 623         AudioStreamBasicDescription streamFormat;
 624
 625         streamFormat.mSampleRate = _session.frame_rate();
 626         streamFormat.mFormatID = kAudioFormatLinearPCM;
 627         streamFormat.mFormatFlags = kAudioFormatFlagIsFloat|kAudioFormatFlagIsPacked|kAudioFormatFlagIsNonInterleaved;
 628
 629 #ifdef __LITTLE_ENDIAN__
 630         /* relax */
 631 #else
 632         streamFormat.mFormatFlags |= kAudioFormatFlagIsBigEndian;
 633 #endif
 634
 635         streamFormat.mBitsPerChannel = 32;
 636         streamFormat.mFramesPerPacket = 1;
 637
 638         /* apple says that for non-interleaved data, these
 639            values always refer to a single channel.
 640         */
 641         streamFormat.mBytesPerPacket = 4;
 642         streamFormat.mBytesPerFrame = 4;
 643
 644         streamFormat.mChannelsPerFrame = in;
 645
 646         if (set_input_format (streamFormat) != 0) {
 647                 return -1;
 648         }
 649
 650         streamFormat.mChannelsPerFrame = out;
 651
 652         if (set_output_format (streamFormat) != 0) {
 653                 return -1;
 654         }
 655
 656         return Plugin::configure_io (in, out);
 657 }
 658
 659 int32_t
 660 AUPlugin::can_do (int32_t in, int32_t& out)
 661 {
 662         // XXX as of May 13th 2008, AU plugin support returns a count of either 1 or -1. We never
 663         // attempt to multiply-instantiate plugins to meet io configurations.
 664
 665         int32_t plugcnt = -1;
 666         AUPluginInfoPtr pinfo = boost::dynamic_pointer_cast<AUPluginInfo>(get_info());
 667
 668         out = -1;
 669
 670         vector<pair<int,int> >& io_configs = pinfo->cache.io_configs;
 671
 672         for (vector<pair<int,int> >::iterator i = io_configs.begin(); i != io_configs.end(); ++i) {
 673
 674                 int32_t possible_in = i->first;
 675                 int32_t possible_out = i->second;
 676
 677                 if (possible_out == 0) {
 678                         warning << string_compose (_("AU %1 has zero outputs - configuration ignored"), name()) << endmsg;
 679                         continue;
 680                 }
 681
 682                 if (possible_in == 0) {
 683
 684                         /* instrument plugin, always legal but throws away inputs ...
 685                         */
 686
 687                         if (possible_out == -1) {
 688                                 /* out much match in (UNLIKELY!!) */
 689                                 out = in;
 690                                 plugcnt = 1;
 691                         } else if (possible_out == -2) {
 692                                 /* any configuration possible, pick matching */
 693                                 out = in;
 694                                 plugcnt = 1;
 695                         } else if (possible_out < -2) {
 696                                 /* explicit variable number of outputs, pick maximum */
 697                                 out = -possible_out;
 698                                 plugcnt = 1;
 699                         } else {
 700                                 /* exact number of outputs */
 701                                 out = possible_out;
 702                                 plugcnt = 1;
 703                         }
 704                 }
 705
 706                 if (possible_in == -1) {
 707
 708                         /* wildcard for input */
 709
 710                         if (possible_out == -1) {
 711                                 /* out much match in */
 712                                 out = in;
 713                                 plugcnt = 1;
 714                         } else if (possible_out == -2) {
 715                                 /* any configuration possible, pick matching */
 716                                 out = in;
 717                                 plugcnt = 1;
 718                         } else if (possible_out < -2) {
 719                                 /* explicit variable number of outputs, pick maximum */
 720                                 out = -possible_out;
 721                                 plugcnt = 1;
 722                         } else {
 723                                 /* exact number of outputs */
 724                                 out = possible_out;
 725                                 plugcnt = 1;
 726                         }
 727                 }
 728
 729                 if (possible_in == -2) {
 730
 731                         if (possible_out == -1) {
 732                                 /* any configuration possible, pick matching */
 733                                 out = in;
 734                                 plugcnt = 1;
 735                         } else if (possible_out == -2) {
 736                                 error << string_compose (_("AU plugin %1 has illegal IO configuration (-2,-2)"), name())
 737                                       << endmsg;
 738                                 plugcnt = -1;
 739                         } else if (possible_out < -2) {
 740                                 /* explicit variable number of outputs, pick maximum */
 741                                 out = -possible_out;
 742                                 plugcnt = 1;
 743                         } else {
 744                                 /* exact number of outputs */
 745                                 out = possible_out;
 746                                 plugcnt = 1;
 747                         }
 748                 }
 749
 750                 if (possible_in < -2) {
 751
 752                         /* explicit variable number of inputs */
 753
 754                         if (in > -possible_in) {
 755                                 /* request is too large */
 756                                 plugcnt = -1;
 757                         }
 758
 759                         if (possible_out == -1) {
 760                                 /* out must match in */
 761                                 out = in;
 762                                 plugcnt = 1;
 763                         } else if (possible_out == -2) {
 764                                 error << string_compose (_("AU plugin %1 has illegal IO configuration (-2,-2)"), name())
 765                                       << endmsg;
 766                                 plugcnt = -1;
 767                         } else if (possible_out < -2) {
 768                                 /* explicit variable number of outputs, pick maximum */
 769                                 out = -possible_out;
 770                                 plugcnt = 1;
 771                         } else {
 772                                 /* exact number of outputs */
 773                                 out = possible_out;
 774                                 plugcnt = 1;
 775                         }
 776                 }
 777
 778                 if (possible_in == in) {
 779
 780                         /* exact number of inputs ... must match obviously */
 781
 782                         if (possible_out == -1) {
 783                                 /* out must match in */
 784                                 out = in;
 785                                 plugcnt = 1;
 786                         } else if (possible_out == -2) {
 787                                 /* any output configuration, pick matching */
 788                                 out = in;
 789                                 plugcnt = -1;
 790                         } else if (possible_out < -2) {
 791                                 /* explicit variable number of outputs, pick maximum */
 792                                 out = -possible_out;
 793                                 plugcnt = 1;
 794                         } else {
 795                                 /* exact number of outputs */
 796                                 out = possible_out;
 797                                 plugcnt = 1;
 798                         }
 799                 }
 800
 801                 if (plugcnt == 1) {
 802                         break;
 803                 }
 804         }
 805
 806         /* no fit */
 807         return plugcnt;
 808 }
 809
 810 int
 811 AUPlugin::set_input_format (AudioStreamBasicDescription& fmt)
 812 {
 813         return set_stream_format (kAudioUnitScope_Input, input_elements, fmt);
 814 }
 815
 816 int
 817 AUPlugin::set_output_format (AudioStreamBasicDescription& fmt)
 818 {
 819         if (set_stream_format (kAudioUnitScope_Output, output_elements, fmt) != 0) {
 820                 return -1;
 821         }
 822
 823         if (buffers) {
 824                 free (buffers);
 825                 buffers = 0;
 826         }
 827
 828         buffers = (AudioBufferList *) malloc (offsetof(AudioBufferList, mBuffers) +
 829                                               fmt.mChannelsPerFrame * sizeof(AudioBuffer));
 830
 831         Glib::Mutex::Lock em (_session.engine().process_lock());
 832         IO::MoreOutputs (fmt.mChannelsPerFrame);
 833
 834         return 0;
 835 }
 836
 837 int
 838 AUPlugin::set_stream_format (int scope, uint32_t cnt, AudioStreamBasicDescription& fmt)
 839 {
 840         OSErr result;
 841
 842         for (uint32_t i = 0; i < cnt; ++i) {
 843                 if ((result = unit->SetFormat (scope, i, fmt)) != 0) {
 844                         error << string_compose (_("AUPlugin: could not set stream format for %1/%2 (err = %3)"),
 845                                                  (scope == kAudioUnitScope_Input ? "input" : "output"), i, result) << endmsg;
 846                         return -1;
 847                 }
 848         }
 849
 850         if (scope == kAudioUnitScope_Input) {
 851                 input_channels = fmt.mChannelsPerFrame;
 852         } else {
 853                 output_channels = fmt.mChannelsPerFrame;
 854         }
 855
 856         return 0;
 857 }
 858
 859 uint32_t
 860 AUPlugin::input_streams() const
 861 {
 862         if (input_channels < 0) {
 863                 warning << string_compose (_("AUPlugin: %1 input_streams() called without any format set!"), name()) << endmsg;
 864                 return 1;
 865         }
 866         return input_channels;
 867 }
 868
 869
 870 uint32_t
 871 AUPlugin::output_streams() const
 872 {
 873         if (output_channels < 0) {
 874                 warning << string_compose (_("AUPlugin: %1 output_streams() called without any format set!"), name()) << endmsg;
 875                 return 1;
 876         }
 877         return output_channels;
 878 }
 879
 880 OSStatus
 881 AUPlugin::render_callback(AudioUnitRenderActionFlags *ioActionFlags,
 882                           const AudioTimeStamp    *inTimeStamp,
 883                           UInt32       inBusNumber,
 884                           UInt32       inNumberFrames,
 885                           AudioBufferList*       ioData)
 886 {
 887         /* not much to do - the data is already in the buffers given to us in connect_and_run() */
 888
 889         if (current_maxbuf == 0) {
 890                 error << _("AUPlugin: render callback called illegally!") << endmsg;
 891                 return kAudioUnitErr_CannotDoInCurrentContext;
 892         }
 893
 894         for (uint32_t i = 0; i < current_maxbuf; ++i) {
 895                 ioData->mBuffers[i].mNumberChannels = 1;
 896                 ioData->mBuffers[i].mDataByteSize = sizeof (Sample) * inNumberFrames;
 897                 ioData->mBuffers[i].mData = (*current_buffers)[i] + cb_offset + current_offset;
 898         }
 899
 900         cb_offset += inNumberFrames;
 901
 902         return noErr;
 903 }
 904
 905 int
 906 AUPlugin::connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in, int32_t& out, nframes_t nframes, nframes_t offset)
 907 {
 908         AudioUnitRenderActionFlags flags = 0;
 909         AudioTimeStamp ts;
 910
 911         current_buffers = &bufs;
 912         current_maxbuf = maxbuf;
 913         current_offset = offset;
 914         cb_offset = 0;
 915
 916         buffers->mNumberBuffers = maxbuf;
 917
 918         for (uint32_t i = 0; i < maxbuf; ++i) {
 919                 buffers->mBuffers[i].mNumberChannels = 1;
 920                 buffers->mBuffers[i].mDataByteSize = nframes * sizeof (Sample);
 921                 buffers->mBuffers[i].mData = 0;
 922         }
 923
 924         ts.mSampleTime = frames_processed;
 925         ts.mFlags = kAudioTimeStampSampleTimeValid;
 926
 927         if (unit->Render (&flags, &ts, 0, nframes, buffers) == noErr) {
 928
 929                 current_maxbuf = 0;
 930                 frames_processed += nframes;
 931
 932                 for (uint32_t i = 0; i < maxbuf; ++i) {
 933                         if (bufs[i] + offset != buffers->mBuffers[i].mData) {
 934                                 memcpy (bufs[i]+offset, buffers->mBuffers[i].mData, nframes * sizeof (Sample));
 935                         }
 936                 }
 937                 return 0;
 938         }
 939
 940         return -1;
 941 }
 942
 943 set<uint32_t>
 944 AUPlugin::automatable() const
 945 {
 946         set<uint32_t> automates;
 947
 948         for (uint32_t i = 0; i < descriptors.size(); ++i) {
 949                 if (descriptors[i].automatable) {
 950                         automates.insert (i);
 951                 }
 952         }
 953
 954         return automates;
 955 }
 956
 957 string
 958 AUPlugin::describe_parameter (uint32_t param)
 959 {
 960         return descriptors[param].label;
 961 }
 962
 963 void
 964 AUPlugin::print_parameter (uint32_t param, char* buf, uint32_t len) const
 965 {
 966         // NameValue stuff here
 967 }
 968
 969 bool
 970 AUPlugin::parameter_is_audio (uint32_t) const
 971 {
 972         return false;
 973 }
 974
 975 bool
 976 AUPlugin::parameter_is_control (uint32_t) const
 977 {
 978         return true;
 979 }
 980
 981 bool
 982 AUPlugin::parameter_is_input (uint32_t) const
 983 {
 984         return false;
 985 }
 986
 987 bool
 988 AUPlugin::parameter_is_output (uint32_t) const
 989 {
 990         return false;
 991 }
 992
 993 XMLNode&
 994 AUPlugin::get_state()
 995 {
 996         LocaleGuard lg (X_("POSIX"));
 997         XMLNode *root = new XMLNode (state_node_name());
 998
 999 #ifdef AU_STATE_SUPPORT
1000         CFDataRef xmlData;
1001         CFPropertyListRef propertyList;
1002
1003         if (unit->GetAUPreset (propertyList) != noErr) {
1004                 return *root;
1005         }
1006
1007         // Convert the property list into XML data.
1008
1009         xmlData = CFPropertyListCreateXMLData( kCFAllocatorDefault, propertyList);
1010
1011         if (!xmlData) {
1012                 error << _("Could not create XML version of property list") << endmsg;
1013                 return *root;
1014         }
1015
1016         /* re-parse XML bytes to create a libxml++ XMLTree that we can merge into
1017            our state node. GACK!
1018         */
1019
1020         XMLTree t;
1021
1022         if (t.read_buffer (string ((const char*) CFDataGetBytePtr (xmlData), CFDataGetLength (xmlData)))) {
1023                 if (t.root()) {
1024                         root->add_child_copy (*t.root());
1025                 }
1026         }
1027
1028         CFRelease (xmlData);
1029         CFRelease (propertyList);
1030 #else
1031         if (!seen_get_state_message) {
1032                 info << _("Saving AudioUnit settings is not supported in this build of Ardour. Consider paying for a newer version")
1033                      << endmsg;
1034                 seen_get_state_message = true;
1035         }
1036 #endif
1037
1038         return *root;
1039 }
1040
1041 int
1042 AUPlugin::set_state(const XMLNode& node)
1043 {
1044 #ifdef AU_STATE_SUPPORT
1045         int ret = -1;
1046         CFPropertyListRef propertyList;
1047         LocaleGuard lg (X_("POSIX"));
1048
1049         if (node.name() != state_node_name()) {
1050                 error << _("Bad node sent to AUPlugin::set_state") << endmsg;
1051                 return -1;
1052         }
1053
1054         if (node.children().empty()) {
1055                 return -1;
1056         }
1057
1058         XMLNode* top = node.children().front();
1059         XMLNode* copy = new XMLNode (*top);
1060
1061         XMLTree t;
1062         t.set_root (copy);
1063
1064         const string& xml = t.write_buffer ();
1065         CFDataRef xmlData = CFDataCreateWithBytesNoCopy (kCFAllocatorDefault, (UInt8*) xml.data(), xml.length(), kCFAllocatorNull);
1066         CFStringRef errorString;
1067
1068         propertyList = CFPropertyListCreateFromXMLData( kCFAllocatorDefault,
1069                                                         xmlData,
1070                                                         kCFPropertyListImmutable,
1071                                                         &errorString);
1072
1073         CFRelease (xmlData);
1074
1075         if (propertyList) {
1076                 if (unit->SetAUPreset (propertyList) == noErr) {
1077                         ret = 0;
1078                 }
1079                 CFRelease (propertyList);
1080         }
1081
1082         return ret;
1083 #else
1084         if (!seen_set_state_message) {
1085                 info << _("Restoring AudioUnit settings is not supported in this build of Ardour. Consider paying for a newer version")
1086                      << endmsg;
1087         }
1088         return 0;
1089 #endif
1090 }
1091
1092 bool
1093 AUPlugin::load_preset (const string preset_label)
1094 {
1095 #ifdef AU_STATE_SUPPORT
1096         bool ret = false;
1097         CFPropertyListRef propertyList;
1098         Glib::ustring path;
1099         PresetMap::iterator x = preset_map.find (preset_label);
1100
1101         if (x == preset_map.end()) {
1102                 return false;
1103         }
1104
1105         if ((propertyList = load_property_list (x->second)) != 0) {
1106                 if (unit->SetAUPreset (propertyList) == noErr) {
1107                         ret = true;
1108                 }
1109                 CFRelease(propertyList);
1110         }
1111
1112         return ret;
1113 #else
1114         if (!seen_loading_message) {
1115                 info << _("Loading AudioUnit presets is not supported in this build of Ardour. Consider paying for a newer version")
1116                      << endmsg;
1117                 seen_loading_message = true;
1118         }
1119         return true;
1120 #endif
1121 }
1122
1123 bool
1124 AUPlugin::save_preset (string preset_name)
1125 {
1126 #ifdef AU_STATE_SUPPORT
1127         CFPropertyListRef propertyList;
1128         vector<Glib::ustring> v;
1129         Glib::ustring user_preset_path;
1130         bool ret = true;
1131
1132         std::string m = maker();
1133         std::string n = name();
1134
1135         strip_whitespace_edges (m);
1136         strip_whitespace_edges (n);
1137
1138         v.push_back (Glib::get_home_dir());
1139         v.push_back ("Library");
1140         v.push_back ("Audio");
1141         v.push_back ("Presets");
1142         v.push_back (m);
1143         v.push_back (n);
1144
1145         user_preset_path = Glib::build_filename (v);
1146
1147         if (g_mkdir_with_parents (user_preset_path.c_str(), 0775) < 0) {
1148                 error << string_compose (_("Cannot create user plugin presets folder (%1)"), user_preset_path) << endmsg;
1149                 return false;
1150         }
1151
1152         if (unit->GetAUPreset (propertyList) != noErr) {
1153                 return false;
1154         }
1155
1156         // add the actual preset name */
1157
1158         v.push_back (preset_name + preset_suffix);
1159
1160         // rebuild
1161
1162         user_preset_path = Glib::build_filename (v);
1163
1164         set_preset_name_in_plist (propertyList, preset_name);
1165
1166         if (save_property_list (propertyList, user_preset_path)) {
1167                 error << string_compose (_("Saving plugin state to %1 failed"), user_preset_path) << endmsg;
1168                 ret = false;
1169         }
1170
1171         CFRelease(propertyList);
1172
1173         return ret;
1174 #else
1175         if (!seen_saving_message) {
1176                 info << _("Saving AudioUnit presets is not supported in this build of Ardour. Consider paying for a newer version")
1177                      << endmsg;
1178                 seen_saving_message = true;
1179         }
1180         return false;
1181 #endif
1182 }
1183
1184 //-----------------------------------------------------------------------------
1185 // this is just a little helper function used by GetAUComponentDescriptionFromPresetFile()
1186 static SInt32
1187 GetDictionarySInt32Value(CFDictionaryRef inAUStateDictionary, CFStringRef inDictionaryKey, Boolean * outSuccess)
1188 {
1189         CFNumberRef cfNumber;
1190         SInt32 numberValue = 0;
1191         Boolean dummySuccess;
1192
1193         if (outSuccess == NULL)
1194                 outSuccess = &dummySuccess;
1195         if ( (inAUStateDictionary == NULL) || (inDictionaryKey == NULL) )
1196         {
1197                 *outSuccess = FALSE;
1198                 return 0;
1199         }
1200
1201         cfNumber = (CFNumberRef) CFDictionaryGetValue(inAUStateDictionary, inDictionaryKey);
1202         if (cfNumber == NULL)
1203         {
1204                 *outSuccess = FALSE;
1205                 return 0;
1206         }
1207         *outSuccess = CFNumberGetValue(cfNumber, kCFNumberSInt32Type, &numberValue);
1208         if (*outSuccess)
1209                 return numberValue;
1210         else
1211                 return 0;
1212 }
1213
1214 static OSStatus
1215 GetAUComponentDescriptionFromStateData(CFPropertyListRef inAUStateData, ComponentDescription * outComponentDescription)
1216 {
1217         CFDictionaryRef auStateDictionary;
1218         ComponentDescription tempDesc = {0};
1219         SInt32 versionValue;
1220         Boolean gotValue;
1221
1222         if ( (inAUStateData == NULL) || (outComponentDescription == NULL) )
1223                 return paramErr;
1224
1225         // the property list for AU state data must be of the dictionary type
1226         if (CFGetTypeID(inAUStateData) != CFDictionaryGetTypeID()) {
1227                 return kAudioUnitErr_InvalidPropertyValue;
1228         }
1229
1230         auStateDictionary = (CFDictionaryRef)inAUStateData;
1231
1232         // first check to make sure that the version of the AU state data is one that we know understand
1233         // XXX should I really do this?  later versions would probably still hold these ID keys, right?
1234         versionValue = GetDictionarySInt32Value(auStateDictionary, CFSTR(kAUPresetVersionKey), &gotValue);
1235
1236         if (!gotValue) {
1237                 return kAudioUnitErr_InvalidPropertyValue;
1238         }
1239 #define kCurrentSavedStateVersion 0
1240         if (versionValue != kCurrentSavedStateVersion) {
1241                 return kAudioUnitErr_InvalidPropertyValue;
1242         }
1243
1244         // grab the ComponentDescription values from the AU state data
1245         tempDesc.componentType = (OSType) GetDictionarySInt32Value(auStateDictionary, CFSTR(kAUPresetTypeKey), NULL);
1246         tempDesc.componentSubType = (OSType) GetDictionarySInt32Value(auStateDictionary, CFSTR(kAUPresetSubtypeKey), NULL);
1247         tempDesc.componentManufacturer = (OSType) GetDictionarySInt32Value(auStateDictionary, CFSTR(kAUPresetManufacturerKey), NULL);
1248         // zero values are illegit for specific ComponentDescriptions, so zero for any value means that there was an error
1249         if ( (tempDesc.componentType == 0) || (tempDesc.componentSubType == 0) || (tempDesc.componentManufacturer == 0) )
1250                 return kAudioUnitErr_InvalidPropertyValue;
1251
1252         *outComponentDescription = tempDesc;
1253         return noErr;
1254 }
1255
1256
1257 static bool au_preset_filter (const string& str, void* arg)
1258 {
1259         /* Not a dotfile, has a prefix before a period, suffix is aupreset */
1260
1261         bool ret;
1262
1263         ret = (str[0] != '.' && str.length() > 9 && str.find (preset_suffix) == (str.length() - preset_suffix.length()));
1264
1265         if (ret && arg) {
1266
1267                 /* check the preset file path name against this plugin
1268                    ID. The idea is that all preset files for this plugin
1269                    include "<manufacturer>/<plugin-name>" in their path.
1270                 */
1271
1272                 Plugin* p = (Plugin *) arg;
1273                 string match = p->maker();
1274                 match += '/';
1275                 match += p->name();
1276
1277                 ret = str.find (match) != string::npos;
1278
1279                 if (ret == false) {
1280                         string m = p->maker ();
1281                         string n = p->name ();
1282                         strip_whitespace_edges (m);
1283                         strip_whitespace_edges (n);
1284                         match = m;
1285                         match += '/';
1286                         match += n;
1287
1288                         ret = str.find (match) != string::npos;
1289                 }
1290         }
1291
1292         return ret;
1293 }
1294
1295 bool
1296 check_and_get_preset_name (Component component, const string& pathstr, string& preset_name)
1297 {
1298         OSStatus status;
1299         CFPropertyListRef plist;
1300         ComponentDescription presetDesc;
1301         bool ret = false;
1302
1303         plist = load_property_list (pathstr);
1304
1305         if (!plist) {
1306                 return ret;
1307         }
1308
1309         // get the ComponentDescription from the AU preset file
1310
1311         status = GetAUComponentDescriptionFromStateData(plist, &presetDesc);
1312
1313         if (status == noErr) {
1314                 if (ComponentAndDescriptionMatch_Loosely(component, &presetDesc)) {
1315
1316                         /* try to get the preset name from the property list */
1317
1318                         if (CFGetTypeID(plist) == CFDictionaryGetTypeID()) {
1319
1320                                 const void* psk = CFDictionaryGetValue ((CFMutableDictionaryRef)plist, CFSTR(kAUPresetNameKey));
1321
1322                                 if (psk) {
1323
1324                                         const char* p = CFStringGetCStringPtr ((CFStringRef) psk, kCFStringEncodingUTF8);
1325
1326                                         if (!p) {
1327                                                 char buf[PATH_MAX+1];
1328
1329                                                 if (CFStringGetCString ((CFStringRef)psk, buf, sizeof (buf), kCFStringEncodingUTF8)) {
1330                                                         preset_name = buf;
1331                                                 }
1332                                         }
1333                                 }
1334                         }
1335                 }
1336         }
1337
1338         CFRelease (plist);
1339
1340         return true;
1341 }
1342
1343 std::string
1344 AUPlugin::current_preset() const
1345 {
1346         string preset_name;
1347
1348 #ifdef AU_STATE_SUPPORT
1349         CFPropertyListRef propertyList;
1350
1351         if (unit->GetAUPreset (propertyList) == noErr) {
1352                 preset_name = get_preset_name_in_plist (propertyList);
1353                 CFRelease(propertyList);
1354         }
1355 #endif
1356         return preset_name;
1357 }
1358
1359 vector<string>
1360 AUPlugin::get_presets ()
1361 {
1362         vector<string*>* preset_files;
1363         vector<string> presets;
1364         PathScanner scanner;
1365
1366         preset_files = scanner (preset_search_path, au_preset_filter, this, true, true, -1, true);
1367
1368         if (!preset_files) {
1369                 return presets;
1370         }
1371
1372         for (vector<string*>::iterator x = preset_files->begin(); x != preset_files->end(); ++x) {
1373
1374                 string path = *(*x);
1375                 string preset_name;
1376
1377                 /* make an initial guess at the preset name using the path */
1378
1379                 preset_name = Glib::path_get_basename (path);
1380                 preset_name = preset_name.substr (0, preset_name.find_last_of ('.'));
1381
1382                 /* check that this preset file really matches this plugin
1383                    and potentially get the "real" preset name from
1384                    within the file.
1385                 */
1386
1387                 if (check_and_get_preset_name (get_comp()->Comp(), path, preset_name)) {
1388                         presets.push_back (preset_name);
1389                         preset_map[preset_name] = path;
1390                 }
1391
1392                 delete *x;
1393         }
1394
1395         delete preset_files;
1396
1397         return presets;
1398 }
1399
1400 bool
1401 AUPlugin::has_editor () const
1402 {
1403         // even if the plugin doesn't have its own editor, the AU API can be used
1404         // to create one that looks native.
1405         return true;
1406 }
1407
1408 AUPluginInfo::AUPluginInfo (boost::shared_ptr<CAComponentDescription> d)
1409         : descriptor (d)
1410 {
1411
1412 }
1413
1414 AUPluginInfo::~AUPluginInfo ()
1415 {
1416 }
1417
1418 PluginPtr
1419 AUPluginInfo::load (Session& session)
1420 {
1421         try {
1422                 PluginPtr plugin;
1423
1424                 boost::shared_ptr<CAComponent> comp (new CAComponent(*descriptor));
1425
1426                 if (!comp->IsValid()) {
1427                         error << ("AudioUnit: not a valid Component") << endmsg;
1428                 } else {
1429                         plugin.reset (new AUPlugin (session.engine(), session, comp));
1430                 }
1431
1432                 plugin->set_info (PluginInfoPtr (new AUPluginInfo (*this)));
1433                 return plugin;
1434         }
1435
1436         catch (failed_constructor &err) {
1437                 return PluginPtr ();
1438         }
1439 }
1440
1441 Glib::ustring
1442 AUPluginInfo::au_cache_path ()
1443 {
1444         return Glib::build_filename (ARDOUR::get_user_ardour_path(), "au_cache");
1445 }
1446
1447 PluginInfoList
1448 AUPluginInfo::discover ()
1449 {
1450         XMLTree tree;
1451
1452         if (!Glib::file_test (au_cache_path(), Glib::FILE_TEST_EXISTS)) {
1453                 ARDOUR::BootMessage (_("Discovering AudioUnit plugins (could take some time ...)"));
1454         }
1455
1456         PluginInfoList plugs;
1457
1458         discover_fx (plugs);
1459         discover_music (plugs);
1460         discover_generators (plugs);
1461
1462         return plugs;
1463 }
1464
1465 void
1466 AUPluginInfo::discover_music (PluginInfoList& plugs)
1467 {
1468         CAComponentDescription desc;
1469         desc.componentFlags = 0;
1470         desc.componentFlagsMask = 0;
1471         desc.componentSubType = 0;
1472         desc.componentManufacturer = 0;
1473         desc.componentType = kAudioUnitType_MusicEffect;
1474
1475         discover_by_description (plugs, desc);
1476 }
1477
1478 void
1479 AUPluginInfo::discover_fx (PluginInfoList& plugs)
1480 {
1481         CAComponentDescription desc;
1482         desc.componentFlags = 0;
1483         desc.componentFlagsMask = 0;
1484         desc.componentSubType = 0;
1485         desc.componentManufacturer = 0;
1486         desc.componentType = kAudioUnitType_Effect;
1487
1488         discover_by_description (plugs, desc);
1489 }
1490
1491 void
1492 AUPluginInfo::discover_generators (PluginInfoList& plugs)
1493 {
1494         CAComponentDescription desc;
1495         desc.componentFlags = 0;
1496         desc.componentFlagsMask = 0;
1497         desc.componentSubType = 0;
1498         desc.componentManufacturer = 0;
1499         desc.componentType = kAudioUnitType_Generator;
1500
1501         discover_by_description (plugs, desc);
1502 }
1503
1504 void
1505 AUPluginInfo::discover_by_description (PluginInfoList& plugs, CAComponentDescription& desc)
1506 {
1507         Component comp = 0;
1508
1509         comp = FindNextComponent (NULL, &desc);
1510
1511         while (comp != NULL) {
1512                 CAComponentDescription temp;
1513                 GetComponentInfo (comp, &temp, NULL, NULL, NULL);
1514
1515                 AUPluginInfoPtr info (new AUPluginInfo
1516                                       (boost::shared_ptr<CAComponentDescription> (new CAComponentDescription(temp))));
1517
1518                 /* no panners, format converters or i/o AU's for our purposes
1519                  */
1520
1521                 switch (info->descriptor->Type()) {
1522                 case kAudioUnitType_Panner:
1523                 case kAudioUnitType_OfflineEffect:
1524                 case kAudioUnitType_FormatConverter:
1525                         continue;
1526                 case kAudioUnitType_Output:
1527                 case kAudioUnitType_MusicDevice:
1528                 case kAudioUnitType_MusicEffect:
1529                 case kAudioUnitType_Effect:
1530                 case kAudioUnitType_Mixer:
1531                 case kAudioUnitType_Generator:
1532                         break;
1533                 default:
1534                         break;
1535                 }
1536
1537                 switch (info->descriptor->SubType()) {
1538                 case kAudioUnitSubType_DefaultOutput:
1539                 case kAudioUnitSubType_SystemOutput:
1540                 case kAudioUnitSubType_GenericOutput:
1541                 case kAudioUnitSubType_AUConverter:
1542                         /* we don't want output units here */
1543                         continue;
1544                         break;
1545
1546                 case kAudioUnitSubType_DLSSynth:
1547                         info->category = "DLS Synth";
1548                         break;
1549
1550                 case kAudioUnitSubType_Varispeed:
1551                         info->category = "Varispeed";
1552                         break;
1553
1554                 case kAudioUnitSubType_Delay:
1555                         info->category = "Delay";
1556                         break;
1557
1558                 case kAudioUnitSubType_LowPassFilter:
1559                         info->category = "Low-pass Filter";
1560                         break;
1561
1562                 case kAudioUnitSubType_HighPassFilter:
1563                         info->category = "High-pass Filter";
1564                         break;
1565
1566                 case kAudioUnitSubType_BandPassFilter:
1567                         info->category = "Band-pass Filter";
1568                         break;
1569
1570                 case kAudioUnitSubType_HighShelfFilter:
1571                         info->category = "High-shelf Filter";
1572                         break;
1573
1574                 case kAudioUnitSubType_LowShelfFilter:
1575                         info->category = "Low-shelf Filter";
1576                         break;
1577
1578                 case kAudioUnitSubType_ParametricEQ:
1579                         info->category = "Parametric EQ";
1580                         break;
1581
1582                 case kAudioUnitSubType_GraphicEQ:
1583                         info->category = "Graphic EQ";
1584                         break;
1585
1586                 case kAudioUnitSubType_PeakLimiter:
1587                         info->category = "Peak Limiter";
1588                         break;
1589
1590                 case kAudioUnitSubType_DynamicsProcessor:
1591                         info->category = "Dynamics Processor";
1592                         break;
1593
1594                 case kAudioUnitSubType_MultiBandCompressor:
1595                         info->category = "Multiband Compressor";
1596                         break;
1597
1598                 case kAudioUnitSubType_MatrixReverb:
1599                         info->category = "Matrix Reverb";
1600                         break;
1601
1602                 case kAudioUnitSubType_SampleDelay:
1603                         info->category = "Sample Delay";
1604                         break;
1605
1606                 case kAudioUnitSubType_Pitch:
1607                         info->category = "Pitch";
1608                         break;
1609
1610                 case kAudioUnitSubType_NetSend:
1611                         info->category = "Net Sender";
1612                         break;
1613
1614                 case kAudioUnitSubType_3DMixer:
1615                         info->category = "3DMixer";
1616                         break;
1617
1618                 case kAudioUnitSubType_MatrixMixer:
1619                         info->category = "MatrixMixer";
1620                         break;
1621
1622                 case kAudioUnitSubType_ScheduledSoundPlayer:
1623                         info->category = "Scheduled Sound Player";
1624                         break;
1625
1626
1627                 case kAudioUnitSubType_AudioFilePlayer:
1628                         info->category = "Audio File Player";
1629                         break;
1630
1631                 case kAudioUnitSubType_NetReceive:
1632                         info->category = "Net Receiver";
1633                         break;
1634
1635                 default:
1636                         info->category = "";
1637                 }
1638
1639                 AUPluginInfo::get_names (temp, info->name, info->creator);
1640
1641                 info->type = ARDOUR::AudioUnit;
1642                 info->unique_id = stringify_descriptor (*info->descriptor);
1643
1644                 /* XXX not sure of the best way to handle plugin versioning yet
1645                  */
1646
1647                 CAComponent cacomp (*info->descriptor);
1648
1649                 if (cacomp.GetResourceVersion (info->version) != noErr) {
1650                         info->version = 0;
1651                 }
1652
1653                 if (cached_io_configuration (info->unique_id, info->version, cacomp, info->cache, info->name)) {
1654
1655                         /* here we have to map apple's wildcard system to a simple pair
1656                            of values. in ::can_do() we use the whole system, but here
1657                            we need a single pair of values. XXX probably means we should
1658                            remove any use of these values.
1659                         */
1660
1661                         info->n_inputs = info->cache.io_configs.front().first;
1662                         info->n_outputs = info->cache.io_configs.front().second;
1663
1664                         if (info->cache.io_configs.size() > 1) {
1665                                 cerr << "ODD: variable IO config for " << info->unique_id << endl;
1666                         }
1667
1668                         plugs.push_back (info);
1669
1670                 } else {
1671                         error << string_compose (_("Cannot get I/O configuration info for AU %1"), info->name) << endmsg;
1672                 }
1673
1674                 comp = FindNextComponent (comp, &desc);
1675         }
1676 }
1677
1678 bool
1679 AUPluginInfo::cached_io_configuration (const std::string& unique_id,
1680                                        UInt32 version,
1681                                        CAComponent& comp,
1682                                        AUPluginCachedInfo& cinfo,
1683                                        const std::string& name)
1684 {
1685         std::string id;
1686         char buf[32];
1687
1688         /* concatenate unique ID with version to provide a key for cached info lookup.
1689            this ensures we don't get stale information, or should if plugin developers
1690            follow Apple "guidelines".
1691          */
1692
1693         snprintf (buf, sizeof (buf), "%u", version);
1694         id = unique_id;
1695         id += '/';
1696         id += buf;
1697
1698         CachedInfoMap::iterator cim = cached_info.find (id);
1699
1700         if (cim != cached_info.end()) {
1701                 cinfo = cim->second;
1702                 return true;
1703         }
1704
1705         CAAudioUnit unit;
1706         AUChannelInfo* channel_info;
1707         UInt32 cnt;
1708         int ret;
1709
1710         ARDOUR::BootMessage (string_compose (_("Checking AudioUnit: %1"), name));
1711
1712         try {
1713
1714                 if (CAAudioUnit::Open (comp, unit) != noErr) {
1715                         return false;
1716                 }
1717
1718         } catch (...) {
1719
1720                 warning << string_compose (_("Could not load AU plugin %1 - ignored"), name) << endmsg;
1721                 cerr << string_compose (_("Could not load AU plugin %1 - ignored"), name) << endl;
1722                 return false;
1723
1724         }
1725
1726         if ((ret = unit.GetChannelInfo (&channel_info, cnt)) < 0) {
1727                 return false;
1728         }
1729
1730         if (ret > 0) {
1731                 /* no explicit info available */
1732
1733                 cinfo.io_configs.push_back (pair<int,int> (-1, -1));
1734
1735         } else {
1736
1737                 /* store each configuration */
1738
1739                 for (uint32_t n = 0; n < cnt; ++n) {
1740                         cinfo.io_configs.push_back (pair<int,int> (channel_info[n].inChannels,
1741                                                                    channel_info[n].outChannels));
1742                 }
1743
1744                 free (channel_info);
1745         }
1746
1747         add_cached_info (id, cinfo);
1748         save_cached_info ();
1749
1750         return true;
1751 }
1752
1753 void
1754 AUPluginInfo::add_cached_info (const std::string& id, AUPluginCachedInfo& cinfo)
1755 {
1756         cached_info[id] = cinfo;
1757 }
1758
1759 void
1760 AUPluginInfo::save_cached_info ()
1761 {
1762         XMLNode* node;
1763
1764         node = new XMLNode (X_("AudioUnitPluginCache"));
1765
1766         for (map<string,AUPluginCachedInfo>::iterator i = cached_info.begin(); i != cached_info.end(); ++i) {
1767                 XMLNode* parent = new XMLNode (X_("plugin"));
1768                 parent->add_property ("id", i->first);
1769                 node->add_child_nocopy (*parent);
1770
1771                 for (vector<pair<int, int> >::iterator j = i->second.io_configs.begin(); j != i->second.io_configs.end(); ++j) {
1772
1773                         XMLNode* child = new XMLNode (X_("io"));
1774                         char buf[32];
1775
1776                         snprintf (buf, sizeof (buf), "%d", j->first);
1777                         child->add_property (X_("in"), buf);
1778                         snprintf (buf, sizeof (buf), "%d", j->second);
1779                         child->add_property (X_("out"), buf);
1780                         parent->add_child_nocopy (*child);
1781                 }
1782
1783         }
1784
1785         Glib::ustring path = au_cache_path ();
1786         XMLTree tree;
1787
1788         tree.set_root (node);
1789
1790         if (!tree.write (path)) {
1791                 error << string_compose (_("could not save AU cache to %1"), path) << endmsg;
1792                 unlink (path.c_str());
1793         }
1794 }
1795
1796 int
1797 AUPluginInfo::load_cached_info ()
1798 {
1799         Glib::ustring path = au_cache_path ();
1800         XMLTree tree;
1801
1802         if (!Glib::file_test (path, Glib::FILE_TEST_EXISTS)) {
1803                 return 0;
1804         }
1805
1806         tree.read (path);
1807         const XMLNode* root (tree.root());
1808
1809         if (root->name() != X_("AudioUnitPluginCache")) {
1810                 return -1;
1811         }
1812
1813         cached_info.clear ();
1814
1815         const XMLNodeList children = root->children();
1816
1817         for (XMLNodeConstIterator iter = children.begin(); iter != children.end(); ++iter) {
1818
1819                 const XMLNode* child = *iter;
1820
1821                 if (child->name() == X_("plugin")) {
1822
1823                         const XMLNode* gchild;
1824                         const XMLNodeList gchildren = child->children();
1825                         const XMLProperty* prop = child->property (X_("id"));
1826
1827                         if (!prop) {
1828                                 continue;
1829                         }
1830
1831                         std::string id = prop->value();
1832                         AUPluginCachedInfo cinfo;
1833
1834                         for (XMLNodeConstIterator giter = gchildren.begin(); giter != gchildren.end(); giter++) {
1835
1836                                 gchild = *giter;
1837
1838                                 if (gchild->name() == X_("io")) {
1839
1840                                         int in;
1841                                         int out;
1842                                         const XMLProperty* iprop;
1843                                         const XMLProperty* oprop;
1844
1845                                         if (((iprop = gchild->property (X_("in"))) != 0) &&
1846                                             ((oprop = gchild->property (X_("out"))) != 0)) {
1847                                                 in = atoi (iprop->value());
1848                                                 out = atoi (iprop->value());
1849
1850                                                 cinfo.io_configs.push_back (pair<int,int> (in, out));
1851                                         }
1852                                 }
1853                         }
1854
1855                         if (cinfo.io_configs.size()) {
1856                                 add_cached_info (id, cinfo);
1857                         }
1858                 }
1859         }
1860
1861         return 0;
1862 }
1863
1864 void
1865 AUPluginInfo::get_names (CAComponentDescription& comp_desc, std::string& name, Glib::ustring& maker)
1866 {
1867         CFStringRef itemName = NULL;
1868
1869         // Marc Poirier-style item name
1870         CAComponent auComponent (comp_desc);
1871         if (auComponent.IsValid()) {
1872                 CAComponentDescription dummydesc;
1873                 Handle nameHandle = NewHandle(sizeof(void*));
1874                 if (nameHandle != NULL) {
1875                         OSErr err = GetComponentInfo(auComponent.Comp(), &dummydesc, nameHandle, NULL, NULL);
1876                         if (err == noErr) {
1877                                 ConstStr255Param nameString = (ConstStr255Param) (*nameHandle);
1878                                 if (nameString != NULL) {
1879                                         itemName = CFStringCreateWithPascalString(kCFAllocatorDefault, nameString, CFStringGetSystemEncoding());
1880                                 }
1881                         }
1882                         DisposeHandle(nameHandle);
1883                 }
1884         }
1885
1886         // if Marc-style fails, do the original way
1887         if (itemName == NULL) {
1888                 CFStringRef compTypeString = UTCreateStringForOSType(comp_desc.componentType);
1889                 CFStringRef compSubTypeString = UTCreateStringForOSType(comp_desc.componentSubType);
1890                 CFStringRef compManufacturerString = UTCreateStringForOSType(comp_desc.componentManufacturer);
1891
1892                 itemName = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%@ - %@ - %@"),
1893                         compTypeString, compManufacturerString, compSubTypeString);
1894
1895                 if (compTypeString != NULL)
1896                         CFRelease(compTypeString);
1897                 if (compSubTypeString != NULL)
1898                         CFRelease(compSubTypeString);
1899                 if (compManufacturerString != NULL)
1900                         CFRelease(compManufacturerString);
1901         }
1902
1903         string str = CFStringRefToStdString(itemName);
1904         string::size_type colon = str.find (':');
1905
1906         if (colon) {
1907                 name = str.substr (colon+1);
1908                 maker = str.substr (0, colon);
1909                 // strip_whitespace_edges (maker);
1910                 // strip_whitespace_edges (name);
1911         } else {
1912                 name = str;
1913                 maker = "unknown";
1914         }
1915 }
1916
1917 // from CAComponentDescription.cpp (in libs/appleutility in ardour source)
1918 extern char *StringForOSType (OSType t, char *writeLocation);
1919
1920 std::string
1921 AUPluginInfo::stringify_descriptor (const CAComponentDescription& desc)
1922 {
1923         char str[24];
1924         stringstream s;
1925
1926         s << StringForOSType (desc.Type(), str);
1927         s << " - ";
1928
1929         s << StringForOSType (desc.SubType(), str);
1930         s << " - ";
1931
1932         s << StringForOSType (desc.Manu(), str);
1933
1934         return s.str();
1935 }