falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3871 Commits
16 Branches
16GB
Tree: a90b9f9a3e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a90b9f9a3e'
${ noResults }
Carla/source/native-plugins/zynaddsubfx/Params/EnvelopeParams.cpp

519 lines
15KB
Raw Blame History 

  1. /*

  2.   ZynAddSubFX - a software synthesizer

  3. 

  4.   EnvelopeParams.cpp - Parameters for Envelope

  5.   Copyright (C) 2002-2005 Nasca Octavian Paul

  6.   Author: Nasca Octavian Paul

  7. 

  8.   This program is free software; you can redistribute it and/or

  9.   modify it under the terms of the GNU General Public License

  10.   as published by the Free Software Foundation; either version 2

  11.   of the License, or (at your option) any later version.

  12. */

  13. 

  14. #include <cmath>

  15. #include <cstdlib>

  16. #include <cassert>

  17. #include <rtosc/ports.h>

  18. #include <rtosc/port-sugar.h>

  19. 

  20. #include "zyn-version.h"

  21. #include "EnvelopeParams.h"

  22. #include "../Misc/Util.h"

  23. #include "../Misc/Time.h"

  24. 

  25. using namespace rtosc;

  26. 

  27. namespace zyncarla {

  28. 

  29. #define rObject EnvelopeParams

  30. #define rBegin [](const char *msg, RtData &d) { \

  31.     EnvelopeParams *env = (rObject*) d.obj

  32. #define rEnd }

  33. 

  34. static const rtosc::Ports localPorts = {

  35.     rSelf(EnvelopeParams),

  36.     rPaste,

  37. #undef  rChangeCb

  38. #define rChangeCb if(!obj->Pfreemode) obj->converttofree(); if (obj->time) { \

  39.         obj->last_update_timestamp = obj->time->time(); }

  40.     rToggle(Pfreemode, rDefault(false), "Complex Envelope Definitions"),

  41. #undef  rChangeCb

  42. #define rChangeCb if(!obj->Pfreemode) obj->converttofree(); \

  43.                   if(obj->time) { obj->last_update_timestamp = obj->time->time(); }

  44.     rOption(envelope_type, rProp(internal),

  45.             rOptions(ad_global_amp, ad_global_freq, ad_global_filter,

  46.                      ad_voice_amp, ad_voice_freq, ad_voice_filter,

  47.                      ad_voice_fm_freq, ad_voice_fm_amp,

  48.                      sub_freq_env, sub_bandwidth_env), "function of the envelope"),

  49.     rParamZyn(Penvpoints, rProp(internal), rDefaultDepends(envelope_type),

  50.             rPresets(4, 3, 4, 4, 3, 4, 3, 4, 3, 3),

  51.             "Number of points in complex definition"),

  52.     rParamZyn(Penvsustain, rDefaultDepends(envelope_type),

  53.             rPresets(2, 1, 2, 2, 1, 2, 1, 2, 1, 1),

  54.             "Location of the sustain point"),

  55.     rParams(Penvdt,  MAX_ENVELOPE_POINTS, "Envelope Delay Times"),

  56.     rParams(Penvval, MAX_ENVELOPE_POINTS, "Envelope Values"),

  57.     rParamZyn(Penvstretch,  rShort("stretch"), rDefaultDepends(envelope_type),

  58.             rPresets(64, 0, 0, 64, 0, 0, 0, 64, 64, 64),

  59.             "Stretch with respect to frequency"),

  60.     rToggle(Pforcedrelease, rShort("frcr"), rDefaultDepends(envelope_type),

  61.             rPresets(true, false, true, true, false,

  62.                      false, false, true, false, false),

  63.             "Force Envelope to fully evaluate"),

  64.     rToggle(Plinearenvelope, rShort("lin/log"), rDefault(false),

  65.             "Linear or Logarithmic Envelopes"),

  66.     rParamZyn(PA_dt,  rShort("a.dt"), rDefaultDepends(envelope_type),

  67.               rPresets(0, 50, 40, 0, 40, 70, 90, 80, 50, 70),

  68.               "Attack Time"),

  69.     rParamZyn(PA_val, rShort("a.val"), rDefaultDepends(envelope_type),

  70.               rDefault(64), rPresetsAt(4, 30, 90, 20, 64, 30, 100),

  71.               "Attack Value"),

  72.     rParamZyn(PD_dt,  rShort("d.dt"),  rDefaultDepends(envelope_type),

  73.               rDefault(10), rPresets(40, 10, 70, 100, 10, 70, 10, 90),

  74.               "Decay Time"),

  75.     rParamZyn(PD_val, rShort("d.val"), rDefaultDepends(envelope_type),

  76.               rDefault(64), rPresetsAt(5, 40),

  77.               "Decay Value"),

  78.     rParamZyn(PS_val, rShort("s.val"), rDefaultDepends(envelope_type),

  79.               rDefault(64),

  80.               rPresets(127), rPresetsAt(3, 127), rPresetsAt(7, 127),

  81.               "Sustain Value"),

  82.     rParamZyn(PR_dt,  rShort("r.dt"),  rDefaultDepends(envelope_type),

  83.               rPresets(25, 60, 60, 100, 60, 10, 80, 100, 60, 60),

  84.               "Release Time"),

  85.     rParamZyn(PR_val, rShort("r.val"), rDefaultDepends(envelope_type),

  86.               rDefault(64), rPresetsAt(5, 40, 40),

  87.               "Release Value"),

  88. 

  89.     {"Envmode:", rDoc("Envelope variant type"), NULL,

  90.         rBegin;

  91.         d.reply(d.loc, "i", env->Envmode);

  92.         rEnd},

  93. 

  94.     {"envdt", rDoc("Envelope Delay Times"), NULL,

  95.         rBegin;

  96.         const int N = MAX_ENVELOPE_POINTS;

  97.         const int M = rtosc_narguments(msg);

  98.         if(M == 0) {

  99.             rtosc_arg_t args[N];

  100.             char arg_types[N+1] = {0};

  101.             for(int i=0; i<N; ++i) {

  102.                 args[i].f    = env->getdt(i);

  103.                 arg_types[i] = 'f';

  104.             }

  105.             d.replyArray(d.loc, arg_types, args);

  106.         } else {

  107.             for(int i=0; i<N && i<M; ++i)

  108.                 env->Penvdt[i] = env->inv_dt(rtosc_argument(msg, i).f);

  109.         }

  110.         rEnd},

  111.     {"envval", rDoc("Envelope Delay Times"), NULL,

  112.         rBegin;

  113.         const int N = MAX_ENVELOPE_POINTS;

  114.         const int M = rtosc_narguments(msg);

  115.         if(M == 0) {

  116.             rtosc_arg_t args[N];

  117.             char arg_types[N+1] = {0};

  118.             for(int i=0; i<N; ++i) {

  119.                 args[i].f    = env->Penvval[i]/127.0f;

  120.                 arg_types[i] = 'f';

  121.             }

  122.             d.replyArray(d.loc, arg_types, args);

  123.         } else {

  124.             for(int i=0; i<N && i<M; ++i) {

  125.                 env->Penvval[i] = limit(roundf(rtosc_argument(msg,i).f*127.0f), 0.0f, 127.0f);

  126.             }

  127.         }

  128.         rEnd},

  129. 

  130.     {"addPoint:i", rProp(internal) rDoc("Add point to envelope"), NULL,

  131.         rBegin;

  132.         const int curpoint = rtosc_argument(msg, 0).i;

  133.         //int curpoint=freeedit->lastpoint;

  134.         if (curpoint<0 || curpoint>env->Penvpoints || env->Penvpoints>=MAX_ENVELOPE_POINTS)

  135.             return;

  136. 

  137.         for (int i=env->Penvpoints; i>=curpoint+1; i--) {

  138.             env->Penvdt[i]=env->Penvdt[i-1];

  139.             env->Penvval[i]=env->Penvval[i-1];

  140.         }

  141. 

  142.         if (curpoint==0)

  143.             env->Penvdt[1]=64;

  144. 

  145.         env->Penvpoints++;

  146.         if (curpoint<=env->Penvsustain)

  147.             env->Penvsustain++;

  148.         rEnd},

  149.     {"delPoint:i", rProp(internal) rDoc("Delete Envelope Point"), NULL,

  150.         rBegin;

  151.         const int curpoint=rtosc_argument(msg, 0).i;

  152.         if(curpoint<1 || curpoint>=env->Penvpoints-1 || env->Penvpoints<=3)

  153.             return;

  154. 

  155.         for (int i=curpoint+1;i<env->Penvpoints;i++){

  156.             env->Penvdt[i-1]=env->Penvdt[i];

  157.             env->Penvval[i-1]=env->Penvval[i];

  158.         };

  159. 

  160.         env->Penvpoints--;

  161. 

  162.         if (curpoint<=env->Penvsustain)

  163.             env->Penvsustain--;

  164. 

  165.         rEnd},

  166. };

  167. #undef  rChangeCb

  168. 

  169. const rtosc::Ports &EnvelopeParams::ports = localPorts;

  170. 

  171. EnvelopeParams::EnvelopeParams(unsigned char Penvstretch_,

  172.                                unsigned char Pforcedrelease_,

  173.                                const AbsTime *time_):

  174.         time(time_), last_update_timestamp(0)

  175. {

  176.     PA_dt  = 10;

  177.     PD_dt  = 10;

  178.     PR_dt  = 10;

  179.     PA_val = 64;

  180.     PD_val = 64;

  181.     PS_val = 64;

  182.     PR_val = 64;

  183. 

  184.     for(int i = 0; i < MAX_ENVELOPE_POINTS; ++i) {

  185.         Penvdt[i]  = 32;

  186.         Penvval[i] = 64;

  187.     }

  188.     Penvdt[0]       = 0; //no used

  189.     Penvsustain     = 1;

  190.     Penvpoints      = 1;

  191.     Envmode         = 1;

  192.     Penvstretch     = Penvstretch_;

  193.     Pforcedrelease  = Pforcedrelease_;

  194.     Pfreemode       = 1;

  195.     Plinearenvelope = 0;

  196. 

  197.     store2defaults();

  198. }

  199. 

  200. EnvelopeParams::~EnvelopeParams()

  201. {}

  202. 

  203. #define COPY(y) this->y = ep.y

  204. void EnvelopeParams::paste(const EnvelopeParams &ep)

  205. {

  206. 

  207.     COPY(Pfreemode);

  208.     COPY(Penvpoints);

  209.     COPY(Penvsustain);

  210.     for(int i=0; i<MAX_ENVELOPE_POINTS; ++i) {

  211.         this->Penvdt[i]  = ep.Penvdt[i];

  212.         this->Penvval[i] = ep.Penvval[i];

  213.     }

  214.     COPY(Penvstretch);

  215.     COPY(Pforcedrelease);

  216.     COPY(Plinearenvelope);

  217. 

  218.     COPY(PA_dt);

  219.     COPY(PD_dt);

  220.     COPY(PR_dt);

  221.     COPY(PA_val);

  222.     COPY(PD_val);

  223.     COPY(PS_val);

  224.     COPY(PR_val);

  225. 

  226.     if ( time ) {

  227.         last_update_timestamp = time->time();

  228.     }

  229. }

  230. #undef COPY

  231. 

  232. void EnvelopeParams::init(EnvelopeParams::envelope_type_t etype)

  233. {

  234.     switch(etype)

  235.     {

  236.         case ad_global_amp_env:    ADSRinit_dB(0, 40, 127, 25); break;

  237.         case ad_global_freq_env:   ASRinit(64, 50, 64, 60); break;

  238.         case ad_global_filter_env: ADSRinit_filter(64, 40, 64, 70, 60, 64);

  239.             break;

  240.         case ad_voice_amp_env:     ADSRinit_dB(0, 100, 127, 100); break;

  241.         case ad_voice_freq_env:    ASRinit(30, 40, 64, 60); break;

  242.         case ad_voice_filter_env:  ADSRinit_filter(90, 70, 40, 70, 10, 40);

  243.             break;

  244.         case ad_voice_fm_freq_env: ASRinit(20, 90, 40, 80); break;

  245.         case ad_voice_fm_amp_env:  ADSRinit(80, 90, 127, 100); break;

  246.         case sub_freq_env:         ASRinit(30, 50, 64, 60); break;

  247.         case sub_bandwidth_env:    ASRinit_bw(100, 70, 64, 60); break;

  248.     };

  249.     envelope_type = etype;

  250. }

  251. 

  252. float EnvelopeParams::getdt(char i) const

  253. {

  254.     return EnvelopeParams::dt(Penvdt[(int)i]);

  255. }

  256. 

  257. float EnvelopeParams::dt(char val)

  258. {

  259.     return (powf(2.0f, val / 127.0f * 12.0f) - 1.0f) * 10.0f; //miliseconds

  260. }

  261. 

  262. char EnvelopeParams::inv_dt(float val)

  263. {

  264.     int ival = roundf(logf(val/10.0f + 1.0f)/logf(2.0f) * 127.0f/12.0f);

  265.     return limit(ival, 0, 127);

  266. }

  267. 

  268. 

  269. /*

  270.  * ADSR/ASR... initialisations

  271.  */

  272. void EnvelopeParams::ADSRinit(char A_dt, char D_dt, char S_val, char R_dt)

  273. {

  274.     setpresettype("Penvamplitude");

  275.     Envmode   = 1;

  276.     PA_dt     = A_dt;

  277.     PD_dt     = D_dt;

  278.     PS_val    = S_val;

  279.     PR_dt     = R_dt;

  280.     Pfreemode = 0;

  281.     converttofree();

  282. 

  283.     store2defaults();

  284. }

  285. 

  286. void EnvelopeParams::ADSRinit_dB(char A_dt, char D_dt, char S_val, char R_dt)

  287. {

  288.     setpresettype("Penvamplitude");

  289.     Envmode   = 2;

  290.     PA_dt     = A_dt;

  291.     PD_dt     = D_dt;

  292.     PS_val    = S_val;

  293.     PR_dt     = R_dt;

  294.     Pfreemode = 0;

  295.     converttofree();

  296. 

  297.     store2defaults();

  298. }

  299. 

  300. void EnvelopeParams::ASRinit(char A_val, char A_dt, char R_val, char R_dt)

  301. {

  302.     setpresettype("Penvfrequency");

  303.     Envmode   = 3;

  304.     PA_val    = A_val;

  305.     PA_dt     = A_dt;

  306.     PR_val    = R_val;

  307.     PR_dt     = R_dt;

  308.     Pfreemode = 0;

  309.     converttofree();

  310. 

  311.     store2defaults();

  312. }

  313. 

  314. void EnvelopeParams::ADSRinit_filter(char A_val,

  315.                                      char A_dt,

  316.                                      char D_val,

  317.                                      char D_dt,

  318.                                      char R_dt,

  319.                                      char R_val)

  320. {

  321.     setpresettype("Penvfilter");

  322.     Envmode   = 4;

  323.     PA_val    = A_val;

  324.     PA_dt     = A_dt;

  325.     PD_val    = D_val;

  326.     PD_dt     = D_dt;

  327.     PR_dt     = R_dt;

  328.     PR_val    = R_val;

  329.     Pfreemode = 0;

  330.     converttofree();

  331.     store2defaults();

  332. }

  333. 

  334. void EnvelopeParams::ASRinit_bw(char A_val, char A_dt, char R_val, char R_dt)

  335. {

  336.     setpresettype("Penvbandwidth");

  337.     Envmode   = 5;

  338.     PA_val    = A_val;

  339.     PA_dt     = A_dt;

  340.     PR_val    = R_val;

  341.     PR_dt     = R_dt;

  342.     Pfreemode = 0;

  343.     converttofree();

  344.     store2defaults();

  345. }

  346. 

  347. /*

  348.  * Convert the Envelope to freemode

  349.  */

  350. void EnvelopeParams::converttofree()

  351. {

  352.     switch(Envmode) {

  353.         case 1:

  354.         case 2:

  355.             Penvpoints  = 4;

  356.             Penvsustain = 2;

  357.             Penvval[0]  = 0;

  358.             Penvdt[1]   = PA_dt;

  359.             Penvval[1]  = 127;

  360.             Penvdt[2]   = PD_dt;

  361.             Penvval[2]  = PS_val;

  362.             Penvdt[3]   = PR_dt;

  363.             Penvval[3]  = 0;

  364.             break;

  365.         case 3:

  366.         case 5:

  367.             Penvpoints  = 3;

  368.             Penvsustain = 1;

  369.             Penvval[0]  = PA_val;

  370.             Penvdt[1]   = PA_dt;

  371.             Penvval[1]  = 64;

  372.             Penvdt[2]   = PR_dt;

  373.             Penvval[2]  = PR_val;

  374.             break;

  375.         case 4:

  376.             Penvpoints  = 4;

  377.             Penvsustain = 2;

  378.             Penvval[0]  = PA_val;

  379.             Penvdt[1]   = PA_dt;

  380.             Penvval[1]  = PD_val;

  381.             Penvdt[2]   = PD_dt;

  382.             Penvval[2]  = 64;

  383.             Penvdt[3]   = PR_dt;

  384.             Penvval[3]  = PR_val;

  385.             break;

  386.     }

  387. }

  388. 

  389. 

  390. 

  391. 

  392. void EnvelopeParams::add2XML(XMLwrapper& xml)

  393. {

  394.     xml.addparbool("free_mode", Pfreemode);

  395.     xml.addpar("env_points", Penvpoints);

  396.     xml.addpar("env_sustain", Penvsustain);

  397.     xml.addpar("env_stretch", Penvstretch);

  398.     xml.addparbool("forced_release", Pforcedrelease);

  399.     xml.addparbool("linear_envelope", Plinearenvelope);

  400.     xml.addpar("A_dt", PA_dt);

  401.     xml.addpar("D_dt", PD_dt);

  402.     xml.addpar("R_dt", PR_dt);

  403.     xml.addpar("A_val", PA_val);

  404.     xml.addpar("D_val", PD_val);

  405.     xml.addpar("S_val", PS_val);

  406.     xml.addpar("R_val", PR_val);

  407. 

  408.     if((Pfreemode != 0) || (!xml.minimal))

  409.         for(int i = 0; i < Penvpoints; ++i) {

  410.             xml.beginbranch("POINT", i);

  411.             if(i != 0)

  412.                 xml.addpar("dt", Penvdt[i]);

  413.             xml.addpar("val", Penvval[i]);

  414.             xml.endbranch();

  415.         }

  416. }

  417. 

  418. float EnvelopeParams::env_dB2rap(float db) {

  419.     return (powf(10.0f, db / 20.0f) - 0.01)/.99f;

  420. }

  421. 

  422. float EnvelopeParams::env_rap2dB(float rap) {

  423.     return 20.0f * log10f(rap * 0.99f + 0.01);

  424. }

  425. 

  426. /**

  427.     since commit 5334d94283a513ae42e472aa020db571a3589fb9, i.e. between

  428.     versions 2.4.3 and 2.4.4, the amplitude envelope has been converted

  429.     differently from dB to rap for AmplitudeEnvelope (mode 2)

  430.     this converts the values read from an XML file once

  431. */

  432. struct version_fixer_t

  433. {

  434.     const bool mismatch;

  435. public:

  436.     int operator()(int input) const

  437.     {

  438.         return (mismatch)

  439.             // The errors occured when calling env_dB2rap. Let f be the

  440.             // conversion function for mode 2 (see Envelope.cpp), then we

  441.             // load values with (let "o" be the function composition symbol):

  442.             //   f^{-1} o (env_dB2rap^{-1}) o dB2rap o f

  443.             // from the xml file. This results in the following formula:

  444.             ? roundf(127.0f * (0.5f *

  445.                    log10f( 0.01f + 0.99f *

  446.                                        powf(100, input/127.0f - 1))

  447.                                + 1))

  448.             : input;

  449.     }

  450.     version_fixer_t(const version_type& fileversion, int env_mode) :

  451.         mismatch(fileversion < version_type(2,4,4) &&

  452.                  (env_mode == 2)) {}

  453. };

  454. 

  455. void EnvelopeParams::getfromXML(XMLwrapper& xml)

  456. {

  457.     Pfreemode       = xml.getparbool("free_mode", Pfreemode);

  458.     Penvpoints      = xml.getpar127("env_points", Penvpoints);

  459.     Penvsustain     = xml.getpar127("env_sustain", Penvsustain);

  460.     Penvstretch     = xml.getpar127("env_stretch", Penvstretch);

  461.     Pforcedrelease  = xml.getparbool("forced_release", Pforcedrelease);

  462.     Plinearenvelope = xml.getparbool("linear_envelope", Plinearenvelope);

  463. 

  464.     version_fixer_t version_fix(xml.fileversion(), Envmode);

  465. 

  466.     PA_dt  = xml.getpar127("A_dt", PA_dt);

  467.     PD_dt  = xml.getpar127("D_dt", PD_dt);

  468.     PR_dt  = xml.getpar127("R_dt", PR_dt);

  469.     PA_val = version_fix(xml.getpar127("A_val", PA_val));

  470.     PD_val = version_fix(xml.getpar127("D_val", PD_val));

  471.     PS_val = version_fix(xml.getpar127("S_val", PS_val));

  472.     PR_val = version_fix(xml.getpar127("R_val", PR_val));

  473. 

  474.     for(int i = 0; i < Penvpoints; ++i) {

  475.         if(xml.enterbranch("POINT", i) == 0)

  476.             continue;

  477.         if(i != 0)

  478.             Penvdt[i] = xml.getpar127("dt", Penvdt[i]);

  479.         Penvval[i] = version_fix(xml.getpar127("val", Penvval[i]));

  480.         xml.exitbranch();

  481.     }

  482. 

  483.     if(!Pfreemode)

  484.         converttofree();

  485. }

  486. 

  487. 

  488. void EnvelopeParams::defaults()

  489. {

  490.     Penvstretch     = Denvstretch;

  491.     Pforcedrelease  = Dforcedrelease;

  492.     Plinearenvelope = Dlinearenvelope;

  493.     PA_dt     = DA_dt;

  494.     PD_dt     = DD_dt;

  495.     PR_dt     = DR_dt;

  496.     PA_val    = DA_val;

  497.     PD_val    = DD_val;

  498.     PS_val    = DS_val;

  499.     PR_val    = DR_val;

  500.     Pfreemode = 0;

  501.     converttofree();

  502. }

  503. 

  504. void EnvelopeParams::store2defaults()

  505. {

  506.     Denvstretch     = Penvstretch;

  507.     Dforcedrelease  = Pforcedrelease;

  508.     Dlinearenvelope = Plinearenvelope;

  509.     DA_dt  = PA_dt;

  510.     DD_dt  = PD_dt;

  511.     DR_dt  = PR_dt;

  512.     DA_val = PA_val;

  513.     DD_val = PD_val;

  514.     DS_val = PS_val;

  515.     DR_val = PR_val;

  516. }

  517. 

  518. }