DanielRudrich::LookAheadGainReduction Class Reference

#include <LookAheadGainReduction.h>

Collaboration diagram for DanielRudrich::LookAheadGainReduction:

Public Member Functions
	LookAheadGainReduction ()
	~LookAheadGainReduction ()
void	setDelayTime (float delayTimeInSeconds)
const int	getDelayInSamples ()
void	prepare (const double sampleRate, const int blockSize)
void	pushSamples (const float *src, const int numSamples)
void	process ()
void	readSamples (float *dest, const int numSamples)

Private Member Functions
void	getProcessPositions (int startIndex, int numSamples, int &blockSize1, int &blockSize2)
void	getWritePositions (int numSamples, int &startIndex, int &blockSize1, int &blockSize2)
void	getReadPositions (int numSamples, int &startIndex, int &blockSize1, int &blockSize2)

Private Attributes
double	sampleRate
int	blockSize
float	delay
int	delayInSamples = 0
int	writePosition = 0
int	lastPushedSamples = 0
std::vector< float >	buffer

Detailed Description

This class acts as a delay line for gain-reduction samples, which additionally fades in high gain-reduction values in order to avoid distortion when limiting an audio signal.

Definition at line 26 of file LookAheadGainReduction.h.

Constructor & Destructor Documentation

LookAheadGainReduction()

DanielRudrich::LookAheadGainReduction::LookAheadGainReduction ( )

inline

Definition at line 29 of file LookAheadGainReduction.h.

: sampleRate (0.0) {}

~LookAheadGainReduction()

DanielRudrich::LookAheadGainReduction::~LookAheadGainReduction ( )

inline

Definition at line 30 of file LookAheadGainReduction.h.

{}

Member Function Documentation

getDelayInSamples()

const int DanielRudrich::LookAheadGainReduction::getDelayInSamples ( )

inline

Definition at line 34 of file LookAheadGainReduction.h.

{ return delayInSamples; }

References delayInSamples.

getProcessPositions()

void DanielRudrich::LookAheadGainReduction::getProcessPositions ( int  startIndex, int  numSamples, int &  blockSize1, int &  blockSize2  )

inlineprivate

A little helper-function which calulcates how many samples we should process in a first step before we have to wrap around, as our buffer is a ring-buffer.

Definition at line 213 of file LookAheadGainReduction.cpp.

{
    if (numSamples <= 0)
    {
        blockSize1 = 0;
        blockSize2 = 0;
    }
    else
    {
        blockSize1 = std::min (startIndex + 1, numSamples);
        numSamples -= blockSize1;
        blockSize2 = numSamples <= 0 ? 0 : numSamples;
    }
}

References min().

Referenced by process().

Here is the call graph for this function:

Here is the caller graph for this function:

getReadPositions()

void DanielRudrich::LookAheadGainReduction::getReadPositions ( int  numSamples, int &  startIndex, int &  blockSize1, int &  blockSize2  )

inlineprivate

Definition at line 252 of file LookAheadGainReduction.cpp.

{
    const int L = static_cast<int> (buffer.size());
    int pos = writePosition - lastPushedSamples - delayInSamples;
 
    if (pos < 0)
        pos = pos + L;
    pos = pos % L;
 
    if (numSamples <= 0)
    {
        startIndex = 0;
        blockSize1 = 0;
        blockSize2 = 0;
    }
    else
    {
        startIndex = pos;
        blockSize1 = std::min (L - pos, numSamples);
        numSamples -= blockSize1;
        blockSize2 = numSamples <= 0 ? 0 : numSamples;
    }
}

References buffer, delayInSamples, lastPushedSamples, min(), and writePosition.

Referenced by readSamples().

Here is the call graph for this function:

Here is the caller graph for this function:

getWritePositions()

void DanielRudrich::LookAheadGainReduction::getWritePositions ( int  numSamples, int &  startIndex, int &  blockSize1, int &  blockSize2  )

inlineprivate

Definition at line 228 of file LookAheadGainReduction.cpp.

{
    const int L = static_cast<int> (buffer.size());
    int pos = writePosition;
 
    if (pos < 0)
        pos = pos + L;
    pos = pos % L;
 
    if (numSamples <= 0)
    {
        startIndex = 0;
        blockSize1 = 0;
        blockSize2 = 0;
    }
    else
    {
        startIndex = pos;
        blockSize1 = std::min (L - pos, numSamples);
        numSamples -= blockSize1;
        blockSize2 = numSamples <= 0 ? 0 : numSamples;
    }
}

References buffer, min(), and writePosition.

Referenced by pushSamples().

Here is the call graph for this function:

Here is the caller graph for this function:

prepare()

void DanielRudrich::LookAheadGainReduction::prepare	(	const double	sampleRate,
		const int	blockSize
	)

Prepares the processor so it can resize the buffers depending on samplerate and the expected buffersize.

