1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
/*
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
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.
*/
#ifndef __ardour_panner_h__
#define __ardour_panner_h__
#include <cmath>
#include <cassert>
#include <vector>
#include <string>
#include <iostream>
#include "pbd/cartesian.h"
#include "pbd/signals.h"
#include "pbd/stateful.h"
#include "ardour/types.h"
#include "ardour/automation_control.h"
#include "ardour/automatable.h"
namespace ARDOUR {
class Session;
class Pannable;
class BufferSet;
class AudioBuffer;
class Speakers;
class Panner : public PBD::Stateful, public PBD::ScopedConnectionList
{
public:
Panner (boost::shared_ptr<Pannable>);
~Panner ();
virtual ChanCount in() const = 0;
virtual ChanCount out() const = 0;
virtual void configure_io (ARDOUR::ChanCount in, ARDOUR::ChanCount out) {}
/* derived implementations of these methods must indicate
whether it is legal for a Controllable to use the
value of the argument (post-call) in a call to
Controllable::set_value().
they have a choice of:
* return true, leave argument unchanged
* return true, modify argument
* return false
*/
virtual bool clamp_position (double&) { return true; }
virtual bool clamp_width (double&) { return true; }
virtual bool clamp_elevation (double&) { return true; }
virtual void set_position (double) { }
virtual void set_width (double) { }
virtual void set_elevation (double) { }
virtual double position () const { return 0.0; }
virtual double width () const { return 0.0; }
virtual double elevation () const { return 0.0; }
virtual void reset() {}
virtual bool bypassed() const { return _bypassed; }
virtual void set_bypassed (bool yn);
virtual bool is_mono () const { return _mono; }
virtual void set_mono (bool);
void set_automation_state (AutoState);
AutoState automation_state() const;
void set_automation_style (AutoStyle);
AutoStyle automation_style() const;
virtual std::set<Evoral::Parameter> what_can_be_automated() const;
virtual std::string describe_parameter (Evoral::Parameter);
bool touching() const;
static double azimuth_to_lr_fract (double azi) {
/* 180.0 degrees=> left => 0.0 */
/* 0.0 degrees => right => 1.0 */
/* humans can only distinguish 1 degree of arc between two positions,
so force azi back to an integral value before computing
*/
return 1.0 - (rint(azi)/180.0);
}
static double lr_fract_to_azimuth (double fract) {
/* fract = 0.0 => degrees = 180.0 => left */
/* fract = 1.0 => degrees = 0.0 => right */
/* humans can only distinguish 1 degree of arc between two positions,
so force azi back to an integral value after computing
*/
return rint (180.0 - (fract * 180.0));
}
/**
* Pan some input buffers to a number of output buffers.
*
* @param ibufs Input buffers (one per panner input)
* @param obufs Output buffers (one per panner output).
* @param gain_coeff fixed, additional gain coefficient to apply to output samples.
* @param nframes Number of frames in the input.
*
* Derived panners can choose to implement these if they need to gain more control over the panning algorithm.
* the default is to (1) check if _mono is true, and if so, just deliver .. (2) otherwise, call
* distribute_one() or distribute_one_automated() on each input buffer to deliver it to each output
* buffer.
*
* If a panner does not need to override this default behaviour, it can just implement
* distribute_one() and distribute_one_automated() (below).
*/
virtual void distribute (BufferSet& ibufs, BufferSet& obufs, gain_t gain_coeff, pframes_t nframes);
virtual void distribute_automated (BufferSet& ibufs, BufferSet& obufs,
framepos_t start, framepos_t end, pframes_t nframes,
pan_t** buffers);
PBD::Signal0<void> Changed; /* for positional info */
PBD::Signal0<void> StateChanged; /* for mute, mono */
int set_state (const XMLNode&, int version);
virtual XMLNode& state (bool full_state) = 0;
boost::shared_ptr<Pannable> pannable() const { return _pannable; }
//virtual std::string describe_parameter (Evoral::Parameter);
//virtual std::string value_as_string (Evoral::Parameter, double val);
static bool equivalent (pan_t a, pan_t b) {
return fabsf (a - b) < 0.002; // about 1 degree of arc for a stereo panner
}
static bool equivalent (const PBD::AngularVector& a, const PBD::AngularVector& b) {
/* XXX azimuth only, at present */
return fabs (a.azi - b.azi) < 1.0;
}
protected:
boost::shared_ptr<Pannable> _pannable;
bool _mono;
bool _bypassed;
XMLNode& get_state ();
virtual void distribute_one (AudioBuffer&, BufferSet& obufs, gain_t gain_coeff, pframes_t nframes, uint32_t which) = 0;
virtual void distribute_one_automated (AudioBuffer&, BufferSet& obufs,
framepos_t start, framepos_t end, pframes_t nframes,
pan_t** buffers, uint32_t which) = 0;
};
} // namespace
extern "C" {
struct PanPluginDescriptor {
std::string name;
int32_t in;
int32_t out;
ARDOUR::Panner* (*factory)(boost::shared_ptr<ARDOUR::Pannable>, ARDOUR::Speakers&);
};
}
#endif /* __ardour_panner_h__ */
|
