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() {

        #if DEBUG
        Thread::setNameOfCaller("HostPlugin");
        #endif

        for (;;) {
            TestCancel();
            sleep(1);

            // prevent thread from being cancelled
            // (e.g. to prevent deadlocks while holding mutex lock(s))
            pushCancelable(false);

            pSampler->fireStatistics();

            // now allow thread being cancelled again
            // (since all mutexes are now unlocked)
            popCancelable();
        }
        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);
    }

    /*
      These methods can be overloaded by different plugin types to map
      file names to/from file names to be used in the state text, making
      it possible for state to be self-contained and/or movable.
    */

    String Plugin::PathToState(const String& string) {
        return string;
    }

    String Plugin::PathFromState(const String& string) {
        return string;
    }

    /*
      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 << ' ' <<
                    PathToState(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() << ' ' <<
                    PathToState(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 = PathFromState(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
90	#if DEBUG
91	Thread::setNameOfCaller("HostPlugin");
92	#endif
93
94	for (;;) {
95	TestCancel();
96	sleep(1);
97
98	// prevent thread from being cancelled
99	// (e.g. to prevent deadlocks while holding mutex lock(s))
100	pushCancelable(false);
101
102	pSampler->fireStatistics();
103
104	// now allow thread being cancelled again
105	// (since all mutexes are now unlocked)
106	popCancelable();
107	}
108	return 0;
109	}
110
111
112	// ************* Plugin *************
113	// *
114
115	PluginGlobal* Plugin::global = 0;
116
117	Plugin::Plugin(bool bDoPreInit) :
118	pAudioDevice(0),
119	pMidiDevice(0) {
120	bPreInitDone = false;
121	if (bDoPreInit) PreInit();
122	}
123
124	void Plugin::PreInit() {
125	if (bPreInitDone) return;
126
127	bPreInitDone = true;
128	if (!global) {
129	global = new PluginGlobal;
130	}
131	global->RefCount++;
132	}
133
134	void Plugin::Init(int SampleRate, int FragmentSize, int Channels) {
135	if (pAudioDevice && SampleRate == pAudioDevice->SampleRate() &&
136	FragmentSize == pAudioDevice->MaxSamplesPerCycle()) {
137	return; // nothing has changed
138	}
139
140	String oldState;
141	if (pAudioDevice) {
142	oldState = GetState();
143	RemoveChannels();
144	AudioOutputDeviceFactory::DestroyPrivate(pAudioDevice);
145	}
146	std::map<String, String> params;
147	params["SAMPLERATE"] = ToString(SampleRate);
148	params["FRAGMENTSIZE"] = ToString(FragmentSize);
149	if (Channels > 0) params["CHANNELS"] = ToString(Channels);
150	pAudioDevice = dynamic_cast<AudioOutputDevicePlugin*>(
151	AudioOutputDeviceFactory::CreatePrivate(
152	AudioOutputDevicePlugin::Name(), params
153	)
154	);
155
156	if (!pMidiDevice) {
157	pMidiDevice = dynamic_cast<MidiInputDevicePlugin*>(
158	MidiInputDeviceFactory::CreatePrivate(
159	MidiInputDevicePlugin::Name(), std::map<String,String>(),
160	global->pSampler
161	)
162	);
163	}
164
165	if (!oldState.empty()) {
166	SetState(oldState);
167	}
168	}
169
170	Plugin::~Plugin() {
171	RemoveChannels();
172	if (pAudioDevice) AudioOutputDeviceFactory::DestroyPrivate(pAudioDevice);
173	if (pMidiDevice) MidiInputDeviceFactory::DestroyPrivate(pMidiDevice);
174	if (bPreInitDone) {
175	if (--global->RefCount == 0) {
176	delete global;
177	global = 0;
178	}
179	}
180	}
181
182	void Plugin::InitState() {
183	SamplerChannel* channel = global->pSampler->AddSamplerChannel();
184	channel->SetEngineType("gig");
185	channel->SetAudioOutputDevice(pAudioDevice);
186	channel->SetMidiInputDevice(pMidiDevice);
187	channel->SetMidiInputChannel(midi_chan_1);
188	}
189
190	/*
191	These methods can be overloaded by different plugin types to map
192	file names to/from file names to be used in the state text, making
193	it possible for state to be self-contained and/or movable.
194	*/
195
196	String Plugin::PathToState(const String& string) {
197	return string;
198	}
199
200	String Plugin::PathFromState(const String& string) {
201	return string;
202	}
203
204	/*
205	The sampler state is stored in a text base format, designed to
206	be easy to parse with the istream >> operator. Values are
207	separated by spaces or newlines. All string values that may
208	contain spaces end with a newline.
209
210	The first line contains the global volume.
211
212	The rest of the lines have an integer first representing the
213	type of information on the line, except for the two lines that
214	describe each sampler channel. The first of these two starts
215	with an integer from 0 to 16 (the midi channel for the sampler
216	channel).
217
218	Note that we should try to keep the parsing of this format both
219	backwards and forwards compatible between versions. The parser
220	ignores lines with unknown type integers and accepts that new
221	types are missing.
222	*/
223
224	enum {
225	FXSEND = 17,
226	MIDIMAP,
227	MIDIMAPPING,
228	DEFAULTMIDIMAP
229	};
230
231	String Plugin::GetState() {
232	std::stringstream s;
233
234	s << GLOBAL_VOLUME << '\n';
235
236	std::vector<int> maps = MidiInstrumentMapper::Maps();
237	for (int i = 0 ; i < maps.size() ; i++) {
238	s << MIDIMAP << ' ' <<
239	maps[i] << ' ' <<
240	MidiInstrumentMapper::MapName(maps[i]) << '\n';
241
242	std::map<midi_prog_index_t, MidiInstrumentMapper::entry_t> mappings = MidiInstrumentMapper::Entries(maps[i]);
243	for (std::map<midi_prog_index_t, MidiInstrumentMapper::entry_t>::iterator iter = mappings.begin() ;
244	iter != mappings.end(); iter++) {
245	s << MIDIMAPPING << ' ' <<
246	((int(iter->first.midi_bank_msb) << 7) \|
247	int(iter->first.midi_bank_lsb)) << ' ' <<
248	int(iter->first.midi_prog) << ' ' <<
249	iter->second.EngineName << ' ' <<
250	PathToState(iter->second.InstrumentFile) << '\n' <<
251	MIDIMAPPING << ' ' <<
252	iter->second.InstrumentIndex << ' ' <<
253	iter->second.Volume << ' ' <<
254	iter->second.LoadMode << ' ' <<
255	iter->second.Name << '\n';
256	}
257	}
258	if (maps.size()) {
259	s << DEFAULTMIDIMAP << ' ' <<
260	MidiInstrumentMapper::GetDefaultMap() << '\n';
261	}
262
263	std::map<uint, SamplerChannel*> channels = global->pSampler->GetSamplerChannels();
264	for (std::map<uint, SamplerChannel*>::iterator iter = channels.begin() ;
265	iter != channels.end() ; iter++) {
266	SamplerChannel* channel = iter->second;
267	if (channel->GetAudioOutputDevice() == pAudioDevice) {
268	EngineChannel* engine_channel = channel->GetEngineChannel();
269	String filename = engine_channel->InstrumentFileName();
270	s << channel->GetMidiInputChannel() << ' ' <<
271	engine_channel->Volume() << ' ' <<
272	PathToState(filename) << '\n' <<
273	engine_channel->InstrumentIndex() << ' ' <<
274	engine_channel->GetSolo() << ' ' <<
275	(engine_channel->GetMute() == 1) << ' ' <<
276	engine_channel->OutputChannel(0) << ' ' <<
277	engine_channel->OutputChannel(1) << ' ' <<
278	(engine_channel->UsesNoMidiInstrumentMap() ? -2 :
279	(engine_channel->UsesDefaultMidiInstrumentMap() ? -1 :
280	engine_channel->GetMidiInstrumentMap())) << ' ' <<
281	engine_channel->EngineName() << '\n';
282
283	for (int i = 0 ; i < engine_channel->GetFxSendCount() ; i++) {
284	FxSend* fxsend = engine_channel->GetFxSend(i);
285	s << FXSEND << ' ' <<
286	fxsend->Level() << ' ' <<
287	int(fxsend->MidiController()) << ' ' <<
288	fxsend->DestinationChannel(0) << ' ' <<
289	fxsend->DestinationChannel(1) << ' ' <<
290	fxsend->Name() << '\n';
291	}
292	}
293	}
294	return s.str();
295	}
296
297	void Plugin::RemoveChannels() {
298	if(global == NULL) return;
299
300	std::map<uint, SamplerChannel*> channels = global->pSampler->GetSamplerChannels();
301
302	for (std::map<uint, SamplerChannel*>::iterator iter = channels.begin() ;
303	iter != channels.end() ; iter++) {
304	if (iter->second->GetAudioOutputDevice() == pAudioDevice) {
305	global->pSampler->RemoveSamplerChannel(iter->second);
306	}
307	}
308	}
309
310	bool Plugin::SetState(String State) {
311	RemoveChannels();
312	MidiInstrumentMapper::RemoveAllMaps();
313
314	std::stringstream s(State);
315	s >> GLOBAL_VOLUME;
316
317	EngineChannel* engine_channel;
318	int midiMapId;
319	std::map<int, int> oldToNewId;
320	int type;
321	while (s >> type) {
322
323	if (type <= 16) { // sampler channel
324	int midiChannel = type;
325	float volume;
326	s >> volume;
327	s.ignore();
328	String filename;
329	std::getline(s, filename);
330	int index;
331	bool solo;
332	bool mute;
333	s >> index >> solo >> mute;
334
335	int left = -1;
336	int right;
337	int oldMapId;
338	String engineType = "gig";
339	if (s.get() == ' ') {
340	s >> left >> right >> oldMapId;
341	if (s.get() == ' ') {
342	s >> engineType;
343	// skip rest of line
344	s.ignore(std::numeric_limits<int>::max(), '\n');
345	}
346	}
347	SamplerChannel* channel = global->pSampler->AddSamplerChannel();
348	channel->SetEngineType(engineType);
349	channel->SetAudioOutputDevice(pAudioDevice);
350	channel->SetMidiInputDevice(pMidiDevice);
351	channel->SetMidiInputChannel(midi_chan_t(midiChannel));
352
353	engine_channel = channel->GetEngineChannel();
354	engine_channel->Volume(volume);
355
356	if (left != -1) {
357	engine_channel->SetOutputChannel(0, left);
358	engine_channel->SetOutputChannel(1, right);
359
360	if (oldMapId == -1) {
361	engine_channel->SetMidiInstrumentMapToDefault();
362	} else if (oldMapId >= 0) {
363	engine_channel->SetMidiInstrumentMap(oldToNewId[oldMapId]);
364	}
365	}
366	if (!filename.empty() && index != -1) {
367	InstrumentManager::instrument_id_t id;
368	id.FileName = PathFromState(filename);
369	id.Index = index;
370	InstrumentManager::LoadInstrumentInBackground(id, engine_channel);
371	}
372	if (solo) engine_channel->SetSolo(solo);
373	if (mute) engine_channel->SetMute(1);
374
375	} else if (type == FXSEND) {
376	float level;
377	int controller;
378	int fxleft;
379	int fxright;
380	String name;
381
382	s >> level >> controller >> fxleft >> fxright;
383	s.ignore();
384	std::getline(s, name);
385	FxSend* send = engine_channel->AddFxSend(controller, name);
386	send->SetLevel(level);
387	send->SetDestinationChannel(0, fxleft);
388	send->SetDestinationChannel(1, fxright);
389
390	} else if (type == MIDIMAP) {
391	int oldId;
392	s >> oldId;
393	String name;
394	s.ignore();
395	std::getline(s, name);
396	midiMapId = MidiInstrumentMapper::AddMap(name);
397	oldToNewId[oldId] = midiMapId;
398
399	} else if (type == MIDIMAPPING) {
400	int bank;
401	int prog;
402	String engine;
403	String file;
404	int index;
405	float volume;
406	int loadmode;
407	String name;
408
409	s >> bank >> prog >> engine;
410	s.ignore();
411	std::getline(s, file);
412	s >> type >> index >> volume >> loadmode;
413	s.ignore();
414	std::getline(s, name);
415
416	global->pLSCPServer->AddOrReplaceMIDIInstrumentMapping(
417	midiMapId, bank, prog, engine, file, index, volume,
418	MidiInstrumentMapper::mode_t(loadmode), name, false);
419
420	} else if (type == DEFAULTMIDIMAP) {
421	int oldId;
422	s >> oldId;
423	MidiInstrumentMapper::SetDefaultMap(oldToNewId[oldId]);
424
425	} else { // unknown type
426	// try to be forward-compatible and just skip the line
427	s.ignore(std::numeric_limits<int>::max(), '\n');
428	}
429	}
430
431	return true;
432	}
433
434	void Plugin::DestroyDevice(AudioOutputDevicePlugin* pDevice) {
435	AudioOutputDeviceFactory::DestroyPrivate(pDevice);
436	}
437
438	void Plugin::DestroyDevice(MidiInputDevicePlugin* pDevice) {
439	MidiInputDeviceFactory::DestroyPrivate(pDevice);
440	}
441	}