LinVst/remotepluginserver.h at master · jhernberg/LinVst · GitHub

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
138
139
140
141
142
143
144
145
/*  dssi-vst: a DSSI plugin wrapper for VST effects and instruments
    Copyright 2004-2007 Chris Cannam
*/


#ifndef REMOTE_PLUGIN_SERVER_H
#define REMOTE_PLUGIN_SERVER_H

#ifdef __WINE__
#else
#define __cdecl
#endif

#include "pluginterfaces/vst2.x/aeffectx.h"

#include "remoteplugin.h"
#include <string>


class RemotePluginServer
{
public:
    virtual                 ~RemotePluginServer();

    virtual float           getVersion() { return RemotePluginVersion; }
    virtual std::string     getName() = 0;
    virtual std::string     getMaker() = 0;

    virtual void            setBufferSize(int) = 0;
    virtual void            setSampleRate(int) = 0;

    virtual void            reset() = 0;
    virtual void            terminate() = 0;

    virtual int             getInputCount() = 0;
    virtual int             getOutputCount() = 0;
    virtual int             getFlags() = 0;
    virtual int             getinitialDelay() = 0;

    virtual int             processVstEvents() = 0;
    virtual void            getChunk() = 0;
    virtual void            setChunk() = 0;
    // virtual void            canBeAutomated() = 0;
    virtual void            getProgram() = 0;
    virtual void            EffectOpen() = 0;

    // virtual int             getUniqueID() = 0;
    // virtual int             getVersion() = 0;
    // virtual void            eff_mainsChanged(int v) = 0;

    virtual int             getUID()                                { return 0; }
    virtual int             getParameterCount()                     { return 0; }
    virtual std::string     getParameterName(int)                   { return ""; }
    virtual void            setParameter(int, float)                { return; }
    virtual float           getParameter(int)                       { return 0.0f; }
    virtual float           getParameterDefault(int)                { return 0.0f; }
    virtual void            getParameters(int p0, int pn, float *v) { for (int i = p0; i <= pn; ++i) v[i - p0] = 0.0f; }

    virtual int             getProgramCount()                       { return 0; }
    virtual std::string     getProgramNameIndexed(int)              { return ""; }
    virtual std::string     getProgramName()                        { return ""; }
    virtual void            setCurrentProgram(int)                  { return; }

    virtual int             getEffInt(int opcode)                   { return 0; }
    virtual std::string     getEffString(int opcode, int index)     { return ""; }
    virtual void            effDoVoid(int opcode)                   { return; }

    virtual void            process(float **inputs, float **outputs, int sampleFrames) = 0;

    virtual void            setDebugLevel(RemotePluginDebugLevel)   { return; }
    virtual bool            warn(std::string) = 0;

    virtual void            showGUI()                               { }
    virtual void            hideGUI()                               { }

#ifdef EMBED
    virtual void            openGUI()                               { }
#endif

    void                    dispatch(int timeout = -1); // may throw RemotePluginClosedException
    void                    dispatchControl(int timeout = -1); // may throw RemotePluginClosedException
    void                    dispatchProcess(int timeout = -1); // may throw RemotePluginClosedException
    void                    dispatchPar(int timeout = -1); // may throw RemotePluginClosedException

   void                     sizeShm();
   char                     *m_shm;
   char                     *m_shm2;
   char                     *m_shm3;
   void                     dispatchParEvents();

#ifdef AMT
    int                     m_AMRequestFd;
    int                     m_AMResponseFd;
#endif
    int                     m_threadsfinish;

protected:
                            RemotePluginServer(std::string fileIdentifiers);
    void                    cleanup();

    int                     m_controlRequestFd;
    int                     m_controlResponseFd;
    int                     m_parRequestFd;
    int                     m_parResponseFd;
    int                     m_processFd;
    int                     m_processResponseFd;

private:
    void                    dispatchControlEvents();
    void                    dispatchProcessEvents();

    int                     m_bufferSize;
    int                     m_numInputs;
    int                     m_numOutputs;
    int                     m_flags;
    int                     m_delay;
    int                     m_shmFd;
    int                     m_shmFd2;
    int                     m_shmFd3;

    char                    *m_controlRequestFileName;
    char                    *m_controlResponseFileName;
    char                    *m_parRequestFileName;
    char                    *m_parResponseFileName;
    char                    *m_processFileName;
    char                    *m_processResponseFileName;

#ifdef AMT
    char                    *m_AMRequestFileName;
    char                    *m_AMResponseFileName;
#endif

    size_t                  m_shmSize;
    size_t                  m_shmSize2;
    size_t                  m_shmSize3;
    char                    *m_shmFileName;
    char                    *m_shmFileName2;
    char                    *m_shmFileName3;

    float                   **m_inputs;
    float                   **m_outputs;

    RemotePluginDebugLevel  m_debugLevel;
};
#endif