Why Your Synth Keeps Clicking (And How To Fix It)

[00:00:00] why your synthesizer keeps clicking. So this video is about having these annoying click sounds or
[00:00:05] crackle sounds sometimes when you play a synthesizer or a sampler. I want to explain to you why it
[00:00:11] happens and how to solve it. And it's also not bitwig-specific, so you can also watch this with
[00:00:16] Ableton Live or with Logic and then find some of your own solutions in these kind of environments.
[00:00:23] So what's the problem? So I want to play here certain sounds with the synthesizer,
[00:00:28] monophonic synthesizer and I have here a sine oscillator, I have an amplitude envelope,
[00:00:32] an oscilloscope and an audio output. So it's very simple synthesizer setup. And when I play here
[00:00:38] some notes on the keyboard, especially low sounds, right, you can hear these kind of crackles in the
[00:00:54] beginning when I press a key. It's very annoying. Sometimes you want exactly that when you make
[00:01:00] kick drums for instance, but most of the times you don't want it to happen if you play some ambience
[00:01:06] and you know some nice little melodies and you have these sine partials and every now and then
[00:01:10] you get some clicks. It's very annoying. So what's the problem here? So I want to show you this here
[00:01:16] in the oscilloscope. I use a gate input module and hook this up here to the oscilloscope. So every
[00:01:24] time I press a key on the keyboard, it just freezes the visuals here of the oscilloscope.
[00:01:31] So the first problem you can see here when I press a key on the keyboard
[00:01:37] is that the sine oscillator starts off center. So it's not starting at zero or in the middle
[00:01:45] of the oscilloscope here, right? So it starts off center. And you can see here the sine oscillator
[00:01:50] itself doesn't have a retrigger enabled. So it's just running freely, which means when I
[00:01:56] hook this up here to the oscilloscope itself, you can see it just runs. It starts somewhere
[00:02:02] and it just runs forever. And the only thing that happens that prevents it from outputting here to
[00:02:09] the audio output is basically the ADSR amplitude envelope. So it's just a free running playing
[00:02:17] oscillator and the amplitude envelope here just fades in the audio and fades out the audio,
[00:02:22] which also means we have no influence over when and how the sine oscillator retriggers.
[00:02:31] Okay, so it's just starts somewhere inside of the oscilloscope. So sometimes it starts at zero,
[00:02:38] sometimes here, sometimes here. So it depends on when I press a key. You can see it's all over the place.
[00:02:46] Right? And this gives you these kind of crackles. So when we hit here restart or when we enable
[00:02:53] restart on the oscillator, we restart the oscillator every time we press a key.
[00:03:00] So now we can see consistently we start at minus one, because you also can see this here on the
[00:03:07] graph on the oscillator itself, it starts at minus one. This is just a waveform. This is how the
[00:03:14] lookup table of the oscillator looks like. So, yeah, right off the bat, we get bad sounds.
[00:03:24] Every time we press a key, we get a crack or click. And sometimes that's exactly what you want
[00:03:33] when you make, for instance, kick drum sounds or bass sounds and you want to have a bit of smack in
[00:03:38] the attack. You get it this way, pretty free or for free. So this time we don't want it. So how do
[00:03:45] we prevent it? And we can do this here by just offsetting the phase of the sine oscillator.
[00:03:52] In between it works by using here a constant. So this one, this module just outputs a constant
[00:03:59] of one, number one, and then we do here 25% on the phase input, which means we just offset the whole
[00:04:08] graph by 25%. You can see here the graph when we zoom in, it starts at minus one. Then here in the
[00:04:15] middle, it's, of course, 50%. There's 100% and here between zero and 50% is 25%, because we want to
[00:04:22] start here exactly at zero. So we can do this here by inputting one and then using 25% on the phase
[00:04:29] input knob, or we can input a constant of 0.25 and use here 100%, it's just the same thing.
[00:04:39] So with this, we constantly now restart the oscillator exactly at zero, at a zero crossing.
[00:04:47] So this gives you no crackles. Right? Pretty dope. But when you play multiple notes very quickly,
[00:05:01] you get crackles again. Why is that? Do this here. Maybe it's too long.
[00:05:14] You can see this here. We play the first note. It plays from the beginning from zero,
[00:05:19] very smooth sine wave here. And then we retrigger in midst of the phase. So the phase happens to be
[00:05:29] here at this point when we press the key on the keyboard again. And then the thing does here a
[00:05:36] movement from +1 back to -0. So it switches back to zero. So why does this crackle actually?
[00:05:45] What's the problem here? Why does it produce a crackle? And the explanation is pretty easy.
[00:05:49] What you can see here on the screen is actually what your speaker cone does in real life. So it
[00:05:56] moves out and in of your speaker or the cone or the membrane moves out and inwards all the time.
[00:06:06] But when you do hear this very steep movement from going to the most outward position back to
[00:06:14] the initial zero position, it gives you this kind of crackle. It's actually what your speaker cone
[00:06:20] produces. So this is why it crackles all the time. So we want to prevent this. And people sometimes
[00:06:28] prevent this by using just a small little attack on the amplitude envelope just to fade in here.
[00:06:37] You can see this here. It's smoothly fades in.
[00:06:39] But sometimes it's not enough when you press your multiple keys. You can see
[00:06:48] also when you do hear a small little release time.
[00:06:53] Maybe bring also the signal of the amplitude into the oscilloscope. It's okay when I re-trigger.
[00:07:07] Ah, another one. This one. Okay. So here we press the first key and then we quickly press the second
[00:07:14] key. And what happens here is we switch back to zero. So we never finish the release time, right?
[00:07:21] So we press a key. We are here. And then we release the key. And then we quickly after that press
[00:07:28] another key again. So we never finish actually the release time, which makes it happen to fade
[00:07:35] out the audio. So we jump from here back to here, right? So we have never had really having this
[00:07:43] release time here fading out the audio very smoothly. So this never happens when you press
[00:07:49] key keys pretty quickly one after the other. And yeah, that's kind of a problem. So the solution
[00:07:57] in most synthesizers is that we switch from monophonic which is just one voice to a digi
[00:08:06] mono or whatever this is called. What's it saying? A monophonic playback with two alternating voices
[00:08:14] envelopes will always re-trigger from zero and note input is required to make each voice sound
[00:08:22] saving CPU. So this is a pretty technical explanation. But what it does is it's
[00:08:28] just launching two voices. So you press the first key, you press, you play basically this part here.
[00:08:35] And then when you re-trigger, so quickly release and quickly press again, we actually play this old
[00:08:42] voice the release time until it finishes. But at the same time, we start a second voice and start
[00:08:49] from zero. So when I show you this here on on a graph, I want to show you this, we have the first
[00:08:55] voice. This is probably active. You have an oscilloscope here and you start from zero
[00:09:01] and you play and you play. Then at some random point you decide, oh, let's play another note,
[00:09:07] right? And then it starts the release phase. So this phase here, because you release the key,
[00:09:15] and it goes down and fades slowly out. And because you press another key again, so you release and
[00:09:23] then you press again, we start here, but on a second voice. And exactly at this point here,
[00:09:31] when here the release time starts, we start here at zero again and play another sign partial.
[00:09:40] So this prevents everything from clicking because this is smoothly fading out while this sound
[00:09:46] plays. So we have kind of a crossover. So we fade from one sound to the other sound,
[00:09:52] but it needs to have two voices. And this also never happens here when you actually use polyphonic
[00:09:59] voices or multiple voices. Of course, you can always alternating between different voices. You
[00:10:04] play another key and the old voice slowly fades out in the background while you're playing a new
[00:10:10] sound on a new voice. That's why it never clicks properly on a polyphonic synthesizer when you
[00:10:18] start a sign partial from zero. It can click when you, of course, you never retrigger and you never
[00:10:25] retrigger from a zero crossing point, then it clicks also. So yeah, this is how you solve the
[00:10:34] problem. But sometimes you need to have this problem solved in a monophonic environment
[00:10:41] because you only have maybe one voice at your disposal. Maybe you want to create a
[00:10:47] generative patch or you have a very old monophonic synthesizer or whatever. So here you can solve
[00:10:55] this also in a monophonic way. So how do we do this? We just make sure that this release phase
[00:11:03] here is playing before you start a new envelope or a new envelope sequence. We can do this with
[00:11:13] the logic delay in Bitwig at least. It looks like this and it can delay certain movements in the
[00:11:21] signal. So here we have only upward movements in the signal. So when I press basically here,
[00:11:28] the key on my keyboard, every time I press here, it goes up to one and when I release the key,
[00:11:36] it goes back to zero. So it can really replicate what I'm doing on my keyboard. So here I'm pressing
[00:11:45] a key, here I'm releasing a key. But what we want to delay is only the upward movement. So when I
[00:11:51] press the key, that's what I want to delay. Why? Because I want to wait until this release
[00:11:57] sequence here is finished and then I want to press or go up again. So this is the idea. I'm
[00:12:05] delaying the upward movement until this release time is finished. And we can really dial this in
[00:12:11] here. We can say release time is exactly 10 milliseconds long. So I need to wait for 10
[00:12:18] milliseconds before I restart a new thing. I can do maybe 20 milliseconds. It doesn't matter.
[00:12:27] But for that, we need to actually disable here the precode because we want to use a delay on the
[00:12:34] gate input. We can use here the gate input. And we also want to delay the sign oscillator
[00:12:45] retriggering because also the release here needs to finish before we switch the oscillator back
[00:12:54] to zero. Okay. It's a bit complicated now, right? Okay. Anyway, so with this setup now, just delaying
[00:13:05] the amplitude envelope retriggering until the release time is finished. Okay. So now I can do this here
[00:13:11] and press multiple keys. And you can see it waits here basically for the thing to finish.
[00:13:19] Also important here, the amplitude envelope has a digital mode, which is called digital
[00:13:24] with exact timing. Usually it's on analog here, which sounds a bit better maybe.
[00:13:32] But when you dial in digital here, 10 milliseconds are really 10 milliseconds and also here
[00:13:39] 10 milliseconds for one thing. So instead of me triggering on the keyboard, I want to use here
[00:13:46] a quick setup to simulate when I really trigger very fast on my keyboard.
[00:13:59] So this is not needed here. It's just me simulating
[00:14:03] my very fast triggers. It makes this a bit faster. So you can see it here on the scope.
[00:14:13] When I retrigger, I can make this a bit longer. Let's make it a bit longer so you
[00:14:21] can see it better. So 30 milliseconds release time. So we need to wait 30 milliseconds here
[00:14:28] for the next retrigger. You can see it's much smoother there.
[00:14:31] Yeah. So it waits here for the release time until it finishes. Then it retriggers here again.
[00:14:42] Maybe go here also for 20, 30. Yeah, much, much better. But this is already pretty slow,
[00:14:53] 30 milliseconds. And when you need to dial in here, it's 40 now.
[00:14:58] When you need to have a delay of 40 milliseconds, because remember when you press the key on the
[00:15:05] keyboard, the whole setup waits for 40 milliseconds until it actually triggers the synth itself,
[00:15:14] just because of the release time. So you don't want to have this too high. So 40 milliseconds
[00:15:21] is pretty long. So you can probably feel this when you play it on the keyboard. So you want
[00:15:27] to keep it low, maybe at 20 or 10 milliseconds. But I want to show you this here, how it works.
[00:15:33] So here then you can see the sign is slowly fading out. So we have not this instant movement back
[00:15:40] to zero. This is what we want to prevent from happening, because this is creating this kind of
[00:15:46] crackle thing. So yeah, when we just here, go back to our initial preset. So I can trigger
[00:15:55] this with my keyboard. Let's play it with the sound.
[00:16:00] You can see there is no crackling happening, even though we press the keys pretty fast.
[00:16:15] What I would say 40 milliseconds is too much. Let's let's try it out here with 10 milliseconds.
[00:16:20] But you can see this is a problem that you can't solve without having a fade in or fade out.
[00:16:28] It's just not possible because the synthesizer doesn't know when you press a key the next time.
[00:16:36] It's just you have to look into the future, right? And we look into the future here and
[00:16:42] this set up by just delaying everything else by 10 milliseconds. So we have a bit of time.
[00:16:48] Yeah, this is also okay.
[00:16:51] Smooth as a baby's ass. Okay, so this setup prevents you from clicking in a monophonic setup just with
[00:17:04] one oscillator here. And you can also use this of course in a generative patch where you want to
[00:17:10] generate multiple nodes here with the triggers module or the gates module or whatever. You can
[00:17:16] re-trigger everything pretty fast and you never get any crackles. That's the point of it.
[00:17:22] Another setup that someone asked today was with the recorder. So sometimes you sample something
[00:17:29] instead of having a sine oscillator here. You have just something sampled in here and you also need
[00:17:36] some fade in and fade outs. So here the delay you probably want to also do this here with the playback
[00:17:47] and recording. Let's use a button here.
[00:17:58] And maybe use a sign, some sign here for the recording. So yeah, you re-trigger this.
[00:18:10] You can hear there's also some kind of crackling happening. So you probably need a bit more.
[00:18:21] 20 milliseconds here and you also probably need to finish here this playback because it's just
[00:18:32] when I release the key, it just stops playing. So we need to delay actually also the playback. So
[00:18:42] it plays further. So the amplitude envelope here has time to fade it out. But you can't fade anything
[00:18:49] out when it stops playing before the release is finishing, right? So this is another problem.
[00:18:55] So to solve this, we need to have here the logic delay actually only acting on the recorder for
[00:19:02] now. And we delay also on both directions. So when we release the key, the recorder keeps playing
[00:19:10] for 10 milliseconds longer. So the release time here also plays for 10 seconds longer because
[00:19:16] release time itself is 10 milliseconds long. And if you use a second logic delay here,
[00:19:22] but only upwards delaying for the ADSR. Something like this. So this is the setup. So now we can
[00:19:30] play here and then we press stop or release. You have your nice smooth fade out.
[00:19:41] You can make this a bit longer maybe here for 30 milliseconds so you can maybe see it.
[00:19:47] Yeah, but it's not going to work because we have here also 10 milliseconds so we need 30 there.
[00:20:04] Oh, we need also have 30 here. You can see it also here on the oscilloscope.
[00:20:15] You have a nice smooth fade in also nice smooth fade out. And it prevents you from having these
[00:20:22] clicks and pops and whatever you want to call it. Yeah, from happening. So yeah, this is my solution
[00:20:30] for monophonic patches. You can solve most of the stuff in synthesizer by just using like I said
[00:20:36] here multiple voices to here in bitwig or polyphonic voices because you have then multiple voices
[00:20:44] just alternating and smoothly fading from one voice to the other voice and it's pretty easy to solve.
[00:20:53] But sometimes you need to keep these monophonic setups here and you still want to have
[00:21:00] these pops and clicks removed. So this is the solution for that. Yeah, but the recorder and of
[00:21:05] course with the oscillator in sometimes also with the delay and stuff where you just resample and
[00:21:13] retrigger and you want to have these nice little smooth fade overs. Okay, at the end I want to
[00:21:21] give you here a quick idea for this setup. When you have a sine oscillator and we go here maybe
[00:21:32] again into an oscilloscope. And you can see here we have crossover right and my thinking was at
[00:21:39] some point why not use a logic here right and this compares it basically with zero. So when the input
[00:21:49] here the sine oscillator input is zero which happens only here on the zero crossing then give me a
[00:21:56] gate. So let's try this. You can see nothing happens there. You can switch to your exact
[00:22:03] matches nothing happens. So yeah it's kind of a problem when this would work easily then you could
[00:22:11] say I only want to retrigger when the phase is zero only then allow me to trigger the amplitude
[00:22:19] envelope. There are some tricks you can do to make this happen here you can use a bend and then you
[00:22:26] get at some point the two phases here right. Every yellow line is basically a zero crossing.
[00:22:34] What we do basically for this is bending here the waveform it looks like this. Make the zero line
[00:22:41] a bit more prominent so the logic device has a bit more time to get used to it or whatever.
[00:22:49] Yeah this kind of works. Exact matches also doesn't work but when you have this set up here
[00:22:56] you get the trigger every time we have a zero crossing then you can do an ad
[00:23:01] an amplitude envelope and only trigger this. So we use a gate input. Oops gate input.
[00:23:16] Only trigger the amplitude envelope.
[00:23:20] When there's a zero crossing happening we can do this with the name
[00:23:29] aquantizer. So this is our clock. The zero crossings is our clock.
[00:23:36] Maybe try to play this.
[00:23:47] This and maybe pitch it down.
[00:24:00] So you can quantize the triggering to the zero crossings. I don't know if this is a good idea
[00:24:10] but you can see here it kind of works. It's not the best idea probably but it gives you some
[00:24:19] solutions for certain problems.
[00:24:22] You can see it more clearly here. So clock quantizing the amplitude envelope to the face.
[00:24:33] Also an idea you can maybe try out if you want to have this possible in the Bitwig grid.
[00:24:40] There are also modules in Bitwig where you get the envelope for free. So let's say you want
[00:24:46] to make a sine oscillator and you can go for the wavetables oscillator because here we have this
[00:24:52] standard four waveform where you get a sine wave for free that starts at zero.
[00:24:59] So you don't need to offset this oscillator here. If you use the sine it always starts at minus one
[00:25:05] and the wavetable one with the standard four wavetable starts always at zero.
[00:25:10] We get this for free. You can use here for instance a trigger but instead of triggering
[00:25:17] with this here which you can do but we can also use a face input for that. So here's a face pre-quad.
[00:25:28] When I switch this off nothing happens but then I can connect here the face input to the triggers
[00:25:34] module and it gets face information again but now we can hook something up here in between
[00:25:39] and we get also the face information for that. So we can say this is here the face signal.
[00:25:49] It's more or less like ramp signal. It's going up from zero to one across one bar
[00:25:55] and then we have four triggers for each bar. So we have four up-down movements here from the gate
[00:26:02] between zero and one of the gate of the face signal which means we can trigger with this here maybe
[00:26:11] once each bar and then we have in the background here the ramp signal which is the face signal
[00:26:19] then we can use here the window module. The window module takes in also a face signal.
[00:26:27] We can use this to actually fade in and fade out certain things. So let's say we trigger here
[00:26:36] then we have zero volume then we go up to the volume until the end of the of the gate signal
[00:26:43] then we fade slowly out. So yeah but this we can also just take here an audio out
[00:26:53] multiply take this window as a volume signal.
[00:26:59] So it's more or less also an amplitude envelope so instead of using here an AD or ADSR which also
[00:27:11] just fades in and fades out the volume over time and you need to set the release time and the attack
[00:27:19] time here on this AD envelope manually. Here we have the the face of yeah of this trigger thing
[00:27:30] and we can synchronize basically when we trigger and how each trigger influences the shape more or
[00:27:39] less. We can do here also a transport thing which gives you also a face signal and the gate
[00:27:48] signal at the same time so you can say 16 so 160 node triggers we get a lot of triggers here
[00:27:56] and we need to fade for each for each trigger or let's say
[00:28:01] 16 16 triggers right so we have the same as before we can also say eight. So the the envelope changes
[00:28:12] or the timing of the envelope changes with your amount of triggers we can use this pretty easily
[00:28:20] to create sounds.
[00:28:22] And if you're not happy here with the shape of this envelope just sign up down movement
[00:28:43] uh you can influence the face so you can say uh band
[00:28:49] something like this right so the envelope is different
[00:28:54] like more like an amplitude envelope right you can see here or this is the attack
[00:29:01] it's the release and it changes with the speed.
[00:29:13] And yeah you can not only use this for the oscillator again you can use just the recorder here
[00:29:26] right and trigger the recorder and then you use
[00:29:29] this for the volume like this
[00:29:37] sign here to record again record here for a moment
[00:29:46] we have something in the recorder here we want to play it back
[00:29:56] but it's still smooth of course we have this movement here
[00:30:05] if we don't do this it sounds like this
[00:30:10] much better this way
[00:30:15] maybe there needs to be a delay here or maybe a shift you can use a shift
[00:30:27] this one
[00:30:36] yeah it's not perfect but you get the idea it's it's much better than this
[00:30:41] anyway so you can use anything more or less for amplitude envelopes you don't need to use the
[00:30:50] envelopes in general it's in the grid it's just everything is a signal and you can shape
[00:30:56] signals in all kinds of shapes and forms and yeah you just need the right idea and you can
[00:31:03] make it work and by the way if Bitwig watches this please make the recorder longer and maybe
[00:31:10] give us some pitch options okay thank you so that's it for this video I hope I could explain
[00:31:16] something to you why these crackles happening why these clicks and pops happening it's just
[00:31:23] where you restart the phase and you don't want to have these drastic movements in the waveform
[00:31:29] where you go from 0 to 1 or from 1 to 0 or from plus 1 to minus 1 in a fraction of a second
[00:31:38] just make smooth smooth out movements and the crackles and the pops go away thanks for watching bye