/*

* 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 "ProcTools.h"

#include "AudPanic.h"

#include "mime_io.h"

TBool ProcTools::Dec2Bin(TUint8 aDec, TBuf8<8>& aBinary) 

    {

    // clear aBinary just in case

    aBinary.Delete(0, aBinary.Length());

    aBinary.AppendNum(aDec, EBinary);

    TInt zerosNeeded = 0;

    if (aBinary.Length() == 8) 

        {

        // the MSB is one -> no padding needed

        }

    else 

        {

        zerosNeeded = 8 - aBinary.Length();

        for(TInt as = 0 ; as < zerosNeeded ; as++) 

            {

            aBinary.AppendNum(0);

            }

        for (TInt tr = 8 - 1 ; tr >= 0 ; tr--) 

            {

            if (tr >= zerosNeeded) 

                { 

                aBinary[tr] = aBinary[tr-zerosNeeded];

                }

            else 

                {

                aBinary[tr] = '0';

                }

            }

        }

    return ETrue;

    }

TBool ProcTools::Dec2BinL(TUint32 aDec, HBufC8*& aBin)

    {

    // 32 bits, the leftmost is one

    TUint32 bitMask = 0x80000000;

    TBool onlyZeros = ETrue;

    for (TInt a = 32 ; a > 0 ; a--)

        {

        TUint32 res = bitMask & aDec;

        if (res > 0 && onlyZeros)

            {

            // the first one from left found

            onlyZeros = EFalse;

            aBin = HBufC8::NewL(a);

            aBin->Des().Append('1');

            }

        else if (res > 0 && !onlyZeros)

            {

            aBin->Des().Append('1');

            }

        else if (res == 0 && !onlyZeros)

            {    

            aBin->Des().Append('0');

            }

        bitMask >>= 1;

        }

    return ETrue;

    }

TBool ProcTools::Bin2Dec(const TDesC8& aBin, TUint& aDec) 

    {

    TLex8 leks(aBin);

    if (leks.Val(aDec, EBinary) != KErrNone) 

        {

        return EFalse;

        }

    return ETrue;

    }

TBool ProcTools::Des2Dec(TDesC8& aDes, TUint& aDec) 

    {

    TLex8 leks(aDes);

    if (leks.Val(aDec, EDecimal) != KErrNone) 

        {

        return EFalse;

        }

    return ETrue;

    }

TBool ProcTools::Des2BinL(const TDesC8& aDes, HBufC8*& aBin) 

    {

    aBin = HBufC8::NewL(aDes.Length()*8);

    // clear aBinary just in case

    for (TInt a = 0 ; a < aDes.Length() ; a++) 

        {

        TUint8 chDec = aDes[a];

        aBin->Des().AppendNum(chDec, EBinary);

        TInt zerosNeeded = 0;

        if (aBin->Des().Length() == (a+1)*8) 

            {

            // the MSB is one -> no padding needed

            }

        else 

            {

            zerosNeeded = (a+1)*8 - aBin->Des().Length();

            for(TInt as = 0 ; as < zerosNeeded ; as++) 

                {

                aBin->Des().Insert(a*8, _L8("0"));

                //AppendNum(0);

                }

            }

        }

    return ETrue;

    }

TInt ProcTools::MilliSeconds(TTimeIntervalMicroSeconds aMicroSeconds)

    {

#ifndef EKA2

    return (aMicroSeconds.Int64()/1000).GetTInt();

#else

    return (aMicroSeconds.Int64()/1000);

#endif

    }

TTimeIntervalMicroSeconds ProcTools::MicroSeconds(TInt aMilliSeconds)

    {

    TTimeIntervalMicroSeconds mic(aMilliSeconds*1000);

    return mic;

    }

TInt ProcTools::GetTInt(TInt64 aTInt64)

    {

#ifndef EKA2

    return aTInt64.GetTInt();

#else        

    return aTInt64;

#endif

    }

TInt ProcTools::GetValueFromShuffledFrame(const HBufC8* aFrame, 

                                          const TUint8 aBitPositions[], 

                                          const TInt aSize) 

    {

    HBufC8* inBytes = 0;

    TRAPD(err, inBytes = HBufC8::NewL(aSize));

    if (err != KErrNone)

        {

        inBytes = 0;

        return -1;

        }

    _LIT8(KZero, "0");

    _LIT8(KOne, "1");

    for (TInt a = 0 ; a < aSize ; a++) 

        {

        TUint8 mask = 0x80; // 1000 0000b

        TUint byteNumber = aBitPositions[a]/8;

        TUint bitNumber = aBitPositions[a]%8;

        const TUint8 byteNow = (*aFrame)[byteNumber];

        mask >>= bitNumber;

        //TUint8 masked = byteNow & mask;

        // why casting is needed, dunno?

        TUint8 masked = static_cast<TUint8>(byteNow & mask);

        if (masked == 0) 

            {

            inBytes->Des().Append(KZero);

            }

        else 

            {

            inBytes->Des().Append(KOne);

            }

        }

    TUint dec = 0;

    Bin2Dec(inBytes->Des(), dec);

    delete inBytes;

    inBytes = 0;

    return dec;

    }

TInt ProcTools::GetValueFromShuffledAWBFrameL(const HBufC8* aFrame, TInt aBitRate, TInt aBitPosition, TInt aLength)

    {

    HBufC8* inBytes = HBufC8::NewLC(aLength);

    _LIT8(KZero, "0");

    _LIT8(KOne, "1");

    const TInt* table = 0;

    TInt tableSize = 0;

    switch(aBitRate)

        {

        case(23850):

            {

            table = sort_2385;

            tableSize = 477;

            break;

            }

        case(23050):

            {

            table = sort_2305;

            tableSize = 461;

            break;

            }

        case(19850):

            {

            table = sort_1985;

            tableSize = 397;

            break;

            }

        case(18250):

            {

            table = sort_1825;

            tableSize = 365;

            break;

            }

        case(15850):

            {

            table = sort_1585;

            tableSize = 317;

            break;

            }

        case(14250):

            {

            table = sort_1425;

            tableSize = 285;

            break;

            }

        case(12650):

            {

            table = sort_1265;

            tableSize = 253;

            break;

            }

        case(8850):

            {

            table = sort_885;

            tableSize = 177;

            break;

            }

        case(6600):

            {

            table = sort_660;

            tableSize = 132;

            break;

            }

        default:

            {

            // illegal bitrate

            CleanupStack::PopAndDestroy(inBytes);

            return -1;

            }

        }

    for (TInt a = 0 ; a < aLength ; a++) 

        {

        TInt bitIndex = FindIndex(aBitPosition+a, table, tableSize)+8;

        TUint8 mask = 0x80; // 1000 0000b

        TUint byteNumber = bitIndex/8;

        TUint bitNumber = bitIndex%8;

        const TUint8 byteNow = (*aFrame)[byteNumber];

        mask >>= bitNumber;

        //TUint8 masked = byteNow & mask;

        // why casting is needed, dunno?

        TUint8 masked = static_cast<TUint8>(byteNow & mask);

        if (masked == 0) 

            {

            inBytes->Des().Append(KZero);

            }

        else 

            {

            inBytes->Des().Append(KOne);

            }

        }

    TUint dec = 0;

    Bin2Dec(inBytes->Des(), dec);

    CleanupStack::PopAndDestroy(inBytes);

    inBytes = 0;

    return dec;

    }

TBool ProcTools::SetValueToShuffledAWBFrame(TUint8 aNewValue, HBufC8* aFrame, 

                                            TInt aBitRate, TInt aBitPosition, TInt aLength)

    {

    const TInt* table = 0;

    TInt tableSize = 0;

    switch(aBitRate)

        {

        case(23850):

            {

            table = sort_2385;

            tableSize = 477;

            break;

            }

        case(23050):

            {

            table = sort_2305;

            tableSize = 461;

            break;

            }

        case(19850):

            {

            table = sort_1985;

            tableSize = 397;

            break;

            }

        case(18250):

            {

            table = sort_1825;

            tableSize = 365;

            break;

            }

        case(15850):

            {

            table = sort_1585;

            tableSize = 317;

            break;

            }

        case(14250):

            {

            table = sort_1425;

            tableSize = 285;

            break;

            }

        case(12650):

            {

            table = sort_1265;

            tableSize = 253;

            break;

            }

        case(8850):

            {

            table = sort_885;

            tableSize = 177;

            break;

            }

        case(6600):

            {

            table = sort_660;

            tableSize = 132;

            break;

            }

        default:

            {

            // illegal bitrate

            return -1;

            }

        }

    _LIT8(KZero, "0");

    TBuf8<8> newValueBin;

    Dec2Bin(aNewValue, newValueBin);

    // remove leading zeros

    newValueBin.Delete(0, 8-aLength);

    TPtr8 framePtr(aFrame->Des());

    for (TInt a = 0 ; a < newValueBin.Size() ; a++) 

        {

        TInt bitIndex = FindIndex(aBitPosition+a, table, tableSize)+8;

        TUint8 bitPositionInByte = static_cast<TUint8>(bitIndex%8);

        TUint byteNumber = bitIndex/8;

        if (newValueBin.Mid(a,1).Compare(KZero) == 0) 

            {

            TUint8 mask = 0x80; // 0111 1111b

            mask >>= bitPositionInByte;

            mask = static_cast<TUint8>(~mask);

            //--->

//            TUint8 oldByte = framePtr[byteNumber];

    //        TUint8 newByte = oldByte & mask;

            //<--

            framePtr[byteNumber] = static_cast<TUint8>(framePtr[byteNumber] & mask);  

            }

        else 

            {

            TUint8 mask = 0x80; // 1000 0000b

            mask >>= bitPositionInByte;

            //--->

//            TUint8 oldByte = framePtr[byteNumber];

//            TUint8 newByte = oldByte & mask;

            //<--

            framePtr[byteNumber] = static_cast<TUint8>(framePtr[byteNumber] | mask);

            }

        }

    return EFalse;

    }

TBool ProcTools::SetValueToShuffledFrame(HBufC8* aFrame, TUint8 aNewValue, 

                                         const TUint8 aBitPositions[], 

                                         TInt aSize) 

    {

    _LIT8(KZero, "0");

    TBuf8<8> newValueBin;

    Dec2Bin(aNewValue, newValueBin);

    newValueBin.Delete(0, 8-aSize);

    TPtr8 framePtr(aFrame->Des());

    for (TInt a = 0 ; a < aSize ; a++) 

        {

        TUint8 bitPosition = static_cast<TUint8>(aBitPositions[a]%8);

        TUint byteNumber = aBitPositions[a]/8;

        if (newValueBin.Mid(a,1).Compare(KZero) == 0) 

            {

            TUint8 mask = 0x80; // 0111 1111b

            mask >>= bitPosition;

            mask = static_cast<TUint8>(~mask);

            //--->

//            TUint8 oldByte = framePtr[byteNumber];

    //        TUint8 newByte = oldByte & mask;

            //<--

            framePtr[byteNumber] = static_cast<TUint8>(framePtr[byteNumber] & mask);