/*

* 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 <ecom/ecom.h>

#include <ecom/implementationproxy.h>

#include <lcdgdrv.h>

#include "lcdgdrvif.h"

#include "lcdtransform.h"

#include "calctransform.h"

#include "collision.h"

#include "lcdgdev.h"

#ifdef _DEBUG

TBool DbgValidateImageType(const TImageType& aType);

TBool DbgValidateRendererArray(const TImageRenderer aRendererArray[], TInt aCount);

#endif

/**

 * Used in blitter/renderer searches

 */

inline TBool operator == (const TImageType& aLhs, const TImageType& aRhs)

{

    return (aLhs.iTransparency == aRhs.iTransparency) &&

           (aLhs.iAlphaMode == aRhs.iAlphaMode) &&

           (aLhs.iColorMode == aRhs.iColorMode);

}

inline void Swap(TInt& aX, TInt& aY)

{

    TInt tmp = aX;

    aX = aY;

    aY = tmp;

}

#define ASCIITEXT(x) (const TUint8*)x

#define UCS16TEXT(x) (const TText*)L##x

struct TLcdDriverType

{

    TDisplayMode    iMode;

    const TUint8*   iDataType;      // ASCII/UTF8

    const TText*    iLibName;       // UNICODE

    TInt            iInterfaceUid;

};

const TLcdDriverType LcdDriverTypeTab[] =

{

    { EColor64K,  ASCIITEXT(LCDGD_COLOR64K_DRIVER_ID_STR),  UCS16TEXT("LCDC64K"),  LCDGD_COLOR64K_IMPLEMENTATION_UID },

    { EColor4K,   ASCIITEXT(LCDGD_COLOR4K_DRIVER_ID_STR),   UCS16TEXT("LCDC4K"),   LCDGD_COLOR4K_IMPLEMENTATION_UID  },

    { EColor16MU, ASCIITEXT(LCDGD_COLOR16MU_DRIVER_ID_STR), UCS16TEXT("LCDC16MU"), LCDGD_COLOR16MU_IMPLEMENTATION_UID },

    { EColor16MA, ASCIITEXT(LCDGD_COLOR16MA_DRIVER_ID_STR), UCS16TEXT("LCDC16MA"), LCDGD_COLOR16MA_IMPLEMENTATION_UID }

};

const TInt KLcdDriverTypeTabSize = sizeof(LcdDriverTypeTab)/sizeof(LcdDriverTypeTab[0]);

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

// Driver implementation ECOM interface.

//

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

EXPORT_C CLcdGraphicsDriverImpl* CLcdGraphicsDriverImpl::NewL(TDisplayMode aDisplayMode)

{

    const TLcdDriverType* type = &LcdDriverTypeTab[0];

    const TLcdDriverType* end  = type + KLcdDriverTypeTabSize;

    while (type < end)

    {

        if (type->iMode == aDisplayMode)

        {

            break;

        }

        type++;

    }

    if (type == end)

    {

        User::Leave(KErrNotSupported);

    }

    TEComResolverParams resolverParams;

    TPtrC8 dataType(type->iDataType);

    resolverParams.SetDataType(dataType);

    TUid    interfaceUid  = KLcdDriverInterfaceUid;

    TUint32 dtorKeyOffset = _FOFF(CLcdGraphicsDriverImpl, iDtor_ID_Key);

    //

    // Try to load via ECOM

    //

    CLcdGraphicsDriverImpl* impl = NULL;

    impl = (CLcdGraphicsDriverImpl*)REComSession::CreateImplementationL(interfaceUid, dtorKeyOffset, resolverParams);

    return impl;

}

EXPORT_C CLcdGraphicsDriverImpl::CLcdGraphicsDriverImpl

(

    const TDriverInfo& aDriverInfo,

    const TImageRenderer* aRendererArray,

    TInt aRendererCount,

    const TColorMap* aColorMapArray,

    TInt aColorMapCount,

    const TCollisionDetector* aCollisionDetectorArray,

    TInt aCollisionDetectorCount,

    const TDrawFunctions* aDrawFunctionsArray,

    TInt aDrawFunctionsCount

)

        : iDriverInfo(aDriverInfo)

        , iRendererArray(aRendererArray)

        , iRendererCount(aRendererCount)

        , iColorMapArray(aColorMapArray)

        , iColorMapCount(aColorMapCount)

        , iCollisionDetectorArray(aCollisionDetectorArray)

        , iCollisionDetectorCount(aCollisionDetectorCount)

        , iDrawFunctionsArray(aDrawFunctionsArray)

        , iDrawFunctionsCount(aDrawFunctionsCount)

