Merge branch 'multichannel'

.githooks/pre-push

@@ -1,4 +0,0 @@
-#!/bin/bash
-make test
-make check
-make format

docs/1-multichannel.md

@@ -1,72 +0,0 @@
-# Multi‑Channel & Bind Feature
-
-The looper supports up to 16 independent channels (numbered 0–15).  
-Channel 0 is always present and connected to the `looper:input` / `looper:output` audio ports.  
-Additional channels can be created and removed dynamically using MIDI commands.
-
-## MIDI Ports
-
-- **`looper:control`** – receives MIDI note‑on events for channel management and state toggling.
-- **`looper:clock`** – receives MIDI clock messages (0xFA, 0xFC, 0xFB) that affect channel 0 only.
-
-## Control‑Key Modifier
-
-Hold the **control key** (MIDI note 64) pressed *before* sending another note to put the looper in “command mode”.  
-While control‑key is active, the next note‑on (with velocity > 0) performs a special action instead of its direct mapping.  
-The control key is released either by sending note‑off (note 64 or any note) or by sending a note‑on while control‑key is already active (the action is performed and control‑key is cleared).
-
-## Available Commands (under control key)
-
-| Note | Action                                                                                       |
-|------|----------------------------------------------------------------------------------------------|
-| 0–15 | **Bind** the next `control+62` toggle to the channel with that index.                       |
-| 60   | **Add** a new dynamic channel (creates `channelX_input` / `channelX_output` ports).         |
-| 61   | **Remove** the highest‑numbered active channel (excluding channel 0).                       |
-| 62   | **Toggle** the current bound channel through its state machine:                              |
-|      | IDLE → RECORD → LOOPING → PAUSED → LOOPING → … (each press advances one step).              |
-| 63   | **Unbind** – reset the bound channel back to **0**.                                          |
-
-> **Notes:**
-> - The default bound channel is **0**. If you never send a bind command, `control+62` controls channel 0.
-> - To bind a different channel, send `control + note <16>` (e.g., control + note 5 binds channel 5).
-> - Bind is sticky – it stays until overwritten by another bind command.
-> - To **unbind** (reset to channel 0), send `control + note 63`.
-
-## Direct Mapping (without control key)
-
-For backward compatibility, the following notes work **without** the control‑key modifier:
-
-| Note | Action                                                                                       |
-|------|----------------------------------------------------------------------------------------------|
-| 1    | Toggle channel 0 state (IDLE→RECORD→LOOPING→PAUSED→LOOPING…).                               |
-| 60   | Add a dynamic channel (same as `control+60`).                                                |
-| 61   | Remove the highest‑numbered active channel (same as `control+61`).                           |
-
-## Example Usage
-
-1. **Record a loop on channel 0 (using direct note 1)**  
-   - Send note‑on, note 1, velocity 127 → channel 0 enters RECORD.  
-   - Play some audio into `looper:input`.  
-   - Send note‑on, note 1, velocity 127 again → channel 0 enters LOOPING.  
-   - The recorded audio repeats indefinitely.
-
-2. **Use the control‑key to toggle channel 0**  
-   - Send `note‑on, note 64` (control key).  
-   - Then send `note‑on, note 62` → toggles channel 0 (IDLE→RECORD).  
-   - Send `note‑on, note 64` again, then `note‑on, note 62` again → RECORD→LOOPING.
-
-3. **Add a new channel and bind it**  
-   - Send `note‑on, note 64` + `note‑on, note 60` → creates channel 1.  
-   - Send `note‑on, note 64` + `note‑on, note 1` → binds channel 1.  
-   - Now `control+62` toggles channel 1 instead of channel 0.  
-   - Record audio on channel 1 by sending `control+62` twice.
-
-4. **Remove a dynamic channel**  
-   - Send `note‑on, note 64` + `note‑on, note 61` → removes the highest‑numbered active channel (e.g., channel 1).
-
-## Notes
-
-- The looper must be connected to a running JACK server.  
-- Channel buffers hold up to 5 seconds of audio at 48 kHz.  
-- After removal, the channel’s audio ports are unregistered on the next main‑loop cycle (deferred to avoid race conditions).  
-- The bind index is stored as an integer (0–15); values outside 0–15 are ignored (the note is processed as a command rather than a bind).

makefile

@@ -20,13 +20,3 @@ test: integration
 .PHONY: clean integration test
 clean:
 	rm -f looper integration_test src/*.o
-
-check:
-	cppcheck --enable=all --error-exitcode=1 --suppress=missingIncludeSystem --suppress=normalCheckLevelMaxBranches src/*.c --library=posix .
-
-# Optional: Format code using clang-format
-format:
-	clang-format -i src/*.c
-
-install-hooks:
-	git config core.hooksPath .githooks

src/channel.c

@@ -1,40 +1,43 @@
-// cppcheck-suppress missingIncludeSystem
-#include "channel.h"
-#include <jack/jack.h>
-#include <stdatomic.h>
 #include <stdio.h>
 #include <string.h>
+#include <jack/jack.h>
+#include <stdatomic.h>
+#include "channel.h"
 
-void channel_add(jack_client_t *client, int idx) {
+void channel_add(jack_client_t *client, int idx)
-  char in_name[64], out_name[64];
+{
-  snprintf(in_name, sizeof(in_name), "channel%d_input", next_channel_id);
+    char in_name[64], out_name[64];
-  snprintf(out_name, sizeof(out_name), "channel%d_output", next_channel_id);
+    snprintf(in_name, sizeof(in_name), "channel%d_input", next_channel_id);
+    snprintf(out_name, sizeof(out_name), "channel%d_output", next_channel_id);
 
-  channels[idx].audio_in = jack_port_register(
+    channels[idx].audio_in = jack_port_register(client, in_name,
-      client, in_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
+                                                JACK_DEFAULT_AUDIO_TYPE,
-  channels[idx].audio_out = jack_port_register(
+                                                JackPortIsInput, 0);
-      client, out_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
+    channels[idx].audio_out = jack_port_register(client, out_name,
-  if (!channels[idx].audio_in || !channels[idx].audio_out) {
+                                                 JACK_DEFAULT_AUDIO_TYPE,
-    fprintf(stderr, "Failed to register ports for channel %d\n",
+                                                 JackPortIsOutput, 0);
-            next_channel_id);
+    if (!channels[idx].audio_in || !channels[idx].audio_out) {
-    /* Do NOT mark channel active – process loop will skip it */
+        fprintf(stderr, "Failed to register ports for channel %d\n", next_channel_id);
-    atomic_store(&channels[idx].active, 0);
+        /* Do NOT mark channel active – process loop will skip it */
-    return;
+        channels[idx].active = 0;
-  }
+        return;
+    }
 
