--- /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