{

}

EXPORT_C CLcdGraphicsDriverImpl::~CLcdGraphicsDriverImpl()

{

    if (iDtor_ID_Key != KNullUid)

    {

        REComSession::DestroyedImplementation(iDtor_ID_Key);

    }

}

EXPORT_C void CLcdGraphicsDriverImpl::GetDriverInfo(CLcdGraphicsDriver::TDriverInfo& aDriverInfo) const

{

    aDriverInfo=iDriverInfo;

}

EXPORT_C TInt CLcdGraphicsDriverImpl::DrawRegion

(

    const TAcceleratedBitmapInfo* aDstColorBitmap,

    const TRect&                  aDstRect,

    const TAcceleratedBitmapInfo* aSrcColorBitmap,

    const TAcceleratedBitmapInfo* aSrcAlphaBitmap,

    TTransparency                 aSrcTransparency,

    const TRect&                  aSrcRect,

    TTransformType                aSrcTransform,

    const TRect&                  aClipRect

)

{

    ASSERT(aDstColorBitmap);

    ASSERT(aSrcColorBitmap);

    TInt err = KErrNotSupported;

    TImageType dstType;

    dstType.iColorMode = aDstColorBitmap->iDisplayMode;

    dstType.iAlphaMode = ENone;

    dstType.iTransparency = ETransparencyNone;

    TImageType srcType;

    srcType.iColorMode = aSrcColorBitmap->iDisplayMode;

    srcType.iAlphaMode = aSrcAlphaBitmap ? aSrcAlphaBitmap->iDisplayMode : ENone;

    srcType.iTransparency = aSrcTransparency;

    const TImageRenderer* renderer = GetRenderer(dstType, srcType, aSrcTransform, ECompositeSrcOver);

    if (renderer)

    {

        TImageRenderFunction drawRegion = renderer->iFunction;

        // calc source to target transform

        TLcdTransform transform = CalcTransform(aDstRect, aSrcRect, aSrcTransform);

        TRect dstRect(aDstRect);

        TRect srcRect(aSrcRect);

        TRect srcClipRect(aSrcColorBitmap->iSize);

        TRect dstClipRect(aDstColorBitmap->iSize);

        // clip cliprect to device rect

        dstClipRect.Intersection(aClipRect);

        // calculate source and target rects clipped to src and target bounds.

        ClipTransformRect(dstRect, srcRect, dstClipRect, srcClipRect, transform);

        // clip dst rect to cliprect shouldn't be necessary if

        // ClipTransformRect works

        dstRect.Intersection(dstClipRect);

        if (!dstRect.IsEmpty())

        {

            // calc target to source transform.

            transform = transform.Inverse();

            ASSERT(CheckBounds(aDstColorBitmap->iSize, aSrcColorBitmap->iSize, dstRect, transform));

            (*drawRegion)(aDstColorBitmap, NULL, dstRect, aSrcColorBitmap, aSrcAlphaBitmap, transform);

        }

        err = KErrNone;

    }

    return err;

}

EXPORT_C TInt CLcdGraphicsDriverImpl::CopyRegion

(

    const TAcceleratedBitmapInfo*   aDstColorBitmap,

    const TAcceleratedBitmapInfo*   aDstAlphaBitmap,

    TTransparency                   aDstTransparency,

    const TRect&                    aDstRect,

    const TAcceleratedBitmapInfo*   aSrcColorBitmap,

    const TAcceleratedBitmapInfo*   aSrcAlphaBitmap,

    TTransparency                   aSrcTransparency,

    const TRect&                    aSrcRect,

    TTransformType                  aSrcTransform,

    const TRect&                    aClipRect

)

