diff options
Diffstat (limited to 'src/base/Instrument.h')
| -rw-r--r-- | src/base/Instrument.h | 349 |
1 files changed, 349 insertions, 0 deletions
diff --git a/src/base/Instrument.h b/src/base/Instrument.h new file mode 100644 index 0000000..8c348f0 --- /dev/null +++ b/src/base/Instrument.h @@ -0,0 +1,349 @@ +// -*- c-basic-offset: 4 -*- + +/* + 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_ |