1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
// -*- c-indentation-style:"stroustrup" c-basic-offset: 4 -*-
/*
Rosegarden
A sequencer and musical notation editor.
This program is Copyright 2000-2008
Guillaume Laurent <[email protected]>,
Chris Cannam <[email protected]>,
Richard Bown <[email protected]>
The moral right of the authors to claim authorship of this work
has been asserted.
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. See the file
COPYING included with this distribution for more information.
*/
#include <vector>
#include <set>
#include <qstring.h>
#include "Instrument.h"
#ifndef _LADSPAPLUGININSTANCE_H_
#define _LADSPAPLUGININSTANCE_H_
#ifdef HAVE_LADSPA
#include <ladspa.h>
#include "RunnablePluginInstance.h"
namespace Rosegarden
{
// LADSPA plugin instance. LADSPA is a variable block size API, but
// for one reason and another it's more convenient to use a fixed
// block size in this wrapper.
//
class LADSPAPluginInstance : public RunnablePluginInstance
{
public:
virtual ~LADSPAPluginInstance();
virtual bool isOK() const { return m_instanceHandles.size() != 0; }
InstrumentId getInstrument() const { return m_instrument; }
virtual QString getIdentifier() const { return m_identifier; }
int getPosition() const { return m_position; }
virtual void run(const RealTime &rt);
virtual void setPortValue(unsigned int portNumber, float value);
virtual float getPortValue(unsigned int portNumber);
virtual size_t getBufferSize() { return m_blockSize; }
virtual size_t getAudioInputCount() { return m_instanceCount * m_audioPortsIn.size(); }
virtual size_t getAudioOutputCount() { return m_instanceCount * m_audioPortsOut.size(); }
virtual sample_t **getAudioInputBuffers() { return m_inputBuffers; }
virtual sample_t **getAudioOutputBuffers() { return m_outputBuffers; }
virtual bool isBypassed() const { return m_bypassed; }
virtual void setBypassed(bool bypassed) { m_bypassed = bypassed; }
virtual size_t getLatency();
virtual void silence();
virtual void setIdealChannelCount(size_t channels); // may re-instantiate
protected:
// To be constructed only by LADSPAPluginFactory
friend class LADSPAPluginFactory;
// Constructor that creates the buffers internally
//
LADSPAPluginInstance(PluginFactory *factory,
InstrumentId instrument,
QString identifier,
int position,
unsigned long sampleRate,
size_t blockSize,
int idealChannelCount,
const LADSPA_Descriptor* descriptor);
// Constructor that uses shared buffers
//
LADSPAPluginInstance(PluginFactory *factory,
InstrumentId instrument,
QString identifier,
int position,
unsigned long sampleRate,
size_t blockSize,
sample_t **inputBuffers,
sample_t **outputBuffers,
const LADSPA_Descriptor* descriptor);
void init(int idealChannelCount = 0);
void instantiate(unsigned long sampleRate);
void cleanup();
void activate();
void deactivate();
// Connection of data (and behind the scenes control) ports
//
void connectPorts();
InstrumentId m_instrument;
int m_position;
std::vector<LADSPA_Handle> m_instanceHandles;
size_t m_instanceCount;
const LADSPA_Descriptor *m_descriptor;
std::vector<std::pair<unsigned long, LADSPA_Data*> > m_controlPortsIn;
std::vector<std::pair<unsigned long, LADSPA_Data*> > m_controlPortsOut;
std::vector<int> m_audioPortsIn;
std::vector<int> m_audioPortsOut;
size_t m_blockSize;
sample_t **m_inputBuffers;
sample_t **m_outputBuffers;
bool m_ownBuffers;
size_t m_sampleRate;
float *m_latencyPort;
bool m_run;
bool m_bypassed;
};
}
#endif // HAVE_LADSPA
#endif // _LADSPAPLUGININSTANCE_H_
|
