lancir.h

Go to the documentation of this file.

//$ nobt
//$ nocpp

#ifndef AVIR_CLANCIR_INCLUDED
#define AVIR_CLANCIR_INCLUDED

#include <string.h>
#include <math.h>

namespace avir {

#define LANCIR_PI 3.1415926535897932

class CLancIR
{
private:
    CLancIR( const CLancIR& )
    {
        // Unsupported.
    }

    CLancIR& operator = ( const CLancIR& )
    {
        // Unsupported.
        return( *this );
    }

public:
    CLancIR()
        : FltBuf( NULL )
        , FltBufLen( 0 )
        , spv( NULL )
        , spvlen( 0 )
    {
    }

    ~CLancIR()
    {
        delete[] FltBuf;
        delete[] spv;
    }

    template< class T >
    void resizeImage( const T* const SrcBuf, const int SrcWidth,
        const int SrcHeight, int SrcScanlineSize, T* const NewBuf,
        const int NewWidth, const int NewHeight, const int ElCount,
        const double kx0 = 0.0, const double ky0 = 0.0, double ox = 0.0,
        double oy = 0.0 )
    {
        if( NewWidth <= 0 || NewHeight <= 0 )
        {
            return;
        }

        if( SrcWidth <= 0 || SrcHeight <= 0 )
        {
            memset( NewBuf, 0, (size_t) NewWidth * NewHeight * ElCount *
                sizeof( T ));

            return;
        }

        const double la = 3.0; // Lanczos "a".
        double kx;
        double ky;

        if( kx0 == 0.0 )
        {
            kx = (double) SrcWidth / NewWidth;
            ox += ( kx - 1.0 ) * 0.5;
        }
        else
        if( kx0 > 0.0 )
        {
            kx = kx0;
            ox += ( kx0 - 1.0 ) * 0.5;
        }
        else
        {
            kx = -kx0;
        }

        if( ky0 == 0.0 )
        {
            ky = (double) SrcHeight / NewHeight;
            oy += ( ky - 1.0 ) * 0.5;
        }
        else
        if( ky0 > 0.0 )
        {
            ky = ky0;
            oy += ( ky0 - 1.0 ) * 0.5;
        }
        else
        {
            ky = -ky0;
        }

        if( rfh.update( la, kx ))
        {
            rsh.reset();
            rsv.reset();
        }

        CResizeFilters* rfv; // Pointer to resizing filters for vertical
            // resizing, may equal to "rfh" if the same stepping is in use.

        if( ky == kx )
        {
            rfv = &rfh;
        }
        else
        {
            rfv = &rfv0;

            if( rfv0.update( la, ky ))
            {
                rsv.reset();
            }
        }

        rsh.update( kx, ox, ElCount, SrcWidth, NewWidth, rfh );
        rsv.update( ky, oy, ElCount, SrcHeight, NewHeight, *rfv );

        const int NewWidthE = NewWidth * ElCount;

        if( SrcScanlineSize < 1 )
        {
            SrcScanlineSize = SrcWidth * ElCount;
        }

        // Allocate/resize temporary buffer.

        const size_t FltBufLenNew = (size_t) NewWidthE * (size_t) SrcHeight;

        if( FltBufLenNew > FltBufLen )
        {
            delete[] FltBuf;
            FltBufLen = FltBufLenNew;
            FltBuf = new float[ FltBufLen ];
        }

        // Perform horizontal resizing.

        const T* ips = SrcBuf;
        float* op = FltBuf;
        int i;

        if( ElCount == 3 )
        {
            for( i = 0; i < SrcHeight; i++ )
            {
                copyScanline3h( ips, rsh, SrcWidth );
                resize3( op, NewWidth, rsh.pos, rfh.KernelLen );
                ips += SrcScanlineSize;
                op += NewWidthE;
            }
        }
        else
        if( ElCount == 1 )
        {
            for( i = 0; i < SrcHeight; i++ )
            {
                copyScanline1h( ips, rsh, SrcWidth );
                resize1( op, NewWidth, rsh.pos, rfh.KernelLen );
                ips += SrcScanlineSize;
                op += NewWidthE;
            }
        }
        else
        if( ElCount == 4 )
        {
            for( i = 0; i < SrcHeight; i++ )
            {
                copyScanline4h( ips, rsh, SrcWidth );
                resize4( op, NewWidth, rsh.pos, rfh.KernelLen );
                ips += SrcScanlineSize;
                op += NewWidthE;
            }
        }
        else
        if( ElCount == 2 )
        {
            for( i = 0; i < SrcHeight; i++ )
            {
                copyScanline2h( ips, rsh, SrcWidth );
                resize2( op, NewWidth, rsh.pos, rfh.KernelLen );
                ips += SrcScanlineSize;
                op += NewWidthE;
            }
        }

        // Perform vertical resizing.

        const int spvlennew = NewHeight * ElCount;

        if( spvlennew > spvlen )
        {
            delete[] spv;
            spvlen = spvlennew;
            spv = new float[ spvlen ];
        }

        const bool IsIOFloat = ( (T) 0.25 != 0 );
        const int Clamp = ( sizeof( T ) == 1 ? 255 : 65535 );
        const float* ip = FltBuf;
        T* opd = NewBuf;

        if( ElCount == 3 )
        {
            for( i = 0; i < NewWidth; i++ )
            {
                copyScanline3v( ip, rsv, SrcHeight, NewWidthE );
                resize3( spv, NewHeight, rsv.pos, rfv -> KernelLen );
                copyOutput3( spv, opd, NewHeight, NewWidthE, IsIOFloat,
                    Clamp );

                ip += 3;
                opd += 3;
            }
        }
        else
        if( ElCount == 1 )
        {
            for( i = 0; i < NewWidth; i++ )
            {
                copyScanline1v( ip, rsv, SrcHeight, NewWidthE );
                resize1( spv, NewHeight, rsv.pos, rfv -> KernelLen );
                copyOutput1( spv, opd, NewHeight, NewWidthE, IsIOFloat,
                    Clamp );

                ip++;
                opd++;
            }
        }
        else
        if( ElCount == 4 )
        {
            for( i = 0; i < NewWidth; i++ )
            {
                copyScanline4v( ip, rsv, SrcHeight, NewWidthE );
                resize4( spv, NewHeight, rsv.pos, rfv -> KernelLen );
                copyOutput4( spv, opd, NewHeight, NewWidthE, IsIOFloat,
                    Clamp );

                ip += 4;
                opd += 4;
            }
        }
        else
        if( ElCount == 2 )
        {
            for( i = 0; i < NewWidth; i++ )
            {
                copyScanline2v( ip, rsv, SrcHeight, NewWidthE );
                resize2( spv, NewHeight, rsv.pos, rfv -> KernelLen );
                copyOutput2( spv, opd, NewHeight, NewWidthE, IsIOFloat,
                    Clamp );

                ip += 2;
                opd += 2;
            }
        }
    }

protected:
    float* FltBuf; 
    size_t FltBufLen; 
    float* spv; 
    int spvlen; 

