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 )
        : StepCapacity( 0 )
        , StepCount( 0 )
        , MaxInLen( aMaxInLen )
        , CurMaxOutLen( aMaxInLen )
        , LatencyFrac( 0.0 )
    {
        R8BASSERT( SrcSampleRate > 0.0 );
        R8BASSERT( DstSampleRate > 0.0 );
        R8BASSERT( MaxInLen > 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 ), 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;
            int c = 0;

            while( true )
            {
                const double NewSR = SrcSampleRate * ( i << c );

                if( NewSR == DstSampleRate )
                {
                    WasFound = true;
                    break;
                }

                if( NewSR > DstSampleRate )
                {
                    break;
                }

                c++;
            }

            if( WasFound )
            {
                addProcessor( new CDSPBlockConvolver(
                    CDSPFIRFilterCache :: getLPFilter( 1.0 / i, ReqTransBand,
                    ReqAtten, ReqPhase, i ), i, 1, LatencyFrac ));

                const bool IsThird = ( i == 3 );

                for( i = 0; i < c; i++ )
                {
                    addProcessor( new CDSPHBUpsampler( ReqAtten, i, IsThird,
                        LatencyFrac ));
                }

                createTmpBuffers();
                return;
            }
        }

        if( DstSampleRate * 2 > 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 ), 2, 1, LatencyFrac ));

            // Try intermediate interpolated'd resampling with subsequent 2X
            // or 3X upsampling.

            const double ThreshSampleRate = SrcSampleRate * 1.01;
            int c = 0;
            int div = 1;

            while( true )
            {
                const int ndiv = div * 2;

                if( DstSampleRate < ThreshSampleRate * ndiv )
                {
                    break;
                }

                div = ndiv;
                c++;
            }

            int c2 = 0;
            int div2 = 1;

            while( true )
            {
                const int ndiv = div * ( c2 == 0 ? 3 : 2 );

                if( DstSampleRate < ThreshSampleRate * ndiv )
                {
                    break;
                }

                div2 = ndiv;
                c2++;
            }

            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.

                int num;

                if( c2 > 0 && div2 > div )
                {
                    div = div2;
                    c = c2;
                    num = 3;
                }
                else
                {
                    num = 2;
                }

                addProcessor( new CDSPFracInterpolator( SrcSampleRate2 * div,
                    DstSampleRate, ReqAtten, false, LatencyFrac ));

                const double tb = 100.0 * ( 1.0 - SrcSampleRate * div /
                    DstSampleRate ) / 1.75; // Divide TransBand by a constant
                    // that assures a linear response in the pass-band.

                addProcessor( new CDSPBlockConvolver(
                    CDSPFIRFilterCache :: getLPFilter( 1.0 / num, tb,
                    ReqAtten, ReqPhase, num ), num, 1, LatencyFrac ));

                for( i = 1; i < c; i++ )
                {
                    addProcessor( new CDSPHBUpsampler( ReqAtten, i - 1,
                        ( num == 3 ), 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;
        int c = 0;
        double FinGain = 1.0;

        while( CheckSR <= SrcSampleRate )
        {
            c++;
            CheckSR *= 2.0;
            FinGain *= 0.5;
        }

        const int SrcSRDiv = ( 1 << c );
        int downf;
        double NormFreq = 0.5;
        bool UseInterp = true;
        bool IsThird = false;

        for( downf = 2; downf <= 3; downf++ )
        {
            if( DstSampleRate * SrcSRDiv * downf == SrcSampleRate )
            {
                NormFreq = 1.0 / downf;
                UseInterp = false;
                IsThird = ( downf == 3 );
                break;
            }
        }

        if( UseInterp )
        {
            downf = 1;
            NormFreq = DstSampleRate * SrcSRDiv / SrcSampleRate;
            IsThird = ( NormFreq * 3.0 <= 1.0 );
        }

        for( i = 0; i < c; i++ )
        {
            // Use a fixed very relaxed 2X downsampling filters, that at
            // the final stage only guarantees stop-band between 0.75 and
            // pi. 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, IsThird,
                LatencyFrac ));
        }

        addProcessor( new CDSPBlockConvolver(
            CDSPFIRFilterCache :: getLPFilter( NormFreq, ReqTransBand,
            ReqAtten, ReqPhase, FinGain ), 1, downf, LatencyFrac ));

        if( UseInterp )
        {
            addProcessor( new CDSPFracInterpolator( SrcSampleRate,
                DstSampleRate * SrcSRDiv, ReqAtten, IsThird, LatencyFrac ));
        }

        createTmpBuffers();
    }

    virtual ~CDSPResampler()
    {
        int i;

        for( i = 0; i < StepCount; i++ )
        {
            delete Steps[ i ];
        }
    }

    virtual int getLatency() const
    {
        return( 0 );
    }

    virtual double getLatencyFrac() const
    {
        return( LatencyFrac );
    }

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

    virtual void clear()
    {
        int i;

        for( i = 0; i < StepCount; i++ )
        {
            Steps[ i ] -> clear();
        }
    }

    virtual int process( double* ip0, int l, double*& op0 )
    {
        R8BASSERT( l >= 0 );

        double* ip = ip0;
        int i;

        for( i = 0; i < StepCount; i++ )
        {
            double* op = TmpBufs[ i & 1 ];
            l = Steps[ i ] -> process( ip, l, op );
            ip = op;
        }

        op0 = ip;
        return( l );
    }

    template< class Tin, class Tout >
    void oneshot( const 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( double ));
                }
            }
            else
            {
                rc = min( iplen, MaxInLen );

                if( sizeof( Tin ) == sizeof( double ))
                {
                    p = (double*) ip;
                }
                else
                {
                    p = &Buf[ 0 ];

                    for( i = 0; i < rc; i++ )
                    {
                        p[ i ] = ip[ i ];
                    }
                }

                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();
    }

    int getInLenBeforeOutStart()
    {
        int inc = 0;

        while( true )
        {
            double ins = 0.0;
            double* op;

            if( process( &ins, 1, op ) > 0 )
            {
                clear();
                return( inc );
            }

            inc++;
        }
    }

private:
    CFixedBuffer< CDSPProcessor* > Steps; 
    int StepCapacity; 
    int StepCount; 
    int MaxInLen; 
    CFixedBuffer< double > TmpBufAll; 
    double* TmpBufs[ 2 ]; 
    int TmpBufCapacities[ 2 ]; 
    int CurTmpBuf; 
    int CurMaxOutLen; 
    double LatencyFrac; 

    void addProcessor( CDSPProcessor* const Proc )
    {
        if( StepCount == StepCapacity )
        {
            // Reallocate and increase Steps array's capacity.

            const int NewCapacity = StepCapacity + 8;
            Steps.realloc( StepCapacity, NewCapacity );
            StepCapacity = NewCapacity;
        }

        LatencyFrac = Proc -> getLatencyFrac();
        CurMaxOutLen = Proc -> getMaxOutLen( CurMaxOutLen );

        if( CurMaxOutLen > TmpBufCapacities[ CurTmpBuf ])
        {
            TmpBufCapacities[ CurTmpBuf ] = CurMaxOutLen;
        }

        CurTmpBuf ^= 1;

        Steps[ StepCount ] = Proc;
        StepCount++;
    }

    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" );
    }
};

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