diff -r 000000000000 -r 307788aac0a8 realtimenetprots/sipfw/SigComp/CompDeflate/inc/Deflate.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/realtimenetprots/sipfw/SigComp/CompDeflate/inc/Deflate.h	Tue Feb 02 01:03:15 2010 +0200
@@ -0,0 +1,303 @@
+/*
+* Copyright (c) 2002-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:
+* Name        : CDeflate.h
+* Part of     : deflatecomp / deflatecomp
+* deflate compressor header file.
+* Version     : 1.0
+*
+*/
+
+
+
+
+/**
+ @internalComponent
+*/
+
+#ifndef CDEFLATE_H
+#define CDEFLATE_H
+
+class CSigCompDeflateContext;
+class CMessageWriter;
+
+const TInt KMaxBits = 15;
+const TInt KLengthCodes = 29;
+const TInt KLiterals = 256;
+const TInt KLiteralCodes = (KLiterals + 1 + KLengthCodes);
+const TInt KDistanceCodes = 30;
+const TInt KMinMatch = 3;
+const TInt KMaxMatch = 258;
+const TUint KEncodeDistance = 256;
+
+/** length of good match, search stops after one of this length
+has been found
+*/
+const TInt KGoodMatchLength = 16;
+
+/** length of nice match, chainlength will be reduced if one of
+this length has been found
+*/
+const TInt KNiceMatchLength = 8;
+
+/** Do not perform lazy matching if we found match of this length
+*/
+const TInt KNiceLazyMatchLength = 16;
+
+
+/** maximum number of chains linked to one hash table entry */
+const TInt KMaxChainLength = 32;
+
+/*
+number of bits for hash table. hash table size = 1<<KHashTableBits
+the lower this number is, the slower compression is (because of
+bigger possibility of conflicts in hashing) but lower the memory consumption
+15 is probably the bigger reasonable number, 8 lower.
+*/
+const TInt KHashTableBits = 10;
+
+/**
+ * @brief Class for deflate compressor definition.
+ *
+ * From RFC 1951:
+ * The compressor uses a chained hash table to find duplicated strings,
+ * using a hash function that operates on 3-byte sequences.  At any
+ * given point during compression, let XYZ be the next 3 input bytes to
+ * be examined (not necessarily all different, of course).  First, the
+ * compressor examines the hash chain for XYZ.  If the chain is empty,
+ * the compressor simply writes out X as a literal byte and advances one
+ * byte in the input.  If the hash chain is not empty, indicating that
+ * the sequence XYZ (or, if we are unlucky, some other 3 bytes with the
+ * same hash function value) has occurred recently, the compressor
+ * compares all strings on the XYZ hash chain with the actual input data
+ * sequence starting at the current point, and selects the longest
+ * match.
+ *
+ * The compressor searches the hash chains starting with the most recent
+ * strings, to favor small distances and thus take advantage of the
+ * Huffman encoding. The hash chains are singly linked. There are no
+ *  deletions from the hash chains; the algorithm simply discards matches
+ *  that are too old.  To avoid a worst-case situation, very long hash
+ *  chains are arbitrarily truncated at a certain length, determined by a
+ *  run-time parameter.
+ *
+ *  To improve overall compression, the compressor optionally defers the
+ *  selection of matches ("lazy matching"): after a match of length N has
+ *  been found, the compressor searches for a longer match starting at
+ *  the next input byte.  If it finds a longer match, it truncates the
+ *  previous match to a length of one (thus producing a single literal
+ *  byte) and then emits the longer match.  Otherwise, it emits the
+ *  original match, and, as described above, advances N bytes before
+ *  continuing.
+ */
+class CDeflate : public CBase
+    {
+    public:
+
+        /**
+         * @brief huffman tree node
+         */
+        class TTreeNode
+            {
+            public:
+                /** actual value of this node */
+                TUint16 iBits;
+                /** number of bits this tree node uses */
+                TUint8 iLength;
+            };
+
+    public:
+
+        /**
+        * This function creates a new CDeflate object.
+        * The function may leave with KErrNoMemory if there is
+        * insufficient memory available.
+        * 
+        * @post compressor is ready to compress.
+        * @returns A created CDeflate object.
+        */ 
+        static CDeflate* NewL(TBool aDynamic,
+                              CSigCompDeflateContext* aContext);
+
+        /**
+        * This function creates a new CDeflate and places a pointer
+        * to it onto the cleanup stack.
+        *  
+        * @post compressor is ready to compress.
+        * @returns Pointer to a created CDeflate object.
+        * The function may leave with KErrNoMemory if there is
+        * insufficient memory available.
+        */ 
+        static CDeflate* NewLC(TBool aDynamic,
+                               CSigCompDeflateContext* aContext);
+
+        /**
+        * Destructor of the object. Destroy object and all its members.
+        * 
+        */ 
+        ~CDeflate();
+
+        /**
+        * Compress given data into aOutputBuffer.
+        * @param aMessage message to be compressed
+        * @param aOutputBuffer compressed message will be placed into
+        * this buffer
+        */
+        void CompressL(const TDesC8& aMessage, CMessageWriter* aMessageWriter);
+
+        /**
+        * Reset the compressor.
+        */
+        void Reset(void);
+
+        /**
+        * Reset hash table
+        */
+        void ResetHashTable(void);
+
+        /**
+        * Set the given dictionary
+        * @param aPtr pointer to memory containing dictionary
+        * @param aSize size of the dictionary, in bytes
+        */
+        void SetDictionary(const TUint8* aPtr, TInt aSize);
+
+        /**
+        * Change the window size.
+        * @param aWindowSize new window size.
+        */
+        void ChangeWindowSizeL(TInt aWindowSize);
+    
+    private:
+        void ConstructL(TBool aDynamic, CSigCompDeflateContext* aContext);
+
+        CDeflate();
+
+        /**
+        * Send n bits to a queue buffer.
+        * 
+        * @param aValue bits value
+        * @param aLength number of bits to send,
+        */ 
+        void SendBitsL(TUint aValue, TUint aLength);
+
+        /**
+        * Flush all queued bits
+        */ 
+        void FlushBitsL();
+
+        /**
+        * Put one byte into output buffer.
+        * 
+        * @param aValue byte to store in output buffer.
+        */ 
+        void PutByteL(TUint8 aValue);
+
+        /**
+        * Encode literal value, using Literal huffman tree
+        * 
+        * @param aValue literal to encode
+        */ 
+        void EncodeLiteralL(TInt aValue);
+
+        /**
+        * Encode pair of distance and length
+        * 
+        * @param aDist distance of a match being encoded
+        * @param aLength length of the match.
+        */ 
+        void EncodeDistanceLengthPairL(TUint aDist, TUint aLength);
+
+        /**
+        * This method searches matching substrings in encoded message
+        * using the hash table.
+        * 
+        * @param aMatchPos position within current window of found match.
+        *                  (if match was found).
+        * @param aLength length reference
+        *                (if match was found).
+        *
+        * @post if match was found aOffset and aLength are filled with correct
+        *       values
+        * @returns ETrue if match was found, EFalse if not,
+        */ 
+        TBool FindBestMatch(TInt& aMatchPos, TInt& aLength);
+
+        /**
+        * Fill window with aBytes characters from given pointer
+        * @param aPtr pointer where to fetch data from
+        * @param aBytes number of bytes to fetch
+        *
+        * @returns number of bytes fetched from given address.
+        */
+        TInt FillWindow(const TUint8* aPtr, TInt aBytes);
+
+        /**
+        * Calculate hash from three given characters
+        * @param aA first character for hash 
+        * @param aB second character for hash 
+        * @param aC third character for hash 
+        */
+        TInt CalcHash(TUint8 aA, TUint8 aB, TUint8 aC) const;
+
+        /**
+        * Insert hash calculated from 3 characters at given address
+        * to the hash table.
+        * @param aPosition position within the iWindow from where 3
+        * characters for the hash will be fetched from
+        */
+        void InsertHash(TInt aPosition);
+
+    private:
+        /** output bit buffer, encoded bitstream*/
+        TUint iBitBuffer;
+        
+        /** number of bits currently stored in bit buffer */
+        TUint iBitsQueued;
+        
+        /** size of hash table */
+        TInt iHashSize;
+        
+        /** mask used when calculating hash */
+        TUint iHashMask;
+        
+        /** shift used when calculating hash */
+        TUint iHashShift;
+        
+        /** shift used when calculating hash */
+        TUint iHashShift2;
+        
+        /** the hash table,used to speed up searching of matching substrings */
+        CArrayFixFlat<TInt16>* iHashTable;
+
+        /** number of bytes queued */
+        TInt iLookAhead;
+
+        /** array of nodes, those are used as linked elements in hash table */
+        CArrayFixFlat<TInt16>* iChainNodes;
+        
+        /** modulo mask for chain nodes, iWindowSize - 1 */
+        TInt iChainMask;
+
+        /** output buffer, encoded bitstream is stored there */
+        CMessageWriter* iMessageWriter;
+
+        /** determines whenever compression is dynamic or not */
+        TBool iDynamic;
+        
+        /** deflate compression context */
+        CSigCompDeflateContext* iDeflateContext;
+    };
+
+#endif