merge 3.0-panexp (pan experiments) branch, revisions 8534-8585 into 3.0, thus ending 3.0-panexp. THIS COMMIT WILL BREAK ALL EXISTING 3.0 SESSIONS IN SOME WAY (possibly not fatally).

git-svn-id: svn://localhost/ardour2/branches/3.0@8586 d708f5d6-7413-0410-9779-e7cbd77b26cf

1 files changed, 60 insertions, 1453 deletions

diff --git a/libs/ardour/panner.cc b/libs/ardour/panner.cc
index e4dc417c83..bfee68a342 100644
--- a/libs/ardour/panner.cc
+++ b/libs/ardour/panner.cc
@@ -1,6 +1,5 @@
-
 /*
-    Copyright (C) 2004 Paul Davis
+    Copyright (C) 2004-2011 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
@@ -18,1539 +17,147 @@
 
 */
 
-#include <inttypes.h>
-
-#include <cmath>
-#include <cerrno>
-#include <fstream>
-#include <cstdlib>
-#include <string>
-#include <cstdio>
-#include <locale.h>
-#include <unistd.h>
-#include <float.h>
-#include <iomanip>
-
-#include <glibmm.h>
-
-#include "pbd/cartesian.h"
-#include "pbd/convert.h"
-#include "pbd/error.h"
-#include "pbd/failed_constructor.h"
-#include "pbd/xml++.h"
-#include "pbd/enumwriter.h"
-
-#include "evoral/Curve.hpp"
-
-#include "ardour/session.h"
-#include "ardour/panner.h"
-#include "ardour/utils.h"
 #include "ardour/audio_buffer.h"
-
-#include "ardour/runtime_functions.h"
 #include "ardour/buffer_set.h"
-#include "ardour/audio_buffer.h"
-#include "ardour/vbap.h"
-
-#include "i18n.h"
-
-#include "pbd/mathfix.h"
+#include "ardour/panner.h"
+#include "ardour/pannable.h"
+#include "ardour/session.h"
+#include "ardour/utils.h"
 
 using namespace std;
 using namespace ARDOUR;
-using namespace PBD;
-
-float Panner::current_automation_version_number = 1.0;
-
-string EqualPowerStereoPanner::name = "Equal Power Stereo";
 
-/* this is a default mapper of control values to a pan position
-   others can be imagined.
-*/
-
-static double direct_control_to_stereo_pan (double fract)
+Panner::Panner (boost::shared_ptr<Pannable> p)
+	: _pannable (p)
+        , _mono (0)
 {
-	return BaseStereoPanner::lr_fract_to_azimuth (fract);
 }
 
-StreamPanner::StreamPanner (Panner& p, Evoral::Parameter param)
-	: parent (p)
-        , _control (new PanControllable (parent.session(), _("direction"), this, param))
-{
-	assert (param.type() != NullAutomation);
-
-	_muted = false;
-	_mono = false;
-
-        p.add_control (_control);
-}
-
-StreamPanner::~StreamPanner ()
+Panner::~Panner ()
 {
 }
 
 void
