X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fplugin_insert.cc;h=351d6dae6a873c81629ef0fe905d669733f2f1aa;hb=aa8128cdf526c8f10b39ad4362101e4760be3319;hp=c82257a4f4ad71292b4a7d99b5497f3224eaa5da;hpb=044cfab946649c8006ed1f9f8e770e942a29b51d;p=ardour.git diff --git a/libs/ardour/plugin_insert.cc b/libs/ardour/plugin_insert.cc index c82257a4f4..351d6dae6a 100644 --- a/libs/ardour/plugin_insert.cc +++ b/libs/ardour/plugin_insert.cc @@ -25,7 +25,7 @@ #include "pbd/failed_constructor.h" #include "pbd/xml++.h" -#include "pbd/convert.h" +#include "pbd/types_convert.h" #include "ardour/audio_buffer.h" #include "ardour/automation_list.h" @@ -83,6 +83,7 @@ PluginInsert::PluginInsert (Session& s, boost::shared_ptr plug) , _maps_from_state (false) , _latency_changed (false) , _bypass_port (UINT32_MAX) + , _stat_reset (0) { /* the first is the master */ @@ -98,6 +99,9 @@ PluginInsert::PluginInsert (Session& s, boost::shared_ptr plug) PluginInsert::~PluginInsert () { + for (CtrlOutMap::const_iterator i = _control_outputs.begin(); i != _control_outputs.end(); ++i) { + boost::dynamic_pointer_cast(i->second)->drop_references (); + } } void @@ -202,10 +206,12 @@ PluginInsert::add_sidechain (uint32_t n_audio, uint32_t n_midi) return false; } std::ostringstream n; - if (n_audio > 0 || n_midi > 0) { - n << "Sidechain " << Session::next_name_id (); - } else { + if (n_audio == 0 && n_midi == 0) { n << "TO BE RESET FROM XML"; + } else if (owner()) { + n << "SC " << owner()->name() << "/" << name() << " " << Session::next_name_id (); + } else { + n << "tobeRenamed"; } SideChain *sc = new SideChain (_session, n.str ()); _sidechain = boost::shared_ptr (sc); @@ -234,21 +240,22 @@ PluginInsert::del_sidechain () } void -PluginInsert::set_sidechain_latency (uint32_t capture, uint32_t playback) +PluginInsert::update_sidechain_name () { - if (_sidechain && - (_sc_playback_latency != playback || _sc_capture_latency != capture)) { - _sc_capture_latency = capture; - _sc_playback_latency = playback; - LatencyRange pl; pl.min = pl.max = playback; - LatencyRange cl; cl.min = cl.max = capture; - DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: capture %2 playback; %3\n", _sidechain->name (), capture, playback)); - PortSet& ps (_sidechain->input ()->ports ()); - for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) { - p->set_private_latency_range (pl, true); - p->set_private_latency_range (cl, false); - } + if (!_sidechain) { + return; + } + + std::ostringstream n; + + n << "SC "; + if (owner()) { + n << owner()->name() << "/"; } + + n << name() << " " << Session::next_name_id (); + + _sidechain->set_name (n.str()); } void @@ -261,7 +268,7 @@ PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, Au = boost::dynamic_pointer_cast(control (which)); if (c && s != Off) { - _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame())); + _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_sample())); } } @@ -392,7 +399,7 @@ PluginInsert::has_no_audio_inputs() const return _plugins[0]->get_info()->n_inputs.n_audio() == 0; } -framecnt_t +samplecnt_t PluginInsert::plugin_latency () const { return _plugins.front()->signal_latency (); } @@ -401,10 +408,7 @@ bool PluginInsert::is_instrument() const { PluginInfoPtr pip = _plugins[0]->get_info(); - if (pip->is_instrument ()) { - return true; - } - return pip->n_inputs.n_midi () != 0 && pip->n_outputs.n_audio () > 0 && pip->n_inputs.n_audio () == 0; + return (pip->is_instrument ()); } bool @@ -451,23 +455,27 @@ PluginInsert::create_automatable_parameters () boost::shared_ptr plugin = _plugins.front(); set a = _plugins.front()->automatable (); + const uint32_t limit_automatables = Config->get_limit_n_automatables (); + for (uint32_t i = 0; i < plugin->parameter_count(); ++i) { - if (!plugin->parameter_is_control (i) || !plugin->parameter_is_input (i)) { + if (!plugin->parameter_is_control (i)) { continue; } - Evoral::Parameter param (PluginAutomation, 0, i); ParameterDescriptor desc; plugin->get_parameter_descriptor(i, desc); + if (!plugin->parameter_is_input (i)) { + _control_outputs[i] = boost::shared_ptr (new ReadOnlyControl (plugin, desc, i)); + continue; + } + Evoral::Parameter param (PluginAutomation, 0, i); + const bool automatable = a.find(param) != a.end(); - if (automatable) { - can_automate (param); - } boost::shared_ptr list(new AutomationList(param, desc)); boost::shared_ptr c (new PluginControl(this, param, desc, list)); - if (!automatable) { + if (!automatable || (limit_automatables > 0 && i > limit_automatables)) { c->set_flags (Controllable::Flag ((int)c->flags() | Controllable::NotAutomatable)); } add_control (c); @@ -484,12 +492,31 @@ PluginInsert::create_automatable_parameters () if (Variant::type_is_numeric(desc.datatype)) { list = boost::shared_ptr(new AutomationList(param, desc)); } - add_control (boost::shared_ptr (new PluginPropertyControl(this, param, desc, list))); + boost::shared_ptr c (new PluginPropertyControl(this, param, desc, list)); + if (!Variant::type_is_numeric(desc.datatype)) { + c->set_flags (Controllable::Flag ((int)c->flags() | Controllable::NotAutomatable)); + } + add_control (c); } } _bypass_port = plugin->designated_bypass_port (); + /* special case VST effSetBypass */ + if (_bypass_port == UINT32_MAX -1) { + // emulate VST Bypass + Evoral::Parameter param (PluginAutomation, 0, _bypass_port); + ParameterDescriptor desc; + desc.label = _("Plugin Enable"); + desc.toggled = true; + desc.normal = 1; + desc.lower = 0; + desc.upper = 1; + boost::shared_ptr list(new AutomationList(param, desc)); + boost::shared_ptr c (new PluginControl(this, param, desc, list)); + add_control (c); + } + if (_bypass_port != UINT32_MAX) { boost::shared_ptr ac = automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port)); if (0 == (ac->flags () & Controllable::NotAutomatable)) { @@ -561,9 +588,57 @@ PluginInsert::set_block_size (pframes_t nframes) return ret; } +void +PluginInsert::automation_run (samplepos_t start, pframes_t nframes) +{ + // XXX does not work when rolling backwards + if (_loop_location && nframes > 0) { + const samplepos_t loop_start = _loop_location->start (); + const samplepos_t loop_end = _loop_location->end (); + const samplecnt_t looplen = loop_end - loop_start; + + samplecnt_t remain = nframes; + samplepos_t start_pos = start; + + while (remain > 0) { + if (start_pos >= loop_end) { + sampleoffset_t start_off = (start_pos - loop_start) % looplen; + start_pos = loop_start + start_off; + } + samplecnt_t move = std::min ((samplecnt_t)nframes, loop_end - start_pos); + + Automatable::automation_run (start_pos, move); + remain -= move; + start_pos += move; + } + return; + } + Automatable::automation_run (start, nframes); +} + +bool +PluginInsert::find_next_event (double now, double end, Evoral::ControlEvent& next_event, bool only_active) const +{ + bool rv = Automatable::find_next_event (now, end, next_event, only_active); + + if (_loop_location && now < end) { + if (rv) { + end = ceil (next_event.when); + } + const samplepos_t loop_end = _loop_location->end (); + assert (now < loop_end); // due to map_loop_range () + if (end > loop_end) { + next_event.when = loop_end; + rv = true; + } + } + return rv; +} + void PluginInsert::activate () { + _timing_stats.reset (); for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) { (*i)->activate (); } @@ -585,6 +660,12 @@ PluginInsert::activate () void PluginInsert::deactivate () { +#ifdef MIXBUS + if (is_nonbypassable ()) { + return; + } +#endif + _timing_stats.reset (); Processor::deactivate (); for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) { @@ -618,7 +699,27 @@ PluginInsert::enable (bool yn) activate (); } boost::shared_ptr ac = automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port)); - ac->set_value (yn ? 1.0 : 0.0, Controllable::NoGroup); + const double val = yn ? 1.0 : 0.0; + ac->set_value (val, Controllable::NoGroup); + +#ifdef ALLOW_VST_BYPASS_TO_FAIL // yet unused, see also vst_plugin.cc + /* special case VST.. bypass may fail */ + if (_bypass_port == UINT32_MAX - 1) { + /* check if bypass worked */ + if (ac->get_value () != val) { + warning << _("PluginInsert: VST Bypass failed, falling back to host bypass.") << endmsg; + // set plugin to enabled (not-byassed) + ac->set_value (1.0, Controllable::NoGroup); + // ..and use host-provided hard-bypass + if (yn) { + activate (); + } else { + deactivate (); + } + return; + } + } +#endif ActiveChanged (); } } @@ -658,6 +759,18 @@ PluginInsert::bypassable_changed () BypassableChanged (); } +bool +PluginInsert::write_immediate_event (size_t size, const uint8_t* buf) +{ + bool rv = true; + for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) { + if (!(*i)->write_immediate_event (size, buf)) { + rv = false; + } + } + return rv; +} + void PluginInsert::preset_load_set_value (uint32_t p, float v) { @@ -676,7 +789,7 @@ PluginInsert::preset_load_set_value (uint32_t p, float v) } void -PluginInsert::inplace_silence_unconnected (BufferSet& bufs, const PinMappings& out_map, framecnt_t nframes, framecnt_t offset) const +PluginInsert::inplace_silence_unconnected (BufferSet& bufs, const PinMappings& out_map, samplecnt_t nframes, samplecnt_t offset) const { // TODO optimize: store "unconnected" in a fixed set. // it only changes on reconfiguration. @@ -709,16 +822,16 @@ PluginInsert::inplace_silence_unconnected (BufferSet& bufs, const PinMappings& o } void -PluginInsert::connect_and_run (BufferSet& bufs, framepos_t start, framepos_t end, double speed, pframes_t nframes, framecnt_t offset, bool with_auto) +PluginInsert::connect_and_run (BufferSet& bufs, samplepos_t start, samplepos_t end, double speed, pframes_t nframes, samplecnt_t offset, bool with_auto) { - // TODO: atomically copy maps & _no_inplace - PinMappings in_map (_in_map); - PinMappings out_map (_out_map); - ChanMapping thru_map (_thru_map); - if (_mapping_changed) { // ToDo use a counters, increment until match. + if (_mapping_changed) { // ToDo use a counter, increment until match _no_inplace = check_inplace (); _mapping_changed = false; } + // TODO: atomically copy maps & _no_inplace + PinMappings in_map (_in_map); // TODO Split case below overrides, use const& in_map + PinMappings const& out_map (_out_map); + ChanMapping const& thru_map (_thru_map); if (_latency_changed) { /* delaylines are configured with the max possible latency (as reported by the plugin) @@ -747,11 +860,11 @@ PluginInsert::connect_and_run (BufferSet& bufs, framepos_t start, framepos_t end continue; } bool valid; - uint32_t first_idx = in_map[0].get (*t, 0, &valid); + uint32_t first_idx = in_map.p(0).get (*t, 0, &valid); assert (valid && first_idx == 0); // check_inplace ensures this /* copy the first stream's buffer contents to the others */ for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) { - uint32_t idx = in_map[0].get (*t, i, &valid); + uint32_t idx = in_map.p(0).get (*t, i, &valid); if (valid) { assert (idx == 0); bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, offset, offset); @@ -769,37 +882,28 @@ PluginInsert::connect_and_run (BufferSet& bufs, framepos_t start, framepos_t end uint32_t n = 0; - for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) { - - boost::shared_ptr c - = boost::dynamic_pointer_cast(li->second); + for (Controls::const_iterator li = controls().begin(); li != controls().end(); ++li, ++n) { - if (c->list() && c->automation_playback()) { + /* boost::dynamic_pointer_cast<> has significant overhead, since we know that + * all controls are AutomationControl and their lists - if any - are AutomationList, + * we can use static_cast<>. This yields a speedup of 2.8/4.6 over to the + * previous code (measuerd with VeeSeeVSTRack 10k parameters, optimized build) */ + AutomationControl& c = static_cast (*(li->second)); + boost::shared_ptr clist (c.list()); + if (clist && (static_cast (*clist)).automation_playback ()) { bool valid; - - const float val = c->list()->rt_safe_eval (start, valid); - + const float val = c.list()->rt_safe_eval (start, valid); if (valid) { - /* This is the ONLY place where we are - * allowed to call - * AutomationControl::set_value_unchecked(). We - * know that the control is in - * automation playback mode, so no - * check on writable() is required - * (which must be done in AutomationControl::set_value() - * - */ - c->set_value_unchecked(val); + c.set_value_unchecked(val); } - } } } - /* Calculate if, and how many frames we need to collect for analysis */ - framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max - + /* Calculate if, and how many samples we need to collect for analysis */ + samplecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max - _signal_analysis_collected_nframes); - if (nframes < collect_signal_nframes) { // we might not get all frames now + if (nframes < collect_signal_nframes) { // we might not get all samples now collect_signal_nframes = nframes; } @@ -807,9 +911,9 @@ PluginInsert::connect_and_run (BufferSet& bufs, framepos_t start, framepos_t end // collect input //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl; //std::cerr << " streams " << internal_input_streams().n_audio() << std::endl; - //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl; + //std::cerr << "filling buffer with " << collect_signal_nframes << " samples at " << _signal_analysis_collected_nframes << std::endl; - _signal_analysis_inputs.set_count(input_streams()); + _signal_analysis_inputs.set_count (ChanCount (DataType::AUDIO, input_streams().n_audio())); for (uint32_t i = 0; i < input_streams().n_audio(); ++i) { _signal_analysis_inputs.get_audio(i).read_from ( @@ -846,7 +950,7 @@ PluginInsert::connect_and_run (BufferSet& bufs, framepos_t start, framepos_t end for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) { for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) { bool valid; - uint32_t out_idx = out_map[pc].get (*t, out, &valid); + uint32_t out_idx = out_map.p(pc).get (*t, out, &valid); if (valid) { used_outputs.set (*t, out_idx, 1); // mark as used } @@ -878,14 +982,14 @@ PluginInsert::connect_and_run (BufferSet& bufs, framepos_t start, framepos_t end for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) { ARDOUR::ChanMapping i_in_map (natural_input_streams()); - ARDOUR::ChanMapping i_out_map (out_map[pc]); + ARDOUR::ChanMapping i_out_map (out_map.p(pc)); ARDOUR::ChanCount mapped; /* map inputs sequentially */ for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) { for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) { bool valid; - uint32_t in_idx = in_map[pc].get (*t, in, &valid); + uint32_t in_idx = in_map.p(pc).get (*t, in, &valid); uint32_t m = mapped.get (*t); if (valid) { inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset); @@ -931,7 +1035,7 @@ PluginInsert::connect_and_run (BufferSet& bufs, framepos_t start, framepos_t end /* in-place processing */ uint32_t pc = 0; for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) { - if ((*i)->connect_and_run(bufs, start, end, speed, in_map[pc], out_map[pc], nframes, offset)) { + if ((*i)->connect_and_run(bufs, start, end, speed, in_map.p(pc), out_map.p(pc), nframes, offset)) { deactivate (); } } @@ -944,7 +1048,7 @@ PluginInsert::connect_and_run (BufferSet& bufs, framepos_t start, framepos_t end //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl; //std::cerr << " streams " << internal_output_streams().n_audio() << std::endl; - _signal_analysis_outputs.set_count(output_streams()); + _signal_analysis_outputs.set_count (ChanCount (DataType::AUDIO, output_streams().n_audio())); for (uint32_t i = 0; i < output_streams().n_audio(); ++i) { _signal_analysis_outputs.get_audio(i).read_from( @@ -977,14 +1081,13 @@ PluginInsert::bypass (BufferSet& bufs, pframes_t nframes) /* bypass the plugin(s) not the whole processor. * -> use mappings just like connect_and_run */ - - // TODO: atomically copy maps & _no_inplace - const ChanMapping in_map (no_sc_input_map ()); - const ChanMapping out_map (output_map ()); if (_mapping_changed) { _no_inplace = check_inplace (); _mapping_changed = false; } + // TODO: atomically copy maps & _no_inplace + ChanMapping const& in_map (no_sc_input_map ()); + ChanMapping const& out_map (output_map ()); bufs.set_count(ChanCount::max(bufs.count(), _configured_internal)); bufs.set_count(ChanCount::max(bufs.count(), _configured_out)); @@ -1083,50 +1186,75 @@ PluginInsert::bypass (BufferSet& bufs, pframes_t nframes) } void -PluginInsert::silence (framecnt_t nframes, framepos_t start_frame) +PluginInsert::silence (samplecnt_t nframes, samplepos_t start_sample) { + automation_run (start_sample, nframes); // evaluate automation only + if (!active ()) { + // XXX delaybuffers need to be offset by nframes return; } _delaybuffers.flush (); - ChanMapping in_map (natural_input_streams ()); - ChanMapping out_map (natural_output_streams ()); + const ChanMapping in_map (natural_input_streams ()); + const ChanMapping out_map (natural_output_streams ()); ChanCount maxbuf = ChanCount::max (natural_input_streams (), natural_output_streams()); #ifdef MIXBUS if (is_channelstrip ()) { if (_configured_in.n_audio() > 0) { - _plugins.front()->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_frame, start_frame + nframes, 1.0, in_map, out_map, nframes, 0); + _plugins.front()->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_sample, start_sample + nframes, 1.0, in_map, out_map, nframes, 0); } } else #endif for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) { - (*i)->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_frame, start_frame + nframes, 1.0, in_map, out_map, nframes, 0); + (*i)->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_sample, start_sample + nframes, 1.0, in_map, out_map, nframes, 0); } } void -PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, double speed, pframes_t nframes, bool) +PluginInsert::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, double speed, pframes_t nframes, bool) { if (_sidechain) { // collect sidechain input for complete cycle (!) // TODO we need delaylines here for latency compensation - _sidechain->run (bufs, start_frame, end_frame, speed, nframes, true); + _sidechain->run (bufs, start_sample, end_sample, speed, nframes, true); + } + + if (g_atomic_int_compare_and_exchange (&_stat_reset, 1, 0)) { + _timing_stats.reset (); } if (_pending_active) { +#if defined MIXBUS && defined NDEBUG + if (!is_channelstrip ()) { + _timing_stats.start (); + } +#else + _timing_stats.start (); +#endif /* run as normal if we are active or moving from inactive to active */ if (_session.transport_rolling() || _session.bounce_processing()) { - automation_run (bufs, start_frame, end_frame, speed, nframes); + automate_and_run (bufs, start_sample, end_sample, speed, nframes); } else { Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK); - connect_and_run (bufs, start_frame, end_frame, speed, nframes, 0, lm.locked()); + connect_and_run (bufs, start_sample, end_sample, speed, nframes, 0, lm.locked()); + } +#if defined MIXBUS && defined NDEBUG + if (!is_channelstrip ()) { + _timing_stats.update (); } +#else + _timing_stats.update (); +#endif } else { + _timing_stats.reset (); + // XXX should call ::silence() to run plugin(s) for consistent load. + // We'll need to change this anyway when bypass can be automated bypass (bufs, nframes); + automation_run (start_sample, nframes); // evaluate automation only _delaybuffers.flush (); } @@ -1138,10 +1266,10 @@ PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame } void -PluginInsert::automation_run (BufferSet& bufs, framepos_t start, framepos_t end, double speed, pframes_t nframes) +PluginInsert::automate_and_run (BufferSet& bufs, samplepos_t start, samplepos_t end, double speed, pframes_t nframes) { Evoral::ControlEvent next_event (0, 0.0f); - framecnt_t offset = 0; + samplecnt_t offset = 0; Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK); @@ -1150,6 +1278,9 @@ PluginInsert::automation_run (BufferSet& bufs, framepos_t start, framepos_t end, return; } + /* map start back into loop-range, adjust end */ + map_loop_range (start, end); + if (!find_next_event (start, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) { /* no events have a time within the relevant range */ @@ -1160,7 +1291,7 @@ PluginInsert::automation_run (BufferSet& bufs, framepos_t start, framepos_t end, while (nframes) { - framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - start), (framecnt_t) nframes); + samplecnt_t cnt = min (((samplecnt_t) ceil (next_event.when) - start), (samplecnt_t) nframes); connect_and_run (bufs, start, start + cnt, speed, cnt, offset, true); // XXX (start + cnt) * speed @@ -1168,6 +1299,8 @@ PluginInsert::automation_run (BufferSet& bufs, framepos_t start, framepos_t end, offset += cnt; start += cnt; + map_loop_range (start, end); + if (!find_next_event (start, end, next_event)) { break; } @@ -1450,6 +1583,10 @@ bool PluginInsert::is_channelstrip () const { return _plugins.front()->is_channelstrip(); } +bool +PluginInsert::is_nonbypassable () const { + return _plugins.front()->is_nonbypassable (); +} #endif bool @@ -1520,7 +1657,7 @@ PluginInsert::check_inplace () * * but allows in-port 1 -> sink-pin 2 || source-pin 2 -> out port 1 */ - ChanMapping in_map (input_map ()); + ChanMapping const& in_map (input_map ()); const ChanMapping::Mappings out_m (output_map ().mappings ()); for (ChanMapping::Mappings::const_iterator t = out_m.begin (); t != out_m.end () && inplace_ok; ++t) { for (ChanMapping::TypeMapping::const_iterator c = (*t).second.begin (); c != (*t).second.end () ; ++c) { @@ -1938,15 +2075,20 @@ PluginInsert::configure_io (ChanCount in, ChanCount out) _delaybuffers.configure (_configured_out, _plugins.front ()->max_latency ()); _latency_changed = true; - // we don't know the analysis window size, so we must work with the - // current buffer size here. each request for data fills in these - // buffers and the analyser makes sure it gets enough data for the - // analysis window - session().ensure_buffer_set (_signal_analysis_inputs, in); - _signal_analysis_inputs.set_count (in); + /* we don't know the analysis window size, so we must work with the + * current buffer size here. each request for data fills in these + * buffers and the analyser makes sure it gets enough data for the + * analysis window. We also only analyze audio, so we can ignore + * MIDI buffers. + */ + ChanCount cc_analysis_in (DataType::AUDIO, in.n_audio()); + ChanCount cc_analysis_out (DataType::AUDIO, out.n_audio()); + + session().ensure_buffer_set (_signal_analysis_inputs, cc_analysis_in); + _signal_analysis_inputs.set_count (cc_analysis_in); - session().ensure_buffer_set (_signal_analysis_outputs, out); - _signal_analysis_outputs.set_count (out); + session().ensure_buffer_set (_signal_analysis_outputs, cc_analysis_out); + _signal_analysis_outputs.set_count (cc_analysis_out); // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl; @@ -2293,19 +2435,13 @@ PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, Cha XMLNode& -PluginInsert::get_state () +PluginInsert::state () { - return state (true); -} + XMLNode& node = Processor::state (); -XMLNode& -PluginInsert::state (bool full) -{ - XMLNode& node = Processor::state (full); - - node.add_property("type", _plugins[0]->state_node_name()); - node.add_property("unique-id", _plugins[0]->unique_id()); - node.add_property("count", string_compose("%1", _plugins.size())); + node.set_property("type", _plugins[0]->state_node_name()); + node.set_property("unique-id", _plugins[0]->unique_id()); + node.set_property("count", (uint32_t)_plugins.size()); /* remember actual i/o configuration (for later placeholder * in case the plugin goes missing) */ @@ -2315,7 +2451,7 @@ PluginInsert::state (bool full) node.add_child_nocopy (* _preset_out.state (X_("PresetOutput"))); /* save custom i/o config */ - node.add_property("custom", _custom_cfg ? "yes" : "no"); + node.set_property("custom", _custom_cfg); for (uint32_t pc = 0; pc < get_count(); ++pc) { char tmp[128]; snprintf (tmp, sizeof(tmp), "InputMap-%d", pc); @@ -2326,7 +2462,7 @@ PluginInsert::state (bool full) node.add_child_nocopy (* _thru_map.state ("ThruMap")); if (_sidechain) { - node.add_child_nocopy (_sidechain->state (full)); + node.add_child_nocopy (_sidechain->get_state ()); } _plugins[0]->set_insert_id(this->id()); @@ -2351,19 +2487,19 @@ PluginInsert::set_control_ids (const XMLNode& node, int version) for (iter = nlist.begin(); iter != nlist.end(); ++iter) { if ((*iter)->name() == Controllable::xml_node_name) { - XMLProperty const * prop; uint32_t p = (uint32_t)-1; #ifdef LV2_SUPPORT - if ((prop = (*iter)->property (X_("symbol"))) != 0) { + std::string str; + if ((*iter)->get_property (X_("symbol"), str)) { boost::shared_ptr lv2plugin = boost::dynamic_pointer_cast (_plugins[0]); if (lv2plugin) { - p = lv2plugin->port_index(prop->value().c_str()); + p = lv2plugin->port_index(str.c_str()); } } #endif - if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) { - p = atoi (prop->value()); + if (p == (uint32_t)-1) { + (*iter)->get_property (X_("parameter"), p); } if (p != (uint32_t)-1) { @@ -2392,36 +2528,34 @@ PluginInsert::set_state(const XMLNode& node, int version) XMLNodeList nlist = node.children(); XMLNodeIterator niter; XMLPropertyList plist; - XMLProperty const * prop; ARDOUR::PluginType type; - if ((prop = node.property ("type")) == 0) { + std::string str; + if (!node.get_property ("type", str)) { error << _("XML node describing plugin is missing the `type' field") << endmsg; return -1; } - if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */ + if (str == X_("ladspa") || str == X_("Ladspa")) { /* handle old school sessions */ type = ARDOUR::LADSPA; - } else if (prop->value() == X_("lv2")) { + } else if (str == X_("lv2")) { type = ARDOUR::LV2; - } else if (prop->value() == X_("windows-vst")) { + } else if (str == X_("windows-vst")) { type = ARDOUR::Windows_VST; - } else if (prop->value() == X_("lxvst")) { + } else if (str == X_("lxvst")) { type = ARDOUR::LXVST; - } else if (prop->value() == X_("mac-vst")) { + } else if (str == X_("mac-vst")) { type = ARDOUR::MacVST; - } else if (prop->value() == X_("audiounit")) { + } else if (str == X_("audiounit")) { type = ARDOUR::AudioUnit; - } else if (prop->value() == X_("luaproc")) { + } else if (str == X_("luaproc")) { type = ARDOUR::Lua; } else { - error << string_compose (_("unknown plugin type %1 in plugin insert state"), - prop->value()) - << endmsg; + error << string_compose (_("unknown plugin type %1 in plugin insert state"), str) << endmsg; return -1; } - prop = node.property ("unique-id"); + XMLProperty const * prop = node.property ("unique-id"); if (prop == 0) { #ifdef WINDOWS_VST_SUPPORT @@ -2447,6 +2581,7 @@ PluginInsert::set_state(const XMLNode& node, int version) } boost::shared_ptr plugin = find_plugin (_session, prop->value(), type); + bool any_vst = false; /* treat VST plugins equivalent if they have the same uniqueID * allow to move sessions windows <> linux */ @@ -2454,6 +2589,7 @@ PluginInsert::set_state(const XMLNode& node, int version) if (plugin == 0 && (type == ARDOUR::Windows_VST || type == ARDOUR::MacVST)) { type = ARDOUR::LXVST; plugin = find_plugin (_session, prop->value(), type); + if (plugin) { any_vst = true; } } #endif @@ -2461,6 +2597,7 @@ PluginInsert::set_state(const XMLNode& node, int version) if (plugin == 0 && (type == ARDOUR::LXVST || type == ARDOUR::MacVST)) { type = ARDOUR::Windows_VST; plugin = find_plugin (_session, prop->value(), type); + if (plugin) { any_vst = true; } } #endif @@ -2468,6 +2605,7 @@ PluginInsert::set_state(const XMLNode& node, int version) if (plugin == 0 && (type == ARDOUR::Windows_VST || type == ARDOUR::LXVST)) { type = ARDOUR::MacVST; plugin = find_plugin (_session, prop->value(), type); + if (plugin) { any_vst = true; } } #endif @@ -2514,9 +2652,7 @@ PluginInsert::set_state(const XMLNode& node, int version) set_control_ids (node, version); } - if ((prop = node.property ("count")) != 0) { - sscanf (prop->value().c_str(), "%u", &count); - } + node.get_property ("count", count); if (_plugins.size() != count) { for (uint32_t n = 1; n < count; ++n) { @@ -2529,9 +2665,7 @@ PluginInsert::set_state(const XMLNode& node, int version) PBD::ID new_id = this->id(); PBD::ID old_id = this->id(); - if ((prop = node.property ("id")) != 0) { - old_id = prop->value (); - } + node.get_property ("id", old_id); for (niter = nlist.begin(); niter != nlist.end(); ++niter) { @@ -2539,7 +2673,9 @@ PluginInsert::set_state(const XMLNode& node, int version) and set all plugins to the same state. */ - if ((*niter)->name() == plugin->state_node_name()) { + if ( ((*niter)->name() == plugin->state_node_name()) + || (any_vst && ((*niter)->name() == "lxvst" || (*niter)->name() == "windows-vst" || (*niter)->name() == "mac-vst")) + ) { for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) { /* Plugin state can include external files which are named after the ID. @@ -2594,9 +2730,7 @@ PluginInsert::set_state(const XMLNode& node, int version) set_parameter_state_2X (node, version); } - if ((prop = node.property (X_("custom"))) != 0) { - _custom_cfg = string_is_affirmative (prop->value()); - } + node.get_property (X_("custom"), _custom_cfg); uint32_t in_maps = 0; uint32_t out_maps = 0; @@ -2636,10 +2770,16 @@ PluginInsert::set_state(const XMLNode& node, int version) // sidechain is a Processor (IO) if ((*i)->name () == Processor::state_node_name) { if (!_sidechain) { - add_sidechain (0); + if (regenerate_xml_or_string_ids ()) { + add_sidechain_from_xml (**i, version); + } else { + add_sidechain (0); + } } if (!regenerate_xml_or_string_ids ()) { _sidechain->set_state (**i, version); + } else { + update_sidechain_name (); } } } @@ -2700,10 +2840,8 @@ PluginInsert::set_parameter_state_2X (const XMLNode& node, int version) } XMLNodeList cnodes; - XMLProperty const * cprop; XMLNodeConstIterator iter; XMLNode *child; - const char *port; uint32_t port_id; cnodes = (*niter)->children ("port"); @@ -2712,15 +2850,11 @@ PluginInsert::set_parameter_state_2X (const XMLNode& node, int version) child = *iter; - if ((cprop = child->property("number")) != 0) { - port = cprop->value().c_str(); - } else { + if (!child->get_property("number", port_id)) { warning << _("PluginInsert: Auto: no ladspa port number") << endmsg; continue; } - sscanf (port, "%" PRIu32, &port_id); - if (port_id >= _plugins[0]->parameter_count()) { warning << _("PluginInsert: Auto: port id out of range") << endmsg; continue; @@ -2732,30 +2866,6 @@ PluginInsert::set_parameter_state_2X (const XMLNode& node, int version) if (c && c->alist()) { if (!child->children().empty()) { c->alist()->set_state (*child->children().front(), version); - - /* In some cases 2.X saves lists with min_yval and max_yval - being FLT_MIN and FLT_MAX respectively. This causes problems - in A3 because these min/max values are used to compute - where GUI control points should be drawn. If we see such - values, `correct' them to the min/max of the appropriate - parameter. - */ - - float min_y = c->alist()->get_min_y (); - float max_y = c->alist()->get_max_y (); - - ParameterDescriptor desc; - _plugins.front()->get_parameter_descriptor (port_id, desc); - - if (min_y == FLT_MIN) { - min_y = desc.lower; - } - - if (max_y == FLT_MAX) { - max_y = desc.upper; - } - - c->alist()->set_yrange (min_y, max_y); } } else { error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg; @@ -2768,6 +2878,16 @@ PluginInsert::set_parameter_state_2X (const XMLNode& node, int version) } } +boost::shared_ptr +PluginInsert::control_output (uint32_t num) const +{ + CtrlOutMap::const_iterator i = _control_outputs.find (num); + if (i == _control_outputs.end ()) { + return boost::shared_ptr (); + } else { + return (*i).second; + } +} string PluginInsert::describe_parameter (Evoral::Parameter param) @@ -2783,7 +2903,7 @@ PluginInsert::describe_parameter (Evoral::Parameter param) return Automatable::describe_parameter(param); } -ARDOUR::framecnt_t +ARDOUR::samplecnt_t PluginInsert::signal_latency() const { if (!_pending_active) { @@ -2810,7 +2930,6 @@ PluginInsert::PluginControl::PluginControl (PluginInsert* p, , _plugin (p) { if (alist()) { - alist()->reset_default (desc.normal); if (desc.toggled) { list->set_interpolation(Evoral::ControlList::Discrete); } @@ -2845,15 +2964,12 @@ PluginInsert::PluginControl::catch_up_with_external_value (double user_val) XMLNode& PluginInsert::PluginControl::get_state () { - stringstream ss; - XMLNode& node (AutomationControl::get_state()); - ss << parameter().id(); - node.add_property (X_("parameter"), ss.str()); + node.set_property (X_("parameter"), parameter().id()); #ifdef LV2_SUPPORT boost::shared_ptr lv2plugin = boost::dynamic_pointer_cast (_plugin->_plugins[0]); if (lv2plugin) { - node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id())); + node.set_property (X_("symbol"), lv2plugin->port_symbol (parameter().id())); } #endif @@ -2880,10 +2996,6 @@ PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* : AutomationControl (p->session(), param, desc, list) , _plugin (p) { - if (alist()) { - alist()->set_yrange (desc.lower, desc.upper); - alist()->reset_default (desc.normal); - } } void @@ -2910,11 +3022,8 @@ PluginInsert::PluginPropertyControl::actually_set_value (double user_val, Contro XMLNode& PluginInsert::PluginPropertyControl::get_state () { - stringstream ss; - XMLNode& node (AutomationControl::get_state()); - ss << parameter().id(); - node.add_property (X_("property"), ss.str()); + node.set_property (X_("property"), parameter().id()); node.remove_property (X_("value")); return node; @@ -2943,6 +3052,7 @@ PluginInsert::get_impulse_analysis_plugin() assert (out == internal_output_streams ()); } ret->configure_io (internal_input_streams (), out); + ret->set_owner (_owner); _impulseAnalysisPlugin = ret; } else { ret = _impulseAnalysisPlugin.lock(); @@ -2952,7 +3062,7 @@ PluginInsert::get_impulse_analysis_plugin() } void -PluginInsert::collect_signal_for_analysis (framecnt_t nframes) +PluginInsert::collect_signal_for_analysis (samplecnt_t nframes) { // called from outside the audio thread, so this should be safe // only do audio as analysis is (currently) only for audio plugins @@ -2999,6 +3109,42 @@ PluginInsert::add_plugin (boost::shared_ptr plugin) _plugins.push_back (plugin); } +void +PluginInsert::add_sidechain_from_xml (const XMLNode& node, int version) +{ + if (version < 3000) { + return; + } + + XMLNodeList nlist = node.children(); + + if (nlist.size() == 0) { + return; + } + + uint32_t audio = 0; + uint32_t midi = 0; + + XMLNodeConstIterator it = nlist.front()->children().begin(); + for ( ; it != nlist.front()->children().end(); ++ it) { + if ((*it)->name() == "Port") { + DataType type(DataType::NIL); + (*it)->get_property ("type", type); + if (type == DataType::AUDIO) { + ++audio; + } else if (type == DataType::MIDI) { + ++midi; + } + } + } + + ChanCount in_cc = ChanCount(); + in_cc.set (DataType::AUDIO, audio); + in_cc.set (DataType::MIDI, midi); + + add_sidechain (audio, midi); +} + bool PluginInsert::load_preset (ARDOUR::Plugin::PresetRecord pr) { @@ -3050,8 +3196,8 @@ PluginInsert::start_touch (uint32_t param_id) { boost::shared_ptr ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id)); if (ac) { - // ToDo subtract _plugin_signal_latency from audible_frame() when rolling, assert > 0 - ac->start_touch (session().audible_frame()); + // ToDo subtract _plugin_signal_latency from audible_sample() when rolling, assert > 0 + ac->start_touch (session().audible_sample()); } } @@ -3060,9 +3206,35 @@ PluginInsert::end_touch (uint32_t param_id) { boost::shared_ptr ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id)); if (ac) { - // ToDo subtract _plugin_signal_latency from audible_frame() when rolling, assert > 0 - ac->stop_touch (true, session().audible_frame()); + // ToDo subtract _plugin_signal_latency from audible_sample() when rolling, assert > 0 + ac->stop_touch (session().audible_sample()); + } +} + +bool +PluginInsert::provides_stats () const +{ +#if defined MIXBUS && defined NDEBUG + if (is_channelstrip () || !display_to_user ()) { + return false; } +#endif + return true; +} + +bool +PluginInsert::get_stats (uint64_t& min, uint64_t& max, double& avg, double& dev) const +{ + /* TODO: consider taking a try/lock: Don't run concurrently with + * TimingStats::update, TimingStats::reset. + */ + return _timing_stats.get_stats (min, max, avg, dev); +} + +void +PluginInsert::clear_stats () +{ + g_atomic_int_set (&_stat_reset, 1); } std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)