Delay.h

Go to the documentation of this file.

/*
 * Delay.h - Delay effect objects to use as building blocks in DSP
 *
 * Copyright (c) 2014 Vesa Kivimäki <contact/dot/diizy/at/nbl/dot/fi>
 * Copyright (c) 2006-2014 Tobias Doerffel <tobydox/at/users.sourceforge.net>
 *
 * This file is part of LMMS - https://lmms.io
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program (see COPYING); if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA.
 *
 */
 
#ifndef LMMS_DELAY_H
#define LMMS_DELAY_H
 
#include <cmath>
 
#include "LmmsTypes.h"
 
namespace lmms
{
 
// brief usage 
 
// Classes:
 
// CombFeedback: a feedback comb filter - basically a simple delay line, makes a comb shape in the freq response
// CombFeedfwd: a feed-forward comb filter - an "inverted" comb filter, can be combined with CombFeedback to create a net allpass if negative gain is used
// CombFeedbackDualtap: same as CombFeedback but takes two delay values
// AllpassDelay: an allpass delay - combines feedback and feed-forward - has flat frequency response
 
// all classes are templated with channel count, any arbitrary channel count can be used for each fx
 
// Methods (for all classes):
 
// setDelay sets delay amount in frames. It's up to you to make this samplerate-agnostic. 
// Fractions are allowed - linear interpolation is used to deal with them
// CombFeedbackDualTap is a special case: it requires 2 delay times
 
// setMaxDelay (re)sets the maximum allowed delay, in frames
// NOTE: for performance reasons, there's no bounds checking at setDelay, so make sure you set maxDelay >= delay!
 
// clearHistory clears the delay buffer
 
// setGain sets the feedback/feed-forward gain, in linear amplitude, negative values are allowed
// 1.0 is full feedback/feed-forward, -1.0 is full negative feedback/feed-forward
 
// update runs the fx for one frame - takes as arguments input and number of channel to run, returns output
 
template<ch_cnt_t CHANNELS>
class CombFeedback
{
public:
        using frame = std::array<double, CHANNELS>;
 
        CombFeedback( int maxDelay ) :
                m_size( maxDelay ),
                m_position( 0 ),
                m_feedBack( 0.0 ),
                m_delay( 0 ),
                m_fraction( 0.0 )
        {
                m_buffer = new frame[maxDelay];
                memset( m_buffer, 0, sizeof( frame ) * maxDelay );
        }
        virtual ~CombFeedback()
        {
                delete[] m_buffer;
        }
        
        inline void setMaxDelay( int maxDelay )
        {
                if( maxDelay > m_size )
                {
                        delete[] m_buffer;
                        m_buffer = new frame[maxDelay];
                        memset( m_buffer, 0, sizeof( frame ) * maxDelay );
                }
                m_size = maxDelay;
                m_position %= m_size;
        }
        
        inline void clearHistory()
        {
                memset( m_buffer, 0, sizeof( frame ) * m_size );
        }
        
        inline void setDelay( double delay )
        {
                m_delay = static_cast<int>( ceil( delay ) );
                m_fraction = 1.0 - ( delay - floor( delay ) );
        }
        
        inline void setGain( double gain )
        {
                m_gain = gain;
        }
        
        inline double update( double in, ch_cnt_t ch )
        {
                int readPos = m_position - m_delay;
                if( readPos < 0 ) { readPos += m_size; }
                
                const double y = std::lerp(m_buffer[readPos][ch], m_buffer[(readPos + 1) % m_size][ch], m_fraction);
                
                ++m_position %= m_size;
                
                m_buffer[m_position][ch] = in + m_gain * y;
                return y;
        }
 
private:
        frame * m_buffer;
        int m_size;
        int m_position;
        double m_gain;
        int m_delay;
        double m_fraction;
};
 
 
template<ch_cnt_t CHANNELS>
class CombFeedfwd
{
        using frame = std::array<double, CHANNELS>;
 
        CombFeedfwd( int maxDelay ) :
                m_size( maxDelay ),
                m_position( 0 ),
                m_feedBack( 0.0 ),
                m_delay( 0 ),
                m_fraction( 0.0 )
        {
                m_buffer = new frame[maxDelay];
                memset( m_buffer, 0, sizeof( frame ) * maxDelay );
        }
        virtual ~CombFeedfwd()
        {
                delete[] m_buffer;
        }
        
        inline void setMaxDelay( int maxDelay )
        {
                if( maxDelay > m_size )
                {
                        delete[] m_buffer;
                        m_buffer = new frame[maxDelay];
                        memset( m_buffer, 0, sizeof( frame ) * maxDelay );
                }
                m_size = maxDelay;
                m_position %= m_size;
        }
        
        inline void clearHistory()
        {
                memset( m_buffer, 0, sizeof( frame ) * m_size );
        }
        
        inline void setDelay( double delay )
        {
                m_delay = static_cast<int>( ceil( delay ) );
                m_fraction = 1.0 - ( delay - floor( delay ) );
        }
        
        inline void setGain( double gain )
        {
                m_gain = gain;
        }
        
