Audio Quantizer - Quantizing Audio with FX Grid in Bitwig Studio

tutorial | Nov 24, 2022

In this video, I show how to use the FX Grid in Bitwig to clean up and quantize samples for easier use in a sampler. I go through the steps of using a loud split to remove noise, and then an auto level preset to normalize the sound. I also explain how to use a follower, latch, and logic modules to trigger recording and playback, which allows for quantization of audio. Finally, I show how to use the FX Grid for more creative effects.

You can watch the Video on Youtube
Download the Preset here

What is an Audio Quantizer? #

An audio quantizer is an effect used to automatically align audio samples with a rhythmic grid. It can be used to create rhythmic patterns from samples or to clean up noisy audio recordings. With audio quantization, audio samples are "snapped" to the grid, allowing for rhythmic precision that would otherwise be difficult to achieve.

What can you do with an Audio Quantizer? #

An audio quantizer can be used to clean up and normalize audio samples, as well as to synchronize and quantize audio to a grid or beat. It can also be used to create interesting effects by triggering audio at different rates or with different rhythms.

Transcription #

If you don't want to watch the Video, or search for a specific topic, here is the transcription of the video with links to video markers:

[00:00.000] Hey folks, welcome back to another pretty useful video and it's probably the third
[00:08.000] part of my recent series about treating samples or something like this where you
[00:16.080] probably watch the video with the auto level and with the loud split so this is
[00:19.600] part three you can use all these things together. So let's imagine you have an
[00:27.040] audio track here and you want to sample some percussions, right? So what you do is you hit
[00:33.840] record probably without a...
[00:45.200] You have this nice kalimba sound in there and when you want to use this in the sampler
[00:51.040] you just can drag it into the sampler and then modify it in the sampler if you want to
[00:57.920] but we are a bit lazy and we want to learn some things so we use multiple things here.
[01:03.360] First up we use a loud split to get rid of the noise in here. Let me drag this in here.
[01:11.360] You can see we have a lot of noise here from the microphones. We just disable the noise
[01:16.720] and are left with the tonal parts and the interesting parts. So this is pretty easy
[01:25.840] and then we want to normalize it so we can use our auto level preset we made in the last video.
[01:35.040] Pull down the threshold here a bit.
[01:36.560] You can see we have it nicely peaking here at 0.minus 0.3 dB so it's nicely normalized
[01:52.400] and then the third problem is, and this is what this video is about, it's about
[01:59.200] quantizing the position of this, right? You can see here we snap to the grid,
[02:02.880] we can't really cut it on the right at this position here easily. I'm sure we can use here the knife
[02:12.960] knife tool right and try to cut it but it's not really on point. So what I usually want to have
[02:18.720] is exactly this starting point on the grid and you can do this in the sampler. There's a snap
[02:25.440] feature in there and also in here. The transient is perfectly recognized by Bitwig but
[02:32.400] this is just a theoretical video where we want to learn something and want to dive in the grid
[02:37.760] and try to have some solutions with the grid. So we want to quantize audio with the FX grid
[02:44.720] and I want to show you this here. I can kind of do it. We have some shortcomings here because of
[02:51.280] the recorder. The recorder doesn't have maybe or doesn't have that long of recording time,
[02:58.400] maybe two seconds or something. I'm not really sure but it only works for percussion sounds,
[03:05.120] for short sounds. So we want to record here when there is audio on the signal. So we use a follower
[03:13.520] for that. So the follower tells us if there's something happening. Okay, so every time something
[03:30.240] happens we want to switch on the recording but this doesn't work really well. You can see it
[03:38.400] just stops because the signal here from the follower was pretty quickly below 0.5 which is
[03:48.560] the gate, needed gate value here. So we need to hold on to this on information with the latch.
[03:59.520] The latch is basically just a module that switches between 13.0 and 1 and you want to
[04:05.280] switch it on every time this event happens here. You can see it holds on to recording this thing here
[04:17.520] and then we want to switch it off every time this level or this value goes below a certain value.
[04:25.840] So we need the logic module for that smaller than. So every time this value is smaller than
[04:32.240] the constant of 0.02. So not really 0. So a little bit above 0. You can change this for whatever you
[04:46.240] want to do, whatever your threshold is and then we want to stop recording. That's a bit too short
[04:56.960] so maybe increase the default time. And then it stops recording, maybe a bit shorter, something
[05:08.960] like this. So now we have to recording the logic here. Now we need the playback logic
[05:15.840] and we use maybe a trigger for that. Let's go for 1 here and then we get basically the trigger
[05:29.040] signal sends out a trigger perfectly in sync, perfectly on the grid. It's exactly what we want
[05:34.800] but you don't want to start recording here every time this happens. So we need some logic there
[05:39.680] and we want to start recording every time the trigger is true
[05:47.680] and also we want to make this trigger short. So if you use here an oscilloscope
[05:55.760] you can see the on time is pretty long right here. This on section is pretty long. So we
[06:02.880] lose a length signal here for that and make it just 1 millisecond maybe, 0.5 milliseconds. So
[06:10.800] pretty short. We just want to have an event here happening and this event is then compared with
[06:21.920] when there's no recording happening. So this one tells here the record event record. So we use a
[06:27.680] knot. So every time this records or doesn't record and this is 0 we want to turn this into an on
[06:38.800] effect or on value. So every time this is not recording we want to have a true here and every
[06:45.200] time this trigger is then active we want to trigger it. So we have these two conditions met and then
[06:52.720] we can hit play basically. And then we need also a latch of course
[07:04.960] in here. We want to switch this on and we want to switch it off every time we start recording.
[07:12.000] And then after the record stops we want to start the playback.
[07:25.440] Okay so let's try this out. Give this here a bounce out. Actually a bit longer something like this.
[07:32.320] A bit stop here. Of course that doesn't work.
[07:50.640] That's not correct.
[07:51.760] Oh sure.
[08:02.720] My mistake. Of course we have to use the recorder bounce.
[08:11.840] So now we have to set a different position here and it's nearly perfectly on the grid.
[08:18.960] There's some overlap here right from here to here. So we need to fix that maybe with the delay.
[08:28.880] Of maybe a small delay in there.
[08:36.880] So let's try this again. Bounce.
[08:39.680] Bounce. You can see now it's nearly perfect on the grid.
[08:53.920] Now we have basically a nice little quantizing thing here and all you have to do next time
[09:04.400] is to load up this kind of chain and it cleans up your sample. It cleans up your sample,
[09:12.240] it normalizes your sample and it also quantizes it to the grid. And all you have to do is just
[09:21.120] drag this here, drag this there and hit ctrl and g and then maybe drag it into the sampler.
[09:29.840] And you have a perfectly nice starting point. It's cleaned up,
[09:34.400] there's no noise in there and it's also normalized. So this would be a nice little
[09:39.520] chain you can use for sampling. Then right click here to detect tools here.
[09:52.320] So it's easy to do and it helps you a bit in your daily sampling workflow maybe.
[09:57.680] So this is an idea for something like this grid here. But you can also do with this here some
[10:05.440] weirder stuff. So maybe we increase here to trigger behavior to eight
[10:10.880] notes. So we trigger this more often and we maybe also want to decrease here the falling time
[10:20.400] and we just want to record stuff on the fly. So let's see. So I record multiple sounds.
[10:32.800] Okay. So we have now this here, this and this is completely off the grid, right?
[10:52.000] So let's try and use our weird little audio effect here.
[11:09.840] Now we have something like this.
[11:11.040] It's kind of quantized. Sometimes maybe some of these percussion sounds are missing,
[11:23.040] but you get the idea, right? So you can do some kind of live audio quantizing effect with this here.
[11:32.080] Maybe use 16 notes. It's basically what the clock quantizer does, but for audio.
[11:41.280] All right. So we have a normalized signal. It's quantized in a way.
[12:02.080] It's also cleaned with noise. So there's no noise in there. So it's, yeah,
[12:08.080] it's probably an interesting effect here when you want to sample something,
[12:12.400] percussion sounds, whatever. And then you want to track it into the sampler or maybe you want to
[12:17.440] use it in your project and it's already nicely synchronized or quantized. Okay. So yeah, this
[12:25.440] is of course available here in the description below. You can download this from my github.
[12:31.200] It's just a small idea I had last night and I thought it's maybe worth sharing. Maybe you have
[12:37.440] some use cases for that. And yeah, that's it for this video. Thanks for watching. Leave a thumbs up.
[12:45.040] If you have some questions, let me know in the comments. And thanks for watching. Until next time, bye.