Distortion Archives - Audio Ordeal

Wave Destroyer is my new go-to VST for making drums hot!

Tom Jarvis — Wed, 24 Jun 2020 01:10:31 +0000

I don’t normally review products before they launch. Recently though I was beta-testing the latest plugin from GMH audio, Wave Destroyer, and was so impressed that I thought I’d give you a preview of what’s to come.

Note: This plugin is still in Beta so the following information may be subject to change. This article is very positive, but not sponsored. I did however receive a free copy of the VST for Beta-testing purposes.

UPDATE: The plugin has now been published and is available here. It allows you to decide the pricing you think is fair.

What is Wave Destroyer?

Wave Destroyer is an audio distortion plugin with a huge amount of sound control, from subtle warmth, to all-out decimation.

It is centred around three stages of sound design, with an EQ on input and output, and a distortion control in the middle of the chain. It also features the much-coveted Dry/Wet knob that is so simple, yet something so many developers neglect to include.

Developer Greg Hendler, Founder and Engineer at GMH audio, described it to me: “It was initially inspired by a mix tip I saw somewhere years ago, that involved EQing before and after a distortion to shape tone in unique ways.”

How does Wave Destroyer work?

Designed to be a “character tool” and “not too much of a channel strip”, it excels at firing up drum busses and dynamic elements.

The key to using this well, I found, was exploring the input EQ’s effect as it fed different frequencies into the distortion.

Having the option to do this in a single plugin makes life a lot easier and the level of control you have is great.

I found the ability to boost the lows to increase their saturation was a great way to bring out kicks and 808s on small speakers, and dull drum tracks could be livened with a hi-mid boost and toying with the highs.

Of course, distortion adds a lot of new sounds to a musical element and so having the same style of EQ on the output allowed me to tame the beast and get a carefully sculpted sound.

One of the key elements that makes this stand out from other distortion plugins is the visualisation of Bias and Asym controls.

Under the hood, it is designed with fuzz pedals in mind. And with three levels of distortion available (Saturate, Distort, and “DESTROY”), it has a huge amount of depth.

“The Bias and Asym controls are inspired by guitar fuzz pedals that have bias adjustment to give spurty, gated, lofi fuzz,” Greg explained.

“I haven’t seen that in a plugin before so wanted that to be an aspect of it. I especially like how the gates sounds work with drums.”

My new drum-bus

Up until now, I have been using the Supercharger GT plugin from Native Instruments on my drum bus (I personally like my drums to be hot).

Doing side-by-side comparisons, I can tell you that Wave Destroyer does a better job – even without the compressor knob.

Supercharger GT was my former drum-bus magic wand. Now I’ll have to rethink my chain

The reason for my affinity to Supercharger GT was because of its input saturation and output tone controls allowing for fat, warm, or bright sounds.

Well, with the Wave Destroyer, you get them – but with even more control options.

Given the fact that (and I say this very cautiously) distortion is a type of compression, Wave Destroyer can actually tame a lot of transients and fatten the audio up while still keeping the saturation silky smooth.

For this reason, all my future projects will have the dilemma of picking between my traditional choice, or this new one.

When will Wave Destroyer release?

GMH audio’s Wave Destroyer is still in the Beta-testing phase right now, however Greg told me to expect a release some time in July.

It will be available at GMH audio, alongside their other plugins.

The post Wave Destroyer is my new go-to VST for making drums hot! appeared first on Audio Ordeal.

Ableton: What is the difference between Dynamic Tube and Overdrive?

Tom Jarvis — Fri, 20 Mar 2020 19:54:47 +0000

You may be wondering what the difference is between Dynamic Tube and Overdrive in Ableton, which one works best? What is each for?

Let’s look at the differences to see why these two similar effects are packaged so differently.

The Dynamic Tube effect is a model of tube saturation. This is a very particular sound that was used in old-school amplifiers. Tubes give a really warm effect on the signal. They also respond to dynamics in a smooth way.

In the effect, an “integrated envelope follower” generates dynamic tonal variations related to the level of the input signal.

