src/drivers/Plugin.cpp

/***************************************************************************
 *                                                                         *
 *   Copyright (C) 2008 - 2009 Andreas Persson                             *
 *                                                                         *
 *   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., 51 Franklin St, Fifth Floor, Boston,                *
 *   MA  02110-1301  USA                                                   *
 ***************************************************************************/

#include <limits>
#include <sstream>

#include "Plugin.h"
#include "audio/AudioOutputDeviceFactory.h"
#include "midi/MidiInputDeviceFactory.h"

namespace LinuxSampler {

// *************** PluginGlobal ***************
// *

    PluginGlobal::PluginGlobal() :
        RefCount(0) {
        // we need to remove the ASIO driver, otherwise the lscp info
        // methods will lock up the audio device
        AudioOutputDeviceFactory::Unregister("ASIO");

        REGISTER_AUDIO_OUTPUT_DRIVER(AudioOutputDevicePlugin);
        REGISTER_AUDIO_OUTPUT_DRIVER_PARAMETER(AudioOutputDevicePlugin, ParameterActive);
        REGISTER_AUDIO_OUTPUT_DRIVER_PARAMETER(AudioOutputDevicePlugin, ParameterSampleRate);
        REGISTER_AUDIO_OUTPUT_DRIVER_PARAMETER(AudioOutputDevicePlugin, ParameterChannelsPlugin);
        REGISTER_AUDIO_OUTPUT_DRIVER_PARAMETER(AudioOutputDevicePlugin, ParameterFragmentSize);

        REGISTER_MIDI_INPUT_DRIVER(MidiInputDevicePlugin);
        REGISTER_MIDI_INPUT_DRIVER_PARAMETER(MidiInputDevicePlugin, ParameterActive);
        REGISTER_MIDI_INPUT_DRIVER_PARAMETER(MidiInputDevicePlugin, ParameterPortsPlugin);

        pSampler = new Sampler;

        // using LOOPBACK instead of ANY to prevent windows firewall
        // warnings
        pLSCPServer = new LSCPServer(pSampler, htonl(INADDR_LOOPBACK),
                                     htons(LSCP_PORT));
        pLSCPServer->StartThread();
        pLSCPServer->WaitUntilInitialized();

        pEventThread = new EventThread(pSampler);
        pEventThread->StartThread();
    }


    PluginGlobal::~PluginGlobal() {
        pEventThread->StopThread();
        pLSCPServer->StopThread();
        pLSCPServer->RemoveListeners();

        delete pEventThread;
        delete pSampler;
        delete pLSCPServer;
    }


// *************** EventThread ***************
// *


    EventThread::EventThread(Sampler* pSampler) :
        Thread(false, false, 0, 0),
        pSampler(pSampler) {
    }

    int EventThread::Main() {
        for (;;) {
            sleep(1);
            pSampler->fireStatistics();
        }
        return 0;
    }


// *************** Plugin ***************
// *

    PluginGlobal* Plugin::global = 0;

    Plugin::Plugin(bool bDoPreInit) :
        pAudioDevice(0),
        pMidiDevice(0) {
        bPreInitDone = false;
        if (bDoPreInit) PreInit();
    }

    void Plugin::PreInit() {
        if (bPreInitDone) return;

        bPreInitDone = true;
        if (!global) {
            global = new PluginGlobal;
        }
        global->RefCount++;
    }

    void Plugin::Init(int SampleRate, int FragmentSize, int Channels) {
        if (pAudioDevice && SampleRate == pAudioDevice->SampleRate() &&
            FragmentSize == pAudioDevice->MaxSamplesPerCycle()) {
            return; // nothing has changed
        }

        String oldState;
        if (pAudioDevice) {
            oldState = GetState();
            RemoveChannels();
            global->pSampler->DestroyAudioOutputDevice(pAudioDevice);
        }
        std::map<String, String> params;
        params["SAMPLERATE"] = ToString(SampleRate);
        params["FRAGMENTSIZE"] = ToString(FragmentSize);
        if (Channels > 0) params["CHANNELS"] = ToString(Channels);
        pAudioDevice = dynamic_cast<AudioOutputDevicePlugin*>(
            global->pSampler->CreateAudioOutputDevice(AudioOutputDevicePlugin::Name(), params));

        if (!pMidiDevice) {
            pMidiDevice = dynamic_cast<MidiInputDevicePlugin*>(
                global->pSampler->CreateMidiInputDevice(MidiInputDevicePlugin::Name(),
                                                        std::map<String,String>()));
        }

        if (!oldState.empty()) {
            SetState(oldState);
        }
    }

