/*

* Copyright (c) 2004-2008 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:  Alpha Blend provides functionality to combine masked images with

*                Porter-Duff operations.

*

*/

// INCLUDE FILES

#include "AknsRlEffectPluginAlphaBlend.h"

#include "AknsRlEffectUtil.h"

#include "AknsRlExpand.h"

// =================== INTERNAL IMPL. OF ALPHA BLEND ===========================

// "clean" Porter-Duff alpha blend implementation for reference

//TUint8 AknsRlAlphaBlend::Blend( const TAknsRlAlphaBlendMode aMode,

//                                const TUint8 aColorA,

//                                const TUint8 aAlphaA,

//                                const TUint8 aColorB,

//                                const TUint8 aAlphaB )

//    {

//    TInt colorA = (aAlphaA * aColorA) >> 8;

//    TInt colorB = (aAlphaB * aColorB) >> 8;

//

//    // No need to do clamping, results are always in range [0, 255]

//    switch(aMode)

//        {

//        case EAknsRlAlphaBlendAOverB:

//            return TUint8( colorA + ((colorB * (255 - aAlphaA)) >> 8) );

//        case EAknsRlAlphaBlendBOverA:

//            return TUint8( ((colorA * (255 - aAlphaB)) >> 8) + colorB );

//        case EAknsRlAlphaBlendAInB:

//            return TUint8( (colorA * aAlphaB) >> 8 );

//        case EAknsRlAlphaBlendBInA:

//            return TUint8( (colorB * aAlphaA) >> 8 );

//        case EAknsRlAlphaBlendAOutB:

//            return TUint8( (colorA * (255 - aAlphaB)) >> 8 );

//        case EAknsRlAlphaBlendBOutA:

//            return TUint8( (colorB * (255 - aAlphaA)) >> 8 );

//        case EAknsRlAlphaBlendAAtopB:

//            return TUint8( (colorA * (aAlphaB) + colorB * (255 - aAlphaA)) >> 8 );

//        case EAknsRlAlphaBlendBAtopA:

//            return TUint8( (colorA * (255 - aAlphaB) + colorB * (aAlphaA)) >> 8 );

//        case EAknsRlAlphaBlendAXorB:

//            return TUint8( (colorA * (255 - aAlphaB) + colorB * (255 - aAlphaA)) >> 8 );

//        default:

//            break;

//        }

//

//    return 0;

//    }

/**

* Template implementation of AlphaBlend. Pitch is the number of data elements

* to skip before moving to next line. The next parameters are passed to blend

* functions:

* aW      Bitmap width in pixels

* aH      Bitmap height in pixels

* aT      Target bitmap data address

* aPT     Target bitmap scanline pitch

* aA      Source bitmap A data address

* aPA     Source bitmap A scanline pitch

* aMA     Source bitmap A mask data address

* aPMA    Source bitmap A mask scanline pitch

* aB      Source bitmap B data address

* aPB     Source bitmap B scanline pitch

* aMB     Source bitmap B mask data address

* aPMA    Source bitmap B mask scanline pitch

*

* Inside methods local variables have the following roles:

* x   The current pixel's x position

* y   The current pixel's y position

* r   The resulting red color component

* g   The resulting green color component

* b   The resulting blue color component

* sa  Currently processed source A color component

* sb  Currently processed source B color component

* ma  Mask A value for current pixel position

* mb  Mask B value for current pixel position

* ca  A RGB color value for current pixel position

* cb  B RGB color value for current pixel position

*/

template <class T, TInt X, TInt R, TInt G, TInt B>

