/*

* Copyright (c) 2005-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:  Extension to chunk maintainer.

*

*/

#include "AknsSrvChunkMaintainer.h"

#include "AknsSrvUtils.h"

#include "AknsSrvDescriptorFileLayout.h"

#include "AknsDebug.h"

// CONSTANTS

// Max of 32 effects per queue and 64 params per effect should be enough

static const TInt KAknsSrvMaxEffectCount      = 0x20;

static const TInt KAknsSrvMaxParamGroupCount  = 0x20;

static const TInt KAknsSrvMaxEffectParamCount = 0x40;

/**

* A wrapper class for RPointerArray cleanup.

*/

NONSHARABLE_CLASS( CAknsSrvArrayStore ): public CBase

    {

    public:

        CAknsSrvArrayStore()

            {}

        ~CAknsSrvArrayStore()

            {

            while( iArray.Count() )

                {

                delete [] iArray[0];

                iArray.Remove(0);

                }

            iArray.Reset();

            }

    public:

        RPointerArray<TUint8> iArray;

    };

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

// CAknsSrvChunkMaintainer::DoMergeEffectQueueL

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

//

void CAknsSrvChunkMaintainer::DoMergeEffectQueueL(

    CAknsSrvFileBuffer& aFile, const TUint aOffset,

    const TAknsItemDefClass /*aClass*/,

    const TAknsSrvExclusionQuery& aExclQuery, const TBool /*aAhOverride*/ )

    {

    TAknsSrvDef itemDef;

    TInt32 major = AknsSrvUtils::GetInt32L( aFile, aOffset+EAknsSrvDFOEffectQueueMajor );

    TInt32 minor = AknsSrvUtils::GetInt32L( aFile, aOffset+EAknsSrvDFOEffectQueueMinor );

    TInt32 refmajor = AknsSrvUtils::GetInt32L( aFile, aOffset+EAknsSrvDFOEffectQueueRefMajor );

    TInt32 refminor = AknsSrvUtils::GetInt32L( aFile, aOffset+EAknsSrvDFOEffectQueueRefMinor );

    TUint8 inputlayerindex = AknsSrvUtils::GetUInt8L( aFile, aOffset + EAknsSrvDFOEffectQueueInputLayerIndex);

    TUint8 inputlayermode = AknsSrvUtils::GetUInt8L( aFile, aOffset + EAknsSrvDFOEffectQueueInputLayerMode);

    TUint8 outputlayerindex = AknsSrvUtils::GetUInt8L( aFile, aOffset + EAknsSrvDFOEffectQueueOutputLayerIndex);

    TUint8 outputlayermode = AknsSrvUtils::GetUInt8L( aFile, aOffset + EAknsSrvDFOEffectQueueOutputLayerMode);

    TUint16 effectcount = AknsSrvUtils::GetUInt16L( aFile, aOffset + EAknsSrvDFOEffectQueueEffectCount);

    if( inputlayermode > 0x08 ||

        outputlayermode > 0x08 ||

        effectcount > KAknsSrvMaxEffectCount )

        {

        User::Leave(KErrCorrupt);

        }

    TUint32 size = 0;

    itemDef.iID.Set(major,minor);

    if( aExclQuery.IsExcluded( itemDef.iID ) )

        {

        return;

        }

    CheckAndModifyIID( itemDef.iID, aExclQuery );

    itemDef.iType = EAknsITEffectQueue;

    if (refmajor && refminor)

        {

        TAknsSrvEffectQueueDef eq;

        eq.iEffectQueueSize = sizeof(TAknsSrvEffectQueueDef);

        eq.iEffectCount = 0;

        eq.iRefMajor = refmajor;

        eq.iRefMinor = refminor;

        UpdateDef(&itemDef,&eq,sizeof(TAknsSrvEffectQueueDef),-1);

        return;

        }

    CAknsSrvArrayStore* effectArray = new(ELeave) CAknsSrvArrayStore();

    CleanupStack::PushL( effectArray );

    TUint32 eqBase = EAknsSrvDFOEffectQueueEffects;

    TUint32 totalEffectSize = 0;

    // process all effect chunks inside

    totalEffectSize = DoMergeEffectCommandsL( aFile, aOffset, eqBase, effectArray->iArray, effectcount );

    // All effects collected, add them to the queue

    TUint8* eqBlock = new (ELeave) TUint8[sizeof(TAknsSrvEffectQueueDef)+totalEffectSize];

    // No leaves after this

    TAknsSrvEffectQueueDef* eqDef = (TAknsSrvEffectQueueDef*)eqBlock;

    eqDef->iEffectCount = effectcount;

    eqDef->iRefMinor = 0;

    eqDef->iRefMajor = 0;

    eqDef->iInputLayerIndex = inputlayerindex;

    eqDef->iInputLayerMode = inputlayermode;

    eqDef->iOutputLayerIndex = outputlayerindex;

    eqDef->iOutputLayerMode = outputlayermode;

    TUint32 base = sizeof(TAknsSrvEffectQueueDef);

    for (TInt ecount = 0; ecount < effectcount; ecount++)

        {

        TAknsSrvEffectDef* effectDef = (TAknsSrvEffectDef*)(effectArray->iArray[ecount]);

        size = effectDef->iEffectSize;

        Mem::Copy(eqBlock+base, effectDef, size);

        base+=size;

        }

    eqDef->iEffectQueueSize = sizeof(TAknsSrvEffectQueueDef)+totalEffectSize;

    CleanupStack::PopAndDestroy( effectArray ); // effectArray

    UpdateDef( &itemDef, eqDef, sizeof(TAknsSrvEffectQueueDef)+totalEffectSize, -1 );

    delete [] eqBlock;

    // Leaves ok as eqBlock has been deleted

    }

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