    static int roundclamp( const float v, const int Clamp )
    {
        if( v <= 0.0f )
        {
            return( 0 );
        }

        const int vr = (int) ( v + 0.5f );

        if( vr > Clamp )
        {
            return( Clamp );
        }

        return( vr );
    }

    template< class T >
    static void copyOutput1( const float* ip, T* op, int l, const int opinc,
        const bool IsIOFloat, const int Clamp )
    {
        if( IsIOFloat )
        {
            while( l > 0 )
            {
                op[ 0 ] = (T) ip[ 0 ];
                ip++;
                op += opinc;
                l--;
            }
        }
        else
        {
            while( l > 0 )
            {
                op[ 0 ] = (T) roundclamp( ip[ 0 ], Clamp );
                ip++;
                op += opinc;
                l--;
            }
        }
    }

    template< class T >
    static void copyOutput2( const float* ip, T* op, int l, const int opinc,
        const bool IsIOFloat, const int Clamp )
    {
        if( IsIOFloat )
        {
            while( l > 0 )
            {
                op[ 0 ] = (T) ip[ 0 ];
                op[ 1 ] = (T) ip[ 1 ];
                ip += 2;
                op += opinc;
                l--;
            }
        }
        else
        {
            while( l > 0 )
            {
                op[ 0 ] = (T) roundclamp( ip[ 0 ], Clamp );
                op[ 1 ] = (T) roundclamp( ip[ 1 ], Clamp );
                ip += 2;
                op += opinc;
                l--;
            }
        }
    }

