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	persson	1777	/***************************************************************************
2			* *
3	persson	2165	* Copyright (C) 2008 - 2011 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	iliev	1994	#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	persson	1777	// using LOOPBACK instead of ANY to prevent windows firewall
56			// warnings
57	iliev	1994	pLSCPServer = new LSCPServer(pSampler, htonl(INADDR_LOOPBACK), htons(LSCP_PORT));
58			#endif
59
60	persson	1777	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	iliev	1835	pLSCPServer->RemoveListeners();
72	persson	1777
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	schoenebeck	3766
90			#if DEBUG
91			Thread::setNameOfCaller("HostPlugin");
92			#endif
93
94	persson	1777	for (;;) {
95	persson	2185	TestCancel();
96	persson	1777	sleep(1);
97	schoenebeck	3766
98			// prevent thread from being cancelled
99			// (e.g. to prevent deadlocks while holding mutex lock(s))
100			pushCancelable(false);
101
102	persson	1777	pSampler->fireStatistics();
103	schoenebeck	3766
104			// now allow thread being cancelled again
105			// (since all mutexes are now unlocked)
106			popCancelable();
107	persson	1777	}
108	persson	1895	return 0;
109	persson	1777	}
110
111
112			// ************* Plugin *************
113			// *
114
115			PluginGlobal* Plugin::global = 0;
116
117	iliev	1835	Plugin::Plugin(bool bDoPreInit) :
118	persson	1777	pAudioDevice(0),
119			pMidiDevice(0) {
120	iliev	1835	bPreInitDone = false;
121			if (bDoPreInit) PreInit();
122			}
123
124			void Plugin::PreInit() {
125			if (bPreInitDone) return;
126
127			bPreInitDone = true;
128	persson	1777	if (!global) {
129			global = new PluginGlobal;
130			}
131			global->RefCount++;
132			}
133
134	iliev	1835	void Plugin::Init(int SampleRate, int FragmentSize, int Channels) {
135	persson	1895	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	schoenebeck	1934	AudioOutputDeviceFactory::DestroyPrivate(pAudioDevice);
145	persson	1895	}
146	persson	1777	std::map<String, String> params;
147			params["SAMPLERATE"] = ToString(SampleRate);
148			params["FRAGMENTSIZE"] = ToString(FragmentSize);
149	iliev	1835	if (Channels > 0) params["CHANNELS"] = ToString(Channels);
150	persson	1777	pAudioDevice = dynamic_cast<AudioOutputDevicePlugin*>(
151	schoenebeck	1934	AudioOutputDeviceFactory::CreatePrivate(
152			AudioOutputDevicePlugin::Name(), params
153			)
154			);
155	persson	1777
156	persson	1895	if (!pMidiDevice) {
157			pMidiDevice = dynamic_cast<MidiInputDevicePlugin*>(
158	schoenebeck	1934	MidiInputDeviceFactory::CreatePrivate(
159			MidiInputDevicePlugin::Name(), std::map<String,String>(),
160			global->pSampler
161			)
162			);
163	persson	1895	}
164
165			if (!oldState.empty()) {
166			SetState(oldState);
167			}
168	persson	1777	}
169
170			Plugin::~Plugin() {
171			RemoveChannels();
172	schoenebeck	1934	if (pAudioDevice) AudioOutputDeviceFactory::DestroyPrivate(pAudioDevice);
173			if (pMidiDevice) MidiInputDeviceFactory::DestroyPrivate(pMidiDevice);
174	iliev	1835	if (bPreInitDone) {
175			if (--global->RefCount == 0) {
176			delete global;
177			global = 0;
178			}
179	persson	1777	}
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	persson	1922	/*
191	capela	2174	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	persson	1922	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	persson	1777
210	persson	1922	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	persson	1777	String Plugin::GetState() {
232			std::stringstream s;
233
234			s << GLOBAL_VOLUME << '\n';
235	persson	1922
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	capela	2174	PathToState(iter->second.InstrumentFile) << '\n' <<
251	persson	1922	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	persson	1777	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	capela	2174	PathToState(filename) << '\n' <<
273	persson	1777	engine_channel->InstrumentIndex() << ' ' <<
274			engine_channel->GetSolo() << ' ' <<
275	persson	1922	(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	persson	2165	engine_channel->GetMidiInstrumentMap())) << ' ' <<
281			engine_channel->EngineName() << '\n';
282	persson	1922
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	persson	1777	}
293			}
294			return s.str();
295			}
296
297			void Plugin::RemoveChannels() {
298	iliev	1835	if(global == NULL) return;
299
300	persson	1777	std::map<uint, SamplerChannel*> channels = global->pSampler->GetSamplerChannels();
301	iliev	1835
302	persson	1777	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	persson	1922	MidiInstrumentMapper::RemoveAllMaps();
313	persson	1777
314			std::stringstream s(State);
315			s >> GLOBAL_VOLUME;
316
317	persson	1922	EngineChannel* engine_channel;
318			int midiMapId;
319			std::map<int, int> oldToNewId;
320			int type;
321			while (s >> type) {
322	persson	1777
323	persson	1922	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	persson	1777
335	persson	2165	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	persson	1922	SamplerChannel* channel = global->pSampler->AddSamplerChannel();
348	persson	2165	channel->SetEngineType(engineType);
349	persson	1922	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	persson	2165
356			if (left != -1) {
357	persson	1922	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	capela	2174	id.FileName = PathFromState(filename);
369	persson	1922	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	persson	1777	}
429			}
430
431			return true;
432			}
433	iliev	1992
434			void Plugin::DestroyDevice(AudioOutputDevicePlugin* pDevice) {
435			AudioOutputDeviceFactory::DestroyPrivate(pDevice);
436			}
437
438			void Plugin::DestroyDevice(MidiInputDevicePlugin* pDevice) {
439			MidiInputDeviceFactory::DestroyPrivate(pDevice);
440			}
441	persson	1777	}