// CAknsSrvChunkMaintainer::DoMergeParamL

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

//

TUint32 CAknsSrvChunkMaintainer::DoMergeParamsL(

    CAknsSrvFileBuffer& aFile, const TUint aOffset, TUint32& aEqBase,

    RPointerArray<TUint8>& aParamArray, const TUint16 aParamCount )

    {

    TUint32 totalparamsize = 0; // total size of all parameters

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

        {

        TUint16 totalparamlen = AknsSrvUtils::GetUInt16L( aFile, aOffset + aEqBase);

        TUint32 datasize = totalparamlen-4; //ParamLength(TUint16)-Reserved(TUint8)-ParamType(TUint8)

        // lets assume that one effect cannot be larger than 32kb (should be more than enough)

        if (datasize >= 0x8000)

            {

            User::Leave(KErrCorrupt);

            }

        TUint8 ptype = AknsSrvUtils::GetUInt8L(aFile,aOffset+aEqBase+3);

        TUint8* paramBlock = NULL;

        TAknsSrvEffectParameterDef* paramDef = NULL;

        TUint8* data = AknsSrvUtils::ReadSkinDescL(aFile, aOffset+aEqBase+4, datasize);

        CleanupStack::PushL(data);

        if (ptype == 2) // graphics param

            {

            TUint32 filenameid = *((TUint32*)(data+datasize-4)) + iCurrentFilenameID;

            TInt filenameoffset = GetFilenameOffsetByID(filenameid);

            paramBlock = new (ELeave) TUint8[sizeof(TAknsSrvEffectParameterDef)+datasize-4+KAknsSrvMaxFileNameLen-4];

            CleanupStack::PushL( paramBlock );

            paramDef = (TAknsSrvEffectParameterDef*)paramBlock;

            Mem::Copy(paramBlock+sizeof(TAknsSrvEffectParameterDef), data, datasize-4);

            // Convert filenameid to offset and replace the id with offset

            Mem::Copy(paramBlock+sizeof(TAknsSrvEffectParameterDef)+datasize-4,&filenameoffset, sizeof(TInt));

            paramDef->iParameterType = ptype;

            paramDef->iParameterLength = AlignToFour(sizeof(TAknsSrvEffectParameterDef)+datasize);

            }

        else // string or int param or namedref (similar to int, used in animations)

            {

            paramBlock = new (ELeave) TUint8[sizeof(TAknsSrvEffectParameterDef)+datasize];

            CleanupStack::PushL( paramBlock );

            paramDef = (TAknsSrvEffectParameterDef*)paramBlock;

            paramDef->iParameterType = ptype;

            paramDef->iParameterLength = AlignToFour(sizeof(TAknsSrvEffectParameterDef)+datasize);

            Mem::Copy(paramBlock+sizeof(TAknsSrvEffectParameterDef), data, datasize);

            }

        totalparamsize += paramDef->iParameterLength;

        User::LeaveIfError( aParamArray.Append(paramBlock) );

        CleanupStack::Pop( paramBlock ); // paramBlock

        CleanupStack::PopAndDestroy( data ); // data

        aEqBase += totalparamlen;

        }

    return totalparamsize;

    }

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

