I tried just calling calculate_tempo_frames() from the jack timebase callback in jack_audio_driver in lieu of setting transport info, but I don’t think that’s the right approach. I need to be fixing the calculation for giving JACK the right transport info. The Engine::calculate_tempo_frames function doesn’t yield BBT info. So I need to dig in and figure out how that information is calculated in the engine, and glue that to the transport callback. It think it’s in Engine::set_tempo, and I already see some possibilities.

The bug occurs when quantization is set to 8th as opposed to cycle, this reminds me. Note to self, verify that and finish writing out the conditions the trouble appears under in the first place.

Despite the fact that I knew the test was for remembering quantization boundaries after tempo changes when sooperlooper is JACK timebase master, I proceeded to write it as if I was testing sooperlooper’s performance with the loop stretching. Haha, sometimes brains just won’t get unstuck (well, mine at least).

This code will eventually not be one test, but I’m writing it all in one blob at first just to get my thoughts out and to experiment. I’ve had a lot of fun writing this, and just like I predicted it has really forced me to learn some of the the boring how-to-glue-it-together parts of supercollider instead of pasting code for weird noises in and then playing my guitar for an hour.

I still intend on a blog post describing the exact thing I’m trying to fix in sooperlooper, and how I intend to fix it. Incidentally, I found a couple other interesting little bugs to fix when there’s time. You can’t set the tap tempo over OSC. I found a place where it had been commented out (can’t remember where), and when I uncommented and recompiled, sooperlooper responded to the OSC tap-tempo message with a segfault. I sense somebody’s been down this road before… 😀

No matter. I used MIDI instead for now and put that on my list for later.

Here’s what I have so far:

// 1. Start an instance of the sooperlooper engine
// 2. create 8 loops
// 3. set playback sync, sync, and timestretch on all loops
// 4. make sooperlooper timebase master
// 5. set the tempo TODO
// load a soundfile into each loop AND/OR record a pattern into each loop
// -- this will be a simple bleep or bloop, something that can be detected
// -- or a breakbeat.
// TESTING LOOP STRETCH (no reason, it works perfectly. What's up with my brain?):
// send tap-tempo signal to change up the tempo a bunch.
// listen to test events and record whether they happened at the time expected. Try to do this
// automatically, signal detection.
// It'll probably work just fine.
// After some tempo changes, try to record or overdub. While doing so, query
// the loop states over OSC. See if they change when we took the action or if
// they got stuck or mistimed. (I remember, they used to get stuck). okay,
// how do I test when it records? OSC docs.

//################# SETUP ###############
~engine = NetAddr.new("localhost", 9951);

"sooperlooper &".systemCmd();

SystemClock.sched(2.0, {

8.do({~engine.sendMsg("/loop_add", 1,1)});

// Global settings
~engine.sendMsg("/set", "sync_source", -1);
~engine.sendMsg("/set", "smart_eighths", 0);
~engine.sendMsg("/set", "jack_timebase_master", 1);
~engine.sendMsg("/add_midi_binding", "0 on 55 set tap_tempo -2 0 1 norm 0 127");

~engine_midi = MIDIOut.findPort("sooperlooper-sooperlooper", "sooperlooper-sooperlooper");

for (0,7, {arg i; ~engine.sendMsg(format("/sl/%/set", i), "sync", 1)});
for (0,7, {arg i; ~engine.sendMsg(format("/sl/%/set", i), "playback_sync", 1)});
for (0,7, {arg i; ~engine.sendMsg(format("/sl/%/set", i), "tempo_stretch", 1)});
for (0,7, {arg i; ~engine.sendMsg(format("/sl/%/set", i), "relative_sync", 1)});
for (0,7, {arg i; ~engine.sendMsg(format("/sl/%/set", i), "quantize", 2)});
for (0,7, {arg i; ~engine.sendMsg(format("/sl/%/set", i), "mute_quantized", 1)});
for (0,7, {arg i; ~engine.sendMsg(format("/sl/%/set", i), "overdub_quantized", 1)});


~player = Routine({

// No idea why 0.exit() works or whether it's the best convention, but this allows
// me to just run this code like a script and not have the sclang interpreter
// just hanging around

SystemClock.sched(5.0, {"pkill sooperlooper".systemCmd(); 0.exit(); nil;});

I’m trying to fix an esoteric problem with Sooperlooper keeping track of quantization over tempo changes when it’s also JACK transport master. It performs pretty well with time-stretching the loops, but it totally loses track of where the quantization boundaries are if you change the tempo. With loops, those milliseconds really add up after a few repetitions until things sound mega borked, so I rely heavily on the looper’s ability to not start recording until the next boundary even if I tap the button just a tad early like some kind of human or something.

(An aside, I’m almost positive this unmodified example code in jack_audio_driver.cpp is the problem. I will describe my hypothesis about exactly how the malfunction functions in another blog post — this one is reserved for describing my testing plan).

So, I spent all afternoon yesterday tediously trying to manually reproduce the issue, just to get it fresh in my mind again. I totally forgot about the quantization part of the problem and neglected to test it, and I was spinning my wheels running two instances of the engine (one with my changes and the other without) and manually connecting the GUI to either one, clicking buttons to set the settings. Having forgotten to test the quantization, I was confounded at the parity between the two versions’ performance as I tapped on the ‘t’ key at varying intervals. Yep, I forgot what bug I was even trying to fix. Lawl. What a mess.

I do actually do this for a living, so why the hell wouldn’t I have written some sort of test for it already?

“Eh, something something it’s a loopstation how would I test live audio and all that, it seems like more trouble than it’s worth.”

Okay. Fair enough. I am a green dev. So I’m trying to fix this minor malfunction in Sooperlooper, and I don’t know how to test it and I’m still learning C++ and reading the codebase and I have a day job and I’m not getting very far on this and I still wanna build my magical rig, so lately I’m also playing a lot with SuperCollider.

Hey! Supercollider is designed for audio and has its own internal timing mechanisms. It also talks OSC and MIDI. I can control Sooperlooper, I can send it audio, I can analyze the audio it returns! I have seen (and even partially understood!) code examples which do all of these things. And I need a beginner project.

This is perfect. I will write an automated test for this part of Sooperlooper in SuperCollider. I’ll bet you I can write the whole thing that way, even starting the engines. I can dispense with the GUI entirely. I can configure all the loops and settings, I can tell Sooperlooper to load files over OSC. Aw man, this is fucking RAD.

The timing is great. I’ve just recently started to understand busses and groups and how to route audio in SC, but I’m still looking for the exercise that will force me to understand how to wrangle the language toward a complex end goal. This is it.

Due to this realization, I’m very happy.

Just some notes to myself for later.

Sooperlooper builds if I do like the patch file in the AUR package for sooperlooper does, and change all the includes for sigc++/object.h to sigc++/trackable.h

I’m going to want to research why that is, and whether that change breaks the build on other platforms. For now, I’m gonna get it building so I can start playing with the bugs I actually intended to tackle.

I also have to use these options to ./configure:

CPPFLAGS=-std=c++11 ./configure \
--prefix=/usr \