X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fplugin_insert.cc;h=6fbb5cb67908de7f318ecc46d087b034bdff5bab;hb=6142c814bf991b829ccb8818050d0cac8ffb9d9e;hp=b3517531aa0a2ede287da6540e90bce32599571e;hpb=b880a381523b2cfdb7ebd17c27fff1adf90fa028;p=ardour.git

diff --git a/libs/ardour/plugin_insert.cc b/libs/ardour/plugin_insert.cc
index b3517531aa..6fbb5cb679 100644
--- a/libs/ardour/plugin_insert.cc
+++ b/libs/ardour/plugin_insert.cc
@@ -346,13 +346,15 @@ PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t of
 		/* XXX: audio only */
 		uint32_t first_idx = in_map.get (DataType::AUDIO, 0, &valid);
 		if (valid) {
-			Sample const * mono = bufs.get_audio (first_idx).data (offset);
 			for (uint32_t i = in_streams.n_audio(); i < natural_input_streams().n_audio(); ++i) {
-				memcpy (bufs.get_audio (in_map.get (DataType::AUDIO, i, &valid)).data (offset), mono, sizeof (Sample) * nframes);
+				bufs.get_audio(in_map.get (DataType::AUDIO, i, &valid)).read_from(bufs.get_audio(first_idx), nframes, offset, offset);
 			}
 		}
 	}
 
+	bufs.set_count(ChanCount::max(bufs.count(), in_streams));
+	bufs.set_count(ChanCount::max(bufs.count(), out_streams));
+
 	/* Note that we've already required that plugins
 	   be able to handle in-place processing.
 	*/
@@ -465,38 +467,31 @@ PluginInsert::run (BufferSet& bufs, framepos_t /*start_frame*/, framepos_t /*end
 		}
 
 	} else {
-		if (has_no_audio_inputs()) {
+		uint32_t in = input_streams ().n_audio ();
+		uint32_t out = output_streams().n_audio ();
+
+		if (has_no_audio_inputs() || in == 0) {
 
 			/* silence all (audio) outputs. Should really declick
 			 * at the transitions of "active"
 			 */
 
-			uint32_t out = output_streams().n_audio ();
-
 			for (uint32_t n = 0; n < out; ++n) {
 				bufs.get_audio (n).silence (nframes);
 			}
 
-			bufs.count().set_audio (out);
-
-		} else {
-
-			/* does this need to be done with MIDI? it appears not */
-
-			uint32_t in = input_streams ().n_audio ();
-			uint32_t out = output_streams().n_audio ();
+		} else if (out > in) {
 
-			if (out > in) {
+			/* not active, but something has make up for any channel count increase */
 
-				/* not active, but something has make up for any channel count increase */
-				
-				for (uint32_t n = out - in; n < out; ++n) {
-					memcpy (bufs.get_audio (n).data(), bufs.get_audio(in - 1).data(), sizeof (Sample) * nframes);
-				}
+			// TODO: option round-robin (n % in) or silence additional buffers ??
+			// for now , simply replicate last buffer
+			for (uint32_t n = in; n < out; ++n) {
+				bufs.get_audio(n).read_from(bufs.get_audio(in - 1), nframes);
 			}
-
-			bufs.count().set_audio (out);
 		}
+
+		bufs.count().set_audio (out);
 	}
 
 	_active = _pending_active;
@@ -650,6 +645,8 @@ bool
 PluginInsert::configure_io (ChanCount in, ChanCount out)
 {
 	Match old_match = _match;
+	ChanCount old_in = input_streams ();
+	ChanCount old_out = output_streams ();
 
 	/* set the matching method and number of plugins that we will use to meet this configuration */
 	_match = private_can_support_io_configuration (in, out);
@@ -657,9 +654,12 @@ PluginInsert::configure_io (ChanCount in, ChanCount out)
 		return false;
 	}
 
-	/* a signal needs emitting if we start or stop splitting */
-	if (old_match.method != _match.method && (old_match.method == Split || _match.method == Split)) {
-		SplittingChanged (); /* EMIT SIGNAL */
+	if (  (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
+			|| old_in != in
+			|| old_out != out
+			)
+	{
+		PluginIoReConfigure (); /* EMIT SIGNAL */
 	}
 
 	/* configure plugins */
@@ -714,6 +714,10 @@ PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
 PluginInsert::Match
 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out)
 {
+	if (_plugins.empty()) {
+		return Match();
+	}
+
 	PluginInfoPtr info = _plugins.front()->get_info();
 	ChanCount in; in += inx;
 	midi_bypass.reset();
@@ -972,6 +976,22 @@ PluginInsert::set_state(const XMLNode& node, int version)
 
 	boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
 
+	/* treat linux and windows VST plugins equivalent if they have the same uniqueID
+	 * allow to move sessions windows <> linux */
+#ifdef LXVST_SUPPORT
+	if (plugin == 0 && type == ARDOUR::Windows_VST) {
+		type = ARDOUR::LXVST;
+		plugin = find_plugin (_session, prop->value(), type);
+	}
+#endif
+
+#ifdef WINDOWS_VST_SUPPORT
+	if (plugin == 0 && type == ARDOUR::LXVST) {
+		type = ARDOUR::Windows_VST;
+		plugin = find_plugin (_session, prop->value(), type);
+	}
+#endif
+
 	if (plugin == 0) {
 		error << string_compose(
 			_("Found a reference to a plugin (\"%1\") that is unknown.\n"
@@ -1207,10 +1227,23 @@ double
 PluginInsert::PluginControl::internal_to_interface (double val) const
 {
 	if (_logarithmic) {
+		/* some plugins have a log-scale range "0.."
+		 * ideally we'd map the range down to infinity somehow :)
+		 *
+		 * one solution could be to use
+		 *   val = exp(lower + log(range) * value);
+		 *   (log(val) - lower) / range)
+		 * This approach would require access to the actual range (ie
+		 * Plugin::ParameterDescriptor) and also require handling
+		 * of unbound ranges..
+		 *
+		 * currently an arbitrarly low number is assumed to represnt
+		 * log(0) as hot-fix solution.
+		 */
 		if (val > 0) {
 			val = log (val);
 		} else {
-			val = 0;
+			val = -8; // ~ -70dB = 20 * log10(exp(-8))
 		}
 	}
 
@@ -1221,7 +1254,12 @@ double
 PluginInsert::PluginControl::interface_to_internal (double val) const
 {
 	if (_logarithmic) {
-		val = exp (val);
+		if (val <= -8) {
+			/* see note in PluginInsert::PluginControl::internal_to_interface() */
+			val= 0;
+		} else {
+			val = exp (val);
+		}
 	}
 
 	return val;