svcore  1.9
DSSIPluginInstance.h
Go to the documentation of this file.
00001 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
00002 
00003 /*
00004     Sonic Visualiser
00005     An audio file viewer and annotation editor.
00006     Centre for Digital Music, Queen Mary, University of London.
00007     
00008     This program is free software; you can redistribute it and/or
00009     modify it under the terms of the GNU General Public License as
00010     published by the Free Software Foundation; either version 2 of the
00011     License, or (at your option) any later version.  See the file
00012     COPYING included with this distribution for more information.
00013 */
00014 
00015 /*
00016    This is a modified version of a source file from the 
00017    Rosegarden MIDI and audio sequencer and notation editor.
00018    This file copyright 2000-2006 Chris Cannam.
00019 */
00020 
00021 #ifndef _DSSIPLUGININSTANCE_H_
00022 #define _DSSIPLUGININSTANCE_H_
00023 
00024 #define DSSI_API_LEVEL 2
00025 
00026 #include <vector>
00027 #include <set>
00028 #include <map>
00029 #include <QString>
00030 #include <QMutex>
00031 
00032 #include "api/dssi.h"
00033 
00034 #include "base/RingBuffer.h"
00035 #include "base/Thread.h"
00036 #include "RealTimePluginInstance.h"
00037 #include "base/Scavenger.h"
00038 
00039 class DSSIPluginInstance : public RealTimePluginInstance
00040 {
00041 public:
00042     virtual ~DSSIPluginInstance();
00043 
00044     virtual bool isOK() const { return m_instanceHandle != 0; }
00045 
00046     int getClientId() const { return m_client; }
00047     virtual QString getPluginIdentifier() const { return m_identifier; }
00048     int getPosition() const { return m_position; }
00049 
00050     virtual std::string getIdentifier() const;
00051     virtual std::string getName() const;
00052     virtual std::string getDescription() const;
00053     virtual std::string getMaker() const;
00054     virtual int getPluginVersion() const;
00055     virtual std::string getCopyright() const;
00056 
00057     virtual void run(const Vamp::RealTime &, size_t count = 0);
00058 
00059     virtual unsigned int getParameterCount() const;
00060     virtual void setParameterValue(unsigned int parameter, float value);
00061     virtual float getParameterValue(unsigned int parameter) const;
00062     virtual float getParameterDefault(unsigned int parameter) const;
00063     virtual int getParameterDisplayHint(unsigned int parameter) const;
00064 
00065     virtual ParameterList getParameterDescriptors() const;
00066     virtual float getParameter(std::string) const;
00067     virtual void setParameter(std::string, float);
00068 
00069     virtual std::string configure(std::string key, std::string value);
00070     virtual void sendEvent(const Vamp::RealTime &eventTime,
00071                            const void *event);
00072     virtual void clearEvents();
00073 
00074     virtual size_t getBufferSize() const { return m_blockSize; }
00075     virtual size_t getAudioInputCount() const { return m_audioPortsIn.size(); }
00076     virtual size_t getAudioOutputCount() const { return m_idealChannelCount; }
00077     virtual sample_t **getAudioInputBuffers() { return m_inputBuffers; }
00078     virtual sample_t **getAudioOutputBuffers() { return m_outputBuffers; }
00079 
00080     virtual size_t getControlOutputCount() const { return m_controlPortsOut.size(); }
00081     virtual float getControlOutputValue(size_t n) const;
00082 
00083     virtual ProgramList getPrograms() const;
00084     virtual std::string getCurrentProgram() const;
00085     virtual std::string getProgram(int bank, int program) const;
00086     virtual unsigned long getProgram(std::string name) const;
00087     virtual void selectProgram(std::string program);
00088 
00089     virtual bool isBypassed() const { return m_bypassed; }
00090     virtual void setBypassed(bool bypassed) { m_bypassed = bypassed; }
00091 
00092     virtual size_t getLatency();
00093 
00094     virtual void silence();
00095     virtual void discardEvents();
00096     virtual void setIdealChannelCount(size_t channels); // may re-instantiate
00097 
00098     virtual bool isInGroup() const { return m_grouped; }
00099     virtual void detachFromGroup();
00100 
00101     virtual std::string getType() const { return "DSSI Real-Time Plugin"; }
00102 
00103 protected:
00104     // To be constructed only by DSSIPluginFactory
00105     friend class DSSIPluginFactory;
00106 
00107     // Constructor that creates the buffers internally
00108     // 
00109     DSSIPluginInstance(RealTimePluginFactory *factory,
00110                        int client,
00111                        QString identifier,
00112                        int position,
00113                        unsigned long sampleRate,
00114                        size_t blockSize,
00115                        int idealChannelCount,
00116                        const DSSI_Descriptor* descriptor);
00117     
00118     void init();
00119     void instantiate(unsigned long sampleRate);
00120     void cleanup();
00121     void activate();
00122     void deactivate();
00123     void connectPorts();
00124 
00125     bool handleController(snd_seq_event_t *ev);
00126     void setPortValueFromController(unsigned int portNumber, int controlValue);
00127     void selectProgramAux(std::string program, bool backupPortValues);
00128     void checkProgramCache() const;
00129 
00130     void initialiseGroupMembership();
00131     void runGrouped(const Vamp::RealTime &);
00132 
00133     // For use in DSSIPluginFactory (set in the DSSI_Host_Descriptor):
00134     static int requestMidiSend(LADSPA_Handle instance,
00135                                unsigned char ports,
00136                                unsigned char channels);
00137     static void midiSend(LADSPA_Handle instance,
00138                          snd_seq_event_t *events,
00139                          unsigned long eventCount);
00140     static int requestNonRTThread(LADSPA_Handle instance,
00141                                   void (*runFunction)(LADSPA_Handle));
00142 
00143     int                        m_client;
00144     int                        m_position;
00145     LADSPA_Handle              m_instanceHandle;
00146     const DSSI_Descriptor     *m_descriptor;
00147 
00148     std::vector<std::pair<unsigned long, LADSPA_Data*> > m_controlPortsIn;
00149     std::vector<std::pair<unsigned long, LADSPA_Data*> > m_controlPortsOut;
00150 
00151     std::vector<LADSPA_Data>  m_backupControlPortsIn;
00152 
00153     std::map<int, int>        m_controllerMap;
00154 
00155     std::vector<int>          m_audioPortsIn;
00156     std::vector<int>          m_audioPortsOut;
00157 
00158     struct ProgramControl {
00159         int msb;
00160         int lsb;
00161         int program;
00162     };
00163     ProgramControl m_pending;
00164 
00165     struct ProgramDescriptor {
00166         int bank;
00167         int program;
00168         std::string name;
00169     };
00170     mutable std::vector<ProgramDescriptor> m_cachedPrograms;
00171     mutable bool m_programCacheValid;
00172 
00173     RingBuffer<snd_seq_event_t> m_eventBuffer;
00174 
00175     size_t                    m_blockSize;
00176     sample_t                **m_inputBuffers;
00177     sample_t                **m_outputBuffers;
00178     bool                      m_ownBuffers;
00179     size_t                    m_idealChannelCount;
00180     size_t                    m_outputBufferCount;
00181     size_t                    m_sampleRate;
00182     float                    *m_latencyPort;
00183     bool                      m_run;
00184     
00185     bool                      m_bypassed;
00186     std::string               m_program;
00187     bool                      m_grouped;
00188     Vamp::RealTime            m_lastRunTime;
00189 
00190     Vamp::RealTime            m_lastEventSendTime;
00191     bool                      m_haveLastEventSendTime;
00192 
00193     QMutex                    m_processLock;
00194 
00195     typedef std::set<DSSIPluginInstance *> PluginSet;
00196     typedef std::map<QString, PluginSet> GroupMap;
00197     static GroupMap m_groupMap;
00198     static snd_seq_event_t **m_groupLocalEventBuffers;
00199     static size_t m_groupLocalEventBufferCount;
00200 
00201     static Scavenger<ScavengerArrayWrapper<snd_seq_event_t *> > m_bufferScavenger;
00202 
00203     class NonRTPluginThread : public Thread
00204     {
00205     public:
00206         NonRTPluginThread(LADSPA_Handle handle,
00207                           void (*runFunction)(LADSPA_Handle)) :
00208             m_handle(handle),
00209             m_runFunction(runFunction),
00210             m_exiting(false) { }
00211 
00212         virtual void run();
00213         void setExiting() { m_exiting = true; }
00214 
00215     protected:
00216         LADSPA_Handle m_handle;
00217         void (*m_runFunction)(LADSPA_Handle);
00218         bool m_exiting;
00219     };
00220     static std::map<LADSPA_Handle, std::set<NonRTPluginThread *> > m_threads;
00221 };
00222 
00223 #endif // _DSSIPLUGININSTANCE_H_
00224