{

    ASSERT(aDstColorBitmap);

    ASSERT(aSrcColorBitmap);

    TInt err = KErrNotSupported;

    TImageType dstType;

    TImageType srcType;

    dstType.iColorMode = aDstColorBitmap->iDisplayMode;

    dstType.iAlphaMode = aDstAlphaBitmap ? aDstAlphaBitmap->iDisplayMode : ENone;

    dstType.iTransparency = aDstTransparency;

    srcType.iColorMode = aSrcColorBitmap->iDisplayMode;

    srcType.iAlphaMode = aSrcAlphaBitmap ? aSrcAlphaBitmap->iDisplayMode : ENone;

    srcType.iTransparency = aSrcTransparency;

    const TImageRenderer* renderer = GetRenderer(dstType, srcType, aSrcTransform, ECompositeSrcCopy);

    if (renderer)

    {

        TImageRenderFunction copyRegion = renderer->iFunction;

        // calc source to target transform

        TLcdTransform transform = CalcTransform(aDstRect, aSrcRect, aSrcTransform);

        TRect dstRect(aDstRect);

        TRect srcRect(aSrcRect);

        TRect srcClipRect(aSrcColorBitmap->iSize);

        TRect dstClipRect(aDstColorBitmap->iSize);

        // clip cliprect to device rect

        dstClipRect.Intersection(aClipRect);

        // clip source and target rects

        ClipTransformRect(dstRect, srcRect, dstClipRect, srcClipRect, transform);

        // check src and dst rects still correspond

        ASSERT(CheckTransform(dstRect, srcRect, transform));

        // clip dst rect to cliprect shouldn't be necessary if

        // ClipTransformRect works

        dstRect.Intersection(dstClipRect);

        if (!dstRect.IsEmpty())

        {

            // calc target to source transform.

            transform = transform.Inverse();

            // check source and dst rects lie within bounds

            ASSERT(CheckBounds(aDstColorBitmap->iSize, aSrcColorBitmap->iSize, dstRect, transform));

            (*copyRegion)(aDstColorBitmap, aDstAlphaBitmap, dstRect, aSrcColorBitmap, aSrcAlphaBitmap, transform);

        }

        err = KErrNone;

    }

    return err;

}

/**

Detect collision between images. Returns ETrue if the overlapping

region contains corresponding opaque pixels.

*/

EXPORT_C TBool CLcdGraphicsDriverImpl::DetectCollision

(

    const TAcceleratedBitmapInfo* aMask1,

    TTransparency       aTransparency1,

    const TSize&        aSize1,

    const TRect&        aRect1,

    TInt                aTransform1,

    const TPoint&       aPoint1,

    const TAcceleratedBitmapInfo* aMask2,

    TTransparency       aTransparency2,

    const TSize&        aSize2,

    const TRect&        aRect2,

    TInt                aTransform2,

    const TPoint&       aPoint2

)

{

    if ((aMask1 == NULL) && (aMask2 == NULL))

    {

        // if neither have mask all pixels opaque, so collide

        return ETrue;

    }

    ASSERT(aRect1.Intersects(TRect(aSize1)));

    ASSERT(aRect2.Intersects(TRect(aSize2)));

    TDisplayMode displayMode1 = aMask1 ? aMask1->iDisplayMode : ENone;

    TDisplayMode displayMode2 = aMask2 ? aMask2->iDisplayMode : ENone;

    const TCollisionDetector* detector = GetCollisionDetector(displayMode1,aTransparency1,displayMode2,aTransparency2);

    ASSERT(detector != NULL);

    TSize dstSize1=aRect1.Size();

    if (aTransform1 & EReflectDiag)

    {

        Swap(dstSize1.iWidth, dstSize1.iHeight);

    }

    TSize dstSize2=aRect2.Size();

    if (aTransform2 & EReflectDiag)

    {

        Swap(dstSize2.iWidth, dstSize2.iHeight);

    }

    TRect dstRect1(aPoint1, dstSize1);

    TRect dstRect2(aPoint2, dstSize2);

    TLcdTransform forward1 = CalcTransform(dstRect1, aRect1, (TTransformType)aTransform1);

    const TRect srcClipRect1(aSize1);

    TRect srcRect1 = aRect1;

    ClipTransformRect(dstRect1, srcRect1, dstRect2, srcClipRect1, forward1);

    TLcdTransform transform1 = forward1.Inverse();

    TLcdTransform forward2 = CalcTransform(dstRect2, aRect2, (TTransformType)aTransform2);

    const TRect srcClipRect2(aSize2);

    TRect srcRect2 = aRect2;

    ClipTransformRect(dstRect2, srcRect2, dstRect1, srcClipRect2, forward2);

    TLcdTransform transform2 = forward2.Inverse();

    return (*detector->iFunction)(aMask1, aMask2, srcRect1, srcRect2, transform1, transform2);

}

CLcdGraphicsDevice* CLcdGraphicsDriverImpl::CreateDeviceL(const TImageType& aType)

