If you own a copy of Logic Pro X, you may be familiar with the stock Compressor plugin, but did you know that its various modes are actually emulations of popular hardware compressors? 

Novice or intermediate enthusiasts would be forgiven for thinking that this “stock” tool does not hold its own against more premium and dedicated emulations from third-party plugin companies like Waves or Slate Digital. This, in reality, is false.

A sort of Swiss-Army plugin, the Compressor features a variety of options, compressions types, and extended controls such that it could be argued it actually has an edge over its competitors. 

While these modes are not strictly one-to-one copies, they are certainly inspired by the originals, and when used similarly, yield comparable results. Let’s have a look and identify the different modes of this plugin.

• READ MORE: What’s the difference between Ableton’s Compressor and Glue Compressor
• READ MORE: What are reverse fades and when to use them?

Modes & Emulations

Platinum Digital

This is Logic’s own compressor model. Apple describes it as “a clean-sounding compression type with a fast transient response”. 

Very fast in fact, given the plugin’s ability to provide an attack time of 0 ms! 

This mode is suitable for just about any application you may need a compressor for, and will not alter the character of your source material if transparent compression is your goal.

Studio VCA

This is an emulation of Focusrite’s popular Red 3 Compressor, and the actual unit is a favourite of top mixer Chris Lord-Alge on the mix bus. 

The main giveaway is the metallic red appearance and the knobs which match those found in Focusrite’s Red series hardware. 

This mode is great for bus compression as well as handling bass instruments or other low-frequency instruments like drums. 

While the original hardwire is fully discrete and therefore offers very little colouration, this version offers slightly more pronounced harmonic overtones which can be varied in character by switching through the distortion modes available in the output section.

Studio FET

An emulation of one of the most popular solid-state compressors ever, the Universal Audio 1176 Rev E “Blackface”. 

Famous for introducing ultra-fast attack times to studios it also functions well as a line amplifier when no compression is applied, adding some presence and brightness due to its unique circuitry and components making this very much a character tool. 

The original excels at levelling and adding character to drums, bass & guitar, and rock vocals, and this version does a great job of doing the same.

Classic VCA

Based on the dbx 160, this mode offers the fewest controls out of all the modes: Threshold, Ratio, and Makeup. 

One of the most used compressors of the 70s and 80s. It offers very fast and clean compression to all out beefy, punchy, and aggressive sounds. Especially popular on drums for its ability to bring out their “thump”, “crack” or “snap”, it has been a mainstay for producers like Eddie Kramer throughout his time at Electric Lady Studios and the rest of his career.

Vintage VCA

Inspired by what is probably the most popular bus compressor to date, and with a  multitude of plugin versions in existence, this mode emulates the SSL 4000 G Bus Compressor. 

Again, the knobs and grey appearance (spotted the theme yet?) all point to this. 

Capable of both slow and fast attack and release times, the original is famous for its “gluey” characteristics. 

This plugin is great at handling multiple groups of sounds, such as a full mix or individual instrument sub groups. 

I enjoy this particular emulation on male rock vocals as I find the upper-mid/treble harmonic enhancement to be a little more pronounced than other third-party versions.

Vintage FET

Another 1176 emulation. This time based on 1176 Rev H “Silverface”. 

Offering essentially the same functions and features as the “Blackface”, this version however has a slightly more noticeable effect on the mid range of instruments like drums which can add some perceived “edge” or transient enhancement. 

That said, a crunchy sound in the mid-range is developed in both modes if cranked enough. 

It’s best to think of these two versions more as different flavours of the same tool. 

Another thing that sets these modes apart is that the Blackface has a fixed Knee setting whereas the Silverface has a variable Knee control.

Vintage Opto

Modelled on the Teletronix LA-2A tube compressor, this mode is too good to overlook!

Based on the function of optical compression versus VCA or FET, this offers a unique sound compared to the rest of the modes. 

Controlled by two simple controls (Gain and Gain Reduction) the original unit features fast attack times and programme dependent, multi-stage release times, making it an excellent choice for recording or mixing vocals, bass guitar, and even drum shells. 

