/[svn]/linuxsampler/trunk/src/engines/AbstractEngine.h
ViewVC logotype

Contents of /linuxsampler/trunk/src/engines/AbstractEngine.h

Parent Directory Parent Directory | Revision Log Revision Log

Revision 2611 - (show annotations) (download) (as text)
Mon Jun 9 19:20:37 2014 UTC (9 years, 10 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 10063 byte(s) 
* Fixed crash when loading an instrument script.
* Fixed "init" script handler only to be executed once:
  when the script was loaded.
* Fixed aftertouch script event which always had value zero
  and controller number was set to aftertouch value instead.
* gig Engine: Fixed handling of "smartmidi" dimension, which
  was recognized as "unknown" dimension.
* Fixed script function gig_set_dim_zone(): was accessing
  wrong event.
* ls_instr_script command line tool: is now not limited to
  core language scripts, but can now also parse sampler format
  dependent instrument scripts, with the respective specific
  built-in script variables and functions.
* ScriptVM: Fixed runtime behavior of "and" and "or" binary
  script expressions, which also evaluated the right hand side
  of the expression even if the left hand side already failed
  the overall expression semantic to become true.
* Bumped version (1.0.0.svn46).
1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005-2008 Christian Schoenebeck *
7 * Copyright (C) 2009-2013 Christian Schoenebeck and Grigor Iliev *
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 * This program is distributed in the hope that it will be useful, *
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
17 * GNU General Public License for more details. *
18 * *
19 * You should have received a copy of the GNU General Public License *
20 * along with this program; if not, write to the Free Software *
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
22 * MA 02111-1307 USA *
23 ***************************************************************************/
24
25 #ifndef __LS_ABSTRACTENGINE_H__
26 #define __LS_ABSTRACTENGINE_H__
27
28 #include "Engine.h"
29 #include "../common/ArrayList.h"
30 #include "../common/atomic.h"
31 #include "../common/ConditionServer.h"
32 #include "../common/Pool.h"
33 #include "../common/RingBuffer.h"
34 #include "../common/ChangeFlagRelaxed.h"
35 #include "../common/ResourceManager.h"
36 #include "../drivers/audio/AudioOutputDevice.h"
37 #include "common/Event.h"
38 #include "common/SignalUnitRack.h"
39 #include "common/InstrumentScriptVM.h"
40
41 namespace LinuxSampler {
42
43 class AbstractEngineChannel;
44
45 class AbstractEngine: public Engine {
46
47 public:
48 enum Format { GIG = 1, SF2, SFZ };
49 static String GetFormatString(Format f);
50 static AbstractEngine* AcquireEngine(AbstractEngineChannel* pChannel, AudioOutputDevice* pDevice);
51 static void FreeEngine(AbstractEngineChannel* pChannel, AudioOutputDevice* pDevice);
52
53 AbstractEngine();
54 virtual ~AbstractEngine();
55
56 // implementation of abstract methods derived from class 'LinuxSampler::Engine'
57 virtual void SendSysex(void* pData, uint Size, MidiInputPort* pSender) OVERRIDE;
58 virtual void Reset() OVERRIDE;
59 virtual void Enable() OVERRIDE;
60 virtual void Disable() OVERRIDE;
61 virtual uint VoiceCount() OVERRIDE;
62 virtual uint VoiceCountMax() OVERRIDE;
63 virtual String EngineName() OVERRIDE;
64 virtual void AdjustScaleTuning(const int8_t ScaleTunes[12]) OVERRIDE;
65 virtual void GetScaleTuning(int8_t* pScaleTunes) OVERRIDE;
66 virtual void ResetScaleTuning() OVERRIDE;
67
68 virtual Format GetEngineFormat() = 0;
69 virtual void Connect(AudioOutputDevice* pAudioOut) = 0;
70 virtual void DisableAndLock();
71
72 void SetVoiceCount(uint Count);
73
74 /**
75 * Returns event with the given event ID.
76 */
77 RTList<Event>::Iterator EventByID(int id) {
78 return pEventPool->fromID(id);
79 }
80
81 float Random() {
82 RandomSeed = RandomSeed * 1103515245 + 12345; // classic pseudo random number generator
83 return RandomSeed / 4294967296.0f;
84 }
85
86 // Simple array wrapper just to make sure memory is freed
87 // when liblinuxsampler is unloaded
88 class FloatTable {
89 private:
90 const float* array;
91 public:
92 FloatTable(const float* array) : array(array) { }
93 ~FloatTable() { delete[] array; }
94 const float& operator[](int i) const { return array[i]; }
95 };
96
97 static const FloatTable VolumeCurve; ///< Table that maps volume control change values 0..127 to amplitude. Unity gain is at 90.
98 static const FloatTable PanCurve; ///< Table that maps pan control change values 0..128 to right channel amplitude. Unity gain is at 64 (center).
99 static const FloatTable CrossfadeCurve; ///< Table that maps crossfade control change values 0..127 to amplitude. Unity gain is at 127.
100
101 AudioOutputDevice* pAudioOutputDevice;
102
103 //TODO: should be protected
104 AudioChannel* pDedicatedVoiceChannelLeft; ///< encapsulates a special audio rendering buffer (left) for rendering and routing audio on a per voice basis (this is a very special case and only used for voices which lie on a note which was set with individual, dedicated FX send level)
105 AudioChannel* pDedicatedVoiceChannelRight; ///< encapsulates a special audio rendering buffer (right) for rendering and routing audio on a per voice basis (this is a very special case and only used for voices which lie on a note which was set with individual, dedicated FX send level)
106
107 friend class AbstractVoice;
108 friend class AbstractEngineChannel;
109 template<class V, class R, class I> friend class EngineChannelBase;
110 template<class EC, class R, class S, class D> friend class VoiceBase;
111
112 //protected:
113 ArrayList<EngineChannel*> engineChannels; ///< All engine channels of a Engine instance.
114 ConditionServer EngineDisabled;
115 int8_t ScaleTuning[12]; ///< contains optional detune factors (-64..+63 cents) for all 12 semitones of an octave
116 ChangeFlagRelaxed ScaleTuningChanged; ///< Boolean flag indicating whenever ScaleTuning has been modified by a foreign thread (i.e. by API).
117 RingBuffer<Event,false>* pEventQueue; ///< Input event queue for engine global events (e.g. SysEx messages).
118 EventGenerator* pEventGenerator;
119 RTList<Event>* pGlobalEvents; ///< All engine global events for the current audio fragment (usually only SysEx messages).
120 Pool<Event>* pEventPool; ///< Contains all Event objects that can be used.
121 RingBuffer<uint8_t,false>* pSysexBuffer; ///< Input buffer for MIDI system exclusive messages.
122 uint SampleRate; ///< Sample rate of the engines output audio signal (in Hz)
123 uint MaxSamplesPerCycle; ///< Size of each audio output buffer
124 unsigned long FrameTime; ///< Time in frames of the start of the current audio fragment
125 int ActiveVoiceCountMax; ///< the maximum voice usage since application start
126 atomic_t ActiveVoiceCount; ///< number of currently active voices
127 int VoiceSpawnsLeft; ///< We only allow CONFIG_MAX_VOICES voices to be spawned per audio fragment, we use this variable to ensure this limit.
128 InstrumentScriptVM* pScriptVM; ///< Real-time instrument script virtual machine runner for this engine.
129
130 void RouteAudio(EngineChannel* pEngineChannel, uint Samples);
131 void RouteDedicatedVoiceChannels(EngineChannel* pEngineChannel, optional<float> FxSendLevels[2], uint Samples);
132 void ClearEventLists();
133 void ImportEvents(uint Samples);
134 void ProcessSysex(Pool<Event>::Iterator& itSysexEvent);
135 void ProcessPitchbend(AbstractEngineChannel* pEngineChannel, Pool<Event>::Iterator& itPitchbendEvent);
136
137 void ProcessFxSendControllers (
138 AbstractEngineChannel* pEngineChannel,
139 Pool<Event>::Iterator& itControlChangeEvent
140 );
141
142 uint8_t GSCheckSum(const RingBuffer<uint8_t,false>::NonVolatileReader AddrReader, uint DataSize);
143
144 virtual void ResetInternal() = 0;
145 virtual void KillAllVoices(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itKillEvent) = 0;
146 virtual void ProcessNoteOn(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent) = 0;
147 virtual void ProcessNoteOff(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOffEvent) = 0;
148 virtual void ProcessControlChange(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itControlChangeEvent) = 0;
149 virtual void ProcessChannelPressure(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itChannelPressureEvent) = 0;
150 virtual void ProcessPolyphonicKeyPressure(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNotePressureEvent) = 0;
151 virtual int GetMinFadeOutSamples() = 0;
152 virtual void CreateInstrumentScriptVM();
153
154 private:
155 static std::map<Format, std::map<AudioOutputDevice*,AbstractEngine*> > engines;
156 uint32_t RandomSeed; ///< State of the random number generator used by the random dimension.
157
158 static float* InitVolumeCurve();
159 static float* InitPanCurve();
160 static float* InitCrossfadeCurve();
161 static float* InitCurve(const float* segments, int size = 128);
162
163 bool RouteFxSend(FxSend* pFxSend, AudioChannel* ppSource[2], float FxSendLevel, uint Samples);
164 };
165
166 } // namespace LinuxSampler
167
168 #endif /* __LS_ABSTRACTENGINE_H__ */
169
  ViewVC Help
Powered by ViewVC