X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudio_unit.cc;h=b0ced9bdfbe2b57eeac0f4db3df6adb12d60c6cc;hb=07be98b3410ac70b3c4451592fb88def678611ef;hp=4a432ba544483e8bb3a2e8f616a63a18cd64ee48;hpb=ef172d7ad6f4498c92c115bc1ffbfd156c677e4e;p=ardour.git diff --git a/libs/ardour/audio_unit.cc b/libs/ardour/audio_unit.cc index 4a432ba544..b0ced9bdfb 100644 --- a/libs/ardour/audio_unit.cc +++ b/libs/ardour/audio_unit.cc @@ -1,6 +1,6 @@ /* - Copyright (C) 2006 Paul Davis - + Copyright (C) 2006 Paul Davis + This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or @@ -18,27 +18,30 @@ */ #include +#include +#include -#include -#include -#include +#include "pbd/transmitter.h" +#include "pbd/xml++.h" +#include "pbd/whitespace.h" +#include "pbd/pathscanner.h" #include #include #include -#include -#include -#include -#include -#include -#include +#include "ardour/ardour.h" +#include "ardour/audioengine.h" +#include "ardour/io.h" +#include "ardour/audio_unit.h" +#include "ardour/session.h" +#include "ardour/utils.h" #include #include +#include #include -#include #include "i18n.h" @@ -46,9 +49,20 @@ using namespace std; using namespace PBD; using namespace ARDOUR; +#ifndef AU_STATE_SUPPORT +static bool seen_get_state_message = false; +static bool seen_set_state_message = false; +static bool seen_loading_message = false; +static bool seen_saving_message = false; +#endif + AUPluginInfo::CachedInfoMap AUPluginInfo::cached_info; -static OSStatus +static string preset_search_path = "/Library/Audio/Presets:/Network/Library/Audio/Presets"; +static string preset_suffix = ".aupreset"; +static bool preset_search_path_initialized = false; + +static OSStatus _render_callback(void *userData, AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp, @@ -59,6 +73,212 @@ _render_callback(void *userData, return ((AUPlugin*)userData)->render_callback (ioActionFlags, inTimeStamp, inBusNumber, inNumberFrames, ioData); } +static int +save_property_list (CFPropertyListRef propertyList, Glib::ustring path) + +{ + CFDataRef xmlData; + int fd; + + // Convert the property list into XML data. + + xmlData = CFPropertyListCreateXMLData( kCFAllocatorDefault, propertyList); + + if (!xmlData) { + error << _("Could not create XML version of property list") << endmsg; + return -1; + } + + // Write the XML data to the file. + + fd = open (path.c_str(), O_WRONLY|O_CREAT|O_EXCL, 0664); + while (fd < 0) { + if (errno == EEXIST) { + /* tell any UI's that this file already exists and ask them what to do */ + bool overwrite = Plugin::PresetFileExists(); // EMIT SIGNAL + if (overwrite) { + fd = open (path.c_str(), O_WRONLY, 0664); + continue; + } else { + return 0; + } + } + error << string_compose (_("Cannot open preset file %1 (%2)"), path, strerror (errno)) << endmsg; + CFRelease (xmlData); + return -1; + } + + size_t cnt = CFDataGetLength (xmlData); + + if (write (fd, CFDataGetBytePtr (xmlData), cnt) != cnt) { + CFRelease (xmlData); + close (fd); + return -1; + } + + close (fd); + return 0; +} + + +static CFPropertyListRef +load_property_list (Glib::ustring path) +{ + int fd; + CFPropertyListRef propertyList; + CFDataRef xmlData; + CFStringRef errorString; + + // Read the XML file. + + if ((fd = open (path.c_str(), O_RDONLY)) < 0) { + return propertyList; + + } + + off_t len = lseek (fd, 0, SEEK_END); + char* buf = new char[len]; + lseek (fd, 0, SEEK_SET); + + if (read (fd, buf, len) != len) { + delete [] buf; + close (fd); + return propertyList; + } + + close (fd); + + xmlData = CFDataCreateWithBytesNoCopy (kCFAllocatorDefault, (UInt8*) buf, len, kCFAllocatorNull); + + // Reconstitute the dictionary using the XML data. + + propertyList = CFPropertyListCreateFromXMLData( kCFAllocatorDefault, + xmlData, + kCFPropertyListImmutable, + &errorString); + + CFRelease (xmlData); + delete [] buf; + + return propertyList; +} + +//----------------------------------------------------------------------------- +static void +set_preset_name_in_plist (CFPropertyListRef plist, string preset_name) +{ + if (!plist) { + return; + } + CFStringRef pn = CFStringCreateWithCString (kCFAllocatorDefault, preset_name.c_str(), kCFStringEncodingUTF8); + + if (CFGetTypeID (plist) == CFDictionaryGetTypeID()) { + CFDictionarySetValue ((CFMutableDictionaryRef)plist, CFSTR(kAUPresetNameKey), pn); + } + + CFRelease (pn); +} + +//----------------------------------------------------------------------------- +static std::string +get_preset_name_in_plist (CFPropertyListRef plist) +{ + std::string ret; + + if (!plist) { + return ret; + } + + if (CFGetTypeID (plist) == CFDictionaryGetTypeID()) { + const void *p = CFDictionaryGetValue ((CFMutableDictionaryRef)plist, CFSTR(kAUPresetNameKey)); + if (p) { + CFStringRef str = (CFStringRef) p; + int len = CFStringGetLength(str); + len = (len * 2) + 1; + char local_buffer[len]; + if (CFStringGetCString (str, local_buffer, len, kCFStringEncodingUTF8)) { + ret = local_buffer; + } + } + } + return ret; +} + +//-------------------------------------------------------------------------- +// general implementation for ComponentDescriptionsMatch() and ComponentDescriptionsMatch_Loosely() +// if inIgnoreType is true, then the type code is ignored in the ComponentDescriptions +Boolean ComponentDescriptionsMatch_General(const ComponentDescription * inComponentDescription1, const ComponentDescription * inComponentDescription2, Boolean inIgnoreType); +Boolean ComponentDescriptionsMatch_General(const ComponentDescription * inComponentDescription1, const ComponentDescription * inComponentDescription2, Boolean inIgnoreType) +{ + if ( (inComponentDescription1 == NULL) || (inComponentDescription2 == NULL) ) + return FALSE; + + if ( (inComponentDescription1->componentSubType == inComponentDescription2->componentSubType) + && (inComponentDescription1->componentManufacturer == inComponentDescription2->componentManufacturer) ) + { + // only sub-type and manufacturer IDs need to be equal + if (inIgnoreType) + return TRUE; + // type, sub-type, and manufacturer IDs all need to be equal in order to call this a match + else if (inComponentDescription1->componentType == inComponentDescription2->componentType) + return TRUE; + } + + return FALSE; +} + +//-------------------------------------------------------------------------- +// general implementation for ComponentAndDescriptionMatch() and ComponentAndDescriptionMatch_Loosely() +// if inIgnoreType is true, then the type code is ignored in the ComponentDescriptions +Boolean ComponentAndDescriptionMatch_General(Component inComponent, const ComponentDescription * inComponentDescription, Boolean inIgnoreType); +Boolean ComponentAndDescriptionMatch_General(Component inComponent, const ComponentDescription * inComponentDescription, Boolean inIgnoreType) +{ + OSErr status; + ComponentDescription desc; + + if ( (inComponent == NULL) || (inComponentDescription == NULL) ) + return FALSE; + + // get the ComponentDescription of the input Component + status = GetComponentInfo(inComponent, &desc, NULL, NULL, NULL); + if (status != noErr) + return FALSE; + + // check if the Component's ComponentDescription matches the input ComponentDescription + return ComponentDescriptionsMatch_General(&desc, inComponentDescription, inIgnoreType); +} + +//-------------------------------------------------------------------------- +// determine if 2 ComponentDescriptions are basically equal +// (by that, I mean that the important identifying values are compared, +// but not the ComponentDescription flags) +Boolean ComponentDescriptionsMatch(const ComponentDescription * inComponentDescription1, const ComponentDescription * inComponentDescription2) +{ + return ComponentDescriptionsMatch_General(inComponentDescription1, inComponentDescription2, FALSE); +} + +//-------------------------------------------------------------------------- +// determine if 2 ComponentDescriptions have matching sub-type and manufacturer codes +Boolean ComponentDescriptionsMatch_Loose(const ComponentDescription * inComponentDescription1, const ComponentDescription * inComponentDescription2) +{ + return ComponentDescriptionsMatch_General(inComponentDescription1, inComponentDescription2, TRUE); +} + +//-------------------------------------------------------------------------- +// determine if a ComponentDescription basically matches that of a particular Component +Boolean ComponentAndDescriptionMatch(Component inComponent, const ComponentDescription * inComponentDescription) +{ + return ComponentAndDescriptionMatch_General(inComponent, inComponentDescription, FALSE); +} + +//-------------------------------------------------------------------------- +// determine if a ComponentDescription matches only the sub-type and manufacturer codes of a particular Component +Boolean ComponentAndDescriptionMatch_Loosely(Component inComponent, const ComponentDescription * inComponentDescription) +{ + return ComponentAndDescriptionMatch_General(inComponent, inComponentDescription, TRUE); +} + + AUPlugin::AUPlugin (AudioEngine& engine, Session& session, boost::shared_ptr _comp) : Plugin (engine, session), comp (_comp), @@ -69,7 +289,15 @@ AUPlugin::AUPlugin (AudioEngine& engine, Session& session, boost::shared_ptrSetProperty (kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, + if ((err = unit->SetProperty (kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, (void*) &renderCallbackInfo, sizeof(renderCallbackInfo))) != 0) { cerr << "cannot install render callback (err = " << err << ')' << endl; throw failed_constructor(); @@ -154,8 +381,8 @@ void AUPlugin::discover_parameters () { /* discover writable parameters */ - - AudioUnitScope scopes[] = { + + AudioUnitScope scopes[] = { kAudioUnitScope_Global, kAudioUnitScope_Output, kAudioUnitScope_Input @@ -166,7 +393,7 @@ AUPlugin::discover_parameters () for (uint32_t i = 0; i < sizeof (scopes) / sizeof (scopes[0]); ++i) { AUParamInfo param_info (unit->AU(), false, false, scopes[i]); - + for (uint32_t i = 0; i < param_info.NumParams(); ++i) { AUParameterDescriptor d; @@ -245,10 +472,10 @@ AUPlugin::discover_parameters () d.toggled = (info.unit & kAudioUnitParameterUnit_Boolean) || (d.integer_step && ((d.upper - d.lower) == 1.0)); d.sr_dependent = (info.unit & kAudioUnitParameterUnit_SampleFrames); - d.automatable = !d.toggled && + d.automatable = !d.toggled && !(info.flags & kAudioUnitParameterFlag_NonRealTime) && (info.flags & kAudioUnitParameterFlag_IsWritable); - + d.logarithmic = (info.flags & kAudioUnitParameterFlag_DisplayLogarithmic); d.unit = info.unit; @@ -293,12 +520,8 @@ AUPlugin::default_value (uint32_t port) } nframes_t -AUPlugin::signal_latency () const +AUPlugin::latency () const { - if (_user_latency) { - return _user_latency; - } - return unit->Latency() * _session.frame_rate(); } @@ -328,7 +551,7 @@ AUPlugin::get_parameter_descriptor (uint32_t which, ParameterDescriptor& pd) con if (which < descriptors.size()) { pd = descriptors[which]; return 0; - } + } return -1; } @@ -378,9 +601,10 @@ AUPlugin::_set_block_size (nframes_t nframes) if (initialized) { unit->Uninitialize (); + initialized = false; } - if ((err = unit->SetProperty (kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, + if ((err = unit->SetProperty (kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 0, &numFrames, sizeof (numFrames))) != noErr) { cerr << "cannot set max frames (err = " << err << ')' << endl; return -1; @@ -394,7 +618,7 @@ AUPlugin::_set_block_size (nframes_t nframes) } int32_t -AUPlugin::configure_io (ChanCount in, ChanCount out) +AUPlugin::configure_io (int32_t in, int32_t out) { AudioStreamBasicDescription streamFormat; @@ -417,13 +641,13 @@ AUPlugin::configure_io (ChanCount in, ChanCount out) streamFormat.mBytesPerPacket = 4; streamFormat.mBytesPerFrame = 4; - streamFormat.mChannelsPerFrame = in.n_audio(); + streamFormat.mChannelsPerFrame = in; if (set_input_format (streamFormat) != 0) { return -1; } - streamFormat.mChannelsPerFrame = out.n_audio(); + streamFormat.mChannelsPerFrame = out; if (set_output_format (streamFormat) != 0) { return -1; @@ -432,22 +656,16 @@ AUPlugin::configure_io (ChanCount in, ChanCount out) return Plugin::configure_io (in, out); } -bool -AUPlugin::can_support_io_configuration (const ChanCount& in, ChanCount& out) -{ - int32_t ret = count_for_configuration (in, out); - return ret >= 0; -} - int32_t -AUPlugin::count_for_configuration(ChanCount cin, ChanCount& out) const +AUPlugin::can_do (int32_t in, int32_t& out) { // XXX as of May 13th 2008, AU plugin support returns a count of either 1 or -1. We never // attempt to multiply-instantiate plugins to meet io configurations. int32_t plugcnt = -1; AUPluginInfoPtr pinfo = boost::dynamic_pointer_cast(get_info()); - int32_t in = cin.n_audio(); /* XXX handle MIDI one day ??? */ + + out = -1; vector >& io_configs = pinfo->cache.io_configs; @@ -468,51 +686,51 @@ AUPlugin::count_for_configuration(ChanCount cin, ChanCount& out) const if (possible_out == -1) { /* out much match in (UNLIKELY!!) */ - out.set (DataType::AUDIO, in); + out = in; plugcnt = 1; } else if (possible_out == -2) { /* any configuration possible, pick matching */ - out.set (DataType::AUDIO, in); + out = in; plugcnt = 1; } else if (possible_out < -2) { /* explicit variable number of outputs, pick maximum */ - out.set (DataType::AUDIO, -possible_out); + out = -possible_out; plugcnt = 1; } else { /* exact number of outputs */ - out.set (DataType::AUDIO, possible_out); + out = possible_out; plugcnt = 1; } } - + if (possible_in == -1) { /* wildcard for input */ if (possible_out == -1) { /* out much match in */ - out.set (DataType::AUDIO, in); + out = in; plugcnt = 1; } else if (possible_out == -2) { /* any configuration possible, pick matching */ - out.set (DataType::AUDIO, in); + out = in; plugcnt = 1; } else if (possible_out < -2) { /* explicit variable number of outputs, pick maximum */ - out.set (DataType::AUDIO, -possible_out); + out = -possible_out; plugcnt = 1; } else { /* exact number of outputs */ - out.set (DataType::AUDIO, possible_out); + out = possible_out; plugcnt = 1; } - } - + } + if (possible_in == -2) { if (possible_out == -1) { /* any configuration possible, pick matching */ - out.set (DataType::AUDIO, in); + out = in; plugcnt = 1; } else if (possible_out == -2) { error << string_compose (_("AU plugin %1 has illegal IO configuration (-2,-2)"), name()) @@ -520,11 +738,11 @@ AUPlugin::count_for_configuration(ChanCount cin, ChanCount& out) const plugcnt = -1; } else if (possible_out < -2) { /* explicit variable number of outputs, pick maximum */ - out.set (DataType::AUDIO, -possible_out); + out = -possible_out; plugcnt = 1; } else { /* exact number of outputs */ - out.set (DataType::AUDIO, possible_out); + out = possible_out; plugcnt = 1; } } @@ -540,7 +758,7 @@ AUPlugin::count_for_configuration(ChanCount cin, ChanCount& out) const if (possible_out == -1) { /* out must match in */ - out.set (DataType::AUDIO, in); + out = in; plugcnt = 1; } else if (possible_out == -2) { error << string_compose (_("AU plugin %1 has illegal IO configuration (-2,-2)"), name()) @@ -548,11 +766,11 @@ AUPlugin::count_for_configuration(ChanCount cin, ChanCount& out) const plugcnt = -1; } else if (possible_out < -2) { /* explicit variable number of outputs, pick maximum */ - out.set (DataType::AUDIO, -possible_out); + out = -possible_out; plugcnt = 1; } else { /* exact number of outputs */ - out.set (DataType::AUDIO, possible_out); + out = possible_out; plugcnt = 1; } } @@ -560,26 +778,29 @@ AUPlugin::count_for_configuration(ChanCount cin, ChanCount& out) const if (possible_in == in) { /* exact number of inputs ... must match obviously */ - + if (possible_out == -1) { /* out must match in */ - out.set (DataType::AUDIO, in); + out = in; plugcnt = 1; } else if (possible_out == -2) { /* any output configuration, pick matching */ - out.set (DataType::AUDIO, in); + out = in; plugcnt = -1; } else if (possible_out < -2) { /* explicit variable number of outputs, pick maximum */ - out.set (DataType::AUDIO, -possible_out); + out = -possible_out; plugcnt = 1; } else { /* exact number of outputs */ - out.set (DataType::AUDIO, possible_out); + out = possible_out; plugcnt = 1; } } + if (plugcnt == 1) { + break; + } } /* no fit */ @@ -603,12 +824,12 @@ AUPlugin::set_output_format (AudioStreamBasicDescription& fmt) free (buffers); buffers = 0; } - - buffers = (AudioBufferList *) malloc (offsetof(AudioBufferList, mBuffers) + + + buffers = (AudioBufferList *) malloc (offsetof(AudioBufferList, mBuffers) + fmt.mChannelsPerFrame * sizeof(AudioBuffer)); Glib::Mutex::Lock em (_session.engine().process_lock()); - IO::PortCountChanged (ChanCount (DataType::AUDIO, fmt.mChannelsPerFrame)); + IO::MoreOutputs (fmt.mChannelsPerFrame); return 0; } @@ -635,39 +856,28 @@ AUPlugin::set_stream_format (int scope, uint32_t cnt, AudioStreamBasicDescriptio return 0; } - -ChanCount +uint32_t AUPlugin::input_streams() const { - ChanCount in; - if (input_channels < 0) { warning << string_compose (_("AUPlugin: %1 input_streams() called without any format set!"), name()) << endmsg; - in.set_audio (1); - } else { - in.set_audio (input_channels); + return 1; } - - return in; + return input_channels; } -ChanCount +uint32_t AUPlugin::output_streams() const { - ChanCount out; - if (output_channels < 0) { warning << string_compose (_("AUPlugin: %1 output_streams() called without any format set!"), name()) << endmsg; - out.set_audio (1); - } else { - out.set_audio (output_channels); + return 1; } - - return out; + return output_channels; } -OSStatus +OSStatus AUPlugin::render_callback(AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber, @@ -718,7 +928,7 @@ AUPlugin::connect_and_run (vector& bufs, uint32_t maxbuf, int32_t& in, current_maxbuf = 0; frames_processed += nframes; - + for (uint32_t i = 0; i < maxbuf; ++i) { if (bufs[i] + offset != buffers->mBuffers[i].mData) { memcpy (bufs[i]+offset, buffers->mBuffers[i].mData, nframes * sizeof (Sample)); @@ -783,34 +993,407 @@ AUPlugin::parameter_is_output (uint32_t) const XMLNode& AUPlugin::get_state() { - XMLNode *root = new XMLNode (state_node_name()); LocaleGuard lg (X_("POSIX")); + XMLNode *root = new XMLNode (state_node_name()); + +#ifdef AU_STATE_SUPPORT + CFDataRef xmlData; + CFPropertyListRef propertyList; + + if (unit->GetAUPreset (propertyList) != noErr) { + return *root; + } + + // Convert the property list into XML data. + + xmlData = CFPropertyListCreateXMLData( kCFAllocatorDefault, propertyList); + + if (!xmlData) { + error << _("Could not create XML version of property list") << endmsg; + return *root; + } + + /* re-parse XML bytes to create a libxml++ XMLTree that we can merge into + our state node. GACK! + */ + + XMLTree t; + + if (t.read_buffer (string ((const char*) CFDataGetBytePtr (xmlData), CFDataGetLength (xmlData)))) { + if (t.root()) { + root->add_child_copy (*t.root()); + } + } + + CFRelease (xmlData); + CFRelease (propertyList); +#else + if (!seen_get_state_message) { + info << _("Saving AudioUnit settings is not supported in this build of Ardour. Consider paying for a newer version") + << endmsg; + seen_get_state_message = true; + } +#endif + return *root; } int AUPlugin::set_state(const XMLNode& node) { - return -1; +#ifdef AU_STATE_SUPPORT + int ret = -1; + CFPropertyListRef propertyList; + LocaleGuard lg (X_("POSIX")); + + if (node.name() != state_node_name()) { + error << _("Bad node sent to AUPlugin::set_state") << endmsg; + return -1; + } + + if (node.children().empty()) { + return -1; + } + + XMLNode* top = node.children().front(); + XMLNode* copy = new XMLNode (*top); + + XMLTree t; + t.set_root (copy); + + const string& xml = t.write_buffer (); + CFDataRef xmlData = CFDataCreateWithBytesNoCopy (kCFAllocatorDefault, (UInt8*) xml.data(), xml.length(), kCFAllocatorNull); + CFStringRef errorString; + + propertyList = CFPropertyListCreateFromXMLData( kCFAllocatorDefault, + xmlData, + kCFPropertyListImmutable, + &errorString); + + CFRelease (xmlData); + + if (propertyList) { + if (unit->SetAUPreset (propertyList) == noErr) { + ret = 0; + } + CFRelease (propertyList); + } + + return ret; +#else + if (!seen_set_state_message) { + info << _("Restoring AudioUnit settings is not supported in this build of Ardour. Consider paying for a newer version") + << endmsg; + } + return 0; +#endif } bool -AUPlugin::save_preset (string name) +AUPlugin::load_preset (const string preset_label) { - return false; +#ifdef AU_STATE_SUPPORT + bool ret = false; + CFPropertyListRef propertyList; + Glib::ustring path; + PresetMap::iterator x = preset_map.find (preset_label); + + if (x == preset_map.end()) { + return false; + } + + if ((propertyList = load_property_list (x->second)) != 0) { + if (unit->SetAUPreset (propertyList) == noErr) { + ret = true; + } + CFRelease(propertyList); + } + + return ret; +#else + if (!seen_loading_message) { + info << _("Loading AudioUnit presets is not supported in this build of Ardour. Consider paying for a newer version") + << endmsg; + seen_loading_message = true; + } + return true; +#endif } bool -AUPlugin::load_preset (const string preset_label) +AUPlugin::save_preset (string preset_name) { +#ifdef AU_STATE_SUPPORT + CFPropertyListRef propertyList; + vector v; + Glib::ustring user_preset_path; + bool ret = true; + + std::string m = maker(); + std::string n = name(); + + strip_whitespace_edges (m); + strip_whitespace_edges (n); + + v.push_back (Glib::get_home_dir()); + v.push_back ("Library"); + v.push_back ("Audio"); + v.push_back ("Presets"); + v.push_back (m); + v.push_back (n); + + user_preset_path = Glib::build_filename (v); + + if (g_mkdir_with_parents (user_preset_path.c_str(), 0775) < 0) { + error << string_compose (_("Cannot create user plugin presets folder (%1)"), user_preset_path) << endmsg; + return false; + } + + if (unit->GetAUPreset (propertyList) != noErr) { + return false; + } + + // add the actual preset name */ + + v.push_back (preset_name + preset_suffix); + + // rebuild + + user_preset_path = Glib::build_filename (v); + + set_preset_name_in_plist (propertyList, preset_name); + + if (save_property_list (propertyList, user_preset_path)) { + error << string_compose (_("Saving plugin state to %1 failed"), user_preset_path) << endmsg; + ret = false; + } + + CFRelease(propertyList); + + return ret; +#else + if (!seen_saving_message) { + info << _("Saving AudioUnit presets is not supported in this build of Ardour. Consider paying for a newer version") + << endmsg; + seen_saving_message = true; + } return false; +#endif +} + +//----------------------------------------------------------------------------- +// this is just a little helper function used by GetAUComponentDescriptionFromPresetFile() +static SInt32 +GetDictionarySInt32Value(CFDictionaryRef inAUStateDictionary, CFStringRef inDictionaryKey, Boolean * outSuccess) +{ + CFNumberRef cfNumber; + SInt32 numberValue = 0; + Boolean dummySuccess; + + if (outSuccess == NULL) + outSuccess = &dummySuccess; + if ( (inAUStateDictionary == NULL) || (inDictionaryKey == NULL) ) + { + *outSuccess = FALSE; + return 0; + } + + cfNumber = (CFNumberRef) CFDictionaryGetValue(inAUStateDictionary, inDictionaryKey); + if (cfNumber == NULL) + { + *outSuccess = FALSE; + return 0; + } + *outSuccess = CFNumberGetValue(cfNumber, kCFNumberSInt32Type, &numberValue); + if (*outSuccess) + return numberValue; + else + return 0; +} + +static OSStatus +GetAUComponentDescriptionFromStateData(CFPropertyListRef inAUStateData, ComponentDescription * outComponentDescription) +{ + CFDictionaryRef auStateDictionary; + ComponentDescription tempDesc = {0}; + SInt32 versionValue; + Boolean gotValue; + + if ( (inAUStateData == NULL) || (outComponentDescription == NULL) ) + return paramErr; + + // the property list for AU state data must be of the dictionary type + if (CFGetTypeID(inAUStateData) != CFDictionaryGetTypeID()) { + return kAudioUnitErr_InvalidPropertyValue; + } + + auStateDictionary = (CFDictionaryRef)inAUStateData; + + // first check to make sure that the version of the AU state data is one that we know understand + // XXX should I really do this? later versions would probably still hold these ID keys, right? + versionValue = GetDictionarySInt32Value(auStateDictionary, CFSTR(kAUPresetVersionKey), &gotValue); + + if (!gotValue) { + return kAudioUnitErr_InvalidPropertyValue; + } +#define kCurrentSavedStateVersion 0 + if (versionValue != kCurrentSavedStateVersion) { + return kAudioUnitErr_InvalidPropertyValue; + } + + // grab the ComponentDescription values from the AU state data + tempDesc.componentType = (OSType) GetDictionarySInt32Value(auStateDictionary, CFSTR(kAUPresetTypeKey), NULL); + tempDesc.componentSubType = (OSType) GetDictionarySInt32Value(auStateDictionary, CFSTR(kAUPresetSubtypeKey), NULL); + tempDesc.componentManufacturer = (OSType) GetDictionarySInt32Value(auStateDictionary, CFSTR(kAUPresetManufacturerKey), NULL); + // zero values are illegit for specific ComponentDescriptions, so zero for any value means that there was an error + if ( (tempDesc.componentType == 0) || (tempDesc.componentSubType == 0) || (tempDesc.componentManufacturer == 0) ) + return kAudioUnitErr_InvalidPropertyValue; + + *outComponentDescription = tempDesc; + return noErr; +} + + +static bool au_preset_filter (const string& str, void* arg) +{ + /* Not a dotfile, has a prefix before a period, suffix is aupreset */ + + bool ret; + + ret = (str[0] != '.' && str.length() > 9 && str.find (preset_suffix) == (str.length() - preset_suffix.length())); + + if (ret && arg) { + + /* check the preset file path name against this plugin + ID. The idea is that all preset files for this plugin + include "/" in their path. + */ + + Plugin* p = (Plugin *) arg; + string match = p->maker(); + match += '/'; + match += p->name(); + + ret = str.find (match) != string::npos; + + if (ret == false) { + string m = p->maker (); + string n = p->name (); + strip_whitespace_edges (m); + strip_whitespace_edges (n); + match = m; + match += '/'; + match += n; + + ret = str.find (match) != string::npos; + } + } + + return ret; +} + +bool +check_and_get_preset_name (Component component, const string& pathstr, string& preset_name) +{ + OSStatus status; + CFPropertyListRef plist; + ComponentDescription presetDesc; + bool ret = false; + + plist = load_property_list (pathstr); + + if (!plist) { + return ret; + } + + // get the ComponentDescription from the AU preset file + + status = GetAUComponentDescriptionFromStateData(plist, &presetDesc); + + if (status == noErr) { + if (ComponentAndDescriptionMatch_Loosely(component, &presetDesc)) { + + /* try to get the preset name from the property list */ + + if (CFGetTypeID(plist) == CFDictionaryGetTypeID()) { + + const void* psk = CFDictionaryGetValue ((CFMutableDictionaryRef)plist, CFSTR(kAUPresetNameKey)); + + if (psk) { + + const char* p = CFStringGetCStringPtr ((CFStringRef) psk, kCFStringEncodingUTF8); + + if (!p) { + char buf[PATH_MAX+1]; + + if (CFStringGetCString ((CFStringRef)psk, buf, sizeof (buf), kCFStringEncodingUTF8)) { + preset_name = buf; + } + } + } + } + } + } + + CFRelease (plist); + + return true; } -vector +std::string +AUPlugin::current_preset() const +{ + string preset_name; + +#ifdef AU_STATE_SUPPORT + CFPropertyListRef propertyList; + + if (unit->GetAUPreset (propertyList) == noErr) { + preset_name = get_preset_name_in_plist (propertyList); + CFRelease(propertyList); + } +#endif + return preset_name; +} + +vector AUPlugin::get_presets () { - vector presets; - + vector* preset_files; + vector presets; + PathScanner scanner; + + preset_files = scanner (preset_search_path, au_preset_filter, this, true, true, -1, true); + + if (!preset_files) { + return presets; + } + + for (vector::iterator x = preset_files->begin(); x != preset_files->end(); ++x) { + + string path = *(*x); + string preset_name; + + /* make an initial guess at the preset name using the path */ + + preset_name = Glib::path_get_basename (path); + preset_name = preset_name.substr (0, preset_name.find_last_of ('.')); + + /* check that this preset file really matches this plugin + and potentially get the "real" preset name from + within the file. + */ + + if (check_and_get_preset_name (get_comp()->Comp(), path, preset_name)) { + presets.push_back (preset_name); + preset_map[preset_name] = path; + } + + delete *x; + } + + delete preset_files; + return presets; } @@ -839,13 +1422,13 @@ AUPluginInfo::load (Session& session) PluginPtr plugin; boost::shared_ptr comp (new CAComponent(*descriptor)); - + if (!comp->IsValid()) { error << ("AudioUnit: not a valid Component") << endmsg; } else { plugin.reset (new AUPlugin (session.engine(), session, comp)); } - + plugin->set_info (PluginInfoPtr (new AUPluginInfo (*this))); return plugin; } @@ -871,9 +1454,10 @@ AUPluginInfo::discover () } PluginInfoList plugs; - + discover_fx (plugs); discover_music (plugs); + discover_generators (plugs); return plugs; } @@ -904,6 +1488,19 @@ AUPluginInfo::discover_fx (PluginInfoList& plugs) discover_by_description (plugs, desc); } +void +AUPluginInfo::discover_generators (PluginInfoList& plugs) +{ + CAComponentDescription desc; + desc.componentFlags = 0; + desc.componentFlagsMask = 0; + desc.componentSubType = 0; + desc.componentManufacturer = 0; + desc.componentType = kAudioUnitType_Generator; + + discover_by_description (plugs, desc); +} + void AUPluginInfo::discover_by_description (PluginInfoList& plugs, CAComponentDescription& desc) { @@ -915,7 +1512,7 @@ AUPluginInfo::discover_by_description (PluginInfoList& plugs, CAComponentDescrip CAComponentDescription temp; GetComponentInfo (comp, &temp, NULL, NULL, NULL); - AUPluginInfoPtr info (new AUPluginInfo + AUPluginInfoPtr info (new AUPluginInfo (boost::shared_ptr (new CAComponentDescription(temp)))); /* no panners, format converters or i/o AU's for our purposes @@ -926,6 +1523,13 @@ AUPluginInfo::discover_by_description (PluginInfoList& plugs, CAComponentDescrip case kAudioUnitType_OfflineEffect: case kAudioUnitType_FormatConverter: continue; + case kAudioUnitType_Output: + case kAudioUnitType_MusicDevice: + case kAudioUnitType_MusicEffect: + case kAudioUnitType_Effect: + case kAudioUnitType_Mixer: + case kAudioUnitType_Generator: + break; default: break; } @@ -935,15 +1539,12 @@ AUPluginInfo::discover_by_description (PluginInfoList& plugs, CAComponentDescrip case kAudioUnitSubType_SystemOutput: case kAudioUnitSubType_GenericOutput: case kAudioUnitSubType_AUConverter: + /* we don't want output units here */ continue; break; case kAudioUnitSubType_DLSSynth: - info->category = "DLSSynth"; - break; - - case kAudioUnitType_MusicEffect: - info->category = "MusicEffect"; + info->category = "DLS Synth"; break; case kAudioUnitSubType_Varispeed: @@ -955,55 +1556,59 @@ AUPluginInfo::discover_by_description (PluginInfoList& plugs, CAComponentDescrip break; case kAudioUnitSubType_LowPassFilter: - info->category = "LowPassFilter"; + info->category = "Low-pass Filter"; break; case kAudioUnitSubType_HighPassFilter: - info->category = "HighPassFilter"; + info->category = "High-pass Filter"; break; case kAudioUnitSubType_BandPassFilter: - info->category = "BandPassFilter"; + info->category = "Band-pass Filter"; break; case kAudioUnitSubType_HighShelfFilter: - info->category = "HighShelfFilter"; + info->category = "High-shelf Filter"; break; case kAudioUnitSubType_LowShelfFilter: - info->category = "LowShelfFilter"; + info->category = "Low-shelf Filter"; break; case kAudioUnitSubType_ParametricEQ: - info->category = "ParametricEQ"; + info->category = "Parametric EQ"; break; case kAudioUnitSubType_GraphicEQ: - info->category = "GraphicEQ"; + info->category = "Graphic EQ"; break; case kAudioUnitSubType_PeakLimiter: - info->category = "PeakLimiter"; + info->category = "Peak Limiter"; break; case kAudioUnitSubType_DynamicsProcessor: - info->category = "DynamicsProcessor"; + info->category = "Dynamics Processor"; break; case kAudioUnitSubType_MultiBandCompressor: - info->category = "MultiBandCompressor"; + info->category = "Multiband Compressor"; break; case kAudioUnitSubType_MatrixReverb: - info->category = "MatrixReverb"; + info->category = "Matrix Reverb"; break; - case kAudioUnitType_Mixer: - info->category = "Mixer"; + case kAudioUnitSubType_SampleDelay: + info->category = "Sample Delay"; break; - case kAudioUnitSubType_StereoMixer: - info->category = "StereoMixer"; + case kAudioUnitSubType_Pitch: + info->category = "Pitch"; + break; + + case kAudioUnitSubType_NetSend: + info->category = "Net Sender"; break; case kAudioUnitSubType_3DMixer: @@ -1014,6 +1619,19 @@ AUPluginInfo::discover_by_description (PluginInfoList& plugs, CAComponentDescrip info->category = "MatrixMixer"; break; + case kAudioUnitSubType_ScheduledSoundPlayer: + info->category = "Scheduled Sound Player"; + break; + + + case kAudioUnitSubType_AudioFilePlayer: + info->category = "Audio File Player"; + break; + + case kAudioUnitSubType_NetReceive: + info->category = "Net Receiver"; + break; + default: info->category = ""; } @@ -1031,15 +1649,17 @@ AUPluginInfo::discover_by_description (PluginInfoList& plugs, CAComponentDescrip if (cacomp.GetResourceVersion (info->version) != noErr) { info->version = 0; } - + if (cached_io_configuration (info->unique_id, info->version, cacomp, info->cache, info->name)) { /* here we have to map apple's wildcard system to a simple pair - of values. + of values. in ::can_do() we use the whole system, but here + we need a single pair of values. XXX probably means we should + remove any use of these values. */ - info->n_inputs = ChanCount (DataType::AUDIO, info->cache.io_configs.front().first); - info->n_outputs = ChanCount (DataType::AUDIO, info->cache.io_configs.front().second); + info->n_inputs = info->cache.io_configs.front().first; + info->n_outputs = info->cache.io_configs.front().second; if (info->cache.io_configs.size() > 1) { cerr << "ODD: variable IO config for " << info->unique_id << endl; @@ -1050,16 +1670,16 @@ AUPluginInfo::discover_by_description (PluginInfoList& plugs, CAComponentDescrip } else { error << string_compose (_("Cannot get I/O configuration info for AU %1"), info->name) << endmsg; } - + comp = FindNextComponent (comp, &desc); } } bool -AUPluginInfo::cached_io_configuration (const std::string& unique_id, +AUPluginInfo::cached_io_configuration (const std::string& unique_id, UInt32 version, - CAComponent& comp, - AUPluginCachedInfo& cinfo, + CAComponent& comp, + AUPluginCachedInfo& cinfo, const std::string& name) { std::string id; @@ -1086,9 +1706,9 @@ AUPluginInfo::cached_io_configuration (const std::string& unique_id, AUChannelInfo* channel_info; UInt32 cnt; int ret; - + ARDOUR::BootMessage (string_compose (_("Checking AudioUnit: %1"), name)); - + try { if (CAAudioUnit::Open (comp, unit) != noErr) { @@ -1102,7 +1722,7 @@ AUPluginInfo::cached_io_configuration (const std::string& unique_id, return false; } - + if ((ret = unit.GetChannelInfo (&channel_info, cnt)) < 0) { return false; } @@ -1113,9 +1733,9 @@ AUPluginInfo::cached_io_configuration (const std::string& unique_id, cinfo.io_configs.push_back (pair (-1, -1)); } else { - + /* store each configuration */ - + for (uint32_t n = 0; n < cnt; ++n) { cinfo.io_configs.push_back (pair (channel_info[n].inChannels, channel_info[n].outChannels)); @@ -1142,7 +1762,7 @@ AUPluginInfo::save_cached_info () XMLNode* node; node = new XMLNode (X_("AudioUnitPluginCache")); - + for (map::iterator i = cached_info.begin(); i != cached_info.end(); ++i) { XMLNode* parent = new XMLNode (X_("plugin")); parent->add_property ("id", i->first); @@ -1178,7 +1798,7 @@ AUPluginInfo::load_cached_info () { Glib::ustring path = au_cache_path (); XMLTree tree; - + if (!Glib::file_test (path, Glib::FILE_TEST_EXISTS)) { return 0; } @@ -1195,9 +1815,9 @@ AUPluginInfo::load_cached_info () const XMLNodeList children = root->children(); for (XMLNodeConstIterator iter = children.begin(); iter != children.end(); ++iter) { - + const XMLNode* child = *iter; - + if (child->name() == X_("plugin")) { const XMLNode* gchild; @@ -1209,7 +1829,8 @@ AUPluginInfo::load_cached_info () } std::string id = prop->value(); - + AUPluginCachedInfo cinfo; + for (XMLNodeConstIterator giter = gchildren.begin(); giter != gchildren.end(); giter++) { gchild = *giter; @@ -1225,13 +1846,15 @@ AUPluginInfo::load_cached_info () ((oprop = gchild->property (X_("out"))) != 0)) { in = atoi (iprop->value()); out = atoi (iprop->value()); - - AUPluginCachedInfo cinfo; + cinfo.io_configs.push_back (pair (in, out)); - add_cached_info (id, cinfo); } } } + + if (cinfo.io_configs.size()) { + add_cached_info (id, cinfo); + } } } @@ -1259,16 +1882,16 @@ AUPluginInfo::get_names (CAComponentDescription& comp_desc, std::string& name, G DisposeHandle(nameHandle); } } - + // if Marc-style fails, do the original way if (itemName == NULL) { CFStringRef compTypeString = UTCreateStringForOSType(comp_desc.componentType); CFStringRef compSubTypeString = UTCreateStringForOSType(comp_desc.componentSubType); CFStringRef compManufacturerString = UTCreateStringForOSType(comp_desc.componentManufacturer); - - itemName = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%@ - %@ - %@"), + + itemName = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%@ - %@ - %@"), compTypeString, compManufacturerString, compSubTypeString); - + if (compTypeString != NULL) CFRelease(compTypeString); if (compSubTypeString != NULL) @@ -1276,7 +1899,7 @@ AUPluginInfo::get_names (CAComponentDescription& comp_desc, std::string& name, G if (compManufacturerString != NULL) CFRelease(compManufacturerString); } - + string str = CFStringRefToStdString(itemName); string::size_type colon = str.find (':'); @@ -1302,10 +1925,10 @@ AUPluginInfo::stringify_descriptor (const CAComponentDescription& desc) s << StringForOSType (desc.Type(), str); s << " - "; - + s << StringForOSType (desc.SubType(), str); s << " - "; - + s << StringForOSType (desc.Manu(), str); return s.str();