compress.cpp

用FREE BASIC做的演示程序

#include "Compress.h"
#include<malloc.h>
#include<memory.h>
bool GCompressNone::Compress(void*pOrgData,unsigned long dwOrgDataSize,void**ppCompressData,unsigned long & dwCompressedDataSize)
{
	*ppCompressData=new char[dwOrgDataSize];
	if(!(*ppCompressData))
		return false;
	memcpy(*ppCompressData,pOrgData,dwOrgDataSize);
	dwCompressedDataSize=dwOrgDataSize;
	return true;
}
bool GCompressNone::DecompressAutoSize(void*pCompressedData,unsigned long dwCompressedDataSize,void**ppOrgData,unsigned long & dwOrgDataSize)
{
	*ppOrgData=new char[dwCompressedDataSize];
	if(!(*ppOrgData))
		return false;
	memcpy(*ppOrgData,pCompressedData,dwCompressedDataSize);
	dwOrgDataSize=dwCompressedDataSize;
	return true;
}
bool GCompressNone::Decompress(void*pCompressedData,unsigned long dwCompressedDataSize,void*pDestAddr)
{
	memcpy(pDestAddr,pCompressedData,dwCompressedDataSize);
	return true;
}

bool GCompress8BitRLE::Compress(void*pOrgData,unsigned long dwOrgDataSize,void**ppCompressData,unsigned long & dwCompressedDataSize)
{
	unsigned char*pData=(unsigned char*)pOrgData;
	unsigned char*pDataEnd=pData+dwOrgDataSize;
	unsigned char*pTempAddr;
	unsigned char ubOldData;
	unsigned long dwRepCount;
	
	unsigned char*pCompressed=(unsigned char*)malloc(0xffff);
	if(!pCompressed)
		return false;
	memset(pCompressed,0,0xffff);
	unsigned long dwMaxSize=0xffff;
	unsigned long dwCurSize=0;
	
	unsigned char*pCmpData=pCompressed;
	while(pData<pDataEnd)
	{
		ubOldData=*pData;
		dwRepCount=1;
		pData++;
		while(pData<pDataEnd)
		{
			if(ubOldData!=*pData)
				break;
			if(dwRepCount>=0x7F)
				break;
			dwRepCount++;
			pData++;
		}
		if(1 != dwRepCount)
		{
			dwCurSize+=2;
			if(dwCurSize>=dwMaxSize)
			{
				dwMaxSize+=0xffff;
				unsigned char*pNewAddr=(unsigned char*)realloc(pCompressed,dwMaxSize);
				if(!pNewAddr)
				{
					free(pCompressed);
					return false;
				}
				pCompressed=pNewAddr;
				pCmpData=pNewAddr+dwCurSize-2;			
			}
			*pCmpData=(unsigned char)(0x80|dwRepCount);
			pCmpData++;
			*pCmpData=ubOldData;
			pCmpData++;
		}
		else
		{
			pTempAddr=pCmpData;
			pCmpData++;		
			dwCurSize++;
			if(dwCurSize+0x80>=dwMaxSize)
			{
				dwMaxSize+=0xffff;
				unsigned char*pNewAddr=(unsigned char*)realloc(pCompressed,dwMaxSize);
				if(!pNewAddr)
				{
					free(pCompressed);
					return false;
				}
				pCompressed=pNewAddr;
				pCmpData=pNewAddr+dwCurSize+1;
				pTempAddr=pCmpData-1;
			}
			while(pData<pDataEnd)
			{
				if(dwRepCount>=0x7F)
					break;
				if(ubOldData==*pData)
				{
					dwRepCount--;
					pData--;
					break;
				}
				*pCmpData=ubOldData;
				pCmpData++;
				ubOldData=*pData;
				pData++;
				dwRepCount++;
			}
			dwCurSize+=dwRepCount;
			*pTempAddr=(unsigned char)dwRepCount;
		}
	}
	*ppCompressData=realloc(pCompressed,dwCurSize);
	dwCompressedDataSize=dwCurSize;
	
	return true;	
}
bool GCompress8BitRLE::DecompressAutoSize(void*pCompressedData,unsigned long dwCompressedDataSize,void**ppOrgData,unsigned long & dwOrgDataSize)
{
	unsigned char*pData=(unsigned char*)pCompressedData;
	unsigned char*pDataEnd=pData+dwCompressedDataSize;
	unsigned long dwRepCount;
	
	unsigned char*pOrg=(unsigned char*)malloc(dwCompressedDataSize);
	if(!pOrg)
		return false;
	
	unsigned long dwMaxSize=dwCompressedDataSize;
	unsigned long dwCurSize=0;
	
	unsigned char*pOrgData=pOrg;
	while(pData<pDataEnd)
	{
		dwRepCount=(*pData & 0x7f);
		dwCurSize+=dwRepCount; 
		if(dwCurSize >= dwMaxSize)
		{
			dwMaxSize+=dwCompressedDataSize;
			unsigned char*pNewAddr=(unsigned char*)realloc(pOrg,dwMaxSize);
			if(!pNewAddr)
			{
				free(pOrg);
				return false;
			}
			pOrg=pNewAddr;
			pOrgData=pNewAddr+dwCurSize-dwRepCount;
		}
		if(0x80 & *pData)
		{
			pData++;
			for(unsigned int i=0;i<dwRepCount;i++)
			{
				*pOrgData=*pData;
				pOrgData++;
			}
			pData++;
		}
		else
		{
			pData++;
			for(unsigned int i=0;i<dwRepCount;i++)
			{
				*pOrgData=*pData;
				pData++;
				pOrgData++;
			}
		}
	}
	*ppOrgData=realloc(pOrg,dwCurSize);
	dwOrgDataSize=dwCurSize;
	
	return true;
}
bool GCompress8BitRLE::Decompress(void*pCompressedData,unsigned long dwCompressedDataSize,void*pDestAddr)
{
	unsigned char*pData=(unsigned char*)pCompressedData;
	unsigned char*pDataEnd=pData+dwCompressedDataSize;
	unsigned long dwRepCount;	
	unsigned char*pOrgData=(unsigned char*)pDestAddr;
	while(pData<pDataEnd)
	{
		dwRepCount=(*pData & 0x7f);
		if(0x80 & *pData)
		{
			pData++;
			for(unsigned int i=0;i<dwRepCount;i++)
			{
				*pOrgData=*pData;
				pOrgData++;
			}
			pData++;
		}
		else
		{
			pData++;
			for(unsigned int i=0;i<dwRepCount;i++)
			{
				*pOrgData=*pData;
				pData++;
				pOrgData++;
			}
		}
	}	
	return true;
}
bool GCompress16BitRLE::Compress(void*pOrgData,unsigned long dwOrgDataSize,void**ppCompressData,unsigned long & dwCompressedDataSize)
{
	unsigned short*pData=(unsigned short*)pOrgData;
	unsigned short*pDataEnd=pData+dwOrgDataSize;
	unsigned char*pTempAddr;
	unsigned short ubOldData;
	unsigned long dwRepCount;
	
	unsigned char*pCompressed=(unsigned char*)malloc(0xffff);
	if(!pCompressed)
		return false;
	memset(pCompressed,0,0xffff);
	unsigned long dwMaxSize=0xffff;
	unsigned long dwCurSize=0;
	
	unsigned char*pCmpData=pCompressed;
	while(pData<pDataEnd)
	{
		ubOldData=*pData;
		dwRepCount=1;
		pData++;
		while(pData<pDataEnd)
		{
			if(ubOldData!=*pData)
				break;
			if(dwRepCount>=0x7F)
				break;
			dwRepCount++;
			pData++;
		}
		if(1 != dwRepCount)
		{
			dwCurSize+=3;
			if(dwCurSize>=dwMaxSize)
			{
				dwMaxSize+=0xffff;
				unsigned char*pNewAddr=(unsigned char*)realloc(pCompressed,dwMaxSize);
				if(!pNewAddr)
				{
					free(pCompressed);
					return false;
				}
				pCompressed=pNewAddr;
				pCmpData=pNewAddr+dwCurSize-3;			
			}
			*pCmpData=(unsigned char)(0x80|dwRepCount);
			pCmpData++;
			*((unsigned short*)pCmpData)=ubOldData;
			pCmpData+=2;
		}
		else
		{
			pTempAddr=pCmpData;
			pCmpData++;		
			dwCurSize++;
			if(dwCurSize+0x100>=dwMaxSize)
			{
				dwMaxSize+=0xffff;
				unsigned char*pNewAddr=(unsigned char*)realloc(pCompressed,dwMaxSize);
				if(!pNewAddr)
				{
					free(pCompressed);
					return false;
				}
				pCompressed=pNewAddr;
				pCmpData=pNewAddr+dwCurSize+1;
				pTempAddr=pCmpData-1;
			}
			while(pData<pDataEnd)
			{
				if(dwRepCount>=0x7F)
					break;
				if(ubOldData==*pData)
				{
					dwRepCount--;
					pData--;
					break;
				}
				*((unsigned short*)pCmpData)=ubOldData;
				pCmpData+=2;
				ubOldData=*pData;
				pData++;
				dwRepCount++;
			}
			dwCurSize+=dwRepCount<<1;
			*pTempAddr=(unsigned char)dwRepCount;
		}
	}
	*ppCompressData=realloc(pCompressed,dwCurSize);
	dwCompressedDataSize=dwCurSize;
	
	return true;	
}
bool GCompress16BitRLE::DecompressAutoSize(void*pCompressedData,unsigned long dwCompressedDataSize,void**ppOrgData,unsigned long & dwOrgDataSize)
{
	unsigned char*pData=(unsigned char*)pCompressedData;
	unsigned char*pDataEnd=pData+dwCompressedDataSize;
	unsigned long dwRepCount;
	
	unsigned short*pOrg=(unsigned short*)malloc(dwCompressedDataSize<<1);
	if(!pOrg)
		return false;
	
	unsigned long dwMaxSize=dwCompressedDataSize;
	unsigned long dwCurSize=0;
	
	unsigned short*pOrgData=pOrg;
	while(pData<pDataEnd)
	{
		dwRepCount=(*pData & 0x7f);
		dwCurSize+=dwRepCount; 
		if(dwCurSize >= dwMaxSize)
		{
			dwMaxSize+=dwCompressedDataSize;
			unsigned short*pNewAddr=(unsigned short*)realloc(pOrg,dwMaxSize<<1);
			if(!pNewAddr)
			{
				free(pOrg);
				return false;
			}
			pOrg=pNewAddr;
			pOrgData=pNewAddr+dwCurSize-dwRepCount;
		}
		if(0x80 & *pData)
		{
			pData++;
			for(unsigned int i=0;i<dwRepCount;i++)
			{
				*pOrgData=*((unsigned short*)pData);
				pOrgData++;
			}
			pData+=2;
		}
		else
		{
			pData++;
			for(unsigned int i=0;i<dwRepCount;i++)
			{
				*pOrgData=*((unsigned short*)pData);
				pData+=2;
				pOrgData++;
			}
		}
	}
	*ppOrgData=realloc(pOrg,dwCurSize<<1);
	dwOrgDataSize=dwCurSize;
	
	return true;
}
bool GCompress16BitRLE::Decompress(void*pCompressedData,unsigned long dwCompressedDataSize,void*pDestAddr)
{
	unsigned char*pData=(unsigned char*)pCompressedData;
	unsigned char*pDataEnd=pData+dwCompressedDataSize;
	unsigned long dwRepCount;
	unsigned short*pOrgData=(unsigned short*)pDestAddr;
	while(pData<pDataEnd)
	{
		dwRepCount=(*pData & 0x7f);
		if(0x80 & *pData)
		{
			pData++;
			for(unsigned int i=0;i<dwRepCount;i++)
			{
				*pOrgData=*((unsigned short*)pData);
				pOrgData++;
			}
			pData+=2;
		}
		else
		{
			pData++;
			for(unsigned int i=0;i<dwRepCount;i++)
			{