hzip.h

枚举主机网络设备

#ifndef __SELFLZW_H
#define __SELFLZW_H

#include "HLib32.h"
#include "hzip.h"


typedef struct SHZipEntry
{
	BYTE bLast;
	unsigned short wCode;
	struct SHZipEntry *pChild,*pRightBrother;
}HZIPENTRY,*PHZIPENTRY;

typedef struct SHUnzipEntry
{
	BYTE *pbContain;
}SHUNZIPENTRY,*PHUNZIPENTRY;

class AFX_EXT_CLASS CHUnzipTable
{
public:
	CHUnzipTable(bool fInit=true);
	~CHUnzipTable();
	void ClearDecodeTable(void);
	void InitLZWTable(void);
	BYTE* GetMatchData(unsigned short wCode);
	void AddToChild(unsigned short wCode,BYTE *pbContain,int iLength);
	DWORD GetTableEntryNumber(void){return m_dwTableEntryNumber;};
protected:
	BYTE** m_pbContain;
	DWORD m_dwTableEntryNumber;
};

class AFX_EXT_CLASS CHZipTable
{
public:
	CHZipTable(bool fInit=true);
	~CHZipTable();
	void ClearLZWTable(void);
	void InitLZWTable(void);
	// return the find child
	PHZIPENTRY FindMatchChild(BYTE bChileLast,PHZIPENTRY pCurrent);
	//return the add child
	PHZIPENTRY  AddToChild(BYTE bLast,PHZIPENTRY pCurrent);

public://inline
	PHZIPENTRY GetHead(void){return &m_EntryHead;};
	DWORD GetTableEntryNumber(void){return m_dwTableEntryNumber;};

protected:
	void RemoveFirstChild(void);
	PHZIPENTRY FindRightBrother(PHZIPENTRY pCurrent);
protected:
	DWORD m_dwTableEntryNumber;
	unsigned int m_uNextCodeForUse;
	HZIPENTRY m_EntryHead;
};

// define for lzw encode
typedef bool (*FUN_LZWENCODEGETNEXTBYTE) (BYTE* bufIn,
					   DWORD &dwPtIn,
					   BYTE* bufEncodeGet,
					   DWORD &dwPtEncodeGetPos,
					   BYTE& bGet);// get next byte
typedef bool (*FUN_LZWENCODEPUTNEXTBYTES) (BYTE* bufOut,DWORD &dwPtOut,BYTE* pbPut,int iLength); // put next byte
typedef void (*FUN_LZWENCODEDBYTES) (void);
typedef bool (*FUN_LZWDECODEGETNEXTBYTES) (BYTE* pbGet,int iLength);
typedef bool (*FUN_LZWDECODEPUTNEXTBYTE) (BYTE bPut);
typedef void (*FUN_LZWDECODEDBYTES) (void);

#define LZW_MAX_ENTRY           4096
#define LZW_CLEAR_CODE          256
#define LZW_END_CODE            LZW_CLEAR_CODE+1//257
#define LZW_BEGIN_ENTRY         LZW_END_CODE+1//258

#define CHECK_BIT_1(b,i)        (b & (1<<i))
#define CHECK_BIT_0(b,i)        (!(CHECK_BIT_1(b,i))
#define SET_BIT_1(b,i)          (b |= (1<<i))
#define SET_BIT_0(b,i)          (b &= (~(1<<i)))

#define		LEN_FILEUSEDBUFFER	1024*10 

class AFX_EXT_CLASS CDecodeBitArray
{ 
public:
	CDecodeBitArray(DWORD dwInitWidth=0);// width in bit
	~CDecodeBitArray();
	void ClearBits(void);
	void InitBits(DWORD dwInitWidth);
	void InitBytes(DWORD dwInitWidth);
	DWORD GetLeftBytes(void);
	DWORD GetLeftBits(void){return m_dwTail-m_dwHead;};
	unsigned short RemoveBits(int iWidth);
	bool AddBytes(BYTE* pbAdd,int iLength);
protected:
	void Resort(void);
	unsigned short RemoveFirstBit(void);
protected:
	BYTE *m_pbBits;
	DWORD m_dwTail,m_dwHead;
	// tail is the first not usable bit
	// head is the first usable bit
	DWORD m_dwWidthInByte;
};

