src/engines/EngineChannel.cpp

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005 - 2007 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                                                   *
 ***************************************************************************/

#include "EngineChannel.h"

#include <algorithm>

#include "../drivers/midi/MidiInstrumentMapper.h"

#define NO_MIDI_INSTRUMENT_MAP          -1
#define DEFAULT_MIDI_INSTRUMENT_MAP     -2

namespace LinuxSampler {

    EngineChannel::EngineChannel() {
        iMute = 0;
        bSolo = false;
        uiMidiBankMsb = 0;
        uiMidiBankLsb = 0;
        uiMidiProgram = 0;
        bProgramChangeReceived = bMidiBankMsbReceived = bMidiBankLsbReceived = false;
        iMidiInstrumentMap = NO_MIDI_INSTRUMENT_MAP;
        uiVoiceCount = 0;
        uiDiskStreamCount = 0;
        ResetMidiRpnController();
    }

    void EngineChannel::SetMute(int state) throw (Exception) {
        if(iMute == state) return;
        if(state < -1 || state > 1)
            throw Exception("Invalid Mute state: " + ToString(state));

        iMute = state;

        StatusChanged(true);
    }

    int EngineChannel::GetMute() {
        return iMute;
    }

    void EngineChannel::SetSolo(bool solo) {
        if(bSolo == solo) return;
        bSolo = solo;
        StatusChanged(true);
    }

    bool EngineChannel::GetSolo() {
        return bSolo;
    }

    /*
       We use a workaround for MIDI devices (i.e. old keyboards) which either
       only send bank select MSB or only bank select LSB messages. Bank
       selects will be modified according to the following table:

       MIDI Sequence received:            -> GetMidiBankMsb()= | GetMidiBankLsb()=
       ---------------------------------------------------------------------------
       program change                     ->        0          |        0
       bank LSB, program change           ->        0          |     LSB value
       bank MSB, program change           ->        0          |     MSB value
       bank LSB, bank MSB, program change ->     MSB value     |     LSB value
       bank MSB, bank LSB, program change ->     MSB value     |     LSB value
       ---------------------------------------------------------------------------

       That way we ensure those limited devices always to switch between the
       following set of MIDI instrument banks:  { 0, 1, 2, ..., 127 }
    */

    uint8_t EngineChannel::GetMidiProgram() {
        return uiMidiProgram; // AFAIK atomic on all systems
    }

    void EngineChannel::SetMidiProgram(uint8_t Program) {
        bProgramChangeReceived = true;
        uiMidiProgram = Program; // AFAIK atomic on all systems
    }

    uint8_t EngineChannel::GetMidiBankMsb() {
        return (bMidiBankMsbReceived && bMidiBankLsbReceived) ? uiMidiBankMsb : 0;
    }

    void EngineChannel::SetMidiBankMsb(uint8_t BankMSB) {
        if (bProgramChangeReceived)
            bProgramChangeReceived = bMidiBankLsbReceived = false;
        bMidiBankMsbReceived = true;
        uiMidiBankMsb = BankMSB; // AFAIK atomic on all systems
    }

    uint8_t EngineChannel::GetMidiBankLsb() {
        return (!bMidiBankMsbReceived && !bMidiBankLsbReceived)
                   ? 0
                   : (bMidiBankMsbReceived && !bMidiBankLsbReceived)
                         ? uiMidiBankMsb
                         : uiMidiBankLsb;
    }

    void EngineChannel::SetMidiBankLsb(uint8_t BankLSB) {
        if (bProgramChangeReceived)
            bProgramChangeReceived = bMidiBankMsbReceived = false;
        bMidiBankLsbReceived = true;
        uiMidiBankLsb = BankLSB; // AFAIK atomic on all systems
    }

    bool EngineChannel::UsesNoMidiInstrumentMap() {
        return (iMidiInstrumentMap == NO_MIDI_INSTRUMENT_MAP);
    }

    bool EngineChannel::UsesDefaultMidiInstrumentMap() {
        return (iMidiInstrumentMap == DEFAULT_MIDI_INSTRUMENT_MAP);
    }

