/*

* 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:  Provides convolution operations on images.

*

*/

// INCLUDE FILES

#include "AknsRlEffectPluginConvolution.h"

#include "AknsRlEffectUtil.h"

#include "fx_asm_versions.h"

// CONSTANTS

// Fixed convolution kernels

const TInt KKernelEdgeDetect[9]    = { -1, -1, -1,

                                       -1,  8, -1,

                                       -1, -1, -1 };

const TInt KKernelBlur[9]          = { 1, 2, 1,

                                       2, 2, 2,

                                       1, 2, 1 };

const TInt KKernelBlurGauss[9]     = { 0, 1, 0,

                                       1, 4, 1,

                                       0, 1, 0 };

const TInt KKernelEmbossSoft[9]    = { -1, 0, 0,

                                        0, 0, 0,

                                        0, 0, 1 };

const TInt KKernelEmbossHard[9]    = { -1, -1, 0,

                                       -1,  0, 1,

                                        0,  1, 1 };

const TInt KKernelEnhanceDetail[9] = { 0, -1,  0,

                                      -1,  9, -1,

                                       0, -1,  0 };

const TInt KKernelEnhanceFocus[9]  = { -1, 0, -1,

                                        0, 7,  0,

                                       -1, 0, -1 };

const TInt KKernelSoften[9]        = { 1, 1, 1,

                                       1, 1, 1,

                                       1, 1, 1 };

const TInt KKernelSharpen[9]       = { 0, -1,  0,

                                      -1,  5, -1,

                                       0, -1,  0 };

const TInt KKernelSharpenMore[9]   = {-1, -1, -1,

                                      -1,  9, -1,

                                      -1, -1, -1 };

/*lint -save -e834 */ // Let's get real...not confusing

// ==================== TEMPLATE IMPL. OF CONVOLUTION ==========================

/**

* Template implementation of Convolution. Type defines the used data type for

* iterating over the bitmap data. X, R, G and B define the used pixel color bit

* layout.

*/

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

