/*

* 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 "lcdgdrvif.h"

#include "lcdtransform.h"

#include "lcdgdrvutil.h"

#include "lcdgd.hrh"

#include "collision.h"

#include "lcdbitblt.h"

#include "lcd32bpp.h"

inline TUint32 ARGB8888ToColor16MA(TUint32 aARGB)

{

    return aARGB;

}

inline TUint32 Color16MA(TInt aRed, TInt aGreen, TInt aBlue)

{

    return TUint32((0xff<<24) | (aRed << 16) | (aGreen << 8) | aBlue);

}

LOCAL_C TUint32 Color16MAForward(TUint32 aRGB)

{

    return ARGB8888ToColor16MA(aRGB);

}

LOCAL_C TUint32 Color16MAReverse(TUint32 aColor16MA)

{

    return aColor16MA;

}

LOCAL_C TUint32 Color16MAQuantize(TUint32 aRGB)

{

    return (aRGB & 0x00FFFFFF);     // must ensure we only return RGB.

}

//

// DrawRegion support

//

LOCAL_C void DrawRegionColor16MAMaskToColor16MAOpaque

(

    const TAcceleratedBitmapInfo* aDstColorBitmap,

    const TAcceleratedBitmapInfo* /*aDstAlphaBitmap*/,

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

    const TAcceleratedBitmapInfo* aSrcColorBitmap,

    const TAcceleratedBitmapInfo* aSrcAlphaBitmap,      // ignored

    const TLcdTransform&          aTransform        // includes anchor

);

LOCAL_C void DrawRegionColor16MAAlphaToColor16MAOpaque

(

    const TAcceleratedBitmapInfo* aDstColorBitmap,

    const TAcceleratedBitmapInfo* /*aDstAlphaBitmap*/,

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

    const TAcceleratedBitmapInfo* aSrcColorBitmap,

    const TAcceleratedBitmapInfo* aSrcAlphaBitmap,      // ignored

    const TLcdTransform&          aTransform        // includes anchor

);

//

// BitBlt support

//

LOCAL_C void BitBltJavaOpaqueToColor16MAOpaque

(

    const TAcceleratedBitmapInfo*   aDstColorBitmap,

    const TAcceleratedBitmapInfo*   /*aDstAlphaBitmap*/,

    const TRect&                    aDstRect,

    const TAcceleratedBitmapInfo*   aSrcColorBitmap,

    const TAcceleratedBitmapInfo*   /*aSrcAlphaBitmap*/,

    const TLcdTransform&            aTransform

);

LOCAL_C void BitBltColor16MAAlphaToColor16MAMask

(

    const TAcceleratedBitmapInfo*   aDstColorBitmap,

    const TAcceleratedBitmapInfo*   aDstAlphaBitmap,

    const TRect&                    aDstRect,

    const TAcceleratedBitmapInfo*   aSrcColorBitmap,

    const TAcceleratedBitmapInfo*   aSrcAlphaBitmap,

    const TLcdTransform&            aTransform

);

#ifdef RD_JAVA_NGA_ENABLED

/**

 *

 */

LOCAL_C void DrawRegionColor16MAMaskToColor16MAPre

(

    const TAcceleratedBitmapInfo* aDstColorBitmap,

    const TAcceleratedBitmapInfo* /*aDstAlphaBitmap*/,

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

    const TAcceleratedBitmapInfo* aSrcColorBitmap,

    const TAcceleratedBitmapInfo* aSrcAlphaBitmap,      // ignored

    const TLcdTransform&          aTransform        // includes anchor

);

/**

 *

 */

LOCAL_C void DrawRegionColor16MAAlphaToColor16MAPre

(

    const TAcceleratedBitmapInfo* aDstColorBitmap,

    const TAcceleratedBitmapInfo* /*aDstAlphaBitmap*/,

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

    const TAcceleratedBitmapInfo* aSrcColorBitmap,

    const TAcceleratedBitmapInfo* aSrcAlphaBitmap,      // ignored

    const TLcdTransform&          aTransform        // includes anchor

);

#endif // RD_JAVA_NGA_ENABLED            

TBool DetectCollisionColor16MAColor16MA

(

    const TAcceleratedBitmapInfo*   aBitmap1,

    const TAcceleratedBitmapInfo*   aBitmap2,

    const TRect&                    aRect1,

    const TRect&                    aRect2,

    const TLcdTransform&            aTransform1,

    const TLcdTransform&            aTransform2

);