// CAknsSrvChunkMaintainer::DoMergeParamGroupL

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

//

TUint32 CAknsSrvChunkMaintainer::DoMergeParamGroupsL(

    CAknsSrvFileBuffer& aFile, const TUint aOffset, TUint32& aBase,

    RPointerArray<TUint8>& aGroupArray, const TUint16 aGroupCount )

    {

    TUint32 totalGroupsSize = 0;

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

        {

        // Fetch param group header

        TUint32 valueA = AknsSrvUtils::GetInt32L( aFile, aOffset + aBase + EAknsSrvDFOAnimationParamGroupValueA );

        TUint32 valueB = AknsSrvUtils::GetInt32L( aFile, aOffset + aBase + EAknsSrvDFOAnimationParamGroupValueB );

        TUint16 pcount = AknsSrvUtils::GetUInt16L( aFile, aOffset + aBase + EAknsSrvDFOAnimationParamGroupParameterCount );

        if( pcount > KAknsSrvMaxEffectParamCount )

            {

            User::Leave(KErrCorrupt);

            }

        // Fetch parameters

        aBase = aBase + EAknsSrvDFOAnimationParamGroupParameters;

        CAknsSrvArrayStore* paramArray = new(ELeave) CAknsSrvArrayStore();

        CleanupStack::PushL( paramArray );

        TUint32 totalParamSize = DoMergeParamsL( aFile, aOffset, aBase, paramArray->iArray, pcount );

        // Construct group array block

        TUint8* block = new(ELeave) TUint8[sizeof(TAknsSrvParamGroupDef) + totalParamSize];

        CleanupStack::PushL( block );

        TAknsSrvParamGroupDef* def = (TAknsSrvParamGroupDef*)block;

        def->iValueA = valueA;

        def->iValueB = valueB;

        // Copy all parameters to the param group

        TUint32 base = sizeof(TAknsSrvParamGroupDef);

        for (TInt j = 0; j < pcount; j++)

            {

            TAknsSrvEffectParameterDef* paramDef = (TAknsSrvEffectParameterDef*)(paramArray->iArray[j]);

            TUint32 size = paramDef->iParameterLength;

            Mem::Copy(block + base, paramDef, size);

            base+=size;

            }

        def->iGroupSize      = base;

        def->iParameterCount = pcount;

        User::LeaveIfError( aGroupArray.Append(block) );

        CleanupStack::Pop( block );

        CleanupStack::PopAndDestroy( paramArray );

        totalGroupsSize+=base;

        aBase+=1; // GODDAMN END

        }

    return totalGroupsSize;

    }

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

// CAknsSrvChunkMaintainer::DoMergeEffectCommandL

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

//