The Vintage Opto mode expands upon these features through the Logic Compressor’s additional range of controls, such as a possible ratio up to 30:1, adjustable Attack times and adjustable Release times. 

The original unit featured a Compress/Limit switch and a similar effect can be achieved by adjusting the Knee control of the Vintage Opto Mode.

Output Section and More

This section of the Compressor is what I think makes this tool really something special. 

Featuring a Threshold Limiter, three Distortion modes, an ever useful Mix knob, and a Sidechain Control section, this compressor is able to perform in ways that the original units or other third-party plugins just cannot. 

Want a more aggressive sound on your snare drum? Play with the Distortion settings between Soft, Hard, and Clip to bring out a more pronounced sound. 

Want the cranked 1176 vocal sound without aggravating the sibilance? Send the signal to a bus, side-chain that bus back to the plugin, and adjust the Filter settings to focus on the “esses”. 

Are you slamming the compressor, loving it, but it’s just a bit much? Dial back the Mix knob to retain some vitality as well as keeping the sound controlled.

Hopefully you can now see the versatility of this absolute unit of a plugin. While using some of the more premium plugins can be very nice and in some cases nothing else will do, learning this tool inside and out will help you to control your mixes in ways you maybe hadn’t considered and that the third party plugins just can’t compete with. 

That stock plugin suddenly doesn’t seem so stock and boring now, does it?

The post Logic Pro’s Compressor – Save your money and try this tool first! appeared first on Audio Ordeal.

Compressors are one of the key plugins used in mixing and mastering. In this tutorial I’ll show you how to make one from scratch. At the end of this tutorial you’ll have built a working compressor with attack/release controls and a soft/hard knee selector. 

Add the following base code to Compressor.h.

#include "CircularBuffer.h"
#pragma once

class Compressor {
public:
private:
};

CircularBuffer buffer;
float tav, rms, gain;

Compressor();
float compressSample(float data, float thresh, float ratio, float attack, float release, float knee);

Compressor.h should look like this,

buffer = CircularBuffer(150, 20);
tav = 0.01;
rms = 0;
gain = 1;

rms = (1 - tav) * rms + tav * std::pow(data, 2.0f); //1
float dbRMS = 10 * std::log10(rms); //2

//1 Adjusts the rms value depending on the incoming signal.
//2 Converts this value to the decibel scale.

float slope = 1 - (1 / ratio); //1
float dbGain = std::min(0.0f, (slope * (thresh - dbRMS))); //2
float newGain = std::pow(10, dbGain / 20); //3

//1 Calculate slope from ratio
//2 Find the gain to be applied in db, and make sure it’s less than 0.0f
//3 Calculate the newGain in linear scale

float coeff;
if (newGain < gain) coeff = attack; //1
else coeff = release; //2
gain = (1 - coeff) * gain + coeff * newGain; //3

//1 Declare coeff variable, if newGain is less than current gain set to attack variable
//2 Else set to release
//3 Adjust gain based on new gain and coeff

float compressedSample = gain * buffer.getData();
buffer.setData(data);
buffer.nextSample();
return compressedSample;

#include "Compressor.h" //1

Array allCompressors; //2

Include the new Compressor class at the top of the file, and declare a new array of Compressors.

//Prepare To Play
for (int channel = 0; channel < getNumOutputChannels(); channel++) {
   allCompressors.add(Compressor());
}
//Process Block
for (int i = 0; i < buffer.getNumSamples(); i++) {
   for (int channel = 0; channel < getTotalNumOutputChannels(); channel++) {
      auto* data = buffer.getWritePointer(channel);
      Compressor* comp = &allCompressors.getReference(channel); //1
      data[i] = comp->compressSample(data[i], -30.0f, 20.0f, 0.01f, 0.4f, 0.0f); //2 
   }
}

In PrepareToPlay create an array of Compressors.