-  atomic_store(&channels[idx].active, 1);
+    channels[idx].active = 1;
-  atomic_store(&channels[idx].state, STATE_IDLE);
+    atomic_store(&channels[idx].state, STATE_IDLE);
-  channels[idx].prev_state = -1;
+    channels[idx].prev_state = -1;
-  channels[idx].loop_count = 0;
+    channels[idx].loop_count = 0;
-  channels[idx].record_pos = 0;
+    channels[idx].record_pos = 0;
-  channels[idx].playback_pos = 0;
+    channels[idx].playback_pos = 0;
 
-  next_channel_id++;
+    next_channel_id++;
-  channel_count++;
+    channel_count++;
 }
 
-void channel_remove(jack_client_t *client, int idx) {
+void channel_remove(jack_client_t *client, int idx)
-  (void)client;
+{
-  atomic_store(&channels[idx].active, 0);
+    jack_port_unregister(client, channels[idx].audio_in);
-  channel_count--;
+    jack_port_unregister(client, channels[idx].audio_out);
+    channels[idx].active = 0;
+    channel_count--;
 }

src/channel.h

@@ -1,7 +1,6 @@
 #ifndef CHANNEL_H
 #define CHANNEL_H
 
-// cppcheck-suppress missingIncludeSystem
 #include <jack/jack.h>
 #include <stdatomic.h>
 
@@ -22,7 +21,7 @@ struct channel_t {
     int           loop_count;
     int           record_pos;
     int           playback_pos;
-    atomic_int    active;
+    int           active;
     jack_port_t  *audio_in;
     jack_port_t  *audio_out;
 };

src/looper.c

@@ -1,242 +1,214 @@
-// cppcheck-suppress missingIncludeSystem
-#include "looper.h"
-#include "channel.h"
-#include "midi.h"
-#include <jack/jack.h>
-#include <jack/midiport.h>
-#include <math.h>
-#include <stdatomic.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <jack/jack.h>
+#include <jack/midiport.h>
+#include <stdatomic.h>
+#include <math.h>
+#include "looper.h"
+#include "channel.h"
+#include "midi.h"
 
 /* Global state (shared across files) */
 struct channel_t channels[MAX_CHANNELS];
-atomic_int channel_count = 0;
+atomic_int  channel_count = 0;
-int next_channel_id = 1;
+int         next_channel_id = 1;
-atomic_int cmd_add = 0;
+atomic_int  cmd_add = 0;
-atomic_int cmd_remove = 0;
+atomic_int  cmd_remove = 0;
 jack_port_t *midi_control_port = NULL;
 jack_port_t *midi_clock_port = NULL;
-atomic_int control_key_active = 0;
+atomic_int  control_key_active = 0;
-atomic_int bind_channel = 0;
-
-/* Deferred removal index (1 second grace) */
-static int pending_unregister_idx = -1;
 
 /* ----------------------------------------------------------------
  * process callback
  * ---------------------------------------------------------------- */
-int process_callback(jack_nframes_t nframes, void *arg) {
+int process_callback(jack_nframes_t nframes, void *arg)
-  (void)arg;
+{
+    (void)arg;
 
-  if (midi_control_port) {
     void *midi_ctrl_buf = jack_port_get_buffer(midi_control_port, nframes);
     if (midi_ctrl_buf) {
-      midi_handle_events(midi_ctrl_buf, nframes);
+        midi_handle_events(midi_ctrl_buf, nframes);
-    }
-  }
-
-  /* process each active channel */
-  for (int c = 0; c < MAX_CHANNELS; c++) {
-    if (!atomic_load(&channels[c].active))
-      continue;
-
-    /* Guard against NULL ports (e.g. if port registration failed) */
-    if (!channels[c].audio_in || !channels[c].audio_out) {
-      fprintf(stderr, "WARN: channel %d has NULL audio port(s), skipping\n", c);
-      continue;
     }
 
-    const jack_default_audio_sample_t *in =
+    /* process each active channel */
-        (const jack_default_audio_sample_t *)jack_port_get_buffer(
+    for (int c = 0; c < MAX_CHANNELS; c++) {
-            channels[c].audio_in, nframes);
+        if (!channels[c].active) continue;
-    jack_default_audio_sample_t *out =
-        (jack_default_audio_sample_t *)jack_port_get_buffer(
-            channels[c].audio_out, nframes);
-    if (!out)
-      continue;
 
-    int state = atomic_load(&channels[c].state);
+        /* Guard against NULL ports (e.g. if port registration failed) */
-
+        if (!channels[c].audio_in || !channels[c].audio_out) {
-    if (state != channels[c].prev_state) {
+            fprintf(stderr, "WARN: channel %d has NULL audio port(s), skipping\n", c);
-      switch (state) {
+            continue;
-      case STATE_RECORD:
-        channels[c].record_pos = 0;
-        channels[c].loop_count = 0;
-        break;
-      case STATE_LOOPING:
-        if (channels[c].record_pos > 0)
-          channels[c].loop_count = channels[c].record_pos;
-        channels[c].playback_pos = 0;
-        break;
-      default:
-        break;
-      }
-    }
-
-    jack_nframes_t i;
-    switch (state) {
-    case STATE_RECORD:
-      if (in) {
-        float *f_out = (float *)out;
-        const float *f_in = (const float *)in;
-        for (i = 0; i < nframes; i++) {
-          if (channels[c].record_pos < LOOP_BUF_SIZE)
-            channels[c].loop_buffer[channels[c].record_pos++] =
-                f_in[i];
-          f_out[i] = f_in[i];
         }
-      } else {
-        memset(out, 0, sizeof(jack_default_audio_sample_t) * nframes);
-      }
-      break;
 
-    case STATE_LOOPING:
+        jack_default_audio_sample_t *in  = (jack_default_audio_sample_t *)
-      if (channels[c].loop_count > 0) {
+            jack_port_get_buffer(channels[c].audio_in, nframes);
-        float *outf = (float *)out;
+        jack_default_audio_sample_t *out = (jack_default_audio_sample_t *)
-        for (i = 0; i < nframes; i++) {
+            jack_port_get_buffer(channels[c].audio_out, nframes);
-          outf[i] = channels[c].loop_buffer[channels[c].playback_pos];
+        if (!out) continue;
-          channels[c].playback_pos =
+
-              (channels[c].playback_pos + 1) % channels[c].loop_count;
+        int state = atomic_load(&channels[c].state);
+
+        if (state != channels[c].prev_state) {
+            switch (state) {
+            case STATE_RECORD:
+                channels[c].record_pos = 0;
+                channels[c].loop_count = 0;
+                break;
+            case STATE_LOOPING:
+                if (channels[c].record_pos > 0)
+                    channels[c].loop_count = channels[c].record_pos;
+                channels[c].playback_pos = 0;
+                break;
+            default:
+                break;
+            }
         }
-      } else {
-        memset(out, 0, sizeof(jack_default_audio_sample_t) * nframes);
-      }
-      break;
 
-    case STATE_PAUSED:
+        jack_nframes_t i;
-      memset(out, 0, sizeof(jack_default_audio_sample_t) * nframes);
+        switch (state) {
-      break;
+        case STATE_RECORD:
+            if (in) {
+                for (i = 0; i < nframes; i++) {
+                    if (channels[c].record_pos < LOOP_BUF_SIZE)
+                        channels[c].loop_buffer[channels[c].record_pos++] = ((const float *)in)[i];
+                    ((float *)out)[i] = ((const float *)in)[i];
+                }
+            } else {
+                memset(out, 0, sizeof(jack_default_audio_sample_t) * nframes);
+            }
+            break;
 
-    default: /* IDLE */
+        case STATE_LOOPING:
-      if (in) {
+            if (channels[c].loop_count > 0) {
-        memcpy(out, in, sizeof(jack_default_audio_sample_t) * nframes);
+                float *outf = (float *)out;
-      } else {
+                for (i = 0; i < nframes; i++) {
-        memset(out, 0, sizeof(jack_default_audio_sample_t) * nframes);
+                    outf[i] = channels[c].loop_buffer[channels[c].playback_pos];
-      }
+                    channels[c].playback_pos = (channels[c].playback_pos + 1) % channels[c].loop_count;
-      break;
+                }
+            } else {
+                memset(out, 0, sizeof(jack_default_audio_sample_t) * nframes);
+            }
+            break;
+
+        case STATE_PAUSED:
+            memset(out, 0, sizeof(jack_default_audio_sample_t) * nframes);
+            break;
+
+        default: /* IDLE */
+            if (in) {
+                memcpy(out, in, sizeof(jack_default_audio_sample_t) * nframes);
+            } else {
+                memset(out, 0, sizeof(jack_default_audio_sample_t) * nframes);
+            }
+            break;
+        }
+
+        channels[c].prev_state = state;
     }
 
-    channels[c].prev_state = state;
+    /* MIDI clock events – affect channel 0 only */
-  }
-
-  /* MIDI clock events – affect channel 0 only */
-  if (midi_clock_port) {
     void *midi_clock_buf = jack_port_get_buffer(midi_clock_port, nframes);
     if (midi_clock_buf) {
-      jack_nframes_t n_clock_events = jack_midi_get_event_count(midi_clock_buf);
+        jack_nframes_t n_clock_events = jack_midi_get_event_count(midi_clock_buf);
-      jack_midi_event_t cev;
+        jack_midi_event_t cev;
-      for (jack_nframes_t j = 0; j < n_clock_events; j++) {
+        for (jack_nframes_t j = 0; j < n_clock_events; j++) {
-        if (jack_midi_event_get(&cev, midi_clock_buf, j) != 0)
+            if (jack_midi_event_get(&cev, midi_clock_buf, j) != 0) continue;
-          continue;
+            if (cev.size >= 1) {
-        if (cev.size >= 1) {
+                unsigned char msg = cev.buffer[0];
-          unsigned char msg = cev.buffer[0];
+                switch (msg) {
-          switch (msg) {
+                case 0xFA: {
-          case 0xFA: {
+                    int s = atomic_load(&channels[0].state);
-            int s = atomic_load(&channels[0].state);
+                    if (s == STATE_IDLE) atomic_store(&channels[0].state, STATE_RECORD);
-            if (s == STATE_IDLE)
+                    break;
-              atomic_store(&channels[0].state, STATE_RECORD);
+                }
-            break;
+                case 0xFC:
-          }
+                    atomic_store(&channels[0].state, STATE_IDLE);
-          case 0xFC:
+                    break;
-            atomic_store(&channels[0].state, STATE_IDLE);
+                case 0xFB: {
-            break;
+                    int s = atomic_load(&channels[0].state);
-          case 0xFB: {
+                    if (s == STATE_PAUSED) atomic_store(&channels[0].state, STATE_LOOPING);
-            int s = atomic_load(&channels[0].state);
+                    break;
-            if (s == STATE_PAUSED)
+                }
-              atomic_store(&channels[0].state, STATE_LOOPING);
+                default:
-            break;
+                    break;
-          }
+                }
-          default:
+            }
-            break;
-          }
         }
-      }
     }
-  }
 
-  return 0;
+    return 0;
 }
 
 /* ----------------------------------------------------------------
  * shutdown callback
  * ---------------------------------------------------------------- */
-void jack_shutdown_cb(void *arg) {
+void jack_shutdown_cb(void *arg)
-  (void)arg;
+{
-  fprintf(stderr, "JACK shutdown\n");
+    (void)arg;
-  exit(0);
+    fprintf(stderr, "JACK shutdown\n");
+    exit(0);
 }
 
 /* ----------------------------------------------------------------
  * looper initialisation
  * ---------------------------------------------------------------- */
-int looper_init(jack_client_t *client) {
+int looper_init(jack_client_t *client)
-  /* channel 0 */
+{
-  channels[0].active = 1;
+    /* channel 0 */
-  atomic_store(&channels[0].state, STATE_IDLE);
+    channels[0].active = 1;
-  channels[0].prev_state = -1;
+    atomic_store(&channels[0].state, STATE_IDLE);
-  channels[0].loop_count = 0;
+    channels[0].prev_state = -1;
-  channels[0].record_pos = 0;
+    channels[0].loop_count = 0;
-  channels[0].playback_pos = 0;
+    channels[0].record_pos = 0;
+    channels[0].playback_pos = 0;
 
-  channels[0].audio_in = jack_port_register(
+    channels[0].audio_in = jack_port_register(client, "input",
-      client, "input", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
+                                               JACK_DEFAULT_AUDIO_TYPE,
-  channels[0].audio_out = jack_port_register(
+                                               JackPortIsInput, 0);
-      client, "output", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
+    channels[0].audio_out = jack_port_register(client, "output",
-  if (!channels[0].audio_in || !channels[0].audio_out) {
+                                                JACK_DEFAULT_AUDIO_TYPE,
-    fprintf(stderr, "Could not create audio ports for channel 0\n");
+                                                JackPortIsOutput, 0);
-    return -1;
+    if (!channels[0].audio_in || !channels[0].audio_out) {
-  }
+        fprintf(stderr, "Could not create audio ports for channel 0\n");
-  channel_count = 1;
+        return -1;
+    }
+    channel_count = 1;
 
-  midi_control_port = jack_port_register(
+    midi_control_port = jack_port_register(client, "control",
-      client, "control", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
+                                            JACK_DEFAULT_MIDI_TYPE,
-  midi_clock_port = jack_port_register(client, "clock", JACK_DEFAULT_MIDI_TYPE,
+                                            JackPortIsInput, 0);
-                                       JackPortIsInput, 0);
+    midi_clock_port   = jack_port_register(client, "clock",
-  if (!midi_control_port || !midi_clock_port) {
+                                            JACK_DEFAULT_MIDI_TYPE,
-    fprintf(stderr, "Could not create MIDI ports\n");
+                                            JackPortIsInput, 0);
-    return -1;
+    if (!midi_control_port || !midi_clock_port) {
-  }
+        fprintf(stderr, "Could not create MIDI ports\n");
+        return -1;
+    }
 
-  return 0;
+    return 0;
 }
 
 /* ----------------------------------------------------------------
  * main‑loop command processing
  * ---------------------------------------------------------------- */
-void looper_process_commands(jack_client_t *client) {
+void looper_process_commands(jack_client_t *client)
-  /* Unregister any ports that were marked for deferred removal.
+{
-     By now the real‑time thread has had at least one full cycle
+    if (atomic_exchange(&cmd_add, 0)) {
-     to see the `active = 0` store. */
+        int idx;
-  if (pending_unregister_idx != -1) {
+        for (idx = 0; idx < MAX_CHANNELS; idx++)
-    int idx = pending_unregister_idx;
+            if (!channels[idx].active) break;
-    if (channels[idx].audio_in)
+        if (idx < MAX_CHANNELS) {
-      jack_port_unregister(client, channels[idx].audio_in);
+            channel_add(client, idx);
-    if (channels[idx].audio_out)
+        }
-      jack_port_unregister(client, channels[idx].audio_out);
-    pending_unregister_idx = -1;
-  }
-
-  if (atomic_exchange(&cmd_add, 0)) {
-    int idx;
-    for (idx = 0; idx < MAX_CHANNELS; idx++)
-      if (!channels[idx].active)
-        break;
-    if (idx < MAX_CHANNELS) {
-      channel_add(client, idx);
     }
-  }
 
-  if (atomic_exchange(&cmd_remove, 0)) {
+    if (atomic_exchange(&cmd_remove, 0)) {
-    int remove_idx = -1;
+        int remove_idx = -1;
-    for (int idx = 1; idx < MAX_CHANNELS; idx++)
+        for (int idx = 1; idx < MAX_CHANNELS; idx++)
-      if (channels[idx].active)
+            if (channels[idx].active) remove_idx = idx;
-        remove_idx = idx;
+        if (remove_idx != -1) {
-    if (remove_idx != -1) {
+            channel_remove(client, remove_idx);
-      /* Mark inactive now; ports will be unregistered next round */
+        }
-      channel_remove(client, remove_idx);
-      pending_unregister_idx = remove_idx;
     }
-  }
 }

src/looper.h

@@ -1,7 +1,6 @@
 #ifndef LOOPER_H
 #define LOOPER_H
 
-// cppcheck-suppress missingIncludeSystem
 #include <jack/jack.h>
 
 /* Initialisation – must be called after setting process callback */

src/main.c

@@ -1,51 +1,50 @@
-// cppcheck-suppress missingIncludeSystem
-#include "looper.h"
-#include <jack/jack.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include <time.h>
+#include <jack/jack.h>
+#include "looper.h"
 
-int main(int argc, char *argv[]) {
+int main(int argc, char *argv[])
-  (void)argc;
+{
-  (void)argv;
+    (void)argc;
-  const char *client_name = "looper";
+    (void)argv;
-  jack_options_t options = JackNullOption;
+    const char *client_name = "looper";
-  jack_status_t status;
+    jack_options_t options = JackNullOption;
+    jack_status_t status;
 
-  jack_client_t *client = jack_client_open(client_name, options, &status);
+    jack_client_t *client = jack_client_open(client_name, options, &status);
-  if (client == NULL) {
+    if (client == NULL) {
-    fprintf(stderr, "jack_client_open() failed, status = 0x%2.0x\n", status);
+        fprintf(stderr, "jack_client_open() failed, status = 0x%2.0x\n", status);
-    if (status & JackServerFailed)
+        if (status & JackServerFailed)
-      fprintf(stderr, "Unable to connect to JACK server\n");
+            fprintf(stderr, "Unable to connect to JACK server\n");
-    return 1;
+        return 1;
-  }
+    }
 
-  if (status & JackNameNotUnique)
+    if (status & JackNameNotUnique)
-    client_name = jack_get_client_name(client);
+        client_name = jack_get_client_name(client);
 
-  jack_set_process_callback(client, process_callback, NULL);
+    jack_set_process_callback(client, process_callback, NULL);
-  jack_on_shutdown(client, jack_shutdown_cb, NULL);
+    jack_on_shutdown(client, jack_shutdown_cb, NULL);
+
+    if (looper_init(client) != 0) {
+        fprintf(stderr, "looper initialisation failed\n");
+        jack_client_close(client);
+        return 1;
+    }
+
+    if (jack_activate(client)) {
+        fprintf(stderr, "Cannot activate client\n");
+        jack_client_close(client);
+        return 1;
+    }
+
+    fprintf(stderr, "looper running (client name '%s')\n", client_name);
+
+    while (1) {
+        looper_process_commands(client);
+        usleep(50000);   /* check commands every 50 ms */
+    }
 
-  if (looper_init(client) != 0) {
-    fprintf(stderr, "looper initialisation failed\n");
     jack_client_close(client);
-    return 1;
+    return 0;
-  }
-
-  if (jack_activate(client)) {
-    fprintf(stderr, "Cannot activate client\n");
-    jack_client_close(client);
-    return 1;
-  }
-
-  fprintf(stderr, "looper running (client name '%s')\n", client_name);
-
-  while (1) {
-    looper_process_commands(client);
-    { struct timespec ts = { .tv_sec = 0, .tv_nsec = 50000000 }; nanosleep(&ts, NULL); } /* check commands every 50 ms */
-  }
-
-  jack_client_close(client);
-  return 0;
 }

src/midi.c

@@ -1,111 +1,91 @@
-// cppcheck-suppress missingIncludeSystem
-#include "midi.h"
-#include "channel.h"
 #include <jack/jack.h>
 #include <jack/midiport.h>
 #include <stdatomic.h>
+#include "midi.h"
+#include "channel.h"
 
 extern atomic_int control_key_active;
 extern atomic_int cmd_add;
 extern atomic_int cmd_remove;
-extern atomic_int bind_channel;
 
-void midi_handle_events(void *port_buffer, jack_nframes_t nframes) {
+void midi_handle_events(void *port_buffer, jack_nframes_t nframes)
-  (void)nframes;
+{
-  jack_nframes_t nevents = jack_midi_get_event_count(port_buffer);
+    (void)nframes;
-  jack_midi_event_t ev;
+    jack_nframes_t nevents = jack_midi_get_event_count(port_buffer);
+    jack_midi_event_t ev;
 
-  for (jack_nframes_t i = 0; i < nevents; i++) {
+    for (jack_nframes_t i = 0; i < nevents; i++) {
-    if (jack_midi_event_get(&ev, port_buffer, i) != 0)
+        if (jack_midi_event_get(&ev, port_buffer, i) != 0) continue;
-      continue;
+        if (ev.size < 3) continue;
-    if (ev.size < 3)
-      continue;
 
-    unsigned char status = ev.buffer[0];
+        unsigned char status = ev.buffer[0];
-    unsigned char note = ev.buffer[1];
+        unsigned char note   = ev.buffer[1];
-    unsigned char vel = ev.buffer[2];
+        unsigned char vel    = ev.buffer[2];
 
-    /* note‑on */
+        /* note‑on */
-    if ((status & 0xf0) == 0x90 && vel > 0) {
+        if ((status & 0xf0) == 0x90 && vel > 0) {
-      if (note == 64) {
+            if (note == 64) {
-        atomic_store(&control_key_active, 1);
+                atomic_store(&control_key_active, 1);
-      } else {
+            } else {
-        int ck = atomic_load(&control_key_active);
+                int ck = atomic_load(&control_key_active);
-        if (ck) {
+                if (ck) {
-          atomic_store(&control_key_active, 0);
+                    atomic_store(&control_key_active, 0);
-          if (note < 16) {
+                    switch (note) {
-            atomic_store(&bind_channel, note);
+                    case 60: atomic_store(&cmd_add, 1); break;
-          } else {
+                    case 61: atomic_store(&cmd_remove, 1); break;
-            switch (note) {
+                    case 62: /* trigger looper – channel 0 */
-            case 60:
+                        {
-              atomic_store(&cmd_add, 1);
+                            int cur0 = atomic_load(&channels[0].state);
-              break;
+                            switch (cur0) {
-            case 61:
+                            case STATE_IDLE:
-              atomic_store(&cmd_remove, 1);
+                                atomic_store(&channels[0].state, STATE_RECORD);
-              break;
+                                break;
-            case 62: /* trigger looper – channel via bind_channel */
+                            case STATE_RECORD:
-            {
+                                atomic_store(&channels[0].state, STATE_LOOPING);
-              int bch = atomic_load(&bind_channel);
+                                break;
-              if (bch >= 0 && bch < MAX_CHANNELS) {
+                            case STATE_LOOPING:
-                int cur = atomic_load(&channels[bch].state);
+                                atomic_store(&channels[0].state, STATE_PAUSED);
-                switch (cur) {
+                                break;
-                case STATE_IDLE:
+                            case STATE_PAUSED:
-                  atomic_store(&channels[bch].state, STATE_RECORD);
+                                atomic_store(&channels[0].state, STATE_LOOPING);
-                  break;
+                                break;
-                case STATE_RECORD:
+                            }
-                  atomic_store(&channels[bch].state, STATE_LOOPING);
+                        }
-                  break;
+                        break;
-                case STATE_LOOPING:
+                    default:
-                  atomic_store(&channels[bch].state, STATE_PAUSED);
+                        break;
-                  break;
+                    }
-                case STATE_PAUSED:
+                } else {
-                  atomic_store(&channels[bch].state, STATE_LOOPING);
+                    /* direct mapping */
-                  break;
+                    switch (note) {
+                    case 1: /* toggle channel 0 */
+                        {
+                            int cur0 = atomic_load(&channels[0].state);
+                            switch (cur0) {
+                            case STATE_IDLE:
+                                atomic_store(&channels[0].state, STATE_RECORD);
+                                break;
+                            case STATE_RECORD:
+                                atomic_store(&channels[0].state, STATE_LOOPING);
+                                break;
+                            case STATE_LOOPING:
+                                atomic_store(&channels[0].state, STATE_PAUSED);
+                                break;
+                            case STATE_PAUSED:
+                                atomic_store(&channels[0].state, STATE_LOOPING);
+                                break;
+                            }
+                        }
+                        break;
+                    case 60: atomic_store(&cmd_add, 1); break;
+                    case 61: atomic_store(&cmd_remove, 1); break;
+                    default:
+                        break;
+                    }
                 }
-              }
-            } break;
-            case 63: /* unbind – reset bind to channel 0 */
-              atomic_store(&bind_channel, 0);
-              break;
-            default:
-              break;
             }
-          }
+        } else if ((status & 0xf0) == 0x80 || ((status & 0xf0) == 0x90 && vel == 0)) {
-        } else {
+            atomic_store(&control_key_active, 0);
-          /* direct mapping */
-          switch (note) {
-          case 1: /* toggle channel 0 */
-          {
-            int cur0 = atomic_load(&channels[0].state);
-            switch (cur0) {
-            case STATE_IDLE:
-              atomic_store(&channels[0].state, STATE_RECORD);
-              break;
-            case STATE_RECORD:
-              atomic_store(&channels[0].state, STATE_LOOPING);
-              break;
-            case STATE_LOOPING:
-              atomic_store(&channels[0].state, STATE_PAUSED);
-              break;
-            case STATE_PAUSED:
-              atomic_store(&channels[0].state, STATE_LOOPING);
-              break;
-            }
-          } break;
-          case 60:
-            atomic_store(&cmd_add, 1);
-            break;
-          case 61:
-            atomic_store(&cmd_remove, 1);
-            break;
-          default:
-            break;
-          }
         }
-      }
-    } else if ((status & 0xf0) == 0x80 ||
-               ((status & 0xf0) == 0x90 && vel == 0)) {
-      atomic_store(&control_key_active, 0);
     }
-  }
 }

src/midi.h

@@ -1,7 +1,6 @@
 #ifndef MIDI_H
 #define MIDI_H
 
-// cppcheck-suppress missingIncludeSystem
 #include <jack/types.h>
 
 void midi_handle_events(void *port_buffer, jack_nframes_t nframes);

tests/integration.c

@@ -10,7 +10,6 @@
 #include <jack/jack.h>
 #include <jack/midiport.h>
 #include <math.h>
-#include <time.h>
 
 /* static variables for passthrough test */
 static jack_port_t *passthrough_output_port = NULL;
@@ -33,16 +32,8 @@ static jack_client_t *midi_inject_client = NULL;
 static unsigned char midi_inject_note = 0;
 static unsigned char midi_inject_velocity = 0;
 
-static void safe_usleep(unsigned int usec) {
-    struct timespec ts;
-    ts.tv_sec = usec / 1000000;
-    ts.tv_nsec = (usec % 1000000) * 1000L;
-    nanosleep(&ts, NULL);
-}
-
 static int midi_inject_process(jack_nframes_t nframes, void *arg) {
     (void)arg;
-    if (!midi_inject_port) return 0;
     void *port_buf = jack_port_get_buffer(midi_inject_port, nframes);
     if (!port_buf) return 0;
     jack_midi_clear_buffer(port_buf);
@@ -65,11 +56,11 @@ static int passthrough_process(jack_nframes_t nframes, void *arg) {
     (void)arg;
     jack_default_audio_sample_t *out =
         (jack_default_audio_sample_t *)jack_port_get_buffer(passthrough_output_port, nframes);
-    const jack_default_audio_sample_t *in =
+    jack_default_audio_sample_t *in =
-        (const jack_default_audio_sample_t *)jack_port_get_buffer(passthrough_input_port, nframes);
+        (jack_default_audio_sample_t *)jack_port_get_buffer(passthrough_input_port, nframes);
     if (!out || !in) return 0;
-    float *f_out = (float *)out;
+    float *outf = out;
-    const float *f_in = (const float *)in;
+    const float *inf = in;
     for (jack_nframes_t i = 0; i < nframes; i++) {
         /* generate beep while beep_remaining > 0 or continuous sine */
         float out_val;
@@ -82,17 +73,17 @@ static int passthrough_process(jack_nframes_t nframes, void *arg) {
         } else {
             out_val = 0.0f;
         }
-        f_out[i] = out_val;
+        outf[i] = out_val;
 
         /* detect bursts on the input (looper output) */
-        float sample = f_in[i];
+        float sample = inf[i];
         int above = (fabsf(sample) > 0.05f);
         if (above && !prev_above) {
             bursts++;
         }
         prev_above = above;
 
-        passthrough_sum_sq += (double)f_in[i] * (double)f_in[i];
+        passthrough_sum_sq += (double)inf[i] * (double)inf[i];
         passthrough_total_samples++;
     }
     if (passthrough_total_samples >= passthrough_sample_rate * 2) {
@@ -165,7 +156,7 @@ static int test_audio_pass_through(void) {
         waitpid(pid, NULL, 0);
         return 1;
     }
-    safe_usleep(200000);
+    usleep(200000);
     const char *looper_input = "looper:input";
     const char *looper_output = "looper:output";
     char my_output[64], my_input[64];
@@ -203,7 +194,7 @@ static int test_audio_pass_through(void) {
         waitpid(pid, NULL, 0);
         return 1;
     }
-    safe_usleep(2200000);
+    usleep(2200000); /* 2.2 seconds */
     int saw_input = passthrough_done;
     double rms = passthrough_total_samples > 0 ?
                  sqrt(passthrough_sum_sq / passthrough_total_samples) : 0.0;
@@ -259,7 +250,7 @@ static int send_jack_note_on(const char *target_port, unsigned char note, unsign
     }
     /* wait for the process callback to clear the flag (event delivered) */
     for (int attempts = 0; attempts < 50; attempts++) {   /* ~50 * 10ms = 500ms */
-        safe_usleep(10000);
+        usleep(10000);
         if (!midi_inject_pending) break;
     }
     jack_deactivate(midi_inject_client);
@@ -303,7 +294,7 @@ static int test_looper_looping(void) {
         kill(pid, SIGTERM); waitpid(pid, NULL, 0);
         return 1;
     }
-    safe_usleep(200000);               /* wait for ports to appear */
+    usleep(200000);               /* wait for ports to appear */
     /* connect test:out -> looper:input, looper:output -> test:in */
     char my_out[64], my_in[64];
     snprintf(my_out, sizeof(my_out), "test_looping:out");
@@ -321,7 +312,7 @@ static int test_looper_looping(void) {
         kill(pid, SIGTERM); waitpid(pid, NULL, 0);
         return 1;
     }
-    safe_usleep(500000);               /* allow state to change (500ms) */
+    usleep(500000);               /* allow state to change (500ms) */
 
     int sr = jack_get_sample_rate(client);
     continuous_sine = 0;          /* disable continuous tone */
@@ -345,10 +336,10 @@ static int test_looper_looping(void) {
         return 1;
     }
 
-    safe_usleep(150000);               /* let beep start */
+    usleep(150000);               /* let beep start */
 
     /* ensure beep is fully captured */
-    safe_usleep(800000);   /* 0.8s after start of beep */
+    usleep(800000);   /* 0.8s after start of beep */
 
     if (send_jack_note_on("looper:control", 1, 127) != 0) {
         jack_client_close(client);
@@ -357,7 +348,7 @@ static int test_looper_looping(void) {
     }
 
     /* wait enough time for several loops (4 seconds to be safe) */
-    safe_usleep(4000000);
+    usleep(4000000);
 
     jack_deactivate(client);
     jack_client_close(client);
@@ -398,7 +389,7 @@ static int test_multiple_channels(void) {
     }
     /* wait long enough for the looper's main loop to process the add command
        (it sleeps for 1 second between checks, so 1.5 s is safe) */
-    safe_usleep(1500000);
+    usleep(1500000);
 
     int found = 0;
     const char **ports = jack_get_ports(client, NULL, JACK_DEFAULT_AUDIO_TYPE, 0);
@@ -423,418 +414,6 @@ static int test_multiple_channels(void) {
     return 0;
 }
 
-/* test control‑key modifier (note 64 + note 62) */
-static int test_control_key_modifier(void) {
-    printf("Test: control‑key modifier triggers state transition via note 62\n");
-    pid_t pid = start_looper();
-    if (pid < 0) return 1;
-    jack_client_t *client;
-    jack_status_t status;
-    client = jack_client_open("test_ctrl_key", JackNoStartServer, &status);
-    if (!client) {
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  SKIP: no JACK\n");
-        return 1;
-    }
-    /* connect same as in test_looper_looping but no beep generation */
-    jack_port_t *audio_out = jack_port_register(client, "out",
-                           JACK_DEFAULT_AUDIO_TYPE,
-                           JackPortIsOutput, 0);
-    jack_port_t *audio_in = jack_port_register(client, "in",
-                           JACK_DEFAULT_AUDIO_TYPE,
-                           JackPortIsInput, 0);
-    if (!audio_out || !audio_in) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        return 1;
-    }
-    safe_usleep(200000);
-    char my_out[64], my_in[64];
-    snprintf(my_out, sizeof(my_out), "test_ctrl_key:out");
-    snprintf(my_in,  sizeof(my_in),  "test_ctrl_key:in");
-    if (jack_connect(client, my_out, "looper:input") ||
-        jack_connect(client, "looper:output", my_in)) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        return 1;
-    }
-    /* First send note 64 (control key) */
-    if (send_jack_note_on("looper:control", 64, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: send note 64 failed\n");
-        return 1;
-    }
-    safe_usleep(200000);
-    /* Now send note 62 (toggle channel 0) */
-    if (send_jack_note_on("looper:control", 62, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: send note 62 failed\n");
-        return 1;
-    }
-    /* Wait for looper to enter RECORD and detect audio */
-    int sr = jack_get_sample_rate(client);
-    continuous_sine = 0;
-    beep_remaining = (int)(0.1f * sr);   /* 0.1 second beep */
-    bursts = 0;
-    prev_above = 0;
-    passthrough_output_port = audio_out;
-    passthrough_input_port = audio_in;
-    passthrough_phase = 0.0f;
-    passthrough_freq = 440.0f;
-    passthrough_sample_rate = sr;
-    passthrough_total_samples = 0;
-    passthrough_sum_sq = 0.0;
-    passthrough_done = 0;
-    jack_set_process_callback(client, passthrough_process, NULL);
-    if (jack_activate(client)) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        return 1;
-    }
-    safe_usleep(200000);   /* allow beep */
-    /* send note 62 again under control key to move RECORD->LOOPING */
-    if (send_jack_note_on("looper:control", 64, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: control key re‑send\n");
-        return 1;
-    }
-    safe_usleep(200000);
-    if (send_jack_note_on("looper:control", 62, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: send note 62 for loop\n");
-        return 1;
-    }
-    safe_usleep(2000000);
-    jack_deactivate(client);
-    jack_client_close(client);
-    kill(pid, SIGTERM);
-    waitpid(pid, NULL, 0);
-    int got_bursts = bursts;
-    printf("  detected bursts: %d\n", got_bursts);
-    if (got_bursts < 3) {
-        fprintf(stderr, "  FAIL: expected ≥3 bursts, got %d\n", got_bursts);
-        return 1;
-    }
-    printf("  PASS (control‑key modifier works)\n");
-    return 0;
-}
-
-/* test bind channel */
-static int test_bind_channel(void) {
-    printf("Test: control‑key bind channel (note 0) and toggle\n");
-    pid_t pid = start_looper();
-    if (pid < 0) return 1;
-    jack_client_t *client;
-    jack_status_t status;
-    client = jack_client_open("test_bind", JackNoStartServer, &status);
-    if (!client) {
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  SKIP: no JACK\n");
-        return 1;
-    }
-    jack_port_t *audio_out = jack_port_register(client, "out",
-                           JACK_DEFAULT_AUDIO_TYPE,
-                           JackPortIsOutput, 0);
-    jack_port_t *audio_in = jack_port_register(client, "in",
-                           JACK_DEFAULT_AUDIO_TYPE,
-                           JackPortIsInput, 0);
-    if (!audio_out || !audio_in) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        return 1;
-    }
-    safe_usleep(200000);
-    char my_out[64], my_in[64];
-    snprintf(my_out, sizeof(my_out), "test_bind:out");
-    snprintf(my_in,  sizeof(my_in),  "test_bind:in");
-    if (jack_connect(client, my_out, "looper:input") ||
-        jack_connect(client, "looper:output", my_in)) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        return 1;
-    }
-    /* Send control key + note 0 to bind to channel 0 */
-    if (send_jack_note_on("looper:control", 64, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: send control key failed\n");
-        return 1;
-    }
-    safe_usleep(200000);
-    if (send_jack_note_on("looper:control", 0, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: send bind note 0 failed\n");
-        return 1;
-    }
-    safe_usleep(200000);
-    /* Now toggle using control+note62 – should toggle channel 0 */
-    if (send_jack_note_on("looper:control", 64, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: send control key again failed\n");
-        return 1;
-    }
-    safe_usleep(200000);
-    if (send_jack_note_on("looper:control", 62, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: send toggle note 62 failed\n");
-        return 1;
-    }
-    /* Wait and detect bursts as before */
-    int sr = jack_get_sample_rate(client);
-    continuous_sine = 0;
-    beep_remaining = (int)(0.1f * sr);
-    bursts = 0;
-    prev_above = 0;
-    passthrough_output_port = audio_out;
-    passthrough_input_port = audio_in;
-    passthrough_phase = 0.0f;
-    passthrough_freq = 440.0f;
-    passthrough_sample_rate = sr;
-    passthrough_total_samples = 0;
-    passthrough_sum_sq = 0.0;
-    passthrough_done = 0;
-    jack_set_process_callback(client, passthrough_process, NULL);
-    if (jack_activate(client)) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        return 1;
-    }
-    safe_usleep(200000); /* allow beep */
-    /* send control+note62 again to move RECORD->LOOPING */
-    if (send_jack_note_on("looper:control", 64, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: control key for loop\n");
-        return 1;
-    }
-    safe_usleep(200000);
-    if (send_jack_note_on("looper:control", 62, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: toggle for loop\n");
-        return 1;
-    }
-    safe_usleep(2000000);
-    jack_deactivate(client);
-    jack_client_close(client);
-    kill(pid, SIGTERM);
-    waitpid(pid, NULL, 0);
-    int got_bursts = bursts;
-    printf("  detected bursts: %d\n", got_bursts);
-    if (got_bursts < 3) {
-        fprintf(stderr, "  FAIL: expected >=3 bursts, got %d\n", got_bursts);
-        return 1;
-    }
-    printf("  PASS (bind and toggle)\n");
-    return 0;
-}
-
-/* test unbind */
-static int test_bind_unbind(void) {
-    printf("Test: bind to channel 5, unbind, then toggle default (channel 0)\n");
-    pid_t pid = start_looper();
-    if (pid < 0) return 1;
-    jack_client_t *client;
-    jack_status_t status;
-    client = jack_client_open("test_unbind", JackNoStartServer, &status);
-    if (!client) {
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  SKIP: no JACK\n");
-        return 1;
-    }
-    jack_port_t *audio_out = jack_port_register(client, "out",
-                           JACK_DEFAULT_AUDIO_TYPE,
-                           JackPortIsOutput, 0);
-    jack_port_t *audio_in = jack_port_register(client, "in",
-                           JACK_DEFAULT_AUDIO_TYPE,
-                           JackPortIsInput, 0);
-    if (!audio_out || !audio_in) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        return 1;
-    }
-    safe_usleep(200000);
-    char my_out[64], my_in[64];
-    snprintf(my_out, sizeof(my_out), "test_unbind:out");
-    snprintf(my_in,  sizeof(my_in),  "test_unbind:in");
-    if (jack_connect(client, my_out, "looper:input") ||
-        jack_connect(client, "looper:output", my_in)) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        return 1;
-    }
-    /* Bind to channel 5 */
-    if (send_jack_note_on("looper:control", 64, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: send control key failed\n");
-        return 1;
-    }
-    safe_usleep(200000);
-    if (send_jack_note_on("looper:control", 5, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: bind to 5 failed\n");
-        return 1;
-    }
-    safe_usleep(200000);
-    /* Unbind (reset to 0) */
-    if (send_jack_note_on("looper:control", 64, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: control key for unbind\n");
-        return 1;
-    }
-    safe_usleep(200000);
-    if (send_jack_note_on("looper:control", 63, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: send unbind note 63 failed\n");
-        return 1;
-    }
-    safe_usleep(200000);
-    /* Now toggle with control+62 – should affect channel 0 */
-    if (send_jack_note_on("looper:control", 64, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: control key for toggle\n");
-        return 1;
-    }
-    safe_usleep(200000);
-    if (send_jack_note_on("looper:control", 62, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: toggle note 62\n");
-        return 1;
-    }
-    /* Wait for beep and loop */
-    int sr = jack_get_sample_rate(client);
-    continuous_sine = 0;
-    beep_remaining = (int)(0.1f * sr);
-    bursts = 0;
-    prev_above = 0;
-    passthrough_output_port = audio_out;
-    passthrough_input_port = audio_in;
-    passthrough_phase = 0.0f;
-    passthrough_freq = 440.0f;
-    passthrough_sample_rate = sr;
-    passthrough_total_samples = 0;
-    passthrough_sum_sq = 0.0;
-    passthrough_done = 0;
-    jack_set_process_callback(client, passthrough_process, NULL);
-    if (jack_activate(client)) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        return 1;
-    }
-    safe_usleep(200000); /* allow beep */
-    /* second control+62 -> loop */
-    if (send_jack_note_on("looper:control", 64, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: control key for loop\n");
-        return 1;
-    }
-    safe_usleep(200000);
-    if (send_jack_note_on("looper:control", 62, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: toggle for loop\n");
-        return 1;
-    }
-    safe_usleep(2000000);
-    jack_deactivate(client);
-    jack_client_close(client);
-    kill(pid, SIGTERM);
-    waitpid(pid, NULL, 0);
-    int got_bursts = bursts;
-    printf("  detected bursts: %d\n", got_bursts);
-    if (got_bursts < 3) {
-        fprintf(stderr, "  FAIL: expected >=3 bursts, got %d\n", got_bursts);
-        return 1;
-    }
-    printf("  PASS (unbind works, toggle channel 0)\n");
-    return 0;
-}
-
-/* test remove channel */
-static int test_remove_channel(void) {
-    printf("Test: dynamic channel removal via MIDI command\n");
-    pid_t pid = start_looper();
-    if (pid < 0) return 1;
-    jack_client_t *client;
-    jack_status_t status;
-    client = jack_client_open("test_remove", JackNoStartServer, &status);
-    if (!client) {
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  SKIP: no JACK\n");
-        return 1;
-    }
-    /* add channel */
-    if (send_jack_note_on("looper:control", 60, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: send note 60 failed\n");
-        return 1;
-    }
-    safe_usleep(1500000);
-    /* verify channel1_input exists */
-    const char **ports = jack_get_ports(client, NULL, JACK_DEFAULT_AUDIO_TYPE, 0);
-    int found = 0;
-    if (ports) {
-        for (int i = 0; ports[i]; i++) {
-            if (strstr(ports[i], "looper:channel1_input")) {
-                found = 1;
-                break;
-            }
-        }
-        jack_free(ports);
-    }
-    if (!found) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: channel1_input not created\n");
-        return 1;
-    }
-    printf("  channel1_input created\n");
-    /* remove channel */
-    if (send_jack_note_on("looper:control", 61, 127) != 0) {
-        jack_client_close(client);
-        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
-        fprintf(stderr, "  FAIL: send note 61 failed\n");
-        return 1;
-    }
-    safe_usleep(1500000);
-    /* verify channel1_input has disappeared */
-    ports = jack_get_ports(client, NULL, JACK_DEFAULT_AUDIO_TYPE, 0);
-    int still_found = 0;
-    if (ports) {
-        for (int i = 0; ports[i]; i++) {
-            if (strstr(ports[i], "looper:channel1_input")) {
-                still_found = 1;
-                break;
-            }
-        }
-        jack_free(ports);
-    }
-    jack_client_close(client);
-    kill(pid, SIGTERM);
-    waitpid(pid, NULL, 0);
-    if (still_found) {
-        fprintf(stderr, "  FAIL: channel1_input not removed after remove command\n");
-        return 1;
-    }
-    printf("  PASS (channel removed)\n");
-    return 0;
-}
-
 
 int main(void) {
     /* 1. binary must exist */
@@ -848,48 +427,18 @@ int main(void) {
     /* 3. Audio pass‑through test – must work for basic connectivity */
     test_audio_pass_through();
 
-    int failures = 0;
-
     /* 4. Test that looping feature is now implemented */
     if (test_looper_looping() != 0) {
         fprintf(stderr, "  FAILED\n");
-        failures++;
+        return 1;
     }
 
     /* 5. Test multiple dynamic channels */
     if (test_multiple_channels() != 0) {
         fprintf(stderr, "  FAILED\n");
-        failures++;
-    }
-
-    /* 6. Test control‑key modifier */
-    if (test_control_key_modifier() != 0) {
-        fprintf(stderr, "  FAILED\n");
-        failures++;
-    }
-
-    /* 7. Test bind channel */
-    if (test_bind_channel() != 0) {
-        fprintf(stderr, "  FAILED\n");
-        failures++;
-    }
-
-    /* 8. Test unbind */
-    if (test_bind_unbind() != 0) {
-        fprintf(stderr, "  FAILED\n");
-        failures++;
-    }
-
-    /* 9. Test channel removal */
-    if (test_remove_channel() != 0) {
-        fprintf(stderr, "  FAILED\n");
-        failures++;
-    }
-
-    if (failures > 0) {
-        fprintf(stderr, "%d test(s) FAILED\n", failures);
         return 1;
     }
+
     printf("All tests completed successfully.\n");
     return 0;
 }