    int EngineChannel::GetMidiInstrumentMap() throw (Exception) {
        if (UsesNoMidiInstrumentMap())
            throw Exception("EngineChannel is using no MIDI instrument map");
        if (UsesDefaultMidiInstrumentMap())
            throw Exception("EngineChannel is using default MIDI instrument map");
        // check if the stored map still exists in the MIDI instrument mapper
        std::vector<int> maps = MidiInstrumentMapper::Maps();
        if (find(maps.begin(), maps.end(), iMidiInstrumentMap) == maps.end()) {
            // it doesn't exist anymore, so fall back to NONE and throw an exception
            iMidiInstrumentMap = NO_MIDI_INSTRUMENT_MAP;
            throw Exception("Assigned MIDI instrument map doesn't exist anymore, falling back to NONE");
        }
        return iMidiInstrumentMap;
    }

    void EngineChannel::SetMidiInstrumentMapToNone() {
        if (iMidiInstrumentMap == NO_MIDI_INSTRUMENT_MAP) return;
        iMidiInstrumentMap = NO_MIDI_INSTRUMENT_MAP;
        StatusChanged(true);
    }

    void EngineChannel::SetMidiInstrumentMapToDefault() {
        if (iMidiInstrumentMap == DEFAULT_MIDI_INSTRUMENT_MAP) return;
        iMidiInstrumentMap = DEFAULT_MIDI_INSTRUMENT_MAP;
        StatusChanged(true);
    }

    void EngineChannel::SetMidiInstrumentMap(int MidiMap) throw (Exception) {
        if (iMidiInstrumentMap == MidiMap) return;

        // check if given map actually exists in the MIDI instrument mapper
        std::vector<int> maps = MidiInstrumentMapper::Maps();
        if (find(maps.begin(), maps.end(), MidiMap) == maps.end())
            throw Exception("MIDI instrument map doesn't exist");
        iMidiInstrumentMap = MidiMap; // assign the new map ID
        StatusChanged(true);
    }

    void EngineChannel::SetMidiRpnControllerMsb(uint8_t CtrlMSB) {
        uiMidiRpnMsb = CtrlMSB;
        bMidiRpnReceived = true;
    }

    void EngineChannel::SetMidiRpnControllerLsb(uint8_t CtrlLSB) {
        uiMidiRpnLsb = CtrlLSB;
        bMidiRpnReceived = true;
    }

    void EngineChannel::ResetMidiRpnController() {
        uiMidiRpnMsb = uiMidiRpnLsb = 0;
        bMidiRpnReceived = false;
    }

    int EngineChannel::GetMidiRpnController() {
        return (bMidiRpnReceived) ? (uiMidiRpnMsb << 8) | uiMidiRpnLsb : -1;
    }

    uint EngineChannel::GetVoiceCount() {
        return uiVoiceCount;
    }
    
    void EngineChannel::SetVoiceCount(uint Voices) {
        uiVoiceCount = Voices;
    }

    uint EngineChannel::GetDiskStreamCount() {
        return uiDiskStreamCount;
    }
    
    void EngineChannel::SetDiskStreamCount(uint Streams) {
        uiDiskStreamCount = Streams;
    }

    void EngineChannel::AddFxSendCountListener(FxSendCountListener* l) {
        llFxSendCountListeners.AddListener(l);
    }

    void EngineChannel::RemoveFxSendCountListener(FxSendCountListener* l) {
        llFxSendCountListeners.RemoveListener(l);
    }

    void EngineChannel::RemoveAllFxSendCountListeners() {
        llFxSendCountListeners.RemoveAllListeners();
    }