It offers three modes, A, B, and C, with each modelling a specific type of tube amplification. The Ableton reference manual describes these modes as follows:

Tube A does not produce distortions if Bias is set low, but will kick in whenever the input signal exceeds a certain threshold, creating bright harmonics. Tube C is a very poor tube amp that produces distortions all the time. The qualities of Tube B lie somewhere between these two extremes.

Overdrive, on the other hand, is a model of classic overdrive guitar pedals. It is designed to be driven hard without losing dynamics and so is a great effect for driving percussive or transient sounds such as drums or punchy bass.

It offers less smoothness compared to Dynamic Tube, instead offering more grit and bite to the sound. It also works as an always-on effect with Ableton saying: “Note that 0% [on the drive control] does not mean zero distortion!”

A key feature is the dynamics control, which Ableton describes:

The Dynamics slider allows you to adjust how much compression is applied as the distortion is increased. At low settings, higher distortion amounts result in an increase in internal compression and make-up gain. At higher settings, less compression is applied.

So, which one to use? In my experience, the Dynamic Tube offers a great way to lightly saturate low frequencies and add some warmth. It works really well on the sub-bass and also in low amounts, can glue together a mix.

I have found Dynamic Tube excels best if you don’t push it too hard, in fact, barely audible tweaks are especially useful with this effect. It is a subtlety that Overdrive does not offer.

To distort heavy synths, my go-to would be Overdrive. This is because it allows much more range and grit, and can be pushed harder.

Having said that, I’m not overly keen on using Overdrive for guitars, it works fine, but it does not match up to dedicated guitar effects. If I am using a guitar track, I will always default to the sounds in Native Instruments Guitar Rig.

But for synths and sound effects, Overdrive works great.

The post Ableton: What is the difference between Dynamic Tube and Overdrive? appeared first on Audio Ordeal.

How to build a VST – Lesson 3: Distortion

Alex Rycroft — Mon, 10 Jun 2019 12:45:11 +0000

The last tutorial covered coding an autopanner plugin using the generic UI. In this tutorial we’ll use a different UI that can be modified to use your own UI designs and code a basic distortion plugin.

Setting up the UI

By using the PluginEditor.h and .cpp files created by Projucer, we have more options when designing the plugin UI, than when using the Generic UI elements.

Create a new JUCE audio plugin project, then open up the PluginEditor.h file. There are a few more steps to setting up a UI using the PluginEditor files, but it will allow you to easily change the design of your UI elements.

Load the PluginEditor.h file and add this line to the private section then, add the following lines to the PluginEditor.cpp file to make it visible in the plugin window.

addAndMakeVisible(&disChoice); // 1
disChoice.addItem(“Hard Clip”, 1);
disChoice.addItem(“Soft Clip”, 2);
disChoice.addItem(“Half-Wave Rect”, 3);
disChoice.setSelectedId(1);

disChoice.setBounds(50, 50, 200, 50); //2

This ComboBox will be used to change the type of distortion algorithm in the plugin. Build your code and you will see a ComboBox with three options. To make this box change anything, we need to add a listener. A listener will call a piece of code anytime this ComboBox is changed.

In the PluginEditor.h file add ComboBox::Listener in the private declarations section.

Then in PluginEditor.cpp write this line to add a listener to the disChoice ComboBox.

Back in PluginEditor.h add this line,

void comboBoxChanged(ComboBox* comboBoxThatHasChanged) override;

then either let your IDE create a definition in PluginEditor.cpp or add it yourself.

This function is called anytime a ComboBox is changed.

Now in PluginProcessor.h declare a variable called menuChoice.

int menuChoice;

By using the ComboBoxChanged void, we will change this variable from the UI objects we added to the Plugin.

In PluginEditor.cpp add this line to the ComboBoxChanged void.

processor.menuChoice = comboBoxThatWasChanged->getSelectedId();

This code sets the variable we made in PluginProcessor.h to the value selected by the user in the UI.

We are also going to add two sliders to the Plugin UI. All code in bold needs to be added. The only big difference when adding sliders is that we need to check which slider is being moved in the SliderValueChanged() function.

