czip.h

文件压缩实例 zlib很好的压缩实例

/*
*	版权所有 hdqqq  mail: [e-mail]
*  可以随便使用和分发下面的代码,但请保留这段文字.
*/
// czip.h: interface for the czip class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_CZIP_H__44877316_07EC_4E4D_857C_974DA7C3243B__INCLUDED_)
#define AFX_CZIP_H__44877316_07EC_4E4D_857C_974DA7C3243B__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#pragma warning (disable : 4786)

#include <zlib.h>

#include <list>
using namespace std;


#define CHECK_ERR(err, msg) { \
    if (err != Z_OK) { \
		TRACE("%s error: %d\n", msg, err); \
    } \
}

typedef list< pair<BYTE*, int> > BUF_LIST;

class filter_base
{
public:
	virtual BYTE* Process(const void* source_buf,int source_size,int& total_out) = 0;
	virtual BYTE* ProcessLast(const void* source_buf,int source_size,int& total_out) = 0;

public:
	filter_base(){}
	~filter_base(){}
	
};


template <typename data_type>
class zlib_Buf_Holder
{
public:
	typedef list< pair<data_type*,int> > _buf_type;

private:
	_buf_type m_BufList;

private:
	void Clear() {
		if (m_BufList.size()) {
			_buf_type::iterator it;
			for (it = m_BufList.begin(); it != m_BufList.end(); it++) {
				delete [] it->first;
				it->first = NULL;
			}
			m_BufList.clear();
		}
	}

public:

	void AddBuf(data_type* pdata,int count) {
		m_BufList.push_back(_buf_type::value_type(pdata, count));
	}
	
	int GetBufCount() {
		int ret = 0;
		if (m_BufList.size()) {
			_buf_type::iterator it;
			for (it = m_BufList.begin(); it != m_BufList.end(); it++) {
				ret += it->second;
			}
		}
		return ret;
	}

	data_type* GetBuf() {
		if (m_BufList.size() && GetBufCount() > 0) {
			_buf_type::iterator it;
			int total_out = GetBufCount();
			data_type* retbuf = NULL;
			data_type* head;

			retbuf = new data_type[total_out];
			memset(retbuf, 0, sizeof(data_type)*total_out);
			head = retbuf;
			for (it = m_BufList.begin(); it != m_BufList.end(); it++) {
				memcpy(head, it->first, it->second);
				head += it->second;
			}
			return retbuf;

		}else {
			return NULL;
		}
	}
public:
	zlib_Buf_Holder(){}
	~zlib_Buf_Holder() {
		Clear();
	}
};

template <int uncompress_deep>
class zlib_uncompress_filter : public filter_base
{
private:
	int m_uncompress;
	z_stream m_zStream;
public:
	BYTE* Process(const void* source_buf,int source_size,int& total_out)
	{
		int err;
		int avail_out;
		zlib_Buf_Holder<BYTE> out_buf;
		
		avail_out = source_size + 100;
		BYTE* lbuf = new BYTE[avail_out];
		memset(lbuf, 0, sizeof(BYTE)*avail_out);
		
		m_zStream.next_in = (Bytef*)source_buf;
		m_zStream.avail_in = source_size;
		m_zStream.total_in = 0;
		
		m_zStream.next_out = (unsigned char*) lbuf;
		m_zStream.avail_out = avail_out;
		m_zStream.total_out = 0;
		
		while (m_zStream.avail_in > 0) {
			err = inflate(&m_zStream, Z_SYNC_FLUSH);
			out_buf.AddBuf(lbuf, m_zStream.total_out);
			if (err == Z_OK && m_zStream.avail_in > 0 && m_zStream.avail_out == 0) {
				lbuf = new BYTE[avail_out];
				memset(lbuf, 0, sizeof(BYTE)*avail_out);
				m_zStream.next_out = (Bytef*)lbuf;
				m_zStream.avail_out = avail_out;
				m_zStream.total_out = 0;
			}
			
			if (err == Z_STREAM_END) {
				break;
			}
		}

		total_out = out_buf.GetBufCount();
		return out_buf.GetBuf();		
	}

