/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:

*

*/

#include <graphicsaccelerator.h>

#include <gdi.h>

#include "lcdgdrvif.h"

#include "lcdgdrvutil.h"

#include "lcdtransform.h"

#include "lcdbitblt.h"

LOCAL_C INLINE TInt PixelPitch(const TAcceleratedBitmapInfo* aBitmap)

{

    switch (aBitmap->iDisplayMode)

    {

    case EColor64K:

    case EColor4K:

        return 2;

    case EColorARGB8888:

    case EColor16MU:

        return 4;

    case EGray256:

        return 1;

    }

    // Any other display mode is either invalid, or has a fractional number of

    // bytes per pixel, and cannot be handled by this routine.

    ASSERT(EFalse);

    return 0;   // Pacify the compiler

}

extern void GenericBlit

(

    const TAcceleratedBitmapInfo*   aDstColorBitmap,

    const TRect&                    aDstRect,       // must be clipped to destination

    const TAcceleratedBitmapInfo*   aSrcColorBitmap,

    const TLcdTransform&            aTransform,     // includes anchor

    TBlitLineFunction               aBlitLineFn     // function to call on each line

)

{

    ASSERT(aDstColorBitmap != NULL);

    ASSERT(aSrcColorBitmap != NULL);

    TPoint srcPoint = aTransform(aDstRect.iTl);

    TInt dudx = aTransform.iDuDx;

    TInt dudy = aTransform.iDuDy;

    TInt dvdx = aTransform.iDvDx;

    TInt dvdy = aTransform.iDvDy;

    //

    // For each bitmap, calculate the starting address and byte offsets to the

    // next address for one line down and one pixel right.

    //

    const TInt dstLinePitch = aDstColorBitmap->iLinePitch;

    const TInt dstPixelPitch = PixelPitch(aDstColorBitmap);

    TUint8* dstAddress = aDstColorBitmap->iAddress;

    dstAddress += aDstRect.iTl.iY * dstLinePitch + aDstRect.iTl.iX * dstPixelPitch;

    const TInt colorLinePitch = aSrcColorBitmap->iLinePitch;

    const TInt colorPixelPitch = PixelPitch(aSrcColorBitmap);

    TUint8* colorAddress = aSrcColorBitmap->iAddress;

    colorAddress += srcPoint.iY * colorLinePitch + srcPoint.iX * colorPixelPitch;

    // For the source bitmap, also calculate the pitch to the next address for

    // one line down and one pixel right in the destination bitmap.

    const TInt colorDstLinePitch = colorLinePitch * dvdy + colorPixelPitch * dudy;

    const TInt colorDstPixelPitch = colorLinePitch * dvdx + colorPixelPitch * dudx;

    //

    // Iterate over destination pixels.

    //

    const TInt width = aDstRect.Width();

    TInt h = aDstRect.Height();

    while (h-- > 0)

    {

        (*aBlitLineFn)(dstAddress, width, colorAddress, colorDstPixelPitch);

        dstAddress += dstLinePitch;

        colorAddress += colorDstLinePitch;

    }

}

extern void GenericMaskBlit

(

    const TAcceleratedBitmapInfo*   aDstColorBitmap,

    const TRect&                    aDstRect,       // must be clipped to destination

    const TAcceleratedBitmapInfo*   aSrcColorBitmap,

    const TLcdTransform&            aTransform,     // includes anchor

    const TAcceleratedBitmapInfo*   aAlphaBitmap,   // source or destination alpha

    TBool                           aIsSrcAlpha,    // ETrue if alpha is source

    TMaskBlitLineFunction           aBlitLineFn     // function to call on each line

)

