/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "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:

* Ixonos Plc

*

* Description:  

*

*/

#include "ProcAMRFrameHandler.h"

#include "ProcFrameHandler.h"

#include "ProcTools.h"

#include <e32math.h>

TBool CProcAMRFrameHandler::ManipulateGainL(const HBufC8* aFrameIn, HBufC8*& aFrameOut, TInt8 aGain) 

{

    aFrameOut = HBufC8::NewLC(aFrameIn->Size());

    if (aFrameIn->Size() == 1) // noData element

        {

        aFrameOut->Des().Append(aFrameIn[0]);

        CleanupStack::Pop(); // aFrameOut

        return ETrue;

        }

    aGain = static_cast<TInt8>(aGain/2);

    TInt posNow = 0;

    TInt nextFrameLength = 1;

    while (nextFrameLength > 0)

        {

        nextFrameLength = GetNextFrameLength(aFrameIn, posNow);

        if (nextFrameLength < 1) break;

        if (nextFrameLength + posNow > aFrameIn->Size())

            {

            // something wrong with the frame, return the original

            aFrameOut->Des().Append(aFrameIn[0]);

            CleanupStack::Pop(); // aFrameOut

            return ETrue;

            }

        HBufC8* tmpFrame = HBufC8::NewLC(nextFrameLength);

        tmpFrame->Des().Copy(aFrameIn->Mid(posNow, nextFrameLength));

        posNow += nextFrameLength;

        const TUint8 ch = (*tmpFrame)[0];

        TUint dec_mode = (enum Mode)((ch & 0x0078) >> 3);

        TInt maxGain;

        RArray<TInt> gains;

        GetAMRGains(tmpFrame, gains, maxGain);

        TInt gamma10000 = KAmrGain_dB2Gamma[aGain+127];

        TInt a = 0;

        TInt old_gain, old_gain1 = 0;

        TInt old_pitch, old_pitch1 = 0;

        TInt new_gain, new_gain1 = 0;

        TInt8 new_index = 0;

        switch (dec_mode){

        case 0:

            for (a = 0; a < gains.Count()-1 ; a+=4) 

            {

                old_gain = gains[a+1];

                new_gain = static_cast<TInt>((gamma10000*old_gain)/10000);

                old_pitch = gains[a];

                old_gain1 = gains[a+3];

                new_gain1 = static_cast<TInt>((gamma10000*old_gain1)/10000);

                old_pitch1 = gains[a+2];

                new_index = ProcTools::FindNewIndex475VQ(new_gain, 

                    old_pitch, 

                    new_gain1, 

                    old_pitch1);

                if (a == 0) 

                {

                    ProcTools::SetValueToShuffledFrame(tmpFrame, 

                        new_index, 

                        KAmrGains475_1_2, 

                        8);

                }

                else if(a == 4) 

                {

                    ProcTools::SetValueToShuffledFrame(tmpFrame, 

                        new_index, 

                        KAmrGains475_3_4, 

                        8);

                }

            }

            break;

        case 1:

            for (a = 0; a < gains.Count()-1 ; a+=2) 

            {

                old_gain = gains[a+1];

                new_gain = static_cast<TInt>((gamma10000*old_gain)/10000);

                old_pitch = gains[a];

                new_index = ProcTools::FindNewIndexVQ(new_gain, old_pitch, KAmrGainTable590, 128);

                if (a == 0) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains515_1, 6);

                else if (a == 2) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains515_2, 6);

                else if (a == 4) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains515_3, 6);

                else if (a == 6) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains515_4, 6);

            }

            break;

        case 2:

            for (a = 0; a < gains.Count()-1 ; a+=2) 

            {

                old_gain = gains[a+1];

                new_gain = static_cast<TInt>((gamma10000*old_gain)/10000);

                old_pitch = gains[a];

                new_index = ProcTools::FindNewIndexVQ(new_gain, old_pitch, KAmrGainTable590, 128);

                if (a == 0) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains590_1, 6);

                else if (a == 2) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains590_2, 6);

                else if (a == 4) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains590_3, 6);

                else if (a == 6) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains590_4, 6);

            }

            break;

        case 3:

            for (a = 0; a < gains.Count()-1 ; a+=2) 

            {

                old_gain = gains[a+1];

                new_gain = static_cast<TInt>((gamma10000*old_gain)/10000);

                old_pitch = gains[a];

                new_index = ProcTools::FindNewIndexVQ(new_gain, old_pitch, KAmrGainTable102, 256);

                if (a == 0) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains670_1, 7);

                else if (a == 2) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains670_2, 7);

                else if (a == 4) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains670_3, 7);

                else if (a == 6) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains670_4, 7);

            }

            break;

        case 4:

            for (a = 0; a < gains.Count()-1 ; a+=2) 

            {

                old_gain = gains[a+1];

                new_gain = static_cast<TInt>((gamma10000*old_gain)/10000);

                old_pitch = gains[a];

                new_index = ProcTools::FindNewIndexVQ(new_gain, old_pitch, KAmrGainTable102, 256);

                if (a == 0) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains740_1, 7);

                else if (a == 2) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains740_2, 7);

                else if (a == 4) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains740_3, 7);

                else if (a == 6) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains740_4, 7);

            }

            break;

        case 5:

            for (a = 0; a < gains.Count() ; a++) 

            {

                old_gain = gains[a];

                new_gain = static_cast<TInt>((gamma10000*old_gain)/10000);

                new_index = ProcTools::FindNewIndexSQ(new_gain, KAmrGainTable122, 32);

                if (a == 0) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains795_1, 5);

                else if (a == 1) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains795_2, 5);

                else if (a == 2) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains795_3, 5);

                else if (a == 3) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains795_4, 5);

            }

            break;

        case 6:

            for (a = 0; a < gains.Count()-1 ; a+=2) 

            {

                old_gain = gains[a+1];

                new_gain = static_cast<TInt>((gamma10000*old_gain)/10000);

                old_pitch = gains[a];

                new_index = ProcTools::FindNewIndexVQ(new_gain, old_pitch, KAmrGainTable102, 256);

                if (a == 0) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains102_1, 7);

                else if (a == 2) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains102_2, 7);

                else if (a == 4) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains102_3, 7);

                else if (a == 6) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains102_4, 7);

            }

            break;

        case 7:

            for (a = 0; a < gains.Count() ; a++) 

            {

                old_gain = gains[a];

                new_gain = static_cast<TInt>((gamma10000*old_gain)/10000);

                new_index = ProcTools::FindNewIndexSQ(new_gain, KAmrGainTable122, 32);

                if (a == 0) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains122_1, 5);

                else if (a == 1) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains122_2, 5);

                else if (a == 2) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains122_3, 5);

                else if (a == 3) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains122_4, 5);

            }

            break;

        case 8:

            break;

        case 15:

            break;

        default:

            break;

            };

        gains.Reset();

        aFrameOut->Des().Append(tmpFrame->Des());

        CleanupStack::PopAndDestroy(tmpFrame);

        }

    CleanupStack::Pop(); // aFrameOut

    return ETrue;

    }

