/[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 1298 - (hide annotations) (download)
Fri Aug 17 12:55:37 2007 UTC (16 years, 7 months ago) by iliev
File size: 31744 byte(s)
* ensure that a notification event is sent when already
  loaded instrument is assigned to another sampler channel

1 schoenebeck 411 /***************************************************************************
2     * *
3     * LinuxSampler - modular, streaming capable sampler *
4     * *
5     * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 schoenebeck 1040 * Copyright (C) 2005 - 2007 Christian Schoenebeck *
7 schoenebeck 411 * *
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 persson 438 namespace LinuxSampler { namespace gig {
27 schoenebeck 411
28     EngineChannel::EngineChannel() {
29     pMIDIKeyInfo = new midi_key_info_t[128];
30     pEngine = NULL;
31     pInstrument = NULL;
32 schoenebeck 460 pEvents = NULL; // we allocate when we retrieve the right Engine object
33 schoenebeck 970 pEventQueue = new RingBuffer<Event,false>(CONFIG_MAX_EVENTS_PER_FRAGMENT, 0);
34 schoenebeck 411 pActiveKeys = new Pool<uint>(128);
35     for (uint i = 0; i < 128; i++) {
36     pMIDIKeyInfo[i].pActiveVoices = NULL; // we allocate when we retrieve the right Engine object
37     pMIDIKeyInfo[i].KeyPressed = false;
38     pMIDIKeyInfo[i].Active = false;
39     pMIDIKeyInfo[i].ReleaseTrigger = false;
40     pMIDIKeyInfo[i].pEvents = NULL; // we allocate when we retrieve the right Engine object
41 schoenebeck 473 pMIDIKeyInfo[i].VoiceTheftsQueued = 0;
42 persson 438 pMIDIKeyInfo[i].RoundRobinIndex = 0;
43 schoenebeck 411 }
44     InstrumentIdx = -1;
45     InstrumentStat = -1;
46 schoenebeck 1001 pChannelLeft = NULL;
47     pChannelRight = NULL;
48 schoenebeck 411 AudioDeviceChannelLeft = -1;
49     AudioDeviceChannelRight = -1;
50 schoenebeck 675 pMidiInputPort = NULL;
51     midiChannel = midi_chan_all;
52 schoenebeck 670 ResetControllers();
53 schoenebeck 829 SoloMode = false;
54     PortamentoMode = false;
55     PortamentoTime = CONFIG_PORTAMENTO_TIME_DEFAULT;
56 schoenebeck 411 }
57    
58     EngineChannel::~EngineChannel() {
59 schoenebeck 460 DisconnectAudioOutputDevice();
60 schoenebeck 411 if (pInstrument) Engine::instruments.HandBack(pInstrument, this);
61     if (pEventQueue) delete pEventQueue;
62     if (pActiveKeys) delete pActiveKeys;
63     if (pMIDIKeyInfo) delete[] pMIDIKeyInfo;
64 schoenebeck 1001 RemoveAllFxSends();
65 schoenebeck 411 }
66    
67     /**
68 schoenebeck 660 * Implementation of virtual method from abstract EngineChannel interface.
69     * This method will periodically be polled (e.g. by the LSCP server) to
70     * check if some engine channel parameter has changed since the last
71     * StatusChanged() call.
72     *
73 schoenebeck 670 * This method can also be used to mark the engine channel as changed
74     * from outside, e.g. by a MIDI input device. The optional argument
75     * \a nNewStatus can be used for this.
76     *
77 schoenebeck 660 * TODO: This "poll method" is just a lazy solution and might be
78     * replaced in future.
79 schoenebeck 670 * @param bNewStatus - (optional, default: false) sets the new status flag
80 schoenebeck 660 * @returns true if engine channel status has changed since last
81     * StatusChanged() call
82     */
83 schoenebeck 670 bool EngineChannel::StatusChanged(bool bNewStatus) {
84 schoenebeck 660 bool b = bStatusChanged;
85 schoenebeck 670 bStatusChanged = bNewStatus;
86 schoenebeck 660 return b;
87     }
88    
89 schoenebeck 670 void EngineChannel::Reset() {
90     if (pEngine) pEngine->DisableAndLock();
91     ResetInternal();
92     ResetControllers();
93     if (pEngine) {
94     pEngine->Enable();
95     pEngine->Reset();
96     }
97     }
98    
99 schoenebeck 660 /**
100 schoenebeck 411 * This method is not thread safe!
101     */
102     void EngineChannel::ResetInternal() {
103     CurrentKeyDimension = 0;
104    
105     // reset key info
106     for (uint i = 0; i < 128; i++) {
107     if (pMIDIKeyInfo[i].pActiveVoices)
108     pMIDIKeyInfo[i].pActiveVoices->clear();
109     if (pMIDIKeyInfo[i].pEvents)
110     pMIDIKeyInfo[i].pEvents->clear();
111     pMIDIKeyInfo[i].KeyPressed = false;
112     pMIDIKeyInfo[i].Active = false;
113     pMIDIKeyInfo[i].ReleaseTrigger = false;
114     pMIDIKeyInfo[i].itSelf = Pool<uint>::Iterator();
115 schoenebeck 473 pMIDIKeyInfo[i].VoiceTheftsQueued = 0;
116 schoenebeck 411 }
117 schoenebeck 829 SoloKey = -1; // no solo key active yet
118     PortamentoPos = -1.0f; // no portamento active yet
119 schoenebeck 411
120     // reset all key groups
121     std::map<uint,uint*>::iterator iter = ActiveKeyGroups.begin();
122     for (; iter != ActiveKeyGroups.end(); iter++) iter->second = NULL;
123    
124     // free all active keys
125     pActiveKeys->clear();
126    
127     // delete all input events
128     pEventQueue->init();
129    
130     if (pEngine) pEngine->ResetInternal();
131 schoenebeck 660
132     // status of engine channel has changed, so set notify flag
133     bStatusChanged = true;
134 schoenebeck 411 }
135    
136     LinuxSampler::Engine* EngineChannel::GetEngine() {
137     return pEngine;
138     }
139    
140     /**
141     * More or less a workaround to set the instrument name, index and load
142     * status variable to zero percent immediately, that is without blocking
143     * the calling thread. It might be used in future for other preparations
144     * as well though.
145     *
146     * @param FileName - file name of the Gigasampler instrument file
147     * @param Instrument - index of the instrument in the .gig file
148     * @see LoadInstrument()
149     */
150     void EngineChannel::PrepareLoadInstrument(const char* FileName, uint Instrument) {
151     InstrumentFile = FileName;
152     InstrumentIdx = Instrument;
153     InstrumentStat = 0;
154     }
155    
156     /**
157     * Load an instrument from a .gig file. PrepareLoadInstrument() has to
158     * be called first to provide the information which instrument to load.
159     * This method will then actually start to load the instrument and block
160     * the calling thread until loading was completed.
161     *
162     * @see PrepareLoadInstrument()
163     */
164     void EngineChannel::LoadInstrument() {
165 persson 1038 ::gig::Instrument* oldInstrument = pInstrument;
166 schoenebeck 411
167 persson 1038 // free old instrument
168     if (oldInstrument) {
169     if (pEngine) {
170     // make sure we don't trigger any new notes with the
171     // old instrument
172     ::gig::DimensionRegion** dimRegionsInUse = pEngine->ChangeInstrument(this, 0);
173 persson 438
174 persson 1038 // give old instrument back to instrument manager, but
175     // keep the dimension regions and samples that are in
176     // use
177     Engine::instruments.HandBackInstrument(oldInstrument, this, dimRegionsInUse);
178     } else {
179     Engine::instruments.HandBack(oldInstrument, this);
180     }
181 schoenebeck 411 }
182    
183     // delete all key groups
184     ActiveKeyGroups.clear();
185    
186     // request gig instrument from instrument manager
187 persson 1038 ::gig::Instrument* newInstrument;
188 schoenebeck 411 try {
189 schoenebeck 947 InstrumentManager::instrument_id_t instrid;
190     instrid.FileName = InstrumentFile;
191     instrid.Index = InstrumentIdx;
192 persson 1038 newInstrument = Engine::instruments.Borrow(instrid, this);
193     if (!newInstrument) {
194 schoenebeck 1212 throw InstrumentManagerException("resource was not created");
195 schoenebeck 411 }
196     }
197     catch (RIFF::Exception e) {
198     InstrumentStat = -2;
199     String msg = "gig::Engine error: Failed to load instrument, cause: " + e.Message;
200 schoenebeck 880 throw Exception(msg);
201 schoenebeck 411 }
202 schoenebeck 1212 catch (InstrumentManagerException e) {
203 schoenebeck 411 InstrumentStat = -3;
204     String msg = "gig::Engine error: Failed to load instrument, cause: " + e.Message();
205 schoenebeck 880 throw Exception(msg);
206 schoenebeck 411 }
207     catch (...) {
208     InstrumentStat = -4;
209 schoenebeck 880 throw Exception("gig::Engine error: Failed to load instrument, cause: Unknown exception while trying to parse gig file.");
210 schoenebeck 411 }
211    
212     // rebuild ActiveKeyGroups map with key groups of current instrument
213 persson 1038 for (::gig::Region* pRegion = newInstrument->GetFirstRegion(); pRegion; pRegion = newInstrument->GetNextRegion())
214 schoenebeck 411 if (pRegion->KeyGroup) ActiveKeyGroups[pRegion->KeyGroup] = NULL;
215    
216 persson 1038 InstrumentIdxName = newInstrument->pInfo->Name;
217 schoenebeck 411 InstrumentStat = 100;
218    
219 persson 1038 if (pEngine) pEngine->ChangeInstrument(this, newInstrument);
220     else pInstrument = newInstrument;
221 iliev 1298
222     StatusChanged(true);
223 schoenebeck 411 }
224    
225     /**
226     * Will be called by the InstrumentResourceManager when the instrument
227 schoenebeck 517 * we are currently using on this EngineChannel is going to be updated,
228     * so we can stop playback before that happens.
229 schoenebeck 411 */
230     void EngineChannel::ResourceToBeUpdated(::gig::Instrument* pResource, void*& pUpdateArg) {
231     dmsg(3,("gig::Engine: Received instrument update message.\n"));
232     if (pEngine) pEngine->DisableAndLock();
233     ResetInternal();
234     this->pInstrument = NULL;
235     }
236    
237     /**
238     * Will be called by the InstrumentResourceManager when the instrument
239     * update process was completed, so we can continue with playback.
240     */
241     void EngineChannel::ResourceUpdated(::gig::Instrument* pOldResource, ::gig::Instrument* pNewResource, void* pUpdateArg) {
242     this->pInstrument = pNewResource; //TODO: there are couple of engine parameters we should update here as well if the instrument was updated (see LoadInstrument())
243     if (pEngine) pEngine->Enable();
244 schoenebeck 660 bStatusChanged = true; // status of engine has changed, so set notify flag
245 schoenebeck 411 }
246    
247 schoenebeck 517 /**
248     * Will be called by the InstrumentResourceManager on progress changes
249     * while loading or realoading an instrument for this EngineChannel.
250     *
251     * @param fProgress - current progress as value between 0.0 and 1.0
252     */
253     void EngineChannel::OnResourceProgress(float fProgress) {
254     this->InstrumentStat = int(fProgress * 100.0f);
255     dmsg(7,("gig::EngineChannel: progress %d%", InstrumentStat));
256 schoenebeck 660 bStatusChanged = true; // status of engine has changed, so set notify flag
257 schoenebeck 517 }
258    
259 schoenebeck 412 void EngineChannel::Connect(AudioOutputDevice* pAudioOut) {
260 schoenebeck 460 if (pEngine) {
261     if (pEngine->pAudioOutputDevice == pAudioOut) return;
262 schoenebeck 412 DisconnectAudioOutputDevice();
263     }
264 schoenebeck 411 pEngine = Engine::AcquireEngine(this, pAudioOut);
265 persson 438 ResetInternal();
266 schoenebeck 738 pEvents = new RTList<Event>(pEngine->pEventPool);
267 schoenebeck 411 for (uint i = 0; i < 128; i++) {
268     pMIDIKeyInfo[i].pActiveVoices = new RTList<Voice>(pEngine->pVoicePool);
269     pMIDIKeyInfo[i].pEvents = new RTList<Event>(pEngine->pEventPool);
270     }
271     AudioDeviceChannelLeft = 0;
272     AudioDeviceChannelRight = 1;
273 schoenebeck 1001 if (fxSends.empty()) { // render directly into the AudioDevice's output buffers
274     pChannelLeft = pAudioOut->Channel(AudioDeviceChannelLeft);
275     pChannelRight = pAudioOut->Channel(AudioDeviceChannelRight);
276     } else { // use local buffers for rendering and copy later
277     // ensure the local buffers have the correct size
278     if (pChannelLeft) delete pChannelLeft;
279     if (pChannelRight) delete pChannelRight;
280     pChannelLeft = new AudioChannel(0, pAudioOut->MaxSamplesPerCycle());
281     pChannelRight = new AudioChannel(1, pAudioOut->MaxSamplesPerCycle());
282     }
283 persson 1039 if (pEngine->EngineDisabled.GetUnsafe()) pEngine->Enable();
284 persson 846 MidiInputPort::AddSysexListener(pEngine);
285 schoenebeck 411 }
286    
287     void EngineChannel::DisconnectAudioOutputDevice() {
288     if (pEngine) { // if clause to prevent disconnect loops
289     ResetInternal();
290 schoenebeck 460 if (pEvents) {
291     delete pEvents;
292     pEvents = NULL;
293     }
294 schoenebeck 411 for (uint i = 0; i < 128; i++) {
295 schoenebeck 420 if (pMIDIKeyInfo[i].pActiveVoices) {
296     delete pMIDIKeyInfo[i].pActiveVoices;
297     pMIDIKeyInfo[i].pActiveVoices = NULL;
298     }
299     if (pMIDIKeyInfo[i].pEvents) {
300     delete pMIDIKeyInfo[i].pEvents;
301     pMIDIKeyInfo[i].pEvents = NULL;
302     }
303 schoenebeck 411 }
304     Engine* oldEngine = pEngine;
305     AudioOutputDevice* oldAudioDevice = pEngine->pAudioOutputDevice;
306     pEngine = NULL;
307     Engine::FreeEngine(this, oldAudioDevice);
308     AudioDeviceChannelLeft = -1;
309 persson 438 AudioDeviceChannelRight = -1;
310 schoenebeck 1001 if (!fxSends.empty()) { // free the local rendering buffers
311     if (pChannelLeft) delete pChannelLeft;
312     if (pChannelRight) delete pChannelRight;
313     }
314     pChannelLeft = NULL;
315     pChannelRight = NULL;
316 schoenebeck 411 }
317     }
318    
319 schoenebeck 1001 AudioOutputDevice* EngineChannel::GetAudioOutputDevice() {
320     return (pEngine) ? pEngine->pAudioOutputDevice : NULL;
321     }
322    
323 schoenebeck 411 void EngineChannel::SetOutputChannel(uint EngineAudioChannel, uint AudioDeviceChannel) {
324     if (!pEngine || !pEngine->pAudioOutputDevice) throw AudioOutputException("No audio output device connected yet.");
325 persson 438
326 schoenebeck 411 AudioChannel* pChannel = pEngine->pAudioOutputDevice->Channel(AudioDeviceChannel);
327     if (!pChannel) throw AudioOutputException("Invalid audio output device channel " + ToString(AudioDeviceChannel));
328     switch (EngineAudioChannel) {
329     case 0: // left output channel
330 schoenebeck 1001 if (fxSends.empty()) pChannelLeft = pChannel;
331 schoenebeck 411 AudioDeviceChannelLeft = AudioDeviceChannel;
332     break;
333     case 1: // right output channel
334 schoenebeck 1001 if (fxSends.empty()) pChannelRight = pChannel;
335 schoenebeck 411 AudioDeviceChannelRight = AudioDeviceChannel;
336     break;
337     default:
338     throw AudioOutputException("Invalid engine audio channel " + ToString(EngineAudioChannel));
339     }
340 iliev 1267
341     bStatusChanged = true;
342 schoenebeck 411 }
343    
344     int EngineChannel::OutputChannel(uint EngineAudioChannel) {
345     switch (EngineAudioChannel) {
346     case 0: // left channel
347     return AudioDeviceChannelLeft;
348     case 1: // right channel
349     return AudioDeviceChannelRight;
350     default:
351     throw AudioOutputException("Invalid engine audio channel " + ToString(EngineAudioChannel));
352     }
353     }
354    
355 schoenebeck 675 void EngineChannel::Connect(MidiInputPort* pMidiPort, midi_chan_t MidiChannel) {
356     if (!pMidiPort || pMidiPort == this->pMidiInputPort) return;
357     DisconnectMidiInputPort();
358     this->pMidiInputPort = pMidiPort;
359     this->midiChannel = MidiChannel;
360     pMidiPort->Connect(this, MidiChannel);
361     }
362    
363     void EngineChannel::DisconnectMidiInputPort() {
364     MidiInputPort* pOldPort = this->pMidiInputPort;
365     this->pMidiInputPort = NULL;
366     if (pOldPort) pOldPort->Disconnect(this);
367     }
368    
369     MidiInputPort* EngineChannel::GetMidiInputPort() {
370     return pMidiInputPort;
371     }
372    
373     midi_chan_t EngineChannel::MidiChannel() {
374     return midiChannel;
375     }
376    
377 schoenebeck 1001 FxSend* EngineChannel::AddFxSend(uint8_t MidiCtrl, String Name) throw (Exception) {
378     if (pEngine) pEngine->DisableAndLock();
379     FxSend* pFxSend = new FxSend(this, MidiCtrl, Name);
380     if (fxSends.empty()) {
381     if (pEngine && pEngine->pAudioOutputDevice) {
382     AudioOutputDevice* pDevice = pEngine->pAudioOutputDevice;
383     // create local render buffers
384     pChannelLeft = new AudioChannel(0, pDevice->MaxSamplesPerCycle());
385     pChannelRight = new AudioChannel(1, pDevice->MaxSamplesPerCycle());
386     } else {
387     // postpone local render buffer creation until audio device is assigned
388     pChannelLeft = NULL;
389     pChannelRight = NULL;
390     }
391     }
392     fxSends.push_back(pFxSend);
393     if (pEngine) pEngine->Enable();
394 iliev 1130 fireFxSendCountChanged(iSamplerChannelIndex, GetFxSendCount());
395    
396 schoenebeck 1001 return pFxSend;
397     }
398    
399     FxSend* EngineChannel::GetFxSend(uint FxSendIndex) {
400     return (FxSendIndex < fxSends.size()) ? fxSends[FxSendIndex] : NULL;
401     }
402    
403     uint EngineChannel::GetFxSendCount() {
404     return fxSends.size();
405     }
406    
407     void EngineChannel::RemoveFxSend(FxSend* pFxSend) {
408     if (pEngine) pEngine->DisableAndLock();
409     for (
410     std::vector<FxSend*>::iterator iter = fxSends.begin();
411     iter != fxSends.end(); iter++
412     ) {
413     if (*iter == pFxSend) {
414     delete pFxSend;
415     fxSends.erase(iter);
416     if (fxSends.empty()) {
417     // destroy local render buffers
418     if (pChannelLeft) delete pChannelLeft;
419     if (pChannelRight) delete pChannelRight;
420     // fallback to render directly into AudioOutputDevice's buffers
421     if (pEngine && pEngine->pAudioOutputDevice) {
422     pChannelLeft = pEngine->pAudioOutputDevice->Channel(AudioDeviceChannelLeft);
423     pChannelRight = pEngine->pAudioOutputDevice->Channel(AudioDeviceChannelRight);
424     } else { // we update the pointers later
425     pChannelLeft = NULL;
426     pChannelRight = NULL;
427     }
428     }
429     break;
430     }
431     }
432     if (pEngine) pEngine->Enable();
433 iliev 1130 fireFxSendCountChanged(iSamplerChannelIndex, GetFxSendCount());
434 schoenebeck 1001 }
435    
436 schoenebeck 411 /**
437     * Will be called by the MIDIIn Thread to let the audio thread trigger a new
438 schoenebeck 906 * voice for the given key. This method is meant for real time rendering,
439     * that is an event will immediately be created with the current system
440     * time as time stamp.
441 schoenebeck 411 *
442     * @param Key - MIDI key number of the triggered key
443     * @param Velocity - MIDI velocity value of the triggered key
444     */
445     void EngineChannel::SendNoteOn(uint8_t Key, uint8_t Velocity) {
446     if (pEngine) {
447     Event event = pEngine->pEventGenerator->CreateEvent();
448     event.Type = Event::type_note_on;
449     event.Param.Note.Key = Key;
450     event.Param.Note.Velocity = Velocity;
451 persson 438 event.pEngineChannel = this;
452 schoenebeck 411 if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
453 schoenebeck 412 else dmsg(1,("EngineChannel: Input event queue full!"));
454 schoenebeck 411 }
455     }
456    
457     /**
458 schoenebeck 906 * Will be called by the MIDIIn Thread to let the audio thread trigger a new
459     * voice for the given key. This method is meant for offline rendering
460     * and / or for cases where the exact position of the event in the current
461     * audio fragment is already known.
462     *
463     * @param Key - MIDI key number of the triggered key
464     * @param Velocity - MIDI velocity value of the triggered key
465     * @param FragmentPos - sample point position in the current audio
466     * fragment to which this event belongs to
467     */
468     void EngineChannel::SendNoteOn(uint8_t Key, uint8_t Velocity, int32_t FragmentPos) {
469     if (FragmentPos < 0) {
470     dmsg(1,("EngineChannel::SendNoteOn(): negative FragmentPos! Seems MIDI driver is buggy!"));
471     }
472     else if (pEngine) {
473     Event event = pEngine->pEventGenerator->CreateEvent(FragmentPos);
474     event.Type = Event::type_note_on;
475     event.Param.Note.Key = Key;
476     event.Param.Note.Velocity = Velocity;
477     event.pEngineChannel = this;
478     if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
479     else dmsg(1,("EngineChannel: Input event queue full!"));
480     }
481     }
482    
483     /**
484 schoenebeck 411 * Will be called by the MIDIIn Thread to signal the audio thread to release
485 schoenebeck 906 * voice(s) on the given key. This method is meant for real time rendering,
486     * that is an event will immediately be created with the current system
487     * time as time stamp.
488 schoenebeck 411 *
489     * @param Key - MIDI key number of the released key
490     * @param Velocity - MIDI release velocity value of the released key
491     */
492     void EngineChannel::SendNoteOff(uint8_t Key, uint8_t Velocity) {
493     if (pEngine) {
494     Event event = pEngine->pEventGenerator->CreateEvent();
495     event.Type = Event::type_note_off;
496     event.Param.Note.Key = Key;
497     event.Param.Note.Velocity = Velocity;
498 schoenebeck 412 event.pEngineChannel = this;
499 schoenebeck 411 if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
500 schoenebeck 412 else dmsg(1,("EngineChannel: Input event queue full!"));
501 schoenebeck 411 }
502     }
503    
504     /**
505 schoenebeck 906 * Will be called by the MIDIIn Thread to signal the audio thread to release
506     * voice(s) on the given key. This method is meant for offline rendering
507     * and / or for cases where the exact position of the event in the current
508     * audio fragment is already known.
509     *
510     * @param Key - MIDI key number of the released key
511     * @param Velocity - MIDI release velocity value of the released key
512     * @param FragmentPos - sample point position in the current audio
513     * fragment to which this event belongs to
514     */
515     void EngineChannel::SendNoteOff(uint8_t Key, uint8_t Velocity, int32_t FragmentPos) {
516     if (FragmentPos < 0) {
517     dmsg(1,("EngineChannel::SendNoteOff(): negative FragmentPos! Seems MIDI driver is buggy!"));
518     }
519     else if (pEngine) {
520     Event event = pEngine->pEventGenerator->CreateEvent(FragmentPos);
521     event.Type = Event::type_note_off;
522     event.Param.Note.Key = Key;
523     event.Param.Note.Velocity = Velocity;
524     event.pEngineChannel = this;
525     if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
526     else dmsg(1,("EngineChannel: Input event queue full!"));
527     }
528     }
529    
530     /**
531 schoenebeck 411 * Will be called by the MIDIIn Thread to signal the audio thread to change
532 schoenebeck 906 * the pitch value for all voices. This method is meant for real time
533     * rendering, that is an event will immediately be created with the
534     * current system time as time stamp.
535 schoenebeck 411 *
536     * @param Pitch - MIDI pitch value (-8192 ... +8191)
537     */
538     void EngineChannel::SendPitchbend(int Pitch) {
539 persson 438 if (pEngine) {
540 schoenebeck 411 Event event = pEngine->pEventGenerator->CreateEvent();
541     event.Type = Event::type_pitchbend;
542     event.Param.Pitch.Pitch = Pitch;
543 schoenebeck 412 event.pEngineChannel = this;
544 schoenebeck 411 if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
545 schoenebeck 412 else dmsg(1,("EngineChannel: Input event queue full!"));
546 schoenebeck 411 }
547     }
548    
549     /**
550 schoenebeck 906 * Will be called by the MIDIIn Thread to signal the audio thread to change
551     * the pitch value for all voices. This method is meant for offline
552     * rendering and / or for cases where the exact position of the event in
553     * the current audio fragment is already known.
554     *
555     * @param Pitch - MIDI pitch value (-8192 ... +8191)
556     * @param FragmentPos - sample point position in the current audio
557     * fragment to which this event belongs to
558     */
559     void EngineChannel::SendPitchbend(int Pitch, int32_t FragmentPos) {
560     if (FragmentPos < 0) {
561     dmsg(1,("EngineChannel::SendPitchBend(): negative FragmentPos! Seems MIDI driver is buggy!"));
562     }
563     else if (pEngine) {
564     Event event = pEngine->pEventGenerator->CreateEvent(FragmentPos);
565     event.Type = Event::type_pitchbend;
566     event.Param.Pitch.Pitch = Pitch;
567     event.pEngineChannel = this;
568     if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
569     else dmsg(1,("EngineChannel: Input event queue full!"));
570     }
571     }
572    
573     /**
574 schoenebeck 411 * Will be called by the MIDIIn Thread to signal the audio thread that a
575 schoenebeck 906 * continuous controller value has changed. This method is meant for real
576     * time rendering, that is an event will immediately be created with the
577     * current system time as time stamp.
578 schoenebeck 411 *
579     * @param Controller - MIDI controller number of the occured control change
580     * @param Value - value of the control change
581     */
582     void EngineChannel::SendControlChange(uint8_t Controller, uint8_t Value) {
583     if (pEngine) {
584     Event event = pEngine->pEventGenerator->CreateEvent();
585     event.Type = Event::type_control_change;
586     event.Param.CC.Controller = Controller;
587     event.Param.CC.Value = Value;
588 schoenebeck 412 event.pEngineChannel = this;
589 schoenebeck 411 if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
590 schoenebeck 412 else dmsg(1,("EngineChannel: Input event queue full!"));
591 schoenebeck 411 }
592     }
593    
594 schoenebeck 906 /**
595     * Will be called by the MIDIIn Thread to signal the audio thread that a
596     * continuous controller value has changed. This method is meant for
597     * offline rendering and / or for cases where the exact position of the
598     * event in the current audio fragment is already known.
599     *
600     * @param Controller - MIDI controller number of the occured control change
601     * @param Value - value of the control change
602     * @param FragmentPos - sample point position in the current audio
603     * fragment to which this event belongs to
604     */
605     void EngineChannel::SendControlChange(uint8_t Controller, uint8_t Value, int32_t FragmentPos) {
606     if (FragmentPos < 0) {
607     dmsg(1,("EngineChannel::SendControlChange(): negative FragmentPos! Seems MIDI driver is buggy!"));
608     }
609     else if (pEngine) {
610     Event event = pEngine->pEventGenerator->CreateEvent(FragmentPos);
611     event.Type = Event::type_control_change;
612     event.Param.CC.Controller = Controller;
613     event.Param.CC.Value = Value;
614     event.pEngineChannel = this;
615     if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
616     else dmsg(1,("EngineChannel: Input event queue full!"));
617     }
618     }
619    
620 schoenebeck 460 void EngineChannel::ClearEventLists() {
621     pEvents->clear();
622     // empty MIDI key specific event lists
623     {
624     RTList<uint>::Iterator iuiKey = pActiveKeys->first();
625     RTList<uint>::Iterator end = pActiveKeys->end();
626     for(; iuiKey != end; ++iuiKey) {
627     pMIDIKeyInfo[*iuiKey].pEvents->clear(); // free all events on the key
628     }
629     }
630     }
631    
632 schoenebeck 473 void EngineChannel::ResetControllers() {
633 schoenebeck 670 Pitch = 0;
634     SustainPedal = false;
635 iliev 776 SostenutoPedal = false;
636 schoenebeck 1005 GlobalVolume = 1.0f;
637 schoenebeck 947 MidiVolume = 1.0;
638 schoenebeck 670 GlobalPanLeft = 1.0f;
639     GlobalPanRight = 1.0f;
640 schoenebeck 1041 GlobalTranspose = 0;
641 schoenebeck 473 // set all MIDI controller values to zero
642 persson 903 memset(ControllerTable, 0x00, 129);
643 schoenebeck 1040 // reset all FX Send levels
644     for (
645     std::vector<FxSend*>::iterator iter = fxSends.begin();
646     iter != fxSends.end(); iter++
647     ) {
648     (*iter)->Reset();
649     }
650 schoenebeck 473 }
651    
652 schoenebeck 460 /**
653     * Copy all events from the engine channel's input event queue buffer to
654     * the internal event list. This will be done at the beginning of each
655     * audio cycle (that is each RenderAudio() call) to distinguish all
656     * events which have to be processed in the current audio cycle. Each
657     * EngineChannel has it's own input event queue for the common channel
658     * specific events (like NoteOn, NoteOff and ControlChange events).
659     * Beside that, the engine also has a input event queue for global
660     * events (usually SysEx messages).
661     *
662     * @param Samples - number of sample points to be processed in the
663     * current audio cycle
664     */
665     void EngineChannel::ImportEvents(uint Samples) {
666 schoenebeck 970 RingBuffer<Event,false>::NonVolatileReader eventQueueReader = pEventQueue->get_non_volatile_reader();
667 schoenebeck 460 Event* pEvent;
668     while (true) {
669     // get next event from input event queue
670     if (!(pEvent = eventQueueReader.pop())) break;
671     // if younger event reached, ignore that and all subsequent ones for now
672     if (pEvent->FragmentPos() >= Samples) {
673     eventQueueReader--;
674     dmsg(2,("Younger Event, pos=%d ,Samples=%d!\n",pEvent->FragmentPos(),Samples));
675     pEvent->ResetFragmentPos();
676     break;
677     }
678     // copy event to internal event list
679     if (pEvents->poolIsEmpty()) {
680     dmsg(1,("Event pool emtpy!\n"));
681     break;
682     }
683     *pEvents->allocAppend() = *pEvent;
684     }
685     eventQueueReader.free(); // free all copied events from input queue
686     }
687    
688 schoenebeck 1001 void EngineChannel::RemoveAllFxSends() {
689     if (pEngine) pEngine->DisableAndLock();
690     if (!fxSends.empty()) { // free local render buffers
691     if (pChannelLeft) {
692     delete pChannelLeft;
693     if (pEngine && pEngine->pAudioOutputDevice) {
694     // fallback to render directly to the AudioOutputDevice's buffer
695     pChannelLeft = pEngine->pAudioOutputDevice->Channel(AudioDeviceChannelLeft);
696     } else pChannelLeft = NULL;
697     }
698     if (pChannelRight) {
699     delete pChannelRight;
700     if (pEngine && pEngine->pAudioOutputDevice) {
701     // fallback to render directly to the AudioOutputDevice's buffer
702     pChannelRight = pEngine->pAudioOutputDevice->Channel(AudioDeviceChannelRight);
703     } else pChannelRight = NULL;
704     }
705     }
706     for (int i = 0; i < fxSends.size(); i++) delete fxSends[i];
707     fxSends.clear();
708     if (pEngine) pEngine->Enable();
709     }
710    
711 schoenebeck 411 float EngineChannel::Volume() {
712     return GlobalVolume;
713     }
714    
715     void EngineChannel::Volume(float f) {
716     GlobalVolume = f;
717 schoenebeck 660 bStatusChanged = true; // status of engine channel has changed, so set notify flag
718 schoenebeck 411 }
719    
720     uint EngineChannel::Channels() {
721     return 2;
722     }
723    
724     String EngineChannel::InstrumentFileName() {
725     return InstrumentFile;
726     }
727    
728     String EngineChannel::InstrumentName() {
729     return InstrumentIdxName;
730     }
731    
732     int EngineChannel::InstrumentIndex() {
733     return InstrumentIdx;
734     }
735    
736     int EngineChannel::InstrumentStatus() {
737     return InstrumentStat;
738 persson 438 }
739 schoenebeck 411
740 schoenebeck 475 String EngineChannel::EngineName() {
741     return LS_GIG_ENGINE_NAME;
742     }
743 schoenebeck 660
744 schoenebeck 411 }} // namespace LinuxSampler::gig

  ViewVC Help
Powered by ViewVC