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 = alignptr( 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;
        BufRP1 = Buf1 + fll;
        BufRP2 = Buf2 + fll - 1;
 
        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( const int ReqOutPos ) const
    {
        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( &Buf1[ ReadPos ], 0,
            (size_t) ( BufLen - flb ) * sizeof( Buf1[ 0 ]));
 
        memset( &Buf2[ ReadPos ], 0,
            (size_t) ( BufLen - flb ) * sizeof( Buf2[ 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
                // Buf2.
 
                double* const wp2 = Buf2 + 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* wp1 = Buf1 + WritePos1;
            double* wp2 = Buf2 + WritePos1;
            double* const ipe = ip + b2 * 2;
 
            while( ip != ipe )
            {
                *wp1 = ip[ 0 ];
                *wp2 = ip[ 1 ];
                wp1++;
                wp2++;
                ip += 2;
            }
 
            if( b1 != b2 )
            {
                *wp1 = *ip;
                ip++;
            }
 
            const int ec = flo - WritePos1;
 
            if( ec > 0 )
            {
                wp1 = Buf1 + WritePos1;
                memcpy( wp1 + BufLen, wp1,
                    (size_t) min( b1, ec ) * sizeof( wp1[ 0 ]));
 
                wp2 = Buf2 + WritePos1;
                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.
 
            const int c = BufLeft - fl2;
 
            if( c > 0 )
            {
                double* const opend = op + c;
                ( *convfn )( op, opend, fltp, BufRP1, BufRP2, ReadPos );
 
                op = opend;
                ReadPos = ( ReadPos + c ) & BufLenMask;
                BufLeft -= c;
            }
        }
 
        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; 
    double Buf1[ BufLen + 27 ]; 
    double Buf2[ BufLen + 27 ]; 
    double FltBuf[ 14 + 2 ]; 
    const double* BufRP1; 
    const double* BufRP2; 
    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* const rp01,
        const double* const rp02, int rpos ); 
    CConvolveFn convfn; 
 
#define R8BHBC1( fn ) \
    static void fn( double* op, double* const opend, const double* const flt, \
        const double* const rp01, const double* const rp02, int rpos ) \
    { \
        while( op != opend ) \
        { \
            const double* const rp1 = rp01 + rpos; \
            const double* const rp = rp02 + rpos;
 
#define R8BHBC2 \
            rpos = ( rpos + 1 ) & BufLenMask; \
            op++; \
        } \
    }
 
#include "CDSPHBDownsampler.inc"
 
#undef R8BHBC1
#undef R8BHBC2
};
 
// ---------------------------------------------------------------------------
 
} // namespace r8b
 
#endif // R8B_CDSPHBDOWNSAMPLER_INCLUDED