hostplugins/lv2/PluginLv2.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 <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <string>

#include "PluginLv2.h"

namespace {

    PluginLv2::PluginLv2(const LV2_Descriptor* Descriptor,
                         double SampleRate, const char* BundlePath,
                         const LV2_Feature* const* Features) {
        Out[0] = 0;
        Out[1] = 0;
        for (int i = 0 ; Features[i] ; i++) {
            dmsg(2, ("linuxsampler: host feature: %s\n", Features[i]->URI));
        }

        Init(SampleRate, 128);

        InitState();
    }

    void PluginLv2::ConnectPort(uint32_t Port, void* DataLocation) {
        if (Port == 2) {
            MidiBuf = static_cast<LV2_Event_Buffer*>(DataLocation);
        } else if (Port < 2) {
            Out[Port] = static_cast<float*>(DataLocation);
        }
    }

    void PluginLv2::Activate() {
        dmsg(2, ("linuxsampler: Activate\n"));
    }

    void PluginLv2::Run(uint32_t SampleCount) {
        int samplePos = 0;
        uint8_t* events = MidiBuf->data;
        int eventCount = MidiBuf->event_count;
        while (SampleCount) {
            int samples = std::min(SampleCount, 128U);

            for ( ; eventCount ; eventCount--) {
                LV2_Event* event = reinterpret_cast<LV2_Event*>(events);

                int time = event->frames - samplePos;
                if (time >= samples) break;

                uint8_t* data = events + sizeof(LV2_Event);
                events += (sizeof(LV2_Event) + event->size + 7) & ~7;

                pMidiDevice->Port()->DispatchRaw(data, time);
            }
            pAudioDevice->Channel(0)->SetBuffer(Out[0] + samplePos);
            pAudioDevice->Channel(1)->SetBuffer(Out[1] + samplePos);
            pAudioDevice->Render(samples);

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

    void PluginLv2::Deactivate() {
        dmsg(2, ("linuxsampler: Deactivate\n"));
    }

    char* PluginLv2::Save(const char* Directory, LV2SR_File*** Files) {
        dmsg(2, ("linuxsampler: Save Directory=%s\n", Directory));

        String filename(Directory);
        filename += "/linuxsampler";
        dmsg(2, ("saving to %s\n", filename.c_str()));
        std::ofstream out(filename.c_str());
        out << GetState();
        out.close();

        LV2SR_File** filearr = static_cast<LV2SR_File**>(malloc(sizeof(LV2SR_File*) * 2));

        LV2SR_File* file = static_cast<LV2SR_File*>(malloc(sizeof(LV2SR_File)));
        file->name = strdup("linuxsampler");
        file->path = strdup(filename.c_str());
        file->must_copy = 0;

        filearr[0] = file;
        filearr[1] = 0;

        *Files = filearr;

        dmsg(2, ("saving done\n"));
        return 0;
    }

    char* PluginLv2::Restore(const LV2SR_File** Files) {
        dmsg(2, ("linuxsampler: restore\n"));
        for (int i = 0 ; Files[i] ; i++) {
            dmsg(2, ("  name=%s path=%s\n", Files[i]->name, Files[i]->path));
            if (strcmp(Files[i]->name, "linuxsampler") == 0) {
                std::ifstream in(Files[0]->path);
                String state;
                std::getline(in, state, '\0');
                SetState(state);
            }
        }
        return 0;
    }

    LV2_Handle instantiate(const LV2_Descriptor* descriptor,
                           double sample_rate, const char* bundle_path,
                           const LV2_Feature* const* features) {
        return new PluginLv2(descriptor, sample_rate, bundle_path, features);
    }

    void connect_port(LV2_Handle instance, uint32_t port, void* data_location) {
        static_cast<PluginLv2*>(instance)->ConnectPort(port, data_location);
    }

    void activate(LV2_Handle instance) {
        static_cast<PluginLv2*>(instance)->Activate();
    }

    void run(LV2_Handle instance, uint32_t sample_count) {
        static_cast<PluginLv2*>(instance)->Run(sample_count);
    }

    void deactivate(LV2_Handle instance) {
        static_cast<PluginLv2*>(instance)->Deactivate();
    }

    void cleanup(LV2_Handle instance) {
        delete static_cast<PluginLv2*>(instance);
    }

    char* save(LV2_Handle handle, const char* directory, LV2SR_File*** files) {
        return static_cast<PluginLv2*>(handle)->Save(directory, files);
    }

    char* restore(LV2_Handle handle, const LV2SR_File** files) {
        return static_cast<PluginLv2*>(handle)->Restore(files);
    }

    PluginInfo PluginInfo::Instance;

    PluginInfo::PluginInfo() {
        Lv2.URI = "http://linuxsampler.org/plugins/linuxsampler";
        Lv2.activate = activate;
        Lv2.cleanup = cleanup;
        Lv2.connect_port = connect_port;
        Lv2.deactivate = deactivate;
        Lv2.instantiate = instantiate;
        Lv2.run = run;
        Lv2.extension_data = extension_data;
        Lv2sr.save = save;
        Lv2sr.restore = restore;
    }


    const void* extension_data(const char* uri) {
        dmsg(2, ("linuxsampler: extension_data %s\n", uri));
        if (strcmp(uri, LV2_SAVERESTORE_URI) == 0) {
            return PluginInfo::Lv2srDescriptor();
        }
        return 0;
    }
}


extern "C" {
    LV2_SYMBOL_EXPORT
    const LV2_Descriptor* lv2_descriptor(uint32_t index) {
        return index == 0 ? PluginInfo::Lv2Descriptor() : 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 <cstdio>
23			#include <cstdlib>
24			#include <cstring>
25			#include <fstream>
26			#include <string>
27
28			#include "PluginLv2.h"
29
30			namespace {
31
32			PluginLv2::PluginLv2(const LV2_Descriptor* Descriptor,
33			double SampleRate, const char* BundlePath,
34			const LV2_Feature* const* Features) {
35			Out[0] = 0;
36			Out[1] = 0;
37			for (int i = 0 ; Features[i] ; i++) {
38			dmsg(2, ("linuxsampler: host feature: %s\n", Features[i]->URI));
39			}
40
41			Init(SampleRate, 128);
42
43			InitState();
44			}
45
46			void PluginLv2::ConnectPort(uint32_t Port, void* DataLocation) {
47			if (Port == 2) {
48			MidiBuf = static_cast<LV2_Event_Buffer*>(DataLocation);
49			} else if (Port < 2) {
50			Out[Port] = static_cast<float*>(DataLocation);
51			}
52			}
53
54			void PluginLv2::Activate() {
55			dmsg(2, ("linuxsampler: Activate\n"));
56			}
57
58			void PluginLv2::Run(uint32_t SampleCount) {
59			int samplePos = 0;
60			uint8_t* events = MidiBuf->data;
61			int eventCount = MidiBuf->event_count;
62			while (SampleCount) {
63			int samples = std::min(SampleCount, 128U);
64
65			for ( ; eventCount ; eventCount--) {
66			LV2_Event* event = reinterpret_cast<LV2_Event*>(events);
67
68			int time = event->frames - samplePos;
69			if (time >= samples) break;
70
71			uint8_t* data = events + sizeof(LV2_Event);
72			events += (sizeof(LV2_Event) + event->size + 7) & ~7;
73
74			pMidiDevice->Port()->DispatchRaw(data, time);
75			}
76			pAudioDevice->Channel(0)->SetBuffer(Out[0] + samplePos);
77			pAudioDevice->Channel(1)->SetBuffer(Out[1] + samplePos);
78			pAudioDevice->Render(samples);
79
80			samplePos += samples;
81			SampleCount -= samples;
82			}
83			}
84
85			void PluginLv2::Deactivate() {
86			dmsg(2, ("linuxsampler: Deactivate\n"));
87			}
88
89			char* PluginLv2::Save(const char* Directory, LV2SR_File*** Files) {
90			dmsg(2, ("linuxsampler: Save Directory=%s\n", Directory));
91
92			String filename(Directory);
93			filename += "/linuxsampler";
94			dmsg(2, ("saving to %s\n", filename.c_str()));
95			std::ofstream out(filename.c_str());
96			out << GetState();
97			out.close();
98
99			LV2SR_File filearr = static_cast<LV2SR_File>(malloc(sizeof(LV2SR_File) 2));
100
101			LV2SR_File* file = static_cast<LV2SR_File*>(malloc(sizeof(LV2SR_File)));
102			file->name = strdup("linuxsampler");
103			file->path = strdup(filename.c_str());
104			file->must_copy = 0;
105
106			filearr[0] = file;
107			filearr[1] = 0;
108
109			*Files = filearr;
110
111			dmsg(2, ("saving done\n"));
112			return 0;
113			}
114
115			char* PluginLv2::Restore(const LV2SR_File** Files) {
116			dmsg(2, ("linuxsampler: restore\n"));
117			for (int i = 0 ; Files[i] ; i++) {
118			dmsg(2, (" name=%s path=%s\n", Files[i]->name, Files[i]->path));
119			if (strcmp(Files[i]->name, "linuxsampler") == 0) {
120			std::ifstream in(Files[0]->path);
121			String state;
122			std::getline(in, state, '\0');
123			SetState(state);
124			}
125			}
126			return 0;
127			}
128
129			LV2_Handle instantiate(const LV2_Descriptor* descriptor,
130			double sample_rate, const char* bundle_path,
131			const LV2_Feature* const* features) {
132			return new PluginLv2(descriptor, sample_rate, bundle_path, features);
133			}
134
135			void connect_port(LV2_Handle instance, uint32_t port, void* data_location) {
136			static_cast<PluginLv2*>(instance)->ConnectPort(port, data_location);
137			}
138
139			void activate(LV2_Handle instance) {
140			static_cast<PluginLv2*>(instance)->Activate();
141			}
142
143			void run(LV2_Handle instance, uint32_t sample_count) {
144			static_cast<PluginLv2*>(instance)->Run(sample_count);
145			}
146
147			void deactivate(LV2_Handle instance) {
148			static_cast<PluginLv2*>(instance)->Deactivate();
149			}
150
151			void cleanup(LV2_Handle instance) {
152			delete static_cast<PluginLv2*>(instance);
153			}
154
155			char* save(LV2_Handle handle, const char* directory, LV2SR_File*** files) {
156			return static_cast<PluginLv2*>(handle)->Save(directory, files);
157			}
158
159			char* restore(LV2_Handle handle, const LV2SR_File** files) {
160			return static_cast<PluginLv2*>(handle)->Restore(files);
161			}
162
163			PluginInfo PluginInfo::Instance;
164
165			PluginInfo::PluginInfo() {
166			Lv2.URI = "http://linuxsampler.org/plugins/linuxsampler";
167			Lv2.activate = activate;
168			Lv2.cleanup = cleanup;
169			Lv2.connect_port = connect_port;
170			Lv2.deactivate = deactivate;
171			Lv2.instantiate = instantiate;
172			Lv2.run = run;
173			Lv2.extension_data = extension_data;
174			Lv2sr.save = save;
175			Lv2sr.restore = restore;
176			}
177
178
179			const void* extension_data(const char* uri) {
180			dmsg(2, ("linuxsampler: extension_data %s\n", uri));
181			if (strcmp(uri, LV2_SAVERESTORE_URI) == 0) {
182			return PluginInfo::Lv2srDescriptor();
183			}
184			return 0;
185			}
186			}
187
188
189			extern "C" {
190			LV2_SYMBOL_EXPORT
191			const LV2_Descriptor* lv2_descriptor(uint32_t index) {
192			return index == 0 ? PluginInfo::Lv2Descriptor() : 0;
193			}
194			}