class AknsRlAlpha

    {

    public:

    static void AoverB( TInt aW, TInt aH, T* aT, TInt aPT,

                        const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                        const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

    static void BoverA( TInt aW, TInt aH, T* aT, TInt aPT,

                        const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                        const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

    // Bitmap B is not accessed -> aB and aPB not required

    static void AinB( TInt aW, TInt aH, T* aT, TInt aPT,

                      const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                      const TUint8* aMB, TInt aPMB );

    // Bitmap A is not accessed -> aA and aPA not required

    static void BinA( TInt aW, TInt aH, T* aT, TInt aPT,

                      const TUint8* aMA, TInt aPMA,

                      const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

    // Bitmap B is not accessed -> aB and aPB not required

    static void AoutB( TInt aW, TInt aH, T* aT, TInt aPT,

                       const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                       const TUint8* aMB, TInt aPMB );

    // Bitmap A is not accessed -> aA and aPA not required

    static void BoutA( TInt aW, TInt aH, T* aT, TInt aPT,

                       const TUint8* aMA, TInt aPMA,

                       const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

    static void AatopB( TInt aW, TInt aH, T* aT, TInt aPT,

                        const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                        const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

    static void BatopA( TInt aW, TInt aH, T* aT, TInt aPT,

                        const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                        const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

    static void AxorB( TInt aW, TInt aH, T* aT, TInt aPT,

                       const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                       const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

    }; // End of AknsRlAlpha

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

// AknsRlAlpha::AoverB

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

//

template <class T, TInt X, TInt R, TInt G, TInt B>

void AknsRlAlpha<T,X,R,G,B>::AoverB( TInt aW, TInt aH, T* aT, TInt aPT,

                                     const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                                     const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

    {

    TInt x, y;

    TUint r, g, b, sa, sb, ma, mb, ca, cb;

    for( y= 0; y < aH; y++ )

        {

        for( x=0; x < aW; x++ )

            {

            ma = *aMA; mb = *aMB; ca = *aA; cb = *aB;

            sa = (ma * AknsRlRgb<T,X,R,G,B>::R8(ca)) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::R8(cb)) >> 8;

            r = sa + ((sb * (255 - ma)) >> 8);

            sa = (ma * AknsRlRgb<T,X,R,G,B>::G8(ca)) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::G8(cb)) >> 8;

            g = sa + ((sb * (255 - ma)) >> 8);

            sa = (ma * AknsRlRgb<T,X,R,G,B>::B8(ca)) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::B8(cb)) >> 8;

            b = sa + ((sb * (255 - ma)) >> 8);

            AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

            aT++; aA++; aMA++; aB++; aMB++;

            }

        aT += aPT; aA += aPA; aMA += aPMA; aB += aPB; aMB += aPMB;

        }

    }

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

// AknsRlAlpha::BoverA

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

//

template <class T, TInt X, TInt R, TInt G, TInt B>

void AknsRlAlpha<T,X,R,G,B>::BoverA( TInt aW, TInt aH, T* aT, TInt aPT,

                                     const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                                     const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

    {

    TInt x, y;

    TUint r, g, b, sa, sb, ma, mb, ca, cb;

    for( y= 0; y < aH; y++ )

        {

        for( x=0; x < aW; x++ )

            {

            ma = *aMA; mb = *aMB; ca = *aA; cb = *aB;

            sa = (ma * AknsRlRgb<T,X,R,G,B>::R8(ca)) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::R8(cb)) >> 8;

            r = sb + ((sa * (255 - mb)) >> 8);

            sa = (ma * AknsRlRgb<T,X,R,G,B>::G8(ca)) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::G8(cb)) >> 8;

            g = sb + ((sa * (255 - mb)) >> 8);

            sa = (ma * AknsRlRgb<T,X,R,G,B>::B8(ca)) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::B8(cb)) >> 8;

            b = sb + ((sa * (255 - mb)) >> 8);

            AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

            aT++; aA++; aMA++; aB++; aMB++;

            }

        aT += aPT; aA += aPA; aMA += aPMA; aB += aPB; aMB += aPMB;

        }

    }

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

// AknsRlAlpha::AinB

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

//

template <class T, TInt X, TInt R, TInt G, TInt B>

void AknsRlAlpha<T,X,R,G,B>::AinB( TInt aW, TInt aH, T* aT, TInt aPT,

                                   const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                                   const TUint8* aMB, TInt aPMB )

    {

    TInt x, y;

    TUint r, g, b, sa, ma, mb, ca;

    for( y= 0; y < aH; y++ )

        {

        for( x=0; x < aW; x++ )

            {

            ma = *aMA; mb = *aMB; ca = *aA;

            sa = (ma * AknsRlRgb<T,X,R,G,B>::R8(ca)) >> 8;

            r = (sa * mb) >> 8;

            sa = (ma * AknsRlRgb<T,X,R,G,B>::G8(ca)) >> 8;

            g = (sa * mb) >> 8;

            sa = (ma * AknsRlRgb<T,X,R,G,B>::B8(ca)) >> 8;

            b = (sa * mb) >> 8;

            AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

            aT++; aA++; aMA++; aMB++;

            }

        aT += aPT; aA += aPA; aMA += aPMA; aMB += aPMB;

        }

    }

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

// AknsRlAlpha::BinA

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

//

template <class T, TInt X, TInt R, TInt G, TInt B>

void AknsRlAlpha<T,X,R,G,B>::BinA( TInt aW, TInt aH, T* aT, TInt aPT,

                                   const TUint8* aMA, TInt aPMA,

                                   const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

    {

    TInt x, y;

    TUint r, g, b, sb, ma, mb, cb;

    for( y= 0; y < aH; y++ )

        {

        for( x=0; x < aW; x++ )

            {

            ma = *aMA; mb = *aMB; cb = *aB;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::R8(cb)) >> 8;

            r = (sb * ma) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::G8(cb)) >> 8;

            g = (sb * ma) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::B8(cb)) >> 8;

            b = (sb * ma) >> 8;

            AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

            aT++; aMA++; aB++; aMB++;

            }

        aT += aPT; aMA += aPMA; aB += aPB; aMB += aPMB;

        }

    }

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

// AknsRlAlpha::AoutB

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

//

template <class T, TInt X, TInt R, TInt G, TInt B>

void AknsRlAlpha<T,X,R,G,B>::AoutB( TInt aW, TInt aH, T* aT, TInt aPT,

                                    const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                                    const TUint8* aMB, TInt aPMB )

    {

    TInt x, y;

    TUint r, g, b, sa, ma, mb, ca;

    for( y= 0; y < aH; y++ )

        {

        for( x=0; x < aW; x++ )

            {

            ma = *aMA; mb = *aMB; ca = *aA;

            sa = (ma * AknsRlRgb<T,X,R,G,B>::R8(ca)) >> 8;

            r = (sa * (255 - mb)) >> 8;

            sa = (ma * AknsRlRgb<T,X,R,G,B>::G8(ca)) >> 8;

            g = (sa * (255 - mb)) >> 8;

            sa = (ma * AknsRlRgb<T,X,R,G,B>::B8(ca)) >> 8;

            b = (sa * (255 - mb)) >> 8;

            AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

            aT++; aA++; aMA++; aMB++;

            }

        aT += aPT; aA += aPA; aMA += aPMA; aMB += aPMB;

        }

    }

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

// AknsRlAlpha::BoutA

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

//

template <class T, TInt X, TInt R, TInt G, TInt B>

void AknsRlAlpha<T,X,R,G,B>::BoutA( TInt aW, TInt aH, T* aT, TInt aPT,

                                    const TUint8* aMA, TInt aPMA,

                                    const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

    {

    TInt x, y;

    TUint r, g, b, sb, ma, mb, cb;

    for( y= 0; y < aH; y++ )

        {

        for( x=0; x < aW; x++ )

            {

            ma = *aMA; mb = *aMB; cb = *aB;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::R8(cb)) >> 8;

            r = (sb * (255 - ma)) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::G8(cb)) >> 8;

            g = (sb * (255 - ma)) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::B8(cb)) >> 8;

            b = (sb * (255 - ma)) >> 8;

            AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

            aT++; aMA++; aB++; aMB++;

            }

        aT += aPT; aMA += aPMA; aB += aPB; aMB += aPMB;

        }

    }

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