	BYTE* ProcessLast(const void* source_buf,int source_size,int& total_out) {
		return Process(source_buf,source_size,total_out);
	}

public:
	zlib_uncompress_filter() {
		int err;		
		m_zStream.zalloc = (alloc_func)0;
		m_zStream.zfree = (free_func)0;
		m_zStream.opaque = (voidpf)0;
		err = inflateInit(&m_zStream);
		CHECK_ERR(err, "zlib_uncompress_filter::zlib_uncompress_filter()");

	}
	~zlib_uncompress_filter() {
		int err = inflateEnd(&m_zStream);
		CHECK_ERR(err, "zlib_uncompress_filter::~zlib_uncompress_filter()");
	}
};

template <int compress_deep>
class zlib_compress_filter : public filter_base
{
private:
	int m_compress;
	z_stream m_zStream;

public:	
	BYTE* Process(const void* source_buf,int source_size,int& total_out)
	{
		int err;
		int avail_out;
		
		zlib_Buf_Holder<BYTE> out_buf;
		
		avail_out = source_size + 100;
		BYTE* lbuf = new BYTE[avail_out];
		memset(lbuf,0,sizeof(BYTE)*avail_out);
		
		m_zStream.next_in = (Bytef*)source_buf;
		m_zStream.avail_in = source_size;
		
		m_zStream.next_out = (unsigned char*)lbuf;
		m_zStream.avail_out = avail_out;
		m_zStream.total_out = 0;
		
		while (m_zStream.avail_in > 0) {
			err = deflate(&m_zStream, Z_SYNC_FLUSH);
			CHECK_ERR(err, "zlib_compress_filter::Process()");
			out_buf.AddBuf(lbuf, m_zStream.total_out);
			if (err == Z_OK && m_zStream.avail_in > 0 && m_zStream.avail_out == 0) {
				lbuf = new BYTE[avail_out];
				memset(lbuf,0,sizeof(BYTE)*avail_out);
				m_zStream.next_out = (unsigned char*)lbuf;
				m_zStream.avail_out = avail_out;
				m_zStream.total_out = 0;
			}
		}
		total_out = out_buf.GetBufCount();
		return out_buf.GetBuf();
	}

	BYTE* ProcessLast(const void* source_buf,int source_size,int& total_out)
	{
		int err;
		int avail_out;
		zlib_Buf_Holder<BYTE> out_buf;
		avail_out = source_size + 100;
		BYTE* lbuf = new BYTE[avail_out];
		memset(lbuf,0,sizeof(BYTE)*avail_out);
		m_zStream.next_in = (Bytef*)source_buf;
		m_zStream.avail_in = source_size;
		m_zStream.next_out = (unsigned char*)lbuf;
		m_zStream.avail_out = avail_out;
		m_zStream.total_out = 0;
		while (1) {
			err = deflate(&m_zStream, Z_FINISH);
			CHECK_ERR(err, "zlib_compress_filter::ProcessLast()");
			out_buf.AddBuf(lbuf, m_zStream.total_out);
			if (err == Z_OK && m_zStream.avail_in > 0 && m_zStream.avail_out == 0) {
				lbuf = new BYTE[avail_out];
				memset(lbuf,0,sizeof(BYTE)*avail_out);
				m_zStream.next_out = (unsigned char*)lbuf;
				m_zStream.avail_out = avail_out;
				m_zStream.total_out = 0;
			}
			if (err == Z_STREAM_END) {
				break;
			}
		}
		total_out = out_buf.GetBufCount();
		return out_buf.GetBuf();
	}
public:
	zlib_compress_filter() : m_compress(compress_deep) {
		int err;
		m_zStream.zalloc = (alloc_func)0;
		m_zStream.zfree = (free_func)0;
		m_zStream.opaque = (voidpf)0;
		err = deflateInit(&m_zStream, compress_deep);
		CHECK_ERR(err, "zlib_compress_filter::zlib_compress_filter()");
	}
	~zlib_compress_filter() {
		int err = deflateEnd(&m_zStream);
		CHECK_ERR(err, "zlib_compress_filter::~zlib_compress_filter()");
	}
};



#endif // !defined(AFX_CZIP_H__44877316_07EC_4E4D_857C_974DA7C3243B__INCLUDED_)