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
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
|
/*
Rosegarden
A sequencer and musical notation editor.
This program is Copyright 2000-2008
Guillaume Laurent <[email protected]>,
Chris Cannam <[email protected]>,
Richard Bown <[email protected]>
The moral right of the authors to claim authorship of this work
has been asserted.
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. See the file
COPYING included with this distribution for more information.
*/
#ifndef _INSTRUMENT_H_
#define _INSTRUMENT_H_
#include <string>
#include <vector>
#include "XmlExportable.h"
#include "MidiProgram.h"
// An Instrument connects a Track (which itself contains
// a list of Segments) to a device that can play that
// Track.
//
// An Instrument is either MIDI or Audio (or whatever else
// we decide to implement).
//
//
namespace Rosegarden
{
// plugins
class AudioPluginInstance;
typedef std::vector<AudioPluginInstance*>::iterator PluginInstanceIterator;
typedef std::vector<std::pair<MidiByte, MidiByte> > StaticControllers;
typedef std::vector<std::pair<MidiByte, MidiByte> >::iterator StaticControllerIterator;
typedef std::vector<std::pair<MidiByte, MidiByte> >::const_iterator StaticControllerConstIterator;
// Instrument number groups
//
const InstrumentId SystemInstrumentBase = 0;
const InstrumentId AudioInstrumentBase = 1000;
const InstrumentId MidiInstrumentBase = 2000;
const InstrumentId SoftSynthInstrumentBase = 10000;
const unsigned int AudioInstrumentCount = 16;
const unsigned int SoftSynthInstrumentCount = 24;
const MidiByte MidiMaxValue = 127;
const MidiByte MidiMidValue = 64;
const MidiByte MidiMinValue = 0;
typedef unsigned int BussId;
// Predeclare Device
//
class Device;
class PluginContainer
{
public:
static const unsigned int PLUGIN_COUNT; // for non-synth plugins
PluginInstanceIterator beginPlugins() { return m_audioPlugins.begin(); }
PluginInstanceIterator endPlugins() { return m_audioPlugins.end(); }
// Plugin management
//
void addPlugin(AudioPluginInstance *instance);
bool removePlugin(unsigned int position);
void clearPlugins();
void emptyPlugins(); // empty the plugins but don't clear them down
// Get a plugin for this container
//
AudioPluginInstance* getPlugin(unsigned int position);
virtual unsigned int getId() const = 0;
virtual std::string getName() const = 0;
virtual std::string getPresentationName() const = 0;
protected:
PluginContainer(bool havePlugins);
virtual ~PluginContainer();
std::vector<AudioPluginInstance*> m_audioPlugins;
};
class Instrument : public XmlExportable, public PluginContainer
{
public:
static const unsigned int SYNTH_PLUGIN_POSITION;
enum InstrumentType { Midi, Audio, SoftSynth };
Instrument(InstrumentId id,
InstrumentType it,
const std::string &name,
Device *device);
Instrument(InstrumentId id,
InstrumentType it,
const std::string &name,
MidiByte channel,
Device *device);
// Copy constructor and assignment
//
Instrument(const Instrument &);
Instrument &operator=(const Instrument &);
~Instrument();
virtual std::string getName() const { return m_name; }
virtual std::string getPresentationName() const;
void setId(InstrumentId id) { m_id = id; }
InstrumentId getId() const { return m_id; }
void setName(const std::string &name) { m_name = name; }
InstrumentType getType() const { return m_type; }
void setType(InstrumentType type) { m_type = type; }
InstrumentType getInstrumentType() { return m_type; }
// ---------------- MIDI Controllers -----------------
//
void setMidiChannel(MidiByte mC) { m_channel = mC; }
MidiByte getMidiChannel() const { return m_channel; }
//void setMidiInputChannel(char ic) { m_input_channel = ic; }
//char getMidiInputChannel() const { return m_input_channel; }
void setMidiTranspose(MidiByte mT) { m_transpose = mT; }
MidiByte getMidiTranspose() const { return m_transpose; }
// Pan is 0-127 for MIDI instruments, and (for some
// unfathomable reason) 0-200 for audio instruments.
//
void setPan(MidiByte pan) { m_pan = pan; }
MidiByte getPan() const { return m_pan; }
// Volume is 0-127 for MIDI instruments. It's not used for
// audio instruments -- see "level" instead.
//
void setVolume(MidiByte volume) { m_volume = volume; }
MidiByte getVolume() const { return m_volume; }
void setProgram(const MidiProgram &program) { m_program = program; }
const MidiProgram &getProgram() const { return m_program; }
void setSendBankSelect(bool value) { m_sendBankSelect = value; }
bool sendsBankSelect() const { return m_sendBankSelect; }
void setSendProgramChange(bool value) { m_sendProgramChange = value; }
bool sendsProgramChange() const { return m_sendProgramChange; }
void setSendPan(bool value) { m_sendPan = value; }
bool sendsPan() const { return m_sendPan; }
void setSendVolume(bool value) { m_sendVolume = value; }
bool sendsVolume() const { return m_sendVolume; }
void setControllerValue(MidiByte controller, MidiByte value);
MidiByte getControllerValue(MidiByte controller) const;
// This is retrieved from the reference MidiProgram in the Device
const MidiKeyMapping *getKeyMapping() const;
// Convenience functions (strictly redundant with get/setProgram):
//
void setProgramChange(MidiByte program);
MidiByte getProgramChange() const;
void setMSB(MidiByte msb);
MidiByte getMSB() const;
void setLSB(MidiByte msb);
MidiByte getLSB() const;
void setPercussion(bool percussion);
bool isPercussion() const;
// --------------- Audio Controllers -----------------
//
void setLevel(float dB) { m_level = dB; }
float getLevel() const { return m_level; }
void setRecordLevel(float dB) { m_recordLevel = dB; }
float getRecordLevel() const { return m_recordLevel; }
void setAudioChannels(unsigned int ch) { m_channel = MidiByte(ch); }
unsigned int getAudioChannels() const { return (unsigned int)(m_channel); }
// An audio input can be a buss or a record input. The channel number
// is required for mono instruments, ignored for stereo ones.
void setAudioInputToBuss(BussId buss, int channel = 0);
void setAudioInputToRecord(int recordIn, int channel = 0);
int getAudioInput(bool &isBuss, int &channel) const;
void setAudioOutput(BussId buss) { m_audioOutput = buss; }
BussId getAudioOutput() const { return m_audioOutput; }
// Implementation of virtual function
//
virtual std::string toXmlString();
// Get and set the parent device
//
Device* getDevice() const { return m_device; }
void setDevice(Device* dev) { m_device = dev; }
// Return a string describing the current program for
// this Instrument
//
std::string getProgramName() const;
// MappedId management - should typedef this type once
// we have the energy to shake this all out.
//
int getMappedId() const { return m_mappedId; }
void setMappedId(int id) { m_mappedId = id; }
StaticControllers& getStaticControllers() { return m_staticControllers; }
private:
InstrumentId m_id;
std::string m_name;
InstrumentType m_type;
// Standard MIDI controllers and parameters
//
MidiByte m_channel;
//char m_input_channel;
MidiProgram m_program;
MidiByte m_transpose;
MidiByte m_pan; // required by audio
MidiByte m_volume;
// Used for Audio volume (dB value)
//
float m_level;
// Record level for Audio recording (dB value)
//
float m_recordLevel;
Device *m_device;
// Do we send at this intrument or do we leave these
// things up to the parent device and God? These are
// directly relatable to GUI elements
//
bool m_sendBankSelect;
bool m_sendProgramChange;
bool m_sendPan;
bool m_sendVolume;
// Instruments are directly related to faders for volume
// control. Here we can store the remote fader id.
//
int m_mappedId;
// Which input terminal we're connected to. This is a BussId if
// less than 1000 or a record input number (plus 1000) if >= 1000.
// The channel number is only used for mono instruments.
//
int m_audioInput;
int m_audioInputChannel;
// Which buss we output to. Zero is always the master.
//
BussId m_audioOutput;
// A static controller map that can be saved/loaded and queried along with this instrument.
// These values are modified from the IPB - if they appear on the IPB then they are sent
// at playback start time to the sequencer.
//
//
StaticControllers m_staticControllers;
};
class Buss : public XmlExportable, public PluginContainer
{
public:
Buss(BussId id);
~Buss();
void setId(BussId id) { m_id = id; }
BussId getId() const { return m_id; }
void setLevel(float dB) { m_level = dB; }
float getLevel() const { return m_level; }
void setPan(MidiByte pan) { m_pan = pan; }
MidiByte getPan() const { return m_pan; }
int getMappedId() const { return m_mappedId; }
void setMappedId(int id) { m_mappedId = id; }
virtual std::string toXmlString();
virtual std::string getName() const;
virtual std::string getPresentationName() const;
private:
BussId m_id;
float m_level;
MidiByte m_pan;
int m_mappedId;
};
// audio record input of a sort that can be connected to
class RecordIn : public XmlExportable
{
public:
RecordIn();
~RecordIn();
int getMappedId() const { return m_mappedId; }
void setMappedId(int id) { m_mappedId = id; }
virtual std::string toXmlString();
private:
int m_mappedId;
};
}
#endif // _INSTRUMENT_H_
|