    Plugin::~Plugin() {
        RemoveChannels();
        if (pAudioDevice) global->pSampler->DestroyAudioOutputDevice(pAudioDevice);
        if (pMidiDevice) global->pSampler->DestroyMidiInputDevice(pMidiDevice);
        if (bPreInitDone) {
            if (--global->RefCount == 0) {
                delete global;
                global = 0;
            }
        }
    }

    void Plugin::InitState() {
        SamplerChannel* channel = global->pSampler->AddSamplerChannel();
        channel->SetEngineType("gig");
        channel->SetAudioOutputDevice(pAudioDevice);
        channel->SetMidiInputDevice(pMidiDevice);
        channel->SetMidiInputChannel(midi_chan_1);
    }

    /*
      The sampler state is stored in a text base format, designed to
      be easy to parse with the istream >> operator. Values are
      separated by spaces or newlines. All string values that may
      contain spaces end with a newline.

      The first line contains the global volume.

      The rest of the lines have an integer first representing the
      type of information on the line, except for the two lines that
      describe each sampler channel. The first of these two starts
      with an integer from 0 to 16 (the midi channel for the sampler
      channel).

      Note that we should try to keep the parsing of this format both
      backwards and forwards compatible between versions. The parser
      ignores lines with unknown type integers and accepts that new
      types are missing.
    */

    enum {
        FXSEND = 17,
        MIDIMAP,
        MIDIMAPPING,
        DEFAULTMIDIMAP
    };

    String Plugin::GetState() {
        std::stringstream s;

        s << GLOBAL_VOLUME << '\n';

        std::vector<int> maps = MidiInstrumentMapper::Maps();
        for (int i = 0 ; i < maps.size() ; i++) {
            s << MIDIMAP << ' ' <<
                maps[i] << ' ' <<
                MidiInstrumentMapper::MapName(maps[i]) << '\n';

            std::map<midi_prog_index_t, MidiInstrumentMapper::entry_t> mappings = MidiInstrumentMapper::Entries(maps[i]);
            for (std::map<midi_prog_index_t, MidiInstrumentMapper::entry_t>::iterator iter = mappings.begin() ;
                 iter != mappings.end(); iter++) {
                s << MIDIMAPPING << ' ' <<
                    ((int(iter->first.midi_bank_msb) << 7) |
                     int(iter->first.midi_bank_lsb)) << ' ' <<
                    int(iter->first.midi_prog) << ' ' <<
                    iter->second.EngineName << ' ' <<
                    iter->second.InstrumentFile << '\n' <<
                    MIDIMAPPING << ' ' <<
                    iter->second.InstrumentIndex << ' ' <<
                    iter->second.Volume << ' ' <<
                    iter->second.LoadMode << ' ' <<
                    iter->second.Name << '\n';
            }
        }
        if (maps.size()) {
            s << DEFAULTMIDIMAP << ' ' <<
                MidiInstrumentMapper::GetDefaultMap() << '\n';
        }

        std::map<uint, SamplerChannel*> channels = global->pSampler->GetSamplerChannels();
        for (std::map<uint, SamplerChannel*>::iterator iter = channels.begin() ;
             iter != channels.end() ; iter++) {
            SamplerChannel* channel = iter->second;
            if (channel->GetAudioOutputDevice() == pAudioDevice) {
                EngineChannel* engine_channel = channel->GetEngineChannel();
                String filename = engine_channel->InstrumentFileName();
                s << channel->GetMidiInputChannel() << ' ' <<
                    engine_channel->Volume() << ' ' <<
                    filename << '\n' <<
                    engine_channel->InstrumentIndex() << ' ' <<
                    engine_channel->GetSolo() << ' ' <<
                    (engine_channel->GetMute() == 1) << ' ' <<
                    engine_channel->OutputChannel(0) << ' ' <<
                    engine_channel->OutputChannel(1) << ' ' <<
                    (engine_channel->UsesNoMidiInstrumentMap() ? -2 :
                     (engine_channel->UsesDefaultMidiInstrumentMap() ? -1 :
                      engine_channel->GetMidiInstrumentMap())) << '\n';

                for (int i = 0 ; i < engine_channel->GetFxSendCount() ; i++) {
                    FxSend* fxsend = engine_channel->GetFxSend(i);
                    s << FXSEND << ' ' <<
                        fxsend->Level() << ' ' <<
                        int(fxsend->MidiController()) << ' ' <<
                        fxsend->DestinationChannel(0) << ' ' <<
                        fxsend->DestinationChannel(1) << ' ' <<
                        fxsend->Name() << '\n';
                }
            }
        }
        return s.str();
    }