TBool CProcAMRFrameHandler::GetGainL(const HBufC8* aFrame, RArray<TInt>& aGains, TInt& aMaxGain) const

    {

    TBool vectorQuant = EFalse;

	const TUint8 ch = (*aFrame)[0];

	TUint dec_mode = (enum Mode)((ch & 0x0078) >> 3);

	TBool mode475 = EFalse;

	switch (dec_mode)

		{

		case 0:

			mode475 = ETrue;

			vectorQuant = ETrue;

			break;

		case 1:

		case 2:

		case 3:

		case 4:

		case 6:

			vectorQuant = ETrue;

			break;

		default:

			break;

		};

	RArray<TInt> amrGains;

	RArray<TInt> gpGains;

	TInt maxGain = 0;

	TReal b[4] = {0.68, 0.58, 0.34, 0.19};

	if (aFrame->Size() < 10)

		{

		// SID or no data

		for (TInt r = 0; r < 4 ; r++)

			{

			iPreviousRn[r] = 0;

			iPreviousEnergy = 0;

			}

		aGains.Append(0);

		aMaxGain = 1;

        return ETrue;

		}

	GetAMRGains(aFrame, amrGains, maxGain);

	GetGPGains(aFrame, gpGains);

	TInt gains = 4;

	if (mode475)

		{

		gains = 2;

		}

	for (TInt subFrame = 0 ; subFrame < gains ; subFrame++)

		{

		// calculate gc (fixed codebook gain) ------------------------->

		TReal currentGamma = 0;

		if (vectorQuant)

			{

			currentGamma = (TReal)(amrGains[subFrame*2+1])/4096.0; // Q12, 2^12 = 4096

			}

		else

			{

			currentGamma = (TReal)(amrGains[subFrame])/4096.0; 

			}

		TReal E = iPreviousRn[3]*b[0]+iPreviousRn[2]*b[1]+iPreviousRn[1]*b[2]+iPreviousRn[0]*b[3];

		TReal logGamma = 0;

		Math::Log(logGamma, currentGamma);

		TReal R = 20 * logGamma;

		TReal gcPred = 0; //g'c

		Math::Pow10(gcPred, 0.05*E);

		TReal gc = gcPred*currentGamma;

		// update previous R(n) values --------->

		for (TInt re = 0; re < 3 ; re++)

			{

			iPreviousRn[re] = iPreviousRn[re+1];

			}

		iPreviousRn[3] = R;

		// <---------- update ends

		// <---------- gc calculated

		// calculate energy from adaptive codebook ------------->

		TReal currentGp = 0;

		if (vectorQuant)

			{

			currentGp = (TReal)(amrGains[subFrame*2])/16384.0; // Q14 = 2^14 = 16384

			}

		else

			{

			currentGp = (TReal)(gpGains[subFrame])/16384.0; // Q14, 2^13 = 8192

			}

		TReal energyFromAdaptiveCB = (iPreviousEnergy*currentGp)/2;

		// <----------------------- energy from adaptive codebook calculated

		TReal totalEnergy = energyFromAdaptiveCB+(gc*45);

		iPreviousEnergy = totalEnergy;

		TReal logTotalEnergy = 0;

		if (totalEnergy < 1) totalEnergy = 1;

		Math::Log(logTotalEnergy, totalEnergy);

		if (logTotalEnergy > 3.5) 

		    {

		    logTotalEnergy = 3.5;

		    }

		aGains.Append(logTotalEnergy*100);

        const TInt KMaxGain = 350;

        aMaxGain = KMaxGain;

		}

	amrGains.Reset();	

	gpGains.Reset();

	return ETrue;

    }

