src/globals.h

   1 /*
   2   ZynAddSubFX - a software synthesizer
   3
   4   globals.h - it contains program settings and the program capabilities
   5               like number of parts, of effects
   6   Copyright (C) 2002-2005 Nasca Octavian Paul
   7   Author: Nasca Octavian Paul
   8
   9   This program is free software; you can redistribute it and/or
  10   modify it under the terms of the GNU General Public License
  11   as published by the Free Software Foundation; either version 2
  12   of the License, or (at your option) any later version.
  13 */
  14
  15
  16 #ifndef GLOBALS_H
  17 #define GLOBALS_H
  18
  19 #if defined(__clang__)
  20 #define REALTIME __attribute__((annotate("realtime")))
  21 #define NONREALTIME __attribute__((annotate("nonrealtime")))
  22 #else
  23 #define REALTIME
  24 #define NONREALTIME
  25 #endif
  26
  27 //Forward Declarations
  28
  29 #if defined(HAVE_CPP_STD_COMPLEX)
  30 #include <complex>
  31 #else
  32 namespace std {
  33     template<class T> struct complex;
  34 }
  35 #endif
  36
  37 namespace rtosc{struct Ports; struct ClonePorts; struct MergePorts; class ThreadLink;}
  38 namespace zyn {
  39
  40 class  EffectMgr;
  41 class  ADnoteParameters;
  42 struct ADnoteGlobalParam;
  43 class  SUBnoteParameters;
  44 class  PADnoteParameters;
  45 class  SynthNote;
  46
  47 class  Allocator;
  48 class  AbsTime;
  49 class  RelTime;
  50
  51 class  Microtonal;
  52 class  XMLwrapper;
  53 class  Resonance;
  54 class  FFTwrapper;
  55 class  EnvelopeParams;
  56 class  LFOParams;
  57 class  FilterParams;
  58
  59 struct WatchManager;
  60 class  LFO;
  61 class  Envelope;
  62 class  OscilGen;
  63
  64 class  Controller;
  65 class  Master;
  66 class  Part;
  67
  68 class  Filter;
  69 class  AnalogFilter;
  70 class  MoogFilter;
  71 class  CombFilter;
  72 class  SVFilter;
  73 class  FormantFilter;
  74 class  ModFilter;
  75
  76 typedef float fftwf_real;
  77 typedef std::complex<fftwf_real> fft_t;
  78
  79 /**
  80  * The number of harmonics of additive synth
  81  * This must be smaller than OSCIL_SIZE/2
  82  */
  83 #define MAX_AD_HARMONICS 128
  84
  85
  86 /**
  87  * The number of harmonics of substractive
  88  */
  89 #define MAX_SUB_HARMONICS 64
  90
  91
  92 /*
  93  * The maximum number of samples that are used for 1 PADsynth instrument(or item)
  94  */
  95 #define PAD_MAX_SAMPLES 64
  96
  97
  98 /*
  99  * Number of parts
 100  */
 101 #define NUM_MIDI_PARTS 16
 102
 103 /*
 104  * Number of Midi channels
 105  */
 106 #define NUM_MIDI_CHANNELS 16
 107
 108 /*
 109  * The number of voices of additive synth for a single note
 110  */
 111 #define NUM_VOICES 8
 112
 113 /*
 114  * The polyphony (notes)
 115  */
 116 #define POLYPHONY 60
 117
 118 /*
 119  * Number of system effects
 120  */
 121 #define NUM_SYS_EFX 4
 122
 123
 124 /*
 125  * Number of insertion effects
 126  */
 127 #define NUM_INS_EFX 8
 128
 129 /*
 130  * Number of part's insertion effects
 131  */
 132 #define NUM_PART_EFX 3
 133
 134 /*
 135  * Maximum number of the instrument on a part
 136  */
 137 #define NUM_KIT_ITEMS 16
 138
 139 /*
 140  * Maximum number of "strings" in Sympathetic Resonance Effect
 141  */
 142 #define NUM_SYMPATHETIC_STRINGS 228U // 76*3
 143
 144 /*
 145  * How is applied the velocity sensing
 146  */
 147 #define VELOCITY_MAX_SCALE 8.0f
 148
 149 /*
 150  * The maximum length of instrument's name
 151  */
 152 #define PART_MAX_NAME_LEN 30
 153
 154 /*
 155  * The maximum we allow for an XMZ path
 156  *
 157  * Note that this is an ugly hack.  Finding a compile time path
 158  * max portably is painful.
 159  */
 160 #define XMZ_PATH_MAX 1024
 161
 162 /*
 163  * The maximum number of bands of the equaliser
 164  */
 165 #define MAX_EQ_BANDS 8
 166 #if (MAX_EQ_BANDS >= 20)
 167 #error "Too many EQ bands in globals.h"
 168 #endif
 169
 170
 171 /*
 172  * Maximum filter stages
 173  */
 174 #define MAX_FILTER_STAGES 5
 175
 176 /*
 177  * Formant filter (FF) limits
 178  */
 179 #define FF_MAX_VOWELS 6
 180 #define FF_MAX_FORMANTS 12
 181 #define FF_MAX_SEQUENCE 8
 182
 183 #define MAX_PRESETTYPE_SIZE 30
 184
 185 #define LOG_2 0.693147181f
 186 #define PI 3.1415926536f
 187 #define PIDIV2 1.5707963268f
 188 #define LOG_10 2.302585093f
 189
 190 /*
 191  * For de-pop adjustment
 192  */
 193 #define FADEIN_ADJUSTMENT_SCALE 20
 194
 195 /*
 196  * Envelope Limits
 197  */
 198 #define MAX_ENVELOPE_POINTS 40
 199 #define MIN_ENVELOPE_DB -400
 200
 201 /*
 202  * The threshold for the amplitude interpolation used if the amplitude
 203  * is changed (by LFO's or Envelope's). If the change of the amplitude
 204  * is below this, the amplitude is not interpolated
 205  */
 206 #define AMPLITUDE_INTERPOLATION_THRESHOLD 0.0001f
 207
 208 /*
 209  * How the amplitude threshold is computed
 210  */
 211 #define ABOVE_AMPLITUDE_THRESHOLD(a, b) ((2.0f * fabsf((b) - (a)) \
 212                                           / (fabsf((b) + (a) \
 213                                                   + 0.0000000001f))) > \
 214                                          AMPLITUDE_INTERPOLATION_THRESHOLD)
 215
 216 /*
 217  * Interpolate Amplitude
 218  */
 219 #define INTERPOLATE_AMPLITUDE(a, b, x, size) ((a) \
 220                                               + ((b) \
 221                                                  - (a)) * (float)(x) \
 222                                               / (float) (size))
 223
 224
 225 /*
 226  * dB
 227  */
 228 #define dB2rap(dB) ((expf((dB) * LOG_10 / 20.0f)))
 229 #define rap2dB(rap) ((20 * logf(rap) / LOG_10))
 230
 231 #define ZERO(data, size) {char *data_ = (char *) data; for(int i = 0; \
 232                                                            i < size; \
 233                                                            i++) \
 234                               data_[i] = 0; }
 235 #define ZERO_float(data, size) {float *data_ = (float *) data; \
 236                                 for(int i = 0; \
 237                                     i < size; \
 238                                     i++) \
 239                                     data_[i] = 0.0f; }
 240
 241 enum ONOFFTYPE {
 242     OFF = 0, ON = 1
 243 };
 244
 245 enum MidiControllers {
 246     C_bankselectmsb = 0, C_pitchwheel = 1000, C_NULL = 1001,
 247     C_aftertouch = 1002, C_pitch = 1003,
 248     C_expression    = 11, C_panning = 10, C_bankselectlsb = 32,
 249     C_filtercutoff  = 74, C_filterq = 71, C_bandwidth = 75, C_modwheel = 1,
 250     C_fmamp  = 76,
 251     C_volume = 7, C_sustain = 64, C_allnotesoff = 123, C_allsoundsoff = 120,
 252     C_resetallcontrollers = 121,
 253     C_portamento = 65, C_resonance_center = 77, C_resonance_bandwidth = 78,
 254
 255     C_dataentryhi = 0x06, C_dataentrylo = 0x26, C_nrpnhi = 99, C_nrpnlo = 98
 256 };
 257
 258 enum LegatoMsg {
 259     LM_Norm, LM_FadeIn, LM_FadeOut, LM_CatchUp, LM_ToNorm
 260 };
 261
 262 //is like i=(int)(floor(f))
 263 #ifdef ASM_F2I_YES
 264 #define F2I(f, i)\
 265     do {\
 266         __asm__ __volatile__\
 267             ("fistpl %0" : "=m" (i) : "t" (f - 0.49999999f) : "st");\
 268     } while (false)
 269 #else
 270 #define F2I(f, i)\
 271     do {\
 272         (i) = ((f > 0) ? ((int)(f)) : ((int)(f - 1.0f)));\
 273     } while (false)
 274 #endif
 275
 276
 277
 278 #ifndef  O_BINARY
 279 #define O_BINARY 0
 280 #endif
 281
 282 template<class T>
 283 class m_unique_array
 284 {
 285     T* ptr = nullptr; //!< @invariant nullptr or pointer to new[]'ed memory
 286 public:
 287     m_unique_array() = default;
 288     m_unique_array(m_unique_array&& other) : ptr(other.ptr) {
 289         other.ptr = nullptr;
 290     }
 291     m_unique_array& operator=(m_unique_array&& other) {
 292         ptr = other.ptr;
 293         other.ptr = nullptr;
 294         return *this;
 295     }
 296     m_unique_array(const m_unique_array& other) = delete;
 297     ~m_unique_array() { delete[] ptr; ptr = nullptr; }
 298     void resize(unsigned sz) {
 299         delete[] ptr;
 300         ptr = new T[sz]; }
 301
 302     operator T*() { return ptr; }
 303     operator const T*() const { return ptr; }
 304     //T& operator[](unsigned idx) { return ptr[idx]; }
 305     //const T& operator[](unsigned idx) const { return ptr[idx]; }
 306 };
 307
 308 //temporary include for synth->{samplerate/buffersize} members
 309 struct SYNTH_T {
 310
 311     SYNTH_T(void)
 312         :samplerate(44100), buffersize(256), oscilsize(1024)
 313     {
 314         alias(false);
 315     }
 316
 317     SYNTH_T(const SYNTH_T& ) = delete;
 318     SYNTH_T(SYNTH_T&& ) = default;
 319     SYNTH_T& operator=(const SYNTH_T& ) = delete;
 320     SYNTH_T& operator=(SYNTH_T&& ) = default;
 321
 322     /** the buffer to add noise in order to avoid denormalisation */
 323     m_unique_array<float> denormalkillbuf;
 324
 325     /**Sampling rate*/
 326     unsigned int samplerate;
 327
 328     /**
 329      * The size of a sound buffer (or the granularity)
 330      * All internal transfer of sound data use buffer of this size.
 331      * All parameters are constant during this period of time, except
 332      * some parameters(like amplitudes) which are linearly interpolated.
 333      * If you increase this you'll encounter big latencies, but if you
 334      * decrease this the CPU requirements gets high.
 335      */
 336     int buffersize;
 337
 338     /**
 339      * The size of ADnote Oscillator
 340      * Decrease this => poor quality
 341      * Increase this => CPU requirements gets high (only at start of the note)
 342      */
 343     int oscilsize;
 344
 345     //Alias for above terms
 346     float samplerate_f;
 347     float halfsamplerate_f;
 348     float buffersize_f;
 349     int   bufferbytes;
 350     float oscilsize_f;
 351
 352     float dt(void) const
 353     {
 354         return buffersize_f / samplerate_f;
 355     }
 356     void alias(bool randomize=true);
 357     static float numRandom(void); //defined in Util.cpp for now
 358 };
 359
 360 class smooth_float {
 361 private:
 362     bool init;
 363     float curr_value;
 364     float next_value;
 365 public:
 366     smooth_float() {
 367         init = false;
 368         next_value = curr_value = 0.0f;
 369     };
 370     smooth_float(const float value) {
 371         init = true;
 372         next_value = curr_value = value;
 373     };
 374     operator float() {
 375         const float delta = (next_value - curr_value) / 32.0f;
 376         curr_value += delta;
 377         return (curr_value);
 378     };
 379     void operator =(const float value) {
 380       if (init) {
 381           next_value = value;
 382       } else {
 383           next_value = curr_value = value;
 384           init = true;
 385       }
 386     };
 387     bool isSet() const {
 388         return (init);
 389     };
 390 };
 391
 392 }
 393 #endif