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.
189 Commits
1 Branch
86MB
Tree: 6ecedf2754
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6ecedf2754'
${ noResults }
DPF-Plugins/plugins/Nekobi/DistrhoPluginNekobi.cpp

421 lines
13KB
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-2022 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. 

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

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

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

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

  26. 

  27. // -----------------------------------------------------------------------

  28. // mutual exclusion

  29. 

  30. bool dssp_voicelist_mutex_trylock(nekobee_synth_t* const synth)

  31. {

  32.     /* Attempt the mutex lock */

  33.     if (!synth->voicelist_mutex.try_lock())

  34.     {

  35.         synth->voicelist_mutex_grab_failed = 1;

  36.         return false;

  37.     }

  38. 

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

  40.     if (synth->voicelist_mutex_grab_failed)

  41.     {

  42.         nekobee_synth_all_voices_off(synth);

  43.         synth->voicelist_mutex_grab_failed = 0;

  44.     }

  45. 

  46.     return true;

  47. }

  48. 

  49. void dssp_voicelist_mutex_unlock(nekobee_synth_t* const synth)

  50. {

  51.     synth->voicelist_mutex.unlock();

  52. }

  53. 

  54. // -----------------------------------------------------------------------

  55. // nekobee_handle_raw_event

  56. 

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

  58. {

  59.     if (size != 3)

  60.         return;

  61. 

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

  63.     {

  64.     case 0x80:

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

  66.         break;

  67.     case 0x90:

  68.         if (data[2] > 0)

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

  70.         else

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

  72.         break;

  73.     case 0xB0:

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

  75.         break;

  76.     default:

  77.         break;

  78.     }

  79. }

  80. 

  81. 

  82. START_NAMESPACE_DISTRHO

  83. 

  84. // -----------------------------------------------------------------------

  85. 

  86. DistrhoPluginNekobi::DistrhoPluginNekobi()

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

  88. {

  89.     nekobee_init_tables();

  90. 

  91.     // init synth

  92.     fSynth.sample_rate = getSampleRate();

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

  94.     fSynth.nugget_remains = 0;

  95. 

  96.     fSynth.note_id = 0;

  97.     fSynth.polyphony = XSYNTH_DEFAULT_POLYPHONY;

  98.     fSynth.voices = XSYNTH_DEFAULT_POLYPHONY;

  99.     fSynth.monophonic = XSYNTH_MONO_MODE_ONCE;

  100.     fSynth.glide = 0;

  101.     fSynth.last_noteon_pitch = 0.0f;

  102.     fSynth.vcf_accent = 0.0f;

  103.     fSynth.vca_accent = 0.0f;

  104. 

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

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

  107. 

  108.     fSynth.voice = nekobee_voice_new();

  109.     fSynth.voicelist_mutex_grab_failed = 0;

  110. 

  111.     fSynth.channel_pressure = 0;

  112.     fSynth.pitch_wheel_sensitivity = 0;

  113.     fSynth.pitch_wheel = 0;

  114. 

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

  116.     {

  117.         fSynth.key_pressure[i] = 0;

  118.         fSynth.cc[i] = 0;

  119.     }

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

  121. 

  122.     fSynth.mod_wheel  = 1.0f;

  123.     fSynth.pitch_bend = 1.0f;

  124.     fSynth.cc_volume  = 1.0f;

  125. 

  126.     // Default values

  127.     fParams.waveform = 0.0f;

  128.     fParams.tuning = 0.0f;

  129.     fParams.cutoff = 25.0f;

  130.     fParams.resonance = 25.0f;

  131.     fParams.envMod = 50.0f;

  132.     fParams.decay  = 75.0f;

  133.     fParams.accent = 25.0f;

  134.     fParams.volume = 75.0f;

  135. 

  136.     // Internal stuff

  137.     fSynth.waveform  = 0.0f;

  138.     fSynth.tuning    = 1.0f;

  139.     fSynth.cutoff    = 5.0f;

  140.     fSynth.resonance = 0.8f;

  141.     fSynth.envmod    = 0.3f;

  142.     fSynth.decay     = 0.0002f;

  143.     fSynth.accent    = 0.3f;

  144.     fSynth.volume    = 0.75f;

  145. 

  146.     // reset

  147.     deactivate();

  148. }

  149. 

  150. DistrhoPluginNekobi::~DistrhoPluginNekobi()

  151. {

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

  153. }

  154. 

  155. // -----------------------------------------------------------------------

  156. // Init

  157. 

  158. void DistrhoPluginNekobi::initAudioPort(bool input, uint32_t index, AudioPort& port)

  159. {

  160.     port.groupId = kPortGroupMono;

  161. 

  162.     Plugin::initAudioPort(input, index, port);

  163. }

  164. 

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

  166. {

  167.     switch (index)

  168.     {

  169.     case paramWaveform:

  170.         parameter.hints      = kParameterIsAutomatable|kParameterIsInteger;

  171.         parameter.name       = "Waveform";

  172.         parameter.symbol     = "waveform";

  173.         parameter.ranges.def = 0.0f;

  174.         parameter.ranges.min = 0.0f;

  175.         parameter.ranges.max = 1.0f;

  176.         parameter.enumValues.count = 2;

  177.         parameter.enumValues.restrictedMode = true;

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

  179.         {

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

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

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

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

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

  185.             parameter.enumValues.values = enumValues;

  186.         }

  187.         break;

  188.     case paramTuning:

  189.         parameter.hints      = kParameterIsAutomatable; // was 0.5 <-> 2.0, log

  190.         parameter.name       = "Tuning";

  191.         parameter.symbol     = "tuning";

  192.         parameter.ranges.def = 0.0f;

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

  194.         parameter.ranges.max = 12.0f;

  195.         parameter.midiCC = 75;

  196.         break;

  197.     case paramCutoff:

  198.         parameter.hints      = kParameterIsAutomatable; // modified x2.5

  199.         parameter.name       = "Cutoff";

  200.         parameter.symbol     = "cutoff";

  201.         parameter.unit       = "%";

  202.         parameter.ranges.def = 25.0f;

  203.         parameter.ranges.min = 0.0f;

  204.         parameter.ranges.max = 100.0f;

  205.         parameter.midiCC = 74;

  206.         break;

  207.     case paramResonance:

  208.         parameter.hints      = kParameterIsAutomatable; // modified x100

  209.         parameter.name       = "VCF Resonance";

  210.         parameter.symbol     = "resonance";

  211.         parameter.unit       = "%";

  212.         parameter.ranges.def = 25.0f;

  213.         parameter.ranges.min = 0.0f;

  214.         parameter.ranges.max = 95.0f;

  215.         parameter.midiCC = 71;

  216.         break;

  217.     case paramEnvMod:

  218.         parameter.hints      = kParameterIsAutomatable; // modified x100

  219.         parameter.name       = "Env Mod";

  220.         parameter.symbol     = "env_mod";

  221.         parameter.unit       = "%";

  222.         parameter.ranges.def = 50.0f;

  223.         parameter.ranges.min = 0.0f;

  224.         parameter.ranges.max = 100.0f;

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

  226.         break;

  227.     case paramDecay:

  228.         parameter.hints      = kParameterIsAutomatable; // was 0.000009 <-> 0.0005, log

  229.         parameter.name       = "Decay";

  230.         parameter.symbol     = "decay";

  231.         parameter.unit       = "%";

  232.         parameter.ranges.def = 75.0f;

  233.         parameter.ranges.min = 0.0f;

  234.         parameter.ranges.max = 100.0f;

  235.         parameter.midiCC = 72;

  236.         break;

  237.     case paramAccent:

  238.         parameter.hints      = kParameterIsAutomatable; // modified x100

  239.         parameter.name       = "Accent";

  240.         parameter.symbol     = "accent";

  241.         parameter.unit       = "%";

  242.         parameter.ranges.def = 25.0f;

  243.         parameter.ranges.min = 0.0f;

  244.         parameter.ranges.max = 100.0f;

  245.         parameter.midiCC = 76;

  246.         break;

  247.     case paramVolume:

  248.         parameter.hints      = kParameterIsAutomatable; // modified x100

  249.         parameter.name       = "Volume";

  250.         parameter.symbol     = "volume";

  251.         parameter.unit       = "%";

  252.         parameter.ranges.def = 75.0f;

  253.         parameter.ranges.min = 0.0f;

  254.         parameter.ranges.max = 100.0f;

  255.         parameter.midiCC = 7; //Volume

  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.     }

  284. 

  285.     return 0.0f;

  286. }

  287. 

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

  289. {

  290.     switch (index)

  291.     {

  292.     case paramWaveform:

  293.         fParams.waveform = value;

  294.         fSynth.waveform = value;

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

  296.         break;

  297.     case paramTuning:

  298.         fParams.tuning = value;

  299.         fSynth.tuning = exp2f( value / 12.0f );

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

  301.         break;

  302.     case paramCutoff:

  303.         fParams.cutoff = value;

  304.         fSynth.cutoff = value/2.5f;

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

  306.         break;

  307.     case paramResonance:

  308.         fParams.resonance = value;

  309.         fSynth.resonance = value/100.0f;

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

  311.         break;

  312.     case paramEnvMod:

  313.         fParams.envMod = value;

  314.         fSynth.envmod = value/100.0f;

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

  316.         break;

  317.     case paramDecay:

  318.         fParams.decay = value;

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

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

  321.         break;

  322.     case paramAccent:

  323.         fParams.accent = value;

  324.         fSynth.accent = value/100.0f;

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

  326.         break;

  327.     case paramVolume:

  328.         fParams.volume = value;

  329.         fSynth.volume = value/100.0f;

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

  331.         break;

  332.     }

  333. }

  334. 

  335. // -----------------------------------------------------------------------

  336. // Process

  337. 

  338. void DistrhoPluginNekobi::activate()

  339. {

  340.     fSynth.nugget_remains = 0;

  341.     fSynth.note_id = 0;

  342. 

  343.     if (fSynth.voice != nullptr)

  344.         nekobee_synth_all_voices_off(&fSynth);

  345. }

  346. 

  347. void DistrhoPluginNekobi::deactivate()

  348. {

  349.     if (fSynth.voice != nullptr)

  350.         nekobee_synth_all_voices_off(&fSynth);

  351. }

  352. 

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

  354. {

  355.     uint32_t framesDone = 0;

  356.     uint32_t curEventIndex = 0;

  357.     uint32_t burstSize;

  358. 

  359.     float* out = outputs[0];

  360. 

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

  362.     {

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

  364.         return;

  365.     }

  366. 

  367.     while (framesDone < frames)

  368.     {

  369.         if (fSynth.nugget_remains == 0)

  370.             fSynth.nugget_remains = XSYNTH_NUGGET_SIZE;

  371. 

  372.         /* process any ready events */

  373.         for (; curEventIndex < midiEventCount && framesDone == midiEvents[curEventIndex].frame; ++curEventIndex)

  374.         {

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

  376.                 continue;

  377. 

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

  379.         }

  380. 

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

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

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

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

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

  386.          */

  387.         burstSize = XSYNTH_NUGGET_SIZE;

  388. 

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

  390.          * to end when the nugget ends */

  391.         if (fSynth.nugget_remains < burstSize)

  392.             burstSize = fSynth.nugget_remains;

  393. 

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

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

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

  397. 

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

  399.         if (frames - framesDone < burstSize)

  400.             burstSize = frames - framesDone;

  401. 

  402.         /* render the burst */

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

  404.         framesDone += burstSize;

  405.         fSynth.nugget_remains -= burstSize;

  406.     }

  407. 

  408.     dssp_voicelist_mutex_unlock(&fSynth);

  409. }

  410. 

  411. // -----------------------------------------------------------------------

  412. 

  413. Plugin* createPlugin()

  414. {

  415.     return new DistrhoPluginNekobi();

  416. }

  417. 

  418. // -----------------------------------------------------------------------

  419. 

  420. END_NAMESPACE_DISTRHO