smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-18 04:36:30 +01:00
Code Issues Projects Releases Wiki Activity
ardour/libs/ardour/panner.cc
Paul Davis edea754b6b more stereo panner work 
git-svn-id: svn://localhost/ardour2/branches/3.0@8149 d708f5d6-7413-0410-9779-e7cbd77b26cf
2010-12-01 21:24:57 +00:00

1545 lines
38 KiB
C++
Raw Blame History

/*
Copyright (C) 2004 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
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#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"
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)
{
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 ()
{
}
void
StreamPanner::set_mono (bool yn)
{
if (yn != _mono) {
_mono = 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);
}
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
StreamPanner::PanControllable::get_value (void) const
{
return AutomationControl::get_value();
}
void
StreamPanner::set_muted (bool yn)
{
if (yn != _muted) {
_muted = 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)
{
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, nframes_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,
nframes_t start, nframes_t end, nframes_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')) {
nframes_t when;
double value;
++linecnt;
if (strcmp (line, "end") == 0) {
break;
}
if (sscanf (line, "%" PRIu32 " %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);
}
/* 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, nframes_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 */
nframes_t const limit = min ((nframes_t)64, nframes);
nframes_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 */
nframes_t const limit = min ((nframes_t)64, nframes);
nframes_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,
nframes_t start, nframes_t end, nframes_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 (nframes_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 (nframes_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 (nframes_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)
{
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.
*/
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;
}
for (std::vector<StreamPanner*>::iterator x = _streampanners.begin(); x != _streampanners.end(); ++x) {
(*x)->set_position (AngularVector (deg, 0.0));
deg += degree_step;
}
}
}
void
Panner::remove (uint32_t which)
{
vector<StreamPanner*>::iterator i;
for (i = _streampanners.begin(); i != _streampanners.end() && which; ++i, --which) {}
if (i != _streampanners.end()) {
delete *i;
_streampanners.erase (i);
}
}
/** Remove all our StreamPanners */
void
Panner::clear_panners ()
{
for (vector<StreamPanner*>::iterator i = _streampanners.begin(); i != _streampanners.end(); ++i) {
delete *i;
}
_streampanners.clear ();
}
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 ();
}
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 ();
}
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;
}
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;
}
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, nframes_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, nframes_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);
}
}
string
Panner::value_as_string (double v)
{
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);
}
/* if the new right 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;
}
l_pos = max (min (l_pos, 180.0), 0.0);
r_pos = max (min (r_pos, 180.0), 0.0);
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));
// cerr << "left @ " << BaseStereoPanner::azimuth_to_lr_fract (l_pos) << " right @ " << BaseStereoPanner::azimuth_to_lr_fract (r_pos) << endl;
}
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> wc;
boost::shared_ptr<AutomationControl> dc;
if (!automation_control (lr_param)) {
dc.reset (new StreamPanner::PanControllable (_session, _("lr"), *_streampanners.front(), lr_param));
add_control (dc);
}
if (!automation_control (width_param)) {
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);
}
Reference in a new issue View git blame Copy permalink