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

Annotation of /linuxsampler/trunk/src/engines/gig/Engine.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 738 - (hide annotations) (download) (as text)
Tue Aug 16 17:14:25 2005 UTC (18 years, 7 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 9074 byte(s)
* extensive synthesis optimization: reimplementation of EGs and LFO(s),
  removed synthesis parameter prerendering and the synthesis parameter
  matrix in general, splitting each audio fragment into subfragments now
  where each subfragment uses constant synthesis parameters
  (everything's still very buggy ATM)

1 schoenebeck 53 /***************************************************************************
2     * *
3     * LinuxSampler - modular, streaming capable sampler *
4     * *
5 schoenebeck 56 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 schoenebeck 411 * Copyright (C) 2005 Christian Schoenebeck *
7 schoenebeck 53 * *
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_ENGINE_H__
25     #define __LS_GIG_ENGINE_H__
26    
27     #include "../../common/global.h"
28    
29 schoenebeck 239 #include <map>
30 schoenebeck 505 #include <gig.h>
31 schoenebeck 239
32 schoenebeck 411 #include "EngineGlobals.h"
33 schoenebeck 53 #include "../../common/RingBuffer.h"
34 schoenebeck 271 #include "../../common/Pool.h"
35 schoenebeck 460 #include "../../common/ArrayList.h"
36 schoenebeck 53 #include "../../common/ConditionServer.h"
37     #include "../common/Engine.h"
38     #include "../common/Event.h"
39     #include "../../network/lscp.h"
40 schoenebeck 411 #include "EngineChannel.h"
41 schoenebeck 53
42 schoenebeck 475 // identifier of this sampler engine
43 schoenebeck 727 #define LS_GIG_ENGINE_NAME "GIG"
44 schoenebeck 475
45 schoenebeck 53 namespace LinuxSampler { namespace gig {
46    
47     // just symbol prototyping
48     class Voice;
49     class DiskThread;
50     class InstrumentResourceManager;
51 schoenebeck 411 class midi_key_info_t;
52     class EngineChannel;
53 schoenebeck 53
54     /**
55     * Sampler engine for the Gigasampler format.
56     */
57 schoenebeck 411 class Engine : public LinuxSampler::Engine {
58 persson 438 public:
59 schoenebeck 53 // methods
60     Engine();
61 letz 502 virtual ~Engine();
62 schoenebeck 411 void Connect(AudioOutputDevice* pAudioOut);
63 schoenebeck 53
64 schoenebeck 411 // implementation of abstract methods derived from class 'LinuxSampler::Engine'
65 schoenebeck 412 virtual int RenderAudio(uint Samples);
66 schoenebeck 411 virtual void SendSysex(void* pData, uint Size);
67 schoenebeck 53 virtual void Reset();
68     virtual void Enable();
69     virtual void Disable();
70     virtual uint VoiceCount();
71     virtual uint VoiceCountMax();
72     virtual bool DiskStreamSupported();
73     virtual uint DiskStreamCount();
74     virtual uint DiskStreamCountMax();
75     virtual String DiskStreamBufferFillBytes();
76     virtual String DiskStreamBufferFillPercentage();
77     virtual String Description();
78     virtual String Version();
79 senkov 112 virtual String EngineName();
80 persson 438
81     //protected:
82 schoenebeck 411 static InstrumentResourceManager instruments;
83 schoenebeck 53
84     AudioOutputDevice* pAudioOutputDevice;
85 schoenebeck 225 uint SampleRate; ///< Sample rate of the engines output audio signal (in Hz)
86     uint MaxSamplesPerCycle; ///< Size of each audio output buffer
87 persson 438 DiskThread* pDiskThread;
88 schoenebeck 411 RingBuffer<Event>* pEventQueue; ///< Input event queue for engine global events (e.g. SysEx messages).
89 persson 438 Pool<Voice>* pVoicePool; ///< Contains all voices that can be activated.
90     EventGenerator* pEventGenerator;
91 schoenebeck 271 RTList<Event>* pVoiceStealingQueue; ///< All voice-launching events which had to be postponed due to free voice shortage.
92 schoenebeck 460 RTList<Event>* pGlobalEvents; ///< All engine global events for the current audio fragment (usually only SysEx messages).
93 schoenebeck 411 Pool<Event>* pEventPool; ///< Contains all Event objects that can be used.
94     RingBuffer<uint8_t>* pSysexBuffer; ///< Input buffer for MIDI system exclusive messages.
95 schoenebeck 412 int ActiveVoiceCount; ///< number of currently active voices (this value will be returned for public calls)
96     int ActiveVoiceCountTemp; ///< number of currently active voices (for internal usage, will be used for incrementation)
97 schoenebeck 53 int ActiveVoiceCountMax; ///< the maximum voice usage since application start
98 schoenebeck 663 int VoiceSpawnsLeft; ///< We only allow CONFIG_MAX_VOICES voices to be spawned per audio fragment, we use this variable to ensure this limit.
99 schoenebeck 460 RTList<Voice>::Iterator itLastStolenVoice; ///< Only for voice stealing: points to the last voice which was theft in current audio fragment, NULL otherwise.
100     RTList<uint>::Iterator iuiLastStolenKey; ///< Only for voice stealing: key number of last key on which the last voice was theft in current audio fragment, NULL otherwise.
101 schoenebeck 659 EngineChannel* pLastStolenChannel; ///< Only for voice stealing: points to the engine channel on which the previous voice was stolen in this audio fragment.
102 schoenebeck 649 RTList<Voice>::Iterator itLastStolenVoiceGlobally; ///< Same as itLastStolenVoice, but engine globally
103     RTList<uint>::Iterator iuiLastStolenKeyGlobally; ///< Same as iuiLastStolenKey, but engine globally
104 schoenebeck 53 bool SuspensionRequested;
105     ConditionServer EngineDisabled;
106 persson 438 int8_t ScaleTuning[12]; ///< contains optional detune factors (-64..+63 cents) for all 12 semitones of an octave
107 schoenebeck 411 int MaxFadeOutPos; ///< The last position in an audio fragment to allow an instant fade out (e.g. for voice stealing) without leading to clicks.
108 persson 438 uint32_t RandomSeed; ///< State of the random number generator used by the random dimension.
109 schoenebeck 53
110 schoenebeck 460 void ProcessEvents(EngineChannel* pEngineChannel, uint Samples);
111     void RenderActiveVoices(EngineChannel* pEngineChannel, uint Samples);
112     void RenderStolenVoices(uint Samples);
113     void PostProcess(EngineChannel* pEngineChannel);
114 persson 438 void ClearEventLists();
115 schoenebeck 460 void ImportEvents(uint Samples);
116 schoenebeck 411 void ProcessNoteOn(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent);
117     void ProcessNoteOff(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOffEvent);
118     void ProcessPitchbend(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itPitchbendEvent);
119     void ProcessControlChange(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itControlChangeEvent);
120 schoenebeck 271 void ProcessSysex(Pool<Event>::Iterator& itSysexEvent);
121 schoenebeck 668 Pool<Voice>::Iterator LaunchVoice(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent, int iLayer, bool ReleaseTriggerVoice, bool VoiceStealing, bool HandleKeyGroupConflicts);
122 schoenebeck 473 int StealVoice(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent);
123 schoenebeck 411 void FreeVoice(EngineChannel* pEngineChannel, Pool<Voice>::Iterator& itVoice);
124     void FreeKey(EngineChannel* pEngineChannel, midi_key_info_t* pKey);
125 schoenebeck 53 void ResetInternal();
126 schoenebeck 659 void ResetScaleTuning();
127 schoenebeck 53
128 schoenebeck 411 static Engine* AcquireEngine(LinuxSampler::gig::EngineChannel* pChannel, AudioOutputDevice* pDevice);
129     static void FreeEngine(LinuxSampler::gig::EngineChannel* pChannel, AudioOutputDevice* pDevice);
130    
131     void DisableAndLock(); // FIXME: should at least be protected
132    
133 schoenebeck 53 friend class Voice;
134     private:
135 schoenebeck 460 ArrayList<EngineChannel*> engineChannels; ///< All engine channels of a gig::Engine instance.
136 persson 438
137 schoenebeck 411 static std::map<AudioOutputDevice*,Engine*> engines; ///< All instances of gig::Engine.
138 persson 438
139 schoenebeck 244 uint8_t GSCheckSum(const RingBuffer<uint8_t>::NonVolatileReader AddrReader, uint DataSize);
140     void AdjustScale(int8_t ScaleTunes[12]);
141 schoenebeck 473 void ReleaseAllVoices(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itReleaseEvent);
142     void KillAllVoices(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itKillEvent);
143 persson 630
144     unsigned long FrameTime; ///< Time in frames of the start of the current audio fragment
145 schoenebeck 53 };
146    
147     }} // namespace LinuxSampler::gig
148    
149     #endif // __LS_GIG_ENGINE_H__

  ViewVC Help
Powered by ViewVC