X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudio_unit.cc;h=0b68c95dcedcc85089b2ff3b15ad44d86b983d4e;hb=b66726fdc12c91dc55be0cf18385aea06a300e15;hp=cab6a56c9275f14eb1844e83edfcf010dd906294;hpb=9041fc8d54f4f2e2a3871b05707569ea870f5520;p=ardour.git diff --git a/libs/ardour/audio_unit.cc b/libs/ardour/audio_unit.cc index cab6a56c92..0b68c95dce 100644 --- a/libs/ardour/audio_unit.cc +++ b/libs/ardour/audio_unit.cc @@ -38,13 +38,13 @@ #include #include "ardour/ardour.h" +#include "ardour/audio_unit.h" #include "ardour/audioengine.h" #include "ardour/audio_buffer.h" #include "ardour/debug.h" -#include "ardour/midi_buffer.h" #include "ardour/filesystem_paths.h" #include "ardour/io.h" -#include "ardour/audio_unit.h" +#include "ardour/midi_buffer.h" #include "ardour/route.h" #include "ardour/session.h" #include "ardour/tempo.h" @@ -71,7 +71,7 @@ #define ArdourFindNext AudioComponentFindNext #endif -#include "i18n.h" +#include "pbd/i18n.h" using namespace std; using namespace PBD; @@ -163,11 +163,11 @@ _render_callback(void *userData, AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber, - UInt32 inNumberFrames, + UInt32 inNumberSamples, AudioBufferList* ioData) { if (userData) { - return ((AUPlugin*)userData)->render_callback (ioActionFlags, inTimeStamp, inBusNumber, inNumberFrames, ioData); + return ((AUPlugin*)userData)->render_callback (ioActionFlags, inTimeStamp, inBusNumber, inNumberSamples, ioData); } return paramErr; } @@ -430,18 +430,27 @@ AUPlugin::AUPlugin (AudioEngine& engine, Session& session, boost::shared_ptrUninitialize (); } - if (buffers) { - free (buffers); - } + free (buffers); + free (bus_inputs); + free (bus_outputs); + free (cb_offsets); } void @@ -586,18 +607,56 @@ AUPlugin::init () DEBUG_TRACE (DEBUG::AudioUnits, "count output elements\n"); unit->GetElementCount (kAudioUnitScope_Output, output_elements); - if (input_elements > 0) { - /* setup render callback: the plugin calls this to get input data - */ + cb_offsets = (samplecnt_t*) calloc (input_elements, sizeof(samplecnt_t)); + bus_inputs = (uint32_t*) calloc (input_elements, sizeof(uint32_t)); + bus_outputs = (uint32_t*) calloc (output_elements, sizeof(uint32_t)); - AURenderCallbackStruct renderCallbackInfo; + for (size_t i = 0; i < output_elements; ++i) { + unit->Reset (kAudioUnitScope_Output, i); + AudioStreamBasicDescription fmt; + err = unit->GetFormat (kAudioUnitScope_Output, i, fmt); + if (err == noErr) { + bus_outputs[i] = fmt.mChannelsPerFrame; + } + CFStringRef name; + UInt32 sz = sizeof (CFStringRef); + if (AudioUnitGetProperty (unit->AU(), kAudioUnitProperty_ElementName, kAudioUnitScope_Output, + i, &name, &sz) == noErr + && sz > 0) { + _bus_name_out.push_back (CFStringRefToStdString (name)); + CFRelease(name); + } else { + _bus_name_out.push_back (string_compose ("Audio-Bus %1", i)); + } + } + + for (size_t i = 0; i < input_elements; ++i) { + unit->Reset (kAudioUnitScope_Input, i); + AudioStreamBasicDescription fmt; + err = unit->GetFormat (kAudioUnitScope_Input, i, fmt); + if (err == noErr) { + bus_inputs[i] = fmt.mChannelsPerFrame; + } + CFStringRef name; + UInt32 sz = sizeof (CFStringRef); + if (AudioUnitGetProperty (unit->AU(), kAudioUnitProperty_ElementName, kAudioUnitScope_Input, + i, &name, &sz) == noErr + && sz > 0) { + _bus_name_in.push_back (CFStringRefToStdString (name)); + CFRelease(name); + } else { + _bus_name_in.push_back (string_compose ("Audio-Bus %1", i)); + } + } + for (size_t i = 0; i < input_elements; ++i) { + /* setup render callback: the plugin calls this to get input data */ + AURenderCallbackStruct renderCallbackInfo; renderCallbackInfo.inputProc = _render_callback; renderCallbackInfo.inputProcRefCon = this; - DEBUG_TRACE (DEBUG::AudioUnits, "set render callback in input scope\n"); if ((err = unit->SetProperty (kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, - 0, (void*) &renderCallbackInfo, sizeof(renderCallbackInfo))) != 0) { + i, (void*) &renderCallbackInfo, sizeof(renderCallbackInfo))) != 0) { error << string_compose (_("cannot install render callback (err = %1)"), err) << endmsg; throw failed_constructor(); } @@ -748,8 +807,6 @@ AUPlugin::discover_parameters () break; } - d.min_unbound = 0; // lower is bound - d.max_unbound = 0; // upper is bound d.update_steps(); descriptors.push_back (d); @@ -894,10 +951,15 @@ AUPlugin::default_value (uint32_t port) return 0; } -framecnt_t +samplecnt_t AUPlugin::signal_latency () const { - return unit->Latency() * _session.frame_rate(); + guint lat = g_atomic_int_get (&_current_latency);; + if (lat == UINT_MAX) { + lat = unit->Latency() * _session.sample_rate(); + g_atomic_int_set (&_current_latency, lat); + } + return lat; } void @@ -974,7 +1036,7 @@ AUPlugin::activate () if ((err = unit->Initialize()) != noErr) { error << string_compose (_("AUPlugin: %1 cannot initialize plugin (err = %2)"), name(), err) << endmsg; } else { - frames_processed = 0; + samples_processed = 0; initialized = true; } } @@ -1006,17 +1068,17 @@ int AUPlugin::set_block_size (pframes_t nframes) { bool was_initialized = initialized; - UInt32 numFrames = nframes; + UInt32 numSamples = nframes; OSErr err; if (initialized) { deactivate (); } - DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("set MaximumFramesPerSlice in global scope to %1\n", numFrames)); + DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("set MaximumFramesPerSlice in global scope to %1\n", numSamples)); if ((err = unit->SetProperty (kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, - 0, &numFrames, sizeof (numFrames))) != noErr) { - error << string_compose (_("AU: cannot set max frames (err = %1)"), err) << endmsg; + 0, &numSamples, sizeof (numSamples))) != noErr) { + error << string_compose (_("AU: cannot set max samples (err = %1)"), err) << endmsg; return -1; } @@ -1024,8 +1086,6 @@ AUPlugin::set_block_size (pframes_t nframes) activate (); } - _current_block_size = nframes; - return 0; } @@ -1038,7 +1098,7 @@ AUPlugin::configure_io (ChanCount in, ChanCount out) if (audio_input_cnt > 0) { in.set (DataType::AUDIO, audio_input_cnt); } - int32_t audio_in = in.n_audio(); + const int32_t audio_in = in.n_audio(); DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("configure %1 for %2 in %3 out\n", name(), in, out)); @@ -1051,7 +1111,7 @@ AUPlugin::configure_io (ChanCount in, ChanCount out) } } - streamFormat.mSampleRate = _session.frame_rate(); + streamFormat.mSampleRate = _session.sample_rate(); streamFormat.mFormatID = kAudioFormatLinearPCM; streamFormat.mFormatFlags = kAudioFormatFlagIsFloat|kAudioFormatFlagIsPacked|kAudioFormatFlagIsNonInterleaved; @@ -1065,27 +1125,92 @@ AUPlugin::configure_io (ChanCount in, ChanCount out) streamFormat.mFramesPerPacket = 1; /* apple says that for non-interleaved data, these - values always refer to a single channel. - */ + * values always refer to a single channel. + */ streamFormat.mBytesPerPacket = 4; streamFormat.mBytesPerFrame = 4; - streamFormat.mChannelsPerFrame = audio_in; + configured_input_busses = 0; + configured_output_busses = 0; + /* reset busses */ + for (size_t i = 0; i < output_elements; ++i) { + unit->Reset (kAudioUnitScope_Output, i); + } + for (size_t i = 0; i < input_elements; ++i) { + unit->Reset (kAudioUnitScope_Input, i); + } - if (set_input_format (streamFormat) != 0) { - return false; + /* now assign the channels to available busses */ + uint32_t used_in = 0; + uint32_t used_out = 0; + + if (variable_inputs || input_elements == 1) { + // we only ever use the first bus + if (input_elements > 1) { + warning << string_compose (_("AU %1 has multiple input busses and variable port count."), name()) << endmsg; + } + streamFormat.mChannelsPerFrame = audio_in; + if (set_stream_format (kAudioUnitScope_Input, 0, streamFormat) != 0) { + return false; + } + configured_input_busses = 1; + used_in = audio_in; + } else { + configured_input_busses = 0; + uint32_t remain = audio_in; + for (uint32_t bus = 0; remain > 0 && bus < input_elements; ++bus) { + uint32_t cnt = std::min (remain, bus_inputs[bus]); + if (cnt == 0) { continue; } + DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("%1 configure input bus: %2 chn: %3", name(), bus, cnt)); + + streamFormat.mChannelsPerFrame = cnt; + if (set_stream_format (kAudioUnitScope_Input, bus, streamFormat) != 0) { + return false; + } + used_in += cnt; + ++configured_input_busses; + remain -= cnt; + } } - streamFormat.mChannelsPerFrame = audio_out; + if (variable_outputs || output_elements == 1) { + if (output_elements > 1) { + warning << string_compose (_("AU %1 has multiple output busses and variable port count."), name()) << endmsg; + } - if (set_output_format (streamFormat) != 0) { - return false; + streamFormat.mChannelsPerFrame = audio_out; + if (set_stream_format (kAudioUnitScope_Output, 0, streamFormat) != 0) { + return false; + } + configured_output_busses = 1; + used_out = audio_out; + } else { + uint32_t remain = audio_out; + configured_output_busses = 0; + for (uint32_t bus = 0; remain > 0 && bus < output_elements; ++bus) { + uint32_t cnt = std::min (remain, bus_outputs[bus]); + if (cnt == 0) { continue; } + DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("%1 configure output bus: %2 chn: %3", name(), bus, cnt)); + streamFormat.mChannelsPerFrame = cnt; + if (set_stream_format (kAudioUnitScope_Output, bus, streamFormat) != 0) { + return false; + } + used_out += cnt; + remain -= cnt; + ++configured_output_busses; + } } + free (buffers); + buffers = (AudioBufferList *) malloc (offsetof(AudioBufferList, mBuffers) + + used_out * sizeof(::AudioBuffer)); + + input_channels = used_in; + output_channels = used_out; /* reset plugin info to show currently configured state */ - _info->n_inputs = in; - _info->n_outputs = out; + _info->n_inputs = ChanCount (DataType::AUDIO, used_in) + ChanCount (DataType::MIDI, _has_midi_input ? 1 : 0); + _info->n_outputs = ChanCount (DataType::AUDIO, used_out); if (was_initialized) { activate (); @@ -1098,8 +1223,6 @@ ChanCount AUPlugin::input_streams() const { ChanCount c; - - if (input_channels < 0) { // force PluginIoReConfigure -- see also commit msg e38eb06 c.set (DataType::AUDIO, 0); @@ -1108,7 +1231,6 @@ AUPlugin::input_streams() const c.set (DataType::AUDIO, input_channels); c.set (DataType::MIDI, _has_midi_input ? 1 : 0); } - return c; } @@ -1117,7 +1239,6 @@ ChanCount AUPlugin::output_streams() const { ChanCount c; - if (output_channels < 0) { // force PluginIoReConfigure - see also commit msg e38eb06 c.set (DataType::AUDIO, 0); @@ -1126,17 +1247,14 @@ AUPlugin::output_streams() const c.set (DataType::AUDIO, output_channels); c.set (DataType::MIDI, _has_midi_output ? 1 : 0); } - return c; } bool AUPlugin::can_support_io_configuration (const ChanCount& in, ChanCount& out, ChanCount* imprecise) { - // Note: We never attempt to multiply-instantiate plugins to meet io configurations. - + _output_configs.clear (); const int32_t audio_in = in.n_audio(); - int32_t audio_out; AUPluginInfoPtr pinfo = boost::dynamic_pointer_cast(get_info()); /* lets check MIDI first */ @@ -1145,13 +1263,67 @@ AUPlugin::can_support_io_configuration (const ChanCount& in, ChanCount& out, Cha return false; } - vector >& io_configs = pinfo->cache.io_configs; + vector > io_configs = pinfo->cache.io_configs; + + if (input_elements > 1) { + const vector >& ioc (pinfo->cache.io_configs); + for (vector >::const_iterator i = ioc.begin(); i != ioc.end(); ++i) { + int32_t possible_in = i->first; + int32_t possible_out = i->second; + if (possible_in < 0) { + continue; + } + for (uint32_t i = 1; i < input_elements; ++i) { + // can't use up-to bus_inputs[] + // waves' SC-C6(s) for example fails to configure with only 1 input + // on the 2nd bus. + io_configs.push_back (pair (possible_in + bus_inputs[i], possible_out)); + } + /* only add additional, optional busses to first available config. + * AUPluginInfo::cached_io_configuration () already incrementally + * adds busses (for instruments w/ multiple configurations) + */ + break; + } + } + + if (output_elements > 1) { + const vector >& ioc (pinfo->cache.io_configs); + for (vector >::const_iterator i = ioc.begin(); i != ioc.end(); ++i) { + int32_t possible_in = i->first; + int32_t possible_out = i->second; + if (possible_out < 0) { + continue; + } + for (uint32_t i = 1; i < output_elements; ++i) { + int32_t c = bus_outputs[i]; + for (uint32_t j = 1; j < i; ++j) { + c += bus_outputs [j]; + } + io_configs.push_back (pair (possible_in, possible_out + c)); + } + /* only add additional, optional busses to first available config. + * AUPluginInfo::cached_io_configuration () already incrementally + * adds busses (for instruments w/ multiple configurations) + */ + break; + } + } DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("%1 has %2 IO configurations, looking for %3 in, %4 out\n", name(), io_configs.size(), in, out)); +#if 0 + printf ("AU I/O Configs %s %d\n", name(), io_configs.size()); + for (vector >::iterator i = io_configs.begin(); i != io_configs.end(); ++i) { + printf ("- I/O %d / %d\n", i->first, i->second); + } +#endif + // preferred setting (provided by plugin_insert) - audio_out = out.n_audio (); + const int preferred_out = out.n_audio (); + bool found = false; + bool exact_match = false; /* kAudioUnitProperty_SupportedNumChannels * https://developer.apple.com/library/mac/documentation/MusicAudio/Conceptual/AudioUnitProgrammingGuide/TheAudioUnit/TheAudioUnit.html#//apple_ref/doc/uid/TP40003278-CH12-SW20 @@ -1184,35 +1356,49 @@ AUPlugin::can_support_io_configuration (const ChanCount& in, ChanCount& out, Cha int32_t possible_in = i->first; int32_t possible_out = i->second; - if ((possible_in == audio_in) && (possible_out == audio_out)) { + if ((possible_in == audio_in) && (possible_out == preferred_out)) { DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("\tCHOSEN: %1 in %2 out to match in %3 out %4\n", - possible_in, possible_out, - in, out)); - - out.set (DataType::MIDI, 0); - out.set (DataType::AUDIO, audio_out); + possible_in, possible_out, + in, out)); - return true; + // exact match + _output_configs.insert (preferred_out); + exact_match = true; + found = true; + break; } } /* now allow potentially "imprecise" matches */ - audio_out = -1; - bool found = false; - + int32_t audio_out = -1; float penalty = 9999; - const int preferred_out = out.n_audio (); int used_possible_in = 0; +#if defined (__clang__) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wtautological-compare" +#endif -#define FOUNDCFG(nch) { \ - float p = fabsf ((float)(nch) - preferred_out); \ - if ((nch) > preferred_out) { p *= 1.1; } \ - if (p < penalty) { \ - used_possible_in = possible_in; \ - audio_out = (nch); \ - penalty = p; \ - found = true; \ - } \ +#define FOUNDCFG(nch) { \ + float p = fabsf ((float)(nch) - preferred_out); \ + _output_configs.insert (nch); \ + if ((nch) > preferred_out) { p *= 1.1; } \ + if (p < penalty) { \ + used_possible_in = possible_in; \ + audio_out = (nch); \ + penalty = p; \ + found = true; \ + variable_inputs = possible_in < 0; \ + variable_outputs = possible_out < 0; \ + } \ +} + +#define ANYTHINGGOES \ + _output_configs.insert (0); + +#define UPTO(nch) { \ + for (int n = 1; n <= nch; ++n) { \ + _output_configs.insert (n); \ + } \ } for (vector >::iterator i = io_configs.begin(); i != io_configs.end(); ++i) { @@ -1233,12 +1419,15 @@ AUPlugin::can_support_io_configuration (const ChanCount& in, ChanCount& out, Cha if (possible_out == -1) { /* any configuration possible, provide stereo output */ FOUNDCFG (preferred_out); + ANYTHINGGOES; } else if (possible_out == -2) { /* invalid, should be (0, -1) */ FOUNDCFG (preferred_out); + ANYTHINGGOES; } else if (possible_out < -2) { /* variable number of outputs up to -N, */ FOUNDCFG (min (-possible_out, preferred_out)); + UPTO (-possible_out); } else { /* exact number of outputs */ FOUNDCFG (possible_out); @@ -1253,11 +1442,13 @@ AUPlugin::can_support_io_configuration (const ChanCount& in, ChanCount& out, Cha } else if (possible_out == -2) { /* any configuration possible, pick matching */ FOUNDCFG (preferred_out); + ANYTHINGGOES; } else if (possible_out < -2) { /* explicitly variable number of outputs, pick maximum */ FOUNDCFG (max (-possible_out, preferred_out)); /* and try min, too, in case the penalty is lower */ FOUNDCFG (min (-possible_out, preferred_out)); + UPTO (-possible_out) } else { /* exact number of outputs */ FOUNDCFG (possible_out); @@ -1268,13 +1459,16 @@ AUPlugin::can_support_io_configuration (const ChanCount& in, ChanCount& out, Cha if (possible_out == -1) { /* any configuration possible, pick matching */ FOUNDCFG (preferred_out); + ANYTHINGGOES; } else if (possible_out == -2) { /* invalid. interpret as (-1, -1) */ FOUNDCFG (preferred_out); + ANYTHINGGOES; } else if (possible_out < -2) { /* invalid, interpret as (<-2, <-2) * variable number of outputs up to -N, */ FOUNDCFG (min (-possible_out, preferred_out)); + UPTO (-possible_out) } else { /* exact number of outputs */ FOUNDCFG (possible_out); @@ -1291,14 +1485,17 @@ AUPlugin::can_support_io_configuration (const ChanCount& in, ChanCount& out, Cha if (audio_in > -possible_in && imprecise == NULL) { /* request is too large */ } else if (possible_out == -1) { - /* any output configuration possible, provide stereo out */ + /* any output configuration possible */ FOUNDCFG (preferred_out); + ANYTHINGGOES; } else if (possible_out == -2) { /* invalid. interpret as (<-2, -1) */ FOUNDCFG (preferred_out); + ANYTHINGGOES; } else if (possible_out < -2) { /* variable number of outputs up to -N, */ FOUNDCFG (min (-possible_out, preferred_out)); + UPTO (-possible_out) } else { /* exact number of outputs */ FOUNDCFG (possible_out); @@ -1310,15 +1507,16 @@ AUPlugin::can_support_io_configuration (const ChanCount& in, ChanCount& out, Cha if (possible_out == -1) { /* any output configuration possible */ FOUNDCFG (preferred_out); + ANYTHINGGOES; } else if (possible_out == -2) { - /* plugins shouldn't really use (>0,-2) but might. - * interpret as (>0,-1): - */ + /* plugins shouldn't really use (>0,-2), interpret as (>0,-1) */ FOUNDCFG (preferred_out); + ANYTHINGGOES; } else if (possible_out < -2) { /* > 0, < -2 is not specified * interpret as up to -N */ FOUNDCFG (min (-possible_out, preferred_out)); + UPTO (-possible_out) } else { /* exact number of outputs */ FOUNDCFG (possible_out); @@ -1350,117 +1548,104 @@ AUPlugin::can_support_io_configuration (const ChanCount& in, ChanCount& out, Cha } } - if (found) { + if (!found) { + DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("\tFAIL: no io configs match %1\n", in)); + return false; + } + + if (exact_match) { + out.set (DataType::MIDI, 0); // currently always zero + out.set (DataType::AUDIO, preferred_out); + } else { if (used_possible_in < -2 && audio_in == 0) { // input-port count cannot be zero, use as many ports // as outputs, but at most abs(possible_in) audio_input_cnt = max (1, min (audio_out, -used_possible_in)); } - out.set (DataType::MIDI, 0); /// XXX out.set (DataType::AUDIO, audio_out); - DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("\tCHOSEN: in %1 out %2\n", in, out)); - } else { - DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("\tFAIL: no io configs match %1\n", in)); - return false; } + DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("\tCHOSEN: in %1 out %2\n", in, out)); +#if defined (__clang__) +# pragma clang diagnostic pop +#endif return true; } int -AUPlugin::set_input_format (AudioStreamBasicDescription& fmt) -{ - return set_stream_format (kAudioUnitScope_Input, input_elements, fmt); -} - -int -AUPlugin::set_output_format (AudioStreamBasicDescription& fmt) -{ - if (set_stream_format (kAudioUnitScope_Output, output_elements, fmt) != 0) { - return -1; - } - - if (buffers) { - free (buffers); - buffers = 0; - } - - buffers = (AudioBufferList *) malloc (offsetof(AudioBufferList, mBuffers) + - fmt.mChannelsPerFrame * sizeof(::AudioBuffer)); - - return 0; -} - -int -AUPlugin::set_stream_format (int scope, uint32_t cnt, AudioStreamBasicDescription& fmt) +AUPlugin::set_stream_format (int scope, uint32_t bus, AudioStreamBasicDescription& fmt) { OSErr result; - for (uint32_t i = 0; i < cnt; ++i) { - DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("set stream format for %1, scope = %2 element %3\n", - (scope == kAudioUnitScope_Input ? "input" : "output"), - scope, cnt)); - if ((result = unit->SetFormat (scope, i, fmt)) != 0) { - error << string_compose (_("AUPlugin: could not set stream format for %1/%2 (err = %3)"), - (scope == kAudioUnitScope_Input ? "input" : "output"), i, result) << endmsg; - return -1; - } - } - - if (scope == kAudioUnitScope_Input) { - input_channels = fmt.mChannelsPerFrame; - } else { - output_channels = fmt.mChannelsPerFrame; + DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("set stream format for %1, scope = %2 element %3\n", + (scope == kAudioUnitScope_Input ? "input" : "output"), + scope, bus)); + if ((result = unit->SetFormat (scope, bus, fmt)) != 0) { + error << string_compose (_("AUPlugin: could not set stream format for %1/%2 (err = %3)"), + (scope == kAudioUnitScope_Input ? "input" : "output"), bus, result) << endmsg; + return -1; } - return 0; } OSStatus AUPlugin::render_callback(AudioUnitRenderActionFlags*, const AudioTimeStamp*, - UInt32, - UInt32 inNumberFrames, - AudioBufferList* ioData) + UInt32 bus, + UInt32 inNumberSamples, + AudioBufferList* ioData) { /* not much to do with audio - the data is already in the buffers given to us in connect_and_run() */ - // DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("%1: render callback, frames %2 bufs %3\n", - // name(), inNumberFrames, ioData->mNumberBuffers)); + // DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("%1: render callback, samples %2 bus %3 bufs %4\n", + // name(), inNumberSamples, bus, ioData->mNumberBuffers)); if (input_maxbuf == 0) { DEBUG_TRACE (DEBUG::AudioUnits, "AUPlugin: render callback called illegally!"); error << _("AUPlugin: render callback called illegally!") << endmsg; return kAudioUnitErr_CannotDoInCurrentContext; } + + assert (bus < input_elements); + uint32_t busoff = 0; + for (uint32_t i = 0; i < bus; ++i) { + busoff += bus_inputs[i]; + } + uint32_t limit = min ((uint32_t) ioData->mNumberBuffers, input_maxbuf); ChanCount bufs_count (DataType::AUDIO, 1); BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count); + /* apply bus offsets */ + for (uint32_t i = 0; i < limit; ++i) { ioData->mBuffers[i].mNumberChannels = 1; - ioData->mBuffers[i].mDataByteSize = sizeof (Sample) * inNumberFrames; + ioData->mBuffers[i].mDataByteSize = sizeof (Sample) * inNumberSamples; bool valid = false; - uint32_t idx = input_map->get (DataType::AUDIO, i, &valid); + uint32_t idx = input_map->get (DataType::AUDIO, i + busoff, &valid); if (valid) { - ioData->mBuffers[i].mData = input_buffers->get_audio (idx).data (cb_offset + input_offset); + ioData->mBuffers[i].mData = input_buffers->get_audio (idx).data (cb_offsets[bus] + input_offset); } else { - ioData->mBuffers[i].mData = silent_bufs.get_audio(0).data (cb_offset + input_offset); + ioData->mBuffers[i].mData = silent_bufs.get_audio(0).data (cb_offsets[bus] + input_offset); } } - - cb_offset += inNumberFrames; - + cb_offsets[bus] += inNumberSamples; return noErr; } int -AUPlugin::connect_and_run (BufferSet& bufs, ChanMapping in_map, ChanMapping out_map, pframes_t nframes, framecnt_t offset) +AUPlugin::connect_and_run (BufferSet& bufs, + samplepos_t start, samplepos_t end, double speed, + ChanMapping const& in_map, ChanMapping const& out_map, + pframes_t nframes, samplecnt_t offset) { - Plugin::connect_and_run (bufs, in_map, out_map, nframes, offset); + Plugin::connect_and_run(bufs, start, end, speed, in_map, out_map, nframes, offset); + + transport_sample = start; + transport_speed = speed; AudioUnitRenderActionFlags flags = 0; AudioTimeStamp ts; @@ -1471,9 +1656,21 @@ AUPlugin::connect_and_run (BufferSet& bufs, ChanMapping in_map, ChanMapping out_ _last_nframes = nframes; } - DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("%1 in %2 out %3 MIDI %4 bufs %5 (available %6)\n", + /* test if we can run in-place; only compare audio buffers */ + bool inplace = true; // TODO check plugin-insert in-place ? + ChanMapping::Mappings inmap (in_map.mappings ()); + ChanMapping::Mappings outmap (out_map.mappings ()); + if (outmap[DataType::AUDIO].size () == 0) { + inplace = false; + } + if (inmap[DataType::AUDIO].size() > 0 && inmap != outmap) { + inplace = false; + } + + DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("%1 in %2 out %3 MIDI %4 bufs %5 (available %6) InBus %7 OutBus %8 Inplace: %9 var-i/o %10 %11\n", name(), input_channels, output_channels, _has_midi_input, - bufs.count(), bufs.available())); + bufs.count(), bufs.available(), + configured_input_busses, configured_output_busses, inplace, variable_inputs, variable_outputs)); /* the apparent number of buffers matches our input configuration, but we know that the bufferset * has the capacity to handle our outputs. @@ -1485,107 +1682,125 @@ AUPlugin::connect_and_run (BufferSet& bufs, ChanMapping in_map, ChanMapping out_ input_map = &in_map; input_maxbuf = bufs.count().n_audio(); // number of input audio buffers input_offset = offset; - cb_offset = 0; - - buffers->mNumberBuffers = output_channels; - bool inplace = in_map == out_map; + for (size_t i = 0; i < input_elements; ++i) { + cb_offsets[i] = 0; + } ChanCount bufs_count (DataType::AUDIO, 1); BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count); - for (int32_t i = 0; i < output_channels; ++i) { - buffers->mBuffers[i].mNumberChannels = 1; - buffers->mBuffers[i].mDataByteSize = nframes * sizeof (Sample); - /* setting this to 0 indicates to the AU that it can provide buffers here - * if necessary. if it can process in-place, it will use the buffers provided - * as input by ::render_callback() above. - * - * a non-null values tells the plugin to render into the buffer pointed - * at by the value. - */ - if (inplace) { - buffers->mBuffers[i].mData = 0; - } else { - bool valid = false; - uint32_t idx = out_map.get (DataType::AUDIO, i, &valid); - if (valid) { - buffers->mBuffers[i].mData = bufs.get_audio (idx).data (offset); - } else { - buffers->mBuffers[i].mData = scratch_bufs.get_audio(0).data(offset); - } - } - } - if (_has_midi_input) { - uint32_t nmidi = bufs.count().n_midi(); - for (uint32_t i = 0; i < nmidi; ++i) { - /* one MIDI port/buffer only */ - MidiBuffer& m = bufs.get_midi (i); - for (MidiBuffer::iterator i = m.begin(); i != m.end(); ++i) { - Evoral::MIDIEvent ev (*i); - + Evoral::Event ev (*i); if (ev.is_channel_event()) { const uint8_t* b = ev.buffer(); DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("%1: MIDI event %2\n", name(), ev)); unit->MIDIEvent (b[0], b[1], b[2], ev.time()); } - /* XXX need to handle sysex and other message types */ } } } - /* does this really mean anything ? */ - - ts.mSampleTime = frames_processed; - ts.mFlags = kAudioTimeStampSampleTimeValid; + assert (input_maxbuf < 512); + std::bitset<512> used_outputs; - DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("%1 render flags=%2 time=%3 nframes=%4 buffers=%5\n", - name(), flags, frames_processed, nframes, buffers->mNumberBuffers)); + bool ok = true; + uint32_t busoff = 0; + uint32_t remain = output_channels; + for (uint32_t bus = 0; remain > 0 && bus < configured_output_busses; ++bus) { + uint32_t cnt; + if (variable_outputs || (output_elements == configured_output_busses && configured_output_busses == 1)) { + cnt = output_channels; + } else { + cnt = std::min (remain, bus_outputs[bus]); + } + assert (cnt > 0); + + buffers->mNumberBuffers = cnt; + + for (uint32_t i = 0; i < cnt; ++i) { + buffers->mBuffers[i].mNumberChannels = 1; + buffers->mBuffers[i].mDataByteSize = nframes * sizeof (Sample); + /* setting this to 0 indicates to the AU that it can provide buffers here + * if necessary. if it can process in-place, it will use the buffers provided + * as input by ::render_callback() above. + * + * a non-null values tells the plugin to render into the buffer pointed + * at by the value. + */ + if (inplace) { + buffers->mBuffers[i].mData = 0; + } else { + bool valid = false; + uint32_t idx = out_map.get (DataType::AUDIO, i + busoff, &valid); + if (valid) { + buffers->mBuffers[i].mData = bufs.get_audio (idx).data (offset); + } else { + buffers->mBuffers[i].mData = scratch_bufs.get_audio(0).data(offset); + } + } + } - if ((err = unit->Render (&flags, &ts, 0, nframes, buffers)) == noErr) { + /* does this really mean anything ? */ + ts.mSampleTime = samples_processed; + ts.mFlags = kAudioTimeStampSampleTimeValid; - input_maxbuf = 0; - frames_processed += nframes; + DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("%1 render flags=%2 time=%3 nframes=%4 bus=%5 buffers=%6\n", + name(), flags, samples_processed, nframes, bus, buffers->mNumberBuffers)); - DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("%1 rendered %2 buffers of %3\n", - name(), buffers->mNumberBuffers, output_channels)); + if ((err = unit->Render (&flags, &ts, bus, nframes, buffers)) == noErr) { - int32_t limit = min ((int32_t) buffers->mNumberBuffers, output_channels); - int32_t i; + DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("%1 rendered %2 buffers of %3\n", + name(), buffers->mNumberBuffers, output_channels)); - for (i = 0; i < limit; ++i) { - bool valid = false; - uint32_t idx = out_map.get (DataType::AUDIO, i, &valid); - if (!valid) continue; - Sample* expected_buffer_address = bufs.get_audio (idx).data (offset); - if (expected_buffer_address != buffers->mBuffers[i].mData) { - /* plugin provided its own buffer for output so copy it back to where we want it - */ - memcpy (expected_buffer_address, buffers->mBuffers[i].mData, nframes * sizeof (Sample)); + uint32_t limit = std::min ((uint32_t) buffers->mNumberBuffers, cnt); + for (uint32_t i = 0; i < limit; ++i) { + bool valid = false; + uint32_t idx = out_map.get (DataType::AUDIO, i + busoff, &valid); + if (!valid) continue; + used_outputs.set (i + busoff); + Sample* expected_buffer_address = bufs.get_audio (idx).data (offset); + if (expected_buffer_address != buffers->mBuffers[i].mData) { + /* plugin provided its own buffer for output so copy it back to where we want it */ + memcpy (expected_buffer_address, buffers->mBuffers[i].mData, nframes * sizeof (Sample)); + } } + } else { + DEBUG_TRACE (DEBUG::AudioUnits, string_compose (_("AU: render error for %1, bus %2 status = %3\n"), name(), bus, err)); + error << string_compose (_("AU: render error for %1, bus %2 status = %3"), name(), bus, err) << endmsg; + ok = false; + break; } - /* now silence any buffers that were passed in but the that the plugin - * did not fill/touch/use. - */ + remain -= cnt; + busoff += bus_outputs[bus]; + } - for (;i < output_channels; ++i) { - bool valid = false; - uint32_t idx = out_map.get (DataType::AUDIO, i, &valid); - if (!valid) continue; - memset (bufs.get_audio (idx).data (offset), 0, nframes * sizeof (Sample)); - } + /* now silence any buffers that were passed in but the that the plugin + * did not fill/touch/use. + * + * TODO: optimize, when plugin-insert is processing in-place + * unconnected buffers are (also) cleared there. + */ + for (uint32_t i = 0; i < input_maxbuf; ++i) { + if (used_outputs.test (i)) { continue; } + bool valid = false; + uint32_t idx = out_map.get (DataType::AUDIO, i, &valid); + if (!valid) continue; + memset (bufs.get_audio (idx).data (offset), 0, nframes * sizeof (Sample)); + } + input_maxbuf = 0; + + if (ok) { + samples_processed += nframes; return 0; } - - error << string_compose (_("AU: render error for %1, status = %2"), name(), err) << endmsg; return -1; } @@ -1597,29 +1812,12 @@ AUPlugin::get_beat_and_tempo_callback (Float64* outCurrentBeat, DEBUG_TRACE (DEBUG::AudioUnits, "AU calls ardour beat&tempo callback\n"); - /* more than 1 meter or more than 1 tempo means that a simplistic computation - (and interpretation) of a beat position will be incorrect. So refuse to - offer the value. - */ - - if (tmap.n_tempos() > 1 || tmap.n_meters() > 1) { - return kAudioUnitErr_CannotDoInCurrentContext; - } - - Timecode::BBT_Time bbt; - TempoMetric metric = tmap.metric_at (_session.transport_frame() + input_offset); - tmap.bbt_time (_session.transport_frame() + input_offset, bbt); - if (outCurrentBeat) { - float beat; - beat = metric.meter().divisions_per_bar() * bbt.bars; - beat += bbt.beats; - beat += bbt.ticks / Timecode::BBT_Time::ticks_per_beat; - *outCurrentBeat = beat; + *outCurrentBeat = tmap.quarter_note_at_sample (transport_sample + input_offset); } if (outCurrentTempo) { - *outCurrentTempo = floor (metric.tempo().beats_per_minute()); + *outCurrentTempo = tmap.tempo_at_sample (transport_sample + input_offset).quarter_notes_per_minute(); } return noErr; @@ -1636,27 +1834,18 @@ AUPlugin::get_musical_time_location_callback (UInt32* outDeltaSampleOffsetToNe DEBUG_TRACE (DEBUG::AudioUnits, "AU calls ardour music time location callback\n"); - /* more than 1 meter or more than 1 tempo means that a simplistic computation - (and interpretation) of a beat position will be incorrect. So refuse to - offer the value. - */ - - if (tmap.n_tempos() > 1 || tmap.n_meters() > 1) { - return kAudioUnitErr_CannotDoInCurrentContext; - } - - Timecode::BBT_Time bbt; - TempoMetric metric = tmap.metric_at (_session.transport_frame() + input_offset); - tmap.bbt_time (_session.transport_frame() + input_offset, bbt); + TempoMetric metric = tmap.metric_at (transport_sample + input_offset); + Timecode::BBT_Time bbt = _session.tempo_map().bbt_at_sample (transport_sample + input_offset); if (outDeltaSampleOffsetToNextBeat) { if (bbt.ticks == 0) { /* on the beat */ *outDeltaSampleOffsetToNextBeat = 0; } else { - *outDeltaSampleOffsetToNextBeat = (UInt32) - floor (((Timecode::BBT_Time::ticks_per_beat - bbt.ticks)/Timecode::BBT_Time::ticks_per_beat) * // fraction of a beat to next beat - metric.tempo().frames_per_beat (_session.frame_rate())); // frames per beat + double const next_beat = ceil (tmap.quarter_note_at_sample (transport_sample + input_offset)); + samplepos_t const next_beat_sample = tmap.sample_at_quarter_note (next_beat); + + *outDeltaSampleOffsetToNextBeat = next_beat_sample - (transport_sample + input_offset); } } @@ -1675,8 +1864,10 @@ AUPlugin::get_musical_time_location_callback (UInt32* outDeltaSampleOffsetToNe 3|1|0 -> 1 + (2 * divisions_per_bar) etc. */ + bbt.beats = 1; + bbt.ticks = 0; - *outCurrentMeasureDownBeat = 1 + metric.meter().divisions_per_bar() * (bbt.bars - 1); + *outCurrentMeasureDownBeat = tmap.quarter_note_at_bbt (bbt); } return noErr; @@ -1690,22 +1881,20 @@ AUPlugin::get_transport_state_callback (Boolean* outIsPlaying, Float64* outCycleStartBeat, Float64* outCycleEndBeat) { - bool rolling; - float speed; + const bool rolling = (transport_speed != 0); + const bool last_transport_rolling = (last_transport_speed != 0); DEBUG_TRACE (DEBUG::AudioUnits, "AU calls ardour transport state callback\n"); - rolling = _session.transport_rolling(); - speed = _session.transport_speed (); if (outIsPlaying) { - *outIsPlaying = _session.transport_rolling(); + *outIsPlaying = rolling; } if (outTransportStateChanged) { if (rolling != last_transport_rolling) { *outTransportStateChanged = true; - } else if (speed != last_transport_speed) { + } else if (transport_speed != last_transport_speed) { *outTransportStateChanged = true; } else { *outTransportStateChanged = false; @@ -1716,13 +1905,14 @@ AUPlugin::get_transport_state_callback (Boolean* outIsPlaying, /* this assumes that the AU can only call this host callback from render context, where input_offset is valid. */ - *outCurrentSampleInTimeLine = _session.transport_frame() + input_offset; + *outCurrentSampleInTimeLine = transport_sample + input_offset; } if (outIsCycling) { + // TODO check bounce-processing Location* loc = _session.locations()->auto_loop_location(); - *outIsCycling = (loc && _session.transport_rolling() && _session.get_play_loop()); + *outIsCycling = (loc && rolling && _session.get_play_loop()); if (*outIsCycling) { @@ -1730,45 +1920,20 @@ AUPlugin::get_transport_state_callback (Boolean* outIsPlaying, TempoMap& tmap (_session.tempo_map()); - /* more than 1 meter means that a simplistic computation (and interpretation) of - a beat position will be incorrect. so refuse to offer the value. - */ - - if (tmap.n_meters() > 1) { - return kAudioUnitErr_CannotDoInCurrentContext; - } - Timecode::BBT_Time bbt; if (outCycleStartBeat) { - TempoMetric metric = tmap.metric_at (loc->start() + input_offset); - _session.tempo_map().bbt_time (loc->start(), bbt); - - float beat; - beat = metric.meter().divisions_per_bar() * bbt.bars; - beat += bbt.beats; - beat += bbt.ticks / Timecode::BBT_Time::ticks_per_beat; - - *outCycleStartBeat = beat; + *outCycleStartBeat = tmap.quarter_note_at_sample (loc->start() + input_offset); } if (outCycleEndBeat) { - TempoMetric metric = tmap.metric_at (loc->end() + input_offset); - _session.tempo_map().bbt_time (loc->end(), bbt); - - float beat; - beat = metric.meter().divisions_per_bar() * bbt.bars; - beat += bbt.beats; - beat += bbt.ticks / Timecode::BBT_Time::ticks_per_beat; - - *outCycleEndBeat = beat; + *outCycleEndBeat = tmap.quarter_note_at_sample (loc->end() + input_offset); } } } } - last_transport_rolling = rolling; - last_transport_speed = speed; + last_transport_speed = transport_speed; return noErr; } @@ -1787,6 +1952,68 @@ AUPlugin::automatable() const return automates; } +Plugin::IOPortDescription +AUPlugin::describe_io_port (ARDOUR::DataType dt, bool input, uint32_t id) const +{ + std::stringstream ss; + switch (dt) { + case DataType::AUDIO: + break; + case DataType::MIDI: + ss << _("Midi"); + break; + default: + ss << _("?"); + break; + } + + std::string busname; + + if (dt == DataType::AUDIO) { + if (input) { + uint32_t pid = id; + for (uint32_t bus = 0; bus < input_elements; ++bus) { + if (pid < bus_inputs[bus]) { + id = pid; + ss << _bus_name_in[bus]; + ss << " / Bus " << (1 + bus); + busname = _bus_name_in[bus]; + break; + } + pid -= bus_inputs[bus]; + } + } + else { + uint32_t pid = id; + for (uint32_t bus = 0; bus < output_elements; ++bus) { + if (pid < bus_outputs[bus]) { + id = pid; + ss << _bus_name_out[bus]; + ss << " / Bus " << (1 + bus); + busname = _bus_name_out[bus]; + break; + } + pid -= bus_outputs[bus]; + } + } + } + + if (input) { + ss << " " << _("In") << " "; + } else { + ss << " " << _("Out") << " "; + } + + ss << (id + 1); + + Plugin::IOPortDescription iod (ss.str()); + if (!busname.empty()) { + iod.group_name = busname; + iod.group_channel = id; + } + return iod; +} + string AUPlugin::describe_parameter (Evoral::Parameter param) { @@ -1798,9 +2025,16 @@ AUPlugin::describe_parameter (Evoral::Parameter param) } void -AUPlugin::print_parameter (uint32_t /*param*/, char* /*buf*/, uint32_t /*len*/) const +AUPlugin::print_parameter (uint32_t param, char* buf, uint32_t len) const { // NameValue stuff here + if (buf && len) { + if (param < parameter_count()) { + snprintf (buf, len, "%.3f", get_parameter (param)); + } else { + strcat (buf, "0"); + } + } } bool @@ -1845,7 +2079,7 @@ AUPlugin::parameter_is_output (uint32_t param) const void AUPlugin::add_state (XMLNode* root) const { - LocaleGuard lg (X_("C")); + LocaleGuard lg; CFDataRef xmlData; CFPropertyListRef propertyList; @@ -1884,7 +2118,7 @@ AUPlugin::set_state(const XMLNode& node, int version) { int ret = -1; CFPropertyListRef propertyList; - LocaleGuard lg (X_("C")); + LocaleGuard lg; if (node.name() != state_node_name()) { error << _("Bad node sent to AUPlugin::set_state") << endmsg; @@ -2045,7 +2279,7 @@ AUPlugin::do_save_preset (string preset_name) DEBUG_TRACE (DEBUG::AudioUnits, string_compose("AU Saving Preset to %1\n", user_preset_path)); - return string ("file:///") + user_preset_path; + return user_preset_path; } //----------------------------------------------------------------------------- @@ -2340,8 +2574,10 @@ AUPlugin::find_presets () /* add factory presets */ for (FactoryPresetMap::iterator i = factory_preset_map.begin(); i != factory_preset_map.end(); ++i) { - /* XXX: dubious */ - string const uri = string_compose ("%1", _presets.size ()); + /* XXX: dubious -- deleting & re-adding a preset -> same URI + * good that we don't support deleting AU presets :) + */ + string const uri = PBD::to_string (_presets.size ()); _presets.insert (make_pair (uri, Plugin::PresetRecord (uri, i->first, false))); DEBUG_TRACE (DEBUG::AudioUnits, string_compose("AU Adding Factory Preset: %1 > %2\n", i->first, i->second)); } @@ -2497,6 +2733,8 @@ AUPluginInfo::discover (bool scan_only) if (!Glib::file_test (au_cache_path(), Glib::FILE_TEST_EXISTS)) { ARDOUR::BootMessage (_("Discovering AudioUnit plugins (could take some time ...)")); + // flush RAM cache -- after clear_cache() + cached_info.clear(); } // create crash log file au_start_crashlog (); @@ -2679,27 +2917,27 @@ AUPluginInfo::discover_by_description (PluginInfoList& plugs, CAComponentDescrip continue; case kAudioUnitType_Output: - info->category = _("AudioUnit Outputs"); + info->category = _("Output"); break; case kAudioUnitType_MusicDevice: - info->category = _("AudioUnit Instruments"); + info->category = _("Instrument"); has_midi_in = true; break; case kAudioUnitType_MusicEffect: - info->category = _("AudioUnit MusicEffects"); + info->category = _("Effect"); has_midi_in = true; break; case kAudioUnitType_Effect: - info->category = _("AudioUnit Effects"); + info->category = _("Effect"); break; case kAudioUnitType_Mixer: - info->category = _("AudioUnit Mixers"); + info->category = _("Mixer"); break; case kAudioUnitType_Generator: - info->category = _("AudioUnit Generators"); + info->category = _("Generator"); break; default: - info->category = _("AudioUnit (Unknown)"); + info->category = _("(Unknown)"); break; } @@ -2715,8 +2953,7 @@ AUPluginInfo::discover_by_description (PluginInfoList& plugs, CAComponentDescrip info->type = ARDOUR::AudioUnit; info->unique_id = stringify_descriptor (*info->descriptor); - /* XXX not sure of the best way to handle plugin versioning yet - */ + /* XXX not sure of the best way to handle plugin versioning yet */ CAComponent cacomp (*info->descriptor); @@ -2838,20 +3075,34 @@ AUPluginInfo::cached_io_configuration (const std::string& unique_id, } if (ret > 0) { - - /* no explicit info available, so default to 1in/1out */ - - /* XXX this is wrong. we should be indicating wildcard values */ - + /* AU is expected to deal with same channel valance in and out */ 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)); + /* CAAudioUnit::GetChannelInfo silently merges bus formats + * check if this was the case and if so, add + * bus configs as incremental options. + */ + Boolean* isWritable = 0; + UInt32 dataSize = 0; + OSStatus result = AudioUnitGetPropertyInfo (unit.AU(), + kAudioUnitProperty_SupportedNumChannels, + kAudioUnitScope_Global, 0, + &dataSize, isWritable); + if (result != noErr && (comp.Desc().IsGenerator() || comp.Desc().IsMusicDevice())) { + /* incrementally add busses */ + int in = 0; + int out = 0; + for (uint32_t n = 0; n < cnt; ++n) { + in += channel_info[n].inChannels; + out += channel_info[n].outChannels; + cinfo.io_configs.push_back (pair (in, out)); + } + } 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)); + } } free (channel_info); @@ -2863,6 +3114,17 @@ AUPluginInfo::cached_io_configuration (const std::string& unique_id, return 0; } +void +AUPluginInfo::clear_cache () +{ + const string& fn = au_cache_path(); + if (Glib::file_test (fn, Glib::FILE_TEST_EXISTS)) { + ::g_unlink(fn.c_str()); + } + // keep cached_info in RAM until restart or re-scan + cached_info.clear(); +} + void AUPluginInfo::add_cached_info (const std::string& id, AUPluginCachedInfo& cinfo) { @@ -2877,22 +3139,19 @@ AUPluginInfo::save_cached_info () XMLNode* node; node = new XMLNode (X_("AudioUnitPluginCache")); - node->add_property( "version", AU_CACHE_VERSION ); + node->set_property( "version", AU_CACHE_VERSION ); for (map::iterator i = cached_info.begin(); i != cached_info.end(); ++i) { XMLNode* parent = new XMLNode (X_("plugin")); - parent->add_property ("id", i->first); + parent->set_property ("id", i->first); node->add_child_nocopy (*parent); for (vector >::iterator j = i->second.io_configs.begin(); j != i->second.io_configs.end(); ++j) { XMLNode* child = new XMLNode (X_("io")); - char buf[32]; - snprintf (buf, sizeof (buf), "%d", j->first); - child->add_property (X_("in"), buf); - snprintf (buf, sizeof (buf), "%d", j->second); - child->add_property (X_("out"), buf); + child->set_property (X_("in"), j->first); + child->set_property (X_("out"), j->second); parent->add_child_nocopy (*child); } @@ -2931,7 +3190,7 @@ AUPluginInfo::load_cached_info () } //initial version has incorrectly stored i/o info, and/or garbage chars. - const XMLProperty* version = root->property(X_("version")); + XMLProperty const * version = root->property(X_("version")); if (! ((version != NULL) && (version->value() == X_(AU_CACHE_VERSION)))) { error << "au_cache is not correct version. AU plugins will be re-scanned" << endmsg; return -1; @@ -2949,13 +3208,12 @@ AUPluginInfo::load_cached_info () const XMLNode* gchild; const XMLNodeList gchildren = child->children(); - const XMLProperty* prop = child->property (X_("id")); - if (!prop) { + string id; + if (!child->get_property (X_("id"), id)) { continue; } - string id = prop->value(); string fixed; string version; @@ -2985,16 +3243,10 @@ AUPluginInfo::load_cached_info () if (gchild->name() == X_("io")) { - int in; - int out; - const XMLProperty* iprop; - const XMLProperty* oprop; - - if (((iprop = gchild->property (X_("in"))) != 0) && - ((oprop = gchild->property (X_("out"))) != 0)) { - in = atoi (iprop->value()); - out = atoi (oprop->value()); + int32_t in; + int32_t out; + if (gchild->get_property (X_("in"), in) && gchild->get_property (X_("out"), out)) { cinfo.io_configs.push_back (pair (in, out)); } } @@ -3059,6 +3311,13 @@ AUPluginInfo::is_instrument () const return descriptor->IsMusicDevice(); } +bool +AUPluginInfo::is_utility () const +{ + return (descriptor->IsGenerator() || descriptor->componentType == 'aumi'); + // kAudioUnitType_MidiProcessor ..looks like we aren't even scanning for these yet? +} + void AUPlugin::set_info (PluginInfoPtr info) { @@ -3085,6 +3344,19 @@ AUPlugin::create_parameter_listener (AUEventListenerProc cb, void* arg, float in _parameter_listener_arg = arg; + // listen for latency changes + AudioUnitEvent event; + event.mEventType = kAudioUnitEvent_PropertyChange; + event.mArgument.mProperty.mAudioUnit = unit->AU(); + event.mArgument.mProperty.mPropertyID = kAudioUnitProperty_Latency; + event.mArgument.mProperty.mScope = kAudioUnitScope_Global; + event.mArgument.mProperty.mElement = 0; + + if (AUEventListenerAddEventType (_parameter_listener, _parameter_listener_arg, &event) != noErr) { + PBD::error << "Failed to create latency event listener\n"; + // TODO don't cache _current_latency + } + return 0; } @@ -3181,6 +3453,15 @@ AUPlugin::_parameter_change_listener (void* arg, void* src, const AudioUnitEvent void AUPlugin::parameter_change_listener (void* /*arg*/, void* src, const AudioUnitEvent* event, UInt64 /*host_time*/, Float32 new_value) { + if (event->mEventType == kAudioUnitEvent_PropertyChange) { + if (event->mArgument.mProperty.mPropertyID == kAudioUnitProperty_Latency) { + DEBUG_TRACE (DEBUG::AudioUnits, string_compose("AU Latency Change Event %1 <> %2\n", new_value, unit->Latency())); + guint lat = unit->Latency() * _session.sample_rate(); + g_atomic_int_set (&_current_latency, lat); + } + return; + } + ParameterMap::iterator i; if ((i = parameter_map.find (event->mArgument.mParameter.mParameterID)) == parameter_map.end()) {