hostplugins/dssi/PluginDssi.cpp

/***************************************************************************
 *                                                                         *
 *   Copyright (C) 2008 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 <algorithm>
#include <cstring>
#include <exception>
#include <sstream>
#include <string>

#include "PluginDssi.h"


namespace {

// *************** PluginDssi ***************
// *

    PluginDssi::PluginDssi(unsigned long SampleRate) {
        Out[0] = 0;
        Out[1] = 0;

        // As there is no way in DSSI of knowing a max value of the
        // output buffer size, we set the audio device buffer size to
        // 128 and let RunSynth call Render in a loop if needed.
        Init(SampleRate, 128);

        pChannel = global->pSampler->AddSamplerChannel();
        pChannel->SetEngineType("gig");
        pChannel->SetAudioOutputDevice(pAudioDevice);
        pChannel->SetMidiInputDevice(pMidiDevice);
    }

    PluginDssi::~PluginDssi() {
    }

    void PluginDssi::ConnectPort(unsigned long Port, LADSPA_Data* DataLocation) {
        if (Port < 2) Out[Port] = DataLocation;
    }

    char* PluginDssi::Configure(const char* Key, const char* Value) {
        dmsg(2, ("linuxsampler: configure Key=%s Value=%s\n", Key, Value));

        if (strcmp(Key, "instrument") == 0 && strcmp(Value, "") != 0) {
            String filename(Value);
            String::size_type colon = filename.rfind(':');
            int instrument = 0;
            if (colon != String::npos) {
                std::stringstream(String(filename, colon + 1)) >> instrument;
                filename.erase(colon);
            }
            try {
                LinuxSampler::EngineChannel* engineChannel =
                    pChannel->GetEngineChannel();
                dmsg(2, ("  before LoadInstrument\n"));
                engineChannel->PrepareLoadInstrument(filename.c_str(),
                                                      instrument);
                engineChannel->LoadInstrument();
                dmsg(2, ("  after LoadInstrument\n"));
            }
            catch (std::exception& e) {
                return strdup(e.what());
            }
        }

        return 0;
    }

    inline void PluginDssi::RunSynth(unsigned long SampleCount,
                                     snd_seq_event_t* Events,
                                     unsigned long EventCount) {
        LinuxSampler::MidiInputPort* port = pMidiDevice->Port();
        int samplePos = 0;
        unsigned eventPos = 0;
        while (SampleCount) {
            int samples = std::min(SampleCount, 128UL);

            for ( ; eventPos < EventCount ; eventPos++) {
                snd_seq_event_t* ev = &Events[eventPos];
                int time = ev->time.tick - samplePos;
                if (time >= samples) break;
                switch (ev->type) {
                case SND_SEQ_EVENT_CONTROLLER:
                    port->DispatchControlChange(ev->data.control.param,
                                                ev->data.control.value,
                                                ev->data.control.channel, time);
                    break;

                case SND_SEQ_EVENT_CHANPRESS:
                    port->DispatchControlChange(128, ev->data.control.value,
                                                ev->data.control.channel, time);
                    break;

                case SND_SEQ_EVENT_PITCHBEND:
                    port->DispatchPitchbend(ev->data.control.value,
                                            ev->data.control.channel, time);
                    break;

                case SND_SEQ_EVENT_NOTEON:
                    port->DispatchNoteOn(ev->data.note.note,
                                         ev->data.note.velocity,
                                         ev->data.control.channel, time);
                    break;

                case SND_SEQ_EVENT_NOTEOFF:
                    port->DispatchNoteOff(ev->data.note.note,
                                          ev->data.note.velocity,
                                          ev->data.control.channel, time);
                    break;

                case SND_SEQ_EVENT_SYSEX:
                    port->DispatchSysex(ev->data.ext.ptr, ev->data.ext.len);
                    break;
                }
            }

            pAudioDevice->Channel(0)->SetBuffer(Out[0] + samplePos);
            pAudioDevice->Channel(1)->SetBuffer(Out[1] + samplePos);
            pAudioDevice->Render(samples);

            samplePos += samples;
            SampleCount -= samples;
        }
    }

    void PluginDssi::Activate() {
        dmsg(2, ("linuxsampler: activate instance=%p\n", static_cast<void*>(this)));
        pMidiDevice->Port()->DispatchControlChange(123, 0, 0, 0); // all sound off
    }


// *************** LADSPA callback functions ***************
// *

    LADSPA_Handle instantiate(const LADSPA_Descriptor* Descriptor,
                              unsigned long SampleRate) {
        return new PluginDssi(SampleRate);
    }

    void cleanup(LADSPA_Handle Instance) {
        dmsg(2, ("linuxsampler: cleanup Instance=%p\n", static_cast<void*>(Instance)));
        delete static_cast<PluginDssi*>(Instance);
    }

    void activate(LADSPA_Handle Instance) {
        static_cast<PluginDssi*>(Instance)->Activate();
    }

    void connect_port(LADSPA_Handle Instance, unsigned long Port,
                      LADSPA_Data* DataLocation) {
        static_cast<PluginDssi*>(Instance)->ConnectPort(Port, DataLocation);
    }

    void run(LADSPA_Handle Instance, unsigned long SampleCount) {
        static_cast<PluginDssi*>(Instance)->RunSynth(SampleCount, 0, 0);
    }


// *************** DSSI callback functions ***************
// *

    void run_synth(LADSPA_Handle Instance, unsigned long SampleCount,
                   snd_seq_event_t* Events, unsigned long EventCount) {
        static_cast<PluginDssi*>(Instance)->RunSynth(SampleCount, Events, EventCount);
    }

    void run_multiple_synths(unsigned long InstanceCount,
                             LADSPA_Handle* Instances,
                             unsigned long SampleCount,
                             snd_seq_event_t** Events,
                             unsigned long* EventCounts)
    {
        for (unsigned long i = 0 ; i < InstanceCount ; i++) {
            static_cast<PluginDssi*>(Instances[i])->RunSynth(SampleCount, Events[i],
                                                             EventCounts[i]);
        }
    }

    char* configure(LADSPA_Handle Instance, const char* Key, const char* Value) {
        return static_cast<PluginDssi*>(Instance)->Configure(Key, Value);
    }


// *************** PluginInfo ***************
// *

    PluginInfo PluginInfo::Instance;

    PluginInfo::PluginInfo() {
        Ladspa.UniqueID = 3781; // (received from ladspa.org)
        Ladspa.Label = "LinuxSampler";
        Ladspa.Properties = 0;
        Ladspa.Name = "LinuxSampler";
        Ladspa.Maker = "linuxsampler.org";
        Ladspa.Copyright = "(C) 2003,2004 Benno Senoner and Christian Schoenebeck, "
            "2005-2008 Christian Schoenebeck";
        Ladspa.PortCount = 2;
        Ladspa.ImplementationData = 0;
        Ladspa.PortDescriptors = PortDescriptors;
        Ladspa.PortRangeHints = PortRangeHints;
        Ladspa.PortNames = PortNames;

        PortDescriptors[0] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
        PortNames[0] = "Output Left";
        PortRangeHints[0].HintDescriptor = 0;
        PortDescriptors[1] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
        PortNames[1] = "Output Right";
        PortRangeHints[1].HintDescriptor = 0;

        Ladspa.activate = activate;
        Ladspa.cleanup = cleanup;
        Ladspa.connect_port = connect_port;
        Ladspa.deactivate = 0;
        Ladspa.instantiate = instantiate;
        Ladspa.run = run;
        Ladspa.run_adding = 0;
        Ladspa.set_run_adding_gain = 0;

        Dssi.DSSI_API_Version = 1;
        Dssi.LADSPA_Plugin = &Ladspa;
        Dssi.configure = configure;
        Dssi.get_program = 0;
        Dssi.get_midi_controller_for_port = 0;
        Dssi.select_program = 0;
        Dssi.run_synth = run_synth;
        Dssi.run_synth_adding = 0;
        Dssi.run_multiple_synths = run_multiple_synths;
        Dssi.run_multiple_synths_adding = 0;
    }
}


extern "C" {
    const LADSPA_Descriptor* ladspa_descriptor(unsigned long Index) {
        dmsg(2, ("linuxsampler: ladspa_descriptor\n"));
        return Index == 0 ? PluginInfo::LadspaDescriptor() : 0;
    }

    const DSSI_Descriptor *dssi_descriptor(unsigned long Index) {
        dmsg(2, ("linuxsampler: dssi_descriptor\n"));
        return Index == 0 ? PluginInfo::DssiDescriptor() : 0;
    }
}
1	persson	1777	/***************************************************************************
2			* *
3			* Copyright (C) 2008 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 <algorithm>
22			#include <cstring>
23			#include <exception>
24			#include <sstream>
25			#include <string>
26
27			#include "PluginDssi.h"
28
29
30			namespace {
31
32			// ************* PluginDssi *************
33			// *
34
35			PluginDssi::PluginDssi(unsigned long SampleRate) {
36			Out[0] = 0;
37			Out[1] = 0;
38
39			// As there is no way in DSSI of knowing a max value of the
40			// output buffer size, we set the audio device buffer size to
41			// 128 and let RunSynth call Render in a loop if needed.
42			Init(SampleRate, 128);
43
44			pChannel = global->pSampler->AddSamplerChannel();
45			pChannel->SetEngineType("gig");
46			pChannel->SetAudioOutputDevice(pAudioDevice);
47			pChannel->SetMidiInputDevice(pMidiDevice);
48			}
49
50			PluginDssi::~PluginDssi() {
51			}
52
53			void PluginDssi::ConnectPort(unsigned long Port, LADSPA_Data* DataLocation) {
54			if (Port < 2) Out[Port] = DataLocation;
55			}
56
57			char* PluginDssi::Configure(const char* Key, const char* Value) {
58			dmsg(2, ("linuxsampler: configure Key=%s Value=%s\n", Key, Value));
59
60			if (strcmp(Key, "instrument") == 0 && strcmp(Value, "") != 0) {
61			String filename(Value);
62			String::size_type colon = filename.rfind(':');
63			int instrument = 0;
64			if (colon != String::npos) {
65			std::stringstream(String(filename, colon + 1)) >> instrument;
66			filename.erase(colon);
67			}
68			try {
69			LinuxSampler::EngineChannel* engineChannel =
70			pChannel->GetEngineChannel();
71			dmsg(2, (" before LoadInstrument\n"));
72			engineChannel->PrepareLoadInstrument(filename.c_str(),
73			instrument);
74			engineChannel->LoadInstrument();
75			dmsg(2, (" after LoadInstrument\n"));
76			}
77			catch (std::exception& e) {
78			return strdup(e.what());
79			}
80			}
81
82			return 0;
83			}
84
85			inline void PluginDssi::RunSynth(unsigned long SampleCount,
86			snd_seq_event_t* Events,
87			unsigned long EventCount) {
88			LinuxSampler::MidiInputPort* port = pMidiDevice->Port();
89			int samplePos = 0;
90			unsigned eventPos = 0;
91			while (SampleCount) {
92			int samples = std::min(SampleCount, 128UL);
93
94			for ( ; eventPos < EventCount ; eventPos++) {
95			snd_seq_event_t* ev = &Events[eventPos];
96			int time = ev->time.tick - samplePos;
97			if (time >= samples) break;
98			switch (ev->type) {
99			case SND_SEQ_EVENT_CONTROLLER:
100			port->DispatchControlChange(ev->data.control.param,
101			ev->data.control.value,
102			ev->data.control.channel, time);
103			break;
104
105			case SND_SEQ_EVENT_CHANPRESS:
106			port->DispatchControlChange(128, ev->data.control.value,
107			ev->data.control.channel, time);
108			break;
109
110			case SND_SEQ_EVENT_PITCHBEND:
111			port->DispatchPitchbend(ev->data.control.value,
112			ev->data.control.channel, time);
113			break;
114
115			case SND_SEQ_EVENT_NOTEON:
116			port->DispatchNoteOn(ev->data.note.note,
117			ev->data.note.velocity,
118			ev->data.control.channel, time);
119			break;
120
121			case SND_SEQ_EVENT_NOTEOFF:
122			port->DispatchNoteOff(ev->data.note.note,
123			ev->data.note.velocity,
124			ev->data.control.channel, time);
125			break;
126
127			case SND_SEQ_EVENT_SYSEX:
128			port->DispatchSysex(ev->data.ext.ptr, ev->data.ext.len);
129			break;
130			}
131			}
132
133			pAudioDevice->Channel(0)->SetBuffer(Out[0] + samplePos);
134			pAudioDevice->Channel(1)->SetBuffer(Out[1] + samplePos);
135			pAudioDevice->Render(samples);
136
137			samplePos += samples;
138			SampleCount -= samples;
139			}
140			}
141
142			void PluginDssi::Activate() {
143			dmsg(2, ("linuxsampler: activate instance=%p\n", static_cast<void*>(this)));
144			pMidiDevice->Port()->DispatchControlChange(123, 0, 0, 0); // all sound off
145			}
146
147
148			// ************* LADSPA callback functions *************
149			// *
150
151			LADSPA_Handle instantiate(const LADSPA_Descriptor* Descriptor,
152			unsigned long SampleRate) {
153			return new PluginDssi(SampleRate);
154			}
155
156			void cleanup(LADSPA_Handle Instance) {
157			dmsg(2, ("linuxsampler: cleanup Instance=%p\n", static_cast<void*>(Instance)));
158			delete static_cast<PluginDssi*>(Instance);
159			}
160
161			void activate(LADSPA_Handle Instance) {
162			static_cast<PluginDssi*>(Instance)->Activate();
163			}
164
165			void connect_port(LADSPA_Handle Instance, unsigned long Port,
166			LADSPA_Data* DataLocation) {
167			static_cast<PluginDssi*>(Instance)->ConnectPort(Port, DataLocation);
168			}
169
170			void run(LADSPA_Handle Instance, unsigned long SampleCount) {
171			static_cast<PluginDssi*>(Instance)->RunSynth(SampleCount, 0, 0);
172			}
173
174
175			// ************* DSSI callback functions *************
176			// *
177
178			void run_synth(LADSPA_Handle Instance, unsigned long SampleCount,
179			snd_seq_event_t* Events, unsigned long EventCount) {
180			static_cast<PluginDssi*>(Instance)->RunSynth(SampleCount, Events, EventCount);
181			}
182
183			void run_multiple_synths(unsigned long InstanceCount,
184			LADSPA_Handle* Instances,
185			unsigned long SampleCount,
186			snd_seq_event_t** Events,
187			unsigned long* EventCounts)
188			{
189			for (unsigned long i = 0 ; i < InstanceCount ; i++) {
190			static_cast<PluginDssi*>(Instances[i])->RunSynth(SampleCount, Events[i],
191			EventCounts[i]);
192			}
193			}
194
195			char* configure(LADSPA_Handle Instance, const char* Key, const char* Value) {
196			return static_cast<PluginDssi*>(Instance)->Configure(Key, Value);
197			}
198
199
200			// ************* PluginInfo *************
201			// *
202
203			PluginInfo PluginInfo::Instance;
204
205			PluginInfo::PluginInfo() {
206			Ladspa.UniqueID = 3781; // (received from ladspa.org)
207			Ladspa.Label = "LinuxSampler";
208			Ladspa.Properties = 0;
209			Ladspa.Name = "LinuxSampler";
210			Ladspa.Maker = "linuxsampler.org";
211			Ladspa.Copyright = "(C) 2003,2004 Benno Senoner and Christian Schoenebeck, "
212			"2005-2008 Christian Schoenebeck";
213			Ladspa.PortCount = 2;
214			Ladspa.ImplementationData = 0;
215			Ladspa.PortDescriptors = PortDescriptors;
216			Ladspa.PortRangeHints = PortRangeHints;
217			Ladspa.PortNames = PortNames;
218
219			PortDescriptors[0] = LADSPA_PORT_OUTPUT \| LADSPA_PORT_AUDIO;
220			PortNames[0] = "Output Left";
221			PortRangeHints[0].HintDescriptor = 0;
222			PortDescriptors[1] = LADSPA_PORT_OUTPUT \| LADSPA_PORT_AUDIO;
223			PortNames[1] = "Output Right";
224			PortRangeHints[1].HintDescriptor = 0;
225
226			Ladspa.activate = activate;
227			Ladspa.cleanup = cleanup;
228			Ladspa.connect_port = connect_port;
229			Ladspa.deactivate = 0;
230			Ladspa.instantiate = instantiate;
231			Ladspa.run = run;
232			Ladspa.run_adding = 0;
233			Ladspa.set_run_adding_gain = 0;
234
235			Dssi.DSSI_API_Version = 1;
236			Dssi.LADSPA_Plugin = &Ladspa;
237			Dssi.configure = configure;
238			Dssi.get_program = 0;
239			Dssi.get_midi_controller_for_port = 0;
240			Dssi.select_program = 0;
241			Dssi.run_synth = run_synth;
242			Dssi.run_synth_adding = 0;
243			Dssi.run_multiple_synths = run_multiple_synths;
244			Dssi.run_multiple_synths_adding = 0;
245			}
246			}
247
248
249			extern "C" {
250			const LADSPA_Descriptor* ladspa_descriptor(unsigned long Index) {
251			dmsg(2, ("linuxsampler: ladspa_descriptor\n"));
252			return Index == 0 ? PluginInfo::LadspaDescriptor() : 0;
253			}
254
255			const DSSI_Descriptor *dssi_descriptor(unsigned long Index) {
256			dmsg(2, ("linuxsampler: dssi_descriptor\n"));
257			return Index == 0 ? PluginInfo::DssiDescriptor() : 0;
258			}
259			}