// AknsRlAlpha::AatopB

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

//

template <class T, TInt X, TInt R, TInt G, TInt B>

void AknsRlAlpha<T,X,R,G,B>::AatopB( TInt aW, TInt aH, T* aT, TInt aPT,

                                     const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                                     const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

    {

    TInt x, y;

    TUint r, g, b, sa, sb, ma, mb, ca, cb;

    for( y= 0; y < aH; y++ )

        {

        for( x=0; x < aW; x++ )

            {

            ma = *aMA; mb = *aMB; ca = *aA; cb = *aB;

            sa = (ma * AknsRlRgb<T,X,R,G,B>::R8(ca)) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::R8(cb)) >> 8;

            r = (sa * mb + sb * (255 - ma)) >> 8;

            sa = (ma * AknsRlRgb<T,X,R,G,B>::G8(ca)) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::G8(cb)) >> 8;

            g = (sa * mb + sb * (255 - ma)) >> 8;

            sa = (ma * AknsRlRgb<T,X,R,G,B>::B8(ca)) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::B8(cb)) >> 8;

            b = (sa * mb + sb * (255 - ma)) >> 8;

            AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

            aT++; aA++; aMA++; aB++; aMB++;

            }

        aT += aPT; aA += aPA; aMA += aPMA; aB += aPB; aMB += aPMB;

        }

    }

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

// AknsRlAlpha::BatopA

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

//

template <class T, TInt X, TInt R, TInt G, TInt B>