TUint32 CAknsSrvChunkMaintainer::DoMergeEffectCommandsL(

    CAknsSrvFileBuffer& aFile, const TUint aOffset, TUint32& aBase,

    RPointerArray<TUint8>& aEffectArray, const TUint16 aEffectCount )

    {

    TUint32 totalSize = 0;

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

        {

        TInt32 effectuid = AknsSrvUtils::GetInt32L( aFile, aOffset+aBase + 8  );

        TUint8 inAindex = AknsSrvUtils::GetUInt8L( aFile, aOffset+ aBase+ 12);

        TUint8 inAmode = AknsSrvUtils::GetUInt8L( aFile, aOffset+ aBase+ 13);

        TUint8 inBindex = AknsSrvUtils::GetUInt8L( aFile, aOffset+ aBase+ 14);

        TUint8 inBmode = AknsSrvUtils::GetUInt8L( aFile, aOffset+ aBase+ 15);

        TUint8 outIndex = AknsSrvUtils::GetUInt8L( aFile, aOffset+ aBase+ 16);

        TUint8 outMode = AknsSrvUtils::GetUInt8L( aFile, aOffset+ aBase+ 17);

        // Check that at least some values are meaningful

        if (inAmode > 0x08 || inBmode > 0x08 || outMode > 0x08 )

            {

            User::Leave(KErrCorrupt);

            }

        TUint16 paramcount = AknsSrvUtils::GetUInt16L( aFile, aOffset+ aBase+ 18);

        if (paramcount > KAknsSrvMaxEffectParamCount)

            {

            User::Leave(KErrCorrupt);

            }

        aBase+=20;

        // process all parameters inside single effect

        CAknsSrvArrayStore* paramArray = new(ELeave) CAknsSrvArrayStore();

        CleanupStack::PushL( paramArray );

        TUint32 totalparamsize = DoMergeParamsL( aFile, aOffset, aBase, paramArray->iArray, paramcount );

        // All data collected

        TUint8* effectBlock= new (ELeave) TUint8[sizeof(TAknsSrvEffectDef)+totalparamsize];

        CleanupStack::PushL( effectBlock );

        TAknsSrvEffectDef* effectdef = (TAknsSrvEffectDef*)effectBlock;

        effectdef->iEffectUid.iUid       = effectuid;

        effectdef->iEffectParameterCount = paramcount;

        effectdef->iInputLayerAIndex     = inAindex;

        effectdef->iInputLayerAMode      = inAmode;

        effectdef->iInputLayerBIndex     = inBindex;

        effectdef->iInputLayerBMode      = inBmode;

        effectdef->iOutputLayerIndex     = outIndex;

        effectdef->iOutputLayerMode      = outMode;

        TUint32 base = sizeof(TAknsSrvEffectDef);

        TInt pcount;

        // copy all parameters to the effect

        for (pcount = 0; pcount < paramArray->iArray.Count(); pcount++)

            {

            TAknsSrvEffectParameterDef* paramDef = (TAknsSrvEffectParameterDef*)(paramArray->iArray[pcount]);

            TUint32 size = paramDef->iParameterLength;

            Mem::Copy(effectBlock+base, paramDef, size);

            base+=size;

            }

        effectdef->iEffectSize = base;

        User::LeaveIfError( aEffectArray.Append(effectBlock) );

        CleanupStack::Pop( effectBlock );

        CleanupStack::PopAndDestroy( paramArray );

        totalSize+=base;

        aBase+=1;// End of commands.

        }

    return totalSize;

    }

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

// CAknsSrvChunkMaintainer::DoMergeAnimationL

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

//