TBool CProcAMRFrameHandler::GetNormalizingMargin(const HBufC8* aFrame, TInt8& aMargin) const

    {

    const TUint8 ch = (*aFrame)[0];

    TUint dec_mode = (enum Mode)((ch & 0x0078) >> 3);

    RArray<TInt> gains;

    TInt error = KErrNone;

    TRAP(error, CleanupClosePushL(gains) );

    if (error != KErrNone)

        return EFalse;

    TInt gamma10000 = 1;

    TInt largestGain = 1;

    TInt a = 0;

    TInt maxGain;

        switch (dec_mode)

        {

        case 0:

            GetAMRGains(aFrame, gains, maxGain);

            for (a = 1 ; a < gains.Count() ; a+=2)

                {

                if (gains[a] > largestGain) 

                    {

                    largestGain = gains[a];

                    }

                }

            gamma10000 = (KAmrLargestGain475*10000)/largestGain;

            break;

        case 1:

        case 2:

            // bitrates 515, 590

            GetAMRGains(aFrame, gains, maxGain);

            for (a = 1 ; a < gains.Count() ; a+=2)

                {

                if (gains[a] > largestGain) 

                    {

                    largestGain = gains[a];

                    }

                }

            gamma10000 = (KAmrLargestGain590*10000)/largestGain;

            break;

        case 3:

        case 4:

        case 6:

            // bitRate = 670, 740, 1020;

            GetAMRGains(aFrame, gains, maxGain);

            for (a = 1 ; a < gains.Count() ; a+=2)

                {

                if (gains[a] > largestGain) 

                    {

                    largestGain = gains[a];

                    }

                }

            gamma10000 = (KAmrLargestGain102*10000)/largestGain;

            break;

        case 5:

        case 7:

            //bitRate = 795 & 12.2

            GetAMRGains(aFrame, gains, maxGain);

            for (a = 0 ; a < gains.Count() ; a++)

                {

                if (gains[a] > largestGain) 

                    {

                    largestGain = gains[a];

                    }

                }

            gamma10000 = (KAmrLargestGain122*10000)/largestGain;

            break;

        case 8:

        case 15:

        default:

            aMargin = 100;

            return ETrue;

        };

    CleanupStack::PopAndDestroy(&gains);

    TUint8 newIndex = ProcTools::FindNewIndexSQ(gamma10000, KAmrGain_dB2Gamma, 256);

    TInt8 newGain = static_cast<TInt8>(newIndex-127);