struct AFX_EXT_CLASS SHZipHead
{
	DWORD dwLenCompress;
	DWORD dwLenUnCompress;
	DWORD dwCrc;
};

class AFX_EXT_CLASS CEncodeBitArray
{
public:
	CEncodeBitArray(DWORD dwInitWidth=0);// width in bit
	bool InitBits(DWORD dwInitWidth);
	bool InitBytes(DWORD dwInitWidth){return InitBits(dwInitWidth*8);};
	void ClearBits(void);
	~CEncodeBitArray();
	bool AddBits(unsigned short wAdd,int iWidth);
	DWORD GetBytesWidth(void);// get width in byte
	DWORD GetBitsWidth(void){return m_dwTail;};// get width in bit
	BYTE* GetBits(void){return m_pbBits;};// get the point of contain
	DWORD GetMaxBytes(void){return m_dwWidthInByte;};// get max capability
	int RemoveBytes(BYTE *pbGet,int iWant);
	// get bytes in contain and reset tail
protected:
	BYTE* m_pbBits;
	DWORD m_dwTail;
	DWORD m_dwWidthInByte;
};

class AFX_EXT_CLASS CHZip
{
public:
	CHZip():m_LZWTable(false)
		 {m_wMaxEntry=LZW_MAX_ENTRY;};
	~CHZip(){};
	DWORD Compress(BYTE *bufIn,DWORD dwLenIn,BYTE *bufOut);
	DWORD CompressFile(char *bufFileIn,char *bufFileOut);
protected:
	bool BeginHZip(const DWORD dwLength,
						unsigned short wBufferLen=1024,
						DWORD dwBytesOnce=1);
	void EndHZip();
	DWORD GetCompressedLength(void){return m_dwCompressedLength;};
	bool CompressPutNextBytes(BYTE* bufOut,DWORD &dwPtOut,BYTE* pbPut,int iPut);
	bool CompressGetNextByte(BYTE* bufIn,
					   DWORD &dwPtIn,
					   BYTE* bufEncodeGet,
					   DWORD &dwPtEncodeGetPos,
					   BYTE& bGet);
	int GetBitWidth(void);
protected:
	unsigned short m_wMaxEntry;
	CHZipTable m_LZWTable;
	CEncodeBitArray m_baContain;
	DWORD		m_dwCompressedLength;
	DWORD		m_dwFileUsedBufferLength;
	DWORD		m_dwEncodeGetTotal;

	BYTE		m_bufEncodeGet[LEN_FILEUSEDBUFFER];
	DWORD		m_dwEncodeGetPos;
	BYTE		*m_bufIn;
	BYTE		*m_bufOut;
	DWORD		m_dwPtIn;
	DWORD		m_dwPtOut;
};

class AFX_EXT_CLASS CHUnzip
{ 
public:
	CHUnzip():m_LZWTable(false){
		m_bufIn=NULL;
		m_bufOut=NULL;
		m_dwPtIn=0;
		m_dwPtOut=0;
	};
	~CHUnzip(){};
	bool UnCompress(BYTE *bufIn,DWORD dwLenIn,BYTE *bufOut);
	bool UnCompressFile(char *bufFileIn,char *bufFileOut);
protected:
	bool BeginHUnzip(const DWORD dwLength,
						unsigned short wBuffer=1024,
						DWORD dwBytesOnce=1);
	void EndHUnzip(FUN_LZWDECODEPUTNEXTBYTE pfunLZWPutNextByte);
	void WriteDecode(BYTE* pbWrite,
					DWORD dwBytesOnce=1);
	bool DecodeGetNextBytes(BYTE* pbGet,int iGet);
	bool DecodePutNextByte(BYTE bPut);
protected:
	CHUnzipTable m_LZWTable;
	CDecodeBitArray m_baContain;
	DWORD m_dwDecodedByte;
	int m_iTotalEntry;

	int			m_nDecodeGetPos;

	BYTE		*m_bufIn;
	BYTE		*m_bufOut;
	DWORD		m_dwPtIn;
	DWORD		m_dwPtOut;
};

#endif