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
|
/*
Copyright (C) 2007 Paul Davis
Author: Dave Robillard
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_parameter_h__
#define __ardour_parameter_h__
#include <string>
#include <pbd/compose.h>
#include <pbd/error.h>
#include <ardour/types.h>
namespace ARDOUR {
/** ID of an automatable parameter.
*
* A given automatable object has a number of automatable parameters. This is
* the unique ID for those parameters. Anything automatable (AutomationList,
* Curve) must have an ID unique with respect to it's Automatable parent.
*
* A parameter ID has two parts, a type and an int (only used by some types).
*
* This is a bit more ugly than it could be, due to using the existing/legacy
* ARDOUR::AutomationType: GainAutomation, PanAutomation, SoloAutomation,
* and MuteAutomation use only the type(), but PluginAutomation and
* MidiCCAutomation use the id() as port number and CC number, respectively.
*
* Future types may use a string or URI or whatever, as long as these are
* comparable anything may be added. ints are best as these should be fast to
* copy and compare with one another.
*/
class Parameter
{
public:
inline Parameter(AutomationType type = NullAutomation, uint32_t id=0) : _type(type), _id(id) {}
/** Construct an Parameter from a string returned from Parameter::to_string
* (AutomationList automation-id property)
*/
Parameter(const std::string& str) : _type(NullAutomation), _id(0) {
if (str == "gain") {
_type = GainAutomation;
} else if (str == "solo") {
_type = SoloAutomation;
} else if (str == "mute") {
_type = MuteAutomation;
} else if (str == "fadein") {
_type = FadeInAutomation;
} else if (str == "fadeout") {
_type = FadeOutAutomation;
} else if (str == "envelope") {
_type = EnvelopeAutomation;
} else if (str == "pan") {
_type = PanAutomation;
} else if (str.length() > 4 && str.substr(0, 4) == "pan-") {
_type = PanAutomation;
_id = atoi(str.c_str()+4);
} else if (str.length() > 10 && str.substr(0, 10) == "parameter-") {
_type = PluginAutomation;
_id = atoi(str.c_str()+10);
} else if (str.length() > 7 && str.substr(0, 7) == "midicc-") {
_type = MidiCCAutomation;
_id = atoi(str.c_str()+7);
} else {
PBD::warning << "Unknown Parameter '" << str << "'" << endmsg;
}
}
inline AutomationType type() const { return _type; }
inline uint32_t id() const { return _id; }
inline bool operator==(const Parameter& id) const
{ return (_type == id._type && _id == id._id); }
/** Arbitrary but fixed ordering, so we're comparable (usable in std::map) */
inline bool operator<(const Parameter& id) const {
// FIXME: branch a performance problem? #ifdef DEBUG?
if (_type == NullAutomation)
PBD::warning << "Uninitialized Parameter compared." << endmsg;
return (_type < id._type || _id < id._id);
}
inline operator bool() const { return (_type != 0); }
/** Unique string representation, suitable as an XML property value.
* e.g. <AutomationList automation-id="whatthisreturns">
*/
inline std::string to_string() const {
if (_type == GainAutomation) {
return "gain";
} else if (_type == PanAutomation) {
return string_compose("pan-%1", _id);
} else if (_type == SoloAutomation) {
return "solo";
} else if (_type == MuteAutomation) {
return "mute";
} else if (_type == FadeInAutomation) {
return "fadein";
} else if (_type == FadeOutAutomation) {
return "fadeout";
} else if (_type == EnvelopeAutomation) {
return "envelope";
} else if (_type == PluginAutomation) {
return string_compose("parameter-%1", _id);
} else if (_type == MidiCCAutomation) {
return string_compose("midicc-%1", _id);
} else {
assert(false);
PBD::warning << "Uninitialized Parameter to_string() called." << endmsg;
return "";
}
}
private:
// default copy constructor is ok
AutomationType _type;
uint32_t _id;
};
} // namespace ARDOUR
#endif // __ardour_parameter_h__
|
