rtbuf/rtbuf

diff --git a/rtbuf_cli.c b/rtbuf_cli.c
index 830c01d..aaa8b24 100644
--- a/rtbuf_cli.c
+++ b/rtbuf_cli.c
@@ -81,7 +81,7 @@ int rtbuf_cli_buffers (int argc, const char *argv[])
   printf("Listing %i buffers :\n", n);
   while (i < RTBUF_MAX && n > 0) {
     if (g_rtbuf[i].data) {
-      rtbuf_print(i);
+      rtbuf_print_long(i);
       printf("\n");
       n--;
     }
diff --git a/rtbuf_dynamic.c b/rtbuf_dynamic.c
index 43313fb..aa986b1 100644
--- a/rtbuf_dynamic.c
+++ b/rtbuf_dynamic.c
@@ -21,12 +21,12 @@
 #include "rtbuf_dynamic.h"
 
 s_rtbuf_lib_proc_in g_rtbuf_dynamic_limiter_in[] = {
-  { "signal"  , RTBUF_SIGNAL_TYPE, -1.0, 1.0 },
-  { "gain"    , RTBUF_SIGNAL_TYPE, 0.0, 10.0 },
-  { "treshold", RTBUF_SIGNAL_TYPE, 0.0, 1.0 },
-  { "attack"  , RTBUF_SIGNAL_TYPE, 0.0, 1.0 },
-  { "release" , RTBUF_SIGNAL_TYPE, 0.0, 1.0 },
-  { 0, 0, 0.0, 0.0 } };
+  { "signal"  , RTBUF_SIGNAL_TYPE, 0.0, -1.0, 1.0 },
+  { "gain"    , RTBUF_SIGNAL_TYPE, 1.0, 0.0, 1.0 },
+  { "treshold", RTBUF_SIGNAL_TYPE, 0.9, 0.0, 1.0 },
+  { "attack"  , RTBUF_SIGNAL_TYPE, 0.1, 0.0, 1.0 },
+  { "release" , RTBUF_SIGNAL_TYPE, 1.0, 0.0, 1.0 },
+  { 0, 0, 0.0, 0.0, 0.0 } };
 
 s_rtbuf_lib_proc_out g_rtbuf_dynamic_limiter_out[] = {
   { "signal", RTBUF_SIGNAL_TYPE },
diff --git a/rtbuf_dynamic_limiter.c b/rtbuf_dynamic_limiter.c
index ae937cb..82c5943 100644
--- a/rtbuf_dynamic_limiter.c
+++ b/rtbuf_dynamic_limiter.c
@@ -31,16 +31,11 @@ int rtbuf_dynamic_limiter (s_rtbuf *rtb)
   assert(rtb);
   assert(rtb->proc);
   assert(rtb->data);
-  rtbuf_signal_fun(rtb, RTBUF_DYNAMIC_LIMITER_IN_SIGNAL  , &in_,
-                   &g_rtbuf_signal_sample_zero);
-  rtbuf_signal_fun(rtb, RTBUF_DYNAMIC_LIMITER_IN_GAIN    , &g_,
-                   &g_rtbuf_signal_sample_one);
-  rtbuf_signal_fun(rtb, RTBUF_DYNAMIC_LIMITER_IN_TRESHOLD, &t_,
-                   &g_rtbuf_signal_sample_half);
-  rtbuf_signal_fun(rtb, RTBUF_DYNAMIC_LIMITER_IN_ATTACK  , &a_,
-                   &g_rtbuf_signal_sample_one);
-  rtbuf_signal_fun(rtb, RTBUF_DYNAMIC_LIMITER_IN_RELEASE , &r_,
-                   &g_rtbuf_signal_sample_one);
+  rtbuf_signal_fun(rtb, RTBUF_DYNAMIC_LIMITER_IN_SIGNAL  , &in_);
+  rtbuf_signal_fun(rtb, RTBUF_DYNAMIC_LIMITER_IN_GAIN    , &g_);
+  rtbuf_signal_fun(rtb, RTBUF_DYNAMIC_LIMITER_IN_TRESHOLD, &t_);
+  rtbuf_signal_fun(rtb, RTBUF_DYNAMIC_LIMITER_IN_ATTACK  , &a_);
+  rtbuf_signal_fun(rtb, RTBUF_DYNAMIC_LIMITER_IN_RELEASE , &r_);
   data = (s_rtbuf_dynamic_limiter_data*) rtb->data;
   while (i < RTBUF_SIGNAL_SAMPLES) {
     double in = in_.sample_fun(in_.signal, i);
diff --git a/rtbuf_glfw3.c b/rtbuf_glfw3.c
index a231394..6470431 100644
--- a/rtbuf_glfw3.c
+++ b/rtbuf_glfw3.c
@@ -29,11 +29,11 @@ s_rtbuf_lib_proc_out g_rtbuf_glfw3_keyboard_out[] = {
   { 0, 0 } };
 
 s_rtbuf_lib_proc_in g_rtbuf_glfw3_oscilloscope_in[] = {
-  { "black", RTBUF_SIGNAL_TYPE, -1.0, 1.0 },
-  { "red"  , RTBUF_SIGNAL_TYPE, -1.0, 1.0 },
-  { "green", RTBUF_SIGNAL_TYPE, -1.0, 1.0 },
-  { "blue" , RTBUF_SIGNAL_TYPE, -1.0, 1.0 },
-  { 0, 0, 0.0, 0.0 } };
+  { "black", RTBUF_SIGNAL_TYPE, 0.0, -1.0, 1.0 },
+  { "red"  , RTBUF_SIGNAL_TYPE, 0.0, -1.0, 1.0 },
+  { "green", RTBUF_SIGNAL_TYPE, 0.0, -1.0, 1.0 },
+  { "blue" , RTBUF_SIGNAL_TYPE, 0.0, -1.0, 1.0 },
+  { 0, 0, 0.0, 0.0, 0.0 } };
 
 s_rtbuf_lib_proc_out g_rtbuf_glfw3_oscilloscope_out[] = {
   { "window", "void*" },
diff --git a/rtbuf_glfw3_oscilloscope.c b/rtbuf_glfw3_oscilloscope.c
index 06ebce7..2be4650 100644
--- a/rtbuf_glfw3_oscilloscope.c
+++ b/rtbuf_glfw3_oscilloscope.c
@@ -42,7 +42,7 @@ void rtbuf_glfw3_oscilloscope_draw (GLFWwindow *window)
   unsigned int j;
   assert(rtb);
   for (j = 0; j < 4; j++)
-    rtbuf_signal_fun(rtb, j, &in[j], &g_rtbuf_signal_sample_zero);
+    rtbuf_signal_fun(rtb, j, &in[j]);
   glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
   glClear(GL_COLOR_BUFFER_BIT);
   for (j = 0; j < 4; j++) {
diff --git a/rtbuf_lib.c b/rtbuf_lib.c
index 45ec18f..917aa83 100644
--- a/rtbuf_lib.c
+++ b/rtbuf_lib.c
@@ -205,6 +205,7 @@ void rtbuf_lib_proc_in_init_proc (s_rtbuf_proc *proc,
       s_rtbuf_proc_in *v = &proc->in[i];
       v->name = symbol_intern(in->name);
       v->type = rtbuf_type(in->type);
+      v->def = in->def;
       in++;
       i++;
     }
diff --git a/rtbuf_lib.h b/rtbuf_lib.h
index 5f768d0..bdc25d6 100644
--- a/rtbuf_lib.h
+++ b/rtbuf_lib.h
@@ -24,6 +24,7 @@
 struct rtbuf_lib_proc_in {
   const char *name;
   const char *type;
+  double def;
   double min;
   double max;
 };
diff --git a/rtbuf_music.h b/rtbuf_music.h
index 60db055..ab4732c 100644
--- a/rtbuf_music.h
+++ b/rtbuf_music.h
@@ -35,12 +35,12 @@ typedef struct rtbuf_music_note {
 } s_rtbuf_music_note;
 #pragma pack(pop)
 
-#define RTBUF_MUSIC_NOTE_IN(note)                                 \
-  { note "velocity",  RTBUF_SIGNAL_SAMPLE_TYPE, 0.0, 1.0 },       \
-  { note "frequency", RTBUF_SIGNAL_SAMPLE_TYPE, 0.0,              \
-                  RTBUF_SIGNAL_SAMPLERATE / 2.0 },                \
-  { note "start",     RTBUF_SIGNAL_SAMPLE_TYPE, -1.0, FLT_MAX },  \
-  { note "stop",      RTBUF_SIGNAL_SAMPLE_TYPE, -1.0, FLT_MAX }
+#define RTBUF_MUSIC_NOTE_IN(note)                                       \
+  { note "velocity",  RTBUF_SIGNAL_SAMPLE_TYPE, 1.0, 0.0, 1.0 },        \
+  { note "frequency", RTBUF_SIGNAL_SAMPLE_TYPE, 220.0, 0.0,             \
+                  RTBUF_SIGNAL_SAMPLERATE / 2.0 },                      \
+  { note "start",     RTBUF_SIGNAL_SAMPLE_TYPE, -1.0, -1.0, FLT_MAX },   \
+  { note "stop",      RTBUF_SIGNAL_SAMPLE_TYPE, -1.0, -1.0, FLT_MAX }
           
 #define RTBUF_MUSIC_NOTE_IN_ENUM(note) \
   note ## _VELOCITY , \
diff --git a/rtbuf_music_type.c b/rtbuf_music_type.c
index 02120ff..ee099fd 100644
--- a/rtbuf_music_type.c
+++ b/rtbuf_music_type.c
@@ -9,14 +9,14 @@ void notes_in ()
   const char *st = "RTBUF_SIGNAL_SAMPLE_TYPE";
   printf("\n"
          "#define RTBUF_MUSIC_NOTES_IN(note) \\\n"
-         "  { note \"s\"            , RTBUF_MUSIC_NOTES_TYPE, 0.0, 0.0 }"
+         "  { note \"s\"            , RTBUF_MUSIC_NOTES_TYPE, 0.0, 0.0, 0.0 }"
          ", \\\n");
   while (i < RTBUF_MUSIC_NOTE_MAX) {
-    printf("  { note \"[%u].velocity\" , %s, 0.0, 1.0 }, \\\n", i, st);
-    printf("  { note \"[%u].frequency\", %s, 0.0, "
+    printf("  { note \"[%u].velocity\" , %s, 0.0, 0.0, 1.0 }, \\\n", i, st);
+    printf("  { note \"[%u].frequency\", %s, 0.0, 0.0, "
            "RTBUF_SIGNAL_SAMPLERATE / 2.0 }, \\\n", i, st);
-    printf("  { note \"[%u].start\"    , %s, -1.0, FLT_MAX }, \\\n", i, st);
-    printf("  { note \"[%u].stop\"     , %s, -1.0, FLT_MAX }", i, st);
+    printf("  { note \"[%u].start\"    , %s, -1.0, -1.0, FLT_MAX }, \\\n", i, st);
+    printf("  { note \"[%u].stop\"     , %s, -1.0, -1.0, FLT_MAX }", i, st);
     if (i < RTBUF_MUSIC_NOTE_MAX - 1)
       printf(", \\");
     printf("\n");
diff --git a/rtbuf_proc.h b/rtbuf_proc.h
index d450cc9..22147c4 100644
--- a/rtbuf_proc.h
+++ b/rtbuf_proc.h
@@ -23,6 +23,7 @@
 struct rtbuf_proc_in {
   symbol name;
   s_rtbuf_type *type;
+  double def;
 };
 
 struct rtbuf_proc_out {
diff --git a/rtbuf_signal.c b/rtbuf_signal.c
index d0ab903..225c66f 100644
--- a/rtbuf_signal.c
+++ b/rtbuf_signal.c
@@ -28,10 +28,10 @@ const double g_rtbuf_signal_sample_one        = 1.0;
 const double g_rtbuf_signal_default_frequency = 220.0;
 
 s_rtbuf_lib_proc_in g_rtbuf_signal_delay_in[] = {
-  { "signal", RTBUF_SIGNAL_TYPE, -1.0, 1.0 },
-  { "delay", RTBUF_SIGNAL_TYPE, 0.0, RTBUF_SIGNAL_DELAY_MAX },
-  { "feedback", RTBUF_SIGNAL_TYPE, 0.0, 1.0 },
-  { 0, 0, 0.0, 0.0 } };
+  { "signal",   RTBUF_SIGNAL_TYPE, 0.0, -1.0, 1.0 },
+  { "delay",    RTBUF_SIGNAL_TYPE, 0.4, 0.0, RTBUF_SIGNAL_DELAY_MAX },
+  { "feedback", RTBUF_SIGNAL_TYPE, 0.1, 0.0, 1.0 },
+  { 0, 0, 0.0, 0.0, 0.0 } };
 
 s_rtbuf_lib_proc_out g_rtbuf_signal_delay_out[] = {
   { "wet", RTBUF_SIGNAL_TYPE },
@@ -40,9 +40,9 @@ s_rtbuf_lib_proc_out g_rtbuf_signal_delay_out[] = {
   { 0, 0 } };
 
 s_rtbuf_lib_proc_in g_rtbuf_signal_sinus_in[] = {
-  { "frequency", RTBUF_SIGNAL_TYPE, 0.0, RTBUF_SIGNAL_SAMPLERATE / 2.0 },
-  { "amplitude", RTBUF_SIGNAL_TYPE, 0.0, 1.0 },
-  { 0, 0, 0.0, 0.0 } };
+  { "frequency", RTBUF_SIGNAL_TYPE, 220.0, 0.0, RTBUF_SIGNAL_SAMPLERATE / 2.0 },
+  { "amplitude", RTBUF_SIGNAL_TYPE, 1.0, 0.0, 1.0 },
+  { 0, 0, 0.0, 0.0, 0.0 } };
 
 s_rtbuf_lib_proc_out g_rtbuf_signal_sinus_out[] = {
   { "signal", RTBUF_SIGNAL_TYPE },
@@ -50,10 +50,10 @@ s_rtbuf_lib_proc_out g_rtbuf_signal_sinus_out[] = {
   { 0, 0 } };
 
 s_rtbuf_lib_proc_in g_rtbuf_signal_square_in[] = {
-  { "frequency", RTBUF_SIGNAL_TYPE, 0.0, RTBUF_SIGNAL_SAMPLERATE / 2.0 },
-  { "amplitude", RTBUF_SIGNAL_TYPE, 0.0, 1.0 },
-  { "pulse",     RTBUF_SIGNAL_TYPE, 0.0, 1.0 },
-  { 0, 0, 0.0, 0.0 } };
+  { "frequency", RTBUF_SIGNAL_TYPE, 220.0, 0.0, RTBUF_SIGNAL_SAMPLERATE / 2.0 },
+  { "amplitude", RTBUF_SIGNAL_TYPE, 1.0, 0.0, 1.0 },
+  { "pulse",     RTBUF_SIGNAL_TYPE, 0.5, 0.0, 1.0 },
+  { 0, 0, 0.0, 0.0, 0.0 } };
 
 s_rtbuf_lib_proc_out g_rtbuf_signal_square_out[] = {
   { "signal", RTBUF_SIGNAL_TYPE },
@@ -123,16 +123,16 @@ double rtbuf_signal_sample_from_signal (const double *signal,
 }
 
 void rtbuf_signal_fun (s_rtbuf *rtb,
-                        unsigned int in,
-                        s_rtbuf_signal_fun *rsf,
-                        const double *default_value)
+                       unsigned int in,
+                       s_rtbuf_signal_fun *rsf)
 {
   s_rtbuf_binding *v;
+  const double *default_value;
   assert(rtb);
   assert(rtb->proc);
   assert(in < rtb->proc->in_n);
   assert(rsf);
-  assert(default_value);
+  default_value = &rtb->proc->in[in].def;
   rsf->signal = default_value;
   rsf->sample_fun = rtbuf_signal_sample_from_sample;
   v = &rtb->var[in];
diff --git a/rtbuf_signal.h b/rtbuf_signal.h
index 2a575a5..1e81abc 100644
--- a/rtbuf_signal.h
+++ b/rtbuf_signal.h
@@ -48,8 +48,7 @@ rtbuf_signal_sample (s_rtbuf *rtb,
                      t_rtbuf_signal_sample default_value);
 void rtbuf_signal_fun (s_rtbuf *rtb,
                        unsigned int in,
-                       s_rtbuf_signal_fun *data,
-                       const t_rtbuf_signal_sample *default_value);
+                       s_rtbuf_signal_fun *data);
 
 f_rtbuf_signal rtbuf_signal_sample_from_sample;
 f_rtbuf_signal rtbuf_signal_sample_from_signal;
diff --git a/rtbuf_signal_delay.c b/rtbuf_signal_delay.c
index 7a73753..73f2e02 100644
--- a/rtbuf_signal_delay.c
+++ b/rtbuf_signal_delay.c
@@ -34,10 +34,8 @@ int rtbuf_signal_delay (s_rtbuf *rtb)
   s_rtbuf_signal_fun delay;
   s_rtbuf_signal_delay_data *data;
   unsigned int i = 0;
-  rtbuf_signal_fun(rtb, RTBUF_SIGNAL_DELAY_IN_SIGNAL, &in,
-                   &g_rtbuf_signal_sample_zero);
-  rtbuf_signal_fun(rtb, RTBUF_SIGNAL_DELAY_IN_DELAY, &delay,
-                   &g_rtbuf_signal_sample_one);
+  rtbuf_signal_fun(rtb, RTBUF_SIGNAL_DELAY_IN_SIGNAL, &in);
+  rtbuf_signal_fun(rtb, RTBUF_SIGNAL_DELAY_IN_DELAY, &delay);
   data = (s_rtbuf_signal_delay_data*) rtb->data;
   while (i < RTBUF_SIGNAL_SAMPLES) {
     double s = in.sample_fun(in.signal, i);
diff --git a/rtbuf_signal_sinus.c b/rtbuf_signal_sinus.c
index 24ca779..3c2934c 100644
--- a/rtbuf_signal_sinus.c
+++ b/rtbuf_signal_sinus.c
@@ -26,10 +26,8 @@ int rtbuf_signal_sinus (s_rtbuf *rtb)
   s_rtbuf_signal_fun amp;
   s_rtbuf_signal_sinus_data *data;
   unsigned int i = 0;
-  rtbuf_signal_fun(rtb, RTBUF_SIGNAL_SINUS_IN_FREQUENCY, &freq,
-                   &g_rtbuf_signal_default_frequency);
-  rtbuf_signal_fun(rtb, RTBUF_SIGNAL_SINUS_IN_AMPLITUDE, &amp,
-                   &g_rtbuf_signal_sample_one);
+  rtbuf_signal_fun(rtb, RTBUF_SIGNAL_SINUS_IN_FREQUENCY, &freq);
+  rtbuf_signal_fun(rtb, RTBUF_SIGNAL_SINUS_IN_AMPLITUDE, &amp);
   data = (s_rtbuf_signal_sinus_data*) rtb->data;
   while (i < RTBUF_SIGNAL_SAMPLES) {
     double f = freq.sample_fun(freq.signal, i);
diff --git a/rtbuf_signal_square.c b/rtbuf_signal_square.c
index 21a01b6..fb9cc73 100644
--- a/rtbuf_signal_square.c
+++ b/rtbuf_signal_square.c
@@ -32,12 +32,9 @@ int rtbuf_signal_square (s_rtbuf *rtb)
   s_rtbuf_signal_fun pulse;
   s_rtbuf_signal_square_data *data;
   unsigned int i = 0;
-  rtbuf_signal_fun(rtb, RTBUF_SIGNAL_SQUARE_IN_FREQUENCY, &freq,
-                   &g_rtbuf_signal_default_frequency);
-  rtbuf_signal_fun(rtb, RTBUF_SIGNAL_SQUARE_IN_AMPLITUDE, &amp,
-                   &g_rtbuf_signal_sample_one);
-  rtbuf_signal_fun(rtb, RTBUF_SIGNAL_SQUARE_IN_PULSE, &pulse,
-                   &g_rtbuf_signal_sample_half);
+  rtbuf_signal_fun(rtb, RTBUF_SIGNAL_SQUARE_IN_FREQUENCY, &freq);
+  rtbuf_signal_fun(rtb, RTBUF_SIGNAL_SQUARE_IN_AMPLITUDE, &amp);
+  rtbuf_signal_fun(rtb, RTBUF_SIGNAL_SQUARE_IN_PULSE, &pulse);
   data = (s_rtbuf_signal_square_data*) rtb->data;
   while (i < RTBUF_SIGNAL_SAMPLES) {
     double f = freq.sample_fun(freq.signal, i);
diff --git a/rtbuf_sndio.c b/rtbuf_sndio.c
index 15295d5..be4ce7d 100644
--- a/rtbuf_sndio.c
+++ b/rtbuf_sndio.c
@@ -31,9 +31,9 @@ s_rtbuf_lib_proc_out g_rtbuf_sndio_input_out[] = {
   { 0, 0 } };
 
 s_rtbuf_lib_proc_in g_rtbuf_sndio_output_in[] = {
-  { "left", RTBUF_SIGNAL_TYPE, -1.0, 1.0 },
-  { "right", RTBUF_SIGNAL_TYPE, -1.0, 1.0 },
-  { 0, 0, 0.0, 0.0 } };
+  { "left",  RTBUF_SIGNAL_TYPE, 0.0, -1.0, 1.0 },
+  { "right", RTBUF_SIGNAL_TYPE, 0.0, -1.0, 1.0 },
+  { 0, 0, 0.0, 0.0, 0.0 } };
 
 s_rtbuf_lib_proc_out g_rtbuf_sndio_output_out[] = {
   { "samples", RTBUF_SNDIO_SAMPLES_TYPE },
diff --git a/rtbuf_sndio_output.c b/rtbuf_sndio_output.c
index 1a669cf..a4ba564 100644
--- a/rtbuf_sndio_output.c
+++ b/rtbuf_sndio_output.c
@@ -97,7 +97,7 @@ int rtbuf_sndio_output (s_rtbuf *rtb)
   assert(rtb->data);
   assert(rtb->proc);
   while (j < RTBUF_SNDIO_CHANNELS) {
-    rtbuf_signal_fun(rtb, j, &in[j], &g_rtbuf_signal_sample_zero);
+    rtbuf_signal_fun(rtb, j, &in[j]);
     j++;
   }
   data = (s_rtbuf_sndio_output_data*) rtb->data;
diff --git a/rtbuf_synth.c b/rtbuf_synth.c
index b89f7c7..8fd9cef 100644
--- a/rtbuf_synth.c
+++ b/rtbuf_synth.c
@@ -26,11 +26,11 @@
 
 s_rtbuf_lib_proc_in g_rtbuf_synth_adsr_in[] = {
   RTBUF_MUSIC_NOTE_IN(),
-  { "attack",  RTBUF_SIGNAL_TYPE, 0.0, 2.0 },
-  { "decay",   RTBUF_SIGNAL_TYPE, 0.0, 2.0 },
-  { "sustain", RTBUF_SIGNAL_TYPE, 0.0, 1.0 },
-  { "release", RTBUF_SIGNAL_TYPE, 0.0, 10.0 },
-  { 0, 0, 0.0, 0.0 } };
+  { "attack",  RTBUF_SIGNAL_TYPE, 0.02, 0.0,  2.0 },
+  { "decay",   RTBUF_SIGNAL_TYPE, 0.01, 0.0,  2.0 },
+  { "sustain", RTBUF_SIGNAL_TYPE, 0.4,  0.0,  1.0 },
+  { "release", RTBUF_SIGNAL_TYPE, 0.3,  0.0, 10.0 },
+  { 0, 0, 0.0, 0.0, 0.0 } };
 
 s_rtbuf_lib_proc_out g_rtbuf_synth_adsr_out[] = {
   { "signal", RTBUF_SIGNAL_TYPE },
@@ -38,10 +38,10 @@ s_rtbuf_lib_proc_out g_rtbuf_synth_adsr_out[] = {
   { 0, 0 } };
 
 s_rtbuf_lib_proc_in g_rtbuf_synth_synth_in[] = {
-  { "envelope", RTBUF_SIGNAL_TYPE, 0.0, 1.0 },
-  { "oscillator", RTBUF_SIGNAL_TYPE, -1.0, 1.0 },
+  { "envelope",   RTBUF_SIGNAL_TYPE, 1.0,  0.0, 1.0 },
+  { "oscillator", RTBUF_SIGNAL_TYPE, 0.0, -1.0, 1.0 },
   RTBUF_MUSIC_NOTES_IN("note"),
-  { 0, 0, 0.0, 0.0 } };
+  { 0, 0, 0.0, 0.0, 0.0 } };
 
 s_rtbuf_lib_proc_out g_rtbuf_synth_synth_out[] = {
   { "signal", RTBUF_SIGNAL_TYPE },
diff --git a/rtbuf_synth_synth.c b/rtbuf_synth_synth.c
index 22b0aa9..9521ff5 100644
--- a/rtbuf_synth_synth.c
+++ b/rtbuf_synth_synth.c
@@ -156,10 +156,8 @@ void rtbuf_synth_synth_update_note_signal (s_rtbuf *rtb,
   assert(rtb);
   assert(rtb->data);
   assert(i < RTBUF_MUSIC_NOTE_MAX);
-  rtbuf_signal_fun(rtb, RTBUF_SYNTH_SYNTH_IN_NOTE_ENVELOPE(i), &env,
-                   &g_rtbuf_signal_sample_zero);
-  rtbuf_signal_fun(rtb, RTBUF_SYNTH_SYNTH_IN_NOTE_OSCILLATOR(i), &osc,
-                   &g_rtbuf_signal_sample_zero);
+  rtbuf_signal_fun(rtb, RTBUF_SYNTH_SYNTH_IN_NOTE_ENVELOPE(i), &env);
+  rtbuf_signal_fun(rtb, RTBUF_SYNTH_SYNTH_IN_NOTE_OSCILLATOR(i), &osc);
   data = (s_rtbuf_synth_synth_data *) rtb->data;
   signal = data->signal;
   while (j < RTBUF_SIGNAL_SAMPLES) {