Compiles... but works?

src/Makefile

@@ -3,14 +3,14 @@
 BUNDLE=dexed.lv2
 INSTALL_DIR=/home/pi/zynthian/zynthian-plugins/mod-lv2
 TARGET=dexed.so
-OBJ=ringbuffer.o fm_core.o env.o lfo.o dx7note.o sin.o pitchenv.o fm_op_kernel.o freqlut.o exp2.o EngineMkI.o EngineOpl.o
+OBJ=ringbuffer.o fm_core.o env.o lfo.o dx7note.o sin.o pitchenv.o fm_op_kernel.o freqlut.o exp2.o EngineMkI.o EngineOpl.o PluginFx.o
 CFLAGS=-fPIC -DPIC $(DEBUG) -std=c++11 -I. -I/usr/local/include/lvtk-2
 LDFLAGS=-L/usr/local/lib -llvtk_plugin2
 
 all: $(BUNDLE) Makefile
 
 clean:
-	rm -f *.o *~ *.bak *.gch dexed-ttl.h *.so
+	rm -f *.o *~ *.bak *.gch dexed.peg *.so
 	rm -rf $(BUNDLE)
 
 install: $(BUNDLE)
@@ -34,7 +34,7 @@ dexed.so: $(OBJ) dexed.o
 #dexed-test.o: dexed-test.cpp
 #	$(CXX) $(CFLAGS) -Wall -c dexed-test.cpp
 
-dexed.o: dexed.cpp dexed-ttl.h
+dexed.o: dexed.cpp dexed.peg
 	$(CXX) $(CFLAGS) -Wall -c dexed.cpp
 
 ringbuffer.o: msfa/ringbuffer.cc
@@ -76,6 +76,6 @@ EngineOpl.o: EngineOpl.cpp
 PluginFx.o: PluginFx.cpp
 	$(CXX) $(CFLAGS) -Wall -c PluginFx.cpp
 
-dexed-ttl.h: Dexed.ttl
+dexed.peg: Dexed.ttl
-	ttl2c Dexed.ttl dexed-ttl.h
+	lv2peg Dexed.ttl dexed.peg
 

src/PluginFx.cpp

@@ -25,7 +25,6 @@
 #define _USE_MATH_DEFINES
 #include <math.h>
 #include "PluginFx.h"
-#include "PluginProcessor.h"
 
 const float dc = 1e-18;
 
@@ -44,9 +43,9 @@ inline static float tptlpupw(float & state , float inp , float cutoff , float sr
 	return res;
 }
 