    template< class T >
    static void copyOutput3( const float* ip, T* op, int l, const int opinc,
        const bool IsIOFloat, const int Clamp )
    {
        if( IsIOFloat )
        {
            while( l > 0 )
            {
                op[ 0 ] = (T) ip[ 0 ];
                op[ 1 ] = (T) ip[ 1 ];
                op[ 2 ] = (T) ip[ 2 ];
                ip += 3;
                op += opinc;
                l--;
            }
        }
        else
        {
            while( l > 0 )
            {
                op[ 0 ] = (T) roundclamp( ip[ 0 ], Clamp );
                op[ 1 ] = (T) roundclamp( ip[ 1 ], Clamp );
                op[ 2 ] = (T) roundclamp( ip[ 2 ], Clamp );
                ip += 3;
                op += opinc;
                l--;
            }
        }
    }

    template< class T >
    static void copyOutput4( const float* ip, T* op, int l, const int opinc,
        const bool IsIOFloat, const int Clamp )
    {
        if( IsIOFloat )
        {
            while( l > 0 )
            {
                op[ 0 ] = (T) ip[ 0 ];
                op[ 1 ] = (T) ip[ 1 ];
                op[ 2 ] = (T) ip[ 2 ];
                op[ 3 ] = (T) ip[ 3 ];
                ip += 4;
                op += opinc;
                l--;
            }
        }
        else
        {
            while( l > 0 )
            {
                op[ 0 ] = (T) roundclamp( ip[ 0 ], Clamp );
                op[ 1 ] = (T) roundclamp( ip[ 1 ], Clamp );
                op[ 2 ] = (T) roundclamp( ip[ 2 ], Clamp );
                op[ 3 ] = (T) roundclamp( ip[ 3 ], Clamp );
                ip += 4;
                op += opinc;
                l--;
            }
        }
    }

    class CResizeScanline;

    class CResizeFilters
    {
        friend class CResizeScanline;

    public:
        int KernelLen; 

        CResizeFilters()
            : FilterBuf( NULL )
            , Filters( NULL )
            , Prevla( -1.0 )
            , Prevk( -1.0 )
            , FilterBufLen( 0 )
            , FiltersLen( 0 )
        {
        }

        ~CResizeFilters()
        {
            delete[] FilterBuf;
            delete[] Filters;
        }

        bool update( const double la, const double k )
        {
            if( la == Prevla && k == Prevk )
            {
                return( false );
            }

            Prevla = la;
            Prevk = k;

            NormFreq = ( k <= 1.0 ? 1.0 : 1.0 / k );
            Freq = LANCIR_PI * NormFreq;
            FreqA = LANCIR_PI * NormFreq / la;

            Len2 = la / NormFreq;
            fl2 = (int) ceil( Len2 );
            KernelLen = fl2 + fl2;

            FracCount = 607; // For 8-bit precision.
            FracFill = 0;

            const int FilterBufLenNew = ( FracCount + 1 ) * KernelLen;
                // Add +1 to cover rare cases of fractional delay == 1.

            if( FilterBufLenNew > FilterBufLen )
            {
                delete[] FilterBuf;
                FilterBufLen = FilterBufLenNew;
                FilterBuf = new float[ FilterBufLen ];
            }

            if( FracCount > FiltersLen )
            {
                delete[] Filters;
                FiltersLen = FracCount;
                Filters = new float*[ FiltersLen + 1 ];
            }

            memset( Filters, 0, ( FiltersLen + 1 ) * sizeof( float* ));

            return( true );
        }

