CDSPResampler.h

Go to the documentation of this file.

//$ nobt
//$ nocpp

 
#ifndef R8B_CDSPRESAMPLER_INCLUDED
#define R8B_CDSPRESAMPLER_INCLUDED
 
#include "CDSPHBDownsampler.h"
#include "CDSPHBUpsampler.h"
#include "CDSPBlockConvolver.h"
#include "CDSPFracInterpolator.h"
 
namespace r8b {

 
class CDSPResampler : public CDSPProcessor
{
public:
 
    CDSPResampler( const double SrcSampleRate, const double DstSampleRate,
        const int aMaxInLen, const double ReqTransBand = 2.0,
        const double ReqAtten = 206.91,
        const EDSPFilterPhaseResponse ReqPhase = fprLinearPhase )
        : MaxInLen( aMaxInLen )
        , CurMaxOutLen( aMaxInLen )
        , LatencyFrac( 0.0 )
    {
        R8BASSERT( SrcSampleRate > 0.0 );
        R8BASSERT( DstSampleRate > 0.0 );
        R8BASSERT( MaxInLen > 0 );
        R8BASSERT( ReqTransBand > 0.0 );
        R8BASSERT( ReqAtten > 0.0 );
 
        R8BCONSOLE( "* CDSPResampler: src=%.1f dst=%.1f len=%i tb=%.1f "
            "att=%.2f ph=%i\n", SrcSampleRate, DstSampleRate, aMaxInLen,
            ReqTransBand, ReqAtten, (int) ReqPhase );
 
        if( SrcSampleRate == DstSampleRate )
        {
            return;
        }
 
        TmpBufCapacities[ 0 ] = 0;
        TmpBufCapacities[ 1 ] = 0;
        CurTmpBuf = 0;
 
        // Try some common efficient ratios requiring only a single step.
 
        const int CommonRatioCount = 5;
        const int CommonRatios[ CommonRatioCount ][ 2 ] = {
            { 1, 2 },
            { 1, 3 },
            { 2, 3 },
            { 3, 2 },
            { 3, 4 }
        };
 
        int i;
 
        for( i = 0; i < CommonRatioCount; i++ )
        {
            const int num = CommonRatios[ i ][ 0 ];
            const int den = CommonRatios[ i ][ 1 ];
 
            if( SrcSampleRate * num == DstSampleRate * den )
            {
                addProcessor( new CDSPBlockConvolver(
                    CDSPFIRFilterCache :: getLPFilter(
                    1.0 / ( num > den ? num : den ), ReqTransBand,
                    ReqAtten, ReqPhase, num, den ), num, den, LatencyFrac ));
 
                createTmpBuffers();
                return;
            }
        }
 
        // Try whole-number power-of-2 or 3*power-of-2 upsampling.
 
        for( i = 2; i <= 3; i++ )
        {
            bool WasFound = false;
            double sm = i;
            int c = 0;
 
            while( true )
            {
                const double NewSR = SrcSampleRate * sm;
 
                if( NewSR == DstSampleRate )
                {
                    WasFound = true;
                    break;
                }
 
                if( NewSR > DstSampleRate )
                {
                    break;
                }
 
                sm *= 2.0;
                c++;
            }
 
            if( WasFound )
            {
                addProcessor( new CDSPBlockConvolver(
                    CDSPFIRFilterCache :: getLPFilter( 1.0 / i, ReqTransBand,
                    ReqAtten, ReqPhase, i, 1 ), i, 1, LatencyFrac ));
 
                const bool IsThirdFirst = ( i == 3 );
 
                for( i = 0; i < c; i++ )
                {
                    addProcessor( new CDSPHBUpsampler( ReqAtten, i,
                        ( IsThirdFirst || i > 1 ), LatencyFrac ));
                }
 
                createTmpBuffers();
                return;
            }
        }
 
        if( DstSampleRate * 2.0 > SrcSampleRate )
        {
            // Upsampling or fractional downsampling down to 2X.
 
            const double NormFreq = ( DstSampleRate > SrcSampleRate ? 0.5 :
                0.5 * DstSampleRate / SrcSampleRate );
 
            addProcessor( new CDSPBlockConvolver(
                CDSPFIRFilterCache :: getLPFilter( NormFreq, ReqTransBand,
                ReqAtten, ReqPhase, 2.0, 1 ), 2, 1, LatencyFrac ));
 
            // Try intermediate interpolated resampling with subsequent 2X
            // or 3X upsampling.
 
            const double tbw = 0.0175; // Intermediate filter's transition
                // band extension coefficient.
            const double ThreshSampleRate = SrcSampleRate /
                ( 1.0 - tbw * ReqTransBand ); // Make sure intermediate
                // filter's transition band is not steeper than ReqTransBand
                // (this keeps the latency under control).
 
            int c = 0;
            double div = 1.0;
 
            while( true )
            {
                const double ndiv = div * 2.0;
 
                if( DstSampleRate < ThreshSampleRate * ndiv )
                {
                    break;
                }
 
                div = ndiv;
                c++;
            }
 
            const double SrcSampleRate2 = SrcSampleRate * 2.0;
            int tmp1;
            int tmp2;
 
            if( c == 1 && getWholeStepping( SrcSampleRate2, DstSampleRate,
                tmp1, tmp2 ))
            {
                // Do not use intermediate interpolation if whole stepping is
                // available as it performs very fast.
 
                c = 0;
            }
 
            if( c > 0 )
            {
                // Add steps using intermediate interpolation.
 
                const int num = 2;
 
                addProcessor( new CDSPFracInterpolator( SrcSampleRate2 * div,
                    DstSampleRate, ReqAtten, false, LatencyFrac ));
 
                double tb = ( 1.0 - SrcSampleRate * div / DstSampleRate ) /
                    tbw; // Divide TransBand by a constant that assures a
                    // linear response in the pass-band.
 
                if( tb > CDSPFIRFilter :: getLPMaxTransBand() )
                {
                    tb = CDSPFIRFilter :: getLPMaxTransBand();
                }
 
                addProcessor( new CDSPBlockConvolver(
                    CDSPFIRFilterCache :: getLPFilter( 1.0 / num, tb,
                    ReqAtten, ReqPhase, num, 1 ), num, 1, LatencyFrac ));
 
                for( i = 1; i < c; i++ )
                {
                    addProcessor( new CDSPHBUpsampler( ReqAtten, i - 1,
                        ( i > 2 ), LatencyFrac ));
                }
            }
            else
            {
                addProcessor( new CDSPFracInterpolator( SrcSampleRate2,
                    DstSampleRate, ReqAtten, false, LatencyFrac ));
            }
 
            createTmpBuffers();
            return;
        }
 
        // Use downsampling steps, including power-of-2 downsampling.
 
        double CheckSR = DstSampleRate * 4.0;
        double SrcSRDiv = 1.0;
        int c = 0;
 
        while( CheckSR <= SrcSampleRate )
        {
            c++;
            CheckSR *= 2.0;
            SrcSRDiv *= 2.0;
        }
 
        const double FinGain = 1.0 / SrcSRDiv;
 
        double NormFreq = 0.5;
        bool UseInterp = true;
        bool IsThirdFirst = false;
        int downf;
 
        for( downf = 2; downf <= 3; downf++ )
        {
            if( DstSampleRate * SrcSRDiv * downf == SrcSampleRate )
            {
                NormFreq = 1.0 / downf;
                UseInterp = false;
                IsThirdFirst = ( downf == 3 );
                break;
            }
        }
 
        if( UseInterp )
        {
            downf = 1;
            NormFreq = DstSampleRate * SrcSRDiv / SrcSampleRate;
            IsThirdFirst = ( NormFreq * 3.0 <= 1.0 );
        }
 
        for( i = 0; i < c; i++ )
        {
            // Use fixed, very relaxed 2X downsampling filters, that at the
            // final stage only guarantee stop-band between 0.75 and 1.0 of
            // Nyquist. 0.5-0.75 range will be aliased to 0.25-0.5 range which
            // will then be filtered out by the final filter.
 
            addProcessor( new CDSPHBDownsampler( ReqAtten, c - 1 - i,
                ( IsThirdFirst || i < c - 2 ), LatencyFrac ));
        }
 
        addProcessor( new CDSPBlockConvolver(
            CDSPFIRFilterCache :: getLPFilter( NormFreq, ReqTransBand,
            ReqAtten, ReqPhase, FinGain, downf ), 1, downf, LatencyFrac ));
 
        if( UseInterp )
        {
            addProcessor( new CDSPFracInterpolator( SrcSampleRate,
                DstSampleRate * SrcSRDiv, ReqAtten, IsThirdFirst,
                LatencyFrac ));
        }
 
        createTmpBuffers();
    }
 
