I think most of his videos aged pretty well. The concepts mostly still apply, even though the GUI looks quite different in many places. But yeah, I mainly meant the shared buffer thing - his application in that video is also cool, but if you apply the same concept to a longer buffer, you basically already have a long-running looper that you can push audio into whenever you want.
I honestly thought this was rather basic stuff, but if there’s interest, I’m probably wrong. So let’s do it. The basic setup I had in mind to build a similar thing would be this:
Start by putting a “Dub Looper” unit into a channel (our recording channel). Set the channel input to one of the audio inputs and assign a new buffer to the Dub Looper (whatever length you want, but let’s say 10 seconds). You can now already record something into that buffer and have it played back (in case you don’t know how: first activate “engage”, then “punch” in to start recording and “punch” out again to stop recording). But we can’t pitch shift anything, and there’s certainly no control over grains, so what we’ll actually do is ignore the dub looper completely for sound generation and only use it for recording into the buffer.
Next we want the basic loop playback functionality with pitch shifting. I’d use the “Grain Stretch” unit for this. We’ll add it to the same channel behind the Dub Looper (or a different channel if you prefer it to have it’s own separate output, it does not matter). Set it to use the same audio buffer by going into the setup of the Grain Stretch and choosing “Select from Pool”, then pressing Enter to select the buffer. If you have already recorded something into the buffer, on the second step, you should already hear it being played back now. You can change both the speed of playback (via speed) and the pitch (via the 1v/oct control).
Now we want to add the granular engine for creating grains on top of the whole thing. Again, we can either separate it out to a different channel or (if we use our channels for other things or want it mixed anyways), we can also just add a “Mix” unit to the channel we’ve been working on and put our grain generation into that mixer channel.
We’ll use the “Manual Grains” unit. We’ll add it wherever we want (see above) and then set it up to use the same audio buffer that the Dub Looper and the Grain Stretch units are already using (same setup, “Select from Pool” + Enter). This unit basically plays back one grain at a time whenever it is triggered. In order to get it to do something interesting, we need to a) trigger it and b) manipulate it’s parameters
We’ll start with the trigger. What we do here depends on what we want to do with the whole device. Maybe you want to use something external to trigger grains (a sequencer? An oscillator? Something like Maths EOC?). Or you want to build it all inside the ER-301. Since the external part is easiest (just open the “trig” chain of the “Manual Grains” unit and set the input of that chain to be an external input (e.g. A1) and patch your trigger there), let’s consider two options for building it inside: using an oscillator with varying frequency to create “clouds” of tiny grains and using a clock to produce longer grains on divisions of a beat.
First off, an oscillator. Navigate into the chain of the “trig” input on the “Manual Grains” unit and add a “Aliasing Saw” unit there (you’d want a square wave oscillator, but the saw triggers it just fine and is part of the core libs). You should immediately start hearing grains being triggered (it might be hard to tell if this is actually the case depending on what is in your audio buffer). It’ll be a constant stream of identical grains at 27.5Hz. Not very exciting. To make it a tiny bit more interesting, you can add some sort of random modulation to the v/oct input of the “Aliasing Saw” unit. Again, I’d do this with Teletype, but I recommend checking out the “Pingable Scaled Random” unit from Accents to do it within the ER-301.
Alternatively, we can use a clock and trigger grains at divisions of that clock (or randomly, but only on divisions). To do that, we again get into the “trig” chain, delete the “Aliasing Saw” and instead add a “Clock (BPM)” unit. It has multiplier and divider controls so you can set it up to trigger at whatever rate you want (or sync it to an external clock using the “sync” input). If we don’t want it to trigger constantly, we could process the clock signal further, e.g. by adding a Lojik “Chance” unit behind it. Now we can set the chance that on a given clock pulse a grain will be triggered. Or you could put a sequencer here or whatever else you want. Everything in this chain is a great target for modulation.
But no matter how we trigger the grains, they still all sound the same and that’s quite boring. So we want to add modulation to the parameters of the “Manual Grains” unit. Of course, you can do whatever you want here. But for the sake of the explanation, let’s go with something incredibly simple: Just randomize everything
Again, we’ll use the “Pingable Scaled Random” unit from Accents here. Just open a parameter chain on the “Manual Grains” unit (e.g. “start” to influence the position of playback of the grain), drop a “Pingable Scaled Random” unit in there, navigate into the “trig” chain of that unit and set the chain input. Since we want each grain to have different parameters, we’ll just use the trigger we’re generating to start grains. In order to do that, open the menu to set a chain input and then select “Locals” on the smaller screen on the bottom. Now you should see the units in the chain we’ve created so far. Move the encoder to select the “trig” input of the “Manual Grains” unit and press enter to confirm. Now the “Pingable Scaled Random” unit will create a new value for each grain. All that is left to do is to navigate up and set the gain parameter of the chain such that the random values actually influence the parameter we want to modulate. Rinse and Repeat for all parameters (you can also copy the “Pingable Scaled Random” unit you created inside the first channel and simply paste it into the other channels - that way you don’t have to redo the routing.
This (with some tweaking of the parameters to taste) should already get you quite close. It should at the very least give you a starting point and a lot of ideas on what to do with this.
Additional things that could be done to improve upon this:
- Recording probability, delay, etc. This can all be accomplished by putting some devices into the chain controlling the “Punch” of the Dub Looper. For example, you can put in a square wave (or a clock) and add some logic behind that. Personally, I’d simply control this sort of thing with Teletype, so I never put in a lot of effort into figuring out how to do this within the ER-301. But it should be rather easy using all the cool units in Accents and Lojik (particularly Chance and Latch/TLatch seem like they would make a solution easy)
- Add quantization to scales. There’s a great quantizer in the core lib that you can just add to the 1v/oct chains of both the Grain Stretch and the Manual Grains unit.
- Add slices to the buffer (you can use slices on any buffer, not just prerecorded samples) and use those to skip around with the looper if you like.