        float* getFilter( const double x )
        {
            const int Frac = (int) floor( x * FracCount );

            if( Filters[ Frac ] == NULL )
            {
                Filters[ Frac ] = FilterBuf + FracFill * KernelLen;
                FracFill++;
                makeFilter( 1.0 - (double) Frac / FracCount, Filters[ Frac ]);
                normalizeFilter( Filters[ Frac ]);
            }

            return( Filters[ Frac ]);
        }

    protected:
        double NormFreq; 
        double Freq; 
        double FreqA; 
        double Len2; 
        int fl2; 
        int FracCount; 
        int FracFill; 
        float* FilterBuf; 
        float** Filters; 
        double Prevla; 
        double Prevk; 
        int FilterBufLen; 
        int FiltersLen; 

        class CSinGen
        {
        public:
            CSinGen( const double si, const double ph, const double g = 1.0 )
                : svalue1( sin( ph ) * g )
                , svalue2( sin( ph - si ) * g )
                , sincr( 2.0 * cos( si ))
            {
            }

            double generate()
            {
                const double res = svalue1;

                svalue1 = sincr * res - svalue2;
                svalue2 = res;

                return( res );
            }

        private:
            double svalue1; 
            double svalue2; 
            double sincr; 
        };

        template< class T >
        void makeFilter( const double FracDelay, T* op ) const
        {
            CSinGen f( Freq, Freq * ( FracDelay - fl2 ));
            CSinGen fw( FreqA, FreqA * ( FracDelay - fl2 ), Len2 );

            int t = -fl2;

            if( t + FracDelay < -Len2 )
            {
                f.generate();
                fw.generate();
                *op = (T) 0.0;
                op++;
                t++;
            }

            int mt = ( FracDelay >= 1.0 - 1e-13 && FracDelay <= 1.0 + 1e-13 ?
                -1 : 0 );

            while( t < mt )
            {
                double ut = t + FracDelay;
                *op = (T) ( f.generate() * fw.generate() / ( ut * ut ));
                op++;
                t++;
            }

            double ut = t + FracDelay;

            if( fabs( ut ) <= 1e-13 )
            {
                *op = (T) ( NormFreq * ( LANCIR_PI * LANCIR_PI ));
                f.generate();
                fw.generate();
            }
            else
            {
                *op = (T) ( f.generate() * fw.generate() / ( ut * ut ));
            }

            mt = fl2 - 2;

            while( t < mt )
            {
                op++;
                t++;
                ut = t + FracDelay;
                *op = (T) ( f.generate() * fw.generate() / ( ut * ut ));
            }

            op++;
            t++;
            ut = t + FracDelay;

            if( ut > Len2 )
            {
                *op = (T) 0.0;
            }
            else
            {
                *op = (T) ( f.generate() * fw.generate() / ( ut * ut ));
            }
        }

        template< class T >
        void normalizeFilter( T* const p ) const
        {
            double s = 0.0;
            int i;

            for( i = 0; i < KernelLen; i++ )
            {
                s += p[ i ];
            }

            s = 1.0 / s;

            for( i = 0; i < KernelLen; i++ )
            {
                p[ i ] = (T) ( p[ i ] * s );
            }
        }
    };

    struct CResizePos
    {
        const float* ip; 
        float* flt; 
    };

    class CResizeScanline
    {
    public:
        int padl; 
        int padr; 
        float* sp; 
        CResizePos* pos; 

        CResizeScanline()
            : sp( NULL )
            , pos( NULL )
            , PrevSrcLen( -1 )
            , PrevDstLen( -1 )
            , Prevk( 0.0 )
            , Prevo( 0.0 )
            , PrevElCount( 0 )
            , splen( 0 )
            , poslen( 0 )
        {
        }

        ~CResizeScanline()
        {
            delete[] sp;
            delete[] pos;
        }