TBool HasOpaquePixelColor16MA(const TAcceleratedBitmapInfo* aBitmap, const TRect& aRect);

//

// Image types supported by this DLL.

//

#define COLOR16MA_OPAQUE IMAGE_TYPE(EColor16MA, ENone, ETransparencyNone)

#define COLOR16MA_MASK   IMAGE_TYPE(EColor16MA, ENone, ETransparencyMaskChannel)

#define COLOR16MA_ALPHA  IMAGE_TYPE(EColor16MA, ENone, ETransparencyAlphaChannel)

#ifdef RD_JAVA_NGA_ENABLED

#define COLOR16MA_ALPHA_PRE  IMAGE_TYPE(EColor16MA, ENone, ETransparencyAlphaChannelPre)

#define COLOR16MA_MASK_PRE  IMAGE_TYPE(EColor16MA, ENone, ETransparencyMaskChannelPre)

#endif // RD_JAVA_NGA_ENABLED

const TImageRenderer ImageRendererArray[] =

{

    //

    // SrcOver

    //

    /*           target,          source,          transform mask,      function */

    RENDER_ENTRY(COLOR16MA_OPAQUE, COLOR16MA_OPAQUE, KTransSimpleMask,  BitBltThirtyTwoBppSimple),

    RENDER_ENTRY(COLOR16MA_OPAQUE, COLOR16MA_OPAQUE, KTransAllMask,   BitBltThirtyTwoBpp),

    RENDER_ENTRY(COLOR16MA_OPAQUE, COLOR16MA_MASK,   KTransAllMask,   DrawRegionColor16MAMaskToColor16MAOpaque),

    RENDER_ENTRY(COLOR16MA_OPAQUE, COLOR16MA_ALPHA,  KTransAllMask,   DrawRegionColor16MAAlphaToColor16MAOpaque),

    RENDER_ENTRY(COLOR16MA_OPAQUE, JAVA_OPAQUE_IMAGE, KTransAllMask,  BitBltJavaOpaqueToColor16MAOpaque),

    RENDER_ENTRY(COLOR16MA_OPAQUE, JAVA_ALPHA_IMAGE, KTransAllMask,   DrawRegionColor16MAAlphaToColor16MAOpaque),

#ifdef RD_JAVA_NGA_ENABLED

    RENDER_ENTRY(COLOR16MA_OPAQUE, COLOR16MA_MASK_PRE,   KTransAllMask,   DrawRegionColor16MAMaskToColor16MAPre),

    RENDER_ENTRY(COLOR16MA_OPAQUE, COLOR16MA_ALPHA_PRE,  KTransAllMask,   DrawRegionColor16MAAlphaToColor16MAPre),

#endif // RD_JAVA_NGA_ENABLED

    //

    // SrcCopy

    //

    /*            target,          source,              function */

    BLITTER_ENTRY(COLOR16MA_OPAQUE,  JAVA_OPAQUE_IMAGE, BitBltJavaOpaqueToColor16MAOpaque),

    SIMPLE_BLITTER_ENTRY(COLOR16MA_OPAQUE,  COLOR16MA_OPAQUE,   BitBltThirtyTwoBppSimple),

    BLITTER_ENTRY(COLOR16MA_OPAQUE,  COLOR16MA_OPAQUE,  BitBltThirtyTwoBpp),

    SIMPLE_BLITTER_ENTRY(JAVA_OPAQUE_IMAGE, COLOR16MA_OPAQUE,  BitBltThirtyTwoBppSimple),

    BLITTER_ENTRY(JAVA_OPAQUE_IMAGE, COLOR16MA_OPAQUE,  BitBltThirtyTwoBpp),

    BLITTER_ENTRY(COLOR16MA_OPAQUE,  JAVA_ALPHA_IMAGE,  BitBltJavaOpaqueToColor16MAOpaque), // entry shouldn't be needed

    BLITTER_ENTRY(JAVA_ALPHA_IMAGE,  COLOR16MA_OPAQUE,  BitBltThirtyTwoBpp),

    //

    BLITTER_ENTRY(COLOR16MA_MASK,   JAVA_ALPHA_IMAGE,   BitBltColor16MAAlphaToColor16MAMask),

    BLITTER_ENTRY(JAVA_ALPHA_IMAGE, COLOR16MA_MASK,     BitBltThirtyTwoBpp),        // mask(0,255)==alpha

    BLITTER_ENTRY(COLOR16MA_MASK, COLOR16MA_MASK,       BitBltThirtyTwoBpp),

    //

    BLITTER_ENTRY(COLOR16MA_ALPHA,  JAVA_ALPHA_IMAGE,   BitBltThirtyTwoBpp),

    BLITTER_ENTRY(JAVA_ALPHA_IMAGE, COLOR16MA_ALPHA,    BitBltThirtyTwoBpp)

};