In ProcessBlock loop through samples and channels.
// 1 Get reference Compressor for the current channel.
// 2 Calculate the compressed samples with some initial values passed into the compressSample function.

//PluginProcessor.h
AudioProcessorValueTreeState state;
//PluginProcessor.cpp
,
state(*this, nullptr, Identifier("params"), {
    
}
)

Declare an AudioProcessorValueTreeState called state in PluginProcessor.h then add a constructor in the AudioProcessor Constructor list.

We’ll add the parameters to the StateTree in this constructor.

std::make_unique<AudioParameterFloat>(
              "thresh", 
              "Threshold", 
              NormalisableRange<float>(-60.0f, 20.0f, 0.01f), 
              10.0f),

This creates a unique pointer to an AudioParameterFloat with
identifier “thresh”,
name “Threshold”,
numberRange betwwen -60.0f -> 20.0f with spacing 0.01f,
default value of 10.0f

 std::make_unique(
              "thresh", 
              "Threshold", 
              NormalisableRange(-60.0f, 20.0f, 0.01f), 
              10.0f),
 std::make_unique(
              "ratio",
              "Ratio", 
              NormalisableRange(1.0f, 20.0f, 0.01f), 
              2.0f),
 std::make_unique(
              "knee", 
              "KneeWidth", 
              NormalisableRange(0.0f, 24.0f, 0.01f), 
              0.0f),
 std::make_unique(
              "attack", 
              "Attack", 
              NormalisableRange(0.01f, 500.0, 0.01f), 
              100.0f),
 std::make_unique(
              "release", 
              "Release", 
              NormalisableRange(0.01f, 2000.0f, 0.01f), 
              500.0f)

Head to PluginEditor.h and declare a pointer to an AudioProcessorValueTreeState called params.

Also change the constructor to receive an AudioProcessorValueTreeState object.

Now in PluginEditor.cpp edit the constructor to receive the state and point params to the state object.

Back in PluginProcessor.cpp change the editor constructor to include passing the statetree.

Declare these sliders, labels and sliderattachments in PluginEditor.h. A slider attachment will allow values in the stateTree to be changed by a slider.

Slider threshSlider, slopeSlider, kneeSlider, attackSlider, releaseSlider;
Label threshLabel, slopeLabel, kneeLabel, attackLabel, releaseLabel;
std::unique_ptr<SliderAttachment> threshAttachment, slopeAttachment, kneeAttachment, attackAttachment, releaseAttachment;

void CompressorAudioProcessorEditor::addSlider(String name, String labelText, Slider& slider, Label& label, std::unique_ptr& attachment) {
   addAndMakeVisible(slider);
   attachment.reset(new SliderAttachment(params, name, slider));
   label.setText(labelText, dontSendNotification);
   label.attachToComponent(&slider, true);
   addAndMakeVisible(label);
}

Now we can write this code in the Editor constructor to add all the sliders we want to the GUI and attach them to the stateTree.

addSlider("thresh", "Threshold", threshSlider, threshLabel, threshAttachment);
addSlider("ratio", "Ratio", slopeSlider, slopeLabel, slopeAttachment);
addSlider("knee", "Knee", kneeSlider, kneeLabel, kneeAttachment);
addSlider("attack", "Attack", attackSlider, attackLabel, attackAttachment);
addSlider("release", "Release", releaseSlider, releaseLabel, releaseAttachment);

threshSlider.setBounds(100, 0, 200, 50);
slopeSlider.setBounds(100, 50, 200, 50);
kneeSlider.setBounds(100, 100, 200, 50);
attackSlider.setBounds(100, 150, 200, 50);
releaseSlider.setBounds(100, 200, 200, 50);

//PluginProcessor.h
float* threshParam, *slopeParam, *kneeParam, *attackParam, *releaseParam;
//PluginProcessor.cpp -> PrepareToPlay
threshParam = state.getRawParameterValue("thresh");
scopeParam = state.getRawParameterValue("ratio");
kneeParam = state.getRawParameterValue("knee");
attackParam = state.getRawParameterValue("attack");
releaseParam = state.getRawParameterValue("release");