class AknsRlEffectConvolution

    {

    public:

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

    /**

    * Convolutes a bitmap with generic 3x3 convolution kernel.

    */

    static void Kernel( const CFbsBitmap& aTarget,

                        const CFbsBitmap& aSource,

                        const TInt aKernel[9],

                        const TInt aBlendFactor,

                        const TInt aBias )

    {

    TInt width  = aTarget.SizeInPixels().iWidth;

    TInt height = aTarget.SizeInPixels().iHeight;

    // ScanLineLength returns bytes, but width must match the Type

    TInt scanWtarget  = (CFbsBitmap::ScanLineLength(aTarget.SizeInPixels().iWidth, aTarget.DisplayMode())) / sizeof(Type);

    TInt scanWsource  = (CFbsBitmap::ScanLineLength(aSource.SizeInPixels().iWidth, aSource.DisplayMode())) / sizeof(Type);

    TInt kernelSum = aKernel[0] + aKernel[1] + aKernel[2] +

                     aKernel[3] + aKernel[4] + aKernel[5] +

                     aKernel[6] + aKernel[7] + aKernel[8];

    if( 0 == kernelSum )

        kernelSum = 1;

    TInt r, g, b;

    TInt x, y; // Loop counters

    // Pitch is the number of pixels to skip before next scanline start

    TInt pitchTarget = scanWtarget - width;

    TInt pitchSource = scanWsource - width;

    // Prepare the data addresses

    aTarget.LockHeap( ETrue ); // Lock the global bitmap heap

    Type* dataT = reinterpret_cast<Type*>( aTarget.DataAddress() );

    Type* dataS = reinterpret_cast<Type*>( aSource.DataAddress() );

    dataS = dataS + scanWsource + 1;

    // Do the actual convolution

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

        {

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

            {

            r = aBias + (AknsRlRgb<Type,X,R,G,B>::R8(*(dataS - scanWsource - 1)) * aKernel[0] +

                         AknsRlRgb<Type,X,R,G,B>::R8(*(dataS - scanWsource    )) * aKernel[1] +

                         AknsRlRgb<Type,X,R,G,B>::R8(*(dataS - scanWsource + 1)) * aKernel[2] +

                         AknsRlRgb<Type,X,R,G,B>::R8(*(dataS - 1              )) * aKernel[3] +

                         AknsRlRgb<Type,X,R,G,B>::R8(*(dataS                  )) * aKernel[4] +

                         AknsRlRgb<Type,X,R,G,B>::R8(*(dataS + 1              )) * aKernel[5] +

                         AknsRlRgb<Type,X,R,G,B>::R8(*(dataS + scanWsource - 1)) * aKernel[6] +

                         AknsRlRgb<Type,X,R,G,B>::R8(*(dataS + scanWsource    )) * aKernel[7] +

                         AknsRlRgb<Type,X,R,G,B>::R8(*(dataS + scanWsource + 1)) * aKernel[8]) / kernelSum;

            g = aBias + (AknsRlRgb<Type,X,R,G,B>::G8(*(dataS - scanWsource - 1)) * aKernel[0] +

                         AknsRlRgb<Type,X,R,G,B>::G8(*(dataS - scanWsource    )) * aKernel[1] +

                         AknsRlRgb<Type,X,R,G,B>::G8(*(dataS - scanWsource + 1)) * aKernel[2] +

                         AknsRlRgb<Type,X,R,G,B>::G8(*(dataS - 1              )) * aKernel[3] +

                         AknsRlRgb<Type,X,R,G,B>::G8(*(dataS                  )) * aKernel[4] +

                         AknsRlRgb<Type,X,R,G,B>::G8(*(dataS + 1              )) * aKernel[5] +

                         AknsRlRgb<Type,X,R,G,B>::G8(*(dataS + scanWsource - 1)) * aKernel[6] +

                         AknsRlRgb<Type,X,R,G,B>::G8(*(dataS + scanWsource    )) * aKernel[7] +

                         AknsRlRgb<Type,X,R,G,B>::G8(*(dataS + scanWsource + 1)) * aKernel[8]) / kernelSum;

            b = aBias + (AknsRlRgb<Type,X,R,G,B>::B8(*(dataS - scanWsource - 1)) * aKernel[0] +

                         AknsRlRgb<Type,X,R,G,B>::B8(*(dataS - scanWsource    )) * aKernel[1] +

                         AknsRlRgb<Type,X,R,G,B>::B8(*(dataS - scanWsource + 1)) * aKernel[2] +

                         AknsRlRgb<Type,X,R,G,B>::B8(*(dataS - 1              )) * aKernel[3] +

                         AknsRlRgb<Type,X,R,G,B>::B8(*(dataS                  )) * aKernel[4] +

                         AknsRlRgb<Type,X,R,G,B>::B8(*(dataS + 1              )) * aKernel[5] +

                         AknsRlRgb<Type,X,R,G,B>::B8(*(dataS + scanWsource - 1)) * aKernel[6] +

                         AknsRlRgb<Type,X,R,G,B>::B8(*(dataS + scanWsource    )) * aKernel[7] +

                         AknsRlRgb<Type,X,R,G,B>::B8(*(dataS + scanWsource + 1)) * aKernel[8]) / kernelSum;

            // Exposure blending. Note: It is assumed that arithmetic shifting

            // is supported -> negative values are shifted correctly

            r = ( r * aBlendFactor + (255 - aBlendFactor) * AknsRlRgb<Type,X,R,G,B>::R8(*dataS) ) >> 8;

            g = ( g * aBlendFactor + (255 - aBlendFactor) * AknsRlRgb<Type,X,R,G,B>::G8(*dataS) ) >> 8;

            b = ( b * aBlendFactor + (255 - aBlendFactor) * AknsRlRgb<Type,X,R,G,B>::B8(*dataS) ) >> 8;

            if( r < 0 ) r = 0;

            else if( r > 255 ) r = 255;

            if( g < 0 ) g = 0;

            else if( g > 255 ) g = 255;

            if( b < 0 ) b = 0;

            else if( b > 255 ) b = 255;

            AknsRlRgb<Type,X,R,G,B>::SetRgb8( dataT, TUint8(r), TUint8(g), TUint8(b) );

            dataT++;

            dataS++;

            }

        dataT = dataT + pitchTarget;

        dataS = dataS + pitchSource;

        }

    aTarget.UnlockHeap( ETrue ); // Unlock the global bitmap heap

    }

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

    /**

    * "Convolutes" a bitmap with adjustable gaussian blur kernel.

    * Kernel size from 3*3 to 33*33 (odd sizes).

    */

    static void AdjustableGaussian( const CFbsBitmap& aTarget,

                                    const CFbsBitmap& aSource,

                                    TUint16* aColumnBuffer,

                                    const TInt aKernelsize )

    {

    TInt width  = aTarget.SizeInPixels().iWidth;

    TInt height = aTarget.SizeInPixels().iHeight;

    // ScanLineLength returns bytes, but width must match the Type

    TInt scanWtarget  = (CFbsBitmap::ScanLineLength(aTarget.SizeInPixels().iWidth, aTarget.DisplayMode())) / sizeof(Type);

    TInt scanWsource  = (CFbsBitmap::ScanLineLength(aSource.SizeInPixels().iWidth, aSource.DisplayMode())) / sizeof(Type);

    TUint16 r, g, b;

    r=0;

    g=0;

    b=0;

    TInt x, y, i; // Loop counters

    TInt bufIndx, bufIndxTarget;

    // Pitch is the number of pixels to skip before next scanline start

    TInt pitchTarget = scanWtarget - width;

    TInt pitchSource = scanWsource - width;

    // Prepare the data addresses

    aTarget.LockHeap( ETrue ); // Lock the global bitmap heap

    Type* dataT = reinterpret_cast<Type*>( aTarget.DataAddress() );

    Type* dataS = reinterpret_cast<Type*>( aSource.DataAddress() );

    Type* dataR = dataT; // for recursive iterations, both source and target are the same

    dataS = dataS + scanWsource + 1; // state machine takes pixel (1,1) and output goes to pixel (0,0)

    TUint16 tmp1;

    TUint16 tmp2;

    // row buffer variables for red, green and blue components

    TUint16 SR0r;

    TUint16 SR1r;

    TUint16 SR0g;

    TUint16 SR1g;

    TUint16 SR0b;

    TUint16 SR1b;

    TInt col0_rIndex; // index for row 0 columns in aColumnBuffer for red component

    TInt col1_rIndex; // index for row 1 columns in aColumnBuffer for red component

    TInt col0_gIndex; // index for row 0 columns in aColumnBuffer for green component

    TInt col1_gIndex; // index for row 1 columns in aColumnBuffer for green component

    TInt col0_bIndex; // index for row 0 columns in aColumnBuffer for blue component

    TInt col1_bIndex; // index for row 1 columns in aColumnBuffer for blue component

    TBool renderWithBuffers = ETrue;

    if ( aKernelsize < 7 ) // don't try to use temp buffers with small kernel

        renderWithBuffers = EFalse;

    TUint16* redBuffer;

    TUint16* greenBuffer;

    TUint16* blueBuffer;

    // to disable warnings

    redBuffer = NULL;

    greenBuffer = NULL;

    blueBuffer = NULL;

    if( renderWithBuffers )

        {

        // OOM returns NULL

        redBuffer = new TUint16[(width+1)*(height+1)];

        greenBuffer = new TUint16[(width+1)*(height+1)];

        blueBuffer = new TUint16[(width+1)*(height+1)];

        // All buffers are required for rendering

        if( !redBuffer || !greenBuffer || !blueBuffer )

            {

            delete [] redBuffer;

            redBuffer = NULL;

            delete [] greenBuffer;

            greenBuffer = NULL;

            delete [] blueBuffer;

            blueBuffer = NULL;

            renderWithBuffers = EFalse;

            }

        }

    if( renderWithBuffers )

        {

        i = width + 2; // start writing to pixel (1,1)

        for ( y = 0; y < (height - 1) ; y++ )

            {

            for ( x = 0; x < (width - 1) ; x++ )

                {

                redBuffer[i] = (TUint16)AknsRlRgb<Type,X,R,G,B>::R8(*dataS);

                greenBuffer[i] = (TUint16)AknsRlRgb<Type,X,R,G,B>::G8(*dataS);

                blueBuffer[i] = (TUint16)AknsRlRgb<Type,X,R,G,B>::B8(*dataS);

                i++;

                dataS++;

                }

            redBuffer[i] = redBuffer[i-1];

            greenBuffer[i] = greenBuffer[i-1];

            blueBuffer[i] = blueBuffer[i-1];

            i+=2; // start from second pixel

            dataS = dataS + pitchSource + 1; // start from second pixel

            }

        for ( x = 0; x < width ; x++ ) // copy bottom row

            {

            redBuffer[i] = redBuffer[i-(width+1)];

            greenBuffer[i] = greenBuffer[i-(width+1)];

            blueBuffer[i] = blueBuffer[i-(width+1)];

            i++;

            }

        redBuffer[1] = redBuffer[width+2]; // initialize these for row registers

        greenBuffer[1] = greenBuffer[width+2];

        blueBuffer[1] = blueBuffer[width+2];

        for ( i = 0; i < (aKernelsize - 1) >> 1 ; i++ ) // do (N-1) / 2 times

            {

            bufIndx = width+2;

            bufIndxTarget = 0;

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

                {

                SR0r = redBuffer[bufIndxTarget+1]; // initialize row buffer variables

                SR1r = redBuffer[bufIndxTarget+1];

                SR0g = greenBuffer[bufIndxTarget+1];

                SR1g = greenBuffer[bufIndxTarget+1];

                SR0b = blueBuffer[bufIndxTarget+1];

                SR1b = blueBuffer[bufIndxTarget+1];

                col0_rIndex = 0; // initialize indexes for column buffers

                col1_rIndex = width;

                col0_gIndex = col1_rIndex + width;

                col1_gIndex = col0_gIndex + width;

                col0_bIndex = col1_gIndex + width;

                col1_bIndex = col0_bIndex + width;

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

                    {

                    // red

                    tmp1 = redBuffer[bufIndx];

                    tmp2 = (TUint16)(SR0r + tmp1);

                    SR0r = tmp1;

                    tmp1 = (TUint16)(SR1r + tmp2);

                    SR1r = tmp2;

                    tmp2 = (TUint16)(aColumnBuffer[col0_rIndex] + tmp1);

                    aColumnBuffer[col0_rIndex++] = tmp1;

                    redBuffer[bufIndxTarget] = (TUint16)((8 + aColumnBuffer[col1_rIndex] + tmp2) >> 4);

                    aColumnBuffer[col1_rIndex++] = tmp2;

                    // green

                    tmp1 = greenBuffer[bufIndx];

                    tmp2 = (TUint16)(SR0g + tmp1);

                    SR0g = tmp1;

                    tmp1 = (TUint16)(SR1g + tmp2);

                    SR1g = tmp2;

                    tmp2 = (TUint16)(aColumnBuffer[col0_gIndex] + tmp1);

                    aColumnBuffer[col0_gIndex++] = tmp1;

                    greenBuffer[bufIndxTarget] = (TUint16)((8 + aColumnBuffer[col1_gIndex] + tmp2) >> 4);

                    aColumnBuffer[col1_gIndex++] = tmp2;

                    // blue

                    tmp1 = blueBuffer[bufIndx++];

                    tmp2 = (TUint16)(SR0b + tmp1);

                    SR0b = tmp1;

                    tmp1 = (TUint16)(SR1b + tmp2);

                    SR1b = tmp2;

                    tmp2 = (TUint16)(aColumnBuffer[col0_bIndex] + tmp1);

                    aColumnBuffer[col0_bIndex++] = tmp1;

                    b = (TUint16)((8 + aColumnBuffer[col1_bIndex] + tmp2) >> 4);

                    blueBuffer[bufIndxTarget++] = (TUint16)b;

                    aColumnBuffer[col1_bIndex++] = tmp2;

                    }

                bufIndx++;

                bufIndxTarget++;

                }

            }

            // now write target from buffers

            i = 0;

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

                {

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

                    {

                    AknsRlRgb<Type,X,R,G,B>::SetRgb8LessG( dataT,

                                                      redBuffer[i],

                                                      greenBuffer[i],

                                                      blueBuffer[i++] );

                    dataT++;

                    }

                dataT = dataT + pitchTarget;

                i++;

                }

            aTarget.UnlockHeap( ETrue ); // Unlock the global bitmap heap

            delete [] redBuffer;

            delete [] greenBuffer;

            delete [] blueBuffer;

            return;

        }

    else

        {

        // Do the actual convolution

        for ( i = 0; i < (aKernelsize - 1) >> 1 ; i++ ) // do (N-1) / 2 times

            {

            for( y = 0; y < (height - 1); y++ )

                {

                SR0r = 0; // initialize row buffer variables

                SR1r = 0;

                SR0g = 0;

                SR1g = 0;

                SR0b = 0;

                SR1b = 0;

                col0_rIndex = 0; // initialize indexes for column buffers

                col1_rIndex = width;

                col0_gIndex = col1_rIndex + width;

                col1_gIndex = col0_gIndex + width;

                col0_bIndex = col1_gIndex + width;

                col1_bIndex = col0_bIndex + width;

                for( x = 0; x < (width - 1); x++ )

                    {

                    // red

                    tmp1 = (TUint16)AknsRlRgb<Type,X,R,G,B>::R8(*dataS);

                    tmp2 = (TUint16)(SR0r + tmp1);

                    SR0r = tmp1;

                    tmp1 = (TUint16)(SR1r + tmp2);

                    SR1r = tmp2;

                    tmp2 = (TUint16)(aColumnBuffer[col0_rIndex] + tmp1);

                    aColumnBuffer[col0_rIndex++] = tmp1;

                    r = (TUint16)((8 + aColumnBuffer[col1_rIndex] + tmp2) >> 4);

                    aColumnBuffer[col1_rIndex++] = tmp2;

                    // green

                    tmp1 = (TUint16)AknsRlRgb<Type,X,R,G,B>::G8(*dataS);

                    tmp2 = (TUint16)(SR0g + tmp1);

                    SR0g = tmp1;

                    tmp1 = (TUint16)(SR1g + tmp2);

                    SR1g = tmp2;

                    tmp2 = (TUint16)(aColumnBuffer[col0_gIndex] + tmp1);

                    aColumnBuffer[col0_gIndex++] = tmp1;

                    g = (TUint16)((8 + aColumnBuffer[col1_gIndex] + tmp2) >> 4);

                    aColumnBuffer[col1_gIndex++] = tmp2;

                    // blue

                    tmp1 = (TUint16)AknsRlRgb<Type,X,R,G,B>::B8(*dataS);

                    tmp2 = (TUint16)(SR0b + tmp1);

                    SR0b = tmp1;

                    tmp1 = (TUint16)(SR1b + tmp2);

                    SR1b = tmp2;

                    tmp2 = (TUint16)(aColumnBuffer[col0_bIndex] + tmp1);

                    aColumnBuffer[col0_bIndex++] = tmp1;

                    b = (TUint16)((8 + aColumnBuffer[col1_bIndex] + tmp2) >> 4);

                    aColumnBuffer[col1_bIndex++] = tmp2;

                    if( r > 255 ) r = 255;

                    if( g > 255 ) g = 255;

                    if( b > 255 ) b = 255;

                    AknsRlRgb<Type,X,R,G,B>::SetRgb8LessG( dataT, r, g, b );

                    dataT++;

                    dataS++;

                    }

                dataT = dataT + pitchTarget + 1;

                dataS = dataS + pitchSource + 1;

                }

            dataT = dataR; // for more than 1 iterations, use target bitmap for both

            dataS = dataR+scanWtarget+1; // target and source

            }

        aTarget.UnlockHeap( ETrue ); // Unlock the global bitmap heap

        }

    }

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

    /**

    * Convolutes a bitmap by calculating the mean value of a 3x3 pixel

    * neighborhood as the resulting pixel value.

    */

    static void Mean( const CFbsBitmap& aTarget,

                      const CFbsBitmap& aSource,

                      TInt aBlendFactor )

    {

    TInt width  = aTarget.SizeInPixels().iWidth;

    TInt height = aTarget.SizeInPixels().iHeight;

    // ScanLineLength returns bytes, but width must match the Type

    TInt scanWtarget  = (CFbsBitmap::ScanLineLength(aTarget.SizeInPixels().iWidth, aTarget.DisplayMode())) / sizeof(Type);

    TInt scanWsource  = (CFbsBitmap::ScanLineLength(aSource.SizeInPixels().iWidth, aSource.DisplayMode())) / sizeof(Type);

    TInt r, g, b;

    TInt x, y; // Loop counters

    // Pitch is the number of pixels to skip before next scanline start

    TInt pitchTarget = scanWtarget - width;

    TInt pitchSource = scanWsource - width;

    // Prepare the data addresses

    aTarget.LockHeap( ETrue ); // Lock the global bitmap heap

    Type* dataT = reinterpret_cast<Type*>( aTarget.DataAddress() );

    Type* dataS = reinterpret_cast<Type*>( aSource.DataAddress() );

    dataS = dataS + scanWsource + 1;

    // Calculate the mean per pixel

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

        {

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

            {

            r = (AknsRlRgb<Type,X,R,G,B>::R8(*(dataS - scanWsource - 1)) +

                 AknsRlRgb<Type,X,R,G,B>::R8(*(dataS - scanWsource    )) +

                 AknsRlRgb<Type,X,R,G,B>::R8(*(dataS - scanWsource + 1)) +

                 AknsRlRgb<Type,X,R,G,B>::R8(*(dataS - 1              )) +

                 AknsRlRgb<Type,X,R,G,B>::R8(*(dataS                  )) +

                 AknsRlRgb<Type,X,R,G,B>::R8(*(dataS + 1              )) +

                 AknsRlRgb<Type,X,R,G,B>::R8(*(dataS + scanWsource - 1)) +

                 AknsRlRgb<Type,X,R,G,B>::R8(*(dataS + scanWsource    )) +

                 AknsRlRgb<Type,X,R,G,B>::R8(*(dataS + scanWsource + 1))) / 9;

            g = (AknsRlRgb<Type,X,R,G,B>::G8(*(dataS - scanWsource - 1)) +

                 AknsRlRgb<Type,X,R,G,B>::G8(*(dataS - scanWsource    )) +

                 AknsRlRgb<Type,X,R,G,B>::G8(*(dataS - scanWsource + 1)) +

                 AknsRlRgb<Type,X,R,G,B>::G8(*(dataS - 1              )) +

                 AknsRlRgb<Type,X,R,G,B>::G8(*(dataS                  )) +

                 AknsRlRgb<Type,X,R,G,B>::G8(*(dataS + 1              )) +

                 AknsRlRgb<Type,X,R,G,B>::G8(*(dataS + scanWsource - 1)) +

                 AknsRlRgb<Type,X,R,G,B>::G8(*(dataS + scanWsource    )) +

                 AknsRlRgb<Type,X,R,G,B>::G8(*(dataS + scanWsource + 1))) / 9;

            b = (AknsRlRgb<Type,X,R,G,B>::B8(*(dataS - scanWsource - 1)) +

                 AknsRlRgb<Type,X,R,G,B>::B8(*(dataS - scanWsource    )) +

                 AknsRlRgb<Type,X,R,G,B>::B8(*(dataS - scanWsource + 1)) +

                 AknsRlRgb<Type,X,R,G,B>::B8(*(dataS - 1              )) +

                 AknsRlRgb<Type,X,R,G,B>::B8(*(dataS                  )) +

                 AknsRlRgb<Type,X,R,G,B>::B8(*(dataS + 1              )) +

                 AknsRlRgb<Type,X,R,G,B>::B8(*(dataS + scanWsource - 1)) +

                 AknsRlRgb<Type,X,R,G,B>::B8(*(dataS + scanWsource    )) +

                 AknsRlRgb<Type,X,R,G,B>::B8(*(dataS + scanWsource + 1))) / 9;

            // Exposure blending. Note: It is assumed that arithmetic shifting