JD2022-TU1/main/extern/Camcam/CCZip/CCZip.cpp

// CCZip.cpp : Defines the entry point for the DLL application.
//

#include "windows.h"
#include "CCZip.h"
#include "stdlib.h"
#include "LZO\miniLZO.h"


#ifdef _MANAGED
#pragma managed(push, off)
#endif

#ifdef CCZIP_DLL_MODE
BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
					 )
{
	switch (ul_reason_for_call)
	{
	case DLL_PROCESS_ATTACH:
	case DLL_THREAD_ATTACH:
	case DLL_THREAD_DETACH:
	case DLL_PROCESS_DETACH:
		break;
	}
    return TRUE;
}
#endif

#ifdef _MANAGED
#pragma managed(pop)
#endif


#ifndef __DEFINE_NUMS__
#define __DEFINE_NUMS__

#define f32 float
#define u32 unsigned int
#define s32 int
#define u16 unsigned short
#define s16 signed short
#define u8 unsigned char
#define s8 char

#endif


CCZip::CCZip()
{
	memset(this, 0, sizeof(*this));
	ZIPBUF = (char *)malloc(ZIPBUFSIZE + 256);
	LZOWRK = (char *)malloc(LZO1X_1_MEM_COMPRESS);
	ZIPBufMETHOD = 2;
}
CCZip::~CCZip()
{
	if (ZIPBUF) free(ZIPBUF);
	if (LZOWRK) free(LZOWRK);
}


int CCZip::COMPRESS(u8 *source, int lenght, u8 *dest)
{
	lzo_init();

	switch (ZIPBufMETHOD)
	{
		case 0:// No compression
			memcpy(dest,source,lenght);
			return lenght;
		case 2:
			lzo_uint Dst;
			lzo1x_1_compress( source, lenght , dest , &Dst , LZOWRK );
			return Dst;
	}
	return 0;
}

int CCZip::UNCOMPRESS(u8 *source, int lenght, u8 *dest)
{
	lzo_init();

	switch (ZIPBufMETHOD)
	{
		case 0:// No decompression
			memcpy(dest,source,lenght);
			return lenght;
		case 2:
			lzo_uint Dst;
			lzo1x_decompress( source , lenght , dest , &Dst , NULL);//*/
			return Dst;
			//lzo_uint

	}
	return 0;
}


u32 CCZip::ZIPOpen(char *filename, char *fileattr, u32 *version, u32 *compression)
{
	ZIPFILE = fopen(filename, fileattr);
	if (!ZIPFILE) return 0;
	if (version != NULL && compression != NULL)
	{
		if (*fileattr == 'w')
		{
			fwrite(version,1,4,ZIPFILE); 
			fwrite(compression,1,4,ZIPFILE);
		}
		if (*fileattr == 'r')
		{
			fread(version,1,4,ZIPFILE); 
			fread(compression,1,4,ZIPFILE);
		}
	}
	return ZIPFILE != NULL;
}

u32 CCZip::ZIPFlush()
{
	lzo_init();

	u8 CompB[ZIPBUFSIZE+256];
	u32 Size;
	Size = COMPRESS((u8*)ZIPBUF, ZIPBufP, CompB);
	fwrite(&Size,1,4,ZIPFILE);
	fwrite(CompB,1,Size,ZIPFILE);
	return 0;
}

u32 CCZip::ZIPWrite(const void *bufVOID,u32 sizeT,u32 sizeW)
{
	lzo_init();

	u8 *bufu8;
	bufu8 = (u8 *)bufVOID;
	if (ZIPMODEW == 0) ZIPMODEW = 1;
	if (ZIPMODEW == 2) return 0;
	ZIPMODEW = 1;
	u32 size = sizeT * sizeW;

	while (ZIPBufP+size > ZIPBUFSIZE)
	{
		u32 LocalSize;
		LocalSize = ZIPBUFSIZE - ZIPBufP;
		memcpy(ZIPBUF+ZIPBufP,bufu8,LocalSize);
		bufu8 += LocalSize;
		size -= LocalSize;
		ZIPBufP += LocalSize;
		ZIPFlush();
		ZIPBufP = 0;
	}
	
	memcpy(ZIPBUF+ZIPBufP,bufu8,size);
	ZIPBufP += size;
	return 1;
}


u32 CCZip::ZIPRead(void *bufVOID,u32 sizeT,u32 sizeW)
{
	lzo_init();
	memset(bufVOID,0,sizeT * sizeW);

	u8 *bufu8 = (u8 *)bufVOID;
	if (ZIPMODEW == 0) {ZIPBufS = 0;ZIPMODEW = 2;ZIPBufP = 0;};
	if (ZIPMODEW == 1) return 0;

	u32 size = sizeT * sizeW;
	u32 FlushS;
	u32 SizeBase = size;
	while (size)
	{
		FlushS = ZIPBufS;
		if (FlushS > size) FlushS = size;
		memcpy(bufu8,ZIPBUF + ZIPBufP,FlushS);
		size -= FlushS;
		ZIPBufP += FlushS;
		ZIPBufS -= FlushS;
		bufu8+=FlushS;
		if (size)
		{
			/* recompute ZIPBUF */
			u32 CompSize,DECompSize;
			u8 CompB[ZIPBUFSIZE+256];
			ZIPBufP = 0;
			DECompSize = 0;
			if (fread(&CompSize,1,4,ZIPFILE) == 4)
			{
				if (fread(CompB,1,CompSize,ZIPFILE) == CompSize)
				{
					DECompSize = UNCOMPRESS((u8*)CompB, CompSize, (u8*)ZIPBUF);
				} else
					DECompSize = 0;
			} 
			ZIPBufS = DECompSize;
			if (!DECompSize) 
			{
				return 0;
			}
		}
	}
	return SizeBase - size;
}
u32 CCZip::ZIPClose()
{
	if (ZIPMODEW == 1)
	{
		// flush  
		ZIPFlush();
	}
	ZIPMODEW = ZIPBufP = 0;
	fclose(ZIPFILE);
	ZIPFILE = NULL;
	return 0;
}


// 0 = No compression
// 2 = LZO
void CCZip::ZIPSetMode(u32 Mode)
{
	ZIPBufMETHOD = Mode;
}