{

    ASSERT(aDstColorBitmap != NULL);

    ASSERT(aSrcColorBitmap != NULL);

    ASSERT(aAlphaBitmap != NULL);

    TPoint srcPoint = aTransform(aDstRect.iTl);

    TInt dudx = aTransform.iDuDx;

    TInt dudy = aTransform.iDuDy;

    TInt dvdx = aTransform.iDvDx;

    TInt dvdy = aTransform.iDvDy;

    //

    // For each bitmap, calculate the starting address and byte offsets to the

    // next address for one line down and one pixel right.

    //

    const TInt dstLinePitch = aDstColorBitmap->iLinePitch;

    const TInt dstPixelPitch = PixelPitch(aDstColorBitmap);

    TUint8* dstAddress = aDstColorBitmap->iAddress;

    dstAddress += aDstRect.iTl.iY * dstLinePitch + aDstRect.iTl.iX * dstPixelPitch;

    const TInt colorLinePitch = aSrcColorBitmap->iLinePitch;

    const TInt colorPixelPitch = PixelPitch(aSrcColorBitmap);

    TUint8* colorAddress = aSrcColorBitmap->iAddress;

    colorAddress += srcPoint.iY * colorLinePitch + srcPoint.iX * colorPixelPitch;

    const TInt alphaLinePitch = aAlphaBitmap->iLinePitch;

    const TInt alphaPixelPitch = PixelPitch(aAlphaBitmap);

    TUint8* alphaAddress = aAlphaBitmap->iAddress;

    // Choose the start according to whether alpha/mask is source or destination

    TPoint alphaTl(aIsSrcAlpha ? srcPoint : aDstRect.iTl);

    alphaAddress += alphaTl.iY * alphaLinePitch + alphaTl.iX * alphaPixelPitch;

    // For the source and alpha bitmaps, also calculate the pitch to the next

    // address for one line down and one pixel right in the destination bitmap.

    const TInt colorDstLinePitch = colorLinePitch * dvdy + colorPixelPitch * dudy;

    const TInt colorDstPixelPitch = colorLinePitch * dvdx + colorPixelPitch * dudx;

    TInt alphaDstLinePitch;

    TInt alphaDstPixelPitch;

    if (aIsSrcAlpha)

    {

        alphaDstLinePitch = alphaLinePitch * dvdy + alphaPixelPitch * dudy;

        alphaDstPixelPitch = alphaLinePitch * dvdx + alphaPixelPitch * dudx;

    }

    else

    {

        alphaDstLinePitch = alphaLinePitch;

        alphaDstPixelPitch = alphaPixelPitch;

    }

    //

    // Iterate over destination pixels.

    //

    const TInt width = aDstRect.Width();

    TInt h = aDstRect.Height();

    while (h-- > 0)

    {

        (*aBlitLineFn)(dstAddress, width, colorAddress, colorDstPixelPitch,

                       alphaAddress, alphaDstPixelPitch);

        dstAddress += dstLinePitch;

        colorAddress += colorDstLinePitch;

        alphaAddress += alphaDstLinePitch;

    }

}

extern void BitBltOneBpp

(

    const TAcceleratedBitmapInfo*   aDstColorBitmap,

    const TAcceleratedBitmapInfo*   /*aDstAlphaBitmap*/,

    const TRect&                    aDstRect,

    const TAcceleratedBitmapInfo*   aSrcColorBitmap,

    const TAcceleratedBitmapInfo*   /*aSrcAlphaBitmap*/,

    const TLcdTransform&            aTransform

)

