wirtz
/
dexed
mirror of https://github.com/dcoredump/dexed.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Compiles... but works?

Browse Source
pull/1/head
Holger Wirtz 8 years ago
parent fe88998c12
commit 87e158540c
7 changed files with 2398 additions and 711 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 689
      src/Dexed.ttl
  2. 1531
      src/Dexed.ttl.O
  3. 10
      src/Makefile
  4. 7
      src/PluginFx.cpp
  5. 333
      src/dexed-ttl.h
  6. 499
      src/dexed.cpp
  7. 34
      src/dexed.h

689
src/Dexed.ttl
View File

File diff suppressed because it is too large Load Diff

1531
src/Dexed.ttl.O
View File

File diff suppressed because it is too large Load Diff

10
src/Makefile
Unescape View File

@ -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
ttl2c Dexed.ttl dexed-ttl.h
dexed.peg: Dexed.ttl
lv2peg Dexed.ttl dexed.peg

7
src/PluginFx.cpp
Unescape View File

@ -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) {
return (param) * (max - min) + min;
}
//static float linsc(float param,const float min,const float max) {
// 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;

333
src/dexed-ttl.h
Unescape View File

@ -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 */

499
src/dexed.cpp
Unescape View File

@ -1,8 +1,7 @@
// from: http://ll-plugins.nongnu.org/lv2pftci/#A_synth
#include <lvtk/synth.hpp>
#include <string.h>
#include "dexed-ttl.h"
#include "dexed.peg"
#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)

34
src/dexed.h
Unescape View File

@ -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 setMonoMode(bool mode);
void setParameter (int index, int newValue);
void set_params(void);
void GetSamples(int n_samples, int16_t *buffer);
//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
RingBuffer ring_buffer_;
//static const float scaler = 0.00003051757813;
static const float scaler = 0.00003;
private:
};
#endif // PLUGINPROCESSOR_H_INCLUDED

Write Preview
Loading…
Cancel
Save