/*

* Copyright (c) 2006-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  

*

*/

#define RGB565TO888(rgb565)             (((rgb565 << 8) & 0xf80000) | ((rgb565 << 5) & 0x00fc00) | ((rgb565 << 3) & 0x000f8))

#define RGBToRGB565(r,g,b)              ((r)<<11 | (g)<<5 | (b))

#define RGBToRGB888(r,g,b)              ( (((r) << 16) & 0xff0000) | (((g) << 8) & 0x00ff00) | ((b) & 0x000ff) )

#define GET_PIX_SCANLINE_GRAY2(p, x)    (((TUint16*)p)[x>>4] & (1<<(x&0x0f)))

#define GET_PIX_SCANLINE_64K(p, x)      RGB565TO888( (TUint32)(p[x]) )

#define DRAW_PIXEL_MASKED(p, c, m)      *p ^= c; *p &= m; *p ^= c;

#define BLEND(c1,c2,a)                  (((a)*((c1)-(c2))>>8)+(c2));

#define RED(c) (((c)>>16)&0xff)

#define GREEN(c) (((c)>>8)&0xff)

#define BLUE(c) ((c)&0xff)

#define RED5(c) (((c)>>11)&0x1f)

#define GREEN6(c) (((c)>>5)&0x3f)

#define BLUE5(c) ((c)&0x1f)

//=============================================================================

// TFastWrapUtil

//=============================================================================

void TFastWrapUtil::NextLine()

    {

    if( ++iDelta.iY == iSrcHeight ) iDelta.iY = 0;    

    iDelta.iX = iOrig.iX;

    }

void TFastWrapUtil::operator+=( TInt aSteps )

    {

    // this is a bit slow, fortunately it is only used when scaling images

    iDelta.iX += aSteps;

    if( iDelta.iX >= iSrcWidth ) iDelta.iX = iDelta.iX % iSrcWidth;   

    }

void TFastWrapUtil::JumpLines( TInt aSteps )

    {

    iDelta.iY += aSteps;

    if( iDelta.iY >= iSrcHeight ) iDelta.iY = iDelta.iY % iSrcHeight;

    iDelta.iX = iOrig.iX;

    }

//=============================================================================

// TSrcScanLine

//=============================================================================

void TSrcScanLine::Mix( TUint16* aTarget )

    {

    *aTarget = iSrcLine[iPos];

    }

void TSrcScanLine::Mix( TUint32* aTarget )

    {

    *aTarget = 0xff000000 | GET_PIX_SCANLINE_64K( iSrcLine, iPos );

    }

//=============================================================================

// TSrcScanLineMasked

//=============================================================================

void TSrcScanLineMasked::Mix( TUint16* aTarget )

    {

    TUint16 trgMask = GET_PIX_SCANLINE_GRAY2( iSrcMask, iPos );

    if( trgMask )

        *aTarget = iSrcLine[iPos];

    }

void TSrcScanLineMasked::Mix( TUint32* aTarget )

    {

    TUint32 trgCol = GET_PIX_SCANLINE_64K( iSrcLine, iPos );

    TUint32 trgMask = GET_PIX_SCANLINE_GRAY2( iSrcMask, iPos );

    if( trgMask )

        *aTarget = 0xff000000 | trgCol;

    //trgMask = trgMask ? 0xff000000 : 0xffffffff;    // NOT

    //DRAW_PIXEL_MASKED( aTarget, trgCol, trgMask );

    }

//=============================================================================

// TSrcScanLineAlpha

//=============================================================================

void TSrcScanLineAlpha::Mix( TUint16* aTarget )

    {

    TUint16 trgCol = iSrcLine[iPos];

    TUint16 trgAlpha = (TUint16)( iAlpha[iPos] );

    if( trgAlpha == 0xff )

        *aTarget = trgCol;

    else if( trgAlpha )

        {

        TInt col = *aTarget;

        TInt r = BLEND(RED5(trgCol),RED5(col),trgAlpha);

        TInt g = BLEND(GREEN6(trgCol),GREEN6(col),trgAlpha);

        TInt b = BLEND(BLUE5(trgCol),BLUE5(col),trgAlpha);

        *aTarget = RGBToRGB565(r,g,b); 

        }

    }

void TSrcScanLineAlpha::Mix( TUint32* aTarget )

    {

    TUint32 trgCol = GET_PIX_SCANLINE_64K( iSrcLine, iPos );

    TUint32 trgAlpha = iAlpha[iPos];

    if( trgAlpha == 0xff )

        *aTarget = 0xff000000 | trgCol;

    else if( trgAlpha )

        {

        TUint32 col = *aTarget;

        TUint32 r = BLEND(RED(trgCol),RED(col),trgAlpha);

        TUint32 g = BLEND(GREEN(trgCol),GREEN(col),trgAlpha);

        TUint32 b = BLEND(BLUE(trgCol),BLUE(col),trgAlpha);

        *aTarget = 0xff000000 | RGBToRGB888(r,g,b);

        }

    }

//=============================================================================

// TScanLineTiler<T>::MixLine

//=============================================================================

template <class S, typename T>

void TScanLineTiler<S, T>::MixLine( T& aTarget, S& aSrcLine, TFastWrapUtil& aWrap )

    {

    TInt count = iTrgWidth;

    while( count-- )

        {

        aSrcLine.Mix( aTarget );

        ++aTarget;

        ++aWrap;

        // fast wrapping

        const TPoint& pt = *aWrap;

        aSrcLine = pt.iX;

        }

    }

//=============================================================================

// TileBitmap

//=============================================================================

template <class S, typename T>

void TileBitmap( T& aTarget, TInt aStride, CScanLineFetcher& aFetcher, TScanLineTiler<S, T>& aTiler, 

                   TInt aTrgHeight, TInt aSrcWidth, TInt aSrcHeight, const TPoint& aOffset )

    {

    TInt count = aTrgHeight;

    S srcLine;

    // fast wraping

    TFastWrapUtil srcWrap( aOffset, aSrcWidth, aSrcHeight );

    while( count-- )

        {

        aFetcher.Fetch( srcLine );

        aTiler.MixLine( aTarget, srcLine, srcWrap );

        // next line, wrapped

        aTarget += aStride;

        srcWrap.NextLine();

        const TPoint& p  = *srcWrap;

        aFetcher = p.iY;

        }

    }

// END OF FILE