        void reset()
        {
            PrevSrcLen = -1;
        }

        void update( const double k, const double o0, const int ElCount,
            const int SrcLen, const int DstLen, CResizeFilters& rf )
        {
            if( SrcLen == PrevSrcLen && DstLen == PrevDstLen &&
                k == Prevk && o0 == Prevo && ElCount == PrevElCount )
            {
                return;
            }

            PrevSrcLen = SrcLen;
            PrevDstLen = DstLen;
            Prevk = k;
            Prevo = o0;
            PrevElCount = ElCount;

            const int fl2m1 = rf.fl2 - 1;
            padl = fl2m1 - (int) floor( o0 );

            if( padl < 0 )
            {
                padl = 0;
            }

            padr = (int) floor( o0 + k * ( DstLen - 1 )) + rf.fl2 + 1 -
                SrcLen;

            if( padr < 0 )
            {
                padr = 0;
            }

            const int splennew = ( padl + SrcLen + padr ) * ElCount;

            if( splennew > splen )
            {
                delete[] sp;
                splen = splennew;
                sp = new float[ splen ];
            }

            if( DstLen > poslen )
            {
                delete[] pos;
                poslen = DstLen;
                pos = new CResizePos[ poslen ];
            }

            const float* const spo = sp + ( padl - fl2m1 ) * ElCount;
            int i;

            for( i = 0; i < DstLen; i++ )
            {
                const double o = o0 + k * i;
                const int ix = (int) floor( o );
                pos[ i ].ip = spo + ix * ElCount;
                pos[ i ].flt = rf.getFilter( o - ix );
            }
        }

    protected:
        int PrevSrcLen; 
        int PrevDstLen; 
        double Prevk; 
        double Prevo; 
        int PrevElCount; 
        int splen; 
        int poslen; 
    };

    CResizeFilters rfh; 
    CResizeFilters rfv0; 
    CResizeScanline rsh; 
    CResizeScanline rsv; 

    template< class T >
    static void copyScanline1h( const T* ip, CResizeScanline& rs, const int l )
    {
        float* op = rs.sp;
        int i;

        for( i = 0; i < rs.padl; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op++;
        }

        for( i = 0; i < l - 1; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            ip++;
            op++;
        }

        for( i = 0; i <= rs.padr; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op++;
        }
    }

    template< class T >
    static void copyScanline2h( const T* ip, CResizeScanline& rs, const int l )
    {
        float* op = rs.sp;
        int i;

        for( i = 0; i < rs.padl; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            op += 2;
        }

        for( i = 0; i < l - 1; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            ip += 2;
            op += 2;
        }

        for( i = 0; i <= rs.padr; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            op += 2;
        }
    }

    template< class T >
    static void copyScanline3h( const T* ip, CResizeScanline& rs, const int l )
    {
        float* op = rs.sp;
        int i;

        for( i = 0; i < rs.padl; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            op[ 2 ] = ip[ 2 ];
            op += 3;
        }

        for( i = 0; i < l - 1; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            op[ 2 ] = ip[ 2 ];
            ip += 3;
            op += 3;
        }

        for( i = 0; i <= rs.padr; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            op[ 2 ] = ip[ 2 ];
            op += 3;
        }
    }

    template< class T >
    static void copyScanline4h( const T* ip, CResizeScanline& rs, const int l )
    {
        float* op = rs.sp;
        int i;

        for( i = 0; i < rs.padl; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            op[ 2 ] = ip[ 2 ];
            op[ 3 ] = ip[ 3 ];
            op += 4;
        }

        for( i = 0; i < l - 1; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            op[ 2 ] = ip[ 2 ];
            op[ 3 ] = ip[ 3 ];
            ip += 4;
            op += 4;
        }

        for( i = 0; i <= rs.padr; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            op[ 2 ] = ip[ 2 ];
            op[ 3 ] = ip[ 3 ];
            op += 4;
        }
    }

