Thanks for the response.
Yea I started some generic C++ courses and I see that there's now a C++ course in the Bela forum.
Definitely will take a look and start experimenting soon.
In regard to the convolution aspect of it: could you point me to any resources there? I guess don't fully understand how it works in theory
zillaomg In regard to the convolution aspect of it: could you point me to any resources there? I guess don't fully understand how it works in theory
I struggled with this in my undergrad studies and the lightbulb didn't really come on until I tried to implement a DSP convolution algorithm -- then everything fell into place and made it easier to understand the continuous time convolution as well.
I have been searching the webs for a good intuitive explanation because it is a fairly simple concept that has been over-complicated by academics. I found one that I thought particularly good for just understanding the principle:
https://aha.betterexplained.com/t/convolution/679
Wikipedia includes the formal definition and a lot of different sections describing mathematical properties and its applications, as well as some good animations, but there is also a lot to digest there.
https://en.wikipedia.org/wiki/Convolution
A couple quick tips:
1) Consider and understand the concept of a system's impulse response.
2) Consider that every continuous and discrete time signal can be thought of as an impulse train, in which the impulses are spaced closely (infinitesimally close for continuous time, or on intervals of sampling period for discrete time), and scaled by different values forming the base function.
Eyyyyy
So coding in C++ was a bit overwhelming for me but I did get a decent version going in Super Collider.
Code is here if anyone's interested. Am new to text based coding so any general practice/logic/tidyness tips
are appreciated.
I ended up using a wrapper for PartConv for convenience.
(
s = Server.default;
// Set up options for the Bela
s.options.numAnalogInChannels = 2;
s.options.numAnalogOutChannels = 2;
s.options.numDigitalChannels = 0;
s.options.maxLogins = 4;
s.options.blockSize = 16;
s.options.numInputBusChannels = 2;
s.options.numOutputBusChannels = 2;
~newpreset;
~impulse = "./cello.wav";
~ezConv = EZConv(~impulse, fftSize: 512);
s.waitForBoot {
//drysignal
{
var dry;
dry = AnalogIn.ar(1) * 0.77;
SoundIn.ar(0) * dry;
}.play;
//synthdef for convolution
SynthDef(\wet, { |out|
Out.ar(out, SynthDef.wrap({
~ezConv = EZConv(~impulse);
~input = SoundIn.ar(0);
~blend = AnalogIn.ar(1) * -0.55 + 0.55 * ~input ; // input * blend pot
~ezConv.ar(~blend, mul: 0.5);
}))
}).add;
~wet = Synth(\wet);
//re-run this task when changing impulses
~task = Task({
1.do({arg i;
~wet.free;
~ezConv.free;
~ezConv = EZConv(~impulse, fftSize: 512);
~wet = Synth(\wet);
0.25.rrand(0.75).wait;
})
});
//reading analog in from server and sending to client
~ctrl = {
var a0 = AnalogIn.kr(0);
SendReply.kr(Impulse.kr(10), '/ctrl', [a0]);
}.play;
~preset = 1.0;
~currentpre = 0;
OSCdef('listen', {arg msg;
~preset = msg[3].linlin(0.0, 1.0, 0.0, 1.0).trunc(0.07);
// [~preset].postln; // used for testing
// this is the case loop that evaluates the analog in and changes the impulse depending on value
p = ~preset;
x = case
{ (p <= 1) && (p >= 0.97) && (p != ~newpreset)} { y = 1; ~newpreset = p; y.postln; ~impulse = "./cello.wav"; ~impulse.postln; ~task.reset; ~task.resume;}
{ (p <= 0.90) && (p >= 0.81) && (p != ~newpreset)} { y = 2; ~newpreset = p; y.postln; ~impulse = "./cymbal.wav"; ~impulse.postln; ~task.reset; ~task.resume;}
{ (p <= 0.77) && (p >= 0.70) && (p != ~newpreset)} { y = 3; ~newpreset = p; y.postln; ~impulse = "./opera.wav"; ~impulse.postln; ~task.reset; ~task.resume;}
{ (p <= 0.66) && (p >= 0.55) && (p != ~newpreset)} { y = 4; ~newpreset = p; y.postln;}
{ (p <= 0.50) && (p >= 0.40) && (p != ~newpreset)} { y = 5; ~newpreset = p; y.postln;}
{ (p <= 0.37) && (p >= 0.25) && (p != ~newpreset)} { y = 6; ~newpreset = p; y.postln;}
{ (p <= 0.20) && (p >= 0.12) && (p != ~newpreset)} { y = 7; ~newpreset = p; y.postln;}
{ (p <= 0.09) && (p >= 0) && (p != ~newpreset)} { y = 8; ~newpreset = p; y.postln;}
}, '/ctrl');
}
)I have pushed a neon-based convolver to dev right now : https://github.com/BelaPlatform/Bela/tree/dev/
See the new library libraries/Convolver and the example Audio/convolver.
Thanks Giulio, works great straight away!
ideal for acoustic resonance IR's (it's doing great with bowed string impulse responses) and guitar cabs etc. I find those uses of convolution work better with IR no longer than 50ms, otherwise they start to noticeably smear the time domain. With a 50ms IR and 16 sample buffer it's using 25% cpu and great that it causes no extra latency.
I guess the main use for longer convolution would be reverb.
Seems to me that latency is not such an issue with reverb. Real spaces always have pre-delay, consider standing 5 metres from the nearest wall, that's about 15ms pre-delay. We'd be able to use longer IRs with frequency domain convolution at the cost of latency. Could it not make sense to deliberately give frequency domain convolution say 5ms to process and make that time up by chopping 5ms from the start of the IR (it would be silence anyway!)
I know that workaround may not be great for things like Zillaomgs cymbal IRs but seems like a solution for convolution reverb
