diff -r 000000000000 -r 1bce908db942 multimediacommscontroller/mmccshared/src/streamformatter.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/multimediacommscontroller/mmccshared/src/streamformatter.cpp	Tue Feb 02 01:04:58 2010 +0200
@@ -0,0 +1,286 @@
+/*
+* Copyright (c) 2004-2005 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:    PayloadFormat plugin capable to read RTP payload containing
+*                AMR audio.
+*
+*/
+
+
+
+
+// INCLUDE FILES
+#include "streamformatter.h"
+
+// CONSTANTS
+const TInt KBitsIn4Bytes = 32;
+const TUint8 KZeroMask = 0xFF;
+const TInt KBitIndex7 = 7;
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// TStreamEncoder::Initialize
+// Initialize the stream encoder.
+// -----------------------------------------------------------------------------
+//
+void TStreamEncoder::Initialize( TUint8* aBuffer, TInt aByteIndex, TInt aBitIndex )
+    {
+    iBuffer = aBuffer;
+    iByteIndex = aByteIndex;
+    iBitIndex = aBitIndex;
+    };
+
+// -----------------------------------------------------------------------------
+// TStreamEncoder::Encode
+// Put a number of bit values ( up to 32 bits ) into the bit-stream buffer 
+// -----------------------------------------------------------------------------
+//
+void TStreamEncoder::Encode( TUint32 aValue, TInt aBitCount )
+    {
+    // Bit count has to be between 1 and 32 so if number of bits is out of range
+    // return from here
+    if ( aBitCount < 1 || aBitCount > KBitsIn4Bytes )
+        {
+        return;
+        }
+        
+    TInt bitCount = aBitCount;
+    TInt vacantBits;
+    TInt bitsWritten;
+    TUint32 oldValue;
+    TUint32 newValue;
+    TUint8* p;
+
+    while ( bitCount > 0 )
+        {
+        p = iBuffer + iByteIndex;
+        vacantBits = KBitsIn1Byte - iBitIndex;
+
+        if ( bitCount >= vacantBits )
+            {
+            // get old value and zero out vacant bits
+            oldValue = ( *p ) & ( KZeroMask << vacantBits );
+            
+            newValue = ( ( bitCount - vacantBits ) < KBitsIn4Bytes ) ?
+                 TUint8( ( aValue >> ( bitCount - vacantBits ) ) ) : 0;
+                 
+            bitsWritten = vacantBits;
+            }
+        else
+            {
+            oldValue = ( *p ) 
+                & ( ( KZeroMask << vacantBits ) 
+                | ( KZeroMask >> ( KBitsIn1Byte - vacantBits + bitCount ) ) );
+            newValue = TUint8( ( aValue << ( vacantBits-bitCount ) ) );
+            bitsWritten = bitCount;
+            }
+        
+        // zero out unwanted bits
+        newValue &= ( KZeroMask ) >> ( iBitIndex );
+         // write the byte
+        *p = TUint8( ( oldValue | newValue ) );
+
+        // update variables
+        bitCount -= bitsWritten;
+        iBitIndex += bitsWritten;
+        if ( iBitIndex > KBitIndex7 )
+            {
+            iBitIndex &= KBitIndex7;
+            iByteIndex += 1;
+            }
+        }
+    };
+
+// -----------------------------------------------------------------------------
+// TStreamEncoder::Encode
+// Put a number of bit values into the bit-stream buffer at current location.
+// -----------------------------------------------------------------------------
+//
+void TStreamEncoder::Encode( const TUint8* aFromBuffer, TInt aFromByteIndex, 
+        TInt aFromBitIndex, TInt aBitCount )
+    {
+    if ( aFromBitIndex == 0 && iBitIndex == 0 )
+        {
+        // Mem::Copy is applicable
+        TUint8* desBuffer = iBuffer + iByteIndex;
+        const TUint8* srcBuffer = aFromBuffer + aFromByteIndex;
+        
+        TInt byteLen = aBitCount / KBitsIn1Byte;
+        TInt bitsLeft = aBitCount % KBitsIn1Byte;
+        
+        Mem::Copy( desBuffer, srcBuffer, byteLen );
+        iByteIndex += byteLen;
+        
+        if ( bitsLeft != 0 )
+            {
+            TUint32 value;
+            TStreamDecoder decoder;
+            decoder.Initialize( aFromBuffer, aFromByteIndex + byteLen, aFromBitIndex );
+            value = decoder.Decode( bitsLeft );
+            Encode( value, bitsLeft );
+            }
+            
+        return;
+        }
+
+    // Note that Mem::Copy is not applicable, have to do bit shifting
+    TInt bitFilled = 0;
+    TUint32 value;
+    TStreamDecoder decoder;
+    decoder.Initialize( aFromBuffer, aFromByteIndex, aFromBitIndex );
+
+    while ( bitFilled < aBitCount )
+        {
+        if ( aBitCount - bitFilled < KBitsIn4Bytes )
+            {
+            value = decoder.Decode( aBitCount - bitFilled );
+            Encode( value, ( aBitCount - bitFilled ) );
+            bitFilled = aBitCount;
+            }
+        else
+            {
+            value = decoder.Decode( KBitsIn4Bytes );
+            Encode( value, KBitsIn4Bytes );
+            bitFilled += KBitsIn4Bytes;
+            }
+        }
+    };
+
+// -----------------------------------------------------------------------------
+// TStreamDecoder::Initialize
+// Initialize the stream decoder.
+// -----------------------------------------------------------------------------
+//
+void TStreamDecoder::Initialize( const TUint8* aBuffer, TInt aByteIndex, 
+        TInt aBitIndex )
+    {
+    iBuffer = aBuffer;
+    iByteIndex = aByteIndex;
+    iBitIndex = aBitIndex;
+    };
+
+// -----------------------------------------------------------------------------
+// TStreamDecoder::Decode
+// Get a number of bit values ( up to 32 bits ) from the bit-stream buffer at 
+// current location.
+// -----------------------------------------------------------------------------
+//
+TUint32 TStreamDecoder::Decode( TInt aBitCount )
+    {
+    // Bit count has to be between 1 and 32 so if number of bits is out of range
+    // return from here
+    if ( aBitCount < 1 || aBitCount > KBitsIn4Bytes )
+        {
+        return 0;
+        }
+
+    TInt bitCount = aBitCount;
+    TInt availableBits;
+    TInt bitsRead;
+    TUint8* p;
+    TUint32 temp;
+    TUint32 value = 0;
+
+    while ( bitCount > 0 )
+        {
+        p = const_cast<TUint8*>( iBuffer ) + iByteIndex;
+        availableBits = KBitsIn1Byte - iBitIndex;
+
+        // read one byte and zero out unwanted bits
+        temp = ( *p ) & ( KZeroMask >> iBitIndex );
+
+        // update return value
+        if ( bitCount >= availableBits )
+            {
+            value = TUint8( temp ) | ( value<<availableBits );
+            bitsRead = availableBits;
+            }
+        else
+            {
+            value = TUint8( ( temp >> ( availableBits - bitCount ) ) ) | ( value << bitCount );
+            bitsRead = bitCount;
+            }
+
+        // update variables
+        bitCount -= bitsRead;
+        iBitIndex += bitsRead;
+        if ( iBitIndex > KBitIndex7 )
+            {
+            iBitIndex &= KBitIndex7;
+            iByteIndex += 1;
+            }
+        }
+        
+    return value;
+    };
+
+// -----------------------------------------------------------------------------
+// TStreamDecoder::Decode
+// Get a number of byte values from the bit-stream buffer at current location.
+// -----------------------------------------------------------------------------
+//
+void TStreamDecoder::Decode( TUint8* aToBuffer, TInt aToByteIndex, 
+        TInt aToBitIndex, TInt aBitCount )
+    {
+    if ( aToBitIndex == 0 && iBitIndex == 0 )
+        {
+        // Mem::Copy is applicable
+        TUint8* desBuffer = aToBuffer + aToByteIndex;
+        const TUint8* srcBuffer = iBuffer + iByteIndex;
+        
+        TInt byteLen = aBitCount / KBitsIn1Byte;
+        TInt bitsLeft = aBitCount % KBitsIn1Byte;
+        
+        Mem::Copy( desBuffer, srcBuffer, byteLen );
+        iByteIndex += byteLen;
+        
+        if ( bitsLeft != 0 )
+            {
+            TUint32 value;
+            TStreamEncoder encoder;
+            encoder.Initialize( aToBuffer, aToByteIndex + byteLen, aToBitIndex );
+            value = Decode( bitsLeft );
+            encoder.Encode( value, bitsLeft );
+            }
+            
+        return;
+        }
+
+    // Note that Mem::Copy is not applicable, have to do bit shifting
+    TInt bitFilled = 0;
+    TUint32 value;
+    TStreamEncoder encoder;
+    encoder.Initialize( aToBuffer, aToByteIndex, aToBitIndex );
+
+    while ( bitFilled < aBitCount )
+        {
+        // Check if number of remaining bits is less than 32.
+        if ( aBitCount - bitFilled < KBitsIn4Bytes )
+            {
+            value = Decode( aBitCount - bitFilled );
+            encoder.Encode( value, ( aBitCount - bitFilled ) );
+            bitFilled = aBitCount;
+            }
+        else
+            {
+            value = Decode( KBitsIn4Bytes );
+            encoder.Encode( value, KBitsIn4Bytes );
+            bitFilled += KBitsIn4Bytes;
+            }
+        }
+    };
+
+// ========================== OTHER EXPORTED FUNCTIONS =========================
+
+//  End of File