diff options
Diffstat (limited to 'src/sound/MappedStudio.h')
| -rw-r--r-- | src/sound/MappedStudio.h | 552 |
1 files changed, 552 insertions, 0 deletions
diff --git a/src/sound/MappedStudio.h b/src/sound/MappedStudio.h new file mode 100644 index 0000000..0896e6b --- /dev/null +++ b/src/sound/MappedStudio.h @@ -0,0 +1,552 @@ +// -*- c-indentation-style:"stroustrup" c-basic-offset: 4 -*- + +/* + Rosegarden + A sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <glaurent@telegraph-road.org>, + Chris Cannam <cannam@all-day-breakfast.com>, + Richard Bown <bownie@bownie.com> + + 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. +*/ + +#include <map> +#include <string> +#include <vector> +#include <qdatastream.h> +#include <qstring.h> + +#include "MappedCommon.h" +#include "Instrument.h" +#include "Device.h" + +#include "AudioPluginInstance.h" // for PluginPort::PortDisplayHint //!!!??? + +#ifndef _MAPPEDSTUDIO_H_ +#define _MAPPEDSTUDIO_H_ + + +// A sequencer-side representation of certain elements in the +// gui that enables us to control outgoing or incoming audio +// and MIDI with run-time only persistence. Placeholders for +// our Studio elements on the sequencer. + +namespace Rosegarden +{ + +class SoundDriver; + + +// Types are in MappedCommon.h +// +class MappedObject +{ +public: + + // Some common properties + // + static const MappedObjectProperty Name; + static const MappedObjectProperty Instrument; + static const MappedObjectProperty Position; + + // The object we can create + // + typedef enum + { + Studio, + AudioFader, // connectable fader - interfaces with devices + AudioBuss, // connectable buss - inferfaces with faders + AudioInput, // connectable record input + PluginSlot, + PluginPort + + } MappedObjectType; + + MappedObject(MappedObject *parent, + const std::string &name, + MappedObjectType type, + MappedObjectId id): + m_type(type), + m_id(id), + m_name(name), + m_parent(parent) {;} + + virtual ~MappedObject() {;} + + MappedObjectId getId() { return m_id; } + MappedObjectType getType() { return m_type; } + + std::string getName() { return m_name; } + void setName(const std::string &name) { m_name= name; } + + // Get and set properties + // + virtual MappedObjectPropertyList + getPropertyList(const MappedObjectProperty &property) = 0; + + virtual bool getProperty(const MappedObjectProperty &property, + MappedObjectValue &value) = 0; + + // Only relevant to objects that have string properties + // + virtual bool getProperty(const MappedObjectProperty &/* property */, + QString &/* value */) { return false; } + + virtual void setProperty(const MappedObjectProperty &property, + MappedObjectValue value) = 0; + + // Only relevant to objects that have string properties + // + virtual void setProperty(const MappedObjectProperty &/* property */, + QString /* value */) { } + + // Only relevant to objects that have list properties + // + virtual void setPropertyList(const MappedObjectProperty &/* property */, + const MappedObjectPropertyList &/* values */) { } + + // Ownership + // + MappedObject* getParent() { return m_parent; } + const MappedObject* getParent() const { return m_parent; } + void setParent(MappedObject *parent) { m_parent = parent; } + + // Get a list of child ids - get a list of a certain type + // + MappedObjectPropertyList getChildren(); + MappedObjectPropertyList getChildren(MappedObjectType type); + + // Child management + // + void addChild(MappedObject *mO); + void removeChild(MappedObject *mO); + + // Destruction + // + void destroy(); + void destroyChildren(); + + std::vector<MappedObject*> getChildObjects() { return m_children; } + +protected: + + MappedObjectType m_type; + MappedObjectId m_id; + std::string m_name; + + MappedObject *m_parent; + std::vector<MappedObject*> m_children; +}; + + +class MappedAudioFader; +class MappedAudioBuss; +class MappedAudioInput; + +// Works as a factory and virtual plug-board for all our other +// objects whether they be MIDI or audio. +// +// +// +class MappedStudio : public MappedObject +{ +public: + MappedStudio(); + ~MappedStudio(); + + // Create a new slider of a certain type for a certain + // type of device. + // + MappedObject* createObject(MappedObjectType type); + + // And create an object with a specified id + // + MappedObject* createObject(MappedObjectType type, + MappedObjectId id); + + bool connectObjects(MappedObjectId mId1, MappedObjectId mId2); + bool disconnectObjects(MappedObjectId mId1, MappedObjectId mId2); + bool disconnectObject(MappedObjectId mId); + + // Destroy a MappedObject by ID + // + bool destroyObject(MappedObjectId id); + + // Get an object by ID only + // + MappedObject* getObjectById(MappedObjectId); + + // Get an object by ID and type. (Returns 0 if the ID does not + // exist or exists but is not of the correct type.) This is + // faster than getObjectById if you know the type already. + // + MappedObject* getObjectByIdAndType(MappedObjectId, MappedObjectType); + + // Get an arbitrary object of a given type - to see if any exist + // + MappedObject* getObjectOfType(MappedObjectType type); + + // Find out how many objects there are of a certain type + // + unsigned int getObjectCount(MappedObjectType type); + + // iterators + MappedObject* getFirst(MappedObjectType type); + MappedObject* getNext(MappedObject *object); + + std::vector<MappedObject *> getObjectsOfType(MappedObjectType type); + + // Empty the studio of everything + // + void clear(); + + // Clear a MappedObject reference from the Studio + // + bool clearObject(MappedObjectId id); + + // Property list + // + virtual MappedObjectPropertyList getPropertyList( + const MappedObjectProperty &property); + + virtual bool getProperty(const MappedObjectProperty &property, + MappedObjectValue &value); + + virtual void setProperty(const MappedObjectProperty &property, + MappedObjectValue value); + + // Get an audio fader for an InstrumentId. Convenience function. + // + MappedAudioFader *getAudioFader(InstrumentId id); + MappedAudioBuss *getAudioBuss(int bussNumber); // not buss no., not object id + MappedAudioInput *getAudioInput(int inputNumber); // likewise + + // Return the object vector + // + //std::vector<MappedObject*>* getObjects() const { return &m_objects; } + + // DCOP streaming + // + /* dunno if we need this + friend QDataStream& operator>>(QDataStream &dS, MappedStudio *mS); + friend QDataStream& operator<<(QDataStream &dS, MappedStudio *mS); + friend QDataStream& operator>>(QDataStream &dS, MappedStudio &mS); + friend QDataStream& operator<<(QDataStream &dS, const MappedStudio &mS); + */ + + + // Set the driver object so that we can do things like + // initialise plugins etc. + // + SoundDriver* getSoundDriver() { return m_soundDriver; } + const SoundDriver* getSoundDriver() const { return m_soundDriver; } + void setSoundDriver(SoundDriver *driver) { m_soundDriver = driver; } + +protected: + +private: + + // We give everything we create a unique MappedObjectId for + // this session. So store the running total in here. + // + MappedObjectId m_runningObjectId; + + // All of our mapped (virtual) studio resides in this container as + // well as having all their parent/child relationships. Because + // some things are just blobs with no connections we need to + // maintain both - don't forget about this. + // + // Note that object IDs are globally unique, not just unique within + // a category. + // + typedef std::map<MappedObjectId, MappedObject *> MappedObjectCategory; + typedef std::map<MappedObjectType, MappedObjectCategory> MappedObjectMap; + MappedObjectMap m_objects; + + // Driver object + // + SoundDriver *m_soundDriver; +}; + + +// A connectable AudioObject that provides a connection framework +// for MappedAudioFader and MappedAudioBuss (for example). An +// abstract base class. +// +// n input connections and m output connections - subclasses +// can do the cleverness if n != m +// + +class MappedConnectableObject : public MappedObject +{ +public: + static const MappedObjectProperty ConnectionsIn; + static const MappedObjectProperty ConnectionsOut; + + typedef enum + { + In, + Out + } ConnectionDirection; + + MappedConnectableObject(MappedObject *parent, + const std::string &name, + MappedObjectType type, + MappedObjectId id); + + ~MappedConnectableObject(); + + void setConnections(ConnectionDirection dir, + MappedObjectValueList conns); + + void addConnection(ConnectionDirection dir, MappedObjectId id); + void removeConnection(ConnectionDirection dir, MappedObjectId id); + + MappedObjectValueList getConnections (ConnectionDirection dir); + +protected: + + // Which audio connections we have + // + MappedObjectValueList m_connectionsIn; + MappedObjectValueList m_connectionsOut; +}; + +// Audio fader +// +class MappedAudioFader : public MappedConnectableObject +{ +public: + static const MappedObjectProperty Channels; + + // properties + // + static const MappedObjectProperty FaderLevel; + static const MappedObjectProperty FaderRecordLevel; + static const MappedObjectProperty Pan; + static const MappedObjectProperty InputChannel; + + MappedAudioFader(MappedObject *parent, + MappedObjectId id, + MappedObjectValue channels = 2); // stereo default + ~MappedAudioFader(); + + virtual MappedObjectPropertyList getPropertyList( + const MappedObjectProperty &property); + + virtual bool getProperty(const MappedObjectProperty &property, + MappedObjectValue &value); + + virtual void setProperty(const MappedObjectProperty &property, + MappedObjectValue value); + + InstrumentId getInstrument() const { return m_instrumentId; } + +protected: + + MappedObjectValue m_level; + MappedObjectValue m_recordLevel; + InstrumentId m_instrumentId; + + // Stereo pan (-1.0 to +1.0) + // + MappedObjectValue m_pan; + + // How many channels we carry + // + MappedObjectValue m_channels; + + // If we have an input, which channel we take from it (if we are + // a mono fader at least) + // + MappedObjectValue m_inputChannel; +}; + +class MappedAudioBuss : public MappedConnectableObject +{ +public: + // A buss is much simpler than an instrument fader. It's always + // stereo, and just has a level and pan associated with it. The + // level may be a submaster fader level or a send mix level, it + // depends on what the purpose of the buss is. At the moment we + // just have a 1-1 relationship between busses and submasters, and + // no send channels. + + static const MappedObjectProperty BussId; + static const MappedObjectProperty Pan; + static const MappedObjectProperty Level; + + MappedAudioBuss(MappedObject *parent, + MappedObjectId id); + ~MappedAudioBuss(); + + virtual MappedObjectPropertyList getPropertyList( + const MappedObjectProperty &property); + + virtual bool getProperty(const MappedObjectProperty &property, + MappedObjectValue &value); + + virtual void setProperty(const MappedObjectProperty &property, + MappedObjectValue value); + + MappedObjectValue getBussId() { return m_bussId; } + + // super-convenience function: retrieve the ids of the instruments + // connected to this buss + std::vector<InstrumentId> getInstruments(); + +protected: + int m_bussId; + MappedObjectValue m_level; + MappedObjectValue m_pan; +}; + +class MappedAudioInput : public MappedConnectableObject +{ +public: + // An input is simpler still -- no properties at all, apart from + // the input number, otherwise just the connections + + static const MappedObjectProperty InputNumber; + + MappedAudioInput(MappedObject *parent, + MappedObjectId id); + ~MappedAudioInput(); + + virtual MappedObjectPropertyList getPropertyList( + const MappedObjectProperty &property); + + virtual bool getProperty(const MappedObjectProperty &property, + MappedObjectValue &value); + + virtual void setProperty(const MappedObjectProperty &property, + MappedObjectValue value); + + MappedObjectValue getInputNumber() { return m_inputNumber; } + +protected: + MappedObjectValue m_inputNumber; +}; + +class MappedPluginSlot : public MappedObject +{ +public: + static const MappedObjectProperty Identifier; + static const MappedObjectProperty PluginName; + static const MappedObjectProperty Label; + static const MappedObjectProperty Author; + static const MappedObjectProperty Copyright; + static const MappedObjectProperty Category; + static const MappedObjectProperty PortCount; + static const MappedObjectProperty Ports; + static const MappedObjectProperty Program; + static const MappedObjectProperty Programs; // list property + static const MappedObjectProperty Instrument; + static const MappedObjectProperty Position; + static const MappedObjectProperty Bypassed; + static const MappedObjectProperty Configuration; // list property + + MappedPluginSlot(MappedObject *parent, MappedObjectId id); + ~MappedPluginSlot(); + + virtual MappedObjectPropertyList getPropertyList( + const MappedObjectProperty &property); + + virtual bool getProperty(const MappedObjectProperty &property, + MappedObjectValue &value); + + virtual bool getProperty(const MappedObjectProperty &property, + QString &value); + + virtual void setProperty(const MappedObjectProperty &property, + MappedObjectValue value); + + virtual void setProperty(const MappedObjectProperty &property, + QString value); + + virtual void setPropertyList(const MappedObjectProperty &, + const MappedObjectPropertyList &); + + void setPort(unsigned long portNumber, float value); + float getPort(unsigned long portNumber); + + InstrumentId getInstrument() const { return m_instrument; } + int getPosition() const { return m_position; } + + QString getProgram(int bank, int program); + unsigned long getProgram(QString name); // rv is bank << 16 + program + +protected: + QString m_identifier; + + QString m_name; + QString m_label; + QString m_author; + QString m_copyright; + QString m_category; + unsigned long m_portCount; + + InstrumentId m_instrument; + int m_position; + bool m_bypassed; + + std::map<QString, QString> m_configuration; +}; + +class MappedPluginPort : public MappedObject +{ +public: + static const MappedObjectProperty PortNumber; + static const MappedObjectProperty Name; + static const MappedObjectProperty Minimum; + static const MappedObjectProperty Maximum; + static const MappedObjectProperty Default; + static const MappedObjectProperty DisplayHint; + static const MappedObjectProperty Value; + + MappedPluginPort(MappedObject *parent, MappedObjectId id); + ~MappedPluginPort(); + + virtual MappedObjectPropertyList getPropertyList( + const MappedObjectProperty &property); + + virtual bool getProperty(const MappedObjectProperty &property, + MappedObjectValue &value); + + virtual bool getProperty(const MappedObjectProperty &property, + QString &value); + + virtual void setProperty(const MappedObjectProperty &property, + MappedObjectValue value); + + virtual void setProperty(const MappedObjectProperty &property, + QString value); + + void setValue(MappedObjectValue value); + MappedObjectValue getValue() const; + + int getPortNumber() const { return m_portNumber; } + +protected: + int m_portNumber; + QString m_name; + MappedObjectValue m_minimum; + MappedObjectValue m_maximum; + MappedObjectValue m_default; + PluginPort::PortDisplayHint m_displayHint; + +}; + + +} + +#endif // _MAPPEDSTUDIO_H_ |