include/plugin_interface/SC_InterfaceTable.h

   1 /*
   2         SuperCollider real time audio synthesis system
   3     Copyright (c) 2002 James McCartney. All rights reserved.
   4         http://www.audiosynth.com
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  19 */
  20
  21 #ifndef _SC_SynthInterfaceTable_
  22 #define _SC_SynthInterfaceTable_
  23
  24 static const int sc_api_version = 2;
  25
  26 #include "SC_Types.h"
  27 #include "SC_SndBuf.h"
  28 #include "SC_Unit.h"
  29 #include "SC_BufGen.h"
  30 #include "SC_FifoMsg.h"
  31 #include "SC_fftlib.h"
  32 #include "SC_Export.h"
  33
  34 #ifndef NO_LIBSNDFILE
  35         #ifdef _WIN32
  36                 #include <sndfile-win.h>
  37         #else
  38                 #include <sndfile.h>
  39         #endif
  40 #endif
  41
  42 struct World;
  43
  44 typedef bool (*AsyncStageFn)(World *inWorld, void* cmdData);
  45 typedef void (*AsyncFreeFn)(World *inWorld, void* cmdData);
  46
  47 struct ScopeBufferHnd
  48 {
  49         void *internalData;
  50         float *data;
  51         uint32 channels;
  52         uint32 maxFrames;
  53
  54         float *channel_data( uint32 channel ) {
  55                 return data + (channel * maxFrames);
  56         }
  57
  58         operator bool ()
  59         {
  60                 return internalData != 0;
  61         }
  62 };
  63
  64 struct InterfaceTable
  65 {
  66         unsigned int mSineSize;
  67         float32 *mSineWavetable;
  68         float32 *mSine;
  69         float32 *mCosecant;
  70
  71         // call printf for debugging. should not use in finished code.
  72         int (*fPrint)(const char *fmt, ...);
  73
  74         // get a seed for a random number generator
  75         int32 (*fRanSeed)();
  76
  77         // define a unit def
  78         bool (*fDefineUnit)(const char *inUnitClassName, size_t inAllocSize,
  79                         UnitCtorFunc inCtor, UnitDtorFunc inDtor, uint32 inFlags);
  80
  81         // define a command  /cmd
  82         bool (*fDefinePlugInCmd)(const char *inCmdName, PlugInCmdFunc inFunc, void* inUserData);
  83
  84         // define a command for a unit generator  /u_cmd
  85         bool (*fDefineUnitCmd)(const char *inUnitClassName, const char *inCmdName, UnitCmdFunc inFunc);
  86
  87         // define a buf gen
  88         bool (*fDefineBufGen)(const char *inName, BufGenFunc inFunc);
  89
  90         // clear all of the unit's outputs.
  91         void (*fClearUnitOutputs)(Unit *inUnit, int inNumSamples);
  92
  93         // non real time memory allocation
  94         void* (*fNRTAlloc)(size_t inSize);
  95         void* (*fNRTRealloc)(void *inPtr, size_t inSize);
  96         void  (*fNRTFree)(void *inPtr);
  97
  98         // real time memory allocation
  99         void* (*fRTAlloc)(World *inWorld, size_t inSize);
 100         void* (*fRTRealloc)(World *inWorld, void *inPtr, size_t inSize);
 101         void  (*fRTFree)(World *inWorld, void *inPtr);
 102
 103         // call to set a Node to run or not.
 104         void (*fNodeRun)(struct Node* node, int run);
 105
 106         // call to stop a Graph after the next buffer.
 107         void (*fNodeEnd)(struct Node* graph);
 108
 109         // send a trigger from a Node to clients
 110         void (*fSendTrigger)(struct Node* inNode, int triggerID, float value);
 111
 112         // send a reply message from a Node to clients
 113         void (*fSendNodeReply)(struct Node* inNode, int replyID, const char* cmdName, int numArgs, const float* values);
 114
 115         // sending messages between real time and non real time levels.
 116         bool (*fSendMsgFromRT)(World *inWorld, struct FifoMsg& inMsg);
 117         bool (*fSendMsgToRT)(World *inWorld, struct FifoMsg& inMsg);
 118
 119         // libsndfile support
 120 #ifdef NO_LIBSNDFILE
 121         int (*fSndFileFormatInfoFromStrings)(void *info,
 122                 const char *headerFormatString, const char *sampleFormatString);
 123 #else
 124         int (*fSndFileFormatInfoFromStrings)(SF_INFO *info,
 125                 const char *headerFormatString, const char *sampleFormatString);
 126 #endif
 127
 128         // get nodes by id
 129         struct Node* (*fGetNode)(World *inWorld, int inID);
 130         struct Graph* (*fGetGraph)(World *inWorld, int inID);
 131
 132         void (*fNRTLock)(World *inWorld);
 133         void (*fNRTUnlock)(World *inWorld);
 134
 135         bool mAltivecAvailable;
 136
 137         void (*fGroup_DeleteAll)(struct Group* group);
 138         void (*fDoneAction)(int doneAction, struct Unit *unit);
 139
 140         int (*fDoAsynchronousCommand)
 141                 (
 142                         World *inWorld,
 143                         void* replyAddr,
 144                         const char* cmdName,
 145                         void *cmdData,
 146                         AsyncStageFn stage2, // stage2 is non real time
 147                         AsyncStageFn stage3, // stage3 is real time - completion msg performed if stage3 returns true
 148                         AsyncStageFn stage4, // stage4 is non real time - sends done if stage4 returns true
 149                         AsyncFreeFn cleanup,
 150                         int completionMsgSize,
 151                         void* completionMsgData
 152                 );
 153
 154
 155         // fBufAlloc should only be called within a BufGenFunc
 156         int (*fBufAlloc)(SndBuf *inBuf, int inChannels, int inFrames, double inSampleRate);
 157
 158         // To initialise a specific FFT, ensure your input and output buffers exist. Internal data structures
 159         // will be allocated using the alloc object,
 160         // Both "fullsize" and "winsize" should be powers of two (this is not checked internally).
 161         struct scfft * (*fSCfftCreate)(size_t fullsize, size_t winsize, SCFFT_WindowFunction wintype,
 162                                          float *indata, float *outdata, SCFFT_Direction forward, SCFFT_Allocator & alloc);
 163
 164         void (*fSCfftDoFFT)(scfft *f);
 165         void (*fSCfftDoIFFT)(scfft *f);
 166
 167         // destroy any resources held internally.
 168         void (*fSCfftDestroy)(scfft *f, SCFFT_Allocator & alloc);
 169
 170         // Get scope buffer. Returns the maximum number of possile frames.
 171         bool (*fGetScopeBuffer)(World *inWorld, int index, int channels, int maxFrames, ScopeBufferHnd &);
 172         void (*fPushScopeBuffer)(World *inWorld, ScopeBufferHnd &, int frames);
 173         void (*fReleaseScopeBuffer)(World *inWorld, ScopeBufferHnd &);
 174 };
 175
 176 typedef struct InterfaceTable InterfaceTable;
 177
 178 #define Print (*ft->fPrint)
 179 #define RanSeed (*ft->fRanSeed)
 180 #define NodeEnd (*ft->fNodeEnd)
 181 #define NodeRun (*ft->fNodeRun)
 182 #define DefineUnit (*ft->fDefineUnit)
 183 #define DefinePlugInCmd (*ft->fDefinePlugInCmd)
 184 #define DefineUnitCmd (*ft->fDefineUnitCmd)
 185 #define DefineBufGen (*ft->fDefineBufGen)
 186 #define ClearUnitOutputs (*ft->fClearUnitOutputs)
 187 #define SendTrigger (*ft->fSendTrigger)
 188 #define SendNodeReply (*ft->fSendNodeReply)
 189 #define SendMsgFromRT (*ft->fSendMsgFromRT)
 190 #define SendMsgToRT (*ft->fSendMsgToRT)
 191 #define DoneAction (*ft->fDoneAction)
 192
 193 #define NRTAlloc (*ft->fNRTAlloc)
 194 #define NRTRealloc (*ft->fNRTRealloc)
 195 #define NRTFree (*ft->fNRTFree)
 196
 197 #define RTAlloc (*ft->fRTAlloc)
 198 #define RTRealloc (*ft->fRTRealloc)
 199 #define RTFree (*ft->fRTFree)
 200
 201 #define SC_GetNode (*ft->fGetNode)
 202 #define SC_GetGraph (*ft->fGetGraph)
 203
 204 #define NRTLock (*ft->fNRTLock)
 205 #define NRTUnlock (*ft->fNRTUnlock)
 206
 207 #define BufAlloc (*ft->fBufAlloc)
 208
 209 #define GroupDeleteAll (*ft->fGroup_DeleteAll)
 210
 211 #define SndFileFormatInfoFromStrings (*ft->fSndFileFormatInfoFromStrings)
 212
 213 #define DoAsynchronousCommand (*ft->fDoAsynchronousCommand)
 214
 215 #define DefineSimpleUnit(name) \
 216         (*ft->fDefineUnit)(#name, sizeof(name), (UnitCtorFunc)&name##_Ctor, 0, 0);
 217
 218 #define DefineDtorUnit(name) \
 219         (*ft->fDefineUnit)(#name, sizeof(name), (UnitCtorFunc)&name##_Ctor, \
 220         (UnitDtorFunc)&name##_Dtor, 0);
 221
 222 #define DefineSimpleCantAliasUnit(name) \
 223         (*ft->fDefineUnit)(#name, sizeof(name), (UnitCtorFunc)&name##_Ctor, 0, kUnitDef_CantAliasInputsToOutputs);
 224
 225 #define DefineDtorCantAliasUnit(name) \
 226         (*ft->fDefineUnit)(#name, sizeof(name), (UnitCtorFunc)&name##_Ctor, \
 227         (UnitDtorFunc)&name##_Dtor, kUnitDef_CantAliasInputsToOutputs);
 228
 229 #ifdef STATIC_PLUGINS
 230         #define PluginLoad(name) void name##_Load(InterfaceTable *inTable)
 231 #else
 232         #define PluginLoad(name)                                                                                                                \
 233                 C_LINKAGE SC_API_EXPORT int api_version(void) { return sc_api_version; }        \
 234                 C_LINKAGE SC_API_EXPORT void load(InterfaceTable *inTable)
 235 #endif
 236
 237 #define scfft_create (*ft->fSCfftCreate)
 238 #define scfft_dofft (*ft->fSCfftDoFFT)
 239 #define scfft_doifft (*ft->fSCfftDoIFFT)
 240 #define scfft_destroy (*ft->fSCfftDestroy)
 241
 242
 243 class SCWorld_Allocator:
 244         public SCFFT_Allocator
 245 {
 246         InterfaceTable * ft;
 247         World * world;
 248
 249 public:
 250         SCWorld_Allocator(InterfaceTable * ft, World * world):
 251                 ft(ft), world(world)
 252         {}
 253
 254         virtual void* alloc(size_t size)
 255         {
 256                 return RTAlloc(world, size);
 257         }
 258
 259         virtual void free(void* ptr)
 260         {
 261                 RTFree(world, ptr);
 262         }
 263 };
 264
 265
 266 #endif