Be careful to copy these lines in the correct places, if you have trouble you can see the final plugin code at:

https://github.com/aRycroft/JuceTutorial3

PluginEditor.h:

class DistortionAudioProcessorEditor :
public
AudioProcessorEditor,
private
ComboBox::Listener,
Slider::Listener

private:
void comboBoxChanged(ComboBox* comboBoxThatHasChanged) override;
void sliderValueChanged(Slider* sliderThatHasChanged) override;
// This reference is provided as a quick way for your editor to
// access the processor object that created it.
DistortionAudioProcessor& processor;
ComboBox disChoice;
Slider Threshold;
Slider Mix;

PluginEditor.cpp:

{
// Make sure that before the constructor has finished, you’ve set the
// editor’s size to whatever you need it to be.
setSize (400, 300);

addAndMakeVisible(&disChoice);
disChoice.addItem(“Hard Clip”, 1);
disChoice.addItem(“Soft Clip”, 2);
disChoice.addItem(“Half-Wave Rect”, 3);
disChoice.setSelectedId(1);
disChoice.addListener(this);

addAndMakeVisible(&Threshold);
Threshold.setRange(0.0f, 1.0f, 0.001);
Threshold.addListener(this);

addAndMakeVisible(&Mix);
Mix.setRange(0.0f, 1.0f, 0.001);
Mix.addListener(this);
}

void DistortionAudioProcessorEditor::resized()
{
// This is generally where you’ll want to lay out the positions of any
// subcomponents in your editor..
disChoice.setBounds(50, 50, 200, 50);
Threshold.setBounds(50, 100, 200, 50);
Mix.setBounds(50, 150, 200, 50);
}

PluginProcesor.h:

int menuChoice;
float thresh = 0.0f;
float mix = 0.0f;

After adding the two slider elements to the UI, add this code to the sliderValueChanged function. This code checks which slider has been changed, then assigns a value to the variables in the processor files.

void DistortionAudioProcessorEditor::sliderValueChanged(Slider *slider)
{
if (&Mix == slider)
{
processor.mix = Mix.getValue();
}
if (&Threshold == slider)
{
processor.thresh = Threshold.getValue();
}
}

Coding the Process Block

After building your plugin you should see two sliders below the ComboBox. Now we can start building the distortion algorithms for this plugin.

I won’t go into detail on distortion algorithms here, but if you’re interested you can easily look up how these algorithms work. I would also encourage you to try and modify the ProcessBlock code to add more options or change how the signal is modified.

Copy the following code into your process block. After building your plugin you should be able to change the type of distortion, and the threshold and mix values.

PluginProcessor.cpp -> ProcessBlock()

{
for (int channel = 0; channel < buffer.getNumChannels(); ++channel)
{
auto* channelData = buffer.getWritePointer(channel);

for (int i = 0; i < buffer.getNumSamples(); ++i) {

auto input = channelData[i];
auto cleanOut = channelData[i];

if (menuChoice == 1)
//Hard Clipping
{
if (input > thresh)
{
input = thresh;
}
else if (input < -thresh)
{
input = -thresh;
}
else
{
input = input;
}
}
if (menuChoice == 2)
//Soft Clipping Exp
{
if (input > thresh)
{
input = 1.0f – expf(-input);
}
else
{
input = -1.0f + expf(input);
}
}
if (menuChoice == 3)
//Half-Wave Rectifier
{
if (input > thresh)
{
input = input;
}
else
{
input = 0;
}
}
channelData[i] = ((1 – mix) * cleanOut) + (mix * input);
}
}
}

These are very simple distortion algorithms but can create some interesting results. Checking out some other JUCE projects is a great way to improve the distortion algorithms and find out what else is possible using JUCE. Any non-linear effects are easy to implement, such as saturation or exciter algorithms.

Code for this tutorial can be found here:

https://github.com/aRycroft/JuceTutorial3

I’ll continue to improve this plugin in the next tutorial, changing the design of the UI elements by coding the plugin look and feel.

The post How to build a VST – Lesson 3: Distortion appeared first on Audio Ordeal.