include/plugin_interface/SC_PlugIn.hpp

   1 /*
   2  *    SuperCollider real time audio synthesis system
   3  *    Copyright (c) 2002 James McCartney. All rights reserved.
   4  *    Copyright (c) 2011 Tim Blechmann
   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_PLUGIN_HPP
  22 #define SC_PLUGIN_HPP
  23
  24 #include "SC_PlugIn.h"
  25
  26 // c++ wrapper for Unit struct
  27 class SCUnit:
  28         public Unit
  29 {
  30 public:
  31         const float * in(int index) const
  32         {
  33                 const Unit * unit = this;
  34                 return IN(index);
  35         }
  36
  37         const float * zin(int index) const
  38         {
  39                 const Unit * unit = this;
  40                 return ZIN(index);
  41         }
  42
  43         float const & in0(int index) const
  44         {
  45                 const Unit * unit = this;
  46                 return IN0(index);
  47         }
  48
  49         float * out(int index) const
  50         {
  51                 const Unit * unit = this;
  52                 return OUT(index);
  53         }
  54
  55         float * zout(int index) const
  56         {
  57                 const Unit * unit = this;
  58                 return ZOUT(index);
  59         }
  60
  61         float & out0(int index) const
  62         {
  63                 const Unit * unit = this;
  64                 return OUT0(index);
  65         }
  66
  67         int inRate(int index) const
  68         {
  69                 const Unit * unit = this;
  70                 return INRATE(index);
  71         }
  72
  73         int inBufferSize(int index) const
  74         {
  75                 const Unit * unit = this;
  76                 return INBUFLENGTH(index);
  77         }
  78
  79         /// @{
  80         double sampleRate() const
  81         {
  82                 const Unit * unit = this;
  83                 return SAMPLERATE;
  84         }
  85
  86         double sampleDur() const
  87         {
  88                 const Unit * unit = this;
  89                 return SAMPLEDUR;
  90         }
  91
  92         int bufferSize() const
  93         {
  94                 return mBufLength;
  95         }
  96
  97         double controlRate() const
  98         {
  99                 const Unit * unit = this;
 100                 return BUFRATE;
 101         }
 102
 103         double controlDur() const
 104         {
 105                 const Unit * unit = this;
 106                 return BUFDUR;
 107         }
 108
 109         double fullSampleRate() const
 110         {
 111                 const Unit * unit = this;
 112                 return FULLRATE;
 113         }
 114
 115         int fullBufferSize() const
 116         {
 117                 const Unit * unit = this;
 118                 return FULLBUFLENGTH;
 119         }
 120         /// @}
 121
 122         template <typename FloatType>
 123         FloatType calcSlope(FloatType next, FloatType prev) const
 124         {
 125                 const Unit * unit = this;
 126                 return CALCSLOPE(next, prev);
 127         }
 128
 129         template <typename UnitType, void (UnitType::*PointerToMember)(int)>
 130         static UnitCalcFunc make_calc_function(void)
 131         {
 132                 return &run_member_function<UnitType, PointerToMember>;
 133         }
 134
 135         /// @{
 136         /// set calc function & compute initial sample
 137         template <typename UnitType, void (UnitType::*PointerToMember)(int)>
 138         void set_calc_function(void)
 139         {
 140                 mCalcFunc = make_calc_function<UnitType, PointerToMember>();
 141                 (mCalcFunc)(this, 1);
 142         }
 143
 144         template <typename UnitType, void (UnitType::*VectorCalcFunc)(int), void (UnitType::*ScalarCalcFunc)(int)>
 145         void set_vector_calc_function(void)
 146         {
 147                 mCalcFunc = make_calc_function<UnitType, VectorCalcFunc>();
 148                 make_calc_function<UnitType, ScalarCalcFunc>()(this, 1);
 149         }
 150         /// @}
 151
 152 private:
 153         template <typename UnitType, void (UnitType::*PointerToMember)(int)>
 154         static void run_member_function(struct Unit * unit, int inNumSamples)
 155         {
 156                 UnitType * realUnit = static_cast<UnitType*>(unit);
 157                 ((realUnit)->*(PointerToMember))(inNumSamples);
 158         }
 159 };
 160
 161 // define Ctor/Dtor functions
 162 #define DEFINE_XTORS(CLASSNAME)         \
 163 void CLASSNAME##_Ctor(CLASSNAME * unit) \
 164 {                                       \
 165         new(unit) CLASSNAME();              \
 166 }                                       \
 167                                                                                 \
 168 void CLASSNAME##_Dtor(CLASSNAME * unit) \
 169 {                                       \
 170         unit->~CLASSNAME();                 \
 171 }
 172
 173 #endif /* SC_PLUGIN_HPP */