/[svn]/linuxsampler/trunk/src/engines/gig/EngineChannel.cpp
ViewVC logotype

Annotation of /linuxsampler/trunk/src/engines/gig/EngineChannel.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 424 - (hide annotations) (download)
Fri Mar 4 22:54:11 2005 UTC (19 years ago) by schoenebeck
File size: 15907 byte(s)
* implemented MIDI Control Change 7 (Volume)
* implemented MIDI Control Change 10 (Panpot)

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     #include "EngineChannel.h"
25    
26     namespace LinuxSampler { namespace gig {
27    
28     EngineChannel::EngineChannel() {
29     pMIDIKeyInfo = new midi_key_info_t[128];
30     pEngine = NULL;
31     pInstrument = NULL;
32     pEventQueue = new RingBuffer<Event>(MAX_EVENTS_PER_FRAGMENT, 0);
33     pActiveKeys = new Pool<uint>(128);
34     for (uint i = 0; i < 128; i++) {
35     pMIDIKeyInfo[i].pActiveVoices = NULL; // we allocate when we retrieve the right Engine object
36     pMIDIKeyInfo[i].KeyPressed = false;
37     pMIDIKeyInfo[i].Active = false;
38     pMIDIKeyInfo[i].ReleaseTrigger = false;
39     pMIDIKeyInfo[i].pEvents = NULL; // we allocate when we retrieve the right Engine object
40     }
41     InstrumentIdx = -1;
42     InstrumentStat = -1;
43     AudioDeviceChannelLeft = -1;
44     AudioDeviceChannelRight = -1;
45     }
46    
47     EngineChannel::~EngineChannel() {
48     if (pInstrument) Engine::instruments.HandBack(pInstrument, this);
49     for (uint i = 0; i < 128; i++) {
50     if (pMIDIKeyInfo[i].pActiveVoices) {
51     pMIDIKeyInfo[i].pActiveVoices->clear();
52     delete pMIDIKeyInfo[i].pActiveVoices;
53     }
54     if (pMIDIKeyInfo[i].pEvents) {
55     pMIDIKeyInfo[i].pEvents->clear();
56     delete pMIDIKeyInfo[i].pEvents;
57     }
58     }
59     if (pEventQueue) delete pEventQueue;
60     if (pActiveKeys) delete pActiveKeys;
61     if (pMIDIKeyInfo) delete[] pMIDIKeyInfo;
62     }
63    
64     /**
65     * This method is not thread safe!
66     */
67     void EngineChannel::ResetInternal() {
68     Pitch = 0;
69     SustainPedal = false;
70     GlobalVolume = 1.0;
71 schoenebeck 424 GlobalPanLeft = 1.0f;
72     GlobalPanRight = 1.0f;
73 schoenebeck 411 CurrentKeyDimension = 0;
74    
75     // set all MIDI controller values to zero
76     memset(ControllerTable, 0x00, 128);
77    
78 schoenebeck 412 // reset voice stealing parameters
79     itLastStolenVoice = RTList<Voice>::Iterator();
80     iuiLastStolenKey = RTList<uint>::Iterator();
81    
82 schoenebeck 411 // reset key info
83     for (uint i = 0; i < 128; i++) {
84     if (pMIDIKeyInfo[i].pActiveVoices)
85     pMIDIKeyInfo[i].pActiveVoices->clear();
86     if (pMIDIKeyInfo[i].pEvents)
87     pMIDIKeyInfo[i].pEvents->clear();
88     pMIDIKeyInfo[i].KeyPressed = false;
89     pMIDIKeyInfo[i].Active = false;
90     pMIDIKeyInfo[i].ReleaseTrigger = false;
91     pMIDIKeyInfo[i].itSelf = Pool<uint>::Iterator();
92     }
93    
94     // reset all key groups
95     std::map<uint,uint*>::iterator iter = ActiveKeyGroups.begin();
96     for (; iter != ActiveKeyGroups.end(); iter++) iter->second = NULL;
97    
98     // free all active keys
99     pActiveKeys->clear();
100    
101     // delete all input events
102     pEventQueue->init();
103    
104     if (pEngine) pEngine->ResetInternal();
105     }
106    
107     LinuxSampler::Engine* EngineChannel::GetEngine() {
108     return pEngine;
109     }
110    
111     /**
112     * More or less a workaround to set the instrument name, index and load
113     * status variable to zero percent immediately, that is without blocking
114     * the calling thread. It might be used in future for other preparations
115     * as well though.
116     *
117     * @param FileName - file name of the Gigasampler instrument file
118     * @param Instrument - index of the instrument in the .gig file
119     * @see LoadInstrument()
120     */
121     void EngineChannel::PrepareLoadInstrument(const char* FileName, uint Instrument) {
122     InstrumentFile = FileName;
123     InstrumentIdx = Instrument;
124     InstrumentStat = 0;
125     }
126    
127     /**
128     * Load an instrument from a .gig file. PrepareLoadInstrument() has to
129     * be called first to provide the information which instrument to load.
130     * This method will then actually start to load the instrument and block
131     * the calling thread until loading was completed.
132     *
133     * @returns detailed description of the method call result
134     * @see PrepareLoadInstrument()
135     */
136     void EngineChannel::LoadInstrument() {
137    
138     if (pEngine) pEngine->DisableAndLock();
139    
140     ResetInternal();
141    
142     // free old instrument
143     if (pInstrument) {
144     // give old instrument back to instrument manager
145     Engine::instruments.HandBack(pInstrument, this);
146     }
147    
148     // delete all key groups
149     ActiveKeyGroups.clear();
150    
151     // request gig instrument from instrument manager
152     try {
153     instrument_id_t instrid;
154     instrid.FileName = InstrumentFile;
155     instrid.iInstrument = InstrumentIdx;
156     pInstrument = Engine::instruments.Borrow(instrid, this);
157     if (!pInstrument) {
158     InstrumentStat = -1;
159     dmsg(1,("no instrument loaded!!!\n"));
160     exit(EXIT_FAILURE);
161     }
162     }
163     catch (RIFF::Exception e) {
164     InstrumentStat = -2;
165     String msg = "gig::Engine error: Failed to load instrument, cause: " + e.Message;
166     throw LinuxSamplerException(msg);
167     }
168     catch (InstrumentResourceManagerException e) {
169     InstrumentStat = -3;
170     String msg = "gig::Engine error: Failed to load instrument, cause: " + e.Message();
171     throw LinuxSamplerException(msg);
172     }
173     catch (...) {
174     InstrumentStat = -4;
175     throw LinuxSamplerException("gig::Engine error: Failed to load instrument, cause: Unknown exception while trying to parse gig file.");
176     }
177    
178     // rebuild ActiveKeyGroups map with key groups of current instrument
179     for (::gig::Region* pRegion = pInstrument->GetFirstRegion(); pRegion; pRegion = pInstrument->GetNextRegion())
180     if (pRegion->KeyGroup) ActiveKeyGroups[pRegion->KeyGroup] = NULL;
181    
182     InstrumentIdxName = pInstrument->pInfo->Name;
183     InstrumentStat = 100;
184    
185     // inform audio driver for the need of two channels
186     try {
187     if (pEngine && pEngine->pAudioOutputDevice)
188     pEngine->pAudioOutputDevice->AcquireChannels(2); // gig Engine only stereo
189     }
190     catch (AudioOutputException e) {
191     String msg = "Audio output device unable to provide 2 audio channels, cause: " + e.Message();
192     throw LinuxSamplerException(msg);
193     }
194    
195     if (pEngine) pEngine->Enable();
196     }
197    
198     /**
199     * Will be called by the InstrumentResourceManager when the instrument
200     * we are currently using in this engine is going to be updated, so we
201     * can stop playback before that happens.
202     */
203     void EngineChannel::ResourceToBeUpdated(::gig::Instrument* pResource, void*& pUpdateArg) {
204     dmsg(3,("gig::Engine: Received instrument update message.\n"));
205     if (pEngine) pEngine->DisableAndLock();
206     ResetInternal();
207     this->pInstrument = NULL;
208     }
209    
210     /**
211     * Will be called by the InstrumentResourceManager when the instrument
212     * update process was completed, so we can continue with playback.
213     */
214     void EngineChannel::ResourceUpdated(::gig::Instrument* pOldResource, ::gig::Instrument* pNewResource, void* pUpdateArg) {
215     this->pInstrument = pNewResource; //TODO: there are couple of engine parameters we should update here as well if the instrument was updated (see LoadInstrument())
216     if (pEngine) pEngine->Enable();
217     }
218    
219 schoenebeck 412 void EngineChannel::Connect(AudioOutputDevice* pAudioOut) {
220     if (pEngine && pEngine->pAudioOutputDevice != pAudioOut) {
221     DisconnectAudioOutputDevice();
222     }
223 schoenebeck 411 pEngine = Engine::AcquireEngine(this, pAudioOut);
224     ResetInternal();
225     for (uint i = 0; i < 128; i++) {
226     pMIDIKeyInfo[i].pActiveVoices = new RTList<Voice>(pEngine->pVoicePool);
227     pMIDIKeyInfo[i].pEvents = new RTList<Event>(pEngine->pEventPool);
228     }
229     AudioDeviceChannelLeft = 0;
230     AudioDeviceChannelRight = 1;
231     pOutputLeft = pAudioOut->Channel(0)->Buffer();
232     pOutputRight = pAudioOut->Channel(1)->Buffer();
233     }
234    
235     void EngineChannel::DisconnectAudioOutputDevice() {
236     if (pEngine) { // if clause to prevent disconnect loops
237     ResetInternal();
238     for (uint i = 0; i < 128; i++) {
239 schoenebeck 420 if (pMIDIKeyInfo[i].pActiveVoices) {
240     delete pMIDIKeyInfo[i].pActiveVoices;
241     pMIDIKeyInfo[i].pActiveVoices = NULL;
242     }
243     if (pMIDIKeyInfo[i].pEvents) {
244     delete pMIDIKeyInfo[i].pEvents;
245     pMIDIKeyInfo[i].pEvents = NULL;
246     }
247 schoenebeck 411 }
248     Engine* oldEngine = pEngine;
249     AudioOutputDevice* oldAudioDevice = pEngine->pAudioOutputDevice;
250     pEngine = NULL;
251     Engine::FreeEngine(this, oldAudioDevice);
252     AudioDeviceChannelLeft = -1;
253 schoenebeck 412 AudioDeviceChannelRight = -1;
254 schoenebeck 411 }
255     }
256    
257     void EngineChannel::SetOutputChannel(uint EngineAudioChannel, uint AudioDeviceChannel) {
258     if (!pEngine || !pEngine->pAudioOutputDevice) throw AudioOutputException("No audio output device connected yet.");
259    
260     AudioChannel* pChannel = pEngine->pAudioOutputDevice->Channel(AudioDeviceChannel);
261     if (!pChannel) throw AudioOutputException("Invalid audio output device channel " + ToString(AudioDeviceChannel));
262     switch (EngineAudioChannel) {
263     case 0: // left output channel
264     pOutputLeft = pChannel->Buffer();
265     AudioDeviceChannelLeft = AudioDeviceChannel;
266     break;
267     case 1: // right output channel
268     pOutputRight = pChannel->Buffer();
269     AudioDeviceChannelRight = AudioDeviceChannel;
270     break;
271     default:
272     throw AudioOutputException("Invalid engine audio channel " + ToString(EngineAudioChannel));
273     }
274     }
275    
276     int EngineChannel::OutputChannel(uint EngineAudioChannel) {
277     switch (EngineAudioChannel) {
278     case 0: // left channel
279     return AudioDeviceChannelLeft;
280     case 1: // right channel
281     return AudioDeviceChannelRight;
282     default:
283     throw AudioOutputException("Invalid engine audio channel " + ToString(EngineAudioChannel));
284     }
285     }
286    
287     /**
288     * Will be called by the MIDIIn Thread to let the audio thread trigger a new
289     * voice for the given key.
290     *
291     * @param Key - MIDI key number of the triggered key
292     * @param Velocity - MIDI velocity value of the triggered key
293     */
294     void EngineChannel::SendNoteOn(uint8_t Key, uint8_t Velocity) {
295     if (pEngine) {
296     Event event = pEngine->pEventGenerator->CreateEvent();
297     event.Type = Event::type_note_on;
298     event.Param.Note.Key = Key;
299     event.Param.Note.Velocity = Velocity;
300 schoenebeck 412 event.pEngineChannel = this;
301 schoenebeck 411 if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
302 schoenebeck 412 else dmsg(1,("EngineChannel: Input event queue full!"));
303 schoenebeck 411 }
304     }
305    
306     /**
307     * Will be called by the MIDIIn Thread to signal the audio thread to release
308     * voice(s) on the given key.
309     *
310     * @param Key - MIDI key number of the released key
311     * @param Velocity - MIDI release velocity value of the released key
312     */
313     void EngineChannel::SendNoteOff(uint8_t Key, uint8_t Velocity) {
314     if (pEngine) {
315     Event event = pEngine->pEventGenerator->CreateEvent();
316     event.Type = Event::type_note_off;
317     event.Param.Note.Key = Key;
318     event.Param.Note.Velocity = Velocity;
319 schoenebeck 412 event.pEngineChannel = this;
320 schoenebeck 411 if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
321 schoenebeck 412 else dmsg(1,("EngineChannel: Input event queue full!"));
322 schoenebeck 411 }
323     }
324    
325     /**
326     * Will be called by the MIDIIn Thread to signal the audio thread to change
327     * the pitch value for all voices.
328     *
329     * @param Pitch - MIDI pitch value (-8192 ... +8191)
330     */
331     void EngineChannel::SendPitchbend(int Pitch) {
332     if (pEngine) {
333     Event event = pEngine->pEventGenerator->CreateEvent();
334     event.Type = Event::type_pitchbend;
335     event.Param.Pitch.Pitch = Pitch;
336 schoenebeck 412 event.pEngineChannel = this;
337 schoenebeck 411 if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
338 schoenebeck 412 else dmsg(1,("EngineChannel: Input event queue full!"));
339 schoenebeck 411 }
340     }
341    
342     /**
343     * Will be called by the MIDIIn Thread to signal the audio thread that a
344     * continuous controller value has changed.
345     *
346     * @param Controller - MIDI controller number of the occured control change
347     * @param Value - value of the control change
348     */
349     void EngineChannel::SendControlChange(uint8_t Controller, uint8_t Value) {
350     if (pEngine) {
351     Event event = pEngine->pEventGenerator->CreateEvent();
352     event.Type = Event::type_control_change;
353     event.Param.CC.Controller = Controller;
354     event.Param.CC.Value = Value;
355 schoenebeck 412 event.pEngineChannel = this;
356 schoenebeck 411 if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
357 schoenebeck 412 else dmsg(1,("EngineChannel: Input event queue full!"));
358 schoenebeck 411 }
359     }
360    
361     float EngineChannel::Volume() {
362     return GlobalVolume;
363     }
364    
365     void EngineChannel::Volume(float f) {
366     GlobalVolume = f;
367     }
368    
369     uint EngineChannel::Channels() {
370     return 2;
371     }
372    
373     String EngineChannel::InstrumentFileName() {
374     return InstrumentFile;
375     }
376    
377     String EngineChannel::InstrumentName() {
378     return InstrumentIdxName;
379     }
380    
381     int EngineChannel::InstrumentIndex() {
382     return InstrumentIdx;
383     }
384    
385     int EngineChannel::InstrumentStatus() {
386     return InstrumentStat;
387     }
388    
389     }} // namespace LinuxSampler::gig

  ViewVC Help
Powered by ViewVC