/*

* 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:  ChannelBlend provides functionality to combine bitmaps arithmetically.

*

*/

// INCLUDE FILES

#include "AknsRlEffectPluginChannelBlend.h"

#include "AknsRlEffectUtil.h"

#include "AknsRlExpand.h"

// ==================== TEMPLATE IMPL. OF CHANNEL BLEND ========================

/**

* Template implementation of ChannelBlend. It is assumed that arithmetic

* shifting is supported -> negative values are shifted correctly. Pitch is the

* number of data elements to skip before moving to next line. Note that all

* non-masked cases are also done with the alpha blended version (masks are

* constants in that case).

*

* 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

* aFactor The blend factor between A and B on the output.

*

* 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 AknsRlBlend

    {

    public:

    static void Normal( 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 aFactor );

    static void Darken( 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 aFactor );

    static void Lighten( 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 aFactor );

    static void Multiply( 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 aFactor );

    static void Screen( 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 aFactor );

    static void Overlay( 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 aFactor );

    static void HardLight( 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 aFactor );

    static void SoftLight( 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 aFactor );

    static void Difference( 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 aFactor );

    static void Dodge( 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 aFactor );

    static void Burn( 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 aFactor );

    };

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

// AknsRlBlend::Normal

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

//

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

void AknsRlBlend<T,X,R,G,B>::Normal( 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 aFactor )

    {

    TInt x, y, 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 * aFactor + ( 255 - aFactor ) * sa ) >> 8;

            if( r < 0 ) r = 0; else if( r > 255 ) r = 255;

            // AlphaBlend red (BoverA)

            r = ((mb * r)>>8) + ((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 * aFactor + ( 255 - aFactor ) * sa ) >> 8;

            if( g < 0 ) g = 0; else if( g > 255 ) g = 255;

            // AlphaBlend green (BoverA)

            g = ((mb * g)>>8) + ((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 * aFactor + ( 255 - aFactor ) * sa ) >> 8;

            if( b < 0 ) b = 0; else if( b > 255 ) b = 255;

            // AlphaBlend blue (BoverA)

            b = ((mb * b)>>8) + ((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;

        }

    }

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

// AknsRlBlend::Darken

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

//

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

void AknsRlBlend<T,X,R,G,B>::Darken( 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 aFactor )

    {

    TInt x, y, 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;

            if( sa < sb )

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

            else

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

            if( r < 0 ) r = 0; else if( r > 255 ) r = 255;

            // AlphaBlend red (BoverA)

            r = ((mb * r)>>8) + ((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;

            if( sa < sb )

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

            else

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

            if( g < 0 ) g = 0; else if( g > 255 ) g = 255;

            // AlphaBlend green (BoverA)

            g = ((mb * g)>>8) + ((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;

            if( sa < sb )

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

            else

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

            if( b < 0 ) b = 0; else if( b > 255 ) b = 255;

            // AlphaBlend blue (BoverA)

            b = ((mb * b)>>8) + ((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;

        }

    }

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

// AknsRlBlend::Lighten

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

//

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

void AknsRlBlend<T,X,R,G,B>::Lighten( 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 aFactor )

    {

    TInt x, y, 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;

            if( sa > sb )

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

            else

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

            if( r < 0 ) r = 0; else if( r > 255 ) r = 255;

            // AlphaBlend red (BoverA)

            r = ((mb * r)>>8) + ((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;

            if( sa > sb )

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

            else

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

            if( g < 0 ) g = 0; else if( g > 255 ) g = 255;

            // AlphaBlend green (BoverA)

            g = ((mb * g)>>8) + ((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;

            if( sa > sb )

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

            else

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

            if( b < 0 ) b = 0; else if( b > 255 ) b = 255;

            // AlphaBlend blue (BoverA)

            b = ((mb * b)>>8) + ((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;

        }

    }

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

// AknsRlBlend::Multiply

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

//

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

void AknsRlBlend<T,X,R,G,B>::Multiply( 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 aFactor )

    {

    TInt x, y, 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 ) >> 8) * aFactor + ( 255 - aFactor ) * sa ) >> 8;

            if( r < 0 ) r = 0; else if( r > 255 ) r = 255;

            // AlphaBlend red (BoverA)

            r = ((mb * r)>>8) + ((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 = ( (( sa * sb ) >> 8) * aFactor + ( 255 - aFactor ) * sa ) >> 8;

            if( g < 0 ) g = 0; else if( g > 255 ) g = 255;

            // AlphaBlend green (BoverA)

            g = ((mb * g)>>8) + ((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 = ( (( sa * sb ) >> 8) * aFactor + ( 255 - aFactor ) * sa ) >> 8;

            if( b < 0 ) b = 0; else if( b > 255 ) b = 255;

            // AlphaBlend blue (BoverA)

            b = ((mb * b)>>8) + ((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;

        }

    }

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

// AknsRlBlend::Screen

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

//

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

void AknsRlBlend<T,X,R,G,B>::Screen( 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 aFactor )

    {

    TInt x, y, 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 = ( (255 - ((( 255 - sa ) * ( 255 - sb )) >> 8 )) * aFactor + ( 255 - aFactor ) * sa ) >> 8;

            if( r < 0 ) r = 0; else if( r > 255 ) r = 255;

            // AlphaBlend red (BoverA)

            r = ((mb * r)>>8) + ((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 = ( (255 - ((( 255 - sa ) * ( 255 - sb )) >> 8 )) * aFactor + ( 255 - aFactor ) * sa ) >> 8;

            if( g < 0 ) g = 0; else if( g > 255 ) g = 255;

            // AlphaBlend green (BoverA)

            g = ((mb * g)>>8) + ((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 = ( (255 - ((( 255 - sa ) * ( 255 - sb )) >> 8 )) * aFactor + ( 255 - aFactor ) * sa ) >> 8;

            if( b < 0 ) b = 0; else if( b > 255 ) b = 255;

            // AlphaBlend blue (BoverA)

            b = ((mb * b)>>8) + ((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;

        }

    }

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

// AknsRlBlend::Overlay

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

//

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

void AknsRlBlend<T,X,R,G,B>::Overlay( 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 aFactor )

    {

    TInt x, y, 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;

            if( sa < 127 )

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

            else

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

            if( r < 0 ) r = 0; else if( r > 255 ) r = 255;

            // AlphaBlend red (BoverA)

            r = ((mb * r)>>8) + ((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;

            if( sa < 127 )

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

            else

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

            if( g < 0 ) g = 0; else if( g > 255 ) g = 255;

            // AlphaBlend green (BoverA)

            g = ((mb * g)>>8) + ((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;

            if( sa < 127 )

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

            else

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

            if( b < 0 ) b = 0; else if( b > 255 ) b = 255;

            // AlphaBlend blue (BoverA)

            b = ((mb * b)>>8) + ((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;

        }

    }

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

// AknsRlBlend::HardLight

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

//

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

void AknsRlBlend<T,X,R,G,B>::HardLight( 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 aFactor )

    {

    TInt x, y, 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;

            if( sb < 127 )

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

            else

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

            if( r < 0 ) r = 0; else if( r > 255 ) r = 255;

            // AlphaBlend red (BoverA)

            r = ((mb * r)>>8) + ((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;

            if( sb < 127 )

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

            else

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

            if( g < 0 ) g = 0; else if( g > 255 ) g = 255;

            // AlphaBlend green (BoverA)

            g = ((mb * g)>>8) + ((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;

            if( sb < 127 )

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

            else

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

            if( b < 0 ) b = 0; else if( b > 255 ) b = 255;

            // AlphaBlend blue (BoverA)

            b = ((mb * b)>>8) + ((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;

        }

    }

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

// AknsRlBlend::SoftLight

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

//

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

void AknsRlBlend<T,X,R,G,B>::SoftLight( 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 aFactor )

    {

    TInt x, y, 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 = ( (2 * (( sa * sb ) >> 8 ) + (( sa * sa ) >> 8 ) - 2 * (( sa * (( sa * sb ) >> 8 )) >> 8 )) * aFactor + ( 255 - aFactor ) * sa ) >> 8;

            if( r < 0 ) r = 0; else if( r > 255 ) r = 255;

            // AlphaBlend red (BoverA)

            r = ((mb * r)>>8) + ((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 = ( (2 * (( sa * sb ) >> 8 ) + (( sa * sa ) >> 8 ) - 2 * (( sa * (( sa * sb ) >> 8 )) >> 8 )) * aFactor + ( 255 - aFactor ) * sa ) >> 8;

            if( g < 0 ) g = 0; else if( g > 255 ) g = 255;

            // AlphaBlend green (BoverA)

            g = ((mb * g)>>8) + ((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 = ( (2 * (( sa * sb ) >> 8 ) + (( sa * sa ) >> 8 ) - 2 * (( sa * (( sa * sb ) >> 8 )) >> 8 )) * aFactor + ( 255 - aFactor ) * sa ) >> 8;

            if( b < 0 ) b = 0; else if( b > 255 ) b = 255;

            // AlphaBlend blue (BoverA)

            b = ((mb * b)>>8) + ((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;