const TInt ImageRendererCount = sizeof(ImageRendererArray)/sizeof(ImageRendererArray[0]);

const TCollisionDetector CollisionDetectorArray[] =

{

    COLLISION_DETECTOR_ENTRY(EColor16MABit,ETransparencyMaskChannelBit,     EColor16MABit,ETransparencyMaskChannelBit,  DetectCollisionColor16MAColor16MA),

    COLLISION_DETECTOR_ENTRY(EColor16MABit,ETransparencyAlphaChannelBit,    EColor16MABit,ETransparencyAlphaChannelBit, DetectCollisionColor16MAColor16MA),

    COLLISION_DETECTOR_ENTRY(EColor16MABit,ETransparencyMaskChannelBit,     EColor16MABit,ETransparencyAlphaChannelBit, DetectCollisionColor16MAColor16MA),

    COLLISION_DETECTOR_ENTRY(EColor16MABit,ETransparencyAlphaChannelBit,    EColor16MABit,ETransparencyMaskChannelBit,  DetectCollisionColor16MAColor16MA),

    COLLISION_DETECTOR_ENTRY(ENoneBit,ETransparencyNoneBit,                 EColor16MABit,ETransparencyMaskChannelBit,  DetectCollisionColor16MAColor16MA),

    COLLISION_DETECTOR_ENTRY(EColor16MABit,ETransparencyMaskChannelBit,     ENoneBit,ETransparencyNoneBit,              DetectCollisionColor16MAColor16MA),

    COLLISION_DETECTOR_ENTRY(ENoneBit,ETransparencyNoneBit,                 EColor16MABit,ETransparencyAlphaChannelBit, DetectCollisionColor16MAColor16MA),

    COLLISION_DETECTOR_ENTRY(EColor16MABit,ETransparencyAlphaChannelBit,    ENoneBit,ETransparencyNoneBit,              DetectCollisionColor16MAColor16MA)

};

const TInt CollisionDetectorCount = sizeof(CollisionDetectorArray)/sizeof(CollisionDetectorArray[0]);

const TColorMap ColorMapArray[] =

{

    { EColor16MA, Color16MAForward, Color16MAReverse, Color16MAQuantize }

};

const TInt ColorMapCount = sizeof(ColorMapArray)/sizeof(ColorMapArray[0]);

const TDrawFunctions DrawFunctionsArray[] =

{

    {

        EColor16MA,

        CLcdGraphicsDevice::ECapFillTriangle,

        NULL,   // drawLine

        NULL,   // drawRect

        NULL,   // fillRect

        NULL,   // drawArc

        NULL,   // fillArc

        &FillTriangle32Bpp,

        NULL    // drawText

    }

};

const TInt DrawFunctionsCount = sizeof(DrawFunctionsArray)/sizeof(DrawFunctionsArray[0]);

const TInt KVersionBuild = 0;

_LIT(KProviderSymbianSoftwareLtd, "Symbian Software Ltd");

LOCAL_C CLcdGraphicsDriverImpl* CreateColor16MADriverL();

const TImplementationProxy ImplementationTable[] =

{

    IMPLEMENTATION_PROXY_ENTRY(LCDGD_COLOR16MA_IMPLEMENTATION_UID, CreateColor16MADriverL)

};

/**

 * Ordinal 1

 */

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

{

    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

    return ImplementationTable;

}

CLcdGraphicsDriverImpl* CreateColor16MADriverL()

{

    CLcdGraphicsDriver::TDriverInfo driverInfo;

    driverInfo.iVersion      = TVersion(KLcdImgVersionMajor, KLcdImgVersionMinor, KVersionBuild);

    driverInfo.iProvider     = KProviderSymbianSoftwareLtd;

    driverInfo.iTransparencyCaps = CAP_1BPP_MASK_BITMAP|CAP_MATCHED_MASK_BITMAP|CAP_ALPHA_BITMAP;

    driverInfo.iARGB8888Mode = EColorARGB8888;

    driverInfo.iDisplayMode = EColor16MA;

    return new(ELeave) CLcdGraphicsDriverImpl

           (

               driverInfo,

               ImageRendererArray,

               ImageRendererCount,

               ColorMapArray,

               ColorMapCount,

               CollisionDetectorArray,

               CollisionDetectorCount,

               DrawFunctionsArray,

               DrawFunctionsCount

           );

}

