CDSPHBDownsampler.h

Go to the documentation of this file.

//$ nobt
//$ nocpp

 
#ifndef R8B_CDSPHBDOWNSAMPLER_INCLUDED
#define R8B_CDSPHBDOWNSAMPLER_INCLUDED
 
#include "CDSPHBUpsampler.h"
 
namespace r8b {

 
class CDSPHBDownsampler : public CDSPProcessor
{
public:
 
    CDSPHBDownsampler( const double ReqAtten, const int SteepIndex,
        const bool IsThird, const double PrevLatency )
    {
        static const CConvolveFn FltConvFn[ 14 ] = {
            &CDSPHBDownsampler :: convolve1, &CDSPHBDownsampler :: convolve2,
            &CDSPHBDownsampler :: convolve3, &CDSPHBDownsampler :: convolve4,
            &CDSPHBDownsampler :: convolve5, &CDSPHBDownsampler :: convolve6,
            &CDSPHBDownsampler :: convolve7, &CDSPHBDownsampler :: convolve8,
            &CDSPHBDownsampler :: convolve9, &CDSPHBDownsampler :: convolve10,
            &CDSPHBDownsampler :: convolve11, &CDSPHBDownsampler :: convolve12,
            &CDSPHBDownsampler :: convolve13,
            &CDSPHBDownsampler :: convolve14 };
 
        const double* fltp0;
        int fltt;
        double att;
 
        if( IsThird )
        {
            CDSPHBUpsampler :: getHBFilterThird( ReqAtten, SteepIndex, fltp0,
                fltt, att );
        }
        else
        {
            CDSPHBUpsampler :: getHBFilter( ReqAtten, SteepIndex, fltp0, fltt,
                att );
        }
 
        // Copy obtained filter to address-aligned buffer.
 
        fltp = align_ptr( FltBuf, 16 );
        memcpy( fltp, fltp0, (size_t) fltt * sizeof( fltp[ 0 ]));
 
        convfn = FltConvFn[ fltt - 1 ];
        fll = fltt;
        fl2 = fltt - 1;
        flo = fll + fl2;
        flb = BufLen - fll;
        BufRP = Buf + fll;
 
        LatencyFrac = PrevLatency * 0.5;
        Latency = (int) LatencyFrac;
        LatencyFrac -= Latency;
 
        R8BASSERT( Latency >= 0 );
 
        R8BCONSOLE( "CDSPHBDownsampler: taps=%i third=%i att=%.1f io=1/2\n",
            fltt, (int) IsThird, att );
 
        clear();
    }
 
    virtual int getInLenBeforeOutPos( int ReqOutPos ) const
    {
        if( Next != R8B_NULL )
        {
            ReqOutPos = Next -> getInLenBeforeOutPos( ReqOutPos );
        }
 
        return( flo + (int) (( Latency + LatencyFrac + ReqOutPos ) * 2.0 ));
    }
 
    virtual int getLatency() const
    {
        return( 0 );
    }
 
    virtual double getLatencyFrac() const
    {
        return( LatencyFrac );
    }
 
    virtual int getMaxOutLen( const int MaxInLen ) const
    {
        R8BASSERT( MaxInLen >= 0 );
 
        return(( MaxInLen + 1 ) >> 1 );
    }
 
    virtual void clear()
    {
        LatencyLeft = Latency;
        BufLeft = 0;
        WritePos1 = 0;
        WritePos2 = 0;
        ReadPos = flb; // Set "read" position to account for filter's latency.
 
        memset( &Buf[ ReadPos ], 0,
            (size_t) ( BufLen - flb ) * sizeof( Buf[ 0 ]));
 
        memset( &Buf[ BufLenPad + ReadPos ], 0,
            (size_t) ( BufLen - flb ) * sizeof( Buf[ 0 ]));
    }
 
