--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lowlevellibsandfws/apputils/src/BADICTIONARYCOMPRESSION.CPP Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,172 @@
+// Copyright (c) 2001-2009 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:
+//
+
+#include <e32std.h>
+#include <baflpan.h>
+#include "BADICTIONARYCOMPRESSION.H"
+
+RDictionaryCompressionBitStream::RDictionaryCompressionBitStream() :
+ iNumberOfBitsUsedForDictionaryTokens(0),
+ iOffsetToFirstBit(-1),
+ iOffsetToCurrentBit(-1),
+ iOffsetOnePastLastBit(-1),
+ iOwnsBitBuffer(EFalse),
+ iBuffer(NULL),
+ iAssertObj()
+ {
+ }
+
+void RDictionaryCompressionBitStream::OpenL(
+ TInt aNumberOfBitsUsedForDictionaryTokens,
+ TInt aOffsetToFirstBit,
+ TInt aOffsetOnePastLastBit,
+ TBool aTransferringOwnershipOfBuffer,
+ TUint8* aBuffer,
+ const TBaAssert& aAssertObj)
+ {
+ iNumberOfBitsUsedForDictionaryTokens = aNumberOfBitsUsedForDictionaryTokens;
+ iOffsetToFirstBit = aOffsetToFirstBit;
+ iOffsetToCurrentBit = aOffsetToFirstBit;
+ iOffsetOnePastLastBit = aOffsetOnePastLastBit;
+ iOwnsBitBuffer = aTransferringOwnershipOfBuffer;
+ iBuffer = aBuffer;
+ iAssertObj = aAssertObj;
+
+ iAssertObj.AssertDebL(aBuffer!=NULL,EBafPanicNullPointer);
+ iAssertObj.AssertDebL(aOffsetToFirstBit>=0,EBafPanicNegativeOffsetToFirstBit1);
+ iAssertObj.AssertDebL(aOffsetToFirstBit<=aOffsetOnePastLastBit,EBafPanicNegativeLengthOfBitBuffer);
+ }
+
+void RDictionaryCompressionBitStream::Close()
+ {
+ if (iOwnsBitBuffer)
+ {
+ iOwnsBitBuffer=EFalse;
+ delete [] iBuffer;
+ }
+ iBuffer=NULL;
+ }
+
+TBool RDictionaryCompressionBitStream::EndOfStreamL() const
+ {
+ __ASSERT_DEBUG(iBuffer!=NULL,Panic(EBafPanicNotConstructed1));
+ iAssertObj.AssertDebL(iOffsetToFirstBit>=0,EBafPanicNegativeOffsetToFirstBit2);
+ iAssertObj.AssertDebL(iOffsetToCurrentBit>=iOffsetToFirstBit,EBafPanicBadCurrentBitPosition1);
+ iAssertObj.AssertDebL(iOffsetToCurrentBit<=iOffsetOnePastLastBit,EBafPanicBadCurrentBitPosition2);
+ return iOffsetToCurrentBit>=iOffsetOnePastLastBit;
+ }
+
+TInt RDictionaryCompressionBitStream::IndexOfDictionaryEntryL()
+ {
+ // increments the current bit-position if it returns a value >=0; returns KErrNotFound if the next thing in the stream is plain data rather than the index of a dictionary entry
+ __ASSERT_DEBUG(iBuffer!=NULL,Panic(EBafPanicNotConstructed2));
+ iAssertObj.AssertDebL(!EndOfStreamL(),EBafPanicEndOfStream1);
+ if (!CurrentBitIsOn())
+ {
+ ++iOffsetToCurrentBit;
+ return ReadIntegerL(iNumberOfBitsUsedForDictionaryTokens);
+ }
+ return KErrNotFound;
+ }
+
+void RDictionaryCompressionBitStream::ReadL(TDes8& aBufferToAppendTo,TBool aCalypsoFileFormat)
+ {
+ // can only be called if IndexOfDictionaryEntry returned a negative value
+ __ASSERT_DEBUG(iBuffer!=NULL,Panic(EBafPanicNotConstructed3));
+ iAssertObj.AssertDebL(!EndOfStreamL(),EBafPanicEndOfStream2);
+ TInt numberOfConsecutivePrefixBits=0;
+ TInt i;
+ for (i=0; i<4; ++i)
+ {
+ const TBool currentBitIsOn=CurrentBitIsOn();
+ ++iOffsetToCurrentBit; // increment this regardless whether the current bit is on
+ if (!currentBitIsOn)
+ {
+ break;
+ }
+ ++numberOfConsecutivePrefixBits;
+ }
+ iAssertObj.AssertDebL(numberOfConsecutivePrefixBits>0,EBafPanicBadNumberOfConsecutivePrefixBits1);
+ iAssertObj.AssertDebL(numberOfConsecutivePrefixBits<=4,EBafPanicBadNumberOfConsecutivePrefixBits2);
+ TInt numberOfBytesToRead;
+ if (numberOfConsecutivePrefixBits==3)
+ {
+ numberOfBytesToRead=3+ReadIntegerL(3);
+ }
+ else if (numberOfConsecutivePrefixBits==4)
+ {
+ numberOfBytesToRead=ReadIntegerL(8);
+ if (!aCalypsoFileFormat)
+ {
+ numberOfBytesToRead+=3+(1<<3);
+ }
+ }
+ else
+ {
+ numberOfBytesToRead=numberOfConsecutivePrefixBits;
+ }
+ const TInt numberOfBitsOffByteBoundary=iOffsetToCurrentBit%8;
+ const TUint8* currentByte=iBuffer+(iOffsetToCurrentBit/8);
+ iAssertObj.AssertDebL(
+ (numberOfBytesToRead + aBufferToAppendTo.Length()) <= aBufferToAppendTo.MaxLength(),
+ EBafPanicBufLength);
+ for (i=0; i<numberOfBytesToRead; ++i, ++currentByte)
+ {
+ TUint byte=*currentByte;
+ iAssertObj.AssertDebL(numberOfBitsOffByteBoundary>=0,EBafPanicBadNumberOfBitsOffByteBoundary1);
+ if (numberOfBitsOffByteBoundary>0)
+ {
+ byte>>=numberOfBitsOffByteBoundary;
+ byte|=(*(currentByte+1)<<(8-numberOfBitsOffByteBoundary));
+ byte&=0xff;
+ }
+ aBufferToAppendTo.Append(byte);
+ }
+ iOffsetToCurrentBit+=numberOfBytesToRead*8;
+ iAssertObj.AssertDebL(numberOfBitsOffByteBoundary==iOffsetToCurrentBit%8,EBafPanicBadNumberOfBitsOffByteBoundary2);
+ }
+
+TBool RDictionaryCompressionBitStream::CurrentBitIsOn() const
+ {
+ // does not increment the current bit-position
+ __ASSERT_DEBUG(iBuffer!=NULL,Panic(EBafPanicNotConstructed4));
+ return iBuffer[iOffsetToCurrentBit/8]&(1<<(iOffsetToCurrentBit%8));
+ }
+
+TUint RDictionaryCompressionBitStream::ReadIntegerL(TInt aNumberOfBits)
+ {
+ // increments the current bit-position
+ __ASSERT_DEBUG(iBuffer!=NULL,Panic(EBafPanicNotConstructed5));
+ TInt integer=0;
+ TInt numberOfBitsLeftToRead=aNumberOfBits;
+ FOREVER
+ {
+ const TInt offsetToFirstBitToReadInCurrentByte=iOffsetToCurrentBit%8;
+ const TInt offsetOnePastLastBitToReadInCurrentByte=Min(8,offsetToFirstBitToReadInCurrentByte+numberOfBitsLeftToRead);
+ const TInt numberOfBitsReadFromCurrentByte=offsetOnePastLastBitToReadInCurrentByte-offsetToFirstBitToReadInCurrentByte;
+ iAssertObj.AssertDebL(numberOfBitsReadFromCurrentByte>0,EBafPanicBadNumberOfBitsReadFromCurrentByte);
+ const TUint bitsReadFromCurrentByte=((iBuffer[iOffsetToCurrentBit/8]>>offsetToFirstBitToReadInCurrentByte)&((1<<numberOfBitsReadFromCurrentByte)-1));
+ integer|=(bitsReadFromCurrentByte<<(aNumberOfBits-numberOfBitsLeftToRead));
+ iOffsetToCurrentBit+=numberOfBitsReadFromCurrentByte;
+ numberOfBitsLeftToRead-=numberOfBitsReadFromCurrentByte;
+ iAssertObj.AssertDebL(numberOfBitsLeftToRead>=0,EBafPanicBadNumberOfBitsLeftToRead);
+ if (numberOfBitsLeftToRead<=0)
+ {
+ break;
+ }
+ }
+ return integer;
+ }
+