DISTRHO
/
DPF-Plugins
mirror of https://github.com/DISTRHO/DPF-Plugins
1
0
Fork 0
Code Releases 8 Activity
Collection of DPF-based plugins for packaging
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.
121 Commits
1 Branch
105MB
Tree: 014db6d4ef
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '014db6d4ef'
${ noResults }
DPF-Plugins/plugins/Nekobi/DistrhoPluginNekobi.cpp

436 lines
14KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Nekobi Plugin, based on Nekobee by Sean Bolton and others.

  3.  * Copyright (C) 2004 Sean Bolton and others

  4.  * Copyright (C) 2013-2015 Filipe Coelho <falktx@falktx.com>

  5.  *

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

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

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

  9.  * the License, or 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.  * For a full copy of the GNU General Public License see the LICENSE file.

  17.  */

  18. 

  19. #include "DistrhoPluginNekobi.hpp"

  20. 

  21. extern "C" {

  22. 

  23. #include "nekobee-src/nekobee_synth.c"

  24. #include "nekobee-src/nekobee_voice.c"

  25. #include "nekobee-src/nekobee_voice_render.c"

  26. #include "nekobee-src/minblep_tables.c"

  27. 

  28. // -----------------------------------------------------------------------

  29. // mutual exclusion

  30. 

  31. bool dssp_voicelist_mutex_trylock(nekobee_synth_t* const synth)

  32. {

  33.     /* Attempt the mutex lock */

  34.     if (pthread_mutex_trylock(&synth->voicelist_mutex) != 0)

  35.     {

  36.         synth->voicelist_mutex_grab_failed = 1;

  37.         return false;

  38.     }

  39. 

  40.     /* Clean up if a previous mutex grab failed */

  41.     if (synth->voicelist_mutex_grab_failed)

  42.     {

  43.         nekobee_synth_all_voices_off(synth);

  44.         synth->voicelist_mutex_grab_failed = 0;

  45.     }

  46. 

  47.     return true;

  48. }

  49. 

  50. bool dssp_voicelist_mutex_unlock(nekobee_synth_t* const synth)

  51. {

  52.     return (pthread_mutex_unlock(&synth->voicelist_mutex) == 0);

  53. }

  54. 

  55. // -----------------------------------------------------------------------

  56. // nekobee_handle_raw_event

  57. 

  58. void nekobee_handle_raw_event(nekobee_synth_t* const synth, const uint8_t size, const uint8_t* const data)

  59. {

  60.     if (size != 3)

  61.         return;

  62. 

  63.     switch (data[0] & 0xf0)

  64.     {

  65.     case 0x80:

  66.         nekobee_synth_note_off(synth, data[1], data[2]);

  67.         break;

  68.     case 0x90:

  69.         if (data[2] > 0)

  70.             nekobee_synth_note_on(synth, data[1], data[2]);

  71.         else

  72.             nekobee_synth_note_off(synth, data[1], 64); /* shouldn't happen, but... */

  73.         break;

  74.     case 0xB0:

  75.         nekobee_synth_control_change(synth, data[1], data[2]);

  76.         break;

  77.     default:

  78.         break;

  79.     }

  80. }

  81. 

  82. } /* extern "C" */

  83. 

  84. START_NAMESPACE_DISTRHO

  85. 

  86. // -----------------------------------------------------------------------

  87. 

  88. DistrhoPluginNekobi::DistrhoPluginNekobi()

  89.     : Plugin(paramCount, 0, 0) // 0 programs, 0 states

  90. {

  91.     nekobee_init_tables();

  92. 

  93.     // init synth

  94.     fSynth.sample_rate = getSampleRate();

  95.     fSynth.deltat = 1.0f / (float)getSampleRate();

  96.     fSynth.nugget_remains = 0;

  97. 

  98.     fSynth.note_id = 0;

  99.     fSynth.polyphony = XSYNTH_DEFAULT_POLYPHONY;

  100.     fSynth.voices = XSYNTH_DEFAULT_POLYPHONY;

  101.     fSynth.monophonic = XSYNTH_MONO_MODE_ONCE;

  102.     fSynth.glide = 0;

  103.     fSynth.last_noteon_pitch = 0.0f;

  104.     fSynth.vcf_accent = 0.0f;

  105.     fSynth.vca_accent = 0.0f;

  106. 

  107.     for (int i=0; i<8; ++i)

  108.         fSynth.held_keys[i] = -1;

  109. 

  110.     fSynth.voice = nekobee_voice_new();

  111.     fSynth.voicelist_mutex_grab_failed = 0;

  112.     pthread_mutex_init(&fSynth.voicelist_mutex, nullptr);

  113. 

  114.     fSynth.channel_pressure = 0;

  115.     fSynth.pitch_wheel_sensitivity = 0;

  116.     fSynth.pitch_wheel = 0;

  117. 

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

  119.     {

  120.         fSynth.key_pressure[i] = 0;

  121.         fSynth.cc[i] = 0;

  122.     }

  123.     fSynth.cc[7] = 127; // full volume

  124. 

  125.     fSynth.mod_wheel  = 1.0f;

  126.     fSynth.pitch_bend = 1.0f;

  127.     fSynth.cc_volume  = 1.0f;

  128. 

  129.     // Default values

  130.     fParams.waveform = 0.0f;

  131.     fParams.tuning = 0.0f;

  132.     fParams.cutoff = 25.0f;

  133.     fParams.resonance = 25.0f;

  134.     fParams.envMod = 50.0f;

  135.     fParams.decay  = 75.0f;

  136.     fParams.accent = 25.0f;

  137.     fParams.volume = 75.0f;

  138.     fParams.bypass = false;

  139. 

  140.     // Internal stuff

  141.     fSynth.waveform  = 0.0f;

  142.     fSynth.tuning    = 1.0f;

  143.     fSynth.cutoff    = 5.0f;

  144.     fSynth.resonance = 0.8f;

  145.     fSynth.envmod    = 0.3f;

  146.     fSynth.decay     = 0.0002f;

  147.     fSynth.accent    = 0.3f;

  148.     fSynth.volume    = 0.75f;

  149. 

  150.     // reset

  151.     deactivate();

  152. }

  153. 

  154. DistrhoPluginNekobi::~DistrhoPluginNekobi()

  155. {

  156.     std::free(fSynth.voice);

  157. }

  158. 

  159. // -----------------------------------------------------------------------

  160. // Init

  161. 

  162. void DistrhoPluginNekobi::initParameter(uint32_t index, Parameter& parameter)

  163. {

  164.     switch (index)

  165.     {

  166.     case paramWaveform:

  167.         parameter.hints      = kParameterIsAutomable|kParameterIsInteger;

  168.         parameter.name       = "Waveform";

  169.         parameter.symbol     = "waveform";

  170.         parameter.ranges.def = 0.0f;

  171.         parameter.ranges.min = 0.0f;

  172.         parameter.ranges.max = 1.0f;

  173.         parameter.enumValues.count = 2;

  174.         parameter.enumValues.restrictedMode = true;

  175.         parameter.midiCC = 70; //Sound Variation

  176.         {

  177.             ParameterEnumerationValue* const enumValues = new ParameterEnumerationValue[2];

  178.             enumValues[0].value = 0.0f;

  179.             enumValues[0].label = "Square";

  180.             enumValues[1].value = 1.0f;

  181.             enumValues[1].label = "Triangle";

  182.             parameter.enumValues.values = enumValues;

  183.         }

  184.         break;

  185.     case paramTuning:

  186.         parameter.hints      = kParameterIsAutomable; // was 0.5 <-> 2.0, log

  187.         parameter.name       = "Tuning";

  188.         parameter.symbol     = "tuning";

  189.         parameter.ranges.def = 0.0f;

  190.         parameter.ranges.min = -12.0f;

  191.         parameter.ranges.max = 12.0f;

  192.         parameter.midiCC = 75;

  193.         break;

  194.     case paramCutoff:

  195.         parameter.hints      = kParameterIsAutomable; // modified x2.5

  196.         parameter.name       = "Cutoff";

  197.         parameter.symbol     = "cutoff";

  198.         parameter.unit       = "%";

  199.         parameter.ranges.def = 25.0f;

  200.         parameter.ranges.min = 0.0f;

  201.         parameter.ranges.max = 100.0f;

  202.         parameter.midiCC = 74;

  203.         break;

  204.     case paramResonance:

  205.         parameter.hints      = kParameterIsAutomable; // modified x100

  206.         parameter.name       = "VCF Resonance";

  207.         parameter.symbol     = "resonance";

  208.         parameter.unit       = "%";

  209.         parameter.ranges.def = 25.0f;

  210.         parameter.ranges.min = 0.0f;

  211.         parameter.ranges.max = 95.0f;

  212.         parameter.midiCC = 71;

  213.         break;

  214.     case paramEnvMod:

  215.         parameter.hints      = kParameterIsAutomable; // modified x100

  216.         parameter.name       = "Env Mod";

  217.         parameter.symbol     = "env_mod";

  218.         parameter.unit       = "%";

  219.         parameter.ranges.def = 50.0f;

  220.         parameter.ranges.min = 0.0f;

  221.         parameter.ranges.max = 100.0f;

  222.         parameter.midiCC = 1; //Mod Wheel

  223.         break;

  224.     case paramDecay:

  225.         parameter.hints      = kParameterIsAutomable; // was 0.000009 <-> 0.0005, log

  226.         parameter.name       = "Decay";

  227.         parameter.symbol     = "decay";

  228.         parameter.unit       = "%";

  229.         parameter.ranges.def = 75.0f;

  230.         parameter.ranges.min = 0.0f;

  231.         parameter.ranges.max = 100.0f;

  232.         parameter.midiCC = 72;

  233.         break;

  234.     case paramAccent:

  235.         parameter.hints      = kParameterIsAutomable; // modified x100

  236.         parameter.name       = "Accent";

  237.         parameter.symbol     = "accent";

  238.         parameter.unit       = "%";

  239.         parameter.ranges.def = 25.0f;

  240.         parameter.ranges.min = 0.0f;

  241.         parameter.ranges.max = 100.0f;

  242.         parameter.midiCC = 76;

  243.         break;

  244.     case paramVolume:

  245.         parameter.hints      = kParameterIsAutomable; // modified x100

  246.         parameter.name       = "Volume";

  247.         parameter.symbol     = "volume";

  248.         parameter.unit       = "%";

  249.         parameter.ranges.def = 75.0f;

  250.         parameter.ranges.min = 0.0f;

  251.         parameter.ranges.max = 100.0f;

  252.         parameter.midiCC = 7; //Volume

  253.         break;

  254.     case paramBypass:

  255.         parameter.initDesignation(kParameterDesignationBypass);

  256.         break;

  257.     }

  258. }

  259. 

  260. // -----------------------------------------------------------------------

  261. // Internal data

  262. 

  263. float DistrhoPluginNekobi::getParameterValue(uint32_t index) const

  264. {

  265.     switch (index)

  266.     {

  267.     case paramWaveform:

  268.         return fParams.waveform;

  269.     case paramTuning:

  270.         return fParams.tuning;

  271.     case paramCutoff:

  272.         return fParams.cutoff;

  273.     case paramResonance:

  274.         return fParams.resonance;

  275.     case paramEnvMod:

  276.         return fParams.envMod;

  277.     case paramDecay:

  278.         return fParams.decay;

  279.     case paramAccent:

  280.         return fParams.accent;

  281.     case paramVolume:

  282.         return fParams.volume;

  283.     case paramBypass:

  284.         return fParams.bypass ? 1.0f : 0.0f;

  285.     }

  286. 

  287.     return 0.0f;

  288. }

  289. 

  290. void DistrhoPluginNekobi::setParameterValue(uint32_t index, float value)

  291. {

  292.     switch (index)

  293.     {

  294.     case paramWaveform:

  295.         fParams.waveform = value;

  296.         fSynth.waveform = value;

  297.         DISTRHO_SAFE_ASSERT(fSynth.waveform == 0.0f || fSynth.waveform == 1.0f);

  298.         break;

  299.     case paramTuning:

  300.         fParams.tuning = value;

  301.         fSynth.tuning = (value+12.0f)/24.0f * 1.5 + 0.5f; // FIXME: log?

  302.         DISTRHO_SAFE_ASSERT(fSynth.tuning >= 0.5f && fSynth.tuning <= 2.0f);

  303.         break;

  304.     case paramCutoff:

  305.         fParams.cutoff = value;

  306.         fSynth.cutoff = value/2.5f;

  307.         DISTRHO_SAFE_ASSERT(fSynth.cutoff >= 0.0f && fSynth.cutoff <= 40.0f);

  308.         break;

  309.     case paramResonance:

  310.         fParams.resonance = value;

  311.         fSynth.resonance = value/100.0f;

  312.         DISTRHO_SAFE_ASSERT(fSynth.resonance >= 0.0f && fSynth.resonance <= 0.95f);

  313.         break;

  314.     case paramEnvMod:

  315.         fParams.envMod = value;

  316.         fSynth.envmod = value/100.0f;

  317.         DISTRHO_SAFE_ASSERT(fSynth.envmod >= 0.0f && fSynth.envmod <= 1.0f);

  318.         break;

  319.     case paramDecay:

  320.         fParams.decay = value;

  321.         fSynth.decay = value/100.0f * 0.000491f + 0.000009f; // FIXME: log?

  322.         DISTRHO_SAFE_ASSERT(fSynth.decay >= 0.000009f && fSynth.decay <= 0.0005f);

  323.         break;

  324.     case paramAccent:

  325.         fParams.accent = value;

  326.         fSynth.accent = value/100.0f;

  327.         DISTRHO_SAFE_ASSERT(fSynth.accent >= 0.0f && fSynth.accent <= 1.0f);

  328.         break;

  329.     case paramVolume:

  330.         fParams.volume = value;

  331.         fSynth.volume = value/100.0f;

  332.         DISTRHO_SAFE_ASSERT(fSynth.volume >= 0.0f && fSynth.volume <= 1.0f);

  333.         break;

  334.     case paramBypass: {

  335.         const bool bypass = (value > 0.5f);

  336.         if (fParams.bypass != bypass)

  337.         {

  338.             fParams.bypass = bypass;

  339.             nekobee_synth_all_voices_off(&fSynth);

  340.         }

  341.     }   break;

  342.     }

  343. }

  344. 

  345. // -----------------------------------------------------------------------

  346. // Process

  347. 

  348. void DistrhoPluginNekobi::activate()

  349. {

  350.     fSynth.nugget_remains = 0;

  351.     fSynth.note_id = 0;

  352. 

  353.     if (fSynth.voice != nullptr)

  354.         nekobee_synth_all_voices_off(&fSynth);

  355. }

  356. 

  357. void DistrhoPluginNekobi::deactivate()

  358. {

  359.     if (fSynth.voice != nullptr)

  360.         nekobee_synth_all_voices_off(&fSynth);

  361. }

  362. 

  363. void DistrhoPluginNekobi::run(const float**, float** outputs, uint32_t frames, const MidiEvent* midiEvents, uint32_t midiEventCount)

  364. {

  365.     uint32_t framesDone = 0;

  366.     uint32_t curEventIndex = 0;

  367.     uint32_t burstSize;

  368. 

  369.     float* out = outputs[0];

  370. 

  371.     if (fSynth.voice == nullptr || ! dssp_voicelist_mutex_trylock(&fSynth))

  372.     {

  373.         std::memset(out, 0, sizeof(float)*frames);

  374.         return;

  375.     }

  376. 

  377.     // ignore midi input if bypassed

  378.     if (fParams.bypass)

  379.         midiEventCount = 0;

  380. 

  381.     while (framesDone < frames)

  382.     {

  383.         if (fSynth.nugget_remains == 0)

  384.             fSynth.nugget_remains = XSYNTH_NUGGET_SIZE;

  385. 

  386.         /* process any ready events */

  387.         while (curEventIndex < midiEventCount && framesDone == midiEvents[curEventIndex].frame)

  388.         {

  389.             if (midiEvents[curEventIndex].size > MidiEvent::kDataSize)

  390.                 continue;

  391. 

  392.             nekobee_handle_raw_event(&fSynth, midiEvents[curEventIndex].size, midiEvents[curEventIndex].data);

  393.             curEventIndex++;

  394.         }

  395. 

  396.         /* calculate the sample count (burstSize) for the next nekobee_voice_render() call to be the smallest of:

  397.          * - control calculation quantization size (XSYNTH_NUGGET_SIZE, in samples)

  398.          * - the number of samples remaining in an already-begun nugget (synth->nugget_remains)

  399.          * - the number of samples until the next event is ready

  400.          * - the number of samples left in this run

  401.          */

  402.         burstSize = XSYNTH_NUGGET_SIZE;

  403. 

  404.         /* we're still in the middle of a nugget, so reduce the burst size

  405.          * to end when the nugget ends */

  406.         if (fSynth.nugget_remains < burstSize)

  407.             burstSize = fSynth.nugget_remains;

  408. 

  409.         /* reduce burst size to end when next event is ready */

  410.         if (curEventIndex < midiEventCount && midiEvents[curEventIndex].frame - framesDone < burstSize)

  411.             burstSize = midiEvents[curEventIndex].frame - framesDone;

  412. 

  413.         /* reduce burst size to end at end of this run */

  414.         if (frames - framesDone < burstSize)

  415.             burstSize = frames - framesDone;

  416. 

  417.         /* render the burst */

  418.         nekobee_synth_render_voices(&fSynth, out + framesDone, burstSize, (burstSize == fSynth.nugget_remains));

  419.         framesDone += burstSize;

  420.         fSynth.nugget_remains -= burstSize;

  421.     }

  422. 

  423.     dssp_voicelist_mutex_unlock(&fSynth);

  424. }

  425. 

  426. // -----------------------------------------------------------------------

  427. 

  428. Plugin* createPlugin()

  429. {

  430.     return new DistrhoPluginNekobi();

  431. }

  432. 

  433. // -----------------------------------------------------------------------

  434. 

  435. END_NAMESPACE_DISTRHO