    virtual int getInLenBeforeOutPos( int ReqOutPos ) const
    {
        R8BASSERT( ReqOutPos >= 0 );
 
        if( Next != R8B_NULL )
        {
            ReqOutPos = Next -> getInLenBeforeOutPos( ReqOutPos );
        }
 
        if( StepFirst != R8B_NULL )
        {
            ReqOutPos = StepFirst -> getInLenBeforeOutPos( ReqOutPos );
        }
 
        return( ReqOutPos );
    }

 
    int getInLenBeforeOutStart( const int ReqOutPos = 0 )
    {
        R8BASSERT( ReqOutPos >= 0 );
 
        int inc = 0;
        int outc = 0;
 
        while( true )
        {
            double ins = 0.0;
            double* op;
            outc += process( &ins, 1, op );
 
            if( outc > ReqOutPos )
            {
                clear();
                return( inc );
            }
 
            inc++;
        }
    }

 
    int getInputRequiredForOutput( const int ReqOutSamples ) const
    {
        if( ReqOutSamples < 1 )
        {
            return( 0 );
        }
 
        return( getInLenBeforeOutPos( ReqOutSamples - 1 ) + 1 );
    }
 
    virtual int getLatency() const
    {
        return( 0 );
    }
 
    virtual double getLatencyFrac() const
    {
        return( LatencyFrac );
    }

 
    virtual int getMaxOutLen( const int/* MaxInLen */) const
    {
        return( CurMaxOutLen );
    }

 
    virtual void clear()
    {
        CDSPProcessor* ps = StepFirst;
 
        while( ps != R8B_NULL )
        {
            ps -> clear();
            ps = ps -> Next;
        }
    }

 
    virtual int process( double* ip0, int l, double*& op0 )
    {
        R8BASSERT( l >= 0 && l <= MaxInLen );
 
        double* ip = ip0;
        int tp = 0;
        CDSPProcessor* ps = StepFirst;
 
        while( ps != R8B_NULL )
        {
            double* op = TmpBufs[ tp ];
            l = ps -> process( ip, l, op );
            ps = ps -> Next;
            ip = op;
            tp ^= 1;
        }
 
        op0 = ip;
        return( l );
    }

 
    template< typename Tin, typename Tout >
    void oneshot( Tin* ip, int iplen, Tout* op, int oplen )
    {
        CFixedBuffer< double > Buf( MaxInLen );
        bool IsZero = false;
 
        while( oplen > 0 )
        {
            int rc;
            double* p;
            int i;
 
            if( iplen == 0 )
            {
                rc = MaxInLen;
                p = &Buf[ 0 ];
 
                if( !IsZero )
                {
                    IsZero = true;
                    memset( p, 0, MaxInLen * sizeof( p[ 0 ]));
                }
            }
            else
            {
                rc = min( iplen, MaxInLen );
                p = getOneshotBuf( ip, Buf, rc );
                ip += rc;
                iplen -= rc;
            }
 
            double* op0;
            int wc = process( p, rc, op0 );
            wc = min( oplen, wc );
 
            for( i = 0; i < wc; i++ )
            {
                op[ i ] = (Tout) op0[ i ];
            }
 
            op += wc;
            oplen -= wc;
        }
 
        clear();
    }
 
private:
    CPtrKeeper< CDSPProcessor > StepFirst; 
    CDSPProcessor* StepLast; 
    int MaxInLen; 
    CFixedBuffer< double > TmpBufAll; 
    double* TmpBufs[ 2 ]; 
    int TmpBufCapacities[ 2 ]; 
    int CurTmpBuf; 
    int CurMaxOutLen; 
    double LatencyFrac; 

 
    void addProcessor( CDSPProcessor* const Proc )
    {
        if( StepFirst != R8B_NULL )
        {
            StepLast -> Next = Proc;
        }
        else
        {
            StepFirst = Proc;
        }
 
        StepLast = Proc;
 
        LatencyFrac = Proc -> getLatencyFrac();
        CurMaxOutLen = Proc -> getMaxOutLen( CurMaxOutLen );
 
        if( CurMaxOutLen > TmpBufCapacities[ CurTmpBuf ])
        {
            TmpBufCapacities[ CurTmpBuf ] = CurMaxOutLen;
        }
 
        CurTmpBuf ^= 1;
    }

 
    void createTmpBuffers()
    {
        const int ol = TmpBufCapacities[ 0 ] + TmpBufCapacities[ 1 ];
 
        if( ol > 0 )
        {
            TmpBufAll.alloc( ol );
            TmpBufs[ 0 ] = &TmpBufAll[ 0 ];
            TmpBufs[ 1 ] = &TmpBufAll[ TmpBufCapacities[ 0 ]];
        }
 
        R8BCONSOLE( "* CDSPResampler: init done\n" );
    }

 
    static double* getOneshotBuf( double* const ip, double* const, const int )
    {
        return( ip );
    }

 
    static double* getOneshotBuf( float* const ip, double* const Buf,
        const int rc )
    {
        int i;
 
        for( i = 0; i < rc; i++ )
        {
            Buf[ i ] = ip[ i ];
        }
 
        return( Buf );
    }
};

 
class CDSPResampler16 : public CDSPResampler
{
public:
 
    CDSPResampler16( const double SrcSampleRate, const double DstSampleRate,
        const int aMaxInLen, const double ReqTransBand = 2.0 )
        : CDSPResampler( SrcSampleRate, DstSampleRate, aMaxInLen, ReqTransBand,
            136.45, fprLinearPhase )
    {
    }
};

 
class CDSPResampler16IR : public CDSPResampler
{
public:
 
    CDSPResampler16IR( const double SrcSampleRate, const double DstSampleRate,
        const int aMaxInLen, const double ReqTransBand = 2.0 )
        : CDSPResampler( SrcSampleRate, DstSampleRate, aMaxInLen, ReqTransBand,
            109.56, fprLinearPhase )
    {
    }
};

 
class CDSPResampler24 : public CDSPResampler
{
public:
 
    CDSPResampler24( const double SrcSampleRate, const double DstSampleRate,
        const int aMaxInLen, const double ReqTransBand = 2.0 )
        : CDSPResampler( SrcSampleRate, DstSampleRate, aMaxInLen, ReqTransBand,
            180.15, fprLinearPhase )
    {
    }
};
 
} // namespace r8b
 
#endif // R8B_CDSPRESAMPLER_INCLUDED