Declare these pointers in the header file and set them to values in the stateTree in prepareToPlay.

These pointers don’t directly store the float value. They point to the memory address where the value is stored.

float at = 1 - std::pow(MathConstants::euler, ((1 / getSampleRate()) * -2.2f) / (*attackParam / 1000.0f));
float rt = 1 - std::pow(MathConstants::euler, ((1 / getSampleRate()) * -2.2f) / (*releaseParam / 1000.0f));

for (int i = 0; i < buffer.getNumSamples(); i++) {
   for (int channel = 0; channel < getTotalNumOutputChannels(); channel++) { 
      auto* data = buffer.getWritePointer(channel); 
      Compressor* comp = &allCompressors.getReference(channel);
      data[i] = comp->compressSample(data[i], *threshParam, *slopeParam, at, rt, *kneeParam);
   }
}

void CompressorAudioProcessor::getStateInformation(MemoryBlock& destData)
{
    auto stateTree = state.copyState();
    std::unique_ptr<XmlElement> xml(stateTree.createXml());
    copyXmlToBinary(*xml, destData);
}

void CompressorAudioProcessor::setStateInformation(const void* data, int sizeInBytes)
{
    std::unique_ptr<XmlElement> xmlState(getXmlFromBinary(data, sizeInBytes));
    if (xmlState.get() != nullptr && xmlState->hasTagName(state.state.getType())) {
        state.replaceState(ValueTree::fromXml(*xmlState));
    }
}