-StreamPanner::set_mono (bool yn)
+Panner::set_bypassed (bool yn)
 {
-	if (yn != _mono) {
-		_mono = yn;
+	if (yn != _bypassed) {
+		_bypassed = yn;
 		StateChanged ();
 	}
 }
 
-double
-StreamPanner::PanControllable::lower () const
-{
-        switch (parameter().id()) {
-        case 200: /* width */
-                return -1.0;
-        default:
-                return 0.0;
-        }
-}
-
 void
-StreamPanner::PanControllable::set_value (double val)
-{
-        Panner& p (streampanner->get_parent());
-        switch (parameter().id()) {
-        case 100:
-                /* position */
-                val = max (min (val, 1.0), 0.0);
-                if (p.set_stereo_pan (val, p.width_control()->get_value())) {
-                        AutomationControl::set_value(val);
-                        p.session().set_dirty ();
-                }
-                break;
-
-        case 200:
-                /* width */
-                val = max (min (val, 1.0), -1.0);
-                if (p.set_stereo_pan (p.direction_control()->get_value(), val)) {
-                        AutomationControl::set_value(val);
-                        p.session().set_dirty ();
-                }
-                break;
-
-        default: /* positional */
-                val = max (min (val, 1.0), 0.0);
-                streampanner->set_position (AngularVector (direct_control_to_stereo_pan (val), 0.0));
-                AutomationControl::set_value(val);
-                p.session().set_dirty ();
-                break;
-        }
-
-}
-
-double
-StreamPanner::PanControllable::get_value (void) const
-{
-	return AutomationControl::get_value();
-}
-
-void
-StreamPanner::set_muted (bool yn)
+Panner::set_mono (bool yn)
 {
-	if (yn != _muted) {
-		_muted = yn;
+	if (yn != _mono) {
+		_mono = yn;
 		StateChanged ();
 	}
 }
 
-void
-StreamPanner::set_position (const AngularVector& av, bool link_call)
-{
-	if (!link_call && parent.linked()) {
-		parent.set_position (av, *this);
-	}
-
-	if (_angles != av) {
-		_angles = av;
-		update ();
-		Changed ();
-		_control->Changed ();
-	}
-}
-
 int
-StreamPanner::set_state (const XMLNode& node, int version)
+Panner::set_state (const XMLNode& node, int version)
 {
 	const XMLProperty* prop;
 	XMLNodeConstIterator iter;
 
-	if ((prop = node.property (X_("muted")))) {
-		set_muted (string_is_affirmative (prop->value()));
-	}
-
 	if ((prop = node.property (X_("mono")))) {
 		set_mono (string_is_affirmative (prop->value()));
 	}
 
-	for (XMLNodeConstIterator iter = node.children().begin(); iter != node.children().end(); ++iter) {		
-                if ((*iter)->name() == Controllable::xml_node_name) {
-			if ((prop = (*iter)->property ("name")) != 0 && prop->value() == "direction") {
-				_control->set_state (**iter, version);
-			} 
-                }
-        }
-
-	return 0;
-}
-
-XMLNode&
-StreamPanner::get_state ()
-{
-        XMLNode* node = new XMLNode (X_("StreamPanner"));
-	node->add_property (X_("muted"), (muted() ? "yes" : "no"));
-	node->add_property (X_("mono"), (_mono ? "yes" : "no"));
-	node->add_child_nocopy (_control->get_state ());
-        return *node;
-}
-
-void
-StreamPanner::distribute (AudioBuffer& src, BufferSet& obufs, gain_t gain_coeff, pframes_t nframes)
-{
-	if (_mono) {
-		/* we're in mono mode, so just pan the input to all outputs equally */
-		int const N = parent.nouts ();
-		for (int i = 0; i < N; ++i) {
-			mix_buffers_with_gain (obufs.get_audio(i).data(), src.data(), nframes, gain_coeff);
-		}
-	} else {
-		/* normal mode, call the `real' distribute method */
-		do_distribute (src, obufs, gain_coeff, nframes);
-	}
-}
-
-void
-StreamPanner::distribute_automated (AudioBuffer& src, BufferSet& obufs,
-				    framepos_t start, framepos_t end, pframes_t nframes, pan_t** buffers)
-{
-	if (_mono) {
-		/* we're in mono mode, so just pan the input to all outputs equally */
-		int const N = parent.nouts ();
-		for (int i = 0; i < N; ++i) {
-			mix_buffers_with_gain (obufs.get_audio(i).data(), src.data(), nframes, 1.0);
-		}
-	} else {
-		/* normal mode, call the `real' distribute method */
-		do_distribute_automated (src, obufs, start, end, nframes, buffers);
-	}
-	
-}
-
-
-/*---------------------------------------------------------------------- */
-
-BaseStereoPanner::BaseStereoPanner (Panner& p, Evoral::Parameter param)
-	: StreamPanner (p, param)
-	, left (0.5)
-	, right (0.5)
-	, left_interp (left)
-	, right_interp (right)
-{
-}
-
-BaseStereoPanner::~BaseStereoPanner ()
-{
-}
-
-int
-BaseStereoPanner::load (istream& in, string path, uint32_t& linecnt)
-{
-	char line[128];
-	LocaleGuard lg (X_("POSIX"));
-
-	_control->list()->clear ();
-
-	while (in.getline (line, sizeof (line), '\n')) {
-		framepos_t when;
-		double value;
-
-		++linecnt;
-
-		if (strcmp (line, "end") == 0) {
-			break;
-		}
-
-		if (sscanf (line, "%" PRIu64 " %lf", &when, &value) != 2) {
-			warning << string_compose(_("badly formatted pan automation event record at line %1 of %2 (ignored) [%3]"), linecnt, path, line) << endmsg;
-			continue;
-		}
-
-		_control->list()->fast_simple_add (when, value);
+	if ((prop = node.property (X_("bypassed"))) != 0) {
+		set_bypassed (string_is_affirmative (prop->value()));
 	}
 
-	/* now that we are done loading */
-
-	((AutomationList*)_control->list().get())->StateChanged ();
-
 	return 0;
 }
 
-void
-BaseStereoPanner::do_distribute (AudioBuffer& srcbuf, BufferSet& obufs, gain_t gain_coeff, pframes_t nframes)
-{
-	assert(obufs.count().n_audio() == 2);
-
-	pan_t delta;
-	Sample* dst;
-	pan_t pan;
-
-	if (_muted) {
-		return;
-	}
-
-	Sample* const src = srcbuf.data();
-
-	/* LEFT */
-
-	dst = obufs.get_audio(0).data();
-
-	if (fabsf ((delta = (left - desired_left))) > 0.002) { // about 1 degree of arc
-
-		/* we've moving the pan by an appreciable amount, so we must
-		   interpolate over 64 frames or nframes, whichever is smaller */
-
-		pframes_t const limit = min ((pframes_t) 64, nframes);
-		pframes_t n;
-
-		delta = -(delta / (float) (limit));
-
-		for (n = 0; n < limit; n++) {
-			left_interp = left_interp + delta;
-			left = left_interp + 0.9 * (left - left_interp);
-			dst[n] += src[n] * left * gain_coeff;
-		}
-
-		/* then pan the rest of the buffer; no need for interpolation for this bit */
-
-		pan = left * gain_coeff;
-
-		mix_buffers_with_gain (dst+n,src+n,nframes-n,pan);
-
-	} else {
-
-		left = desired_left;
-		left_interp = left;
-
-		if ((pan = (left * gain_coeff)) != 1.0f) {
-
-			if (pan != 0.0f) {
-
-				/* pan is 1 but also not 0, so we must do it "properly" */
-
-				mix_buffers_with_gain(dst,src,nframes,pan);
-
-				/* mark that we wrote into the buffer */
-
-				// obufs[0] = 0;
-
-			}
-
-		} else {
-
-			/* pan is 1 so we can just copy the input samples straight in */
-
-			mix_buffers_no_gain(dst,src,nframes);
-
-			/* mark that we wrote into the buffer */
-
-			// obufs[0] = 0;
-		}
-	}
-
-	/* RIGHT */
-
-	dst = obufs.get_audio(1).data();
-
-	if (fabsf ((delta = (right - desired_right))) > 0.002) { // about 1 degree of arc
-
-		/* we're moving the pan by an appreciable amount, so we must
-		   interpolate over 64 frames or nframes, whichever is smaller */
-
-		pframes_t const limit = min ((pframes_t) 64, nframes);
-		pframes_t n;
-
-		delta = -(delta / (float) (limit));
-
-		for (n = 0; n < limit; n++) {
-			right_interp = right_interp + delta;
-			right = right_interp + 0.9 * (right - right_interp);
-			dst[n] += src[n] * right * gain_coeff;
-		}
-
-		/* then pan the rest of the buffer, no need for interpolation for this bit */
-
-		pan = right * gain_coeff;
-
-		mix_buffers_with_gain(dst+n,src+n,nframes-n,pan);
-
-		/* XXX it would be nice to mark the buffer as written to */
-
-	} else {
-
-		right = desired_right;
-		right_interp = right;
-
-		if ((pan = (right * gain_coeff)) != 1.0f) {
-
-			if (pan != 0.0f) {
-
-				/* pan is not 1 but also not 0, so we must do it "properly" */
-				
-				mix_buffers_with_gain(dst,src,nframes,pan);
-
-				/* XXX it would be nice to mark the buffer as written to */
-			}
-
-		} else {
-
-			/* pan is 1 so we can just copy the input samples straight in */
-			
-			mix_buffers_no_gain(dst,src,nframes);
-
-			/* XXX it would be nice to mark the buffer as written to */
-		}
-	}
-}
-
-/*---------------------------------------------------------------------- */
-
-EqualPowerStereoPanner::EqualPowerStereoPanner (Panner& p, Evoral::Parameter param)
-	: BaseStereoPanner (p, param)
-{
-	update ();
-
-	left = desired_left;
-	right = desired_right;
-	left_interp = left;
-	right_interp = right;
-}
-
-EqualPowerStereoPanner::~EqualPowerStereoPanner ()
-{
-}
-
-void
-EqualPowerStereoPanner::update ()
-{
-	/* it would be very nice to split this out into a virtual function
-	   that can be accessed from BaseStereoPanner and used in do_distribute_automated().
-
-	   but the place where its used in do_distribute_automated() is a tight inner loop,
-	   and making "nframes" virtual function calls to compute values is an absurd
-	   overhead.
-	*/
-
-	/* x == 0 => hard left = 180.0 degrees
-	   x == 1 => hard right = 0.0 degrees
-	*/
-
-	double _x = BaseStereoPanner::azimuth_to_lr_fract (_angles.azi);
-
-	float const panR = _x;
-	float const panL = 1 - panR;
-
-	float const pan_law_attenuation = -3.0f;
-	float const scale = 2.0f - 4.0f * powf (10.0f,pan_law_attenuation/20.0f);
-
-	desired_left = panL * (scale * panL + 1.0f - scale);
-	desired_right = panR * (scale * panR + 1.0f - scale);
-
-	_effective_angles = _angles;
-	//_control->set_value(x);
-}
-
-void
-EqualPowerStereoPanner::do_distribute_automated (AudioBuffer& srcbuf, BufferSet& obufs,
-						 framepos_t start, framepos_t end, pframes_t nframes,
-						 pan_t** buffers)
-{
-	assert (obufs.count().n_audio() == 2);
-
-	Sample* dst;
-	pan_t* pbuf;
-	Sample* const src = srcbuf.data();
-
-	/* fetch positional data */
-
-	if (!_control->list()->curve().rt_safe_get_vector (start, end, buffers[0], nframes)) {
-		/* fallback */
-		if (!_muted) {
-			do_distribute (srcbuf, obufs, 1.0, nframes);
-		}
-		return;
-	}
-
-	/* store effective pan position. do this even if we are muted */
-
-	if (nframes > 0) {
-		_effective_angles.azi = BaseStereoPanner::lr_fract_to_azimuth (buffers[0][nframes-1]);
-	}
-
-	if (_muted) {
-		return;
-	}
-
-	/* apply pan law to convert positional data into pan coefficients for
-	   each buffer (output)
-	*/
-
-	const float pan_law_attenuation = -3.0f;
-	const float scale = 2.0f - 4.0f * powf (10.0f,pan_law_attenuation/20.0f);
-
-	for (pframes_t n = 0; n < nframes; ++n) {
-
-		float const panR = buffers[0][n];
-		float const panL = 1 - panR;
-
-		buffers[0][n] = panL * (scale * panL + 1.0f - scale);
-		buffers[1][n] = panR * (scale * panR + 1.0f - scale);
-	}
-
-	/* LEFT */
-
-	dst = obufs.get_audio(0).data();
-	pbuf = buffers[0];
-
-	for (pframes_t n = 0; n < nframes; ++n) {
-		dst[n] += src[n] * pbuf[n];
-	}
-
-	/* XXX it would be nice to mark the buffer as written to */
-
-	/* RIGHT */
-
-	dst = obufs.get_audio(1).data();
-	pbuf = buffers[1];
-
-	for (pframes_t n = 0; n < nframes; ++n) {
-		dst[n] += src[n] * pbuf[n];
-	}
-
-	/* XXX it would be nice to mark the buffer as written to */
-}
-
-StreamPanner*
-EqualPowerStereoPanner::factory (Panner& parent, Evoral::Parameter param, Speakers& /* ignored */)
-{
-	return new EqualPowerStereoPanner (parent, param);
-}
-
 XMLNode&
-EqualPowerStereoPanner::get_state (void)
+Panner::get_state ()
 {
-	return state (true);
-}
-
-XMLNode&
-EqualPowerStereoPanner::state (bool /*full_state*/)
-{
-	XMLNode& root (StreamPanner::get_state ());
-	root.add_property (X_("type"), EqualPowerStereoPanner::name);
-	return root;
-}
-
-int
-EqualPowerStereoPanner::set_state (const XMLNode& node, int version)
-{
-	LocaleGuard lg (X_("POSIX"));
-
-	StreamPanner::set_state (node, version);
-
-	for (XMLNodeConstIterator iter = node.children().begin(); iter != node.children().end(); ++iter) {
-
-                if ((*iter)->name() == X_("Automation")) {
-                        
-			_control->alist()->set_state (*((*iter)->children().front()), version);
-                        
-			if (_control->alist()->automation_state() != Off) {
-				double degrees = BaseStereoPanner::lr_fract_to_azimuth (_control->list()->eval (parent.session().transport_frame()));
-				set_position (AngularVector (degrees, 0.0));
-			}
-		}
-	}
-
-	return 0;
-}
-
-Panner::Panner (string name, Session& s)
-	: SessionObject (s, name)
-        , Automatable (s)
-{
-	//set_name_old_auto (name);
-	set_name (name);
-
-	_linked = false;
-	_link_direction = SameDirection;
-	_bypassed = false;
-	_mono = false;
-}
-
-Panner::~Panner ()
-{
-}
-
-void
-Panner::set_linked (bool yn)
-{
-	if (yn != _linked) {
-		_linked = yn;
-		_session.set_dirty ();
-		LinkStateChanged (); /* EMIT SIGNAL */
-	}
-}
-
-void
-Panner::set_link_direction (LinkDirection ld)
-{
-	if (ld != _link_direction) {
-		_link_direction = ld;
-		_session.set_dirty ();
-		LinkStateChanged (); /* EMIT SIGNAL */
-	}
-}
-
-
-void
-Panner::set_bypassed (bool yn)
-{
-	if (yn != _bypassed) {
-		_bypassed = yn;
-		StateChanged ();
-	}
-}
-
-
-void
-Panner::reset_to_default ()
-{
-	vector<float> positions;
-
-	switch (outputs.size()) {
-	case 0:
-	case 1:
-		return;
-	}
-
-	if (outputs.size() == 2) {
-		AngularVector a;
-		switch (_streampanners.size()) {
-		case 1:
-			a.azi = 90.0; /* "front" or "top", in degrees */
-			_streampanners.front()->set_position (a);
-			_streampanners.front()->pan_control()->list()->reset_default (0.5);
-			return;
-			break;
-		case 2:
-			a.azi = 180.0; /* "left", in degrees */
-			_streampanners.front()->set_position (a);
-			_streampanners.front()->pan_control()->list()->reset_default (0.0);
-			a.azi = 0.0; /* "right", in degrees */
-			_streampanners.back()->set_position (a);
-			_streampanners.back()->pan_control()->list()->reset_default (1.0);
-			return;
-		default:
-			break;
-		}
-	}
-
-	vector<Output>::iterator o;
-	vector<StreamPanner*>::iterator p;
-
-	for (o = outputs.begin(), p = _streampanners.begin(); o != outputs.end() && p != _streampanners.end(); ++o, ++p) {
-		(*p)->set_position ((*o).position);
-	}
-}
-
-void
-Panner::reset_streampanner (uint32_t which)
-{
-	AngularVector a;
-
-	if (which >= _streampanners.size() || which >= outputs.size()) {
-		return;
-	}
-
-	switch (outputs.size()) {
-	case 0:
-	case 1:
-		return;
-
-	case 2:
-		switch (_streampanners.size()) {
-		case 1:
-			/* stereo out, 1 stream, default = middle */
-			a.azi = 90.0; /* "front" or "top", in degrees */
-			_streampanners.front()->set_position (a);
-			_streampanners.front()->pan_control()->list()->reset_default (0.5);
-			break;
-		case 2:
-			/* stereo out, 2 streams, default = hard left/right */
-			if (which == 0) {
-				a.azi = 180.0; /* "left", in degrees */
-				_streampanners.front()->set_position (a);
-				_streampanners.front()->pan_control()->list()->reset_default (0.0);
-			} else {
-				a.azi = 0.0; /* "right", in degrees */
-				_streampanners.back()->set_position (a);
-				_streampanners.back()->pan_control()->list()->reset_default (1.0);
-			}
-			break;
-		}
-		return;
-
-	default:
-		_streampanners[which]->set_position (outputs[which].position);
-	}
-}
-
-/**
- *    Reset the panner with a given number of outs and panners (and hence inputs)
- *
- *    \param nouts Number of outputs.
- *    \param npans Number of panners.
- */
-void
-Panner::reset (uint32_t nouts, uint32_t npans)
-{
-	uint32_t n;
-	bool changed = false;
-	bool do_not_and_did_not_need_panning = ((nouts < 2) && (outputs.size() < 2));
-
-	/* if new and old config don't need panning, or if
-	   the config hasn't changed, we're done.
-	*/
+        XMLNode* node = new XMLNode (X_("Panner"));
 
-	if (do_not_and_did_not_need_panning ||
-	    ((nouts == outputs.size()) && (npans == _streampanners.size()))) {
-		return;
-	}
-
-	n = _streampanners.size();
-	clear_panners ();
-
-	if (n != npans) {
-		changed = true;
-	}
-
-	n = outputs.size();
-	outputs.clear ();
-
-	if (n != nouts) {
-		changed = true;
-	}
-
-	if (nouts < 2) {
-		/* no need for panning with less than 2 outputs */
-		if (changed) {
-			Changed (); /* EMIT SIGNAL */
-		}
-		return;
-	}
-
-	switch (nouts) {
-	case 0:
-		/* XXX: this can never happen */
-		break;
-
-	case 1:
-		/* XXX: this can never happen */
-		fatal << _("programming error:")
-		      << X_("Panner::reset() called with a single output")
-		      << endmsg;
-		/*NOTREACHED*/
-		break;
-
-	case 2: // line
-		outputs.push_back (Output (AngularVector (180.0, 0.0)));
-		outputs.push_back (Output (AngularVector (0.0, 0,0)));
-		for (n = 0; n < npans; ++n) {
-			_streampanners.push_back (new EqualPowerStereoPanner (*this, Evoral::Parameter(PanAutomation, 0, n)));
-		}
-		break;
-
-	default:
-		setup_speakers (nouts);
-		for (n = 0; n < npans; ++n) {
-			_streampanners.push_back (new VBAPanner (*this, Evoral::Parameter(PanAutomation, 0, n), _session.get_speakers()));
-		}
-		break;
-	}
-
-	for (std::vector<StreamPanner*>::iterator x = _streampanners.begin(); x != _streampanners.end(); ++x) {
-		(*x)->update ();
-	}
-
-        setup_meta_controls ();
-
-	/* must emit Changed here, otherwise the changes to the pan_control below raise further
-	   signals which the GUI is not prepared for until it has seen the Changed here.
-	*/
-	
-	if (changed) {
-		Changed (); /* EMIT SIGNAL */
-	}
-
-	/* force hard left/right panning in a common case: 2in/2out
-	*/
-
-	if (npans == 2 && outputs.size() == 2) {
-
-		/* Do this only if we changed configuration, or our configuration
-		   appears to be the default set up (zero degrees)
-		*/
-
-		AngularVector left;
-		AngularVector right;
-
-		left = _streampanners.front()->get_position ();
-		right = _streampanners.back()->get_position ();
-
-		if (changed || ((left.azi == 0.0) && (right.azi == 0.0))) {
-
-			_streampanners.front()->set_position (AngularVector (180.0, 0.0));
-			_streampanners.front()->pan_control()->list()->reset_default (0.0);
-
-			_streampanners.back()->set_position (AngularVector (0.0, 0.0));
-			_streampanners.back()->pan_control()->list()->reset_default (1.0);
-		}
-
-	} else if (npans > 1 && outputs.size() > 2) {
-
-		/* 2d panning: spread signals equally around a circle */
-
-		double degree_step = 360.0 / nouts;
-		double deg;
-
-		/* even number of signals? make sure the top two are either side of "top".
-		   otherwise, just start at the "top" (90.0 degrees) and rotate around
-		*/
-
-		if (npans % 2) {
-			deg = 90.0 - degree_step;
-		} else {
-			deg = 90.0;
-		}
+	node->add_property (X_("mono"), (_mono ? "yes" : "no"));
+	node->add_property (X_("bypassed"), (bypassed() ? "yes" : "no"));
 
-		for (std::vector<StreamPanner*>::iterator x = _streampanners.begin(); x != _streampanners.end(); ++x) {
-			(*x)->set_position (AngularVector (deg, 0.0));
-			deg += degree_step;
-		}
-	}
+        return *node;
 }
 
 void
-Panner::remove (uint32_t which)
+Panner::distribute (BufferSet& ibufs, BufferSet& obufs, gain_t gain_coeff, pframes_t nframes)
 {
-	vector<StreamPanner*>::iterator i;
-	for (i = _streampanners.begin(); i != _streampanners.end() && which; ++i, --which) {}
+        uint32_t which = 0;
 
-	if (i != _streampanners.end()) {
-		delete *i;
-		_streampanners.erase (i);
-	}
+	for (BufferSet::audio_iterator src = ibufs.audio_begin(); src != ibufs.audio_end(); ++src, ++which) {
+                if (_mono) {
+                        /* we're in mono mode, so just pan the input to all outputs equally (XXX should we scale?) */
+                        for (BufferSet::audio_iterator o = obufs.audio_begin(); o != obufs.audio_end(); ++o) {
+                                mix_buffers_with_gain ((*o).data(), (*src).data(), nframes, gain_coeff);
+                        }
+                } else {
+                        /* normal mode, call the `real' distribute method */
+                        distribute_one (*src, obufs, gain_coeff, nframes, which);
+                }
+        }
 }
 
-
-/** Remove all our StreamPanners */
 void
-Panner::clear_panners ()
+Panner::distribute_automated (BufferSet& ibufs, BufferSet& obufs,
+                              framepos_t start, framepos_t end, pframes_t nframes, pan_t** buffers)
 {
-	for (vector<StreamPanner*>::iterator i = _streampanners.begin(); i != _streampanners.end(); ++i) {
-		delete *i;
-	}
+        uint32_t which = 0;
 
-	_streampanners.clear ();
+	for (BufferSet::audio_iterator src = ibufs.audio_begin(); src != ibufs.audio_end(); ++src, ++which) {
+                if (_mono) {
+                        /* we're in mono mode, so just pan the input to all outputs equally (XXX should we scale?) */
+                        for (BufferSet::audio_iterator o = obufs.audio_begin(); o != obufs.audio_end(); ++o) {
+                                mix_buffers_with_gain ((*o).data(), (*src).data(), nframes, 1.0);
+                        }
+                } else {
+                        /* normal mode, call the `real' distribute method */
+                        distribute_one_automated (*src, obufs, start, end, nframes, buffers, which);
+                }
+        }
 }
 
 void
 Panner::set_automation_style (AutoStyle style)
 {
-	for (vector<StreamPanner*>::iterator i = _streampanners.begin(); i != _streampanners.end(); ++i) {
-		((AutomationList*)(*i)->pan_control()->list().get())->set_automation_style (style);
-	}
-	_session.set_dirty ();
+        _pannable->set_automation_style (style);
 }
 
 void
 Panner::set_automation_state (AutoState state)
 {
-	for (vector<StreamPanner*>::iterator i = _streampanners.begin(); i != _streampanners.end(); ++i) {
-		((AutomationList*)(*i)->pan_control()->list().get())->set_automation_state (state);
-	}
-	_session.set_dirty ();
+        _pannable->set_automation_state (state);
 }
 
 AutoState
 Panner::automation_state () const
 {
-	boost::shared_ptr<AutomationList> l;
-	if (!empty()) {
-		boost::shared_ptr<AutomationControl> control = _streampanners.front()->pan_control();
-		if (control) {
-			l = boost::dynamic_pointer_cast<AutomationList>(control->list());
-		}
-	}
-
-	return l ? l->automation_state() : Off;
+        return _pannable->automation_state();
 }
 
 AutoStyle
 Panner::automation_style () const
 {
-	boost::shared_ptr<AutomationList> l;
-	if (!empty()) {
-		boost::shared_ptr<AutomationControl> control = _streampanners.front()->pan_control();
-		if (control) {
-			l = boost::dynamic_pointer_cast<AutomationList>(control->list());
-		}
-	}
-
-	return l ? l->automation_style() : Absolute;
-}
-
-struct PanPlugins {
-    string name;
-    uint32_t nouts;
-    StreamPanner* (*factory)(Panner&, Evoral::Parameter, Speakers&);
-};
-
-PanPlugins pan_plugins[] = {
-	{ EqualPowerStereoPanner::name, 2, EqualPowerStereoPanner::factory },
-	{ VBAPanner::name, 3, VBAPanner::factory },
-	{ string (""), 0, 0 }
-};
-
-XMLNode&
-Panner::get_state (void)
-{
-	return state (true);
-}
-
-XMLNode&
-Panner::state (bool full)
-{
-	XMLNode* node = new XMLNode ("Panner");
-
-	char buf[32];
-
-	node->add_property (X_("linked"), (_linked ? "yes" : "no"));
-	node->add_property (X_("link_direction"), enum_2_string (_link_direction));
-	node->add_property (X_("bypassed"), (bypassed() ? "yes" : "no"));
-        snprintf (buf, sizeof (buf), "%zd", outputs.size());
-        node->add_property (X_("outputs"), buf);
-
-	for (vector<StreamPanner*>::const_iterator i = _streampanners.begin(); i != _streampanners.end(); ++i) {
-		node->add_child_nocopy ((*i)->state (full));
-	}
-
-        node->add_child_nocopy (get_automation_xml_state ());
-
-	return *node;
-}
-
-int
-Panner::set_state (const XMLNode& node, int version)
-{
-	XMLNodeList nlist = node.children ();
-	XMLNodeConstIterator niter;
-	const XMLProperty *prop;
-	uint32_t i;
-	uint32_t num_panners = 0;
-	StreamPanner* sp;
-	LocaleGuard lg (X_("POSIX"));
-
-	clear_panners ();
-
-	ChanCount ins = ChanCount::ZERO;
-	ChanCount outs = ChanCount::ZERO;
-
-	// XXX: this might not be necessary anymore
-	outputs.clear ();
-
-	if ((prop = node.property (X_("linked"))) != 0) {
-		set_linked (string_is_affirmative (prop->value()));
-	}
-
-	if ((prop = node.property (X_("bypassed"))) != 0) {
-		set_bypassed (string_is_affirmative (prop->value()));
-	}
-
-	if ((prop = node.property (X_("link_direction"))) != 0) {
-		LinkDirection ld; /* here to provide type information */
-		set_link_direction (LinkDirection (string_2_enum (prop->value(), ld)));
-	}
-
-        if ((prop = node.property (X_("outputs"))) != 0) {
-                uint32_t n = atoi (prop->value());
-
-                while (n--) {
-                        AngularVector a; // value is irrelevant
-                        outputs.push_back (Output (a));
-                }
-
-        } else {
-                
-                /* old school */
-
-                for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-                        if ((*niter)->name() == X_("Output")) {
-                                
-                                AngularVector a;
-                                
-                                if ((prop = (*niter)->property (X_("azimuth")))) {
-                                        sscanf (prop->value().c_str(), "%lg", &a.azi);
-                                } else if ((prop = (*niter)->property (X_("x")))) {
-                                        /* old school cartesian */
-                                        a.azi = BaseStereoPanner::lr_fract_to_azimuth (atof (prop->value().c_str()));
-                                }
-                                
-                                if ((prop = (*niter)->property (X_("elevation")))) {
-                                        sscanf (prop->value().c_str(), "%lg", &a.ele);
-                                }
-                                
-                                outputs.push_back (Output (a));
-                        }
-                }
-        }
-
-	for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-
-		if ((*niter)->name() == X_("StreamPanner")) {
-
-			if ((prop = (*niter)->property (X_("type")))) {
-
-				for (i = 0; pan_plugins[i].factory; ++i) {
-					if (prop->value() == pan_plugins[i].name) {
-
-
-						/* note that we assume that all the stream panners
-						   are of the same type. pretty good
-						   assumption, but it's still an assumption.
-						*/
-
-						sp = pan_plugins[i].factory (*this, Evoral::Parameter(PanAutomation, 0, num_panners), _session.get_speakers ());
-						num_panners++;
-
-						if (sp->set_state (**niter, version) == 0) {
-							_streampanners.push_back (sp);
-                                                }
-
-						break;
-					}
-				}
-
-				if (!pan_plugins[i].factory) {
-					error << string_compose (_("Unknown panner plugin \"%1\" found in pan state - ignored"),
-							  prop->value())
-					      << endmsg;
-				}
-
-			} else {
-				error << _("panner plugin node has no type information!")
-				      << endmsg;
-				return -1;
-			}
-
-		}
-	}
-
-        setup_meta_controls ();
-
-	reset (outputs.size (), num_panners);
-
-	/* don't try to do old-school automation loading if it wasn't marked as existing */
-
-	if ((prop = node.property (X_("automation")))) {
-
-		/* automation path is relative */
-
-		automation_path = Glib::build_filename(_session.automation_dir(), prop->value ());
-	}
-
-	for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-		if ((*niter)->name() == X_("Automation")) {
-			set_automation_xml_state (**niter, Evoral::Parameter (PanAutomation));
-		}
-	}
-
-	return 0;
+        return _pannable->automation_style ();
 }
 
 bool
 Panner::touching () const
 {
-	for (vector<StreamPanner*>::const_iterator i = _streampanners.begin(); i != _streampanners.end(); ++i) {
-		if (((AutomationList*)(*i)->pan_control()->list().get())->touching ()) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-void
-Panner::set_position (const AngularVector& a, StreamPanner& orig)
-{
-	AngularVector delta;
-	AngularVector new_position;
-
-	delta = orig.get_position() - a;
-
-	if (_link_direction == SameDirection) {
-
-		for (vector<StreamPanner*>::iterator i = _streampanners.begin(); i != _streampanners.end(); ++i) {
-			if (*i == &orig) {
-				(*i)->set_position (a, true);
-			} else {
-				new_position = (*i)->get_position() + delta;
-				(*i)->set_position (new_position, true);
-			}
-		}
-
-	} else {
-
-		for (vector<StreamPanner*>::iterator i = _streampanners.begin(); i != _streampanners.end(); ++i) {
-			if (*i == &orig) {
-				(*i)->set_position (a, true);
-			} else {
-				new_position = (*i)->get_position() - delta;
-				(*i)->set_position (new_position, true);
-			}
-		}
-	}
-}
-
-void
-Panner::distribute_no_automation (BufferSet& inbufs, BufferSet& outbufs, pframes_t nframes, gain_t gain_coeff)
-{
-	if (outbufs.count().n_audio() == 0) {
-		// Don't want to lose audio...
-		assert(inbufs.count().n_audio() == 0);
-		return;
-	}
-
-	// We shouldn't be called in the first place...
-	assert(!bypassed());
-	assert(!empty());
-
-
-	if (outbufs.count().n_audio() == 1) {
-
-		AudioBuffer& dst = outbufs.get_audio(0);
-
-		if (gain_coeff == 0.0f) {
-
-			/* only one output, and gain was zero, so make it silent */
-
-			dst.silence (nframes);
-
-		} else if (gain_coeff == 1.0f){
-
-			/* mix all buffers into the output */
-
-			// copy the first
-			dst.read_from(inbufs.get_audio(0), nframes);
-
-			// accumulate starting with the second
-			if (inbufs.count().n_audio() > 0) {
-				BufferSet::audio_iterator i = inbufs.audio_begin();
-				for (++i; i != inbufs.audio_end(); ++i) {
-					dst.merge_from(*i, nframes);
-				}
-			}
-
-		} else {
-
-			/* mix all buffers into the output, scaling them all by the gain */
-
-			// copy the first
-			dst.read_from(inbufs.get_audio(0), nframes);
-
-			// accumulate (with gain) starting with the second
-			if (inbufs.count().n_audio() > 0) {
-				BufferSet::audio_iterator i = inbufs.audio_begin();
-				for (++i; i != inbufs.audio_end(); ++i) {
-					dst.accumulate_with_gain_from(*i, nframes, gain_coeff);
-				}
-			}
-
-		}
-
-		return;
-	}
-
-	/* the terrible silence ... */
-	for (BufferSet::audio_iterator i = outbufs.audio_begin(); i != outbufs.audio_end(); ++i) {
-		i->silence(nframes);
-	}
-
-	BufferSet::audio_iterator i = inbufs.audio_begin();
-
-	for (vector<StreamPanner*>::iterator pan = _streampanners.begin(); pan != _streampanners.end() && i != inbufs.audio_end(); ++pan, ++i) {
-		(*pan)->distribute (*i, outbufs, gain_coeff, nframes);
-	}
-}
-
-void
-Panner::run (BufferSet& inbufs, BufferSet& outbufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes)
-{
-	if (outbufs.count().n_audio() == 0) {
-		// Failing to deliver audio we were asked to deliver is a bug
-		assert(inbufs.count().n_audio() == 0);
-		return;
-	}
-
-	// We shouldn't be called in the first place...
-	assert(!bypassed());
-	assert(!empty());
-
-	// If we shouldn't play automation defer to distribute_no_automation
-	if (!(automation_state() & Play || ((automation_state() & Touch) && !touching()))) {
-
-		// Speed quietning
-		gain_t gain_coeff = 1.0;
-
-		if (fabsf(_session.transport_speed()) > 1.5f && Config->get_quieten_at_speed ()) {
-			gain_coeff = speed_quietning;
-		}
-
-		distribute_no_automation (inbufs, outbufs, nframes, gain_coeff);
-		return;
-	}
-
-	// Otherwise.. let the automation flow, baby
-
-	if (outbufs.count().n_audio() == 1) {
-
-		AudioBuffer& dst = outbufs.get_audio(0);
-
-		// FIXME: apply gain automation?
-
-		// copy the first
-		dst.read_from(inbufs.get_audio(0), nframes);
-
-		// accumulate starting with the second
-		BufferSet::audio_iterator i = inbufs.audio_begin();
-		for (++i; i != inbufs.audio_end(); ++i) {
-			dst.merge_from(*i, nframes);
-		}
-
-		return;
-	}
-
-	// More than 1 output, we should have 1 panner for each input
-	//assert(_streampanners.size() == inbufs.count().n_audio());
-
-	/* the terrible silence ... */
-	for (BufferSet::audio_iterator i = outbufs.audio_begin(); i != outbufs.audio_end(); ++i) {
-		i->silence(nframes);
-	}
-
-	BufferSet::audio_iterator i = inbufs.audio_begin();
-	for (vector<StreamPanner*>::iterator pan = _streampanners.begin(); pan != _streampanners.end(); ++pan, ++i) {
-		(*pan)->distribute_automated (*i, outbufs, start_frame, end_frame, nframes, _session.pan_automation_buffer());
-	}
-}
-
-/* old school automation handling */
-
-/*
-void
-Panner::set_name (string str)
-{
-	automation_path = Glib::build_filename(_session.automation_dir(),
-		_session.snap_name() + "-pan-" + legalize_for_path (str) + ".automation");
-}
-*/
-
-int
-Panner::load ()
-{
-	char line[128];
-	uint32_t linecnt = 0;
-	float version;
-	vector<StreamPanner*>::iterator sp;
-	LocaleGuard lg (X_("POSIX"));
-
-	if (automation_path.length() == 0) {
-		return 0;
-	}
-
-	if (access (automation_path.c_str(), F_OK)) {
-		return 0;
-	}
-
-	ifstream in (automation_path.c_str());
-
-	if (!in) {
-		error << string_compose (_("cannot open pan automation file %1 (%2)"),
-				  automation_path, strerror (errno))
-		      << endmsg;
-		return -1;
-	}
-
-	sp = _streampanners.begin();
-
-	while (in.getline (line, sizeof(line), '\n')) {
-
-		if (++linecnt == 1) {
-			if (memcmp (line, X_("version"), 7) == 0) {
-				if (sscanf (line, "version %f", &version) != 1) {
-					error << string_compose(_("badly formed version number in pan automation event file \"%1\""), automation_path) << endmsg;
-					return -1;
-				}
-			} else {
-				error << string_compose(_("no version information in pan automation event file \"%1\" (first line = %2)"),
-						 automation_path, line) << endmsg;
-				return -1;
-			}
-
-			continue;
-		}
-
-		if (strlen (line) == 0 || line[0] == '#') {
-			continue;
-		}
-
-		if (strcmp (line, "begin") == 0) {
-
-			if (sp == _streampanners.end()) {
-				error << string_compose (_("too many panner states found in pan automation file %1"),
-						  automation_path)
-				      << endmsg;
-				return -1;
-			}
-
-			if ((*sp)->load (in, automation_path, linecnt)) {
-				return -1;
-			}
-
-			++sp;
-		}
-	}
-
-	return 0;
-}
-
-void
-Panner::set_mono (bool yn)
-{
-	if (yn != _mono) {
-		_mono = yn;
-		StateChanged ();
-	}
-
-	for (vector<StreamPanner*>::iterator i = _streampanners.begin(); i != _streampanners.end(); ++i) {
-		(*i)->set_mono (yn);
-	}
+        return _pannable->touching ();
 }
 
-string
-Panner::value_as_string (double v)
+set<Evoral::Parameter> 
+Panner::what_can_be_automated() const
 {
-	if (Panner::equivalent (v, 0.5)) {
-		return _("C");
-	} else if (equivalent (v, 0)) {
-		return _("L");
-	} else if (equivalent (v, 1)) {
-		return _("R");
-	} else if (v < 0.5) {
-		stringstream s;
-		s << fixed << setprecision (0) << _("L") << ((0.5 - v) * 200) << "%";
-		return s.str();
-	} else {
-		stringstream s;
-		s << fixed << setprecision (0) << _("R") << ((v -0.5) * 200) << "%";
-		return s.str ();
-	}
-
-	return "";
-}
-
-void
-Panner::setup_speakers (uint32_t nouts)
-{
-	switch (nouts) {
-	case 3:
-		/* top, bottom kind-of-left & bottom kind-of-right */
-		outputs.push_back (AngularVector (90.0, 0.0));
-		outputs.push_back (AngularVector (215.0, 0,0));
-		outputs.push_back (AngularVector (335.0, 0,0));
-		break;
-	case 4:
-		/* clockwise from top left */
-		outputs.push_back (AngularVector (135.0, 0.0));
-		outputs.push_back (AngularVector (45.0, 0.0));
-		outputs.push_back (AngularVector (335.0, 0.0));
-		outputs.push_back (AngularVector (215.0, 0.0));
-		break;
-
-	default: 
-	{
-		double degree_step = 360.0 / nouts;
-		double deg;
-		uint32_t n;
-
-		/* even number of speakers? make sure the top two are either side of "top".
-		   otherwise, just start at the "top" (90.0 degrees) and rotate around
-		*/
-
-		if (nouts % 2) {
-			deg = 90.0 - degree_step;
-		} else {
-			deg = 90.0;
-		}
-		for (n = 0; n < nouts; ++n, deg += degree_step) {
-			outputs.push_back (Output (AngularVector (deg, 0.0)));
-		}
-	}
-	}
-
-	Speakers& speakers (_session.get_speakers());
-                        
-	speakers.clear_speakers ();
-
-	for (vector<Output>::iterator o = outputs.begin(); o != outputs.end(); ++o) {
-		speakers.add_speaker ((*o).position);
-	}
-}
-
-void
-Panner::set_stereo_width (double val)
-{
-        boost::shared_ptr<AutomationControl> dc = direction_control();
-        if (dc) {
-                dc->set_value (val);
-        }
-}
-
-void
-Panner::set_stereo_position (double val)
-{
-        boost::shared_ptr<AutomationControl> wc = width_control();
-        if (wc) {
-                wc->set_value (val);
-        }
-}
-
-bool
-Panner::set_stereo_pan (double direction_as_lr_fract, double width)
-{
-        AngularVector p (BaseStereoPanner::lr_fract_to_azimuth (direction_as_lr_fract), 0.0);
-        /* width parameter ranges from -1..+1 with 0.0 at center. we want 0..+1 plus knowing
-           whether its "reversed" (i.e. left signal pans right and right signal pans left).
-           full width = 180 degrees
-        */
-        double spread = 2.0 * fabs(width/2.0) * 180.0; 
-        double l_pos = p.azi + (spread/2.0);  /* more left is "increasing degrees" */
-        double r_pos = p.azi - (spread/2.0);  /* more right is "decreasing degrees" */
-        bool move_left = true;
-        bool move_right = true;
-        int l_index = 0;
-        int r_index = 1;
-
-        assert (_streampanners.size() > 1);
-
-        if (width < 0.0) {
-                swap (l_index, r_index);
-        }
-
-        l_pos = max (min (l_pos, 180.0), 0.0);
-        r_pos = max (min (r_pos, 180.0), 0.0);
-
-        /* if the new left position is less than or equal to 180 (hard left) and the left panner
-           is already there, we're not moving the left signal. 
-        */
-
-        if (l_pos >= 180.0 &&_streampanners[l_index]->get_position().azi == 180.0) {
-                move_left = false;
-        }
-
-        /* if the new right position is less than or equal to zero (hard right) and the right panner
-           is already there, we're not moving the right signal. 
-        */
-        
-        if (r_pos <= 0.0 && _streampanners[r_index]->get_position().azi == 0.0) {
-                move_right = false;
-        }
-
-        if (move_left && move_right) {
-                _streampanners[l_index]->set_position (AngularVector (l_pos, 0.0));
-                _streampanners[r_index]->set_position (AngularVector (r_pos, 0.0));
-        }
-
-        return move_left && move_right;
-}
-
-void
-Panner::setup_meta_controls ()
-{
-        if (_streampanners.size() != 2 || outputs.size() != 2) {
-                return;
-        }
-
-        /* 2 signals to 2 outputs: provide "classic" controls for easier manipulation.
-           
-           The ID numbers used here don't really matter that much, because Parameters are scoped by owner,
-           but they keep us out of the ordinary range of pan-related parameters.
-        */
-        
-        Evoral::Parameter lr_param (PanAutomation, 0, 100);
-        Evoral::Parameter width_param (PanAutomation, 0, 200);
-        boost::shared_ptr<AutomationControl> dc = automation_control (lr_param);
-        boost::shared_ptr<AutomationControl> wc = automation_control (width_param);
-
-        if (dc) {
-		/* reset parent StreamPanner as the current one may have been deleted */
-		boost::shared_ptr<StreamPanner::PanControllable> p = boost::dynamic_pointer_cast<StreamPanner::PanControllable> (dc);
-		assert (p);
-		p->streampanner = _streampanners.front ();
-	} else {
-                dc.reset (new StreamPanner::PanControllable (_session, _("lr"), _streampanners.front(), lr_param));
-                add_control (dc);
-        }
-        
-        if (wc) {
-		/* reset parent as above */
-		boost::shared_ptr<StreamPanner::PanControllable> p = boost::dynamic_pointer_cast<StreamPanner::PanControllable> (wc);
-		assert (p);
-		p->streampanner = _streampanners.front ();
-	} else {
-                wc.reset (new StreamPanner::PanControllable (_session, _("width"), _streampanners.front(), width_param));
-                add_control (wc);
-        }
-
-        dc->set_value (0.5);
-        wc->set_value (1.0); // full width
+        return _pannable->what_can_be_automated ();
 }
 
 string
-Panner::describe_parameter (Evoral::Parameter param)
+Panner::describe_parameter (Evoral::Parameter p)
 {
-        if (param.type() == PanAutomation) {
-                switch (param.id()) {
-                case 100:
-                        return "Pan:position";
-                case 200:
-                        return "Pan:width";
-                default:
-                        if (_streampanners.size() == 2) {
-                                switch (param.id()) {
-                                case 0:
-                                        return "Pan L";
-                                default:
-                                        return "Pan R";
-                                }
-                        } else {
-                                stringstream ss;
-                                ss << "Pan " << param.id() + 1;
-                                return ss.str ();
-                        }
-                }
-        }
-
-        return Automatable::describe_parameter (param);
+        return _pannable->describe_parameter (p);
 }