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
  22 #include <pbd/transmitter.h>
  23 #include <pbd/xml++.h>
  24 #include <pbd/whitespace.h>
  25
  26 #include <glibmm/thread.h>
  27
  28 #include <ardour/audioengine.h>
  29 #include <ardour/io.h>
  30 #include <ardour/audio_unit.h>
  31 #include <ardour/session.h>
  32 #include <ardour/utils.h>
  33
  34 #include <appleutility/CAAudioUnit.h>
  35
  36 #include <CoreServices/CoreServices.h>
  37 #include <AudioUnit/AudioUnit.h>
  38
  39 #include "i18n.h"
  40
  41 using namespace std;
  42 using namespace PBD;
  43 using namespace ARDOUR;
  44
  45 static OSStatus
  46 _render_callback(void *userData,
  47                  AudioUnitRenderActionFlags *ioActionFlags,
  48                  const AudioTimeStamp    *inTimeStamp,
  49                  UInt32       inBusNumber,
  50                  UInt32       inNumberFrames,
  51                  AudioBufferList*       ioData)
  52 {
  53         return ((AUPlugin*)userData)->render_callback (ioActionFlags, inTimeStamp, inBusNumber, inNumberFrames, ioData);
  54 }
  55
  56 AUPlugin::AUPlugin (AudioEngine& engine, Session& session, boost::shared_ptr<CAComponent> _comp)
  57         :
  58         Plugin (engine, session),
  59         comp (_comp),
  60         unit (new CAAudioUnit),
  61         initialized (false),
  62         buffers (0),
  63         current_maxbuf (0),
  64         current_offset (0),
  65         current_buffers (0),
  66         frames_processed (0)
  67 {
  68         OSErr err = CAAudioUnit::Open (*(comp.get()), *unit);
  69
  70         if (err != noErr) {
  71                 error << _("AudioUnit: Could not convert CAComponent to CAAudioUnit") << endmsg;
  72                 throw failed_constructor ();
  73         }
  74
  75         AURenderCallbackStruct renderCallbackInfo;
  76
  77         renderCallbackInfo.inputProc = _render_callback;
  78         renderCallbackInfo.inputProcRefCon = this;
  79
  80         if ((err = unit->SetProperty (kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input,
  81                                          0, (void*) &renderCallbackInfo, sizeof(renderCallbackInfo))) != 0) {
  82                 cerr << "cannot install render callback (err = " << err << ')' << endl;
  83                 throw failed_constructor();
  84         }
  85
  86         unit->GetElementCount (kAudioUnitScope_Input, input_elements);
  87         unit->GetElementCount (kAudioUnitScope_Output, output_elements);
  88
  89         // set up the basic stream format. these fields do not change
  90
  91         streamFormat.mSampleRate = session.frame_rate();
  92         streamFormat.mFormatID = kAudioFormatLinearPCM;
  93         streamFormat.mFormatFlags = kAudioFormatFlagIsFloat|kAudioFormatFlagIsPacked|kAudioFormatFlagIsNonInterleaved;
  94         streamFormat.mBitsPerChannel = 32;
  95         streamFormat.mFramesPerPacket = 1;
  96
  97         // subject to later modification as we discover channel counts
  98
  99         streamFormat.mBytesPerPacket = 4;
 100         streamFormat.mBytesPerFrame = 4;
 101         streamFormat.mChannelsPerFrame = 1;
 102
 103         format_set = 0;
 104
 105         if (_set_block_size (_session.get_block_size())) {
 106                 error << _("AUPlugin: cannot set processing block size") << endmsg;
 107                 throw failed_constructor();
 108         }
 109 }
 110
 111 AUPlugin::~AUPlugin ()
 112 {
 113         if (unit) {
 114                 unit->Uninitialize ();
 115         }
 116
 117         if (buffers) {
 118                 free (buffers);
 119         }
 120 }
 121
 122 string
 123 AUPlugin::unique_id () const
 124 {
 125         return AUPluginInfo::stringify_descriptor (comp->Desc());
 126 }
 127
 128 const char *
 129 AUPlugin::label () const
 130 {
 131         return _info->name.c_str();
 132 }
 133
 134 uint32_t
 135 AUPlugin::parameter_count () const
 136 {
 137         return 0;
 138 }
 139
 140 float
 141 AUPlugin::default_value (uint32_t port)
 142 {
 143         // AudioUnits don't have default values.  Maybe presets though?
 144         return 0;
 145 }
 146
 147 nframes_t
 148 AUPlugin::signal_latency () const
 149 {
 150         if (_user_latency) {
 151                 return _user_latency;
 152         }
 153
 154         return unit->Latency ();
 155 }
 156
 157 void
 158 AUPlugin::set_parameter (uint32_t which, float val)
 159 {
 160         // unit->SetParameter (parameter_map[which].first, parameter_map[which].second, 0, val);
 161 }
 162
 163 float
 164 AUPlugin::get_parameter (uint32_t which) const
 165 {
 166         float outValue = 0.0;
 167
 168         // unit->GetParameter(parameter_map[which].first, parameter_map[which].second, 0, outValue);
 169
 170         return outValue;
 171 }
 172
 173 int
 174 AUPlugin::get_parameter_descriptor (uint32_t which, ParameterDescriptor&) const
 175 {
 176         return 0;
 177 }
 178
 179 uint32_t
 180 AUPlugin::nth_parameter (uint32_t which, bool& ok) const
 181 {
 182         return 0;
 183 }
 184
 185 void
 186 AUPlugin::activate ()
 187 {
 188         if (!initialized) {
 189                 OSErr err;
 190                 if ((err = unit->Initialize()) != noErr) {
 191                         error << string_compose (_("AUPlugin: cannot initialize plugin (err = %1)"), err) << endmsg;
 192                 } else {
 193                         frames_processed = 0;
 194                         initialized = true;
 195                 }
 196         }
 197 }
 198
 199 void
 200 AUPlugin::deactivate ()
 201 {
 202         unit->GlobalReset ();
 203 }
 204
 205 void
 206 AUPlugin::set_block_size (nframes_t nframes)
 207 {
 208         _set_block_size (nframes);
 209 }
 210
 211 int
 212 AUPlugin::_set_block_size (nframes_t nframes)
 213 {
 214         bool was_initialized = initialized;
 215         UInt32 numFrames = nframes;
 216         OSErr err;
 217
 218         if (initialized) {
 219                 unit->Uninitialize ();
 220         }
 221
 222         if ((err = unit->SetProperty (kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global,
 223                                       0, &numFrames, sizeof (numFrames))) != noErr) {
 224                 cerr << "cannot set max frames (err = " << err << ')' << endl;
 225                 return -1;
 226         }
 227
 228         if (was_initialized) {
 229                 activate ();
 230         }
 231
 232         return 0;
 233 }
 234
 235 int32_t
 236 AUPlugin::can_support_input_configuration (int32_t in)
 237 {
 238         streamFormat.mChannelsPerFrame = in;
 239         /* apple says that for non-interleaved data, these
 240            values always refer to a single channel.
 241         */
 242         streamFormat.mBytesPerPacket = 4;
 243         streamFormat.mBytesPerFrame = 4;
 244
 245         if (set_input_format () == 0) {
 246                 return 1;
 247         } else {
 248                 return -1;
 249         }
 250 }
 251
 252 int
 253 AUPlugin::set_input_format ()
 254 {
 255         return set_stream_format (kAudioUnitScope_Input, input_elements);
 256 }
 257
 258 int
 259 AUPlugin::set_output_format ()
 260 {
 261         return set_stream_format (kAudioUnitScope_Output, output_elements);
 262 }
 263
 264 int
 265 AUPlugin::set_stream_format (int scope, uint32_t cnt)
 266 {
 267         OSErr result;
 268
 269         for (uint32_t i = 0; i < cnt; ++i) {
 270                 if ((result = unit->SetFormat (scope, i, streamFormat)) != 0) {
 271                         error << string_compose (_("AUPlugin: could not set stream format for %1/%2 (err = %3)"),
 272                                                  (scope == kAudioUnitScope_Input ? "input" : "output"), i, result) << endmsg;
 273                         return -1;
 274                 }
 275         }
 276
 277         if (scope == kAudioUnitScope_Input) {
 278                 format_set |= 0x1;
 279         } else {
 280                 format_set |= 0x2;
 281         }
 282
 283         return 0;
 284 }
 285
 286 int32_t
 287 AUPlugin::compute_output_streams (int32_t nplugins)
 288 {
 289         /* we will never replicate AU plugins - either they can do the I/O we need
 290            or not. thus, we can ignore nplugins entirely.
 291         */
 292
 293         if (set_output_format() == 0) {
 294
 295                 if (buffers) {
 296                         free (buffers);
 297                         buffers = 0;
 298                 }
 299
 300                 buffers = (AudioBufferList *) malloc (offsetof(AudioBufferList, mBuffers) +
 301                                                       streamFormat.mChannelsPerFrame * sizeof(AudioBuffer));
 302
 303                 Glib::Mutex::Lock em (_session.engine().process_lock());
 304                 IO::MoreOutputs (streamFormat.mChannelsPerFrame);
 305
 306                 return streamFormat.mChannelsPerFrame;
 307         } else {
 308                 return -1;
 309         }
 310 }
 311
 312 uint32_t
 313 AUPlugin::output_streams() const
 314 {
 315         if (!(format_set & 0x2)) {
 316                 warning << _("AUPlugin: output_streams() called without any format set!") << endmsg;
 317                 return 1;
 318         }
 319         return streamFormat.mChannelsPerFrame;
 320 }
 321
 322
 323 uint32_t
 324 AUPlugin::input_streams() const
 325 {
 326         if (!(format_set & 0x1)) {
 327                 warning << _("AUPlugin: input_streams() called without any format set!") << endmsg;
 328                 return 1;
 329         }
 330         return streamFormat.mChannelsPerFrame;
 331 }
 332
 333 OSStatus
 334 AUPlugin::render_callback(AudioUnitRenderActionFlags *ioActionFlags,
 335                           const AudioTimeStamp    *inTimeStamp,
 336                           UInt32       inBusNumber,
 337                           UInt32       inNumberFrames,
 338                           AudioBufferList*       ioData)
 339 {
 340         /* not much to do - the data is already in the buffers given to us in connect_and_run() */
 341
 342         if (current_maxbuf == 0) {
 343                 error << _("AUPlugin: render callback called illegally!") << endmsg;
 344                 return kAudioUnitErr_CannotDoInCurrentContext;
 345         }
 346
 347         for (uint32_t i = 0; i < current_maxbuf; ++i) {
 348                 ioData->mBuffers[i].mNumberChannels = 1;
 349                 ioData->mBuffers[i].mDataByteSize = sizeof (Sample) * inNumberFrames;
 350                 ioData->mBuffers[i].mData = (*current_buffers)[i] + cb_offset + current_offset;
 351         }
 352
 353         cb_offset += inNumberFrames;
 354
 355         return noErr;
 356 }
 357
 358 int
 359 AUPlugin::connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in, int32_t& out, nframes_t nframes, nframes_t offset)
 360 {
 361         AudioUnitRenderActionFlags flags = 0;
 362         AudioTimeStamp ts;
 363
 364         current_buffers = &bufs;
 365         current_maxbuf = maxbuf;
 366         current_offset = offset;
 367         cb_offset = 0;
 368
 369         buffers->mNumberBuffers = maxbuf;
 370
 371         for (uint32_t i = 0; i < maxbuf; ++i) {
 372                 buffers->mBuffers[i].mNumberChannels = 1;
 373                 buffers->mBuffers[i].mDataByteSize = nframes * sizeof (Sample);
 374                 buffers->mBuffers[i].mData = 0;
 375         }
 376
 377         ts.mSampleTime = frames_processed;
 378         ts.mFlags = kAudioTimeStampSampleTimeValid;
 379
 380         if (unit->Render (&flags, &ts, 0, nframes, buffers) == noErr) {
 381
 382                 current_maxbuf = 0;
 383                 frames_processed += nframes;
 384
 385                 for (uint32_t i = 0; i < maxbuf; ++i) {
 386                         if (bufs[i] + offset != buffers->mBuffers[i].mData) {
 387                                 memcpy (bufs[i]+offset, buffers->mBuffers[i].mData, nframes * sizeof (Sample));
 388                         }
 389                 }
 390                 return 0;
 391         }
 392
 393         return -1;
 394 }
 395
 396 set<uint32_t>
 397 AUPlugin::automatable() const
 398 {
 399         set<uint32_t> automates;
 400
 401         return automates;
 402 }
 403
 404 string
 405 AUPlugin::describe_parameter (uint32_t)
 406 {
 407         return "";
 408 }
 409
 410 void
 411 AUPlugin::print_parameter (uint32_t, char*, uint32_t len) const
 412 {
 413
 414 }
 415
 416 bool
 417 AUPlugin::parameter_is_audio (uint32_t) const
 418 {
 419         return false;
 420 }
 421
 422 bool
 423 AUPlugin::parameter_is_control (uint32_t) const
 424 {
 425         return false;
 426 }
 427
 428 bool
 429 AUPlugin::parameter_is_input (uint32_t) const
 430 {
 431         return false;
 432 }
 433
 434 bool
 435 AUPlugin::parameter_is_output (uint32_t) const
 436 {
 437         return false;
 438 }
 439
 440 XMLNode&
 441 AUPlugin::get_state()
 442 {
 443         XMLNode *root = new XMLNode (state_node_name());
 444         LocaleGuard lg (X_("POSIX"));
 445         return *root;
 446 }
 447
 448 int
 449 AUPlugin::set_state(const XMLNode& node)
 450 {
 451         return -1;
 452 }
 453
 454 bool
 455 AUPlugin::save_preset (string name)
 456 {
 457         return false;
 458 }
 459
 460 bool
 461 AUPlugin::load_preset (const string preset_label)
 462 {
 463         return false;
 464 }
 465
 466 vector<string>
 467 AUPlugin::get_presets ()
 468 {
 469         vector<string> presets;
 470
 471         return presets;
 472 }
 473
 474 bool
 475 AUPlugin::has_editor () const
 476 {
 477         // even if the plugin doesn't have its own editor, the AU API can be used
 478         // to create one that looks native.
 479         return true;
 480 }
 481
 482 AUPluginInfo::AUPluginInfo (boost::shared_ptr<CAComponentDescription> d)
 483         : descriptor (d)
 484 {
 485
 486 }
 487
 488 AUPluginInfo::~AUPluginInfo ()
 489 {
 490 }
 491
 492 PluginPtr
 493 AUPluginInfo::load (Session& session)
 494 {
 495         try {
 496                 PluginPtr plugin;
 497
 498                 boost::shared_ptr<CAComponent> comp (new CAComponent(*descriptor));
 499
 500                 if (!comp->IsValid()) {
 501                         error << ("AudioUnit: not a valid Component") << endmsg;
 502                 } else {
 503                         plugin.reset (new AUPlugin (session.engine(), session, comp));
 504                 }
 505
 506                 plugin->set_info (PluginInfoPtr (new AUPluginInfo (*this)));
 507                 return plugin;
 508         }
 509
 510         catch (failed_constructor &err) {
 511                 return PluginPtr ((Plugin*) 0);
 512         }
 513 }
 514
 515 PluginInfoList
 516 AUPluginInfo::discover ()
 517 {
 518         PluginInfoList plugs;
 519
 520         discover_fx (plugs);
 521         discover_music (plugs);
 522
 523         return plugs;
 524 }
 525
 526 void
 527 AUPluginInfo::discover_music (PluginInfoList& plugs)
 528 {
 529         CAComponentDescription desc;
 530         desc.componentFlags = 0;
 531         desc.componentFlagsMask = 0;
 532         desc.componentSubType = 0;
 533         desc.componentManufacturer = 0;
 534         desc.componentType = kAudioUnitType_MusicEffect;
 535
 536         discover_by_description (plugs, desc);
 537 }
 538
 539 void
 540 AUPluginInfo::discover_fx (PluginInfoList& plugs)
 541 {
 542         CAComponentDescription desc;
 543         desc.componentFlags = 0;
 544         desc.componentFlagsMask = 0;
 545         desc.componentSubType = 0;
 546         desc.componentManufacturer = 0;
 547         desc.componentType = kAudioUnitType_Effect;
 548
 549         discover_by_description (plugs, desc);
 550 }
 551
 552 void
 553 AUPluginInfo::discover_by_description (PluginInfoList& plugs, CAComponentDescription& desc)
 554 {
 555         Component comp = 0;
 556
 557         comp = FindNextComponent (NULL, &desc);
 558
 559         while (comp != NULL) {
 560                 CAComponentDescription temp;
 561                 GetComponentInfo (comp, &temp, NULL, NULL, NULL);
 562
 563                 AUPluginInfoPtr info (new AUPluginInfo
 564                                       (boost::shared_ptr<CAComponentDescription> (new CAComponentDescription(temp))));
 565
 566                 /* no panners, format converters or i/o AU's for our purposes
 567                  */
 568
 569                 switch (info->descriptor->Type()) {
 570                 case kAudioUnitType_Panner:
 571                 case kAudioUnitType_OfflineEffect:
 572                 case kAudioUnitType_FormatConverter:
 573                         continue;
 574                 default:
 575                         break;
 576                 }
 577
 578                 switch (info->descriptor->SubType()) {
 579                 case kAudioUnitSubType_DefaultOutput:
 580                 case kAudioUnitSubType_SystemOutput:
 581                 case kAudioUnitSubType_GenericOutput:
 582                 case kAudioUnitSubType_AUConverter:
 583                         continue;
 584                         break;
 585
 586                 case kAudioUnitSubType_DLSSynth:
 587                         info->category = "DLSSynth";
 588                         break;
 589
 590                 case kAudioUnitType_MusicEffect:
 591                         info->category = "MusicEffect";
 592                         break;
 593
 594                 case kAudioUnitSubType_Varispeed:
 595                         info->category = "Varispeed";
 596                         break;
 597
 598                 case kAudioUnitSubType_Delay:
 599                         info->category = "Delay";
 600                         break;
 601
 602                 case kAudioUnitSubType_LowPassFilter:
 603                         info->category = "LowPassFilter";
 604                         break;
 605
 606                 case kAudioUnitSubType_HighPassFilter:
 607                         info->category = "HighPassFilter";
 608                         break;
 609
 610                 case kAudioUnitSubType_BandPassFilter:
 611                         info->category = "BandPassFilter";
 612                         break;
 613
 614                 case kAudioUnitSubType_HighShelfFilter:
 615                         info->category = "HighShelfFilter";
 616                         break;
 617
 618                 case kAudioUnitSubType_LowShelfFilter:
 619                         info->category = "LowShelfFilter";
 620                         break;
 621
 622                 case kAudioUnitSubType_ParametricEQ:
 623                         info->category = "ParametricEQ";
 624                         break;
 625
 626                 case kAudioUnitSubType_GraphicEQ:
 627                         info->category = "GraphicEQ";
 628                         break;
 629
 630                 case kAudioUnitSubType_PeakLimiter:
 631                         info->category = "PeakLimiter";
 632                         break;
 633
 634                 case kAudioUnitSubType_DynamicsProcessor:
 635                         info->category = "DynamicsProcessor";
 636                         break;
 637
 638                 case kAudioUnitSubType_MultiBandCompressor:
 639                         info->category = "MultiBandCompressor";
 640                         break;
 641
 642                 case kAudioUnitSubType_MatrixReverb:
 643                         info->category = "MatrixReverb";
 644                         break;
 645
 646                 case kAudioUnitType_Mixer:
 647                         info->category = "Mixer";
 648                         break;
 649
 650                 case kAudioUnitSubType_StereoMixer:
 651                         info->category = "StereoMixer";
 652                         break;
 653
 654                 case kAudioUnitSubType_3DMixer:
 655                         info->category = "3DMixer";
 656                         break;
 657
 658                 case kAudioUnitSubType_MatrixMixer:
 659                         info->category = "MatrixMixer";
 660                         break;
 661
 662                 default:
 663                         info->category = "";
 664                 }
 665
 666                 AUPluginInfo::get_names (temp, info->name, info->creator);
 667
 668                 info->type = ARDOUR::AudioUnit;
 669                 info->unique_id = stringify_descriptor (*info->descriptor);
 670
 671                 /* mark the plugin as having flexible i/o */
 672
 673                 info->n_inputs = -1;
 674                 info->n_outputs = -1;
 675
 676
 677                 plugs.push_back (info);
 678
 679                 comp = FindNextComponent (comp, &desc);
 680         }
 681 }
 682
 683 void
 684 AUPluginInfo::get_names (CAComponentDescription& comp_desc, std::string& name, Glib::ustring& maker)
 685 {
 686         CFStringRef itemName = NULL;
 687
 688         // Marc Poirier-style item name
 689         CAComponent auComponent (comp_desc);
 690         if (auComponent.IsValid()) {
 691                 CAComponentDescription dummydesc;
 692                 Handle nameHandle = NewHandle(sizeof(void*));
 693                 if (nameHandle != NULL) {
 694                         OSErr err = GetComponentInfo(auComponent.Comp(), &dummydesc, nameHandle, NULL, NULL);
 695                         if (err == noErr) {
 696                                 ConstStr255Param nameString = (ConstStr255Param) (*nameHandle);
 697                                 if (nameString != NULL) {
 698                                         itemName = CFStringCreateWithPascalString(kCFAllocatorDefault, nameString, CFStringGetSystemEncoding());
 699                                 }
 700                         }
 701                         DisposeHandle(nameHandle);
 702                 }
 703         }
 704
 705         // if Marc-style fails, do the original way
 706         if (itemName == NULL) {
 707                 CFStringRef compTypeString = UTCreateStringForOSType(comp_desc.componentType);
 708                 CFStringRef compSubTypeString = UTCreateStringForOSType(comp_desc.componentSubType);
 709                 CFStringRef compManufacturerString = UTCreateStringForOSType(comp_desc.componentManufacturer);
 710
 711                 itemName = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%@ - %@ - %@"),
 712                         compTypeString, compManufacturerString, compSubTypeString);
 713
 714                 if (compTypeString != NULL)
 715                         CFRelease(compTypeString);
 716                 if (compSubTypeString != NULL)
 717                         CFRelease(compSubTypeString);
 718                 if (compManufacturerString != NULL)
 719                         CFRelease(compManufacturerString);
 720         }
 721
 722         string str = CFStringRefToStdString(itemName);
 723         string::size_type colon = str.find (':');
 724
 725         if (colon) {
 726                 name = str.substr (colon+1);
 727                 maker = str.substr (0, colon);
 728                 // strip_whitespace_edges (maker);
 729                 // strip_whitespace_edges (name);
 730         } else {
 731                 name = str;
 732                 maker = "unknown";
 733         }
 734 }
 735
 736 // from CAComponentDescription.cpp (in libs/appleutility in ardour source)
 737 extern char *StringForOSType (OSType t, char *writeLocation);
 738
 739 std::string
 740 AUPluginInfo::stringify_descriptor (const CAComponentDescription& desc)
 741 {
 742         char str[24];
 743         stringstream s;
 744
 745         s << StringForOSType (desc.Type(), str);
 746         s << " - ";
 747
 748         s << StringForOSType (desc.SubType(), str);
 749         s << " - ";
 750
 751         s << StringForOSType (desc.Manu(), str);
 752
 753         return s.str();
 754 }