2 Copyright (C) 2004-2011 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
35 #include "pbd/cartesian.h"
36 #include "pbd/convert.h"
37 #include "pbd/error.h"
38 #include "pbd/failed_constructor.h"
39 #include "pbd/xml++.h"
40 #include "pbd/enumwriter.h"
42 #include "evoral/Curve.hpp"
44 #include "ardour/audio_buffer.h"
45 #include "ardour/audio_buffer.h"
46 #include "ardour/buffer_set.h"
47 #include "ardour/pan_controllable.h"
48 #include "ardour/pannable.h"
49 #include "ardour/runtime_functions.h"
50 #include "ardour/session.h"
51 #include "ardour/utils.h"
52 #include "ardour/visibility.h"
53 #include "ardour/mix.h"
55 #include "panner_2in2out.h"
59 #include "pbd/mathfix.h"
62 using namespace ARDOUR;
65 static PanPluginDescriptor _descriptor = {
68 Panner2in2out::factory
71 extern "C" ARDOURPANNER_API PanPluginDescriptor* panner_descriptor () { return &_descriptor; }
73 Panner2in2out::Panner2in2out (boost::shared_ptr<Pannable> p)
76 if (!_pannable->has_state()) {
77 _pannable->pan_azimuth_control->set_value (0.5);
78 _pannable->pan_width_control->set_value (1.0);
84 left_interp[0] = left[0] = desired_left[0];
85 right_interp[0] = right[0] = desired_right[0];
88 left_interp[1] = left[1] = desired_left[1];
89 right_interp[1] = right[1] = desired_right[1];
91 _pannable->pan_azimuth_control->Changed.connect_same_thread (*this, boost::bind (&Panner2in2out::update, this));
92 _pannable->pan_width_control->Changed.connect_same_thread (*this, boost::bind (&Panner2in2out::update, this));
95 Panner2in2out::~Panner2in2out ()
100 Panner2in2out::position () const
102 return _pannable->pan_azimuth_control->get_value();
106 Panner2in2out::width () const
108 return _pannable->pan_width_control->get_value();
112 Panner2in2out::set_position (double p)
114 if (clamp_position (p)) {
115 _pannable->pan_azimuth_control->set_value (p);
120 Panner2in2out::set_width (double p)
122 if (clamp_width (p)) {
123 _pannable->pan_width_control->set_value (p);
128 Panner2in2out::thaw ()
137 Panner2in2out::update ()
143 /* it would be very nice to split this out into a virtual function
144 that can be accessed from BaseStereoPanner and used in do_distribute_automated().
146 but the place where its used in do_distribute_automated() is a tight inner loop,
147 and making "nframes" virtual function calls to compute values is an absurd
151 /* x == 0 => hard left = 180.0 degrees
152 x == 1 => hard right = 0.0 degrees
156 double width = this->width ();
157 const double direction_as_lr_fract = position ();
161 pos[0] = direction_as_lr_fract + (width/2.0); // left signal lr_fract
162 pos[1] = direction_as_lr_fract - (width/2.0); // right signal lr_fract
164 pos[1] = direction_as_lr_fract + (width/2.0); // right signal lr_fract
165 pos[0] = direction_as_lr_fract - (width/2.0); // left signal lr_fract
168 /* compute target gain coefficients for both input signals */
170 float const pan_law_attenuation = -3.0f;
171 float const scale = 2.0f - 4.0f * powf (10.0f,pan_law_attenuation/20.0f);
179 desired_left[0] = panL * (scale * panL + 1.0f - scale);
180 desired_right[0] = panR * (scale * panR + 1.0f - scale);
186 desired_left[1] = panL * (scale * panL + 1.0f - scale);
187 desired_right[1] = panR * (scale * panR + 1.0f - scale);
191 Panner2in2out::clamp_position (double& p)
194 return clamp_stereo_pan (p, w);
198 Panner2in2out::clamp_width (double& w)
200 double p = position ();
201 return clamp_stereo_pan (p, w);
205 Panner2in2out::position_range () const
207 return make_pair (0.5 - (1 - width()) / 2, 0.5 + (1 - width()) / 2);
211 Panner2in2out::width_range () const
213 double const w = min (position(), (1 - position())) * 2;
214 return make_pair (-w, w);
218 Panner2in2out::clamp_stereo_pan (double& direction_as_lr_fract, double& width)
223 width = max (min (width, 1.0), -1.0);
224 direction_as_lr_fract = max (min (direction_as_lr_fract, 1.0), 0.0);
226 r_pos = direction_as_lr_fract + (width/2.0);
227 l_pos = direction_as_lr_fract - (width/2.0);
233 /* if the new left position is less than or equal to zero (hard left) and the left panner
234 is already there, we're not moving the left signal.
241 /* if the new right position is less than or equal to 1.0 (hard right) and the right panner
242 is already there, we're not moving the right signal.
254 Panner2in2out::distribute_one (AudioBuffer& srcbuf, BufferSet& obufs, gain_t gain_coeff, pframes_t nframes, uint32_t which)
256 assert (obufs.count().n_audio() == 2);
262 Sample* const src = srcbuf.data();
266 dst = obufs.get_audio(0).data();
268 if (fabsf ((delta = (left[which] - desired_left[which]))) > 0.002) { // about 1 degree of arc
270 /* we've moving the pan by an appreciable amount, so we must
271 interpolate over 64 frames or nframes, whichever is smaller */
273 pframes_t const limit = min ((pframes_t) 64, nframes);
276 delta = -(delta / (float) (limit));
278 for (n = 0; n < limit; n++) {
279 left_interp[which] = left_interp[which] + delta;
280 left[which] = left_interp[which] + 0.9 * (left[which] - left_interp[which]);
281 dst[n] += src[n] * left[which] * gain_coeff;
284 /* then pan the rest of the buffer; no need for interpolation for this bit */
286 pan = left[which] * gain_coeff;
288 mix_buffers_with_gain (dst+n,src+n,nframes-n,pan);
292 left[which] = desired_left[which];
293 left_interp[which] = left[which];
295 if ((pan = (left[which] * gain_coeff)) != 1.0f) {
299 /* pan is 1 but also not 0, so we must do it "properly" */
301 //obufs.get_audio(1).read_from (srcbuf, nframes);
302 mix_buffers_with_gain(dst,src,nframes,pan);
304 /* mark that we wrote into the buffer */
312 /* pan is 1 so we can just copy the input samples straight in */
314 mix_buffers_no_gain(dst,src,nframes);
316 /* XXX it would be nice to mark that we wrote into the buffer */
322 dst = obufs.get_audio(1).data();
324 if (fabsf ((delta = (right[which] - desired_right[which]))) > 0.002) { // about 1 degree of arc
326 /* we're moving the pan by an appreciable amount, so we must
327 interpolate over 64 frames or nframes, whichever is smaller */
329 pframes_t const limit = min ((pframes_t) 64, nframes);
332 delta = -(delta / (float) (limit));
334 for (n = 0; n < limit; n++) {
335 right_interp[which] = right_interp[which] + delta;
336 right[which] = right_interp[which] + 0.9 * (right[which] - right_interp[which]);
337 dst[n] += src[n] * right[which] * gain_coeff;
340 /* then pan the rest of the buffer, no need for interpolation for this bit */
342 pan = right[which] * gain_coeff;
344 mix_buffers_with_gain(dst+n,src+n,nframes-n,pan);
346 /* XXX it would be nice to mark the buffer as written to */
350 right[which] = desired_right[which];
351 right_interp[which] = right[which];
353 if ((pan = (right[which] * gain_coeff)) != 1.0f) {
357 /* pan is not 1 but also not 0, so we must do it "properly" */
359 mix_buffers_with_gain(dst,src,nframes,pan);
360 // obufs.get_audio(1).read_from (srcbuf, nframes);
362 /* XXX it would be nice to mark the buffer as written to */
367 /* pan is 1 so we can just copy the input samples straight in */
369 mix_buffers_no_gain(dst,src,nframes);
371 /* XXX it would be nice to mark the buffer as written to */
377 Panner2in2out::distribute_one_automated (AudioBuffer& srcbuf, BufferSet& obufs,
378 framepos_t start, framepos_t end, pframes_t nframes,
379 pan_t** buffers, uint32_t which)
381 assert (obufs.count().n_audio() == 2);
385 Sample* const src = srcbuf.data();
386 pan_t* const position = buffers[0];
387 pan_t* const width = buffers[1];
389 /* fetch positional data */
391 if (!_pannable->pan_azimuth_control->list()->curve().rt_safe_get_vector (start, end, position, nframes)) {
393 distribute_one (srcbuf, obufs, 1.0, nframes, which);
397 if (!_pannable->pan_width_control->list()->curve().rt_safe_get_vector (start, end, width, nframes)) {
399 distribute_one (srcbuf, obufs, 1.0, nframes, which);
403 /* apply pan law to convert positional data into pan coefficients for
407 const float pan_law_attenuation = -3.0f;
408 const float scale = 2.0f - 4.0f * powf (10.0f,pan_law_attenuation/20.0f);
410 for (pframes_t n = 0; n < nframes; ++n) {
415 // panning left signal
416 panR = position[n] - (width[n]/2.0f); // center - width/2
418 // panning right signal
419 panR = position[n] + (width[n]/2.0f); // center - width/2
422 const float panL = 1 - panR;
424 /* note that are overwriting buffers, but its OK
425 because we're finished with their old contents
426 (position/width automation data) and are
427 replacing it with panning/gain coefficients
428 that we need to actually process the data.
431 buffers[0][n] = panL * (scale * panL + 1.0f - scale);
432 buffers[1][n] = panR * (scale * panR + 1.0f - scale);
437 dst = obufs.get_audio(0).data();
440 for (pframes_t n = 0; n < nframes; ++n) {
441 dst[n] += src[n] * pbuf[n];
444 /* XXX it would be nice to mark the buffer as written to */
448 dst = obufs.get_audio(1).data();
451 for (pframes_t n = 0; n < nframes; ++n) {
452 dst[n] += src[n] * pbuf[n];
455 /* XXX it would be nice to mark the buffer as written to */
459 Panner2in2out::factory (boost::shared_ptr<Pannable> p, boost::shared_ptr<Speakers> /* ignored */)
461 return new Panner2in2out (p);
465 Panner2in2out::get_state ()
467 XMLNode& root (Panner::get_state ());
468 root.add_property (X_("type"), _descriptor.name);
472 std::set<Evoral::Parameter>
473 Panner2in2out::what_can_be_automated() const
475 set<Evoral::Parameter> s;
476 s.insert (Evoral::Parameter (PanAzimuthAutomation));
477 s.insert (Evoral::Parameter (PanWidthAutomation));
482 Panner2in2out::describe_parameter (Evoral::Parameter p)
485 case PanAzimuthAutomation:
487 case PanWidthAutomation:
490 return _pannable->describe_parameter (p);
495 Panner2in2out::value_as_string (boost::shared_ptr<AutomationControl> ac) const
497 /* DO NOT USE LocaleGuard HERE */
498 double val = ac->get_value();
500 switch (ac->parameter().type()) {
501 case PanAzimuthAutomation:
502 /* We show the position of the center of the image relative to the left & right.
503 This is expressed as a pair of percentage values that ranges from (100,0)
504 (hard left) through (50,50) (hard center) to (0,100) (hard right).
506 This is pretty wierd, but its the way audio engineers expect it. Just remember that
507 the center of the USA isn't Kansas, its (50LA, 50NY) and it will all make sense.
509 This is designed to be as narrow as possible. Dedicated
510 panner GUIs can do their own version of this if they need
511 something less compact.
514 return string_compose (_("L%1R%2"), (int) rint (100.0 * (1.0 - val)),
515 (int) rint (100.0 * val));
517 case PanWidthAutomation:
518 return string_compose (_("Width: %1%%"), (int) floor (100.0 * val));
521 return _pannable->value_as_string (ac);
526 Panner2in2out::reset ()