{

    const TDrawFunctions* drawFunctions = GetDrawFunctions(aType.iColorMode);

    const TColorMap* colorMap = GetColorMap(aType.iColorMode);

    if (!drawFunctions || !colorMap)

    {

        User::Leave(KErrNotSupported);

    }

    CRenderFunctions* renderers = new(ELeave) CRenderFunctions;

    CleanupStack::PushL(renderers);

    const TImageRenderer* ptr = iRendererArray;

    const TImageRenderer* end = iRendererArray + iRendererCount;

    while (ptr < end)

    {

        //

        // extract only the drawRegion renderers

        //

        if ((ptr->iTargetType == aType) && (ptr->iCompositeRule == ECompositeSrcOver))

        {

            renderers->AppendL(*ptr);

        }

        ++ptr;

    }

    //

    // We need to find all renderers targeting aType

    //

    CLcdGraphicsDeviceImpl* impl = new(ELeave) CLcdGraphicsDeviceImpl

    (

        *this,

        aType,

        renderers,

        *colorMap,

        *drawFunctions

    );

    CleanupStack::Pop(renderers);

    return impl;

}

const TImageRenderer* CLcdGraphicsDriverImpl::GetRenderer

(

    const TImageType& aTargetType,

    const TImageType& aSourceType,

    TTransformType aTransform,

    TCompositRule aCompositeRule

)

const

{

    const TInt transformBit = 1<<aTransform;

    const TInt            count = iRendererCount;

    const TImageRenderer* array = iRendererArray;

    const TImageRenderer* ptr = array;

    const TImageRenderer* end = array + count;

    while (ptr < end)

    {

        if ((ptr->iCompositeRule == aCompositeRule) &&

                (ptr->iTransformMask & transformBit)  &&

                (ptr->iSourceType == aSourceType)     &&

                (ptr->iTargetType == aTargetType))

        {

            return ptr;

        }

        ++ptr;

    }

    return NULL;

}

/**

 *

 */

const TColorMap* CLcdGraphicsDriverImpl::GetColorMap(TDisplayMode aMode)

{

    const TColorMap* ptr = iColorMapArray;

    const TColorMap* end = iColorMapArray + iColorMapCount;

    while (ptr < end)

    {

        if (ptr->iTargetMode == aMode)

        {

            return ptr;

        }

        ++ptr;

    }

    return NULL;

}

const TCollisionDetector* CLcdGraphicsDriverImpl::GetCollisionDetector

(

    TDisplayMode    aDisplayMode1,

    TTransparency   aTransparency1,

    TDisplayMode    aDisplayMode2,

    TTransparency   aTransparency2

)

const

{

    const TCollisionDetector* ptr = iCollisionDetectorArray;

    const TCollisionDetector* end = iCollisionDetectorArray + iCollisionDetectorCount;

    TUint displayMode1Bit   = 1<<aDisplayMode1;

    TUint transparency1Bit  = 1<<aTransparency1;

    TUint displayMode2Bit   = 1<<aDisplayMode2;

    TUint transparency2Bit  = 1<<aTransparency2;

    while (ptr < end)

    {

        if ((ptr->iDisplayMode1 & displayMode1Bit) &&

                (ptr->iTransparency1 & transparency1Bit) &&

                (ptr->iDisplayMode2 & displayMode2Bit) &&

                (ptr->iTransparency2 & transparency2Bit))

        {

            return ptr;

        }

        ++ptr;

    }

    return NULL;

}

EXPORT_C const TDrawFunctions* CLcdGraphicsDriverImpl::GetDrawFunctions(TDisplayMode aMode) const

{

    const TDrawFunctions* ptr = iDrawFunctionsArray;

    const TDrawFunctions* end = iDrawFunctionsArray + iDrawFunctionsCount;

    while (ptr < end)

    {

        if (ptr->iDisplayMode == aMode)

        {

            return ptr;

        }

        ++ptr;

    }

    return NULL;

}

#ifdef _DEBUG

TBool DbgValidateRendererArray(const TImageRenderer aRendererArray[], TInt aCount)

{

    for (TInt i=0; i<aCount; i++)

    {

        const TImageRenderer& renderer = aRendererArray[i];

        if (!DbgValidateImageType(renderer.iTargetType))

        {

            return EFalse;

        }

        if (!DbgValidateImageType(renderer.iSourceType))

        {

            return EFalse;

        }

        if (NULL == renderer.iFunction)

        {

            return EFalse;

        }

    }

    return ETrue;

}

TBool DbgValidateImageType(const TImageType& aType)

{

    //

    // Validate displaymodes against transparency type.

    //

    switch (aType.iTransparency)

    {

    case ETransparencyNone:

        //

        // Must be none.

        //

        if (aType.iAlphaMode != ENone)

        {

            return EFalse;

        }