Definition at line 36 of file LookAheadGainReduction.cpp.

{
    sampleRate = newSampleRate;
    blockSize = newBlockSize;
 
    delayInSamples = static_cast<int> (delay * sampleRate);
 
    buffer.resize (blockSize + delayInSamples);
    std::fill (buffer.begin(), buffer.end(), 0.0f);
    writePosition = 0;
}

References blockSize, buffer, delay, delayInSamples, sampleRate, and writePosition.

Referenced by setDelayTime().

Here is the caller graph for this function:

process()

void DanielRudrich::LookAheadGainReduction::process

(

)

Processes the data within the delay line, i.e. fades-in high gain-reduction, in order to reduce distortions.

The basic idea here is to look for high gain-reduction values in the signal, and apply a fade which starts exactly delayInSamples many samples before that value appears. Depending on the value itself, the slope of the fade will vary.

Some things to note:

• as the samples are gain-reduction values in decibel, we actually look for negative peaks or local minima.
• it's easier for us to time-reverse our search, so we start with the last sample
• once we find a minimum, we calculate the slope, which will be called step
• with that slope, we can calculate the next value of our fade-in nextGainReductionValue
• once a value in the buffer is below our fade-in value, we found a new minimum, which might not be as deep as the previous one, but as it comes in earlier, it needs more attention, so we update our fade-in slope
• our buffer is a ring-buffer which makes things a little bit messy

Definition at line 68 of file LookAheadGainReduction.cpp.

{
    // As we don't know any samples of the future, yet, we assume we don't have to apply a fade-in right now, and initialize both `nextGainReductionValue` and step (slope of the fade-in) with zero.
    float nextGainReductionValue = 0.0f;
    float step = 0.0f;
 
 
    // Get the position of the last sample in the buffer, which is the sample right before our new write position.
    int index = writePosition - 1;
    if (index < 0) // in case it's negative...
        index += static_cast<int> (buffer.size()); // ... add the buffersize so we wrap around.
 
    // == FIRST STEP: Process all recently pushed samples.
 
    // We want to process all `lastPushedSamples` many samples, so let's find out, how many we can process in a first run before we have to wrap around our `index` variable (ring-buffer).
    int size1, size2;
    getProcessPositions (index, lastPushedSamples, size1, size2);
 
    // first run
    for (int i = 0; i < size1; ++i)
    {
        const float smpl = buffer[index];
 
        if (smpl > nextGainReductionValue) // in case the sample is above our ramp...
        {
            buffer[index] = nextGainReductionValue; // ... replace it with the current ramp value
            nextGainReductionValue += step; // and update the next ramp value
        }
        else // otherwise... (new peak)
        {
            step = - smpl / delayInSamples; // calculate the new slope
            nextGainReductionValue = smpl + step; // and also the new ramp value
        }
        --index;
    }
 
    // second run
    if (size2 > 0) // in case we have some samples left for the second run
    {
        index = static_cast<int> (buffer.size()) - 1; // wrap around: start from the last sample of the buffer
 
        // exactly the same procedure as before... I guess I could have written that better...
        for (int i = 0; i < size2; ++i)
        {
            const float smpl = buffer[index];
 
            if (smpl > nextGainReductionValue)
            {
                buffer[index] = nextGainReductionValue;
                nextGainReductionValue += step;
            }
            else
            {
                step = - smpl / delayInSamples;
                nextGainReductionValue = smpl + step;
            }
            --index;
        }
    }
 
    /*
     At this point, we have processed all the new gain-reduction values. For this, we actually don't need a delay/lookahead at all.
     !! However, we are not finished, yet !!
     What if the first pushed sample has such a high gain-reduction value, that itself needs a fade-in? So we have to apply a gain-ramp even further into the past. And that is exactly the reason why we need lookahead, why we need to buffer our signal for a short amount of time: so we can apply that gain ramp for the first handful of gain-reduction samples.
     */
 
    if (index < 0) // it's possible the index is exactly -1
        index = static_cast<int> (buffer.size()) - 1; // so let's take care of that
 
    /*
     This time we only need to check `delayInSamples` many samples.
     And there's another cool thing!
        We know that the samples have been processed already, so in case one of the samples is below our ramp value, that's the new minimum, which has been faded-in already! So what we do is hit the break, and call it a day!
     */
    getProcessPositions (index, delayInSamples, size1, size2);
    bool breakWasUsed = false;
 
    // first run
    for (int i = 0; i < size1; ++i) // we iterate over the first size1 samples
    {
        const float smpl = buffer[index];
 
        if (smpl > nextGainReductionValue) // in case the sample is above our ramp...
        {
            buffer[index] = nextGainReductionValue; // ... replace it with the current ramp value
            nextGainReductionValue += step; // and update the next ramp value
        }
        else // otherwise... JACKPOT! Nothing left to do here!
        {
            breakWasUsed = true; // let the guys know we are finished
            break;
        }
        --index;
    }
 
    // second run
    if (! breakWasUsed && size2 > 0) // is there still some work to do?
    {
        index = static_cast<int> (buffer.size()) - 1; // wrap around (ring-buffer)
        for (int i = 0; i < size2; ++i)
        {
            const float smpl = buffer[index];
 
            // same as before
            if (smpl > nextGainReductionValue) // in case the sample is above our ramp...
            {
                buffer[index] = nextGainReductionValue; // ... replace it with the current ramp value
                nextGainReductionValue += step; // and update the next ramp value
            }
            else // otherwise... already processed -> byebye!
                break;
            --index;
        }
    }
}

