diff -r 000000000000 -r 951a5db380a0 videoeditorengine/audioeditorengine/src/ProcTools.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/videoeditorengine/audioeditorengine/src/ProcTools.cpp	Fri Jan 29 14:08:33 2010 +0200
@@ -0,0 +1,1043 @@
+/*
+* 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);  
+    
+            }
+        else 
+            {
+
+            TUint8 mask = 0x80; // 1000 0000b
+            mask >>= bitPosition;
+            
+            //--->
+//            TUint8 oldByte = framePtr[byteNumber];
+//            TUint8 newByte = oldByte & mask;
+            //<--
+            framePtr[byteNumber] = static_cast<TUint8>(framePtr[byteNumber] | mask);
+
+            }
+
+
+        
+        }
+    
+    return ETrue;
+
+    }
+
+
+
+TBool ProcTools::WriteValuesToFileL(const RArray<TInt>& aArray, const TDesC& aFilename) 
+    {
+
+    RFs fs;
+    User::LeaveIfError(fs.Connect());
+
+    RFile file;
+    TInt err=file.Open(fs, aFilename, EFileWrite);
+    
+    if (err==KErrNotFound) 
+        {
+        err=file.Create(fs, aFilename, EFileWrite);
+        }
+    TInt nolla = 0;
+    file.Seek(ESeekEnd, nolla);
+    for (TInt a = 0; a < aArray.Count() ; a++) 
+        {
+        TBuf8<8> num;
+        num.AppendNum(aArray[a]);
+        file.Write(num);
+        file.Write(_L8("\n"));
+
+
+        }
+
+    file.Close();
+    fs.Close();
+
+    return ETrue;
+    }
+
+
+TUint8 ProcTools::FindNewIndexSQ(TInt aNewGain, const TInt aGainTable[], TInt aTableSize) 
+    {
+
+    if (aTableSize > 256)
+        {
+        TAudPanic::Panic(TAudPanic::EInternal);
+        }
+
+    TUint8 tableSize = static_cast<TUint8>(aTableSize-1);
+
+    TInt minimum = 0xFFFF;
+    TUint8 indexFound = 0;
+
+    for (TUint a = 0 ; a <= tableSize ; a++) 
+        {
+            
+        if (Abs(aGainTable[a]-aNewGain) < minimum) 
+            {
+            minimum = Abs(aGainTable[a]-aNewGain);
+            indexFound = static_cast<TUint8>(a);
+            }
+        }
+
+    return indexFound;
+
+    }
+
+TUint8 ProcTools::FindNewIndexVQ(TInt aNewGain, TInt aOldPitch, const TInt aGainTable[], TInt aTableSize) 
+    {
+
+    if (aTableSize > 256)
+        {
+        TAudPanic::Panic(TAudPanic::EInternal);
+        }
+
+    TUint8 tableSize = static_cast<TUint8>(aTableSize-1);
+
+
+
+    TInt minimum = KMaxTInt;
+    TUint8 indexFound = 0;
+
+    for (TUint a = 0 ; a <= tableSize ; a+=2) 
+        {
+
+        // gpitch: Q14 , 2^14 = 16384
+        TInt distance_pitch = (100*(Abs(aGainTable[a]-aOldPitch)))/16384;
+
+        // g_fac: Q12 , 2^12 = 4096
+        TInt distance_fc = (100*Abs(aGainTable[a+1]-aNewGain))/4096;
+        
+
+        TInt distance = distance_pitch*distance_pitch + distance_fc*distance_fc;
+        
+        if (distance < minimum) 
+            {
+            minimum = distance;
+            indexFound = static_cast<TUint8>(a);
+            }
+        }
+
+    return static_cast<TUint8>(indexFound/2);
+
+    }
+
+TUint8 ProcTools::FindNewIndexVQ2(TInt aNewGain, TInt aOldPitch, const TInt aGainTable[], TInt aTableSize)
+    {
+
+    if (aTableSize > 256)
+        {
+        TAudPanic::Panic(TAudPanic::EInternal);
+        }
+
+    TUint8 tableSize = static_cast<TUint8>(aTableSize-1);
+
+    TInt minimum = KMaxTInt;
+    TUint8 indexFound = 0;
+
+    for (TUint a = 0 ; a <= tableSize ; a+=2) 
+        {
+
+        // gpitch: Q14 , 2^14 = 16384
+        TInt distance_pitch = (100*(Abs(aGainTable[a]-aOldPitch)))/16384;
+
+        // g_fac: Q11 , 2^11 = 2048
+        TInt distance_fc = (100*Abs(aGainTable[a+1]-aNewGain))/2048;
+        
+
+        TInt distance = distance_pitch*distance_pitch + distance_fc*distance_fc;
+        
+        if (distance < minimum) 
+            {
+            minimum = distance;
+            indexFound = static_cast<TUint8>(a);
+            }
+        }
+
+    return static_cast<TUint8>(indexFound/2);
+
+    
+
+
+    }
+
+
+TUint8 ProcTools::FindNewIndex475VQ(TInt aNewGain0, TInt aOldPitch0, TInt aNewGain1, TInt aOldPitch1)
+    {
+
+    TInt minimum = KMaxTInt;
+    TInt indexFound = -1;
+
+    TInt tableSize = 256*4;
+
+
+    for (TInt a = 0 ; a < tableSize-3 ; a+=4) 
+        {
+
+        // gpitch: Q14 , 2^14 = 16384
+        TInt distance_pitch0 = (100*(Abs(KAmrGainTable475[a]-aOldPitch0)))/16384;
+        TInt distance_pitch1 = (100*(Abs(KAmrGainTable475[a+2]-aOldPitch1)))/16384;
+
+        // g_fac: Q12 , 2^12 = 4096
+        TInt distance_fc0 = (100*Abs(KAmrGainTable475[a+1]-aNewGain0))/4096;
+        TInt distance_fc1 = (100*Abs(KAmrGainTable475[a+3]-aNewGain1))/4096;        
+
+        TInt distance = distance_pitch0*distance_pitch0 + distance_fc0*distance_fc0 +
+                        distance_pitch1*distance_pitch1 + distance_fc1*distance_fc1;
+        
+        if (distance < minimum) 
+            {
+            minimum = distance;
+            indexFound = a;
+            }
+        }
+
+    return static_cast<TUint8>(indexFound/4);
+
+    }
+
+TInt ProcTools::FindIndex(TInt aKey, const TInt aBitPositions[], TInt aTableLength)
+    {
+    
+    for (TInt a = 0 ; a < aTableLength ; a++)
+        {
+        if (aBitPositions[a] == aKey) return a;
+        }
+
+    return -1;
+
+    }
+
+TBool ProcTools::GenerateADTSHeaderL(TBuf8<7>& aHeader, TInt aFrameLength, TAudFileProperties aProperties)
+    {
+    TUint8 byte1 = 0xFF;
+
+    TUint8 byte2 = 0x0;
+    if (aProperties.iAudioType == EAudAAC_MPEG2)
+        {
+        byte2 = 0xF9;
+        }
+    else if (aProperties.iAudioType == EAudAAC_MPEG4)
+        {
+        byte2 = 0xF1;
+        }
+    else return EFalse;
+    TBuf8<8> byte3b(8);
+    TBuf8<8> byte4b(8);
+    TBuf8<8> byte5b(8);
+    TBuf8<8> byte6b(8);
+    TBuf8<8> byte7b(8);
+
+    byte3b.Fill('0');
+    byte4b.Fill('0');
+    byte5b.Fill('0');
+    byte6b.Fill('0');
+    byte7b.Fill('0');
+
+    
+    const TInt KAAC_SAMPLING_RATES[16] = {96000,88200,64000,48000,44100,32000,24000,
+                                            22050,16000,12000,11025,8000,0,0,0,0};
+    
+    TBool srFound = EFalse;
+    TUint8 srIndex = 0; 
+    for (srIndex = 0 ; srIndex < 14 ; srIndex++)
+        {
+        if (KAAC_SAMPLING_RATES[srIndex] == aProperties.iSamplingRate) 
+            {
+            srFound = ETrue;
+            break;
+            }
+        }
+
+    if (srFound)
+        {
+        TBuf8<8> srB;
+        ProcTools::Dec2Bin(srIndex, srB);
+    
+        // Sampling rate
+        byte3b[2] = srB[4];
+        byte3b[3] = srB[5];
+        byte3b[4] = srB[6];
+        byte3b[5] = srB[7];
+
+        }
+
+    
+
+    // private bit
+    byte3b[6] = '0';
+
+    // channel configuration
+    byte3b[7] = '0';
+    if (aProperties.iChannelMode == EAudStereo)
+        {
+        byte4b[0] = '1';
+        byte4b[1] = '0';
+
+        }
+    else if(aProperties.iChannelMode == EAudSingleChannel)
+        {
+        byte4b[0] = '0';
+        byte4b[1] = '1';
+
+        }
+    else
+        {
+        return EFalse;
+        }
+
+    //original/copy & home
+    byte4b[2] = '0';
+    byte4b[3] = '0';
+    // copyright identification & start
+    byte4b[4] = '0';
+    byte4b[5] = '0';
+
+    HBufC8* lenBin = 0;
+    if (ProcTools::Dec2BinL(aFrameLength+7, lenBin))
+        {
+
+        TInt fromRight = 0;
+        for(TInt i = lenBin->Size()-1 ; i >= 0 ; i--)
+            {
+            if (fromRight < 3)
+                {
+                // byte7
+                byte6b[2-fromRight] = lenBin->Des()[i];    
+                }
+            else if (fromRight < 11)
+                {
+                // byte6
+                byte5b[10-fromRight] = lenBin->Des()[i];
+
+                }
+            else if (fromRight < 13)
+                {
+                // byte5
+                byte4b[18-fromRight] = lenBin->Des()[i];
+                }
+
+            fromRight++;
+            }
+
+        delete lenBin;
+        }
+    
+    TInt bitInd = 0; 
+    for (bitInd = 3 ; bitInd < 8 ; bitInd++)
+    {
+        byte6b[bitInd] = '1';
+    }
+    for (bitInd = 0 ; bitInd < 6 ; bitInd++)
+    {
+        byte7b[bitInd] = '1';
+    }
+    
+    
+    aHeader.Append(byte1);
+    aHeader.Append(byte2);
+
+    TUint tmpByte = 0;
+    ProcTools::Bin2Dec(byte3b, tmpByte);
+    
+    // profile
+    TUint8 bitMask = aProperties.iAACObjectType;
+    bitMask <<= 6;
+    tmpByte = tmpByte | bitMask;
+
+    aHeader.Append(static_cast<TUint8>(tmpByte));
+
+    ProcTools::Bin2Dec(byte4b, tmpByte);
+    aHeader.Append(static_cast<TUint8>(tmpByte));
+
+    ProcTools::Bin2Dec(byte5b, tmpByte);
+    aHeader.Append(static_cast<TUint8>(tmpByte));
+
+    ProcTools::Bin2Dec(byte6b, tmpByte);
+    aHeader.Append(static_cast<TUint8>(tmpByte));
+
+    ProcTools::Bin2Dec(byte7b, tmpByte);
+    aHeader.Append(static_cast<TUint8>(tmpByte));
+
+    return ETrue;
+
+    }
+
+TInt ProcTools::GetNextAMRFrameLength(const HBufC8* aFrame, TInt aPosNow)
+    {
+
+
+    if (aPosNow >= aFrame->Size()) return -1;
+
+
+    const TUint8 ch = (*aFrame)[aPosNow];
+
+    TUint dec_mode = (enum Mode)((ch & 0x0078) >> 3);
+    
+    switch (dec_mode)
+        {
+        case 0:
+            {
+            return 12+1;
+            }
+            
+        case 1:
+            {
+            return 13+1;
+            }
+            
+        case 2:
+            {
+            return 15+1;
+            }
+            
+        case 3:
+            {
+            return 17+1;
+            }
+            
+        case 4:
+            {
+            return 19+1;
+            }
+            
+        case 5:
+            {
+            return 20+1;
+            }
+            
+        case 6:
+            {
+            return 26+1;
+            }
+            
+        case 7:
+            {
+            return 31+1;
+            }
+            
+        case 8:
+            {
+            return 5+1;
+            }
+            
+        case 15:
+            {
+            return 0+1;
+            }
+            
+        default:
+            return 0+1;
+            
+        };
+    
+
+    }
+
+
+CProcessingEvent* CProcessingEvent::NewL()
+    {
+    CProcessingEvent* self = new (ELeave) CProcessingEvent();
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CleanupStack::Pop(self);
+    return self;
+
+    }
+
+void CProcessingEvent::ConstructL()
+    {
+    }
+
+CProcessingEvent::~CProcessingEvent()
+    {
+    iAllIndexes.Close();
+    }
+
+
+CProcessingEvent::CProcessingEvent()
+    {
+    }
+
+void CProcessingEvent::InsertIndex(TInt aIndex)
+        {
+        iAllIndexes.Append(aIndex);
+        }
+
+TInt CProcessingEvent::GetIndex(TInt aProcessingEventIndex)
+    {
+    return iAllIndexes[aProcessingEventIndex];
+    }
+
+TBool CProcessingEvent::GetAllIndexes(RArray<TInt>& aAllIndexes)
+    {
+    for (TInt a = 0 ; a < iAllIndexes.Count() ; a++)
+        {
+        aAllIndexes.Append(iAllIndexes[a]);
+
+        }
+    return ETrue;
+    }
+
+TInt CProcessingEvent::IndexCount()
+    {
+    return iAllIndexes.Count();
+    }
+
+TInt CProcessingEvent::FindIndex(TInt aClipIndex)
+    {
+    return iAllIndexes.Find(aClipIndex);
+    }
+
+void CProcessingEvent::RemoveIndex(TInt aProcessingEventIndex)
+    {
+    iAllIndexes.Remove(aProcessingEventIndex);
+    }
+
+    
+TInt CProcessingEvent::Compare(const CProcessingEvent& c1, const CProcessingEvent& c2) 
+    {
+                
+    if (c1.iPosition > c2.iPosition) 
+        {
+        return 1;
+        }
+    else if (c1.iPosition < c2.iPosition) 
+        {
+        return -1;
+        }
+    else 
+        {
+        return 0;
+        }
+    }
+    
+