float Compressor::interpolatePoints(float* xPoints, float* yPoints, float detectedValue) {
   float result = 0.0f;
   int n = 2;

   for (int i = 0; i < n; i++){
      float term = 1.0f;
      for (int j = 0; j < n; j++{
         if (j != i) {
         term *= (detectedValue - xPoints[j]) / (xPoints[i] - xPoints[j]);
         }
      }
   result += term * yPoints[i];
   }
return result;
}

Don’t worry about understanding how this function works too much, all you need to know is that it takes an array of two xpoints, two y points and approximates a value between them. 

This value will replace our slope value.

if (knee > 0 && dbRMS > (thresh - knee / 2.0) && dbRMS < (thresh + knee / 2.0)) {
   float kneeBottom = thresh - knee /    2.0, kneeTop = thresh + knee / 2.0;
   float xPoints[2], yPoints[2];
   xPoints[0] = kneeBottom;
   xPoints[1] = kneeTop;
   xPoints[1] = std::fmin(0.0f, kneeTop);
   yPoints[0] = 0.0f;
   yPoints[1] = slope;
   slope = interpolatePoints(&xPoints[0], &yPoints[0], thresh);
   thresh = kneeBottom;
}

This block of code sets up some variables for the interpolation function we just wrote.

First it checks the current rms value is in the knee zone, between thresh – knee / 2.0 and thresh + knee / 2.0.

Then we make two arrays of points, 
xPoints holds the db values of the bottom and top of the knee region.
yPoints hold the slope values.

Once these arrays are set up we interpolate a new slope value and set the threshold of the compressor to the lower knee value.

The post How to Build a VST: Compressor appeared first on Audio Ordeal.

ABLETON offers two brilliant compressor effects, Compressor and Glue Compressor, they are both used extensively and look quite different, but what is the difference in their sound?

In brief

Compressor is the default compression plugin in Live 10, it offers a wide range of control and will suit most needs.

Glue Compressor is an emulated classic compressor with a particular focus on “glueing ” the mix together. It has a more limited control set, but is more unique in sound output.

Compressor

Compressor is Ableton’s default compression plugin featuring all of the main controls seen on rival models.

It is used to control the dynamic range of sounds by turning down the loudest parts so the signal has more room to be turned up without the peaks clipping.

Compressor is a very versatile effect which can be used both on individual tracks and as mix bus compression. It is quite transparent and offers advanced sidechain options.

Glue Compressor

Glue Compressor arose from Ableton’s partnership with Cytomic to create an updated version of the ‘The Glue’ compressor plug-in for Live 9.

Glue compressor is an analogue SSL bus compression emulator and is based on the classic bus compressor from a famous 80’s mixing console.

It works to tighten up instruments or to glue elements together in a mix, as opposed to compressing individual tracks – not that you can’t use it for that purpose!

The Threshold knob sets where compression begins. Signals above the threshold are attenuated by an amount specified by the Ratio parameter, which sets the ratio between the input and output signal. Unlike the Compressor, the Glue Compressor does not have a user-adjustable knee. Instead, the knee becomes more sharp as the ratio increases.

Ableton Live 10 manual

One of the reasons it is so good for mix busses is the timing settings. The Glue compressor allows a wide range of dynamic sounds to pass through it “gently” so as not to dampen out the crucial dynamics for a good mix.

The Glue Compressor’s Auto Release actually uses two times – a slow one as a base compression value, and a fast one to react to transients in the signal. Auto Release may be too slow to react to sudden changes in level, but generally is a useful way to tame a wide range of material in a gentle way.

Ableton Live 10 manual

The post What’s the difference between Compressor and Glue Compressor appeared first on Audio Ordeal.

Compression is an essential tool in audio processes. Simply put, a compressor crushes the dynamic range of sound so the quiet bits are louder and the loud bits are quieter.

This sounds quite complicated, so lets look deeper. In sound, e.g. editing an interview, if you want something louder, you turn the volume up. And if you want it even louder, why, you turn it up again.

But you can’t actually just keep turning it up. Audio hardware has a limit to how loud a sound goes through it without you overdriving the signal.

READ MORE: Logic Pro’s Compressor – Save your money and try this tool first!

As you push, let’s say, a mixer harder and harder, it will begin to distort as it just can’t handle the voltage. The more you push above this limit, the more your sound suffers. This is called going into the red.

So we now have a problem, we want to increase the volume but the loud bits can’t get any louder.

One solution for this is to “ride” the faders, that is, have the volume fader all the way up for quiet parts and drop it back down for the loudest. Imagine automating with an effect…

For my example today, I am going to use a simple yet powerful compressor called ReaComp.

It is a software compressor you can add to most Digital Audio Workstations (DAWs) as a VST file.

This one comes native to Reaper, one of the DAWs that I recommend meaning that, along with many other audio processing plugins, you don’t need to download it separately. Here it is:

On careful inspection, most compressors (hardware and software) have the same controls. They will have a threshold, a ratio, an attack and a release.

Other controls include knee-size, pre-comp and more. For the sake of simplicity let’s just look in  very basic detail. 

Threshold

Our “sentencing” control. Everything louder than it will be compressed (reduced in volume).

So we can set the threshold to only the very loudest of bits or we can mercilessly compress the whole thing.

Now think for a moment, we want to boost the quiet parts and make the peak volumes relatively quieter. There is no point crushing the volume of everyone.

If we can find a threshold that is louder than the soft sections, they will stay the same volume. And if the threshold also manages to be below the average volume of the peaks, they will quieten. 

Ratio

This is our “mercy” control. Everything louder than the threshold will be compressed but by how much?

This is what the ratio sets. the higher the ratio, the more merciless the compression.

For example a ratio of 10:1 means that if a sound is 10 dB louder than the threshold volume, after compression, it will only be 1 dB louder.

The higher the ratio, the more obvious the compression. If the ratio is set to infinity. then the audio will never exceed the threshold, this is called limiting.

Attack

How long after the compressor detects the volume exceeding the threshold will it actually start compressing.

Release

How long the compressor will continue compressing.

A quick warning to those using compression. Use it with reason. Don’t just throw a compressor onto any bit of audio if it sounds fine. If you do use a compressor, especially for music, please don’t compress the shit out of it, Loudness Wars prove it isn’t great for music.

The post Audio Compression Intro and Basics – How to use a compressor appeared first on Audio Ordeal.