void AknsRlAlpha<T,X,R,G,B>::BatopA( TInt aW, TInt aH, T* aT, TInt aPT,

                                     const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                                     const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

    {

    TInt x, y;

    TUint r, g, b, sa, sb, ma, mb, ca, cb;

    for( y= 0; y < aH; y++ )

        {

        for( x=0; x < aW; x++ )

            {

            ma = *aMA; mb = *aMB; ca = *aA; cb = *aB;

            sa = (ma * AknsRlRgb<T,X,R,G,B>::R8(ca)) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::R8(cb)) >> 8;

            r = (sa * (255 - mb) + sb * ma) >> 8;

            sa = (ma * AknsRlRgb<T,X,R,G,B>::G8(ca)) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::G8(cb)) >> 8;

            g = (sa * (255 - mb) + sb * ma) >> 8;

            sa = (ma * AknsRlRgb<T,X,R,G,B>::B8(ca)) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::B8(cb)) >> 8;

            b = (sa * (255 - mb) + sb * ma) >> 8;

            AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

            aT++; aA++; aMA++; aB++; aMB++;

            }

        aT += aPT; aA += aPA; aMA += aPMA; aB += aPB; aMB += aPMB;

        }

    }

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

// AknsRlAlpha::AxorB

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

//

template <class T, TInt X, TInt R, TInt G, TInt B>

void AknsRlAlpha<T,X,R,G,B>::AxorB( TInt aW, TInt aH, T* aT, TInt aPT,

                                    const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                                    const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

    {

    TInt x, y;

    TUint r, g, b, sa, sb, ma, mb, ca, cb;

    for( y= 0; y < aH; y++ )

        {

        for( x=0; x < aW; x++ )

            {

            ma = *aMA; mb = *aMB; ca = *aA; cb = *aB;

            sa = (ma * AknsRlRgb<T,X,R,G,B>::R8(ca)) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::R8(cb)) >> 8;

            r = (sa * (255 - mb) + sb * (255 - ma)) >> 8;

            sa = (ma * AknsRlRgb<T,X,R,G,B>::G8(ca)) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::G8(cb)) >> 8;

            g = (sa * (255 - mb) + sb * (255 - ma)) >> 8;

            sa = (ma * AknsRlRgb<T,X,R,G,B>::B8(ca)) >> 8;

            sb = (mb * AknsRlRgb<T,X,R,G,B>::B8(cb)) >> 8;

            b = (sa * (255 - mb) + sb * (255 - ma)) >> 8;

            AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

            aT++; aA++; aMA++; aB++; aMB++;

            }

        aT += aPT; aA += aPA; aMA += aPMA; aB += aPB; aMB += aPMB;

        }

    }

// ============== INTERNAL IMPL. OF GRAYSCALE ALPHA BLEND ======================

/**

* See RGB implementation above for comments.

*/

NONSHARABLE_CLASS(AknsRlAlphaGray)

    {

    public:

    static void AoverB( TInt aW, TInt aH, TUint8* aT, TInt aPT,

                        const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                        const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

    static void BoverA( TInt aW, TInt aH, TUint8* aT, TInt aPT,

                        const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                        const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

    static void AinB( TInt aW, TInt aH, TUint8* aT, TInt aPT,

                      const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                      const TUint8* aMB, TInt aPMB );

    static void BinA( TInt aW, TInt aH, TUint8* aT, TInt aPT,

                      const TUint8* aMA, TInt aPMA,

                      const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

    static void AoutB( TInt aW, TInt aH, TUint8* aT, TInt aPT,

                       const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                       const TUint8* aMB, TInt aPMB );

    static void BoutA( TInt aW, TInt aH, TUint8* aT, TInt aPT,

                       const TUint8* aMA, TInt aPMA,

                       const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

    static void AatopB( TInt aW, TInt aH, TUint8* aT, TInt aPT,

                        const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                        const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

    static void BatopA( TInt aW, TInt aH, TUint8* aT, TInt aPT,

                        const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                        const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

    static void AxorB( TInt aW, TInt aH, TUint8* aT, TInt aPT,

                       const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                       const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

    }; // End of AknsRlAlphaGray

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

// AknsRlAlphaGray::AoverB

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

//

void AknsRlAlphaGray::AoverB( TInt aW, TInt aH, TUint8* aT, TInt aPT,

                              const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

                              const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

    {

    TInt x, y, ca;

    TUint cb;

    for( y= 0; y < aH; y++ )

        {