src/drivers/Plugin.cpp

/***************************************************************************
 *                                                                         *
 *   Copyright (C) 2008 - 2011 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;

        #if defined(__APPLE__)
        // AU plugin sometimes hangs if bound to loopback
        pLSCPServer = new LSCPServer(pSampler, htonl(INADDR_ANY), htons(LSCP_PORT));
        #else
        // using LOOPBACK instead of ANY to prevent windows firewall
        // warnings
        pLSCPServer = new LSCPServer(pSampler, htonl(INADDR_LOOPBACK), htons(LSCP_PORT));
        #endif

        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();
            AudioOutputDeviceFactory::DestroyPrivate(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*>(
            AudioOutputDeviceFactory::CreatePrivate(
                AudioOutputDevicePlugin::Name(), params
            )
        );

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

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

    Plugin::~Plugin() {
        RemoveChannels();
        if (pAudioDevice) AudioOutputDeviceFactory::DestroyPrivate(pAudioDevice);
        if (pMidiDevice) MidiInputDeviceFactory::DestroyPrivate(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())) << ' ' <<
                    engine_channel->EngineName() << '\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;

                int left = -1;
                int right;
                int oldMapId;
                String engineType = "gig";
                if (s.get() == ' ') {
                    s >> left >> right >> oldMapId;
                    if (s.get() == ' ') {
                        s >> engineType;
                        // skip rest of line
                        s.ignore(std::numeric_limits<int>::max(), '\n');
                    }
                }
                SamplerChannel* channel = global->pSampler->AddSamplerChannel();
                channel->SetEngineType(engineType);
                channel->SetAudioOutputDevice(pAudioDevice);
                channel->SetMidiInputDevice(pMidiDevice);
                channel->SetMidiInputChannel(midi_chan_t(midiChannel));

                engine_channel = channel->GetEngineChannel();
                engine_channel->Volume(volume);

                if (left != -1) {
                    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]);
                    }
                }
                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;
    }

    void Plugin::DestroyDevice(AudioOutputDevicePlugin* pDevice) {
        AudioOutputDeviceFactory::DestroyPrivate(pDevice);
    }

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