    void Plugin::RemoveChannels() {
        if(global == NULL) return;

        std::map<uint, SamplerChannel*> channels = global->pSampler->GetSamplerChannels();

        for (std::map<uint, SamplerChannel*>::iterator iter = channels.begin() ;
             iter != channels.end() ; iter++) {
            if (iter->second->GetAudioOutputDevice() == pAudioDevice) {
                global->pSampler->RemoveSamplerChannel(iter->second);
            }
        }
    }

    bool Plugin::SetState(String State) {
        RemoveChannels();
        MidiInstrumentMapper::RemoveAllMaps();

        std::stringstream s(State);
        s >> GLOBAL_VOLUME;

        EngineChannel* engine_channel;
        int midiMapId;
        std::map<int, int> oldToNewId;
        int type;
        while (s >> type) {

            if (type <= 16) { // sampler channel
                int midiChannel = type;
                float volume;
                s >> volume;
                s.ignore();
                String filename;
                std::getline(s, filename);
                int index;
                bool solo;
                bool mute;
                s >> index >> solo >> mute;

                SamplerChannel* channel = global->pSampler->AddSamplerChannel();
                channel->SetEngineType("gig");
                channel->SetAudioOutputDevice(pAudioDevice);
                channel->SetMidiInputDevice(pMidiDevice);
                channel->SetMidiInputChannel(midi_chan_t(midiChannel));

                engine_channel = channel->GetEngineChannel();
                engine_channel->Volume(volume);
                if (s.get() == ' ') {
                    int left;
                    int right;
                    int oldMapId;
                    s >> left >> right >> oldMapId;
                    engine_channel->SetOutputChannel(0, left);
                    engine_channel->SetOutputChannel(1, right);

                    if (oldMapId == -1) {
                        engine_channel->SetMidiInstrumentMapToDefault();
                    } else if (oldMapId >= 0) {
                        engine_channel->SetMidiInstrumentMap(oldToNewId[oldMapId]);
                    }
                    // skip rest of line
                    s.ignore(std::numeric_limits<int>::max(), '\n');
                }
                if (!filename.empty() && index != -1) {
                    InstrumentManager::instrument_id_t id;
                    id.FileName = filename;
                    id.Index    = index;
                    InstrumentManager::LoadInstrumentInBackground(id, engine_channel);
                }
                if (solo) engine_channel->SetSolo(solo);
                if (mute) engine_channel->SetMute(1);

            } else if (type == FXSEND) {
                float level;
                int controller;
                int fxleft;
                int fxright;
                String name;

                s >> level >> controller >> fxleft >> fxright;
                s.ignore();
                std::getline(s, name);
                FxSend* send = engine_channel->AddFxSend(controller, name);
                send->SetLevel(level);
                send->SetDestinationChannel(0, fxleft);
                send->SetDestinationChannel(1, fxright);

            } else if (type == MIDIMAP) {
                int oldId;
                s >> oldId;
                String name;
                s.ignore();
                std::getline(s, name);
                midiMapId = MidiInstrumentMapper::AddMap(name);
                oldToNewId[oldId] = midiMapId;

            } else if (type == MIDIMAPPING) {
                int bank;
                int prog;
                String engine;
                String file;
                int index;
                float volume;
                int loadmode;
                String name;

                s >> bank >> prog >> engine;
                s.ignore();
                std::getline(s, file);
                s >> type >> index >> volume >> loadmode;
                s.ignore();
                std::getline(s, name);

                global->pLSCPServer->AddOrReplaceMIDIInstrumentMapping(
                    midiMapId, bank, prog, engine, file, index, volume,
                    MidiInstrumentMapper::mode_t(loadmode), name, false);

            } else if (type == DEFAULTMIDIMAP) {
                int oldId;
                s >> oldId;
                MidiInstrumentMapper::SetDefaultMap(oldToNewId[oldId]);

            } else { // unknown type
                // try to be forward-compatible and just skip the line
                s.ignore(std::numeric_limits<int>::max(), '\n');
            }
        }

        return true;
    }
}
1	persson	1777	/***************************************************************************
2			* *
3	persson	1889	* Copyright (C) 2008 - 2009 Andreas Persson *
4	persson	1777	* *
5			* This program is free software; you can redistribute it and/or modify *
6			* it under the terms of the GNU General Public License as published by *
7			* the Free Software Foundation; either version 2 of the License, or *
8			* (at your option) any later version. *
9			* *
10			* This program is distributed in the hope that it will be useful, *
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13			* GNU General Public License for more details. *
14			* *
15			* You should have received a copy of the GNU General Public License *
16			* along with this program; if not, write to the Free Software *
17			* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, *
18			* MA 02110-1301 USA *
19			***************************************************************************/
20
21	persson	1922	#include <limits>
22	persson	1777	#include <sstream>
23
24			#include "Plugin.h"
25			#include "audio/AudioOutputDeviceFactory.h"
26			#include "midi/MidiInputDeviceFactory.h"
27
28			namespace LinuxSampler {
29
30			// ************* PluginGlobal *************
31			// *
32
33			PluginGlobal::PluginGlobal() :
34			RefCount(0) {
35			// we need to remove the ASIO driver, otherwise the lscp info
36			// methods will lock up the audio device
37	persson	1889	AudioOutputDeviceFactory::Unregister("ASIO");
38	persson	1777
39			REGISTER_AUDIO_OUTPUT_DRIVER(AudioOutputDevicePlugin);
40			REGISTER_AUDIO_OUTPUT_DRIVER_PARAMETER(AudioOutputDevicePlugin, ParameterActive);
41			REGISTER_AUDIO_OUTPUT_DRIVER_PARAMETER(AudioOutputDevicePlugin, ParameterSampleRate);
42	iliev	1907	REGISTER_AUDIO_OUTPUT_DRIVER_PARAMETER(AudioOutputDevicePlugin, ParameterChannelsPlugin);
43	persson	1777	REGISTER_AUDIO_OUTPUT_DRIVER_PARAMETER(AudioOutputDevicePlugin, ParameterFragmentSize);
44
45			REGISTER_MIDI_INPUT_DRIVER(MidiInputDevicePlugin);
46			REGISTER_MIDI_INPUT_DRIVER_PARAMETER(MidiInputDevicePlugin, ParameterActive);
47	iliev	1907	REGISTER_MIDI_INPUT_DRIVER_PARAMETER(MidiInputDevicePlugin, ParameterPortsPlugin);
48	persson	1777
49			pSampler = new Sampler;
50
51			// using LOOPBACK instead of ANY to prevent windows firewall
52			// warnings
53			pLSCPServer = new LSCPServer(pSampler, htonl(INADDR_LOOPBACK),
54			htons(LSCP_PORT));
55			pLSCPServer->StartThread();
56			pLSCPServer->WaitUntilInitialized();
57
58			pEventThread = new EventThread(pSampler);
59			pEventThread->StartThread();
60			}
61
62
63			PluginGlobal::~PluginGlobal() {
64			pEventThread->StopThread();
65			pLSCPServer->StopThread();
66	iliev	1835	pLSCPServer->RemoveListeners();
67	persson	1777
68			delete pEventThread;
69			delete pSampler;
70			delete pLSCPServer;
71			}
72
73
74			// ************* EventThread *************
75			// *
76
77
78			EventThread::EventThread(Sampler* pSampler) :
79			Thread(false, false, 0, 0),
80			pSampler(pSampler) {
81			}
82
83			int EventThread::Main() {
84			for (;;) {
85			sleep(1);
86			pSampler->fireStatistics();
87			}
88	persson	1895	return 0;
89	persson	1777	}
90
91
92			// ************* Plugin *************
93			// *
94
95			PluginGlobal* Plugin::global = 0;
96
97	iliev	1835	Plugin::Plugin(bool bDoPreInit) :
98	persson	1777	pAudioDevice(0),
99			pMidiDevice(0) {
100	iliev	1835	bPreInitDone = false;
101			if (bDoPreInit) PreInit();
102			}
103
104			void Plugin::PreInit() {
105			if (bPreInitDone) return;
106
107			bPreInitDone = true;
108	persson	1777	if (!global) {
109			global = new PluginGlobal;
110			}
111			global->RefCount++;
112			}
113
114	iliev	1835	void Plugin::Init(int SampleRate, int FragmentSize, int Channels) {
115	persson	1895	if (pAudioDevice && SampleRate == pAudioDevice->SampleRate() &&
116			FragmentSize == pAudioDevice->MaxSamplesPerCycle()) {
117			return; // nothing has changed
118			}
119
120			String oldState;
121			if (pAudioDevice) {
122			oldState = GetState();
123			RemoveChannels();
124			global->pSampler->DestroyAudioOutputDevice(pAudioDevice);
125			}
126	persson	1777	std::map<String, String> params;
127			params["SAMPLERATE"] = ToString(SampleRate);
128			params["FRAGMENTSIZE"] = ToString(FragmentSize);
129	iliev	1835	if (Channels > 0) params["CHANNELS"] = ToString(Channels);
130	persson	1777	pAudioDevice = dynamic_cast<AudioOutputDevicePlugin*>(
131			global->pSampler->CreateAudioOutputDevice(AudioOutputDevicePlugin::Name(), params));
132
133	persson	1895	if (!pMidiDevice) {
134			pMidiDevice = dynamic_cast<MidiInputDevicePlugin*>(
135			global->pSampler->CreateMidiInputDevice(MidiInputDevicePlugin::Name(),
136			std::map<String,String>()));
137			}
138
139			if (!oldState.empty()) {
140			SetState(oldState);
141			}
142	persson	1777	}
143
144			Plugin::~Plugin() {
145			RemoveChannels();
146			if (pAudioDevice) global->pSampler->DestroyAudioOutputDevice(pAudioDevice);
147			if (pMidiDevice) global->pSampler->DestroyMidiInputDevice(pMidiDevice);
148	iliev	1835	if (bPreInitDone) {
149			if (--global->RefCount == 0) {
150			delete global;
151			global = 0;
152			}
153	persson	1777	}
154			}
155
156			void Plugin::InitState() {
157			SamplerChannel* channel = global->pSampler->AddSamplerChannel();
158			channel->SetEngineType("gig");
159			channel->SetAudioOutputDevice(pAudioDevice);
160			channel->SetMidiInputDevice(pMidiDevice);
161			channel->SetMidiInputChannel(midi_chan_1);
162			}
163
164	persson	1922	/*
165			The sampler state is stored in a text base format, designed to
166			be easy to parse with the istream >> operator. Values are
167			separated by spaces or newlines. All string values that may
168			contain spaces end with a newline.
169	persson	1777
170	persson	1922	The first line contains the global volume.
171
172			The rest of the lines have an integer first representing the
173			type of information on the line, except for the two lines that
174			describe each sampler channel. The first of these two starts
175			with an integer from 0 to 16 (the midi channel for the sampler
176			channel).
177
178			Note that we should try to keep the parsing of this format both
179			backwards and forwards compatible between versions. The parser
180			ignores lines with unknown type integers and accepts that new
181			types are missing.
182			*/
183
184			enum {
185			FXSEND = 17,
186			MIDIMAP,
187			MIDIMAPPING,
188			DEFAULTMIDIMAP
189			};
190
191	persson	1777	String Plugin::GetState() {
192			std::stringstream s;
193
194			s << GLOBAL_VOLUME << '\n';
195	persson	1922
196			std::vector<int> maps = MidiInstrumentMapper::Maps();
197			for (int i = 0 ; i < maps.size() ; i++) {
198			s << MIDIMAP << ' ' <<
199			maps[i] << ' ' <<
200			MidiInstrumentMapper::MapName(maps[i]) << '\n';
201
202			std::map<midi_prog_index_t, MidiInstrumentMapper::entry_t> mappings = MidiInstrumentMapper::Entries(maps[i]);
203			for (std::map<midi_prog_index_t, MidiInstrumentMapper::entry_t>::iterator iter = mappings.begin() ;
204			iter != mappings.end(); iter++) {
205			s << MIDIMAPPING << ' ' <<
206			((int(iter->first.midi_bank_msb) << 7) \|
207			int(iter->first.midi_bank_lsb)) << ' ' <<
208			int(iter->first.midi_prog) << ' ' <<
209			iter->second.EngineName << ' ' <<
210			iter->second.InstrumentFile << '\n' <<
211			MIDIMAPPING << ' ' <<
212			iter->second.InstrumentIndex << ' ' <<
213			iter->second.Volume << ' ' <<
214			iter->second.LoadMode << ' ' <<
215			iter->second.Name << '\n';
216			}
217			}
218			if (maps.size()) {
219			s << DEFAULTMIDIMAP << ' ' <<
220			MidiInstrumentMapper::GetDefaultMap() << '\n';
221			}
222
223	persson	1777	std::map<uint, SamplerChannel*> channels = global->pSampler->GetSamplerChannels();
224			for (std::map<uint, SamplerChannel*>::iterator iter = channels.begin() ;
225			iter != channels.end() ; iter++) {
226			SamplerChannel* channel = iter->second;
227			if (channel->GetAudioOutputDevice() == pAudioDevice) {
228			EngineChannel* engine_channel = channel->GetEngineChannel();
229			String filename = engine_channel->InstrumentFileName();
230			s << channel->GetMidiInputChannel() << ' ' <<
231			engine_channel->Volume() << ' ' <<
232			filename << '\n' <<
233			engine_channel->InstrumentIndex() << ' ' <<
234			engine_channel->GetSolo() << ' ' <<
235	persson	1922	(engine_channel->GetMute() == 1) << ' ' <<
236			engine_channel->OutputChannel(0) << ' ' <<
237			engine_channel->OutputChannel(1) << ' ' <<
238			(engine_channel->UsesNoMidiInstrumentMap() ? -2 :
239			(engine_channel->UsesDefaultMidiInstrumentMap() ? -1 :
240			engine_channel->GetMidiInstrumentMap())) << '\n';
241
242			for (int i = 0 ; i < engine_channel->GetFxSendCount() ; i++) {
243			FxSend* fxsend = engine_channel->GetFxSend(i);
244			s << FXSEND << ' ' <<
245			fxsend->Level() << ' ' <<
246			int(fxsend->MidiController()) << ' ' <<
247			fxsend->DestinationChannel(0) << ' ' <<
248			fxsend->DestinationChannel(1) << ' ' <<
249			fxsend->Name() << '\n';
250			}
251	persson	1777	}
252			}
253			return s.str();
254			}
255
256			void Plugin::RemoveChannels() {
257	iliev	1835	if(global == NULL) return;
258
259	persson	1777	std::map<uint, SamplerChannel*> channels = global->pSampler->GetSamplerChannels();
260	iliev	1835
261	persson	1777	for (std::map<uint, SamplerChannel*>::iterator iter = channels.begin() ;
262			iter != channels.end() ; iter++) {
263			if (iter->second->GetAudioOutputDevice() == pAudioDevice) {
264			global->pSampler->RemoveSamplerChannel(iter->second);
265			}
266			}
267			}
268
269			bool Plugin::SetState(String State) {
270			RemoveChannels();
271	persson	1922	MidiInstrumentMapper::RemoveAllMaps();
272	persson	1777
273			std::stringstream s(State);
274			s >> GLOBAL_VOLUME;
275
276	persson	1922	EngineChannel* engine_channel;
277			int midiMapId;
278			std::map<int, int> oldToNewId;
279			int type;
280			while (s >> type) {
281	persson	1777
282	persson	1922	if (type <= 16) { // sampler channel
283			int midiChannel = type;
284			float volume;
285			s >> volume;
286			s.ignore();
287			String filename;
288			std::getline(s, filename);
289			int index;
290			bool solo;
291			bool mute;
292			s >> index >> solo >> mute;
293	persson	1777
294	persson	1922	SamplerChannel* channel = global->pSampler->AddSamplerChannel();
295			channel->SetEngineType("gig");
296			channel->SetAudioOutputDevice(pAudioDevice);
297			channel->SetMidiInputDevice(pMidiDevice);
298			channel->SetMidiInputChannel(midi_chan_t(midiChannel));
299
300			engine_channel = channel->GetEngineChannel();
301			engine_channel->Volume(volume);
302			if (s.get() == ' ') {
303			int left;
304			int right;
305			int oldMapId;
306			s >> left >> right >> oldMapId;
307			engine_channel->SetOutputChannel(0, left);
308			engine_channel->SetOutputChannel(1, right);
309
310			if (oldMapId == -1) {
311			engine_channel->SetMidiInstrumentMapToDefault();
312			} else if (oldMapId >= 0) {
313			engine_channel->SetMidiInstrumentMap(oldToNewId[oldMapId]);
314			}
315			// skip rest of line
316			s.ignore(std::numeric_limits<int>::max(), '\n');
317			}
318			if (!filename.empty() && index != -1) {
319			InstrumentManager::instrument_id_t id;
320			id.FileName = filename;
321			id.Index = index;
322			InstrumentManager::LoadInstrumentInBackground(id, engine_channel);
323			}
324			if (solo) engine_channel->SetSolo(solo);
325			if (mute) engine_channel->SetMute(1);
326
327			} else if (type == FXSEND) {
328			float level;
329			int controller;
330			int fxleft;
331			int fxright;
332			String name;
333
334			s >> level >> controller >> fxleft >> fxright;
335			s.ignore();
336			std::getline(s, name);
337			FxSend* send = engine_channel->AddFxSend(controller, name);
338			send->SetLevel(level);
339			send->SetDestinationChannel(0, fxleft);
340			send->SetDestinationChannel(1, fxright);
341
342			} else if (type == MIDIMAP) {
343			int oldId;
344			s >> oldId;
345			String name;
346			s.ignore();
347			std::getline(s, name);
348			midiMapId = MidiInstrumentMapper::AddMap(name);
349			oldToNewId[oldId] = midiMapId;
350
351			} else if (type == MIDIMAPPING) {
352			int bank;
353			int prog;
354			String engine;
355			String file;
356			int index;
357			float volume;
358			int loadmode;
359			String name;
360
361			s >> bank >> prog >> engine;
362			s.ignore();
363			std::getline(s, file);
364			s >> type >> index >> volume >> loadmode;
365			s.ignore();
366			std::getline(s, name);
367
368			global->pLSCPServer->AddOrReplaceMIDIInstrumentMapping(
369			midiMapId, bank, prog, engine, file, index, volume,
370			MidiInstrumentMapper::mode_t(loadmode), name, false);
371
372			} else if (type == DEFAULTMIDIMAP) {
373			int oldId;
374			s >> oldId;
375			MidiInstrumentMapper::SetDefaultMap(oldToNewId[oldId]);
376
377			} else { // unknown type
378			// try to be forward-compatible and just skip the line
379			s.ignore(std::numeric_limits<int>::max(), '\n');
380	persson	1777	}
381			}
382
383			return true;
384			}
385			}