1 files changed, 149 insertions, 0 deletions
diff --git a/contrib/testzlib/testzlib.c b/contrib/testzlib/testzlib.c
new file mode 100644
index 0000000..caae4ef
--- /dev/null
+++ b/contrib/testzlib/testzlib.c
@@ -0,0 +1,149 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <windows.h>
+#include "zlib.h"
+int ReadFileMemory(const char* filename,long* plFileSize,void** pFilePtr)
+{
+    FILE* stream;
+    void* ptr;
+    int retVal=1;
+    stream=fopen(filename, "rb");
+    if (stream==NULL)
+        return 0;
+    fseek(stream,0,SEEK_END);
+    *plFileSize=ftell(stream);
+    fseek(stream,0,SEEK_SET);
+    ptr=malloc((*plFileSize)+1);
+    if (ptr==NULL)
+        retVal=0;
+    else
+    {
+        if (fread(ptr, 1, *plFileSize,stream) != (*plFileSize))
+            retVal=0;
+    }
+    fclose(stream);
+    *pFilePtr=ptr;
+    return retVal;
+}
+int main(int argc, char *argv[])
+{
+    int BlockSizeCompress=0x8000;
+    int BlockSizeUncompress=0x8000;
+    int cprLevel=Z_DEFAULT_COMPRESSION ;
+    long lFileSize;
+    unsigned char* FilePtr;
+    long lBufferSizeCpr;
+    long lBufferSizeUncpr;
+    long lCompressedSize=0;
+    unsigned char* CprPtr;
+    unsigned char* UncprPtr;
+    long lSizeCpr,lSizeUncpr;
+    DWORD dwGetTick;
+    if (argc<=1)
+    {
+        printf("run TestZlib <File> [BlockSizeCompress] [BlockSizeUncompress] [compres. level]\n");
+        return 0;
+    }
+    if (ReadFileMemory(argv[1],&lFileSize,&FilePtr)==0)
+    {
+        printf("error reading %s\n",argv[1]);
+        return 1;
+    }
+    else printf("file %s read, %u bytes\n",argv[1],lFileSize);
+    if (argc>=3)
+        BlockSizeCompress=atol(argv[2]);
+    if (argc>=4)
+        BlockSizeUncompress=atol(argv[3]);
+    if (argc>=5)
+        cprLevel=(int)atol(argv[4]);
+    lBufferSizeCpr = lFileSize + (lFileSize/0x10) + 0x200;
+    lBufferSizeUncpr = lBufferSizeCpr;
+    CprPtr=(unsigned char*)malloc(lBufferSizeCpr + BlockSizeCompress);
+    UncprPtr=(unsigned char*)malloc(lBufferSizeUncpr + BlockSizeUncompress);
+    dwGetTick=GetTickCount();
+    {
+        z_stream zcpr;
+        int ret=Z_OK;
+        long lOrigToDo = lFileSize;
+        long lOrigDone = 0;
+        int step=0;
+        memset(&zcpr,0,sizeof(z_stream));
+        deflateInit(&zcpr,cprLevel);
+        zcpr.next_in = FilePtr;
+        zcpr.next_out = CprPtr;
+        do
+        {
+            long all_read_before = zcpr.total_in;
+            zcpr.avail_in = min(lOrigToDo,BlockSizeCompress);
+            zcpr.avail_out = BlockSizeCompress;
+            ret=deflate(&zcpr,(zcpr.avail_in==lOrigToDo) ? Z_FINISH : Z_SYNC_FLUSH);
+            lOrigDone += (zcpr.total_in-all_read_before);
+            lOrigToDo -= (zcpr.total_in-all_read_before);
+            step++;
+        } while (ret==Z_OK);
+        lSizeCpr=zcpr.total_out;
+        deflateEnd(&zcpr);
+        dwGetTick=GetTickCount()-dwGetTick;
+        printf("total compress size = %u, in %u step\n",lSizeCpr,step);
+        printf("time = %u msec = %f sec\n\n",dwGetTick,dwGetTick/(double)1000.);
+    }
+    dwGetTick=GetTickCount();
+    {
+        z_stream zcpr;
+        int ret=Z_OK;
+        long lOrigToDo = lSizeCpr;
+        long lOrigDone = 0;
+        int step=0;
+        memset(&zcpr,0,sizeof(z_stream));
+        inflateInit(&zcpr);
+        zcpr.next_in = CprPtr;
+        zcpr.next_out = UncprPtr;
+        do
+        {
+            long all_read_before = zcpr.total_in;
+            zcpr.avail_in = min(lOrigToDo,BlockSizeUncompress);
+            zcpr.avail_out = BlockSizeUncompress;
+            ret=inflate(&zcpr,Z_SYNC_FLUSH);
+            lOrigDone += (zcpr.total_in-all_read_before);
+            lOrigToDo -= (zcpr.total_in-all_read_before);
+            step++;
+        } while (ret==Z_OK);
+        lSizeUncpr=zcpr.total_out;
+        inflateEnd(&zcpr);
+        dwGetTick=GetTickCount()-dwGetTick;
+        printf("total uncompress size = %u, in %u step\n",lSizeUncpr,step);
+        printf("time = %u msec = %f sec\n\n",dwGetTick,dwGetTick/(double)1000.);
+    }
+    if (lSizeUncpr==lFileSize)
+    {
+        if (memcmp(FilePtr,UncprPtr,lFileSize)==0)
+            printf("compare ok\n");
+    }
+    return 0;
+}

