src/engines/EngineChannel.cpp

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

    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() {
        iMidiInstrumentMap = NO_MIDI_INSTRUMENT_MAP;
    }

    void EngineChannel::SetMidiInstrumentMapToDefault() {
        iMidiInstrumentMap = DEFAULT_MIDI_INSTRUMENT_MAP;
    }

    void EngineChannel::SetMidiInstrumentMap(int MidiMap) throw (Exception) {
        // 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
    }

} // namespace LinuxSampler
1	/***************************************************************************
2	* *
3	* LinuxSampler - modular, streaming capable sampler *
4	* *
5	* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6	* Copyright (C) 2005, 2006 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	#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	namespace LinuxSampler {
34
35	EngineChannel::EngineChannel() {
36	iMute = 0;
37	bSolo = false;
38	uiMidiBankMsb = 0;
39	uiMidiBankLsb = 0;
40	uiMidiProgram = 0;
41	bProgramChangeReceived = bMidiBankMsbReceived = bMidiBankLsbReceived = false;
42	iMidiInstrumentMap = NO_MIDI_INSTRUMENT_MAP;
43	}
44
45	void EngineChannel::SetMute(int state) throw (Exception) {
46	if(iMute == state) return;
47	if(state < -1 \|\| state > 1)
48	throw Exception("Invalid Mute state: " + ToString(state));
49
50	iMute = state;
51
52	StatusChanged(true);
53	}
54
55	int EngineChannel::GetMute() {
56	return iMute;
57	}
58
59	void EngineChannel::SetSolo(bool solo) {
60	if(bSolo == solo) return;
61	bSolo = solo;
62	StatusChanged(true);
63	}
64
65	bool EngineChannel::GetSolo() {
66	return bSolo;
67	}
68
69	/*
70	We use a workaround for MIDI devices (i.e. old keyboards) which either
71	only send bank select MSB or only bank select LSB messages. Bank
72	selects will be modified according to the following table:
73
74	MIDI Sequence received: -> GetMidiBankMsb()= \| GetMidiBankLsb()=
75	---------------------------------------------------------------------------
76	program change -> 0 \| 0
77	bank LSB, program change -> 0 \| LSB value
78	bank MSB, program change -> 0 \| MSB value
79	bank LSB, bank MSB, program change -> MSB value \| LSB value
80	bank MSB, bank LSB, program change -> MSB value \| LSB value
81	---------------------------------------------------------------------------
82
83	That way we ensure those limited devices always to switch between the
84	following set of MIDI instrument banks: { 0, 1, 2, ..., 127 }
85	*/
86
87	uint8_t EngineChannel::GetMidiProgram() {
88	return uiMidiProgram; // AFAIK atomic on all systems
89	}
90
91	void EngineChannel::SetMidiProgram(uint8_t Program) {
92	bProgramChangeReceived = true;
93	uiMidiProgram = Program; // AFAIK atomic on all systems
94	}
95
96	uint8_t EngineChannel::GetMidiBankMsb() {
97	return (bMidiBankMsbReceived && bMidiBankLsbReceived) ? uiMidiBankMsb : 0;
98	}
99
100	void EngineChannel::SetMidiBankMsb(uint8_t BankMSB) {
101	if (bProgramChangeReceived)
102	bProgramChangeReceived = bMidiBankLsbReceived = false;
103	bMidiBankMsbReceived = true;
104	uiMidiBankMsb = BankMSB; // AFAIK atomic on all systems
105	}
106
107	uint8_t EngineChannel::GetMidiBankLsb() {
108	return (!bMidiBankMsbReceived && !bMidiBankLsbReceived)
109	? 0
110	: (bMidiBankMsbReceived && !bMidiBankLsbReceived)
111	? uiMidiBankMsb
112	: uiMidiBankLsb;
113	}
114
115	void EngineChannel::SetMidiBankLsb(uint8_t BankLSB) {
116	if (bProgramChangeReceived)
117	bProgramChangeReceived = bMidiBankMsbReceived = false;
118	bMidiBankLsbReceived = true;
119	uiMidiBankLsb = BankLSB; // AFAIK atomic on all systems
120	}
121
122	bool EngineChannel::UsesNoMidiInstrumentMap() {
123	return (iMidiInstrumentMap == NO_MIDI_INSTRUMENT_MAP);
124	}
125
126	bool EngineChannel::UsesDefaultMidiInstrumentMap() {
127	return (iMidiInstrumentMap == DEFAULT_MIDI_INSTRUMENT_MAP);
128	}
129
130	int EngineChannel::GetMidiInstrumentMap() throw (Exception) {
131	if (UsesNoMidiInstrumentMap())
132	throw Exception("EngineChannel is using no MIDI instrument map");
133	if (UsesDefaultMidiInstrumentMap())
134	throw Exception("EngineChannel is using default MIDI instrument map");
135	// check if the stored map still exists in the MIDI instrument mapper
136	std::vector<int> maps = MidiInstrumentMapper::Maps();
137	if (find(maps.begin(), maps.end(), iMidiInstrumentMap) == maps.end()) {
138	// it doesn't exist anymore, so fall back to NONE and throw an exception
139	iMidiInstrumentMap = NO_MIDI_INSTRUMENT_MAP;
140	throw Exception("Assigned MIDI instrument map doesn't exist anymore, falling back to NONE");
141	}
142	return iMidiInstrumentMap;
143	}
144
145	void EngineChannel::SetMidiInstrumentMapToNone() {
146	iMidiInstrumentMap = NO_MIDI_INSTRUMENT_MAP;
147	}
148
149	void EngineChannel::SetMidiInstrumentMapToDefault() {
150	iMidiInstrumentMap = DEFAULT_MIDI_INSTRUMENT_MAP;
151	}
152
153	void EngineChannel::SetMidiInstrumentMap(int MidiMap) throw (Exception) {
154	// check if given map actually exists in the MIDI instrument mapper
155	std::vector<int> maps = MidiInstrumentMapper::Maps();
156	if (find(maps.begin(), maps.end(), MidiMap) == maps.end())
157	throw Exception("MIDI instrument map doesn't exist");
158	iMidiInstrumentMap = MidiMap; // assign the new map ID
159	}
160
161	} // namespace LinuxSampler