// ***************************************************************

// Render Functions

// ***************************************************************

LOCAL_C void BlitLineColor16MAMaskToColor16MAOpaque

(

    TUint8* aDstAddress,

    TInt    aWidth,

    TUint8* aColorAddress,

    TInt    aColorPixelPitch

)

{

    TUint32* dst = (TUint32*)(aDstAddress);

    TUint32* end = dst + aWidth;

    TUint8* colorAddr = aColorAddress;

    while (dst < end)

    {

        TUint32 dstColor = *dst;

        TUint32 srcColor = *(TUint32*)colorAddr;

        TUint32 mask = (TUint32)(((TInt32)srcColor) >> 24); // Sign extend down.

        ASSERT(mask == 0 || mask == (TUint32)-1);

        dstColor = (dstColor & ~mask) | (srcColor & mask);

        ASSERT((dstColor >> 24) == 0xff);

        *dst++ = dstColor;

        colorAddr += aColorPixelPitch;

    }

}

LOCAL_C void DrawRegionColor16MAMaskToColor16MAOpaque

(

    const TAcceleratedBitmapInfo* aDstColorBitmap,

    const TAcceleratedBitmapInfo* /*aDstAlphaBitmap*/,

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

    const TAcceleratedBitmapInfo* aSrcColorBitmap,

    const TAcceleratedBitmapInfo* /*aSrcAlphaBitmap*/,      // mask

    const TLcdTransform&          aTransform        // includes anchor

)

{

    ASSERT(aDstColorBitmap->iDisplayMode == EColor16MA);

    ASSERT(aSrcColorBitmap->iDisplayMode == EColor16MA);

    GenericBlit(aDstColorBitmap, aDstRect, aSrcColorBitmap, aTransform,

                BlitLineColor16MAMaskToColor16MAOpaque);

}

LOCAL_C void BlitLineColor16MAAlphaToColor16MAOpaque

(

    TUint8* aDstAddress,

    TInt    aWidth,

    TUint8* aColorAddress,

    TInt    aColorPixelPitch

)

{

    TUint32* dst = (TUint32*)(aDstAddress);

    TUint32* end = dst + aWidth;

    TUint8* colorAddr = aColorAddress;

    while (dst < end)

    {

        TUint32 argb = *(TUint32*)colorAddr;

        TInt alpha = argb >> 24;

        if (alpha == 0xFF)

        {

            *dst = argb;

        }

        else

        {

            if (alpha)

            {

                //

                // alpha blend src over dst.

                //

                TUint32 drgb= *dst;

                alpha = (alpha << 8) | alpha;

                TUint32 dr = Blend32(alpha, ((argb>>16)&0xff), ((drgb>>16)&0xff));

                TUint32 dg = Blend32(alpha, ((argb>>8)&0xff), ((drgb>>8)&0xff));

                TUint32 db = Blend32(alpha, (argb&0xff), (drgb&0xff));

                ASSERT(dr < 256);

                ASSERT(dg < 256);

                ASSERT(db < 256);

                *dst = Color16MA(dr, dg, db);

            }

        }

        dst++;

        colorAddr += aColorPixelPitch;

    }

}

//

// NB destination is fully opaque.

//

LOCAL_C void DrawRegionColor16MAAlphaToColor16MAOpaque

(

    const TAcceleratedBitmapInfo* aDstColorBitmap,

    const TAcceleratedBitmapInfo* /*aDstAlphaBitmap*/,

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

    const TAcceleratedBitmapInfo* aSrcColorBitmap,

    const TAcceleratedBitmapInfo* /*aSrcAlphaBitmap*/,      // ignored

    const TLcdTransform&          aTransform        // includes anchor

)

{

    ASSERT(aDstColorBitmap->iDisplayMode == EColor16MA);

    ASSERT(aSrcColorBitmap->iDisplayMode == EColorARGB8888);

    GenericBlit(aDstColorBitmap, aDstRect, aSrcColorBitmap, aTransform,

                BlitLineColor16MAAlphaToColor16MAOpaque);

}

