#include <glibmm.h>
#include "pbd/cartesian.h"
+#include "pbd/convert.h"
#include "pbd/error.h"
#include "pbd/failed_constructor.h"
#include "pbd/xml++.h"
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;
- /* get our AutomationControl from our parent Panner, creating it if required */
- _control = boost::dynamic_pointer_cast<AutomationControl> (parent.control (param, true));
+ p.add_control (_control);
}
StreamPanner::~StreamPanner ()
}
}
+double
+StreamPanner::PanControllable::lower () const
+{
+ switch (parameter().id()) {
+ case 200: /* width */
+ return -1.0;
+ default:
+ return 0.0;
+ }
+}
+
void
-Panner::PanControllable::set_value (double val)
+StreamPanner::PanControllable::set_value (double val)
{
- panner.streampanner (parameter().id()).set_position (AngularVector (direct_control_to_stereo_pan (val), 0.0));
- AutomationControl::set_value(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);
+ }
+ 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);
+ }
+ break;
+
+ default:
+ streampanner->set_position (AngularVector (direct_control_to_stereo_pan (val), 0.0));
+ AutomationControl::set_value(val);
+ break;
+ }
+
}
double
-Panner::PanControllable::get_value (void) const
+StreamPanner::PanControllable::get_value (void) const
{
return AutomationControl::get_value();
}
}
int
-StreamPanner::set_state (const XMLNode& node, int /*version*/)
+StreamPanner::set_state (const XMLNode& node, int version)
{
const XMLProperty* prop;
XMLNodeConstIterator iter;
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;
}
-void
-StreamPanner::add_state (XMLNode& node)
+XMLNode&
+StreamPanner::get_state ()
{
- node.add_property (X_("muted"), (muted() ? "yes" : "no"));
- node.add_property (X_("mono"), (_mono ? "yes" : "no"));
+ 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, nframes_t nframes)
+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 */
void
StreamPanner::distribute_automated (AudioBuffer& src, BufferSet& obufs,
- nframes_t start, nframes_t end, nframes_t nframes, pan_t** buffers)
+ 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 */
_control->list()->clear ();
while (in.getline (line, sizeof (line), '\n')) {
- nframes_t when;
+ framepos_t when;
double value;
++linecnt;
break;
}
- if (sscanf (line, "%" PRIu32 " %lf", &when, &value) != 2) {
+ 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;
}
}
void
-BaseStereoPanner::do_distribute (AudioBuffer& srcbuf, BufferSet& obufs, gain_t gain_coeff, nframes_t nframes)
+BaseStereoPanner::do_distribute (AudioBuffer& srcbuf, BufferSet& obufs, gain_t gain_coeff, pframes_t nframes)
{
assert(obufs.count().n_audio() == 2);
/* we've moving the pan by an appreciable amount, so we must
interpolate over 64 frames or nframes, whichever is smaller */
- nframes_t const limit = min ((nframes_t)64, nframes);
- nframes_t n;
+ pframes_t const limit = min ((pframes_t) 64, nframes);
+ pframes_t n;
delta = -(delta / (float) (limit));
/* we're moving the pan by an appreciable amount, so we must
interpolate over 64 frames or nframes, whichever is smaller */
- nframes_t const limit = min ((nframes_t)64, nframes);
- nframes_t n;
+ pframes_t const limit = min ((pframes_t) 64, nframes);
+ pframes_t n;
delta = -(delta / (float) (limit));
void
EqualPowerStereoPanner::do_distribute_automated (AudioBuffer& srcbuf, BufferSet& obufs,
- nframes_t start, nframes_t end, nframes_t nframes,
+ framepos_t start, framepos_t end, pframes_t nframes,
pan_t** buffers)
{
assert (obufs.count().n_audio() == 2);
const float pan_law_attenuation = -3.0f;
const float scale = 2.0f - 4.0f * powf (10.0f,pan_law_attenuation/20.0f);
- for (nframes_t n = 0; n < nframes; ++n) {
+ for (pframes_t n = 0; n < nframes; ++n) {
float const panR = buffers[0][n];
float const panL = 1 - panR;
dst = obufs.get_audio(0).data();
pbuf = buffers[0];
- for (nframes_t n = 0; n < nframes; ++n) {
+ for (pframes_t n = 0; n < nframes; ++n) {
dst[n] += src[n] * pbuf[n];
}
dst = obufs.get_audio(1).data();
pbuf = buffers[1];
- for (nframes_t n = 0; n < nframes; ++n) {
+ for (pframes_t n = 0; n < nframes; ++n) {
dst[n] += src[n] * pbuf[n];
}
XMLNode&
EqualPowerStereoPanner::state (bool /*full_state*/)
{
- XMLNode* root = new XMLNode ("StreamPanner");
- char buf[64];
- LocaleGuard lg (X_("POSIX"));
-
- snprintf (buf, sizeof (buf), "%.12g", _angles.azi);
- root->add_property (X_("azimuth"), buf);
- root->add_property (X_("type"), EqualPowerStereoPanner::name);
-
- // XXX: dont save automation here... its part of the automatable panner now.
-
- StreamPanner::add_state (*root);
-
- root->add_child_nocopy (_control->get_state ());
-
- return *root;
+ XMLNode& root (StreamPanner::get_state ());
+ root.add_property (X_("type"), EqualPowerStereoPanner::name);
+ return root;
}
int
EqualPowerStereoPanner::set_state (const XMLNode& node, int version)
{
- const XMLProperty* prop;
LocaleGuard lg (X_("POSIX"));
- if ((prop = node.property (X_("azimuth")))) {
- AngularVector a (atof (prop->value().c_str()), 0.0);
- set_position (a, true);
- } else if ((prop = node.property (X_("x")))) {
- /* old school cartesian positioning */
- AngularVector a;
- a.azi = BaseStereoPanner::lr_fract_to_azimuth (atof (prop->value().c_str()));
- set_position (a, true);
- }
-
StreamPanner::set_state (node, version);
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() == "panner") {
- _control->set_state (**iter, version);
- }
-
- } else if ((*iter)->name() == X_("Automation")) {
-
+ 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));
Panner::Panner (string name, Session& s)
: SessionObject (s, name)
- , Automatable (s)
+ , Automatable (s)
{
//set_name_old_auto (name);
set_name (name);
(*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.
*/
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"));
-
- for (vector<Panner::Output>::iterator o = outputs.begin(); o != outputs.end(); ++o) {
- XMLNode* onode = new XMLNode (X_("Output"));
- snprintf (buf, sizeof (buf), "%.12g", (*o).position.azi);
- onode->add_property (X_("azimuth"), buf);
- snprintf (buf, sizeof (buf), "%.12g", (*o).position.ele);
- onode->add_property (X_("elevation"), buf);
- node->add_child_nocopy (*onode);
- }
+ 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 ());
+ node->add_child_nocopy (get_automation_xml_state ());
return *node;
}
int
Panner::set_state (const XMLNode& node, int version)
{
- XMLNodeList nlist;
+ XMLNodeList nlist = node.children ();
XMLNodeConstIterator niter;
const XMLProperty *prop;
uint32_t i;
set_link_direction (LinkDirection (string_2_enum (prop->value(), ld)));
}
- nlist = node.children();
-
- 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));
- }
- }
+ 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 (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())
}
}
+ 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")))) {
set_automation_xml_state (**niter, Evoral::Parameter (PanAutomation));
}
}
-
+
return 0;
}
}
void
-Panner::distribute_no_automation (BufferSet& inbufs, BufferSet& outbufs, nframes_t nframes, gain_t gain_coeff)
+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...
}
void
-Panner::run (BufferSet& inbufs, BufferSet& outbufs, framepos_t start_frame, framepos_t end_frame, nframes_t nframes)
+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
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
+}
+
+string
+Panner::describe_parameter (Evoral::Parameter param)
+{
+ 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);
+}
projects / ardour.git / blobdiff