imgtools/imglib/e32image/deflate/huffman.h
changeset 0 044383f39525
equal deleted inserted replaced
-1:000000000000 0:044383f39525
       
     1 /*
       
     2 * Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of the License "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description: 
       
    15 * e32tools\petran\Szip\huffman.h
       
    16 *
       
    17 */
       
    18 
       
    19 
       
    20 #ifndef __HUFFMAN_H__
       
    21 #define __HUFFMAN_H__
       
    22 
       
    23 #include <e32std.h>
       
    24 
       
    25 /** Bit output stream.
       
    26 	Good for writing bit streams for packed, compressed or huffman data algorithms.
       
    27 
       
    28 	This class must be derived from and OverflowL() reimplemented if the bitstream data
       
    29 	cannot be generated into a single memory buffer.
       
    30 
       
    31 	@since 8.0
       
    32 	@library euser.lib
       
    33 */
       
    34 class TBitOutput
       
    35 	{
       
    36 public:
       
    37 	TBitOutput();
       
    38 	TBitOutput(TUint8* aBuf,TInt aSize);
       
    39 	inline virtual ~TBitOutput() { } 
       
    40 	inline void Set(TUint8* aBuf,TInt aSize);
       
    41 	inline const TUint8* Ptr() const;
       
    42 	inline TInt BufferedBits() const;
       
    43 //
       
    44 	void WriteL(TUint aValue, TInt aLength);
       
    45 	void HuffmanL(TUint aHuffCode);
       
    46 	void PadL(TUint aPadding);
       
    47 private:
       
    48 	void DoWriteL(TUint aBits, TInt aSize);
       
    49 	virtual void OverflowL();
       
    50 private:
       
    51 	TUint iCode;		// code in production
       
    52 	TInt iBits;
       
    53 	TUint8* iPtr;
       
    54 	TUint8* iEnd;
       
    55 	};
       
    56 
       
    57 /** Set the memory buffer to use for output
       
    58 
       
    59 	Data will be written to this buffer until it is full, at which point OverflowL() will
       
    60 	be called. This should handle the data and then can Set() again to reset the buffer
       
    61 	for further output.
       
    62 	
       
    63 	@param "TUint8* aBuf" The buffer for output
       
    64 	@param "TInt aSize" The size of the buffer in bytes
       
    65 */
       
    66 inline void TBitOutput::Set(TUint8* aBuf,TInt aSize)
       
    67 	{iPtr=aBuf;iEnd=aBuf+aSize;}
       
    68 /** Get the current write position in the output buffer
       
    69 
       
    70 	In conjunction with the address of the buffer, which should be known to the
       
    71 	caller, this describes the data in the bitstream.
       
    72 */
       
    73 inline const TUint8* TBitOutput::Ptr() const
       
    74 	{return iPtr;}
       
    75 /** Get the number of bits that are buffered
       
    76 
       
    77 	This reports the number of bits that have not yet been written into the
       
    78 	output buffer. It will always lie in the range 0..7. Use PadL() to
       
    79 	pad the data out to the next byte and write it to the buffer.
       
    80 */
       
    81 inline TInt TBitOutput::BufferedBits() const
       
    82 	{return iBits+8;}
       
    83 
       
    84 
       
    85 /** Bit input stream.
       
    86 	Good for reading bit streams for packed, compressed or huffman data algorithms.
       
    87 	@since 8.0
       
    88 	@library euser.lib
       
    89 */
       
    90 class TBitInput
       
    91 	{
       
    92 public:
       
    93 	TBitInput();
       
    94 	TBitInput(const TUint8* aPtr, TInt aLength, TInt aOffset=0);
       
    95 	void Set(const TUint8* aPtr, TInt aLength, TInt aOffset=0);
       
    96  	inline virtual ~TBitInput() { } 
       
    97 	TUint ReadL();
       
    98 	TUint ReadL(TInt aSize);
       
    99 	TUint HuffmanL(const TUint32* aTree);
       
   100 private:
       
   101 	virtual void UnderflowL();
       
   102 private:
       
   103 	TInt iCount;
       
   104 	TUint iBits;
       
   105 	TInt iRemain;
       
   106 	const TUint32* iPtr;
       
   107 	};
       
   108 
       
   109 /** Huffman code toolkit.
       
   110 
       
   111 	This class builds a huffman encoding from a frequency table and builds
       
   112 	a decoding tree from a code-lengths table
       
   113 
       
   114 	The encoding generated is based on the rule that given two symbols s1 and s2, with 
       
   115 	code length l1 and l2, and huffman codes h1 and h2:
       
   116 
       
   117 		if l1<l2 then h1<h2 when compared lexicographically
       
   118 		if l1==l2 and s1<s2 then h1<h2 ditto
       
   119 
       
   120 	This allows the encoding to be stored compactly as a table of code lengths
       
   121 
       
   122 	@since 8.0
       
   123 	@library euser.lib
       
   124 */
       
   125 class Huffman
       
   126 	{
       
   127 public:
       
   128 	enum {KMaxCodeLength=27};
       
   129 	enum {KMetaCodes=KMaxCodeLength+1};
       
   130 	enum {KMaxCodes=0x8000};
       
   131 public:
       
   132 	static void HuffmanL(const TUint32 aFrequency[],TInt aNumCodes,TUint32 aHuffman[]);
       
   133 	static void Encoding(const TUint32 aHuffman[],TInt aNumCodes,TUint32 aEncodeTable[]);
       
   134 	static void Decoding(const TUint32 aHuffman[],TInt aNumCodes,TUint32 aDecodeTree[],TInt aSymbolBase=0);
       
   135 	static TBool IsValid(const TUint32 aHuffman[],TInt aNumCodes);
       
   136 //
       
   137 	static void ExternalizeL(TBitOutput& aOutput,const TUint32 aHuffman[],TInt aNumCodes);
       
   138 	static void InternalizeL(TBitInput& aInput,TUint32 aHuffman[],TInt aNumCodes);
       
   139 	};
       
   140 
       
   141 #endif
       
   142