#ifdef RD_JAVA_NGA_ENABLED

// ---------------------------------------------------------------------------

// BlitLineColor16MAMaskToColor16MAPre

// Target's color components are premultiplied

// ---------------------------------------------------------------------------

//

LOCAL_C void BlitLineColor16MAMaskToColor16MAPre

(

    TUint8* aDstAddress,

    TInt    aWidth,

    TUint8* aColorAddress,

    TInt    aColorPixelPitch

)

{

    TUint32* dst = (TUint32*)(aDstAddress);

    TUint32* end = dst + aWidth;

    TUint8* colorAddr = aColorAddress;

    while (dst < end)

    {

        TUint32 dstColor = *dst;

        TUint32 srcColor = *(TUint32*)colorAddr;

        TUint32 mask = (TUint32)(((TInt32)srcColor) >> 24); // Sign extend down.

        ASSERT(mask == 0 || mask == (TUint32)-1);

        if (mask)

        {

            // Note that the target is not always opaque anymore

            dstColor = srcColor;

        }

        *dst++ = dstColor;

        colorAddr += aColorPixelPitch;

    }

}

// ---------------------------------------------------------------------------

// DrawRegionColor16MAMaskToColor16MAPre

// ---------------------------------------------------------------------------

//

LOCAL_C void DrawRegionColor16MAMaskToColor16MAPre

(

    const TAcceleratedBitmapInfo* aDstColorBitmap,

    const TAcceleratedBitmapInfo* /*aDstAlphaBitmap*/,

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

    const TAcceleratedBitmapInfo* aSrcColorBitmap,

    const TAcceleratedBitmapInfo* /*aSrcAlphaBitmap*/,      // mask

    const TLcdTransform&          aTransform        // includes anchor

)

{

    ASSERT(aDstColorBitmap->iDisplayMode == EColor16MA);

    ASSERT(aSrcColorBitmap->iDisplayMode == EColor16MA);

    GenericBlit(aDstColorBitmap, aDstRect, aSrcColorBitmap, aTransform,

                BlitLineColor16MAMaskToColor16MAPre);

}

// ---------------------------------------------------------------------------

// BlitLineColor16MAMaskToColor16MAPre

// Target's color components are premultiplied

// ---------------------------------------------------------------------------

//

LOCAL_C void BlitLineColor16MAAlphaToColor16MAPre

(

    TUint8* aDstAddress,

    TInt    aWidth,

    TUint8* aColorAddress,

    TInt    aColorPixelPitch

)

{

    TUint32* dstAddress = (TUint32*)(aDstAddress);

    TUint32* end = dstAddress + aWidth;

    TUint8* srcAddress = aColorAddress;

    while (dstAddress < end)

    {

        const TUint32 src=*(TUint32*)srcAddress;

        if (src >= 0xFF000000)

        {

            *(TUint32*)dstAddress = src;

        }

        else

        {

            const TUint32 srcAlpha = src >> 24;

            if (srcAlpha)

            {

                TUint32 destA;

                TUint32 destAG;

                TUint32 destRB;

                TUint32 destMultAlpha;

                const TUint32 dst = *(TUint32*)dstAddress;

                const TUint32 dstAlpha = dst >> 24;

                destA = dstAlpha << 16;

                destA = destA * (0x100 - srcAlpha);

                destA += srcAlpha << 24;

                destMultAlpha = 0xFF - srcAlpha;

                const TUint32 srcPixel = *(TUint32*)srcAddress;

                const TUint32 dstPixel = *(TUint32*)dstAddress;

                destAG = (dstPixel & 0xFF00FF00) >> 8;

                destAG = destAG * destMultAlpha;

                TUint32 srcAG = (srcPixel & 0xFF00FF00) >> 8;

                destAG &= 0xFF00FF00;

                TUint32 alphaPlus1 = srcAlpha + 1;

                destAG += srcAG * alphaPlus1;

                destRB = dstPixel & 0x00FF00FF;

                destRB = destRB * destMultAlpha;

                destRB &= 0xFF00FF00;

                TUint32 srcRB = (srcPixel & 0x00FF00FF);

                destRB += srcRB * alphaPlus1;

                destRB >>= 8;

                *(TUint32*)dstAddress = (destAG & 0x0000FF00) |

                                        (destRB & 0x00FF00FF) |

                                        (destA & 0xFF000000);

            }

        }

        dstAddress++;

        srcAddress += aColorPixelPitch;