falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
1991 Commits
17 Branches
263MB
Tree: ab2db68741
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ab2db68741'
${ noResults }
Carla/source/modules/native-plugins/segmentjuice/SegmentJuicePlugin.cpp

689 lines
20KB
Raw Blame History 

  1. /*

  2.  * Segment Juice Plugin

  3.  * Copyright (C) 2014 Andre Sklenar <andre.sklenar@gmail.com>, www.juicelab.cz

  4.  *

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

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. #include "SegmentJuicePlugin.hpp"

  19. 

  20. START_NAMESPACE_DISTRHO

  21. 

  22. // -----------------------------------------------------------------------

  23. 

  24. SegmentJuicePlugin::SegmentJuicePlugin()

  25.     : Plugin(paramCount, 1, 0) // 1 program, 0 states

  26. {

  27.     // set default values

  28.     d_setProgram(0);

  29. 

  30.     // reset

  31.     d_deactivate();

  32. }

  33. 

  34. SegmentJuicePlugin::~SegmentJuicePlugin()

  35. {

  36. }

  37. 

  38. // -----------------------------------------------------------------------

  39. // Init

  40. 

  41. void SegmentJuicePlugin::d_initParameter(uint32_t index, Parameter& parameter)

  42. {

  43.     switch (index)

  44.     {

  45.     case paramWave1:

  46.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  47.         parameter.name       = "Wave1";

  48.         parameter.symbol     = "w1";

  49.         parameter.unit       = "";

  50.         parameter.ranges.def = 3.0f;

  51.         parameter.ranges.min = 1.0f;

  52.         parameter.ranges.max = 4.0f;

  53.         break;

  54.     case paramWave2:

  55.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  56.         parameter.name       = "Wave2";

  57.         parameter.symbol     = "w2";

  58.         parameter.unit       = "";

  59.         parameter.ranges.def = 3.0f;

  60.         parameter.ranges.min = 1.0f;

  61.         parameter.ranges.max = 4.0f;

  62.         break;

  63.     case paramWave3:

  64.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  65.         parameter.name       = "Wave3";

  66.         parameter.symbol     = "w3";

  67.         parameter.unit       = "";

  68.         parameter.ranges.def = 3.0f;

  69.         parameter.ranges.min = 1.0f;

  70.         parameter.ranges.max = 4.0f;

  71.         break;

  72.     case paramWave4:

  73.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  74.         parameter.name       = "Wave4";

  75.         parameter.symbol     = "w4";

  76.         parameter.unit       = "";

  77.         parameter.ranges.def = 3.0f;

  78.         parameter.ranges.min = 1.0f;

  79.         parameter.ranges.max = 4.0f;

  80.         break;

  81.     case paramWave5:

  82.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  83.         parameter.name       = "Wave5";

  84.         parameter.symbol     = "w5";

  85.         parameter.unit       = "";

  86.         parameter.ranges.def = 3.0f;

  87.         parameter.ranges.min = 1.0f;

  88.         parameter.ranges.max = 4.0f;

  89.         break;

  90.     case paramWave6:

  91.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  92.         parameter.name       = "w6";

  93.         parameter.symbol     = "";

  94.         parameter.unit       = "";

  95.         parameter.ranges.def = 3.0f;

  96.         parameter.ranges.min = 1.0f;

  97.         parameter.ranges.max = 4.0f;

  98.         break;

  99.     case paramFM1:

  100.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  101.         parameter.name       = "FM1";

  102.         parameter.symbol     = "f1";

  103.         parameter.unit       = "";

  104.         parameter.ranges.def = 0.5f;

  105.         parameter.ranges.min = 0.0f;

  106.         parameter.ranges.max = 1.0f;

  107.         break;

  108.     case paramFM2:

  109.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  110.         parameter.name       = "FM2";

  111.         parameter.symbol     = "f2";

  112.         parameter.unit       = "";

  113.         parameter.ranges.def = 0.5f;

  114.         parameter.ranges.min = 0.0f;

  115.         parameter.ranges.max = 1.0f;

  116.         break;

  117.     case paramFM3:

  118.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  119.         parameter.name       = "FM3";

  120.         parameter.symbol     = "f3";

  121.         parameter.unit       = "";

  122.         parameter.ranges.def = 0.5f;

  123.         parameter.ranges.min = 0.0f;

  124.         parameter.ranges.max = 1.0f;

  125.         break;

  126.     case paramFM4:

  127.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  128.         parameter.name       = "FM4";

  129.         parameter.symbol     = "f4";

  130.         parameter.unit       = "";

  131.         parameter.ranges.def = 0.5f;

  132.         parameter.ranges.min = 0.0f;

  133.         parameter.ranges.max = 1.0f;

  134.         break;

  135.     case paramFM5:

  136.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  137.         parameter.name       = "FM5";

  138.         parameter.symbol     = "f5";

  139.         parameter.unit       = "";

  140.         parameter.ranges.def = 0.5f;

  141.         parameter.ranges.min = 0.0f;

  142.         parameter.ranges.max = 1.0f;

  143.         break;

  144.     case paramFM6:

  145.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  146.         parameter.name       = "FM6";

  147.         parameter.symbol     = "f6";

  148.         parameter.unit       = "";

  149.         parameter.ranges.def = 0.0f;

  150.         parameter.ranges.min = -1.0f;

  151.         parameter.ranges.max = 1.0f;

  152.         break;

  153.     case paramPan1:

  154.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  155.         parameter.name       = "Pan1";

  156.         parameter.symbol     = "p1";

  157.         parameter.unit       = "";

  158.         parameter.ranges.def = 0.0f;

  159.         parameter.ranges.min = -1.0f;

  160.         parameter.ranges.max = 1.0f;

  161.         break;

  162.     case paramPan2:

  163.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  164.         parameter.name       = "Pan2";

  165.         parameter.symbol     = "p2";

  166.         parameter.unit       = "";

  167.         parameter.ranges.def = 0.0f;

  168.         parameter.ranges.min = -1.0f;

  169.         parameter.ranges.max = 1.0f;

  170.         break;

  171.     case paramPan3:

  172.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  173.         parameter.name       = "Pan3";

  174.         parameter.symbol     = "p3";

  175.         parameter.unit       = "";

  176.         parameter.ranges.def = 0.0f;

  177.         parameter.ranges.min = -1.0f;

  178.         parameter.ranges.max = 1.0f;

  179.         break;

  180.     case paramPan4:

  181.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  182.         parameter.name       = "Pan4";

  183.         parameter.symbol     = "p4";

  184.         parameter.unit       = "";

  185.         parameter.ranges.def = 0.0f;

  186.         parameter.ranges.min = -1.0f;

  187.         parameter.ranges.max = 1.0f;

  188.         break;

  189.     case paramPan5:

  190.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  191.         parameter.name       = "Pan5";

  192.         parameter.symbol     = "p5";

  193.         parameter.unit       = "";

  194.         parameter.ranges.def = 0.0f;

  195.         parameter.ranges.min = -1.0f;

  196.         parameter.ranges.max = 1.0f;

  197.         break;

  198.     case paramPan6:

  199.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  200.         parameter.name       = "p6";

  201.         parameter.symbol     = "p6";

  202.         parameter.unit       = "";

  203.         parameter.ranges.def = 0.0f;

  204.         parameter.ranges.min = -1.0f;

  205.         parameter.ranges.max = 1.0f;

  206.         break;

  207.     case paramAmp1:

  208.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  209.         parameter.name       = "Amp1";

  210.         parameter.symbol     = "a1";

  211.         parameter.unit       = "";

  212.         parameter.ranges.def = 0.5f;

  213.         parameter.ranges.min = 0.0f;

  214.         parameter.ranges.max = 1.0f;

  215.         break;

  216.     case paramAmp2:

  217.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  218.         parameter.name       = "Amp2";

  219.         parameter.symbol     = "a2";

  220.         parameter.unit       = "";

  221.         parameter.ranges.def = 0.5f;

  222.         parameter.ranges.min = 0.0f;

  223.         parameter.ranges.max = 1.0f;

  224.         break;

  225.     case paramAmp3:

  226.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  227.         parameter.name       = "Amp3";

  228.         parameter.symbol     = "a3";

  229.         parameter.unit       = "";

  230.         parameter.ranges.def = 0.5f;

  231.         parameter.ranges.min = 0.0f;

  232.         parameter.ranges.max = 1.0f;

  233.         break;

  234.     case paramAmp4:

  235.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  236.         parameter.name       = "Amp4";

  237.         parameter.symbol     = "a4";

  238.         parameter.unit       = "";

  239.         parameter.ranges.def = 0.5f;

  240.         parameter.ranges.min = 0.0f;

  241.         parameter.ranges.max = 1.0f;

  242.         break;

  243.     case paramAmp5:

  244.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  245.         parameter.name       = "Amp5";

  246.         parameter.symbol     = "a5";

  247.         parameter.unit       = "";

  248.         parameter.ranges.def = 0.5f;

  249.         parameter.ranges.min = 0.0f;

  250.         parameter.ranges.max = 1.0f;

  251.         break;

  252.     case paramAmp6:

  253.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  254.         parameter.name       = "Amp6";

  255.         parameter.symbol     = "a6";

  256.         parameter.unit       = "";

  257.         parameter.ranges.def = 0.5f;

  258.         parameter.ranges.min = 0.0f;

  259.         parameter.ranges.max = 1.0f;

  260.         break;

  261.     case paramAttack:

  262.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  263.         parameter.name       = "Attack";

  264.         parameter.symbol     = "att";

  265.         parameter.unit       = "";

  266.         parameter.ranges.def = 0.0f;

  267.         parameter.ranges.min = 0.0f;

  268.         parameter.ranges.max = 1.0f;

  269.         break;

  270.     case paramDecay:

  271.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  272.         parameter.name       = "Decay";

  273.         parameter.symbol     = "dec";

  274.         parameter.unit       = "";

  275.         parameter.ranges.def = 0.0f;

  276.         parameter.ranges.min = 0.0f;

  277.         parameter.ranges.max = 1.0f;

  278.         break;

  279.     case paramSustain:

  280.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  281.         parameter.name       = "Sustain";

  282.         parameter.symbol     = "sus";

  283.         parameter.unit       = "";

  284.         parameter.ranges.def = 1.0f;

  285.         parameter.ranges.min = 0.0f;

  286.         parameter.ranges.max = 1.0f;

  287.         break;

  288.     case paramRelease:

  289.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  290.         parameter.name       = "Release";

  291.         parameter.symbol     = "rel";

  292.         parameter.unit       = "";

  293.         parameter.ranges.def = 0.0f;

  294.         parameter.ranges.min = 0.0f;

  295.         parameter.ranges.max = 1.0f;

  296.         break;

  297.     case paramStereo:

  298.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  299.         parameter.name       = "Stereo";

  300.         parameter.symbol     = "str";

  301.         parameter.unit       = "";

  302.         parameter.ranges.def = 0.0f;

  303.         parameter.ranges.min = -1.0f;

  304.         parameter.ranges.max = 1.0f;

  305.         break;

  306.     case paramTune:

  307.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  308.         parameter.name       = "Tune";

  309.         parameter.symbol     = "tun";

  310.         parameter.unit       = "";

  311.         parameter.ranges.def = 0.0f;

  312.         parameter.ranges.min = -1.0f;

  313.         parameter.ranges.max = 1.0f;

  314.         break;

  315.     case paramVolume:

  316.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  317.         parameter.name       = "Volume";

  318.         parameter.symbol     = "vol";

  319.         parameter.unit       = "";

  320.         parameter.ranges.def = 0.5f;

  321.         parameter.ranges.min = 0.0f;

  322.         parameter.ranges.max = 1.0f;

  323.         break;

  324.     case paramGlide:

  325.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  326.         parameter.name       = "Glide";

  327.         parameter.symbol     = "gld";

  328.         parameter.unit       = "";

  329.         parameter.ranges.def = 0.0f;

  330.         parameter.ranges.min = 0.0f;

  331.         parameter.ranges.max = 1.0f;

  332.         break;

  333.     }

  334. }

  335. 

  336. void SegmentJuicePlugin::d_initProgramName(uint32_t index, d_string& programName)

  337. {

  338.     if (index != 0)

  339.         return;

  340. 

  341.     programName = "Default";

  342. }

  343. 

  344. // -----------------------------------------------------------------------

  345. // Internal data

  346. 

  347. float SegmentJuicePlugin::d_getParameterValue(uint32_t index) const

  348. {

  349.     switch (index)

  350.     {

  351.     case paramWave1:

  352.         return wave1;

  353.     case paramWave2:

  354.         return wave2;

  355.     case paramWave3:

  356.         return wave3;

  357.     case paramWave4:

  358.         return wave4;

  359.     case paramWave5:

  360.         return wave5;

  361.     case paramWave6:

  362.         return wave6;

  363.     case paramFM1:

  364.         return FM1;

  365.     case paramFM2:

  366.         return FM2;

  367.     case paramFM3:

  368.         return FM3;

  369.     case paramFM4:

  370.         return FM4;

  371.     case paramFM5:

  372.         return FM5;

  373.     case paramFM6:

  374.         return FM6;

  375.     case paramPan1:

  376.         return pan1;

  377.     case paramPan2:

  378.         return pan2;

  379.     case paramPan3:

  380.         return pan3;

  381.     case paramPan4:

  382.         return pan4;

  383.     case paramPan5:

  384.         return pan5;

  385.     case paramPan6:

  386.         return pan6;

  387.     case paramAmp1:

  388.         return amp1;

  389.     case paramAmp2:

  390.         return amp2;

  391.     case paramAmp3:

  392.         return amp3;

  393.     case paramAmp4:

  394.         return amp4;

  395.     case paramAmp5:

  396.         return amp5;

  397.     case paramAmp6:

  398.         return amp6;

  399.     case paramAttack:

  400.         return attack;

  401.     case paramDecay:

  402.         return decay;

  403.     case paramSustain:

  404.         return sustain;

  405.     case paramRelease:

  406.         return release;

  407.     case paramStereo:

  408.         return stereo;

  409.     case paramTune:

  410.         return tune;

  411.     case paramVolume:

  412.         return volume;

  413.     case paramGlide:

  414.         return glide;

  415. 

  416.     default:

  417.         return 0.0f;

  418.     }

  419. }

  420. 

  421. void SegmentJuicePlugin::d_setParameterValue(uint32_t index, float value)

  422. {

  423.     switch (index)

  424.     {

  425.     case paramWave1:

  426.         synthL.setWave(0, value);

  427.         synthR.setWave(0, value);

  428.         wave1 = value;

  429.         break;

  430.     case paramWave2:

  431.         synthL.setWave(1, value);

  432.         synthR.setWave(1, value);

  433.         wave2 = value;

  434.         break;

  435.     case paramWave3:

  436.         synthL.setWave(2, value);

  437.         synthR.setWave(2, value);

  438.         wave3 = value;

  439.         break;

  440.     case paramWave4:

  441.         synthL.setWave(3, value);

  442.         synthR.setWave(3, value);

  443.         wave4 = value;

  444.         break;

  445.     case paramWave5:

  446.         synthL.setWave(4, value);

  447.         synthR.setWave(4, value);

  448.         wave5 = value;

  449.         break;

  450.     case paramWave6:

  451.         synthL.setWave(5, value);

  452.         synthR.setWave(5, value);

  453.         wave6 = value;

  454.         break;

  455.     case paramFM1:

  456.         synthL.setFM(0, value);

  457.         synthR.setFM(0, value);

  458.         FM1 = value;

  459.         break;

  460.     case paramFM2:

  461.         synthL.setFM(1, value);

  462.         synthR.setFM(1, value);

  463.         FM2 = value;

  464.         break;

  465.     case paramFM3:

  466.         synthL.setFM(2, value);

  467.         synthR.setFM(2, value);

  468.         FM3 = value;

  469.         break;

  470.     case paramFM4:

  471.         synthL.setFM(3, value);

  472.         synthR.setFM(3, value);

  473.         FM4 = value;

  474.         break;

  475.     case paramFM5:

  476.         synthL.setFM(4, value);

  477.         synthR.setFM(4, value);

  478.         FM5 = value;

  479.         break;

  480.     case paramFM6:

  481.         synthL.setFM(5, value);

  482.         synthR.setFM(5, value);

  483.         FM6 = value;

  484.         break;

  485.     case paramPan1:

  486.         synthL.setPan(0, -value);

  487.         synthR.setPan(0, value);

  488.         pan1 = value;

  489.         break;

  490.     case paramPan2:

  491.         synthL.setPan(1, -value);

  492.         synthR.setPan(1, value);

  493.         pan2 = value;

  494.         break;

  495.     case paramPan3:

  496.         synthL.setPan(2, -value);

  497.         synthR.setPan(2, value);

  498.         pan3 = value;

  499.         break;

  500.     case paramPan4:

  501.         synthL.setPan(3, -value);

  502.         synthR.setPan(3, value);

  503.         pan4 = value;

  504.         break;

  505.     case paramPan5:

  506.         synthL.setPan(4, -value);

  507.         synthR.setPan(4, value);

  508.         pan5 = value;

  509.         break;

  510.     case paramPan6:

  511.         synthL.setPan(5, -value);

  512.         synthR.setPan(5, value);

  513.         pan6 = value;

  514.         break;

  515.     case paramAmp1:

  516.         synthL.setAmp(0, value);

  517.         synthR.setAmp(0, value);

  518.         amp1 = value;

  519.         break;

  520.     case paramAmp2:

  521.         synthL.setAmp(1, value);

  522.         synthR.setAmp(1, value);

  523.         amp2 = value;

  524.         break;

  525.     case paramAmp3:

  526.         synthL.setAmp(2, value);

  527.         synthR.setAmp(2, value);

  528.         amp3 = value;

  529.         break;

  530.     case paramAmp4:

  531.         synthL.setAmp(3, value);

  532.         synthR.setAmp(3, value);

  533.         amp4 = value;

  534.         break;

  535.     case paramAmp5:

  536.         synthL.setAmp(4, value);

  537.         synthR.setAmp(4, value);

  538.         amp5 = value;

  539.         break;

  540.     case paramAmp6:

  541.         synthL.setAmp(5, value);

  542.         synthR.setAmp(5, value);

  543.         amp6 = value;

  544.         break;

  545.     case paramAttack:

  546.         synthL.setAttack(value);

  547.         synthR.setAttack(value);

  548.         attack = value;

  549.         break;

  550.     case paramDecay:

  551.         synthL.setDecay(value);

  552.         synthR.setDecay(value);

  553.         attack = value;

  554.         break;

  555.     case paramSustain:

  556.         synthL.setSustain(value);

  557.         synthR.setSustain(value);

  558.         attack = value;

  559.         break;

  560.     case paramRelease:

  561.         synthL.setRelease(value);

  562.         synthR.setRelease(value);

  563.         attack = value;

  564.         break;

  565.     case paramStereo:

  566.         synthL.setStereo(-value);

  567.         synthR.setStereo(value);

  568.         attack = value;

  569.         break;

  570.     case paramTune:

  571.         synthL.setTune(value);

  572.         synthR.setTune(value);

  573.         attack = value;

  574.         break;

  575.     case paramVolume:

  576.         synthL.setMAmp(value);

  577.         synthR.setMAmp(value);

  578.         attack = value;

  579.     case paramGlide:

  580.         synthL.setGlide(value);

  581.         synthR.setGlide(value);

  582.         glide = value;

  583.         break;

  584.     }

  585. }

  586. 

  587. void SegmentJuicePlugin::d_setProgram(uint32_t index)

  588. {

  589.     if (index != 0)

  590.         return;

  591. 

  592.     /* Default parameter values */

  593.     wave1=wave2=wave3=wave4=wave5=wave6=3.0f;

  594.     FM1=FM2=FM3=FM4=FM5=FM6=0.5f;

  595.     pan1=pan2=pan3=pan4=pan5=pan6=0.0f;

  596.     amp1=amp2=amp3=amp4=amp5=amp6=0.5f;

  597.     attack=decay=release=stereo=tune=glide=0.0f;

  598.     sustain=1.0f;

  599.     volume=0.5f;

  600. 

  601.     for (int i=0; i<6; i++) {

  602.         synthL.setFM(i, 0.5f);

  603.         synthR.setFM(i, 0.5f);

  604. 

  605.         synthL.setPan(i, 0.0f);

  606.         synthR.setPan(i, 0.0f);

  607. 

  608.         synthL.setAmp(i, 0.5f);

  609.         synthR.setAmp(i, 0.5f);

  610.     }

  611. 

  612.     /* Default variable values */

  613. 

  614.     synthL.setSampleRate(d_getSampleRate());

  615.     synthR.setSampleRate(d_getSampleRate());

  616.     synthL.setMAmp(0.5);

  617.     synthR.setMAmp(0.5);

  618. 

  619.     synthL.setTune(0.0f);

  620.     synthR.setTune(0.0f);

  621. 

  622.     synthL.setStereo(0.0f);

  623.     synthR.setStereo(0.0f);

  624. 

  625.     synthL.setGlide(0.0f);

  626.     synthR.setGlide(0.0f);

  627. 

  628.     synthL.setAttack(0.0f);

  629.     synthR.setAttack(0.0f);

  630. 

  631.     synthL.setDecay(0.0f);

  632.     synthR.setDecay(0.0f);

  633. 

  634.     synthL.setSustain(1.0f);

  635.     synthR.setSustain(1.0f);

  636. 

  637.     synthL.setRelease(0.0f);

  638.     synthR.setRelease(0.0f);

  639. 

  640.     /* reset filter values */

  641.     d_activate();

  642. }

  643. 

  644. // -----------------------------------------------------------------------

  645. // Process

  646. 

  647. void SegmentJuicePlugin::d_activate()

  648. {

  649. }

  650. 

  651. void SegmentJuicePlugin::d_deactivate()

  652. {

  653.     // all values to zero

  654. }

  655. 

  656. void SegmentJuicePlugin::d_run(const float**, float** outputs, uint32_t frames, const MidiEvent* midiEvents, uint32_t midiEventCount)

  657. {

  658.     for (uint32_t i = 0; i<midiEventCount; i++) {

  659.         int mType = midiEvents[i].buf[0] & 0xF0;

  660.         //int mChan = midiEvents[i].buf[0] & 0x0F;

  661.         int mNum = midiEvents[i].buf[1];

  662.         if (mType == 0x90) {

  663.             //note on

  664.             synthL.play(mNum);

  665.             synthR.play(mNum);

  666.         } else if (mType == 0x80) {

  667.             //note off

  668.             synthL.stop(mNum);

  669.             synthR.stop(mNum);

  670.         }

  671.     }

  672. 

  673.     for (uint32_t i = 0; i<frames; i++) {

  674.         outputs[0][i] = synthL.run();

  675.         outputs[1][i] = synthR.run();

  676.     }

  677. }

  678. 

  679. // -----------------------------------------------------------------------

  680. 

  681. Plugin* createPlugin()

  682. {

  683.     return new SegmentJuicePlugin();

  684. }

  685. 

  686. // -----------------------------------------------------------------------

  687. 

  688. END_NAMESPACE_DISTRHO