diff --git a/contrib/testzlib/testzlib.c b/contrib/testzlib/testzlib.c new file mode 100644 index 0000000..caae4ef --- /dev/null +++ b/contrib/testzlib/testzlib.c
@@ -0,0 +1,149 @@
	1
	2	#include <stdio.h>
	3	#include <stdlib.h>
	4	#include <windows.h>
	5	#include "zlib.h"
	6
	7	int ReadFileMemory(const char* filename,long* plFileSize,void** pFilePtr)
	8	{
	9	FILE* stream;
	10	void* ptr;
	11	int retVal=1;
	12	stream=fopen(filename, "rb");
	13	if (stream==NULL)
	14	return 0;
	15
	16	fseek(stream,0,SEEK_END);
	17
	18	*plFileSize=ftell(stream);
	19	fseek(stream,0,SEEK_SET);
	20	ptr=malloc((*plFileSize)+1);
	21	if (ptr==NULL)
	22	retVal=0;
	23	else
	24	{
	25	if (fread(ptr, 1, plFileSize,stream) != (plFileSize))
	26	retVal=0;
	27	}
	28	fclose(stream);
	29	*pFilePtr=ptr;
	30	return retVal;
	31	}
	32
	33	int main(int argc, char *argv[])
	34	{
	35	int BlockSizeCompress=0x8000;
	36	int BlockSizeUncompress=0x8000;
	37	int cprLevel=Z_DEFAULT_COMPRESSION ;
	38	long lFileSize;
	39	unsigned char* FilePtr;
	40	long lBufferSizeCpr;
	41	long lBufferSizeUncpr;
	42	long lCompressedSize=0;
	43	unsigned char* CprPtr;
	44	unsigned char* UncprPtr;
	45	long lSizeCpr,lSizeUncpr;
	46	DWORD dwGetTick;
	47
	48	if (argc<=1)
	49	{
	50	printf("run TestZlib <File> [BlockSizeCompress] [BlockSizeUncompress] [compres. level]\n");
	51	return 0;
	52	}
	53
	54	if (ReadFileMemory(argv[1],&lFileSize,&FilePtr)==0)
	55	{
	56	printf("error reading %s\n",argv[1]);
	57	return 1;
	58	}
	59	else printf("file %s read, %u bytes\n",argv[1],lFileSize);
	60
	61	if (argc>=3)
	62	BlockSizeCompress=atol(argv[2]);
	63
	64	if (argc>=4)
	65	BlockSizeUncompress=atol(argv[3]);
	66
	67	if (argc>=5)
	68	cprLevel=(int)atol(argv[4]);
	69
	70	lBufferSizeCpr = lFileSize + (lFileSize/0x10) + 0x200;
	71	lBufferSizeUncpr = lBufferSizeCpr;
	72
	73	CprPtr=(unsigned char*)malloc(lBufferSizeCpr + BlockSizeCompress);
	74	UncprPtr=(unsigned char*)malloc(lBufferSizeUncpr + BlockSizeUncompress);
	75
	76	dwGetTick=GetTickCount();
	77	{
	78	z_stream zcpr;
	79	int ret=Z_OK;
	80	long lOrigToDo = lFileSize;
	81	long lOrigDone = 0;
	82	int step=0;
	83	memset(&zcpr,0,sizeof(z_stream));
	84	deflateInit(&zcpr,cprLevel);
	85
	86	zcpr.next_in = FilePtr;
	87	zcpr.next_out = CprPtr;
	88
	89
	90	do
	91	{
	92	long all_read_before = zcpr.total_in;
	93	zcpr.avail_in = min(lOrigToDo,BlockSizeCompress);
	94	zcpr.avail_out = BlockSizeCompress;
	95	ret=deflate(&zcpr,(zcpr.avail_in==lOrigToDo) ? Z_FINISH : Z_SYNC_FLUSH);
	96	lOrigDone += (zcpr.total_in-all_read_before);
	97	lOrigToDo -= (zcpr.total_in-all_read_before);
	98	step++;
	99	} while (ret==Z_OK);
	100
	101	lSizeCpr=zcpr.total_out;
	102	deflateEnd(&zcpr);
	103	dwGetTick=GetTickCount()-dwGetTick;
	104	printf("total compress size = %u, in %u step\n",lSizeCpr,step);
	105	printf("time = %u msec = %f sec\n\n",dwGetTick,dwGetTick/(double)1000.);
	106	}
	107
	108	dwGetTick=GetTickCount();
	109	{
	110	z_stream zcpr;
	111	int ret=Z_OK;
	112	long lOrigToDo = lSizeCpr;
	113	long lOrigDone = 0;
	114	int step=0;
	115	memset(&zcpr,0,sizeof(z_stream));
	116	inflateInit(&zcpr);
	117
	118	zcpr.next_in = CprPtr;
	119	zcpr.next_out = UncprPtr;
	120
	121
	122	do
	123	{
	124	long all_read_before = zcpr.total_in;
	125	zcpr.avail_in = min(lOrigToDo,BlockSizeUncompress);
	126	zcpr.avail_out = BlockSizeUncompress;
	127	ret=inflate(&zcpr,Z_SYNC_FLUSH);
	128	lOrigDone += (zcpr.total_in-all_read_before);
	129	lOrigToDo -= (zcpr.total_in-all_read_before);
	130	step++;
	131	} while (ret==Z_OK);
	132
	133	lSizeUncpr=zcpr.total_out;
	134	inflateEnd(&zcpr);
	135	dwGetTick=GetTickCount()-dwGetTick;
	136	printf("total uncompress size = %u, in %u step\n",lSizeUncpr,step);
	137	printf("time = %u msec = %f sec\n\n",dwGetTick,dwGetTick/(double)1000.);
	138	}
	139
	140	if (lSizeUncpr==lFileSize)
	141	{
	142	if (memcmp(FilePtr,UncprPtr,lFileSize)==0)
	143	printf("compare ok\n");
	144
	145	}
	146
	147	return 0;
	148
	149	}