/*
* 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:
*
*/

#ifndef LCDGDRVUTIL_H
#define LCDGDRVUTIL_H

#include "lcdgdrvif.h"

const TUint KTransNoneMask =  ETransNoneBit;
const TUint KTransAllMask  =  ETransNoneBit
                              | ETransMirrorRot180Bit
                              | ETransMirrorBit
                              | ETransRot180Bit
                              | ETransMirrorRot270Bit
                              | ETransRot90Bit
                              | ETransRot270Bit
                              | ETransMirrorRot90Bit;
// These two transformations can both be handled more easily in some cases,
// where pixels are in the same horizontal order, so Mem::Move() can be used.
const TUint KTransSimpleMask =  ETransNoneBit
                                | ETransMirrorRot180Bit;

#define IMAGE_TYPE(CM,AM,TT) { CM, AM, TT }

#define BLITTER_ENTRY(DT,ST,F) { DT, ST, KTransAllMask, ECompositeSrcCopy, &F }
#define SIMPLE_BLITTER_ENTRY(DT,ST,F) { DT, ST, KTransSimpleMask, ECompositeSrcCopy, &F }
#define RENDER_ENTRY(DT,ST,TM,F) { DT, ST, TM, ECompositeSrcOver, &F }
#define COLLISION_DETECTOR_ENTRY(M1,T1,M2,T2,F) { M1,T1,M2,T2,&F }

#define JAVA_OPAQUE_IMAGE IMAGE_TYPE(EColorARGB8888, ENone, ETransparencyIgnoreChannel)
#define JAVA_ALPHA_IMAGE  IMAGE_TYPE(EColorARGB8888, ENone, ETransparencyAlphaChannel)

#define UNUSED(X)   (void)X

#ifndef _DEBUG
#define INLINE inline
#else
#define INLINE
#endif

struct TEdge
{
    TInt    iDx;        // difference in x coords of end points
    TUint32 iAbsDeltaX;
    TInt32  iSignDeltaX;
    TInt    iDy;        // difference in y coords of end points - always positive due to end point order.
    TUint32 iAbsDeltaY;
    TInt32  iSignDeltaY;
    TInt    iX;         // normalized integer part of x coordinate.
    TInt    iF;         // numerator of normalized fractional part of x coordinate
    TInt    iD;         // denominator of normalized fractional part of x coordinate
    TInt    iIx;        // integer increment (normalized)
    TInt    iIf;        // fractional increment (normalized)
    TInt    iDe;        // Sign(iDx)
};

struct TEdge64
{
    TInt64  iDx;        // difference in x coords of end points
    TUint32 iAbsDeltaX;
    TInt32  iSignDeltaX;
    TInt64  iDy;        // difference in y coords of end points - always positive due to end point order.
    TUint32 iAbsDeltaY;
    TInt32  iSignDeltaY;
    TInt64  iX;         // normalized integer part of x coordinate.
    TInt64  iF;         // numerator of normalized fractional part of x coordinate
    TInt64  iD;         // denominator of normalized fractional part of x coordinate
    TInt64  iIx;        // integer increment (normalized)
    TInt64  iIf;        // fractional increment (normalized)
    TInt64  iDe;        // Sign(iDx)
};

/**
 * Calculate rational increment stepping in positive y direction.
 *
 *@param aDx difference in x coordinates of edge end points
 *@param aDy difference in y coordinates of edge end points, always positive (y sorted vertices)
 *@return aIx integer increment
 *@return aIf positive fractional increment with denominator aDy
 *
 */
void Increment(TInt& aIx, TInt& aIf, TInt aDx, TInt aDy);

void Increment(TInt64& aIx, TInt64& aIf, TInt64 aDx, TInt64 aDy);

/**
 *@return sign of aValue
 */
inline TInt Sign(TInt aValue)
{
    if (aValue > 0)
    {
        return 1;
    }
    if (aValue < 0)
    {
        return -1;
    }
    return 0;
}

/**
 * Porter-Duff src over destination alpha blend for channels of up to
 * 7 bits, with alpha premultiplied by 257
 */
inline TUint32 Blend7PreScaled(TUint32 aAlpha, TUint32 aSrc, TUint32 aDst)
{
    return (((aSrc - aDst)*aAlpha >> 16) + aDst) & 0xff;
}

/**
 * Porter-Duff src over destination alpha blend for channels of up to
 * 8 bits, with alpha premultiplied by 257
 */
inline TUint32 Blend8PreScaled(TUint32 aAlpha, TUint32 aSrc, TUint32 aDst)
{
    return ((aSrc - aDst)*aAlpha + (aDst << 16) - aDst + 255) >> 16;
}

/**
 * 16bpp routines use Blend16
 */
#define Blend16 Blend7PreScaled

/**
 * 32bpp routines use Blend32 (for RGB888 Blend7PreScaled roundoff works againts us)
 */
#define Blend32 Blend8PreScaled
#endif // LCDGDRVUTIL_H