183 lines
3.5 KiB
C++
183 lines
3.5 KiB
C++
#include "scene.h"
|
|
|
|
#include "LZO\miniLZO.h"
|
|
|
|
|
|
int LZWMakeCompression(u8 *source, int lenght, u8 *dest);
|
|
int LZWMakeDecompression(u8 *source, int lenghtRes, u8 *dest);
|
|
#define ZIPBUFSIZE (8192)
|
|
u8 ZIPBUF[ZIPBUFSIZE + 256];
|
|
u8 LZOWRK[LZO1X_1_MEM_COMPRESS];
|
|
static u32 LZO_IsInit = 0;
|
|
u32 ZIPBufP = 0;
|
|
u32 ZIPBufS = 0;
|
|
u32 ZIPBufMETHOD = 0;
|
|
|
|
|
|
int COMPRESS(u8 *source, int lenght, u8 *dest)
|
|
{
|
|
if (!LZO_IsInit) lzo_init();
|
|
LZO_IsInit = 0;
|
|
|
|
switch (ZIPBufMETHOD)
|
|
{
|
|
case 0:// No compression
|
|
memcpy(dest,source,lenght);
|
|
return lenght;
|
|
case 1:// Yousri compression
|
|
return LZWMakeCompression(source, lenght, dest);
|
|
case 2:
|
|
lzo_uint Dst;
|
|
lzo1x_1_compress( source, lenght , dest , &Dst , LZOWRK );
|
|
return Dst;
|
|
}
|
|
return 0;
|
|
}
|
|
int UNCOMPRESS(u8 *source, int lenght, u8 *dest)
|
|
{
|
|
if (!LZO_IsInit) lzo_init();
|
|
LZO_IsInit = 0;
|
|
|
|
switch (ZIPBufMETHOD)
|
|
{
|
|
case 0:// No decompression
|
|
memcpy(dest,source,lenght);
|
|
return lenght;
|
|
case 1:// Yousri decompression
|
|
return LZWMakeDecompression(source, lenght, dest);
|
|
case 2:
|
|
lzo_uint Dst;
|
|
lzo1x_decompress( source , lenght , dest , &Dst , NULL);//*/
|
|
return Dst;
|
|
//lzo_uint
|
|
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
//#define COMP_TEST
|
|
u32 ZIPMODEW = 0;
|
|
u32 ZIPFlush(FILE *DST)
|
|
{
|
|
|
|
if (!LZO_IsInit) lzo_init();
|
|
LZO_IsInit = 0;
|
|
|
|
u8 CompB[ZIPBUFSIZE+256];
|
|
u32 Size;
|
|
Size = COMPRESS((u8*)ZIPBUF, ZIPBufP, CompB);
|
|
#ifdef COMP_TEST
|
|
u8 DECOMPTEST[ZIPBUFSIZE+256];
|
|
u8 DECOMPTESTS[ZIPBUFSIZE+256];
|
|
u32 TESTSIZE;
|
|
memset(DECOMPTEST,0,sizeof(DECOMPTEST));
|
|
memset(DECOMPTESTS,0,sizeof(DECOMPTESTS));
|
|
memcpy(DECOMPTESTS,CompB,Size);
|
|
UNCOMPRESS((u8*)DECOMPTESTS, Size, DECOMPTEST);
|
|
TESTSIZE = memcmp(ZIPBUF,DECOMPTEST,ZIPBufP);
|
|
if (TESTSIZE != 0)
|
|
*(u32 *)0 = *(u32 *)4;// ABSOLUTE CRASH
|
|
#endif
|
|
fwrite(&Size,1,4,DST);
|
|
fwrite(CompB,1,Size,DST);
|
|
return 0;
|
|
}
|
|
|
|
u32 ZIPWrite(const void *bufVOID,u32 sizeT,u32 sizeW,FILE *DST)
|
|
{
|
|
if (!LZO_IsInit) lzo_init();
|
|
LZO_IsInit = 0;
|
|
|
|
|
|
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(DST);
|
|
ZIPBufP = 0;
|
|
}
|
|
|
|
memcpy(ZIPBUF+ZIPBufP,bufu8,size);
|
|
ZIPBufP += size;
|
|
return 1;
|
|
}
|
|
|
|
|
|
u32 ZIPRead(void *bufVOID,u32 sizeT,u32 sizeW,FILE *DST)
|
|
{
|
|
|
|
if (!LZO_IsInit) lzo_init();
|
|
LZO_IsInit = 0;
|
|
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,DST) == 4)
|
|
{
|
|
if (fread(CompB,1,CompSize,DST) == CompSize)
|
|
{
|
|
DECompSize = UNCOMPRESS((u8*)CompB, CompSize, (u8*)ZIPBUF);
|
|
} else
|
|
DECompSize = 0;
|
|
}
|
|
ZIPBufS = DECompSize;
|
|
if (!DECompSize)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
return SizeBase - size;
|
|
}
|
|
u32 ZIPClose(FILE *DST)
|
|
{
|
|
if (ZIPMODEW == 1)
|
|
{
|
|
// flush
|
|
ZIPFlush(DST);
|
|
}
|
|
ZIPMODEW = ZIPBufP = 0;
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 0 = No compression
|
|
// 1 = yousri
|
|
// 2 = LZO
|
|
void ZIPSetMode(u32 Mode)
|
|
{
|
|
ZIPBufMETHOD = Mode;
|
|
}
|