engines/gig/EngineChannel.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005 Christian Schoenebeck                              *
 *                                                                         *
 *   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., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#ifndef __LS_GIG_ENGINECHANNEL_H__
#define __LS_GIG_ENGINECHANNEL_H__

#if DEBUG_HEADERS
# warning EngineChannel.h included
#endif // DEBUG_HEADERS

#include "../common/Event.h"
#include "../common/EngineChannel.h"
#include "EngineGlobals.h"
#include "Engine.h"
#include "Voice.h"
#include "InstrumentResourceManager.h"

namespace LinuxSampler { namespace gig {

    // just symbol prototyping
    class midi_key_info_t;
    class Voice;

    class EngineChannel : public LinuxSampler::EngineChannel, public InstrumentConsumer {
        public:
            EngineChannel();
            virtual ~EngineChannel();

            // implementation of abstract methods derived from interface class 'LinuxSampler::EngineChannel'
            virtual void    PrepareLoadInstrument(const char* FileName, uint Instrument);
            virtual void    LoadInstrument();
            virtual void    SendNoteOn(uint8_t Key, uint8_t Velocity);
            virtual void    SendNoteOff(uint8_t Key, uint8_t Velocity);
            virtual void    SendPitchbend(int Pitch);
            virtual void    SendControlChange(uint8_t Controller, uint8_t Value);
            virtual float   Volume();
            virtual void    Volume(float f);
            virtual uint    Channels();
            virtual void    Connect(AudioOutputDevice* pAudioOut);
            virtual void    DisconnectAudioOutputDevice();
            virtual void    SetOutputChannel(uint EngineAudioChannel, uint AudioDeviceChannel);
            virtual int     OutputChannel(uint EngineAudioChannel);
            virtual String  InstrumentFileName();
            virtual String  InstrumentName();
            virtual int     InstrumentIndex();
            virtual int     InstrumentStatus();
            virtual LinuxSampler::Engine* GetEngine();
            virtual String  EngineName();

            // implementation of abstract methods derived from interface class 'InstrumentConsumer'
            virtual void ResourceToBeUpdated(::gig::Instrument* pResource, void*& pUpdateArg);
            virtual void ResourceUpdated(::gig::Instrument* pOldResource, ::gig::Instrument* pNewResource, void* pUpdateArg);

        //protected:
            Engine*                 pEngine;
            float*                  pOutputLeft;              ///< Audio output channel buffer (left)
            float*                  pOutputRight;             ///< Audio output channel buffer (right)
            int                     AudioDeviceChannelLeft;   ///< audio device channel number to which the left channel is connected to
            int                     AudioDeviceChannelRight;  ///< audio device channel number to which the right channel is connected to
            RingBuffer<Event>*      pEventQueue;              ///< Input event queue.
            RTList<Event>*          pEvents;                  ///< All engine channel specific events for the current audio fragment.
            RTList<Event>*          pCCEvents;                ///< All control change events for the current audio fragment on this engine channel.
            RTList<Event>*          pSynthesisEvents[Event::destination_count]; ///< Events directly affecting synthesis parameters (like pitch, volume and filter).
            uint8_t                 ControllerTable[128];     ///< Reflects the current values (0-127) of all MIDI controllers for this engine / sampler channel.
            midi_key_info_t*        pMIDIKeyInfo;             ///< Contains all active voices sorted by MIDI key number and other informations to the respective MIDI key
            Pool<uint>*             pActiveKeys;              ///< Holds all keys in it's allocation list with active voices.
            std::map<uint,uint*>    ActiveKeyGroups;          ///< Contains active keys (in case they belong to a key group) ordered by key group ID.
            ::gig::Instrument*      pInstrument;
            bool                    SustainPedal;             ///< true if sustain pedal is down
            double                  GlobalVolume;             ///< overall volume (a value < 1.0 means attenuation, a value > 1.0 means amplification)
            float                   GlobalPanLeft;
            float                   GlobalPanRight;
            int                     Pitch;                    ///< Current (absolute) MIDI pitch value.
            int                     CurrentKeyDimension;      ///< Current value (0-127) for the keyboard dimension, altered by pressing a keyswitching key.
            String                  InstrumentFile;
            int                     InstrumentIdx;
            String                  InstrumentIdxName;
            int                     InstrumentStat;
            int                     iEngineIndexSelf;         ///< Reflects the index of this EngineChannel in the Engine's ArrayList.

            void ResetControllers();
            void ClearEventLists();
            void ImportEvents(uint Samples);

            friend class Engine;
            friend class Voice;
            friend class InstrumentResourceManager;

        private:
            void ResetInternal();
    };

}} // namespace LinuxSampler::gig