        inline double update( double in, ch_cnt_t ch )
        {
                int readPos = m_position - m_delay;
                if( readPos < 0 ) { readPos += m_size; }
                
                const double y = std::lerp(m_buffer[readPos][ch], m_buffer[(readPos + 1) % m_size][ch], m_fraction) + in * m_gain;
                
                ++m_position %= m_size;
                
                m_buffer[m_position][ch] = in;
                return y;
        }
 
private:
        frame * m_buffer;
        int m_size;
        int m_position;
        double m_gain;
        int m_delay;
        double m_fraction;
};
 
 
template<ch_cnt_t CHANNELS>
class CombFeedbackDualtap
{
        using frame = std::array<double, CHANNELS>;
 
        CombFeedbackDualtap( int maxDelay ) :
                m_size( maxDelay ),
                m_position( 0 ),
                m_feedBack( 0.0 ),
                m_delay( 0 ),
                m_fraction( 0.0 )
        {
                m_buffer = new frame[maxDelay];
                memset( m_buffer, 0, sizeof( frame ) * maxDelay );
        }
        virtual ~CombFeedbackDualtap()
        {
                delete[] m_buffer;
        }
        
        inline void setMaxDelay( int maxDelay )
        {
                if( maxDelay > m_size )
                {
                        delete[] m_buffer;
                        m_buffer = new frame[maxDelay];
                        memset( m_buffer, 0, sizeof( frame ) * maxDelay );
                }
                m_size = maxDelay;
                m_position %= m_size;
        }
        
        inline void clearHistory()
        {
                memset( m_buffer, 0, sizeof( frame ) * m_size );
        }
        
        inline void setDelays( double delay1, double delay2 )
        {
                m_delay1 = static_cast<int>( ceil( delay1 ) );
                m_fraction1 = 1.0 - ( delay1 - floor( delay1 ) );
                
                m_delay2 = static_cast<int>( ceil( delay2 ) );
                m_fraction2 = 1.0 - ( delay2 - floor( delay2 ) );
        }
        
        inline void setGain( double gain )
        {
                m_gain = gain;
        }
        
        inline double update( double in, ch_cnt_t ch )
        {
                int readPos1 = m_position - m_delay1;
                if( readPos1 < 0 ) { readPos1 += m_size; }
                
                int readPos2 = m_position - m_delay2;
                if( readPos2 < 0 ) { readPos2 += m_size; }
                
                const double y = std::lerp(m_buffer[readPos1][ch], m_buffer[(readPos1 + 1) % m_size][ch], m_fraction1)
                        + std::lerp(m_buffer[readPos2][ch], m_buffer[(readPos2 + 1) % m_size][ch], m_fraction2);
                
                ++m_position %= m_size;
                
                m_buffer[m_position][ch] = in + m_gain * y;
                return y;
        }
 
private:
        frame * m_buffer;
        int m_size;
        int m_position;
        double m_gain;
        int m_delay1;
        int m_delay2;
        double m_fraction1;
        double m_fraction2;
};
 
 
template<ch_cnt_t CHANNELS>
class AllpassDelay
{
public:
        using frame = std::array<double, CHANNELS>;
 
        AllpassDelay( int maxDelay ) :
                m_size( maxDelay ),
                m_position( 0 ),
                m_feedBack( 0.0 ),
                m_delay( 0 ),
                m_fraction( 0.0 )
        {
                m_buffer = new frame[maxDelay];
                memset( m_buffer, 0, sizeof( frame ) * maxDelay );
        }
        virtual ~AllpassDelay()
        {
                delete[] m_buffer;
        }
        
        inline void setMaxDelay( int maxDelay )
        {
                if( maxDelay > m_size )
                {
                        delete[] m_buffer;
                        m_buffer = new frame[maxDelay];
                        memset( m_buffer, 0, sizeof( frame ) * maxDelay );
                }
                m_size = maxDelay;
                m_position %= m_size;
        }
        
        inline void clearHistory()
        {
                memset( m_buffer, 0, sizeof( frame ) * m_size );
        }
        
        inline void setDelay( double delay )
        {
                m_delay = static_cast<int>( ceil( delay ) );
                m_fraction = 1.0 - ( delay - floor( delay ) );
        }
        
        inline void setGain( double gain )
        {
                m_gain = gain;
        }
        
        inline double update( double in, ch_cnt_t ch )
        {
                int readPos = m_position - m_delay;
                if( readPos < 0 ) { readPos += m_size; }
                
                const double y = std::lerp(m_buffer[readPos][ch], m_buffer[(readPos + 1) % m_size][ch], m_fraction) + in * -m_gain;
                const double x = in + m_gain * y;
                
                ++m_position %= m_size;
                
                m_buffer[m_position][ch] = x;
                return y;
        }
 
private:
        frame * m_buffer;
        int m_size;
        int m_position;
        double m_gain;
        int m_delay;
        double m_fraction;      
};
 
// convenience typedefs for stereo effects
using StereoCombFeedback = CombFeedback<2>;
using StereoCombFeedfwd = CombFeedfwd<2>;
using StereoCombFeedbackDualtap = CombFeedbackDualtap<2>;
using StereoAllpassDelay = AllpassDelay<2>;
 
} // namespace lmms
 
#endif // LMMS_DELAY_H