    virtual int process( double* ip, int l, double*& op0 )
    {
        R8BASSERT( l >= 0 );
 
        double* op = op0;
 
        while( l > 0 )
        {
            // Copy new input samples to 2 ring buffers.
 
            if( WritePos1 != WritePos2 )
            {
                // If previous fill was asymmetrical, put a single sample to
                // the second buffer.
 
                double* const wp2 = Buf + BufLenPad + WritePos2;
                *wp2 = *ip;
 
                if( WritePos2 < flo )
                {
                    wp2[ BufLen ] = *ip;
                }
 
                ip++;
                WritePos2 = WritePos1;
                l--;
                BufLeft++;
            }
 
            const int b1 = min(( l + 1 ) >> 1,
                min( BufLen - WritePos1, flb - BufLeft ));
 
            const int b2 = b1 - ( b1 * 2 > l );
 
            double* const wp1 = Buf + WritePos1;
            double* const wp2 = Buf + BufLenPad + WritePos1;
            int i;
 
            for( i = 0; i < b2; i++ )
            {
                wp1[ i ] = ip[ 0 ];
                wp2[ i ] = ip[ 1 ];
                ip += 2;
            }
 
            if( b1 != b2 )
            {
                wp1[ b2 ] = *ip;
                ip++;
            }
 
            const int ec = flo - WritePos1;
 
            if( ec > 0 )
            {
                memcpy( wp1 + BufLen, wp1,
                    (size_t) min( b1, ec ) * sizeof( wp1[ 0 ]));
 
                memcpy( wp2 + BufLen, wp2,
                    (size_t) min( b2, ec ) * sizeof( wp2[ 0 ]));
            }
 
            WritePos1 = ( WritePos1 + b1 ) & BufLenMask;
            WritePos2 = ( WritePos2 + b2 ) & BufLenMask;
            l -= b1 + b2;
            BufLeft += b2;
 
            // Produce output.
 
            int c = BufLeft - fl2;
 
            while( c > 0 )
            {
                const int cb = min( c, BufLen - ReadPos );
                double* const opend = op + cb;
                ( *convfn )( op, opend, fltp, BufRP + ReadPos );
 
                op = opend;
                ReadPos = ( ReadPos + cb ) & BufLenMask;
                BufLeft -= cb;
                c -= cb;
            }
        }
 
        int ol = (int) ( op - op0 );
 
        if( LatencyLeft != 0 )
        {
            if( LatencyLeft >= ol )
            {
                LatencyLeft -= ol;
                return( 0 );
            }
 
            ol -= LatencyLeft;
            op0 += LatencyLeft;
            LatencyLeft = 0;
        }
 
        return( ol );
    }
 
private:
    static const int BufLenBits = 10; 
    static const int BufLen = 1 << BufLenBits; 
    static const int BufLenMask = BufLen - 1; 
    static const int FltBufLen = 14; 
    static const int BufLenPad = BufLen + ( FltBufLen * 2 - 1 ); 
    double Buf[ BufLenPad * 2 ]; 
    double FltBuf[ FltBufLen + 2 ]; 
    const double* BufRP; 
    double* fltp; 
    double LatencyFrac; 
    int Latency; 
    int fll; 
    int fl2; 
    int flo; 
    int flb; 
    int LatencyLeft; 
    int BufLeft; 
    int WritePos1; 
    int WritePos2; 
    int ReadPos; 
 
    typedef void( *CConvolveFn )( double* op, double* const opend,
        const double* const flt, const double* rp1 ); 
    CConvolveFn convfn; 
 
#define R8BHBC1( fn ) \
    static void fn( double* op, double* const opend, const double* const flt, \
        const double* rp1 ) \
    { \
        while( op != opend ) \
        { \
            const double* const rp = rp1 + BufLenPad - 1;
 
#define R8BHBC2 \
            op++; \
            rp1++; \
        } \
    }
 
#include "CDSPHBDownsampler.inc"
 
#undef R8BHBC1
#undef R8BHBC2
};
 
// ---------------------------------------------------------------------------
 
} // namespace r8b
 
#endif // R8B_CDSPHBDOWNSAMPLER_INCLUDED