#endif // __LS_GIG_ENGINECHANNEL_H__
1	schoenebeck	411	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6			* Copyright (C) 2005 Christian Schoenebeck *
7			* *
8			* This program is free software; you can redistribute it and/or modify *
9			* it under the terms of the GNU General Public License as published by *
10			* the Free Software Foundation; either version 2 of the License, or *
11			* (at your option) any later version. *
12			* *
13			* This program is distributed in the hope that it will be useful, *
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16			* GNU General Public License for more details. *
17			* *
18			* You should have received a copy of the GNU General Public License *
19			* along with this program; if not, write to the Free Software *
20			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21			* MA 02111-1307 USA *
22			***************************************************************************/
23
24			#ifndef __LS_GIG_ENGINECHANNEL_H__
25			#define __LS_GIG_ENGINECHANNEL_H__
26
27			#if DEBUG_HEADERS
28			# warning EngineChannel.h included
29			#endif // DEBUG_HEADERS
30
31			#include "../common/Event.h"
32			#include "../common/EngineChannel.h"
33			#include "EngineGlobals.h"
34			#include "Engine.h"
35	schoenebeck	412	#include "Voice.h"
36	schoenebeck	411	#include "InstrumentResourceManager.h"
37
38			namespace LinuxSampler { namespace gig {
39
40	schoenebeck	412	// just symbol prototyping
41	schoenebeck	411	class midi_key_info_t;
42	schoenebeck	412	class Voice;
43	schoenebeck	411
44			class EngineChannel : public LinuxSampler::EngineChannel, public InstrumentConsumer {
45			public:
46			EngineChannel();
47	schoenebeck	460	virtual ~EngineChannel();
48
49	schoenebeck	411	// implementation of abstract methods derived from interface class 'LinuxSampler::EngineChannel'
50			virtual void PrepareLoadInstrument(const char* FileName, uint Instrument);
51			virtual void LoadInstrument();
52			virtual void SendNoteOn(uint8_t Key, uint8_t Velocity);
53			virtual void SendNoteOff(uint8_t Key, uint8_t Velocity);
54			virtual void SendPitchbend(int Pitch);
55	schoenebeck	460	virtual void SendControlChange(uint8_t Controller, uint8_t Value);
56	schoenebeck	411	virtual float Volume();
57			virtual void Volume(float f);
58			virtual uint Channels();
59			virtual void Connect(AudioOutputDevice* pAudioOut);
60			virtual void DisconnectAudioOutputDevice();
61			virtual void SetOutputChannel(uint EngineAudioChannel, uint AudioDeviceChannel);
62			virtual int OutputChannel(uint EngineAudioChannel);
63			virtual String InstrumentFileName();
64			virtual String InstrumentName();
65			virtual int InstrumentIndex();
66			virtual int InstrumentStatus();
67	schoenebeck	460	virtual LinuxSampler::Engine* GetEngine();
68	schoenebeck	475	virtual String EngineName();
69	schoenebeck	411
70			// implementation of abstract methods derived from interface class 'InstrumentConsumer'
71			virtual void ResourceToBeUpdated(::gig::Instrument* pResource, void*& pUpdateArg);
72			virtual void ResourceUpdated(::gig::Instrument* pOldResource, ::gig::Instrument* pNewResource, void* pUpdateArg);
73	schoenebeck	460
74			//protected:
75	schoenebeck	411	Engine* pEngine;
76			float* pOutputLeft; ///< Audio output channel buffer (left)
77			float* pOutputRight; ///< Audio output channel buffer (right)
78			int AudioDeviceChannelLeft; ///< audio device channel number to which the left channel is connected to
79			int AudioDeviceChannelRight; ///< audio device channel number to which the right channel is connected to
80			RingBuffer<Event>* pEventQueue; ///< Input event queue.
81	schoenebeck	460	RTList<Event>* pEvents; ///< All engine channel specific events for the current audio fragment.
82			RTList<Event>* pCCEvents; ///< All control change events for the current audio fragment on this engine channel.
83			RTList<Event>* pSynthesisEvents[Event::destination_count]; ///< Events directly affecting synthesis parameters (like pitch, volume and filter).
84			uint8_t ControllerTable[128]; ///< Reflects the current values (0-127) of all MIDI controllers for this engine / sampler channel.
85	schoenebeck	411	midi_key_info_t* pMIDIKeyInfo; ///< Contains all active voices sorted by MIDI key number and other informations to the respective MIDI key
86	schoenebeck	460	Pool<uint>* pActiveKeys; ///< Holds all keys in it's allocation list with active voices.
87	schoenebeck	411	std::map<uint,uint*> ActiveKeyGroups; ///< Contains active keys (in case they belong to a key group) ordered by key group ID.
88			::gig::Instrument* pInstrument;
89			bool SustainPedal; ///< true if sustain pedal is down
90			double GlobalVolume; ///< overall volume (a value < 1.0 means attenuation, a value > 1.0 means amplification)
91	schoenebeck	424	float GlobalPanLeft;
92			float GlobalPanRight;
93	schoenebeck	411	int Pitch; ///< Current (absolute) MIDI pitch value.
94			int CurrentKeyDimension; ///< Current value (0-127) for the keyboard dimension, altered by pressing a keyswitching key.
95			String InstrumentFile;
96			int InstrumentIdx;
97			String InstrumentIdxName;
98	schoenebeck	412	int InstrumentStat;
99	schoenebeck	460	int iEngineIndexSelf; ///< Reflects the index of this EngineChannel in the Engine's ArrayList.
100	schoenebeck	411
101	schoenebeck	473	void ResetControllers();
102	schoenebeck	460	void ClearEventLists();
103			void ImportEvents(uint Samples);
104
105	schoenebeck	411	friend class Engine;
106			friend class Voice;
107			friend class InstrumentResourceManager;
108	schoenebeck	460
109	schoenebeck	411	private:
110			void ResetInternal();
111			};
112
113			}} // namespace LinuxSampler::gig
114
115			#endif // __LS_GIG_ENGINECHANNEL_H__