References buffer, delayInSamples, getProcessPositions(), lastPushedSamples, and writePosition.

Here is the call graph for this function:

pushSamples()

void DanielRudrich::LookAheadGainReduction::pushSamples	(	const float *	src,
		const int	numSamples
	)

Writes gain-reduction samples into the delay-line. Make sure you call process() afterwards, and read the same amount of samples with the readSamples method. Make also sure the pushed samples are decibel values.

Definition at line 48 of file LookAheadGainReduction.cpp.

{
    int startIndex, blockSize1, blockSize2;
 
    // write in delay line
    getWritePositions (numSamples, startIndex, blockSize1, blockSize2);
 
    for (int i = 0; i < blockSize1; ++i)
        buffer[startIndex + i] = src[i];
 
    if (blockSize2 > 0)
        for (int i = 0; i < blockSize2; ++i)
            buffer[i] = src[blockSize1 + i];
 
    writePosition += numSamples;
    writePosition = writePosition % buffer.size();
 
    lastPushedSamples = numSamples;
}

References buffer, getWritePositions(), lastPushedSamples, and writePosition.

Here is the call graph for this function:

readSamples()

void DanielRudrich::LookAheadGainReduction::readSamples	(	float *	dest,
		const int	numSamples
	)

Reads smoothed gain-reduction samples back to the destination. Make sure you read as many samples as you've pushed before!

Definition at line 197 of file LookAheadGainReduction.cpp.

{
    int startIndex, blockSize1, blockSize2;
 
    // read from delay line
    getReadPositions (numSamples, startIndex, blockSize1, blockSize2);
 
    for (int i = 0; i < blockSize1; ++i)
        dest[i] = buffer[startIndex + i];
 
    if (blockSize2 > 0)
        for (int i = 0; i < blockSize2; ++i)
            dest[blockSize1 + i] = buffer[i];
}

References buffer, and getReadPositions().

Here is the call graph for this function:

setDelayTime()

void DanielRudrich::LookAheadGainReduction::setDelayTime

(

float

delayTimeInSeconds

)

Definition at line 25 of file LookAheadGainReduction.cpp.

{
    if (delayTimeInSeconds <= 0.0f)
        delay = 0.0f;
    else
        delay = delayTimeInSeconds;
 
    if (sampleRate != 0.0)
        prepare (sampleRate, blockSize);
}

References blockSize, delay, prepare(), and sampleRate.

Here is the call graph for this function:

Member Data Documentation

blockSize

int DanielRudrich::LookAheadGainReduction::blockSize

private

Definition at line 66 of file LookAheadGainReduction.h.

Referenced by prepare(), and setDelayTime().

buffer

std::vector<float> DanielRudrich::LookAheadGainReduction::buffer

private

Definition at line 72 of file LookAheadGainReduction.h.

Referenced by getReadPositions(), getWritePositions(), prepare(), process(), pushSamples(), and readSamples().

delay

float DanielRudrich::LookAheadGainReduction::delay

private

Definition at line 68 of file LookAheadGainReduction.h.

Referenced by prepare(), and setDelayTime().

delayInSamples

int DanielRudrich::LookAheadGainReduction::delayInSamples = 0

private

Definition at line 69 of file LookAheadGainReduction.h.

Referenced by getDelayInSamples(), getReadPositions(), prepare(), and process().

lastPushedSamples

int DanielRudrich::LookAheadGainReduction::lastPushedSamples = 0

private

Definition at line 71 of file LookAheadGainReduction.h.

Referenced by getReadPositions(), process(), and pushSamples().

sampleRate

double DanielRudrich::LookAheadGainReduction::sampleRate

private

Definition at line 65 of file LookAheadGainReduction.h.

Referenced by prepare(), and setDelayTime().

writePosition

int DanielRudrich::LookAheadGainReduction::writePosition = 0

private

Definition at line 70 of file LookAheadGainReduction.h.

Referenced by getReadPositions(), getWritePositions(), prepare(), process(), and pushSamples().

---

The documentation for this class was generated from the following files:

• LookAheadGainReduction.h
• LookAheadGainReduction.cpp