    template< class T >
    static void copyScanline1v( const T* ip, CResizeScanline& rs, const int l,
        const int ipinc )
    {
        float* op = rs.sp;
        int i;

        for( i = 0; i < rs.padl; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op++;
        }

        for( i = 0; i < l - 1; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            ip += ipinc;
            op++;
        }

        for( i = 0; i <= rs.padr; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op++;
        }
    }

    template< class T >
    static void copyScanline2v( const T* ip, CResizeScanline& rs, const int l,
        const int ipinc )
    {
        float* op = rs.sp;
        int i;

        for( i = 0; i < rs.padl; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            op += 2;
        }

        for( i = 0; i < l - 1; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            ip += ipinc;
            op += 2;
        }

        for( i = 0; i <= rs.padr; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            op += 2;
        }
    }

    template< class T >
    static void copyScanline3v( const T* ip, CResizeScanline& rs, const int l,
        const int ipinc )
    {
        float* op = rs.sp;
        int i;

        for( i = 0; i < rs.padl; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            op[ 2 ] = ip[ 2 ];
            op += 3;
        }

        for( i = 0; i < l - 1; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            op[ 2 ] = ip[ 2 ];
            ip += ipinc;
            op += 3;
        }

        for( i = 0; i <= rs.padr; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            op[ 2 ] = ip[ 2 ];
            op += 3;
        }
    }

    template< class T >
    static void copyScanline4v( const T* ip, CResizeScanline& rs, const int l,
        const int ipinc )
    {
        float* op = rs.sp;
        int i;

        for( i = 0; i < rs.padl; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            op[ 2 ] = ip[ 2 ];
            op[ 3 ] = ip[ 3 ];
            op += 4;
        }

        for( i = 0; i < l - 1; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            op[ 2 ] = ip[ 2 ];
            op[ 3 ] = ip[ 3 ];
            ip += ipinc;
            op += 4;
        }

        for( i = 0; i <= rs.padr; i++ )
        {
            op[ 0 ] = ip[ 0 ];
            op[ 1 ] = ip[ 1 ];
            op[ 2 ] = ip[ 2 ];
            op[ 3 ] = ip[ 3 ];
            op += 4;
        }
    }

    #define LANCIR_LF_PRE \
            CResizePos* const rpe = rp + DstLen; \
            while( rp < rpe ) \
            { \
                const float* ip = rp -> ip; \
                const float* const flt = rp -> flt;

    #define LANCIR_LF_POST \
                rp++; \
            }

    static void resize1( float* op, int DstLen, CResizePos* rp, const int kl )
    {
        if( kl == 6 )
        {
            LANCIR_LF_PRE
            op[ 0 ] =
                flt[ 0 ] * ip[ 0 ] +
                flt[ 1 ] * ip[ 1 ] +
                flt[ 2 ] * ip[ 2 ] +
                flt[ 3 ] * ip[ 3 ] +
                flt[ 4 ] * ip[ 4 ] +
                flt[ 5 ] * ip[ 5 ];

            op++;
            LANCIR_LF_POST
        }
        else
        {
            LANCIR_LF_PRE
            float sum = 0.0;
            int i;

            for( i = 0; i < kl; i++ )
            {
                sum += flt[ i ] * ip[ i ];
            }

            op[ 0 ] = sum;
            op++;
            LANCIR_LF_POST
        }
    }