    void EngineChannel::fireFxSendCountChanged(int ChannelId, int NewCount) {
        for (int i = 0; i < llFxSendCountListeners.GetListenerCount(); i++) {
            llFxSendCountListeners.GetListener(i)->FxSendCountChanged(ChannelId, NewCount);
        }
    }

} // namespace LinuxSampler
1	schoenebeck	888	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6	schoenebeck	1041	* Copyright (C) 2005 - 2007 Christian Schoenebeck *
7	schoenebeck	888	* *
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	schoenebeck	973	#include <algorithm>
27
28			#include "../drivers/midi/MidiInstrumentMapper.h"
29
30			#define NO_MIDI_INSTRUMENT_MAP -1
31			#define DEFAULT_MIDI_INSTRUMENT_MAP -2
32
33	schoenebeck	888	namespace LinuxSampler {
34
35			EngineChannel::EngineChannel() {
36			iMute = 0;
37			bSolo = false;
38	schoenebeck	947	uiMidiBankMsb = 0;
39			uiMidiBankLsb = 0;
40			uiMidiProgram = 0;
41	schoenebeck	973	bProgramChangeReceived = bMidiBankMsbReceived = bMidiBankLsbReceived = false;
42			iMidiInstrumentMap = NO_MIDI_INSTRUMENT_MAP;
43	iliev	1297	uiVoiceCount = 0;
44			uiDiskStreamCount = 0;
45	schoenebeck	1044	ResetMidiRpnController();
46	schoenebeck	888	}
47
48			void EngineChannel::SetMute(int state) throw (Exception) {
49			if(iMute == state) return;
50			if(state < -1 \|\| state > 1)
51			throw Exception("Invalid Mute state: " + ToString(state));
52
53			iMute = state;
54
55			StatusChanged(true);
56			}
57
58			int EngineChannel::GetMute() {
59			return iMute;
60			}
61
62			void EngineChannel::SetSolo(bool solo) {
63			if(bSolo == solo) return;
64			bSolo = solo;
65			StatusChanged(true);
66			}
67
68			bool EngineChannel::GetSolo() {
69			return bSolo;
70			}
71
72	schoenebeck	973	/*
73			We use a workaround for MIDI devices (i.e. old keyboards) which either
74			only send bank select MSB or only bank select LSB messages. Bank
75			selects will be modified according to the following table:
76
77			MIDI Sequence received: -> GetMidiBankMsb()= \| GetMidiBankLsb()=
78			---------------------------------------------------------------------------
79			program change -> 0 \| 0
80			bank LSB, program change -> 0 \| LSB value
81			bank MSB, program change -> 0 \| MSB value
82			bank LSB, bank MSB, program change -> MSB value \| LSB value
83			bank MSB, bank LSB, program change -> MSB value \| LSB value
84			---------------------------------------------------------------------------
85
86			That way we ensure those limited devices always to switch between the
87			following set of MIDI instrument banks: { 0, 1, 2, ..., 127 }
88			*/
89
90	schoenebeck	947	uint8_t EngineChannel::GetMidiProgram() {
91			return uiMidiProgram; // AFAIK atomic on all systems
92			}
93
94			void EngineChannel::SetMidiProgram(uint8_t Program) {
95	schoenebeck	973	bProgramChangeReceived = true;
96	schoenebeck	947	uiMidiProgram = Program; // AFAIK atomic on all systems
97			}
98
99			uint8_t EngineChannel::GetMidiBankMsb() {
100	schoenebeck	973	return (bMidiBankMsbReceived && bMidiBankLsbReceived) ? uiMidiBankMsb : 0;
101	schoenebeck	947	}
102
103			void EngineChannel::SetMidiBankMsb(uint8_t BankMSB) {
104	schoenebeck	973	if (bProgramChangeReceived)
105			bProgramChangeReceived = bMidiBankLsbReceived = false;
106			bMidiBankMsbReceived = true;
107	schoenebeck	947	uiMidiBankMsb = BankMSB; // AFAIK atomic on all systems
108			}
109
110			uint8_t EngineChannel::GetMidiBankLsb() {
111	schoenebeck	973	return (!bMidiBankMsbReceived && !bMidiBankLsbReceived)
112			? 0
113			: (bMidiBankMsbReceived && !bMidiBankLsbReceived)
114			? uiMidiBankMsb
115			: uiMidiBankLsb;
116	schoenebeck	947	}
117
118			void EngineChannel::SetMidiBankLsb(uint8_t BankLSB) {
119	schoenebeck	973	if (bProgramChangeReceived)
120			bProgramChangeReceived = bMidiBankMsbReceived = false;
121			bMidiBankLsbReceived = true;
122	schoenebeck	947	uiMidiBankLsb = BankLSB; // AFAIK atomic on all systems
123			}
124
125	schoenebeck	973	bool EngineChannel::UsesNoMidiInstrumentMap() {
126			return (iMidiInstrumentMap == NO_MIDI_INSTRUMENT_MAP);
127			}
128
129			bool EngineChannel::UsesDefaultMidiInstrumentMap() {
130			return (iMidiInstrumentMap == DEFAULT_MIDI_INSTRUMENT_MAP);
131			}
132
133			int EngineChannel::GetMidiInstrumentMap() throw (Exception) {
134			if (UsesNoMidiInstrumentMap())
135			throw Exception("EngineChannel is using no MIDI instrument map");
136			if (UsesDefaultMidiInstrumentMap())
137			throw Exception("EngineChannel is using default MIDI instrument map");
138			// check if the stored map still exists in the MIDI instrument mapper
139			std::vector<int> maps = MidiInstrumentMapper::Maps();
140			if (find(maps.begin(), maps.end(), iMidiInstrumentMap) == maps.end()) {
141			// it doesn't exist anymore, so fall back to NONE and throw an exception
142			iMidiInstrumentMap = NO_MIDI_INSTRUMENT_MAP;
143			throw Exception("Assigned MIDI instrument map doesn't exist anymore, falling back to NONE");
144			}
145			return iMidiInstrumentMap;
146			}
147
148			void EngineChannel::SetMidiInstrumentMapToNone() {
149	iliev	1254	if (iMidiInstrumentMap == NO_MIDI_INSTRUMENT_MAP) return;
150	schoenebeck	973	iMidiInstrumentMap = NO_MIDI_INSTRUMENT_MAP;
151	iliev	1254	StatusChanged(true);
152	schoenebeck	973	}
153
154			void EngineChannel::SetMidiInstrumentMapToDefault() {
155	iliev	1254	if (iMidiInstrumentMap == DEFAULT_MIDI_INSTRUMENT_MAP) return;
156	schoenebeck	973	iMidiInstrumentMap = DEFAULT_MIDI_INSTRUMENT_MAP;
157	iliev	1254	StatusChanged(true);
158	schoenebeck	973	}
159
160			void EngineChannel::SetMidiInstrumentMap(int MidiMap) throw (Exception) {
161	iliev	1254	if (iMidiInstrumentMap == MidiMap) return;
162
163	schoenebeck	973	// check if given map actually exists in the MIDI instrument mapper
164			std::vector<int> maps = MidiInstrumentMapper::Maps();
165			if (find(maps.begin(), maps.end(), MidiMap) == maps.end())
166			throw Exception("MIDI instrument map doesn't exist");
167			iMidiInstrumentMap = MidiMap; // assign the new map ID
168	iliev	1254	StatusChanged(true);
169	schoenebeck	973	}
170
171	schoenebeck	1041	void EngineChannel::SetMidiRpnControllerMsb(uint8_t CtrlMSB) {
172			uiMidiRpnMsb = CtrlMSB;
173	schoenebeck	1044	bMidiRpnReceived = true;
174	schoenebeck	1041	}
175
176			void EngineChannel::SetMidiRpnControllerLsb(uint8_t CtrlLSB) {
177			uiMidiRpnLsb = CtrlLSB;
178	schoenebeck	1044	bMidiRpnReceived = true;
179	schoenebeck	1041	}
180
181	schoenebeck	1044	void EngineChannel::ResetMidiRpnController() {
182			uiMidiRpnMsb = uiMidiRpnLsb = 0;
183			bMidiRpnReceived = false;
184			}
185
186	schoenebeck	1041	int EngineChannel::GetMidiRpnController() {
187	schoenebeck	1044	return (bMidiRpnReceived) ? (uiMidiRpnMsb << 8) \| uiMidiRpnLsb : -1;
188	schoenebeck	1041	}
189
190	iliev	1297	uint EngineChannel::GetVoiceCount() {
191			return uiVoiceCount;
192			}
193
194			void EngineChannel::SetVoiceCount(uint Voices) {
195			uiVoiceCount = Voices;
196			}
197
198			uint EngineChannel::GetDiskStreamCount() {
199			return uiDiskStreamCount;
200			}
201
202			void EngineChannel::SetDiskStreamCount(uint Streams) {
203			uiDiskStreamCount = Streams;
204			}
205
206	iliev	1130	void EngineChannel::AddFxSendCountListener(FxSendCountListener* l) {
207			llFxSendCountListeners.AddListener(l);
208			}
209
210			void EngineChannel::RemoveFxSendCountListener(FxSendCountListener* l) {
211			llFxSendCountListeners.RemoveListener(l);
212			}
213
214			void EngineChannel::RemoveAllFxSendCountListeners() {
215			llFxSendCountListeners.RemoveAllListeners();
216			}
217
218			void EngineChannel::fireFxSendCountChanged(int ChannelId, int NewCount) {
219			for (int i = 0; i < llFxSendCountListeners.GetListenerCount(); i++) {
220			llFxSendCountListeners.GetListener(i)->FxSendCountChanged(ChannelId, NewCount);
221			}
222			}
223
224	schoenebeck	888	} // namespace LinuxSampler