boomjacky/looper
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

feat: implement loop recording and playback with integration test

Browse Source 
Co-authored-by: aider (deepseek/deepseek-reasoner) <aider@aider.chat>
This commit is contained in:
Loic Coenen
2026-05-07 21:41:36 +00:00
parent 944608ad7f
commit d4b3c2334b
2 changed files with 252 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

182
tests/integration.c
View File

@@ -20,6 +20,11 @@ static long passthrough_total_samples = 0;
static double passthrough_sum_sq = 0.0;
static volatile int passthrough_done = 0;
/* The test code uses this callback in two ways:
- For the audio passthrough test (existing function) it still works.
- For the loop test we need a version that respects the static variables
beep_remaining and bursts (declared in test_looper_looping).
We change the existing function to also handle those globals. */
static int passthrough_process(jack_nframes_t nframes, void *arg) {
(void)arg;
jack_default_audio_sample_t *out =
@@ -30,10 +35,30 @@ static int passthrough_process(jack_nframes_t nframes, void *arg) {
float *outf = out;
const float *inf = in;
for (jack_nframes_t i = 0; i < nframes; i++) {
float val = sinf(passthrough_phase);
outf[i] = val;
passthrough_phase += 2.0f * (float)M_PI * passthrough_freq / passthrough_sample_rate;
if (passthrough_phase > 2.0f * M_PI) passthrough_phase -= 2.0f * M_PI;
/* generate beep while beep_remaining > 0 */
extern int beep_remaining; /* defined in test_looper_looping */
float out_val;
if (beep_remaining > 0) {
out_val = sinf(passthrough_phase);
passthrough_phase += 2.0f * (float)M_PI * passthrough_freq / passthrough_sample_rate;
if (passthrough_phase > 2.0f * M_PI)
passthrough_phase -= 2.0f * M_PI;
beep_remaining--;
} else {
out_val = 0.0f;
}
outf[i] = out_val;
/* detect bursts on the input (looper output) */
extern int bursts;
extern int prev_above;
float sample = inf[i];
int above = (fabsf(sample) > 0.05f);
if (above && !prev_above) {
bursts++;
}
prev_above = above;
passthrough_sum_sq += (double)inf[i] * (double)inf[i];
passthrough_total_samples++;
}
@@ -305,6 +330,146 @@ static void test_looping_not_implemented(void) {
printf(" SUCCESS: nothing was measured (looping feature not implemented)\n");
}
/* Helper: open a transient JACK client, send a MIDI note‑on, close */
static int send_jack_note_on(const char *target_port, unsigned char note, unsigned char velocity) {
jack_client_t *trig;
jack_status_t st;
trig = jack_client_open("test_midi_trig", JackNoStartServer, &st);
if (!trig) return -1;
jack_port_t *port = jack_port_register(trig, "out",
JACK_DEFAULT_MIDI_TYPE,
JackPortIsOutput, 0);
if (!port) { jack_client_close(trig); return -1; }
if (jack_activate(trig)) { jack_client_close(trig); return -1; }
char src[64];
snprintf(src, sizeof(src), "test_midi_trig:out");
if (jack_connect(trig, src, target_port)) {
jack_client_close(trig);
return -1;
}
usleep(200000);
jack_nframes_t now = jack_frame_time(trig);
jack_midi_data_t data[3] = { 0x90, note, velocity };
jack_midi_event_write(port, now, data, 3);
usleep(100000);
jack_deactivate(trig);
jack_client_close(trig);
return 0;
}
/*
* Full loop recording test:
* 1. start looper
* 2. open test client (audio + MIDI)
* 3. send note‑on to move IDLE->RECORD
* 4. generate a short 440 Hz beep (~0.1 s) while recording
* 5. send note‑on to move RECORD->LOOPING
* 6. monitor looper output for the beep being repeated (≥3 times)
*/
static int test_looper_looping(void) {
printf("Test: loop recording and playback (expect ≥3 repetitions)\n");
pid_t pid = start_looper();
if (pid < 0) return 1;
jack_client_t *client;
jack_status_t status;
client = jack_client_open("test_looping", JackNoStartServer, &status);
if (!client) {
kill(pid, SIGTERM); waitpid(pid, NULL, 0);
fprintf(stderr, " SKIP: JACK not running?\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;
}
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");
snprintf(my_in, sizeof(my_in), "test_looping: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;
}
/* state variables used by the process callback */
static volatile int beep_remaining = 0;
static volatile int bursts = 0;
static volatile int prev_above = 0;
/* first note‑on: IDLE -> RECORD */
if (send_jack_note_on("looper:control", 1, 127) != 0) {
jack_client_close(client);
kill(pid, SIGTERM); waitpid(pid, NULL, 0);
return 1;
}
usleep(200000); /* allow state to change */
int sr = jack_get_sample_rate(client);
beep_remaining = (int)(0.1f * sr); /* 0.1 second beep */
bursts = 0;
prev_above = 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;
}
/* override the global passthrough callbacks to generate beep and detect bursts */
/* We'll embed detection inside a helper that we set via static pointer. */
/* For brevity, we modify the passthrough_process static to check global flags.
We add the beep generator and burst detector inside passthrough_process. */
/* The existing passthrough_process already writes a sine to its output port,
but does not use beep_remaining. We'll replace it with a version that
respects beep_remaining and also counts bursts on the input (looper output). */
/* We'll directly overwrite the static function pointer? Instead, we'll
modify the function definition later. For now we trust that the
existing passthrough_process will be adapted (see code change below). */
usleep(150000); /* let beep start */
/* after beep finishes, give it a moment then send note‑on to stop recording */
usleep(500000);
beep_remaining = 0;
if (send_jack_note_on("looper:control", 1, 127) != 0) {
jack_client_close(client);
kill(pid, SIGTERM); waitpid(pid, NULL, 0);
return 1;
}
/* wait enough time for several loops (3 seconds) */
usleep(3000000);
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 (at least 3 repetitions)\n");
return 0;
}
/*
* Helper: run all MIDI‑based state transition tests.
* Requires jack_midi_send; if missing these tests are skipped.
@@ -339,9 +504,12 @@ int main(void) {
/* 3. Audio pass‑through test – must work for basic connectivity */
test_audio_pass_through();
/* 4. Test that looping feature is missing (expected) */
test_looping_not_implemented();
/* 4. Test that looping feature is now implemented */
if (test_looper_looping() != 0) {
fprintf(stderr, " FAILED\n");
return 1;
}
printf("All tests completed successfully (missing features noted).\n");
printf("All tests completed successfully.\n");
return 0;
}