    static void resize2( float* op, int DstLen, CResizePos* rp, const int kl )
    {
        if( kl == 6 )
        {
            LANCIR_LF_PRE
            op[ 0 ] =
                flt[ 0 ] * ip[ 0 ] +
                flt[ 1 ] * ip[ 2 ] +
                flt[ 2 ] * ip[ 4 ] +
                flt[ 3 ] * ip[ 6 ] +
                flt[ 4 ] * ip[ 8 ] +
                flt[ 5 ] * ip[ 10 ];

            op[ 1 ] =
                flt[ 0 ] * ip[ 1 ] +
                flt[ 1 ] * ip[ 3 ] +
                flt[ 2 ] * ip[ 5 ] +
                flt[ 3 ] * ip[ 7 ] +
                flt[ 4 ] * ip[ 9 ] +
                flt[ 5 ] * ip[ 11 ];

            op += 2;
            LANCIR_LF_POST
        }
        else
        {
            LANCIR_LF_PRE
            float sum[ 2 ];
            sum[ 0 ] = 0.0;
            sum[ 1 ] = 0.0;
            int i;

            for( i = 0; i < kl; i++ )
            {
                const float xx = flt[ i ];
                sum[ 0 ] += xx * ip[ 0 ];
                sum[ 1 ] += xx * ip[ 1 ];
                ip += 2;
            }

            op[ 0 ] = sum[ 0 ];
            op[ 1 ] = sum[ 1 ];
            op += 2;
            LANCIR_LF_POST
        }
    }

    static void resize3( float* op, int DstLen, CResizePos* rp, const int kl )
    {
        if( kl == 6 )
        {
            LANCIR_LF_PRE
            op[ 0 ] =
                flt[ 0 ] * ip[ 0 ] +
                flt[ 1 ] * ip[ 3 ] +
                flt[ 2 ] * ip[ 6 ] +
                flt[ 3 ] * ip[ 9 ] +
                flt[ 4 ] * ip[ 12 ] +
                flt[ 5 ] * ip[ 15 ];

            op[ 1 ] =
                flt[ 0 ] * ip[ 1 ] +
                flt[ 1 ] * ip[ 4 ] +
                flt[ 2 ] * ip[ 7 ] +
                flt[ 3 ] * ip[ 10 ] +
                flt[ 4 ] * ip[ 13 ] +
                flt[ 5 ] * ip[ 16 ];

            op[ 2 ] =
                flt[ 0 ] * ip[ 2 ] +
                flt[ 1 ] * ip[ 5 ] +
                flt[ 2 ] * ip[ 8 ] +
                flt[ 3 ] * ip[ 11 ] +
                flt[ 4 ] * ip[ 14 ] +
                flt[ 5 ] * ip[ 17 ];

            op += 3;
            LANCIR_LF_POST
        }
        else
        {
            LANCIR_LF_PRE
            float sum[ 3 ];
            sum[ 0 ] = 0.0;
            sum[ 1 ] = 0.0;
            sum[ 2 ] = 0.0;
            int i;

            for( i = 0; i < kl; i++ )
            {
                const float xx = flt[ i ];
                sum[ 0 ] += xx * ip[ 0 ];
                sum[ 1 ] += xx * ip[ 1 ];
                sum[ 2 ] += xx * ip[ 2 ];
                ip += 3;
            }

            op[ 0 ] = sum[ 0 ];
            op[ 1 ] = sum[ 1 ];
            op[ 2 ] = sum[ 2 ];
            op += 3;
            LANCIR_LF_POST
        }
    }

    static void resize4( float* op, int DstLen, CResizePos* rp, const int kl )
    {
        LANCIR_LF_PRE
        float sum[ 4 ];
        sum[ 0 ] = 0.0;
        sum[ 1 ] = 0.0;
        sum[ 2 ] = 0.0;
        sum[ 3 ] = 0.0;
        int i;

        for( i = 0; i < kl; i++ )
        {
            const float xx = flt[ i ];
            sum[ 0 ] += xx * ip[ 0 ];
            sum[ 1 ] += xx * ip[ 1 ];
            sum[ 2 ] += xx * ip[ 2 ];
            sum[ 3 ] += xx * ip[ 3 ];
            ip += 4;
        }

        op[ 0 ] = sum[ 0 ];
        op[ 1 ] = sum[ 1 ];
        op[ 2 ] = sum[ 2 ];
        op[ 3 ] = sum[ 3 ];
        op += 4;
        LANCIR_LF_POST
    }

    #undef LANCIR_LF_PRE
    #undef LANCIR_LF_POST
};

#undef LANCIR_PI

} // namespace avir

#endif // AVIR_CLANCIR_INCLUDED