void CAknsSrvChunkMaintainer::DoMergeAnimationL(

    CAknsSrvFileBuffer& aFile, const TUint aOffset,

    const TAknsItemDefClass /*aClass*/,

    const TAknsSrvExclusionQuery& aExclQuery, const TBool /*aAhOverride*/ )

    {

    TAknsSrvDef itemDef;

    TUint32 size = 0;

    TUint32 totalSize = 0;

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

    // Step 1: Process animation header information

    // Fetch animation header

    TInt32 major = AknsSrvUtils::GetInt32L(aFile, aOffset+EAknsSrvDFOAnimationMajor);

    TInt32 minor = AknsSrvUtils::GetInt32L(aFile, aOffset+EAknsSrvDFOAnimationMinor);

    TUint8 type  = AknsSrvUtils::GetUInt8L(aFile, aOffset+EAknsSrvDFOAnimationType);

    // Reserved0 and Reserved1 skipped

    TUint8 inIndex = AknsSrvUtils::GetUInt8L(aFile, aOffset + EAknsSrvDFOAnimationInputLayerIndex);

    TUint8 inMode = AknsSrvUtils::GetUInt8L(aFile, aOffset + EAknsSrvDFOAnimationInputLayerMode);

    TUint8 outIndex = AknsSrvUtils::GetUInt8L(aFile, aOffset + EAknsSrvDFOAnimationOutputLayerIndex);

    TUint8 outMode = AknsSrvUtils::GetUInt8L(aFile, aOffset + EAknsSrvDFOAnimationOutputLayerMode);

    TInt32 minInterval = AknsSrvUtils::GetInt32L(aFile, aOffset+EAknsSrvDFOAnimationMinInterval);

    if( inMode > 0x08 || outMode > 0x08 )

        {

        User::Leave(KErrCorrupt);

        }

    itemDef.iID.Set(major,minor);

    if( aExclQuery.IsExcluded( itemDef.iID ) )

        {

        return;

        }

    CheckAndModifyIID( itemDef.iID, aExclQuery );

    itemDef.iType = EAknsITAnimation;

    // Morphing interval is MIN(all intervals)

    TBool isMorphing(EFalse);

    isMorphing = (TBool)type;

    if (isMorphing)

        {

        if (iMorphingMinInterval < 0)

            {

            if (minInterval > 0)

                {

                iMorphingMinInterval = minInterval;

                }

            }

        else if (iMorphingMinInterval > minInterval)

            {

            iMorphingMinInterval = minInterval;

            }

        }

    else // The definition is for highlight animation

        {

        // If product variant has disabled highlight animation we simply skip

        // non-morphing animation definitions.

        if( !aExclQuery.IsHighlightAnimEnabled() )

            {

            return;

            }

        }

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

    // Step 2: Process animation content

    // Because named reference is stored as parameter, effect commands and

    // animation commands can be processed with the same function. When parsing

    // animation data and creating animation definition ChunkLookup will

    // convert named reference parameters to named reference structures ->

    // named references as parameters are not visible to animation framework.

    CAknsSrvArrayStore* preprocessArray = new(ELeave) CAknsSrvArrayStore();

    CleanupStack::PushL( preprocessArray );

    CAknsSrvArrayStore* commandArray  = new(ELeave) CAknsSrvArrayStore();

    CleanupStack::PushL( commandArray );

    CAknsSrvArrayStore* valueArray = new(ELeave) CAknsSrvArrayStore();

    CleanupStack::PushL( valueArray );

    CAknsSrvArrayStore* timingArray = new(ELeave) CAknsSrvArrayStore();

    CleanupStack::PushL( timingArray );

    CAknsSrvArrayStore* sizeBoundArray = new(ELeave) CAknsSrvArrayStore();

    CleanupStack::PushL( sizeBoundArray );

    TUint16 preprocessCount = 0;

    TUint16 commandCount    = 0;

    TUint16 valueCount      = 0;

    TUint16 timingCount     = 0;

    TUint16 sizeBoundCount  = 0;

    // Process preprocess chunks

    preprocessCount = AknsSrvUtils::GetUInt16L( aFile, aOffset + EAknsSrvDFOAnimationPreprocessCount );

    if( preprocessCount > KAknsSrvMaxEffectCount )

        {

        User::Leave(KErrCorrupt);

        }

    TUint32 animBase = EAknsSrvDFOAnimationContentBegin; // Skip header data

    totalSize += DoMergeEffectCommandsL( aFile, aOffset, animBase, preprocessArray->iArray, preprocessCount );

    // Process animation command chunks

    commandCount = AknsSrvUtils::GetUInt16L( aFile, aOffset + animBase );

    if( commandCount > KAknsSrvMaxEffectCount )

        {

        User::Leave(KErrCorrupt);

        }

    animBase += sizeof(TUint16); // Skip commandCount

    totalSize += DoMergeEffectCommandsL( aFile, aOffset, animBase, commandArray->iArray, commandCount );

    // Animation values, timing models and size bound parameters are stored in

    // similar data structure -> process with the same function.

    // Process animation value chunks

    valueCount = AknsSrvUtils::GetUInt16L( aFile, aOffset + animBase );

    if( valueCount > KAknsSrvMaxParamGroupCount )

        {

        User::Leave(KErrCorrupt);

        }

    animBase += sizeof(TUint16); // Skip valueCount

    totalSize += DoMergeParamGroupsL( aFile, aOffset, animBase, valueArray->iArray, valueCount );

    // Process timing model chunks

    timingCount = AknsSrvUtils::GetUInt16L( aFile, aOffset + animBase );

    if( timingCount > KAknsSrvMaxParamGroupCount )

        {

        User::Leave(KErrCorrupt);

        }

    animBase += sizeof(TUint16); // Skip timingCount

    totalSize += DoMergeParamGroupsL( aFile, aOffset, animBase, timingArray->iArray, timingCount );

    // Process size bound parameter chunks

    sizeBoundCount = AknsSrvUtils::GetUInt16L( aFile, aOffset + animBase );

    if( sizeBoundCount > KAknsSrvMaxParamGroupCount )

        {

        User::Leave(KErrCorrupt);

        }

    animBase += sizeof(TUint16); // Skip sizeBoundCount

    totalSize += DoMergeParamGroupsL( aFile, aOffset, animBase, sizeBoundArray->iArray, sizeBoundCount );

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

    // Step 3: All items collected, add them to the animation

    TUint8* block = new(ELeave) TUint8[sizeof(TAknsSrvEffectAnimDef)+totalSize];

    // No leaves after this

    TAknsSrvEffectAnimDef* eqDef = (TAknsSrvEffectAnimDef*)block;

    eqDef->iPreprocessCount  = preprocessCount;

    eqDef->iAnimCommandCount = commandCount;

    eqDef->iAnimValueCount   = valueCount;

    eqDef->iTimingModelCount = timingCount;

    eqDef->iSizeBoundCount   = sizeBoundCount;

    eqDef->iInputLayerIndex  = inIndex;

    eqDef->iInputLayerMode   = inMode;

    eqDef->iOutputLayerIndex = outIndex;

    eqDef->iOutputLayerMode  = outMode;

    eqDef->iMinInterval      = minInterval;

    eqDef->iAnimType         = isMorphing;

    TUint32 base = sizeof(TAknsSrvEffectAnimDef);

    // Add preprocess commands

    TInt i;

    for (i = 0; i < preprocessCount; i++)

        {

        TAknsSrvEffectDef* def = (TAknsSrvEffectDef*)(preprocessArray->iArray[i]);

        size = def->iEffectSize;

        Mem::Copy( block + base, def, size);

        base += size;

        }

    // Add animation commands

    for (i = 0; i < commandCount; i++)

        {

        TAknsSrvEffectDef* def = (TAknsSrvEffectDef*)(commandArray->iArray[i]);

        size = def->iEffectSize;

        Mem::Copy( block + base, def, size);

        base += size;

        }

    // Add animation values

    for (i = 0; i < valueCount; i++)

        {

        TAknsSrvParamGroupDef* def = (TAknsSrvParamGroupDef*)(valueArray->iArray[i]);

        size = def->iGroupSize;

        Mem::Copy( block + base, def, size);