avir_dil.h

Go to the documentation of this file.

 
namespace avir {

 
template< class fptype, class fptypesimd >
class CImageResizerFilterStepDIL :
    public CImageResizerFilterStep< fptype, fptype >
{
public:
    using CImageResizerFilterStep< fptype, fptype > :: IsUpsample;
    using CImageResizerFilterStep< fptype, fptype > :: ResampleFactor;
    using CImageResizerFilterStep< fptype, fptype > :: Flt;
    using CImageResizerFilterStep< fptype, fptype > :: FltOrig;
    using CImageResizerFilterStep< fptype, fptype > :: FltLatency;
    using CImageResizerFilterStep< fptype, fptype > :: Vars;
    using CImageResizerFilterStep< fptype, fptype > :: InLen;
    using CImageResizerFilterStep< fptype, fptype > :: InPrefix;
    using CImageResizerFilterStep< fptype, fptype > :: InSuffix;
    using CImageResizerFilterStep< fptype, fptype > :: InElIncr;
    using CImageResizerFilterStep< fptype, fptype > :: OutLen;
    using CImageResizerFilterStep< fptype, fptype > :: OutPrefix;
    using CImageResizerFilterStep< fptype, fptype > :: OutSuffix;
    using CImageResizerFilterStep< fptype, fptype > :: OutElIncr;
    using CImageResizerFilterStep< fptype, fptype > :: PrefixDC;
    using CImageResizerFilterStep< fptype, fptype > :: SuffixDC;
    using CImageResizerFilterStep< fptype, fptype > :: RPosBuf;
    using CImageResizerFilterStep< fptype, fptype > :: FltBank;
    using CImageResizerFilterStep< fptype, fptype > :: EdgePixelCount;

 
    template< class Tin >
    void packScanline( const Tin* const ip0, fptype* const op0,
        const int l ) const
    {
        const int ElCount = Vars -> ElCount;
        int j;
 
        if( !Vars -> UseSRGBGamma )
        {
            for( j = 0; j < ElCount; j++ )
            {
                const Tin* ip = ip0 + j;
                fptype* const op = op0 + j * InElIncr;
                int i;
 
                for( i = 0; i < l; i++ )
                {
                    op[ i ] = (fptype) *ip;
                    ip += ElCount;
                }
            }
        }
        else
        {
            const int AlphaIndex = Vars -> AlphaIndex;
            const fptype gm = (fptype) Vars -> InGammaMult;
 
            for( j = 0; j < ElCount; j++ )
            {
                const Tin* ip = ip0 + j;
                fptype* const op = op0 + j * InElIncr;
                int i;
 
                if( ElCount == 4 && j == AlphaIndex )
                {
                    for( i = 0; i < l; i++ )
                    {
                        op[ i ] = (fptype) *ip * gm;
                        ip += ElCount;
                    }
                }
                else
                {
                    for( i = 0; i < l; i++ )
                    {
                        op[ i ] = convertSRGB2Lin( *ip, gm );
                        ip += ElCount;
                    }
                }
            }
        }
    }

 
    static void applySRGBGamma( fptype* const p0, const int l,
        const CImageResizerVars& Vars0 )
    {
        const int ElCount = Vars0.ElCount;
        const int AlphaIndex = Vars0.AlphaIndex;
        const fptype gm = (fptype) Vars0.OutGammaMult;
        int j;
 
        for( j = 0; j < ElCount; j++ )
        {
            fptype* const p = p0 + j * l;
            int i;
 
            if( ElCount == 4 && j == AlphaIndex )
            {
                for( i = 0; i < l; i++ )
                {
                    p[ i ] *= gm;
                }
            }
            else
            {
                for( i = 0; i < l; i++ )
                {
                    p[ i ] = convertLin2SRGB( p[ i ]) * gm;
                }
            }
        }
    }

 
    void convertVtoH( const fptype* ip, fptype* op, const int SrcLen,
        const int SrcIncr ) const
    {
        const int ElCount = Vars -> ElCount;
        const int SrcElIncr = SrcIncr / ElCount;
        const int ips1 = SrcElIncr;
        const int ips2 = SrcElIncr * 2;
        const int ips3 = SrcElIncr * 3;
        const int ops1 = InElIncr;
        const int ops2 = InElIncr * 2;
        const int ops3 = InElIncr * 3;
        int j;
 
        if( ElCount == 1 )
        {
            for( j = 0; j < SrcLen; j++ )
            {
                op[ 0 ] = ip[ 0 ];
                ip += SrcIncr;
                op++;
            }
        }
        else
        if( ElCount == 4 )
        {
            for( j = 0; j < SrcLen; j++ )
            {
                op[ 0 ] = ip[ 0 ];
                op[ ops1 ] = ip[ ips1 ];
                op[ ops2 ] = ip[ ips2 ];
                op[ ops3 ] = ip[ ips3 ];
                ip += SrcIncr;
                op++;
            }
        }
        else
        if( ElCount == 3 )
        {
            for( j = 0; j < SrcLen; j++ )
            {
                op[ 0 ] = ip[ 0 ];
                op[ ops1 ] = ip[ ips1 ];
                op[ ops2 ] = ip[ ips2 ];
                ip += SrcIncr;
                op++;
            }
        }
        else
        if( ElCount == 2 )
        {
            for( j = 0; j < SrcLen; j++ )
            {
                op[ 0 ] = ip[ 0 ];
                op[ ops1 ] = ip[ ips1 ];
                ip += SrcIncr;
                op++;
            }
        }
    }

 
    template< class Tout >
    static void unpackScanline( const fptype* const ip0, Tout* const op0,
        const int l, const CImageResizerVars& Vars0 )
    {
        const int ElCount = Vars0.ElCount;
        int j;
 
        for( j = 0; j < ElCount; j++ )
        {
            const fptype* const ip = ip0 + j * l;
            Tout* op = op0 + j;
            int i;
 
            for( i = 0; i < l; i++ )
            {
                *op = (Tout) ip[ i ];
                op += ElCount;
            }
        }
    }

 
    void prepareInBuf( fptype* Src ) const
    {
        if( IsUpsample || InPrefix + InSuffix == 0 )
        {
            return;
        }
 
        int j;
 
        for( j = 0; j < Vars -> ElCount; j++ )
        {
            replicateArray( Src, 1, Src - InPrefix, InPrefix, 1 );
            fptype* const Src2 = Src + InLen - 1;
            replicateArray( Src2, 1, Src2 + 1, InSuffix, 1 );
            Src += InElIncr;
        }
    }

 
    void doUpsample( const fptype* Src, fptype* Dst ) const
    {
        const int elalign = Vars -> elalign;
        const int opstep = ResampleFactor;
        const fptype* const f = Flt;
        const int flen = Flt.getCapacity();
        int l;
        int i;
        int j;
 
        for( j = 0; j < Vars -> ElCount; j++ )
        {
            const fptype* ip = Src;
            fptype* op0 = &Dst[ -OutPrefix ];
            memset( op0, 0, (size_t) ( OutPrefix + OutLen + OutSuffix ) *
                sizeof( fptype ));
 
            if( FltOrig.getCapacity() > 0 )
            {
                // Do not perform filtering, only upsample.
 
                op0 += OutPrefix % ResampleFactor;
                l = OutPrefix / ResampleFactor;
 
                while( l > 0 )
                {
                    op0[ 0 ] = ip[ 0 ];
                    op0 += opstep;
                    l--;
                }
 
                l = InLen - 1;
 
                while( l > 0 )
                {
                    op0[ 0 ] = ip[ 0 ];
                    op0 += opstep;
                    ip++;
                    l--;
                }
 
                l = OutSuffix / ResampleFactor;
 
                while( l >= 0 )
                {
                    op0[ 0 ] = ip[ 0 ];
                    op0 += opstep;
                    l--;
                }
 
                Src += InElIncr;
                Dst += OutElIncr;
                continue;
            }
 
            l = InPrefix;
            fptypesimd ipv = (fptypesimd) ip[ 0 ];
 
            while( l > 0 )
            {
                for( i = 0; i < flen; i += elalign )
                {
                    fptypesimd :: addu( op0 + i,
                        fptypesimd :: load( f + i ) * ipv );
                }
 
                op0 += opstep;
                l--;
            }
 
            l = InLen - 1;
 
            while( l > 0 )
            {
                ipv = (fptypesimd) ip[ 0 ];
 
                for( i = 0; i < flen; i += elalign )
                {
                    fptypesimd :: addu( op0 + i,
                        fptypesimd :: load( f + i ) * ipv );
                }
 
                ip++;
                op0 += opstep;
                l--;
            }
 
            l = InSuffix;
            ipv = (fptypesimd) ip[ 0 ];
 
            while( l >= 0 )
            {
                for( i = 0; i < flen; i += elalign )
                {
                    fptypesimd :: addu( op0 + i,
                        fptypesimd :: load( f + i ) * ipv );
                }
 
                op0 += opstep;
                l--;
            }
 
            const fptype* dc = SuffixDC;
            l = SuffixDC.getCapacity();
 
            for( i = 0; i < l; i += elalign )
            {
                fptypesimd :: addu( op0 + i,
                    fptypesimd :: load( dc + i ) * ipv );
            }
 
            ipv = (fptypesimd) Src[ 0 ];
            op0 = Dst - InPrefix * opstep;
            dc = PrefixDC;
            l = PrefixDC.getCapacity();
 
            for( i = 0; i < l; i += elalign )
            {
                fptypesimd :: addu( op0 + i,
                    fptypesimd :: load( dc + i ) * ipv );
            }
 
            Src += InElIncr;
            Dst += OutElIncr;
        }
    }

 
    void doFilter( const fptype* const Src, fptype* Dst,
        const int DstIncr ) const
    {
        const int ElCount = Vars -> ElCount;
        const int elalign = Vars -> elalign;
        const fptype* const f = &Flt[ 0 ];
        const int flen = Flt.getCapacity();
        const int ipstep = ResampleFactor;
        int i;
        int j;
 
        if( ElCount == 1 )
        {
            const fptype* ip = Src - EdgePixelCount * ipstep - FltLatency;
            fptype* op = Dst;
            int l = OutLen;
 
            while( l > 0 )
            {
                fptypesimd s = fptypesimd :: load( f ) *
                    fptypesimd :: loadu( ip );
 
                for( i = elalign; i < flen; i += elalign )
                {
                    s += fptypesimd :: load( f + i ) *
                        fptypesimd :: loadu( ip + i );
                }
 
                op[ 0 ] = s.hadd();
                op += DstIncr;
                ip += ipstep;
                l--;
            }
        }
        else
        if( DstIncr == 1 )
        {
            for( j = 0; j < ElCount; j++ )
            {
                const fptype* ip = Src - EdgePixelCount * ipstep -
                    FltLatency + j * InElIncr;
 
                fptype* op = Dst + j * OutElIncr;
                int l = OutLen;
 
                while( l > 0 )
                {
                    fptypesimd s = fptypesimd :: load( f ) *
                        fptypesimd :: loadu( ip );
 
                    for( i = elalign; i < flen; i += elalign )
                    {
                        s += fptypesimd :: load( f + i ) *
                            fptypesimd :: loadu( ip + i );
                    }
 
                    op[ 0 ] = s.hadd();
                    op += DstIncr;
                    ip += ipstep;
                    l--;
                }
            }
        }
        else
        {
            const fptype* ip0 = Src - EdgePixelCount * ipstep - FltLatency;
            fptype* op0 = Dst;
            int l = OutLen;
 
            while( l > 0 )
            {
                const fptype* ip = ip0;
                fptype* op = op0;
 
                for( j = 0; j < ElCount; j++ )
                {
                    fptypesimd s = fptypesimd :: load( f ) *
                        fptypesimd :: loadu( ip );
 
                    for( i = elalign; i < flen; i += elalign )
                    {
                        s += fptypesimd :: load( f + i ) *
                            fptypesimd :: loadu( ip + i );
                    }
 
                    op[ 0 ] = s.hadd();
                    ip += InElIncr;
                    op += OutElIncr;
                }
 
                ip0 += ipstep;
                op0 += DstIncr;
                l--;
            }
        }
    }

 
    void doResize( const fptype* SrcLine, fptype* DstLine,
        int DstLineIncr, fptype* const xx ) const
    {
        const int IntFltLen = FltBank -> getFilterLen();
        const int ElCount = Vars -> ElCount;
        const int elalign = Vars -> elalign;
        const typename CImageResizerFilterStep< fptype, fptype > ::
            CResizePos* rpos = &(*RPosBuf)[ 0 ];
 
        int DstLineLen = OutLen;
        int i;
        int j;
 
#define AVIR_RESIZE_PART1 \
            while( DstLineLen > 0 ) \
            { \
                const fptypesimd x = (fptypesimd) rpos -> x; \
                const fptype* ftp = rpos -> ftp; \
                const fptype* ftp2 = rpos -> ftp + IntFltLen; \
                const fptype* Src = SrcLine + rpos -> SrcOffs;
 
#define AVIR_RESIZE_PART1nx \
            while( DstLineLen > 0 ) \
            { \
                const fptype* ftp = rpos -> ftp; \
                const fptype* Src = SrcLine + rpos -> SrcOffs;
 
#define AVIR_RESIZE_PART2 \
                DstLine += DstLineIncr; \
                rpos++; \
                DstLineLen--; \
            }
 
        if( ElCount == 1 )
        {
            if( FltBank -> getOrder() == 1 )
            {
                AVIR_RESIZE_PART1
 
                fptypesimd sum = ( fptypesimd :: load( ftp ) +
                    fptypesimd :: load( ftp2 ) * x ) *
                    fptypesimd :: loadu( Src );
 
                for( i = elalign; i < IntFltLen; i += elalign )
                {
                    sum += ( fptypesimd :: load( ftp + i ) +
                        fptypesimd :: load( ftp2 + i ) * x ) *
                        fptypesimd :: loadu( Src + i );
                }
 
                DstLine[ 0 ] = sum.hadd();
 
                AVIR_RESIZE_PART2
            }
            else
            {
                AVIR_RESIZE_PART1nx
 
                fptypesimd sum = fptypesimd :: load( ftp ) *
                    fptypesimd :: loadu( Src );
 
                for( i = elalign; i < IntFltLen; i += elalign )
                {
                    sum += fptypesimd :: load( ftp + i ) *
                        fptypesimd :: loadu( Src + i );
                }
 
                DstLine[ 0 ] = sum.hadd();
 
                AVIR_RESIZE_PART2
            }
        }
        else
        if( DstLineIncr == 1 )
        {
            // Horizontal-oriented processing, element loop is outer.
 
            const int SrcIncr = InElIncr;
            const int DstLineElIncr = OutElIncr - DstLineIncr * DstLineLen;
 
            if( FltBank -> getOrder() == 1 )
            {
                for( j = 0; j < ElCount; j++ )
                {
                    AVIR_RESIZE_PART1
 
                    fptypesimd sum = 0.0;
 
                    for( i = 0; i < IntFltLen; i += elalign )
                    {
                        sum += ( fptypesimd :: load( ftp + i ) +
                            fptypesimd :: load( ftp2 + i ) * x ) *
                            fptypesimd :: loadu( Src + i );
                    }
 
                    DstLine[ 0 ] = sum.hadd();
 
                    AVIR_RESIZE_PART2
 
                    DstLine += DstLineElIncr;
                    SrcLine += SrcIncr;
                    DstLineLen = OutLen;
                    rpos = &(*RPosBuf)[ 0 ];
                }
            }
            else
            {
                for( j = 0; j < ElCount; j++ )
                {
                    AVIR_RESIZE_PART1nx
 
                    fptypesimd sum = fptypesimd :: load( ftp ) *
                        fptypesimd :: loadu( Src );
 
                    for( i = elalign; i < IntFltLen; i += elalign )
                    {
                        sum += fptypesimd :: load( ftp + i ) *
                            fptypesimd :: loadu( Src + i );
                    }
 
                    DstLine[ 0 ] = sum.hadd();
 
                    AVIR_RESIZE_PART2
 
                    DstLine += DstLineElIncr;
                    SrcLine += SrcIncr;
                    DstLineLen = OutLen;
                    rpos = &(*RPosBuf)[ 0 ];
                }
            }
        }
        else
        {
            const int SrcIncr = InElIncr;
            const int DstLineElIncr = OutElIncr;
            DstLineIncr -= DstLineElIncr * ElCount;
 
            if( FltBank -> getOrder() == 1 )
            {
                AVIR_RESIZE_PART1
 
                for( i = 0; i < IntFltLen; i += elalign )
                {
                    ( fptypesimd :: load( ftp + i ) +
                        fptypesimd :: load( ftp2 + i ) * x ).store( xx + i );
                }
 
                for( j = 0; j < ElCount; j++ )
                {
                    fptypesimd sum = fptypesimd :: load( xx ) *
                        fptypesimd :: loadu( Src );
 
                    for( i = elalign; i < IntFltLen; i += elalign )
                    {
                        sum += fptypesimd :: load( xx + i ) *
                            fptypesimd :: loadu( Src + i );
                    }
 
                    DstLine[ 0 ] = sum.hadd();
                    DstLine += DstLineElIncr;
                    Src += SrcIncr;
                }
 
                AVIR_RESIZE_PART2
            }
            else
            {
                AVIR_RESIZE_PART1nx
 
                for( j = 0; j < ElCount; j++ )
                {
                    fptypesimd sum = fptypesimd :: load( ftp ) *
                        fptypesimd :: loadu( Src );
 
                    for( i = elalign; i < IntFltLen; i += elalign )
                    {
                        sum += fptypesimd :: load( ftp + i ) *
                            fptypesimd :: loadu( Src + i );
                    }
 
                    DstLine[ 0 ] = sum.hadd();
                    DstLine += DstLineElIncr;
                    Src += SrcIncr;
                }
 
                AVIR_RESIZE_PART2
            }
        }
 
#undef AVIR_RESIZE_PART2
#undef AVIR_RESIZE_PART1nx
#undef AVIR_RESIZE_PART1
    }

 
    void doResize2( const fptype* SrcLine, fptype* DstLine,
        int DstLineIncr, fptype* const xx ) const
    {
        doResize( SrcLine, DstLine, DstLineIncr, xx );
    }
};

 
template< class fptype, class fptypesimd >
class CImageResizerDithererDefDIL
{
public:
 
    void init( const int aLen, const CImageResizerVars& aVars,
        const double aTrMul, const double aPkOut )
    {
        Len = aLen;
        Vars = &aVars;
        LenE = aLen * Vars -> ElCount;
        TrMul0 = aTrMul;
        PkOut0 = aPkOut;
    }

 
    static bool isRecursive()
    {
        return( false );
    }

 
    void dither( fptype* const ResScanline ) const
    {
        const int elalign = Vars -> elalign;
        const fptypesimd c0 = 0.0;
        const fptypesimd PkOut = (fptypesimd) PkOut0;
        int j;
 
        if( TrMul0 == 1.0 )
        {
            // Optimization - do not perform bit truncation.
 
            for( j = 0; j < LenE - elalign; j += elalign )
            {
                const fptypesimd z0 = round(
                    fptypesimd :: loadu( ResScanline + j ));
 
                clamp( z0, c0, PkOut ).storeu( ResScanline + j );
            }
 
            const int lim = LenE - j;
            const fptypesimd z0 = round(
                fptypesimd :: loadu( ResScanline + j, lim ));
 
            clamp( z0, c0, PkOut ).storeu( ResScanline + j, lim );
        }
        else
        {
            const fptypesimd TrMul = (fptypesimd) TrMul0;
            const fptypesimd TrMulI = (fptypesimd) ( 1.0 / TrMul0 );
 
            for( j = 0; j < LenE - elalign; j += elalign )
            {
                const fptypesimd z0 = round(
                    fptypesimd :: loadu( ResScanline + j ) * TrMulI ) * TrMul;
 
                clamp( z0, c0, PkOut ).storeu( ResScanline + j );
            }
 
            const int lim = LenE - j;
            const fptypesimd z0 = round( fptypesimd :: loadu(
                ResScanline + j, lim ) * TrMulI ) * TrMul;
 
            clamp( z0, c0, PkOut ).storeu( ResScanline + j, lim );
        }
    }
 
protected:
    int Len; 
    const CImageResizerVars* Vars; 
    int LenE; 
    double TrMul0; 
    double PkOut0; 
};

 
template< class fptype, class fptypesimd >
class CImageResizerDithererErrdDIL
{
public:
 
    void init( const int aLen, const CImageResizerVars& aVars,
        const double aTrMul, const double aPkOut )
    {
        Len = aLen;
        Vars = &aVars;
        LenE = aLen * Vars -> ElCount;
        TrMul0 = aTrMul;
        PkOut0 = aPkOut;
 
        ResScanlineDith0.alloc( LenE + Vars -> ElCount, sizeof( fptype ));
        ResScanlineDith = ResScanlineDith0 + Vars -> ElCount;
        int i;
 
        for( i = 0; i < LenE + Vars -> ElCount; i++ )
        {
            ResScanlineDith0[ i ] = 0.0;
        }
    }

 
    static bool isRecursive()
    {
        return( true );
    }

 
    void dither( fptype* const ResScanline )
    {
        const int ea = Vars -> elalign;
        const fptypesimd c0 = 0;
        const fptypesimd TrMul = (fptypesimd) TrMul0;
        const fptypesimd TrMulI = (fptypesimd) ( 1.0 / TrMul0 );
        const fptypesimd PkOut = (fptypesimd) PkOut0;
        int j;
 
        for( j = 0; j < LenE - ea; j += ea )
        {
            fptypesimd :: addu( ResScanline + j,
                fptypesimd :: loadu( ResScanlineDith + j ));
 
            c0.storeu( ResScanlineDith + j );
        }
 
        int lim = LenE - j;
        fptypesimd :: addu( ResScanline + j,
            fptypesimd :: loadu( ResScanlineDith + j, lim ), lim );
 
        c0.storeu( ResScanlineDith + j, lim );
 
        const int Len1 = Len - 1;
        fptype* rs = ResScanline;
        fptype* rsd = ResScanlineDith;
        int i;
 
        for( i = 0; i < Vars -> ElCount; i++ )
        {
            for( j = 0; j < Len1; j++ )
            {
                // Perform rounding, noise estimation and saturation.
 
                fptype* const rsj = rs + j;
                const fptype z0 = round( rsj[ 0 ] * TrMulI ) * TrMul;
                const fptype Noise = rsj[ 0 ] - z0;
                rsj[ 0 ] = clamp( z0, (fptype) 0, PkOut );
 
                fptype* const rsdj = rsd + j;
                const fptype NoiseM1 = Noise * (fptype) 0.364842;
                rsj[ 1 ] += NoiseM1;
                rsdj[ -1 ] += Noise * (fptype) 0.207305;
                rsdj[ 0 ] += NoiseM1;
                rsdj[ 1 ] += Noise * (fptype) 0.063011;
            }
 
            // Process the last pixel element in scanline.
 
            const fptype z1 = round( rs[ Len1 ] * TrMulI ) * TrMul;
            const fptype Noise2 = rs[ Len1 ] - z1;
            rs[ Len1 ] = clamp( z1, c0, PkOut );
 
            rsd[ Len1 - 1 ] += Noise2 * (fptype) 0.207305;
            rsd[ Len1 ] += Noise2 * (fptype) 0.364842;
 
            rs += Len;
            rsd += Len;
        }
    }
 
protected:
    int Len; 
    const CImageResizerVars* Vars; 
    int LenE; 
    double TrMul0; 
    double PkOut0; 
    CBuffer< fptype > ResScanlineDith0; 
    fptype* ResScanlineDith; 
};

 
template< class afptype, class afptypesimd,
    class adith = CImageResizerDithererDefDIL< afptype, afptypesimd > >
class fpclass_def_dil
{
public:
    typedef afptype fptype; 
    typedef afptype fptypeatom; 
    static const int fppack = 1; 
    static const int fpalign = sizeof( afptypesimd ); 
    static const int elalign = sizeof( afptypesimd ) / sizeof( afptype ); 
    static const int packmode = 1; 
    typedef CImageResizerFilterStepDIL< fptype, afptypesimd > CFilterStep; 
    typedef adith CDitherer; 
};
 
} // namespace avir