-static float linsc(float param,const float min,const float max) {
+//static float linsc(float param,const float min,const float max) {
-    return (param) * (max - min) + min;
+//    return (param) * (max - min) + min;
-}
+//}
 
 static float logsc(float param, const float min,const float max,const float rolloff = 19.0f) {
 	return ((expf(param * logf(rolloff+1)) - 1.0f) / (rolloff)) * (max-min) + min;

src/dexed-ttl.h

@@ -1,333 +0,0 @@
-#ifndef dexed_ttl_h
-#define dexed_ttl_h
-
-
-#ifndef PEG_STRUCT
-#define PEG_STRUCT
-typedef struct {
-  float min;
-  float max;
-  float default_value;
-  char toggled;
-  char integer;
-  char logarithmic;
-} peg_data_t;
-#endif
-
-/* <https://github.com/dcoredump/dexed> */
-
-static const char p_uri[] = "https://github.com/dcoredump/dexed";
-
-enum p_port_enum {
-  p_lv2_events_in,
-  p_lv2_freewheel,
-  p_lv2_latency,
-  p_lv2_audio_out_1,
-  p_cutoff,
-  p_resonance,
-  p_output,
-  p_algorithm,
-  p_feedback,
-  p_osc_key_sync,
-  p_lfo_speed,
-  p_lfo_delay,
-  p_lfo_pm_depth,
-  p_lfo_am_depth,
-  p_lfo_key_sync,
-  p_lfo_wave,
-  p_middle_c,
-  p_p_mode_sens_,
-  p_pitch_eg_rate_1,
-  p_pitch_eg_rate_2,
-  p_pitch_eg_rate_3,
-  p_pitch_eg_rate_4,
-  p_pitch_eg_level_1,
-  p_pitch_eg_level_2,
-  p_pitch_eg_level_3,
-  p_pitch_eg_level_4,
-  p_op1_eg_rate_1,
-  p_op1_eg_rate_2,
-  p_op1_eg_rate_3,
-  p_op1_eg_rate_4,
-  p_op1_eg_level_1,
-  p_op1_eg_level_2,
-  p_op1_eg_level_3,
-  p_op1_eg_level_4,
-  p_op1_output_level,
-  p_op1_mode,
-  p_op1_f_coarse,
-  p_op1_f_fine,
-  p_op1_osc_detune,
-  p_op1_break_point,
-  p_op1_l_scale_depth,
-  p_op1_r_scale_depth,
-  p_op1_l_key_scale,
-  p_op1_r_key_scale,
-  p_op1_rate_scaling,
-  p_op1_a_mod_sens_,
-  p_op1_key_velocity,
-  p_op2_eg_rate_1,
-  p_op2_eg_rate_2,
-  p_op2_eg_rate_3,
-  p_op2_eg_rate_4,
-  p_op2_eg_level_1,
-  p_op2_eg_level_2,
-  p_op2_eg_level_3,
-  p_op2_eg_level_4,
-  p_op2_output_level,
-  p_op2_mode,
-  p_op2_f_coarse,
-  p_op2_f_fine,
-  p_op2_osc_detune,
-  p_op2_break_point,
-  p_op2_l_scale_depth,
-  p_op2_r_scale_depth,
-  p_op2_l_key_scale,
-  p_op2_r_key_scale,
-  p_op2_rate_scaling,
-  p_op2_a_mod_sens_,
-  p_op2_key_velocity,
-  p_op3_eg_rate_1,
-  p_op3_eg_rate_2,
-  p_op3_eg_rate_3,
-  p_op3_eg_rate_4,
-  p_op3_eg_level_1,
-  p_op3_eg_level_2,
-  p_op3_eg_level_3,
-  p_op3_eg_level_4,
-  p_op3_output_level,
-  p_op3_mode,
-  p_op3_f_coarse,
-  p_op3_f_fine,
-  p_op3_osc_detune,
-  p_op3_break_point,
-  p_op3_l_scale_depth,
-  p_op3_r_scale_depth,
-  p_op3_l_key_scale,
-  p_op3_r_key_scale,
-  p_op3_rate_scaling,
-  p_op3_a_mod_sens_,
-  p_op3_key_velocity,
-  p_op4_eg_rate_1,
-  p_op4_eg_rate_2,
-  p_op4_eg_rate_3,
-  p_op4_eg_rate_4,
-  p_op4_eg_level_1,
-  p_op4_eg_level_2,
-  p_op4_eg_level_3,
-  p_op4_eg_level_4,
-  p_op4_output_level,
-  p_op4_mode,
-  p_op4_f_coarse,
-  p_op4_f_fine,
-  p_op4_osc_detune,
-  p_op4_break_point,
-  p_op4_l_scale_depth,
-  p_op4_r_scale_depth,
-  p_op4_l_key_scale,
-  p_op4_r_key_scale,
-  p_op4_rate_scaling,
-  p_op4_a_mod_sens_,
-  p_op4_key_velocity,
-  p_op5_eg_rate_1,
-  p_op5_eg_rate_2,
-  p_op5_eg_rate_3,
-  p_op5_eg_rate_4,
-  p_op5_eg_level_1,
-  p_op5_eg_level_2,
-  p_op5_eg_level_3,
-  p_op5_eg_level_4,
-  p_op5_output_level,
-  p_op5_mode,
-  p_op5_f_coarse,
-  p_op5_f_fine,
-  p_op5_osc_detune,
-  p_op5_break_point,
-  p_op5_l_scale_depth,
-  p_op5_r_scale_depth,
-  p_op5_l_key_scale,
-  p_op5_r_key_scale,
-  p_op5_rate_scaling,
-  p_op5_a_mod_sens_,
-  p_op5_key_velocity,
-  p_op6_eg_rate_1,
-  p_op6_eg_rate_2,
-  p_op6_eg_rate_3,
-  p_op6_eg_rate_4,
-  p_op6_eg_level_1,
-  p_op6_eg_level_2,
-  p_op6_eg_level_3,
-  p_op6_eg_level_4,
-  p_op6_output_level,
-  p_op6_mode,
-  p_op6_f_coarse,
-  p_op6_f_fine,
-  p_op6_osc_detune,
-  p_op6_break_point,
-  p_op6_l_scale_depth,
-  p_op6_r_scale_depth,
-  p_op6_l_key_scale,
-  p_op6_r_key_scale,
-  p_op6_rate_scaling,
-  p_op6_a_mod_sens_,
-  p_op6_key_velocity,
-  p_n_ports
-};
-
-static const peg_data_t p_ports[] = {
-  { -3.40282e+38, 3.40282e+38, -3.40282e+38, 0, 0, 0 }, 
-  { 0, 1, 0, 1, 0, 0 }, 
-  { -3.40282e+38, 3.40282e+38, -3.40282e+38, 0, 1, 0 }, 
-  { -3.40282e+38, 3.40282e+38, -3.40282e+38, 0, 0, 0 }, 
-  { 0, 1, 1, 0, 0, 0 }, 
-  { 0, 1, 0, 0, 0, 0 }, 
-  { 0, 2, 1, 0, 0, 0 }, 
-  { 1, 32, 1, 0, 1, 0 }, 
-  { 1, 8, 1, 0, 1, 0 }, 
-  { 1, 1, 0, 1, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 1, 0, 1, 1, 0 }, 
-  { 1, 6, 1, 0, 1, 0 }, 
-  { 0, 48, 24, 0, 1, 0 }, 
-  { 1, 8, 1, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 1, 0, 1, 1, 0 }, 
-  { 0, 31, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { -7, 7, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 3, 0, 0, 1, 0 }, 
-  { 0, 3, 0, 0, 1, 0 }, 
-  { 0, 7, 0, 0, 1, 0 }, 
-  { 0, 3, 0, 0, 1, 0 }, 
-  { 0, 7, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 1, 0, 1, 1, 0 }, 
-  { 0, 31, 0, 0, 1, 0 }, 
-  { 0, 100, 0, 0, 1, 0 }, 
-  { -7, 7, 0, 0, 1, 0 }, 
-  { 0, 100, 0, 0, 1, 0 }, 
-  { 0, 100, 0, 0, 1, 0 }, 
-  { 0, 100, 0, 0, 1, 0 }, 
-  { 0, 3, 0, 0, 1, 0 }, 
-  { 0, 3, 0, 0, 1, 0 }, 
-  { 0, 7, 0, 0, 1, 0 }, 
-  { 0, 3, 0, 0, 1, 0 }, 
-  { 0, 7, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 1, 0, 1, 1, 0 }, 
-  { 0, 31, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { -7, 7, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 3, 0, 0, 1, 0 }, 
-  { 0, 3, 0, 0, 1, 0 }, 
-  { 0, 7, 0, 0, 1, 0 }, 
-  { 0, 3, 0, 0, 1, 0 }, 
-  { 0, 7, 0, 0, 1, 0 }, 
-  { 0, 99, 1, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 7, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 1, 0, 1, 1, 0 }, 
-  { 0, 31, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { -7, 7, 0, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 39, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 7, 0, 0, 1, 0 }, 
-  { 0, 3, 0, 0, 1, 0 }, 
-  { 0, 7, 0, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 1, 0, 1, 1, 0 }, 
-  { 0, 31, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { -7, 7, 0, 0, 1, 0 }, 
-  { 0, 99, 39, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 3, 0, 0, 1, 0 }, 
-  { 0, 3, 0, 0, 1, 0 }, 
-  { 0, 7, 0, 0, 1, 0 }, 
-  { 0, 3, 0, 0, 1, 0 }, 
-  { 0, 7, 0, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 99, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 1, 0, 1, 1, 0 }, 
-  { 0, 31, 1, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { -7, 7, 7, 0, 1, 0 }, 
-  { 0, 99, 39, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 99, 0, 0, 1, 0 }, 
-  { 0, 3, 0, 0, 1, 0 }, 
-  { 0, 3, 0, 0, 1, 0 }, 
-  { 0, 7, 0, 0, 1, 0 }, 
-  { 0, 3, 0, 0, 1, 0 }, 
-  { 0, 7, 0, 0, 1, 0 }, 
-};
-
-
-#endif /* dexed_ttl_h */

src/dexed.cpp

@@ -1,8 +1,7 @@
 // from: http://ll-plugins.nongnu.org/lv2pftci/#A_synth
 
 #include <lvtk/synth.hpp>
-#include <string.h>
+#include "dexed.peg"
-#include "dexed-ttl.h"
 #include "dexed.h"
 #include "EngineMkI.h"
 #include "EngineOpl.h"
@@ -11,8 +10,10 @@
 #include "msfa/freqlut.h"
 #include "msfa/controllers.h"
 #include "msfa/ringbuffer.h"
+#include "PluginFx.h"
+#include <string.h>
 
-Dexed::Dexed(double rate) : lvtk::Synth<DexedVoice, Dexed>(p_n_ports, p_lv2_events_in)
+Dexed::Dexed(double rate) : lvtk::Synth<DexedVoice, Dexed>(p_n_ports, p_midi_in)
 {
   TRACE("Hi");
 
@@ -58,7 +59,7 @@ Dexed::Dexed(double rate) : lvtk::Synth<DexedVoice, Dexed>(p_n_ports, p_lv2_even
 
   add_voices(new DexedVoice(rate));
 
-  add_audio_outputs(p_lv2_audio_out_1);
+  add_audio_outputs(p_audio_out);
 }
 
 Dexed::~Dexed()
@@ -67,9 +68,499 @@ Dexed::~Dexed()
 
   delete [] outbuf16_;
 
+  currentNote = -1;
+
+  for (int note = 0; note < MAX_ACTIVE_NOTES; ++note) {
+    if ( voices[note].dx7_note != NULL ) {
+      delete voices[note].dx7_note;
+      voices[note].dx7_note = NULL;
+    } 
+    voices[note].keydown = false;
+    voices[note].sustained = false;
+    voices[note].live = false;
+  }
+
   TRACE("Bye");
 }
 
+void Dexed::set_params(void)
+{
+  TRACE("Hi");
+
+  // OP6
+  onParam(0,static_cast<char>(*p(p_op6_eg_rate_1)));
+  onParam(1,static_cast<char>(*p(p_op6_eg_rate_2)));
+  onParam(2,static_cast<char>(*p(p_op6_eg_rate_3)));
+  onParam(3,static_cast<char>(*p(p_op6_eg_rate_4)));
+  onParam(4,static_cast<char>(*p(p_op6_eg_level_1)));
+  onParam(5,static_cast<char>(*p(p_op6_eg_level_2)));
+  onParam(6,static_cast<char>(*p(p_op6_eg_level_3)));
+  onParam(7,static_cast<char>(*p(p_op6_eg_level_4)));
+  onParam(8,static_cast<char>(*p(p_op6_kbd_lev_scl_brk_pt)));
+  onParam(9,static_cast<char>(*p(p_op6_kbd_lev_scl_lft_depth)));
+  onParam(10,static_cast<char>(*p(p_op6_kbd_lev_scl_rht_depth)));
+  onParam(11,static_cast<char>(*p(p_op6_kbd_lev_scl_lft_curve)));
+  onParam(12,static_cast<char>(*p(p_op6_kbd_lev_scl_rht_curve)));
+  onParam(13,static_cast<char>(*p(p_op6_kbd_rate_scaling)));
+  onParam(14,static_cast<char>(*p(p_op6_amp_mod_sensitivity)));
+  onParam(15,static_cast<char>(*p(p_op6_key_vel_sensitivity)));
+  onParam(16,static_cast<char>(*p(p_op6_operator_output_level)));
+  onParam(17,static_cast<char>(*p(p_op6_osc_mode)));
+  onParam(18,static_cast<char>(*p(p_op6_osc_freq_coarse)));
+  onParam(19,static_cast<char>(*p(p_op6_osc_freq_fine)));
+  onParam(20,static_cast<char>(*p(p_op6_osc_detune)+7));
+  // OP5
+  onParam(21,static_cast<char>(*p(p_op5_eg_rate_1)));
+  onParam(22,static_cast<char>(*p(p_op5_eg_rate_2)));
+  onParam(23,static_cast<char>(*p(p_op5_eg_rate_3)));
+  onParam(24,static_cast<char>(*p(p_op5_eg_rate_4)));
+  onParam(25,static_cast<char>(*p(p_op5_eg_level_1)));
+  onParam(26,static_cast<char>(*p(p_op5_eg_level_2)));
+  onParam(27,static_cast<char>(*p(p_op5_eg_level_3)));
+  onParam(28,static_cast<char>(*p(p_op5_eg_level_4)));
+  onParam(29,static_cast<char>(*p(p_op5_kbd_lev_scl_brk_pt)));
+  onParam(30,static_cast<char>(*p(p_op5_kbd_lev_scl_lft_depth)));
+  onParam(31,static_cast<char>(*p(p_op5_kbd_lev_scl_rht_depth)));
+  onParam(32,static_cast<char>(*p(p_op5_kbd_lev_scl_lft_curve)));
+  onParam(33,static_cast<char>(*p(p_op5_kbd_lev_scl_rht_curve)));
+  onParam(34,static_cast<char>(*p(p_op5_kbd_rate_scaling)));
+  onParam(35,static_cast<char>(*p(p_op5_amp_mod_sensitivity)));
+  onParam(36,static_cast<char>(*p(p_op5_key_vel_sensitivity)));
+  onParam(37,static_cast<char>(*p(p_op5_operator_output_level)));
+  onParam(38,static_cast<char>(*p(p_op5_osc_mode)));
+  onParam(39,static_cast<char>(*p(p_op5_osc_freq_coarse)));
+  onParam(40,static_cast<char>(*p(p_op5_osc_freq_fine)));
+  onParam(41,static_cast<char>(*p(p_op5_osc_detune)+7));
+  // OP4
+  onParam(42,static_cast<char>(*p(p_op4_eg_rate_1)));
+  onParam(43,static_cast<char>(*p(p_op4_eg_rate_2)));
+  onParam(44,static_cast<char>(*p(p_op4_eg_rate_3)));
+  onParam(45,static_cast<char>(*p(p_op4_eg_rate_4)));
+  onParam(46,static_cast<char>(*p(p_op4_eg_level_1)));
+  onParam(47,static_cast<char>(*p(p_op4_eg_level_2)));
+  onParam(48,static_cast<char>(*p(p_op4_eg_level_3)));
+  onParam(49,static_cast<char>(*p(p_op4_eg_level_4)));
+  onParam(50,static_cast<char>(*p(p_op4_kbd_lev_scl_brk_pt)));
+  onParam(51,static_cast<char>(*p(p_op4_kbd_lev_scl_lft_depth)));
+  onParam(52,static_cast<char>(*p(p_op4_kbd_lev_scl_rht_depth)));
+  onParam(53,static_cast<char>(*p(p_op4_kbd_lev_scl_lft_curve)));
+  onParam(54,static_cast<char>(*p(p_op4_kbd_lev_scl_rht_curve)));
+  onParam(55,static_cast<char>(*p(p_op4_kbd_rate_scaling)));
+  onParam(56,static_cast<char>(*p(p_op4_amp_mod_sensitivity)));
+  onParam(57,static_cast<char>(*p(p_op4_key_vel_sensitivity)));
+  onParam(58,static_cast<char>(*p(p_op4_operator_output_level)));
+  onParam(59,static_cast<char>(*p(p_op4_osc_mode)));
+  onParam(60,static_cast<char>(*p(p_op4_osc_freq_coarse)));
+  onParam(61,static_cast<char>(*p(p_op4_osc_freq_fine)));
+  onParam(62,static_cast<char>(*p(p_op4_osc_detune)+7));
+  // OP3
+  onParam(63,static_cast<char>(*p(p_op3_eg_rate_1)));
+  onParam(64,static_cast<char>(*p(p_op3_eg_rate_2)));
+  onParam(65,static_cast<char>(*p(p_op3_eg_rate_3)));
+  onParam(66,static_cast<char>(*p(p_op3_eg_rate_4)));
+  onParam(67,static_cast<char>(*p(p_op3_eg_level_1)));
+  onParam(68,static_cast<char>(*p(p_op3_eg_level_2)));
+  onParam(69,static_cast<char>(*p(p_op3_eg_level_3)));
+  onParam(70,static_cast<char>(*p(p_op3_eg_level_4)));
+  onParam(71,static_cast<char>(*p(p_op3_kbd_lev_scl_brk_pt)));
+  onParam(72,static_cast<char>(*p(p_op3_kbd_lev_scl_lft_depth)));
+  onParam(73,static_cast<char>(*p(p_op3_kbd_lev_scl_rht_depth)));
+  onParam(74,static_cast<char>(*p(p_op3_kbd_lev_scl_lft_curve)));
+  onParam(75,static_cast<char>(*p(p_op3_kbd_lev_scl_rht_curve)));
+  onParam(76,static_cast<char>(*p(p_op3_kbd_rate_scaling)));
+  onParam(77,static_cast<char>(*p(p_op3_amp_mod_sensitivity)));
+  onParam(78,static_cast<char>(*p(p_op3_key_vel_sensitivity)));
+  onParam(79,static_cast<char>(*p(p_op3_operator_output_level)));
+  onParam(80,static_cast<char>(*p(p_op3_osc_mode)));
+  onParam(81,static_cast<char>(*p(p_op3_osc_freq_coarse)));
+  onParam(82,static_cast<char>(*p(p_op3_osc_freq_fine)));
+  onParam(83,static_cast<char>(*p(p_op3_osc_detune)+7));
+  // OP2
+  onParam(84,static_cast<char>(*p(p_op2_eg_rate_1)));
+  onParam(85,static_cast<char>(*p(p_op2_eg_rate_2)));
+  onParam(86,static_cast<char>(*p(p_op2_eg_rate_3)));
+  onParam(87,static_cast<char>(*p(p_op2_eg_rate_4)));
+  onParam(88,static_cast<char>(*p(p_op2_eg_level_1)));
+  onParam(89,static_cast<char>(*p(p_op2_eg_level_2)));
+  onParam(90,static_cast<char>(*p(p_op2_eg_level_3)));
+  onParam(91,static_cast<char>(*p(p_op2_eg_level_4)));
+  onParam(92,static_cast<char>(*p(p_op2_kbd_lev_scl_brk_pt)));
+  onParam(93,static_cast<char>(*p(p_op2_kbd_lev_scl_lft_depth)));
+  onParam(94,static_cast<char>(*p(p_op2_kbd_lev_scl_rht_depth)));
+  onParam(95,static_cast<char>(*p(p_op2_kbd_lev_scl_lft_curve)));
+  onParam(96,static_cast<char>(*p(p_op2_kbd_lev_scl_rht_curve)));
+  onParam(97,static_cast<char>(*p(p_op2_kbd_rate_scaling)));
+  onParam(98,static_cast<char>(*p(p_op2_amp_mod_sensitivity)));
+  onParam(99,static_cast<char>(*p(p_op2_key_vel_sensitivity)));
+  onParam(100,static_cast<char>(*p(p_op2_operator_output_level)));
+  onParam(101,static_cast<char>(*p(p_op2_osc_mode)));
+  onParam(102,static_cast<char>(*p(p_op2_osc_freq_coarse)));
+  onParam(103,static_cast<char>(*p(p_op2_osc_freq_fine)));
+  onParam(104,static_cast<char>(*p(p_op2_osc_detune)+7));
+  // OP1
+  onParam(105,static_cast<char>(*p(p_op1_eg_rate_1)));
+  onParam(106,static_cast<char>(*p(p_op1_eg_rate_2)));
+  onParam(107,static_cast<char>(*p(p_op1_eg_rate_3)));
+  onParam(108,static_cast<char>(*p(p_op1_eg_rate_4)));
+  onParam(109,static_cast<char>(*p(p_op1_eg_level_1)));
+  onParam(110,static_cast<char>(*p(p_op1_eg_level_2)));
+  onParam(111,static_cast<char>(*p(p_op1_eg_level_3)));
+  onParam(112,static_cast<char>(*p(p_op1_eg_level_4)));
+  onParam(113,static_cast<char>(*p(p_op1_kbd_lev_scl_brk_pt)));
+  onParam(114,static_cast<char>(*p(p_op1_kbd_lev_scl_lft_depth)));
+  onParam(115,static_cast<char>(*p(p_op1_kbd_lev_scl_rht_depth)));
+  onParam(116,static_cast<char>(*p(p_op1_kbd_lev_scl_lft_curve)));
+  onParam(117,static_cast<char>(*p(p_op1_kbd_lev_scl_rht_curve)));
+  onParam(118,static_cast<char>(*p(p_op1_kbd_rate_scaling)));
+  onParam(119,static_cast<char>(*p(p_op1_amp_mod_sensitivity)));
+  onParam(120,static_cast<char>(*p(p_op1_key_vel_sensitivity)));
+  onParam(121,static_cast<char>(*p(p_op1_operator_output_level)));
+  onParam(122,static_cast<char>(*p(p_op1_osc_mode)));
+  onParam(123,static_cast<char>(*p(p_op1_osc_freq_coarse)));
+  onParam(124,static_cast<char>(*p(p_op1_osc_freq_fine)));
+  onParam(125,static_cast<char>(*p(p_op1_osc_detune)+7));
+  // Global for all OPs
+  onParam(126,static_cast<char>(*p(p_pitch_eg_rate_1)));
+  onParam(127,static_cast<char>(*p(p_pitch_eg_rate_2)));
+  onParam(128,static_cast<char>(*p(p_pitch_eg_rate_3)));
+  onParam(129,static_cast<char>(*p(p_pitch_eg_rate_4)));
+  onParam(130,static_cast<char>(*p(p_pitch_eg_level_1)));
+  onParam(131,static_cast<char>(*p(p_pitch_eg_level_2)));
+  onParam(132,static_cast<char>(*p(p_pitch_eg_level_3)));
+  onParam(133,static_cast<char>(*p(p_pitch_eg_level_4)));
+  onParam(134,static_cast<char>(*p(p_algorithm_num)-1));
+  onParam(135,static_cast<char>(*p(p_feedback)));
+  onParam(136,static_cast<char>(*p(p_oscillator_sync)));
+  onParam(137,static_cast<char>(*p(p_lfo_speed)));
+  onParam(138,static_cast<char>(*p(p_lfo_delay)));
+  onParam(139,static_cast<char>(*p(p_lfo_pitch_mod_depth)));
+  onParam(140,static_cast<char>(*p(p_lfo_amp_mod_depth)));
+  onParam(141,static_cast<char>(*p(p_lfo_sync)));
+  onParam(142,static_cast<char>(*p(p_lfo_waveform)));
+  onParam(143,static_cast<char>(*p(p_pitch_mod_sensitivity)));
+  onParam(144,static_cast<char>(*p(p_transpose)));
+  // 10 bytes (145-154) are the name of the patch
+  onParam(155,0x3f); // operator on/off => All OPs on
+
+  TRACE("Bye");
+}
+
+// override the run() method
+void Dexed::run (uint32_t sample_count)
+{
+    const LV2_Atom_Sequence* seq = p<LV2_Atom_Sequence> (p_midi_in);
+    float* output = p(p_audio_out);
+    uint32_t last_frame = 0, num_this_time = 0;
+    float level=*p(p_output)*scaler;
+
+    set_params(); // pre_process: copy actual voice params
+
+    for (LV2_Atom_Event* ev = lv2_atom_sequence_begin (&seq->body);
+         !lv2_atom_sequence_is_end(&seq->body, seq->atom.size, ev);
+         ev = lv2_atom_sequence_next (ev))
+    {
+       num_this_time = ev->time.frames - last_frame;
+
+       // If it's midi, send it to the engine
+       if (ev->body.type == m_midi_type)
+          ring_buffer_.Write ((uint8_t*) LV2_ATOM_BODY (&ev->body), ev->body.size);
+
+       // render audio from the last frame until the timestamp of this event
+       GetSamples (num_this_time, outbuf16_);
+      
+       // i is the index of the engine's buf, which always starts at 0 (i think)
+       // j is the index of the plugin's float output buffer which will be the timestamp
+       // of the last processed atom event.
+       for (uint32_t i = 0, j = last_frame; i < num_this_time; ++i, ++j)
+         output[j] = (static_cast<float> (outbuf16_[i])) * level;
+
+       last_frame = ev->time.frames;
+    }
+
+    // render remaining samples if any left
+    if (last_frame < sample_count)
+    {
+       // do the same thing as above except from last frame until the end of
+       // the processing cycles last sample. at this point, all events have
+       // already been handled.
+
+       num_this_time = sample_count - last_frame;
+       GetSamples (num_this_time, outbuf16_);
+       for (uint32_t i = 0, j = last_frame; i < num_this_time; ++i, ++j)
+         output[j] = (static_cast<float> (outbuf16_[i])) * level;
+    }
+    
+    fx.process(output, sample_count);
+}
+
+void Dexed::GetSamples(int n_samples, int16_t *buffer)
+{
+    int i;
+    size_t input_offset;
+
+    TransferInput();
+    for (input_offset = 0; input_offset < input_buffer_index_; ) {
+      int bytes_available = input_buffer_index_ - input_offset;
+      int bytes_consumed = ProcessMidiMessage(input_buffer_ + input_offset, bytes_available);
+      if (bytes_consumed == 0) {
+        break;
+      }
+      input_offset += bytes_consumed;
+    }
+    ConsumeInput(input_offset);
+   
+    if ( refreshVoice ) {
+        for(i=0;i < MAX_ACTIVE_NOTES;i++) {
+            if ( voices[i].live )
+                voices[i].dx7_note->update(data, voices[i].midi_note, feedback_bitdepth);
+        }
+        lfo.reset(data + 137);
+        refreshVoice = false;
+    }
+
+    // flush first events
+    for (i=0; i < n_samples && i < extra_buf_size_; i++) {
+        buffer[i] = extra_buf_[i];
+    }
+    
+    // remaining buffer is still to be processed
+    if (extra_buf_size_ > n_samples) {
+        for (int j = 0; j < extra_buf_size_ - n_samples; j++) {
+            extra_buf_[j] = extra_buf_[j + n_samples];
+        }
+        extra_buf_size_ -= n_samples;
+        
+        // flush the events, they will be process in the next cycle
+        //while(getNextEvent(&it, n_samples)) {
+        //    processMidiMessage(midiMsg);
+       // }
+    } else {
+        for (; i < n_samples; i += N) {
+            AlignedBuf<int32_t, N> audiobuf;
+            float sumbuf[N];
+            
+            //while(getNextEvent(&it, i)) {
+            //    processMidiMessage(midiMsg);
+            //}
+            
+            for (int j = 0; j < N; ++j) {
+                audiobuf.get()[j] = 0;
+                sumbuf[j] = 0;
+            }
+            int32_t lfovalue = lfo.getsample();
+            int32_t lfodelay = lfo.getdelay();
+            
+            for (int note = 0; note < MAX_ACTIVE_NOTES; ++note) {
+                if (voices[note].live) {
+                    voices[note].dx7_note->compute(audiobuf.get(), lfovalue, lfodelay, &controllers);
+                    
+                    for (int j=0; j < N; ++j) {
+                        int32_t val = audiobuf.get()[j];
+                        
+                        val = val >> 4;
+                        int clip_val = val < -(1 << 24) ? 0x8000 : val >= (1 << 24) ? 0x7fff : val >> 9;
+                        float f = ((float) clip_val) / (float) 0x8000;
+                        if( f > 1 ) f = 1;
+                        if( f < -1 ) f = -1;
+                        sumbuf[j] += f;
+                        audiobuf.get()[j] = 0;
+                    }
+                }
+            }
+            
+            int jmax = n_samples - i;
+            for (int j = 0; j < N; ++j) {
+                if (j < jmax) {
+                    buffer[i + j] = sumbuf[j];
+                } else {
+                    extra_buf_[j - jmax] = sumbuf[j];
+                }
+            }
+        }
+        extra_buf_size_ = i - n_samples;
+    }
+}
+
+//void Dexed::processMidiMessage(const MidiMessage *msg) {
+int Dexed::ProcessMidiMessage(const uint8_t *buf, int buf_size) {
+    uint8_t cmd = buf[0];
+
+    switch(cmd & 0xf0) {
+        case 0x80 :
+            keyup(buf[1]);
+        return(3);
+
+        case 0x90 :
+            keydown(buf[1], buf[2]);
+        return(3);
+            
+        case 0xb0 : {
+            int ctrl = buf[1];
+            int value = buf[2];
+            
+            switch(ctrl) {
+                case 1:
+                    controllers.modwheel_cc = value;
+                    controllers.refresh();
+                    break;
+                case 2:
+                    controllers.breath_cc = value;
+                    controllers.refresh();
+                    break;
+                case 4:
+                    controllers.foot_cc = value;
+                    controllers.refresh();
+                    break;
+                case 64:
+                    sustain = value > 63;
+                    if (!sustain) {
+                        for (int note = 0; note < MAX_ACTIVE_NOTES; note++) {
+                            if (voices[note].sustained && !voices[note].keydown) {
+                                voices[note].dx7_note->keyup();
+                                voices[note].sustained = false;
+                            }
+                        }
+                    }
+                    break;
+            }
+        }
+        return(3);
+
+        case 0xc0 :
+            //setCurrentProgram(buf[1]);
+        return(3);
+            
+        // aftertouch
+        case 0xd0 :
+            controllers.aftertouch_cc = buf[1];
+            controllers.refresh();
+        return(3);
+            
+    }
+
+    switch (cmd) {
+        case 0xe0 :
+            controllers.values_[kControllerPitch] = buf[1] | (buf[2] << 7);
+            return(3);
+        break;
+    }
+    return(3);
+}
+
+void Dexed::TransferInput() {
+  size_t bytes_available = ring_buffer_.BytesAvailable();
+  int bytes_to_read = min(bytes_available,
+      sizeof(input_buffer_) - input_buffer_index_);
+  if (bytes_to_read > 0) {
+    ring_buffer_.Read(bytes_to_read, input_buffer_ + input_buffer_index_);
+    input_buffer_index_ += bytes_to_read;
+  }
+}
+
+void Dexed::ConsumeInput(size_t n_input_bytes) {
+  if (n_input_bytes < input_buffer_index_) {
+    memmove(input_buffer_, input_buffer_ + n_input_bytes,
+        input_buffer_index_ - n_input_bytes);
+  }
+  input_buffer_index_ -= n_input_bytes;
+}
+
+void Dexed::keydown(uint8_t pitch, uint8_t velo) {
+    if ( velo == 0 ) {
+        keyup(pitch);
+        return;
+    }
+
+    pitch += data[144] - 24;
+    
+    if ( normalizeDxVelocity ) {
+        velo = ((float)velo) * 0.7874015; // 100/127
+    }
+    
+    int note = currentNote;
+    for (int i=0; i<MAX_ACTIVE_NOTES; i++) {
+        if (!voices[note].keydown) {
+            currentNote = (note + 1) % MAX_ACTIVE_NOTES;
+            lfo.keydown();  // TODO: should only do this if # keys down was 0
+            voices[note].midi_note = pitch;
+            voices[note].sustained = sustain;
+            voices[note].keydown = true;
+            voices[note].dx7_note->init(data, pitch, velo, feedback_bitdepth);
+            if ( data[136] )
+                voices[note].dx7_note->oscSync();
+            break;
+        }
+        note = (note + 1) % MAX_ACTIVE_NOTES;
+    }
+    
+    if ( monoMode ) {
+        for(int i=0; i<MAX_ACTIVE_NOTES; i++) {            
+            if ( voices[i].live ) {
+                // all keys are up, only transfert signal
+                if ( ! voices[i].keydown ) {
+                    voices[i].live = false;
+                    voices[note].dx7_note->transferSignal(*voices[i].dx7_note);
+                    break;
+                }
+                if ( voices[i].midi_note < pitch ) {
+                    voices[i].live = false;
+                    voices[note].dx7_note->transferState(*voices[i].dx7_note);
+                    break;
+                }
+                return;
+            }
+        }
+    }
+ 
+    voices[note].live = true;
+}
+
+void Dexed::keyup(uint8_t pitch) {
+    pitch += data[144] - 24;
+
+    int note;
+    for (note=0; note<MAX_ACTIVE_NOTES; ++note) {
+        if ( voices[note].midi_note == pitch && voices[note].keydown ) {
+            voices[note].keydown = false;
+            break;
+        }
+    }
+    
+    // note not found ?
+    if ( note >= MAX_ACTIVE_NOTES ) {
+        TRACE("note-off not found???");
+        return;
+    }
+    
+    if ( monoMode ) {
+        int highNote = -1;
+        int target = 0;
+        for (int i=0; i<MAX_ACTIVE_NOTES;i++) {
+            if ( voices[i].keydown && voices[i].midi_note > highNote ) {
+                target = i;
+                highNote = voices[i].midi_note;
+            }
+        }
+        
+        if ( highNote != -1 ) {
+            voices[note].live = false;
+            voices[target].live = true;
+            voices[target].dx7_note->transferState(*voices[note].dx7_note);
+        }
+    }
+    
+    if ( sustain ) {
+        voices[note].sustained = true;
+    } else {
+        voices[note].dx7_note->keyup();
+    }
+}
+
+void Dexed::onParam(int param_num,int param_val)
+{
+	data[param_num]=param_val;
+}
+
 //==============================================================================
 
 DexedVoice::DexedVoice(double rate) : m_key(lvtk::INVALID_KEY), m_rate(rate)

src/dexed.h

@@ -30,6 +30,7 @@
 #include "PluginFx.h"
 #include "EngineMkI.h"
 #include "EngineOpl.h"
+#include "dexed.peg"
 
 struct ProcessorVoice {
     int midi_note;
@@ -51,6 +52,10 @@ enum DexedEngineResolution {
     #define TRACE(fmt, ...)
 #endif
 
+// GLOBALS
+//static const float scaler = 0.00003051757813;
+static const float scaler = 0.00003;
+
 //==============================================================================
 
 class DexedVoice : public lvtk::Voice
@@ -65,6 +70,8 @@ class DexedVoice : public lvtk::Voice
   protected:
     unsigned char m_key;
     double m_rate;
+
+  private:
 };
 
 //==============================================================================
@@ -74,17 +81,26 @@ class Dexed : public lvtk::Synth<DexedVoice, Dexed>
   public:
     Dexed(double rate);
     ~Dexed();
+    void run(uint32_t sample_count);
     int getEngineType();
     void setEngineType(int rs);
-    bool isMonoMode();
+    void set_params(void);
-    void setMonoMode(bool mode);
+    void GetSamples(int n_samples, int16_t *buffer);
-    void setParameter (int index, int newValue);
+    //bool isMonoMode();
+    //void setMonoMode(bool mode);
 
     uint8_t data[161];
     Controllers controllers;
     VoiceStatus voiceStatus;
 
   protected:
+    int ProcessMidiMessage(const uint8_t *buf, int buf_size);
+    void onParam(int param_num,int param_val);
+    void TransferInput();
+    void ConsumeInput(size_t n_input_bytes);
+    void keyup(uint8_t pitch);
+    void keydown(uint8_t pitch, uint8_t velo);
+
     static const int MAX_ACTIVE_NOTES = 16;
     ProcessorVoice voices[MAX_ACTIVE_NOTES];
     int currentNote;
@@ -100,13 +116,15 @@ class Dexed : public lvtk::Synth<DexedVoice, Dexed>
     FmCore engineMsfa;
     EngineMkI engineMkI;
     EngineOpl engineOpl;
+    RingBuffer ring_buffer_;
     int16_t* outbuf16_;
     uint32_t bufsize_;
-};
+    int16_t extra_buf_[N];
+    int extra_buf_size_;
+    uint8_t input_buffer_[8192];
+    size_t input_buffer_index_;
 
-// GLOBALS
+  private:
-RingBuffer ring_buffer_;
+};
-//static const float scaler = 0.00003051757813;
-static const float scaler = 0.00003;
 
 #endif  // PLUGINPROCESSOR_H_INCLUDED