misc

Author: koppi

src/app.c

@@ -1,10 +1,17 @@
 #include "app.h"
 #include <stdio.h>
 #include <string.h>
+#include <stdlib.h>
 #include "oscilloscope.h"
 #include "gui.h"
 #include "arpeggiator.h"
 
+static App *g_app_for_toggle = NULL;
+static void toggle_chord_progression(void);
+static void generate_random_chord_progression(App *app);
+static void play_chord(App *app, int root_note, float velocity);
+static void stop_active_notes(App *app);
+
 int app_init(App *app) {
 
   memset(app, 0, sizeof(App));
@@ -15,6 +22,19 @@ int app_init(App *app) {
   app->frame_count = 0;
   app->fps = 0.0f;
 
+  // Initialize chord progression
+  app->chord_progression_enabled = 0;
+  app->current_chord_index = 0;
+  app->chord_progression_timer = 0.0f;
+  app->chord_duration = 2.0f;
+  app->chord_progression_length = 0;
+  app->rhythm_pattern_length = 0;
+  app->current_rhythm_step = 0;
+  app->rhythm_step_timer = 0.0f;
+  app->active_chord_note_count = 0;
+  app->humanize_velocity_amount = 0.15f;
+  app->humanize_timing_amount = 0.03f;
+  app->bpm = 120.0f;
 
   if (SDL_Init(SDL_INIT_AUDIO | SDL_INIT_VIDEO) < 0) {
     return 0;
@@ -66,6 +86,8 @@ int app_init(App *app) {
   }
 
   gui_init(app->window, app->gl_context);
+  g_app_for_toggle = app;
+  gui_set_humanize_vars(&app->chord_progression_enabled, &app->humanize_velocity_amount, &app->humanize_timing_amount, &app->bpm, toggle_chord_progression, &app->synth);
 
   oscilloscope_init();
 
@@ -149,6 +171,103 @@ static void handle_keyboard_note(App *app, SDL_Keycode key, int is_down) {
   }
 }
 
+static void toggle_chord_progression(void) {
+  if (g_app_for_toggle) {
+    g_app_for_toggle->chord_progression_enabled = !g_app_for_toggle->chord_progression_enabled;
+    if (g_app_for_toggle->chord_progression_enabled) {
+      generate_random_chord_progression(g_app_for_toggle);
+      play_chord(g_app_for_toggle, g_app_for_toggle->chord_progression[0], 
+                 g_app_for_toggle->rhythm_pattern[0]);
+    } else {
+      stop_active_notes(g_app_for_toggle);
+    }
+  }
+}
+
+static void generate_random_chord_progression(App *app) {
+  int scale[] = {0, 2, 4, 5, 7, 9, 11};
+  int progression_patterns[][8] = {
+    {0, 5, 3, 4, 2, 6, 1, 0},
+    {0, 3, 5, 4, 2, 1, 6, 5},
+    {0, 4, 5, 3, 1, 6, 2, 0},
+    {0, 5, 3, 4, 0, 5, 3, 6},
+    {0, 3, 4, 5, 1, 2, 6, 0},
+    {0, 4, 3, 5, 6, 1, 2, 4},
+    {0, 6, 3, 5, 4, 1, 2, 0},
+    {0, 2, 5, 3, 6, 4, 1, 0},
+  };
+  
+  int pattern_idx = rand() % 8;
+  int root = 48 + (rand() % 12);
+  
+  app->chord_progression_length = 8;
+  for (int i = 0; i < 8; i++) {
+    app->chord_progression[i] = root + scale[progression_patterns[pattern_idx][i]];
+  }
+  
+  // Generate 128-step rhythm pattern by repeating 16-step patterns
+  float base_patterns[][16] = {
+    {1.0f, 0.0f, 0.5f, 0.0f, 0.75f, 0.0f, 0.5f, 0.0f, 1.0f, 0.0f, 0.5f, 0.0f, 0.75f, 0.0f, 0.5f, 0.0f},
+    {1.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.75f, 0.5f, 0.0f, 1.0f, 0.0f, 0.5f, 0.0f, 0.75f, 0.5f, 0.0f, 0.0f},
+    {1.0f, 0.5f, 0.5f, 0.0f, 0.75f, 0.0f, 0.5f, 0.5f, 1.0f, 0.0f, 0.5f, 0.5f, 0.75f, 0.0f, 0.5f, 0.0f},
+    {1.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.75f, 0.0f, 1.0f, 0.0f, 0.5f, 0.0f, 0.5f, 0.75f, 0.0f, 0.0f},
+    {1.0f, 0.5f, 0.0f, 0.5f, 0.75f, 0.5f, 0.0f, 0.5f, 1.0f, 0.5f, 0.0f, 0.5f, 0.75f, 0.5f, 0.0f, 0.5f},
+  };
+  
+  int rhythm_idx = rand() % 5;
+  app->rhythm_pattern_length = 128;
+  
+  // Fill 128 steps by repeating the 16-step pattern 8 times
+  for (int i = 0; i < 128; i++) {
+    app->rhythm_pattern[i] = base_patterns[rhythm_idx][i % 16];
+  }
+  
+  app->current_chord_index = 0;
+  app->chord_progression_timer = 0.0f;
+  app->current_rhythm_step = 0;
+  app->rhythm_step_timer = 0.0f;
+}
+
+static float humanize_velocity(float velocity, float amount) {
+  float random = ((float)rand() / RAND_MAX) * 2.0f - 1.0f;
+  velocity += random * amount;
+  if (velocity < 0.1f) velocity = 0.1f;
+  if (velocity > 1.0f) velocity = 1.0f;
+  return velocity;
+}
+
+static void stop_active_notes(App *app) {
+  for (int i = 0; i < app->active_chord_note_count; i++) {
+    synth_note_off(&app->synth, app->active_chord_notes[i]);
+  }
+  app->active_chord_note_count = 0;
+}
+
+static void play_chord(App *app, int root_note, float velocity) {
+  if (velocity <= 0.0f) {
+    return;
+  }
+  
+  velocity = humanize_velocity(velocity, app->humanize_velocity_amount);
+  
+  int chord_notes[8];
+  chord_notes[0] = root_note;
+  chord_notes[1] = root_note + 3;
+  chord_notes[2] = root_note + 4;
+  chord_notes[3] = root_note + 7;
+  chord_notes[4] = root_note + 10;
+  chord_notes[5] = root_note + 12;
+  chord_notes[6] = root_note + 15;
+  chord_notes[7] = root_note + 16;
+  
+  app->active_chord_note_count = 0;
+  for (int i = 0; i < 8; i++) {
+    float note_velocity = humanize_velocity(velocity, app->humanize_velocity_amount);
+    synth_note_on(&app->synth, chord_notes[i], note_velocity);
+    app->active_chord_notes[app->active_chord_note_count++] = chord_notes[i];
+  }
+}
+
 void app_poll_events(App *app) {
   SDL_Event e;
   int event_count = 0;
@@ -160,7 +279,13 @@ void app_poll_events(App *app) {
     }
     if (e.type == SDL_KEYDOWN) {
       if (e.key.keysym.sym == SDLK_F1) {
-        app->show_help = !app->show_help;
+        app->chord_progression_enabled = !app->chord_progression_enabled;
+        if (app->chord_progression_enabled) {
+          generate_random_chord_progression(app);
+          play_chord(app, app->chord_progression[0], app->rhythm_pattern[0]);
+        } else {
+          stop_active_notes(app);
+        }
       } else if (app->show_help) {
         app->show_help = 0;
       }
@@ -184,6 +309,37 @@ void app_poll_events(App *app) {
 
 void app_update(App *app) {
 
+  // Update chord progression with rhythm
+  if (app->chord_progression_enabled && app->chord_progression_length > 0 && app->rhythm_pattern_length > 0) {
+    float delta_time = app->target_frame_time / 1000.0f;
+    float seconds_per_beat = 60.0f / app->bpm;
+    float step_duration = seconds_per_beat * 4.0f / app->rhythm_pattern_length;
+    
+    float timing_variation = ((float)rand() / RAND_MAX - 0.5f) * 2.0f * app->humanize_timing_amount;
+    step_duration += timing_variation;
+    if (step_duration < 0.01f) step_duration = 0.01f;
+    
+    app->rhythm_step_timer += delta_time;
+    
+    if (app->rhythm_step_timer >= step_duration) {
+      app->rhythm_step_timer -= step_duration;
+      
+      stop_active_notes(app);
+      
+      app->current_rhythm_step = (app->current_rhythm_step + 1) % app->rhythm_pattern_length;
+      
+      if (app->current_rhythm_step == 0) {
+        app->current_chord_index = (app->current_chord_index + 1) % app->chord_progression_length;
+      }
+      
+      float velocity = app->rhythm_pattern[app->current_rhythm_step];
+      play_chord(app, app->chord_progression[app->current_chord_index], velocity);
+    }
+  }
+  
+  // Sync FX BPM with chord progression BPM
+  synth_set_bpm(&app->synth, app->bpm);
+  
   // Calculate FPS
   app->frame_count++;
   Uint32 current_time = SDL_GetTicks();
@@ -213,7 +369,10 @@ void app_update(App *app) {
 }
 
 void app_render(App *app) {
-    gui_draw(&app->synth, app->window, app->gl_context);
+    gui_draw(&app->synth, app->window, app->gl_context, 
+             app->chord_progression_enabled, app->current_chord_index, 
+             app->chord_progression_length, app->current_rhythm_step, 
+             app->rhythm_pattern_length);
     SDL_GL_SwapWindow(app->window);
 }
 

src/app.h

@@ -15,6 +15,23 @@ typedef struct {
   Uint32 frame_count;
   float fps;
   Uint32 target_frame_time; // 1000ms / 60fps = ~16.67ms
+  
+  // Chord progression
+  int chord_progression_enabled;
+  int current_chord_index;
+  float chord_progression_timer;
+  float chord_duration;
+  int chord_progression[8];
+  int chord_progression_length;
+  float rhythm_pattern[128];
+  int rhythm_pattern_length;
+  int current_rhythm_step;
+  float rhythm_step_timer;
+  int active_chord_notes[16];
+  int active_chord_note_count;
+  float humanize_velocity_amount;
+  float humanize_timing_amount;
+  float bpm;
 } App;
 
 int app_init(App *app);

src/fx.c

@@ -64,8 +64,8 @@ void fx_init(FX *fx, int samplerate) {
   fx->flanger_rate = 0.25f;
   fx->flanger_feedback = 0.5f;
   fx->delay_time = 0.0f;       // Set to 0 (disabled)
-  fx->delay_feedback = 0.0f;   // Set to 0 (disabled)
-  fx->delay_mix = 0.25f;
+  fx->delay_feedback = 0.3f;   // Some feedback for richer delays
+  fx->delay_mix = 0.4f;        // Higher mix to hear the effect better
   fx->reverb_size = 0.0f;      // Set to 0.0 (minimal/no reverb)
   fx->reverb_damping = 0.3f;
   fx->reverb_mix = 0.0f;       // Set to 0.0 (100% dry - no reverb in output)
@@ -76,6 +76,24 @@ void fx_init(FX *fx, int samplerate) {
   fx->flanger_buffer = calloc(fx->flanger_bufsize * 2, sizeof(float));
   fx->flanger_pos = 0;
 
+  // Initialize multi-tap delay
+  fx->bpm = 120.0f;
+  fx->multitap_enabled = 0;
+  fx->multitap_delay_pos = 0;
+  fx->num_taps = 4;
+  // Default tap delays in beats: quarter, dotted eighth, eighth, triplet
+  float tap_beats[] = {1.0f, 0.75f, 0.5f, 0.333f};
+  float tap_levels[] = {0.7f, 0.5f, 0.4f, 0.3f};
+  for (int i = 0; i < MAX_DELAY_TAPS; i++) {
+    if (i < 4) {
+      fx->multitap_taps[i] = tap_beats[i];
+      fx->multitap_levels[i] = tap_levels[i];
+    } else {
+      fx->multitap_taps[i] = 0.0f;
+      fx->multitap_levels[i] = 0.0f;
+    }
+  }
+  
   // Initialize analog filter
   fx->filter_enabled = 0;       // Disabled by default
   fx->filter_cutoff = 1000.0f;  // 1kHz default
@@ -126,6 +144,22 @@ void fx_set_param(FX *fx, const char *param, float value) {
     fx->reverb_damping = value;
   else if (!strcmp(param, "reverb.mix"))
     fx->reverb_mix = value;
+  // Multi-tap delay parameters
+  else if (!strcmp(param, "multitap.enabled"))
+    fx->multitap_enabled = (int)value;
+  else if (!strcmp(param, "multitap.bpm"))
+    fx->bpm = value;
+  else if (!strncmp(param, "multitap.tap", 12)) {
+    // Parse tap index: multitap.tap0, multitap.tap1, etc.
+    int tap_idx = atoi(param + 12);
+    if (tap_idx >= 0 && tap_idx < MAX_DELAY_TAPS) {
+      if (!strncmp(param + 13, "_level", 6)) {
+        fx->multitap_levels[tap_idx] = value;
+      } else {
+        fx->multitap_taps[tap_idx] = value;
+      }
+    }
+  }
   // Analog filter parameters
   else if (!strcmp(param, "filter.enabled"))
     fx->filter_enabled = (int)value;
@@ -192,17 +226,59 @@ void fx_process(FX *fx, float *stereo, int frames) {
     }
     fx->flanger_pos = (fx->flanger_pos + 1) % fx->flanger_bufsize;
   }
-  for (int n = 0; n < frames; ++n) {
-    int delay_samp = (int)(fx->delay_time * fx->samplerate);
-    int pos =
-        (fx->delay_pos + fx->delay_bufsize - delay_samp) % fx->delay_bufsize;
-    for (int ch = 0; ch < 2; ++ch) {
-      float dry = stereo[n * 2 + ch];
-      float wet = fx->delay_buffer[pos * 2 + ch];
-      stereo[n * 2 + ch] = dry * (1.0f - fx->delay_mix) + wet * fx->delay_mix;
-      fx->delay_buffer[fx->delay_pos * 2 + ch] = dry + wet * fx->delay_feedback;
+  // Multi-tap delay synced to BPM (replaces standard delay when enabled)
+  if (fx->multitap_enabled && fx->delay_mix > 0.0f) {
+    float seconds_per_beat = 60.0f / fx->bpm;
+    
+    for (int n = 0; n < frames; ++n) {
+      float dryL = stereo[n * 2 + 0];
+      float dryR = stereo[n * 2 + 1];
+      float wetL = 0.0f, wetR = 0.0f;
+      
+      // Sum all taps
+      for (int tap = 0; tap < fx->num_taps; ++tap) {
+        if (fx->multitap_levels[tap] > 0.0f && fx->multitap_taps[tap] > 0.0f) {
+          float delay_seconds = fx->multitap_taps[tap] * seconds_per_beat;
+          int delay_samp = (int)(delay_seconds * fx->samplerate);
+          
+          // Ensure delay is within buffer bounds
+          if (delay_samp > 0 && delay_samp < fx->delay_bufsize) {
+            int pos = (fx->delay_pos + fx->delay_bufsize - delay_samp) % fx->delay_bufsize;
+            
+            // Read delayed signal
+            float tapL = fx->delay_buffer[pos * 2 + 0];
+            float tapR = fx->delay_buffer[pos * 2 + 1];
+            
+            // Add to wet mix with tap level
+            wetL += tapL * fx->multitap_levels[tap];
+            wetR += tapR * fx->multitap_levels[tap];
+          }
+        }
+      }
+      
+      // Mix wet and dry
+      stereo[n * 2 + 0] = dryL * (1.0f - fx->delay_mix) + wetL * fx->delay_mix;
+      stereo[n * 2 + 1] = dryR * (1.0f - fx->delay_mix) + wetR * fx->delay_mix;
+      
+      // Write input to buffer (ALWAYS write dry signal to keep buffer filled)
+      fx->delay_buffer[fx->delay_pos * 2 + 0] = dryL;
+      fx->delay_buffer[fx->delay_pos * 2 + 1] = dryR;
+      fx->delay_pos = (fx->delay_pos + 1) % fx->delay_bufsize;
+    }
+  } else {
+    // Standard delay (original behavior)
+    for (int n = 0; n < frames; ++n) {
+      int delay_samp = (int)(fx->delay_time * fx->samplerate);
+      int pos =
+          (fx->delay_pos + fx->delay_bufsize - delay_samp) % fx->delay_bufsize;
+      for (int ch = 0; ch < 2; ++ch) {
+        float dry = stereo[n * 2 + ch];
+        float wet = fx->delay_buffer[pos * 2 + ch];
+        stereo[n * 2 + ch] = dry * (1.0f - fx->delay_mix) + wet * fx->delay_mix;
+        fx->delay_buffer[fx->delay_pos * 2 + ch] = dry + wet * fx->delay_feedback;
+      }
+      fx->delay_pos = (fx->delay_pos + 1) % fx->delay_bufsize;
     }
-    fx->delay_pos = (fx->delay_pos + 1) % fx->delay_bufsize;
   }
   for (int n = 0; n < frames; ++n) {
     float inL = stereo[n * 2 + 0];
@@ -223,6 +299,10 @@ void fx_process(FX *fx, float *stereo, int frames) {
   }
 }
 
+void fx_set_bpm(FX *fx, float bpm) {
+  fx->bpm = bpm;
+}
+
 void fx_cleanup(FX *fx) {
   if (fx->delay_buffer) {
     free(fx->delay_buffer);