{

    TPoint srcPoint = aTransform(aDstRect.iTl);

    TInt dudx = aTransform.iDuDx;

    TInt dudy = aTransform.iDuDy;

    TInt dvdx = aTransform.iDvDx;

    TInt dvdy = aTransform.iDvDy;

    TInt u0   = srcPoint.iX;

    TInt v0   = srcPoint.iY;

    TInt u    = u0;

    TInt v    = v0;

    TUint8* dstAddress = aDstColorBitmap->iAddress;

    TUint8* srcAddress = aSrcColorBitmap->iAddress;

    TInt dstLinePitch  = aDstColorBitmap->iLinePitch;

    TInt srcLinePitch  = aSrcColorBitmap->iLinePitch;

    TInt height = aDstRect.Height();

    TInt width  = aDstRect.Width();

    const TInt x0 = aDstRect.iTl.iX;

    const TInt x3 = aDstRect.iBr.iX;

    const TInt x2 = Max(x0, aDstRect.iBr.iX & ~7);

    const TInt x1 = Min(x3,(aDstRect.iTl.iX + 7) & ~7);

    for (; height>0; --height)

    {

        TUint8 accum;

        TInt x;

        u = u0;

        v = v0;

        x = x0;

        if (x < x1)

        {

            //

            // Left edge.

            //

            accum = dstAddress[x0>>3];

            for (; x<x1; x++)

            {

                TUint8 mb = 1<<(x&0x7);

                TUint8 sb = *(srcAddress + srcLinePitch*v + (u>>3));

                if (sb & (1<<(u&7)))

                {

                    accum |= mb;

                }

                else

                {

                    accum &= ~mb;

                }

                u += dudx;

                v += dvdx;

            }

            dstAddress[x0>>3] = accum;

        }

        //

        // Middle section.

        //

        for (; x<x2; x+=8)

        {

            ASSERT((x & 7) == 0);   // must be byte aligned

            accum = 0;

            for (TInt j=0; j<8; j++)

            {

                TUint8 sb = *(srcAddress + srcLinePitch*v + (u>>3));

                if (sb & (1<<(u&7)))

                {

                    accum |= (1<<j);

                }

                u += dudx;

                v += dvdx;

            }

            dstAddress[x>>3] = accum;

        }

        //

        // Right edge

        //

        if (x < x3)

        {

            accum = dstAddress[x>>3];

            for (; x<=x3; x++)

            {

                TUint8 mb = 1<<(x&0x7);

                TUint8 sb = *(srcAddress + srcLinePitch*v + (u>>3));

                if (sb & (1<<(u&7)))

                {

                    accum |= mb;

                }

                else

                {

                    accum &= ~mb;

                }

                u += dudx;

                v += dvdx;

            }

            dstAddress[x>>3] = accum;

        }

        u0 += dudy;

        v0 += dvdy;

        dstAddress += dstLinePitch;

    }

}

LOCAL_C void BlitLineEightBppSimple

(

    TUint8* aDstAddress,

    TInt    aWidth,

    TUint8* aColorAddress,

    TInt    aColorPixelPitch

)

{

    ASSERT(aColorPixelPitch == sizeof(TUint8));

    UNUSED(aColorPixelPitch);   // ASSERT is the only use otherwise.

    Mem::Copy(aDstAddress, aColorAddress, aWidth);

}

extern void BitBltEightBppSimple

(

    const TAcceleratedBitmapInfo*   aDstColorBitmap,

    const TAcceleratedBitmapInfo*   /*aDstAlphaBitmap*/,

    const TRect&                    aDstRect,

    const TAcceleratedBitmapInfo*   aSrcColorBitmap,

    const TAcceleratedBitmapInfo*   /*aSrcAlphaBitmap*/,

    const TLcdTransform&            aTransform

)

{

    GenericBlit(aDstColorBitmap, aDstRect, aSrcColorBitmap, aTransform,

                BlitLineEightBppSimple);

}

LOCAL_C void BlitLineEightBpp

(

    TUint8* aDstAddress,

    TInt    aWidth,

    TUint8* aColorAddress,

    TInt    aColorPixelPitch

)

{

    TUint8* dst = aDstAddress;

    TUint8* end = dst + aWidth;

    TUint8* colorAddr = aColorAddress;

    while (dst < end)

    {

        *dst++ = *colorAddr;

        colorAddr += aColorPixelPitch;

    }

}

extern void BitBltEightBpp

(

    const TAcceleratedBitmapInfo*   aDstColorBitmap,

    const TAcceleratedBitmapInfo*   /*aDstAlphaBitmap*/,

    const TRect&                    aDstRect,

    const TAcceleratedBitmapInfo*   aSrcColorBitmap,

    const TAcceleratedBitmapInfo*   /*aSrcAlphaBitmap*/,

    const TLcdTransform&            aTransform

)

{

    GenericBlit(aDstColorBitmap, aDstRect, aSrcColorBitmap, aTransform,

                BlitLineEightBpp);

}