ltest.c

lzo-1.08-src.zip 高效的压缩解压代码

	my_clock_t t_time = 0, c_time = 0, d_time = 0;
	my_clock_t t_start, c_start, d_start;
#ifdef USE_DUMP
	FILE *dump = NULL;

	if (opt_dump_compressed_data)
		dump = fopen(opt_dump_compressed_data,"wb");
#endif

/* process the file */

	t_start = my_clock();
	for (i = 0; i < t_loops; i++)
	{
		lzo_uint len, c_len, c_len_max, d_len = 0;
		lzo_byte *d = data;

		len = l;
		c_len = 0;
		blocks = 0;

		/* process blocks */
		if (len > 0 || opt_try_to_compress_0_bytes) do
		{
			int j;
			int r;

			const lzo_uint bl = len > opt_block_size ? opt_block_size : len;
			lzo_uint bl_overwrite = bl;
#if defined(__LZO_CHECKER)
			lzo_byte *dd = NULL;
			lzo_byte *b1 = NULL;
			lzo_byte *b2 = NULL;
			const lzo_uint b1_len = bl + bl / 64 + 16 + 3;
#else
			lzo_byte * const dd = d;
			lzo_byte * const b1 = block1;
			lzo_byte * const b2 = block2;
			const lzo_uint b1_len = sizeof(_block1) - 256;
			unsigned char random_byte;
			random_byte = (unsigned char) my_clock();
#endif

			blocks++;

			/* may overwrite 3 bytes past the end of the decompressed block */
			if (opt_use_asm_fast_decompressor)
				bl_overwrite += (lzo_uint) sizeof(int) - 1;

#if defined(__LZO_CHECKER)
			/* malloc a block of the exact size to detect any overrun */
			dd = malloc(bl_overwrite > 0 ? bl_overwrite : 1);
			b1 = malloc(b1_len);
			b2 = dd;
			if (dd == NULL || b1 == NULL)
			{
				perror("malloc");
				return EXIT_MEM;
			}
			if (bl > 0)
				memcpy(dd,d,bl);
#endif

		/* compress the block */
			c_len = c_len_max = 0;
			c_start = my_clock();
			for (j = r = 0; r == 0 && j < c_loops; j++)
			{
				c_len = b1_len;
				r = do_compress(c,dd,bl,b1,&c_len);
				if (r == 0 && c_len > c_len_max)
					c_len_max = c_len;
			}
			c_time += my_clock() - c_start;
			if (r != 0)
			{
				printf("  compression failed in block %d (%d) (%lu %lu)\n",
					blocks, r, (long)c_len, (long)bl);
				return EXIT_LZO_ERROR;
			}

		/* optimize the block */
			if (opt_optimize_compressed_data)
			{
				d_len = bl;
				r = do_optimize(c,b1,c_len,b2,&d_len);
				if (r != 0 || d_len != bl)
				{
					printf("  optimization failed in block %d (%d) "
						"(%lu %lu %lu)\n", blocks, r,
						(long)c_len, (long)d_len, (long)bl);
					return EXIT_LZO_ERROR;
				}
			}

#ifdef USE_DUMP
			/* dump compressed data to disk */
			if (dump)
			{
				lzo_fwrite(dump,b1,c_len);
				fflush(dump);
			}
#endif

		/* decompress the block and verify */
#if defined(__LZO_CHECKER)
			lzo_memset(b2,0,bl_overwrite);
#else
			init_mem_checker(b2,_block2,bl_overwrite,random_byte);
#endif
			d_start = my_clock();
			for (j = r = 0; r == 0 && j < d_loops; j++)
			{
				d_len = bl;
				r = do_decompress(c,decompress,b1,c_len,b2,&d_len);
				if (d_len != bl)
					break;
			}
			d_time += my_clock() - d_start;
			if (r != 0)
			{
				printf("  decompression failed in block %d (%d) "
					"(%lu %lu %lu)\n", blocks, r,
					(long)c_len, (long)d_len, (long)bl);
				return EXIT_LZO_ERROR;
			}
			if (d_len != bl)
			{
				printf("  decompression size error in block %d (%lu %lu %lu)\n",
					blocks, (long)c_len, (long)d_len, (long)bl);
				return EXIT_LZO_ERROR;
			}
			if (is_compressor(c))
			{
				if (lzo_memcmp(d,b2,bl) != 0)
				{
					lzo_uint x = 0;
					while (x < bl && b2[x] == d[x])
						x++;
					printf("  decompression data error in block %d at offset "
						"%lu (%lu %lu)\n", blocks, (long)x,
						(long)c_len, (long)d_len);
					if (opt_compute_adler32)
						printf("      checksum: 0x%08lx 0x%08lx\n",
							(long)adler_in, (long)adler_out);
#if 0
					printf("Orig:  ");
					r = (x >= 10) ? -10 : 0 - (int) x;
					for (j = r; j <= 10 && x + j < bl; j++)
						printf(" %02x", (int)d[x+j]);
					printf("\nDecomp:");
					for (j = r; j <= 10 && x + j < bl; j++)
						printf(" %02x", (int)b2[x+j]);
					printf("\n");
#endif
					return EXIT_LZO_ERROR;
				}
				if ((opt_compute_adler32 && adler_in != adler_out) ||
				    (opt_compute_crc32 && crc_in != crc_out))
				{
					printf("  checksum error in block %d (%lu %lu)\n",
						blocks, (long)c_len, (long)d_len);
					printf("      adler32: 0x%08lx 0x%08lx\n",
						(long)adler_in, (long)adler_out);
					printf("      crc32: 0x%08lx 0x%08lx\n",
						(long)crc_in, (long)crc_out);
					return EXIT_LZO_ERROR;
				}
			}

#if defined(__LZO_CHECKER)
			/* free in reverse order of allocations */
			free(b1);
			free(dd);
#else
			if (check_mem(b2,_block2,bl_overwrite,random_byte) != 0)
			{
				printf("  decompression overwrite error in block %d "
					"(%lu %lu %lu)\n",
					blocks, (long)c_len, (long)d_len, (long)bl);
				return EXIT_LZO_ERROR;
			}
#endif

			d += bl;
			len -= bl;
			compressed_len += c_len_max;
		}
		while (len > 0);
	}
	t_time += my_clock() - t_start;

#ifdef USE_DUMP
	if (dump)
		fclose(dump);
	opt_dump_compressed_data = NULL;	/* only dump the first file */
#endif

	print_stats(method_name, file_name,
	            t_loops, c_loops, d_loops,
	            t_time, c_time, d_time,
	            compressed_len, l, blocks);

	return EXIT_OK;
}




static
int do_file ( int method, const char *file_name,
              int c_loops, int d_loops,
              lzo_uint32 *p_adler, lzo_uint32 *p_crc )
{
	int r;
	const compress_t *c;
	lzo_decompress_t decompress;
	lzo_uint l;
	lzo_uint32 adler, crc;
	char method_name[32];
	const char *n;
	const int t_loops = 1;
	lzo_byte *saved_dict = dict;
	lzo_uint saved_dict_len = dict_len;

	adler_in = adler_out = 0;
	crc_in = crc_out = 0;
	if (p_adler)
		*p_adler = 0;
	if (p_crc)
		*p_crc = 0;

	c = info(method,NULL);
	if (c == NULL || c->name == NULL || c->compress == NULL)
		return EXIT_INTERNAL;
	decompress = get_decomp_info(c,&n);
	if (!decompress || n == NULL || WRK_LEN < c->mem_decompress)
		return EXIT_INTERNAL;
	strcpy(method_name,c->name);
	strcat(method_name,n);

	if (c_loops < 1)  c_loops = 1;
	if (d_loops < 1)  d_loops = 1;

	fflush(stdout); fflush(stderr);

	/* read the whole file */
	r = load_file(file_name,&l);
	if (r != 0)
		return r;

	/* compute some checksums */
	adler = lzo_adler32(0, NULL, 0);
	adler = lzo_adler32(adler, data, l);
	if (p_adler)
		*p_adler = adler;
	crc = lzo_crc32(0, NULL, 0);
	crc = lzo_crc32(crc, data, l);
	if (p_crc)
		*p_crc = crc;

#if 0 && defined(ALG_ZLIB)
	{
		uLong x;
		x = adler32(0, Z_NULL, 0);
		x = adler32(x, data, l);
		if (x != adler)
			return EXIT_LZO_ERROR;
		x = crc32(0, Z_NULL, 0);
		x = crc32(x, data, l);
		if (x != crc)
			return EXIT_LZO_ERROR;
	}
#endif

	if (opt_dict && dict)
		if (opt_max_dict_len <= 0 && dict_len > l)
		{
			if (opt_max_dict_len == -1)
				dict += dict_len - l;		/* use end of dictionary */
			dict_len = l;
		}

	if (opt_verbose >= 2)
	{
		printf("File %s: %lu bytes   (0x%08lx, 0x%08lx)\n",
		        file_name, (long) l, (long) adler, (long) crc);
		printf("  compressing %lu bytes (%d/%d/%d loops, %lu block-size)\n",
		        (long) l, t_loops, c_loops, d_loops, (long) opt_block_size);
		printf("  %s\n", method_name);
	}

	r = process_file(c, decompress, method_name, file_name, l,
	                 t_loops, c_loops, d_loops);

	dict = saved_dict;
	dict_len = saved_dict_len;

	return r;
}


/*************************************************************************
// Calgary Corpus test suite driver
**************************************************************************/

#ifdef USE_CORPUS

typedef struct
{
	const char *name;
	int loops;
	lzo_uint32 adler;
	lzo_uint32 crc;
}
corpus_t;

static const corpus_t calgary_corpus[] =
{
	{ "bib",       8,  0x4bd09e98L, 0xb856ebe8L },
	{ "book1",     1,  0xd4d3613eL, 0x24e19972L },
	{ "book2",     1,  0x6fe14cc3L, 0xba0f3f26L },
	{ "geo",       6,  0xf3cc5be0L, 0x4d3a6ed0L },
	{ "news",      2,  0x2ed405b8L, 0xcafac853L },
	{ "obj1",     35,  0x3887dd2cL, 0xc7b0cd26L },
	{ "obj2",      4,  0xf89407c4L, 0x3ae33007L },
	{ "paper1",   17,  0xfe65ce62L, 0x2b6baca0L },
	{ "paper2",   11,  0x1238b7c2L, 0xf76cba72L },
	{ "pic",       4,  0xf61a5702L, 0x4b17e59cL },
	{ "progc",    25,  0x4c00ba45L, 0x6fb16094L },
	{ "progl",    20,  0x4cba738eL, 0xddbf6baaL },
	{ "progp",    28,  0x7495b92bL, 0x493a1809L },
	{ "trans",    15,  0x52a2cec8L, 0xcdec06a6L },
	{ NULL,        0,  0x00000000L, 0x00000000L },
	{ "paper3",   30,  0x50b727a9L, 0x00000000L },
	{ "paper4",   30,  0xcb4a305fL, 0x00000000L },
	{ "paper5",   30,  0x2ca8a6f3L, 0x00000000L },
	{ "paper6",   30,  0x9ddbcfa4L, 0x00000000L },
	{ NULL,        0,  0x00000000L, 0x00000000L }
};


static
int do_corpus ( const corpus_t *corpus, int method, const char *path,
                int c_loops, int d_loops )
{
	size_t i, n;
	char name[256];

	if (path == NULL || strlen(path) >= sizeof(name) - 12)
		return EXIT_USAGE;

	strcpy(name,path);
	n = strlen(name);
	if (n > 0 && name[n-1] != '/' && name[n-1] != '\\' && name[n-1] != ':')
	{
		strcat(name,"/");
		n++;
	}

	for (i = 0; corpus[i].name != NULL; i++)
	{
		lzo_uint32 adler, crc;
		int c = c_loops * corpus[i].loops;
		int d = d_loops * corpus[i].loops;
		int r;

		strcpy(name+n,corpus[i].name);
		r = do_file(method, name, c, d, &adler, &crc);
		if (r != 0)
			return r;
		if (adler != corpus[i].adler)
		{
			printf("  invalid test suite\n");
			return EXIT_ADLER;
		}
		if (corpus[i].crc && crc != corpus[i].crc)
		{
			printf("  internal checksum error !!  (0x%08lx 0x%08lx)\n",
			        (long) crc, (long) corpus[i].crc);
			return EXIT_INTERNAL;
		}
	}
	return EXIT_OK;
}

#endif


/*************************************************************************
// usage
**************************************************************************/

static
void usage ( const char *name, int exit_code, lzo_bool show_methods )
{
	FILE *f;
	int i;

	f = stdout;

	fflush(stdout); fflush(stderr);

	fprintf(f,"Usage: %s [option..] file...\n", name);
	fprintf(f,"\n");
	fprintf(f,"Options:\n");
	fprintf(f,"  -m#     compression method\n");
	fprintf(f,"  -b#     set input block size (default %ld, max %ld)\n",
		(long) opt_block_size, (long) MAX_BLOCK_SIZE);
	fprintf(f,"  -n#     number of compression/decompression runs\n");
	fprintf(f,"  -c#     number of compression runs\n");
	fprintf(f,"  -d#     number of decompression runs\n");
	fprintf(f,"  -S      use safe decompressor (if available)\n");
	fprintf(f,"  -A      use assembler decompressor (if available)\n");
	fprintf(f,"  -F      use fast assembler decompressor (if available)\n");
	fprintf(f,"  -O      optimize compressed data (if available)\n");
#ifdef USE_CORPUS
	fprintf(f,"  -s DIR  process Calgary Corpus test suite in directory `DIR'\n");
#endif
	fprintf(f,"  -@      read list of files to compress from stdin\n");
	fprintf(f,"  -q      be quiet\n");
	fprintf(f,"  -Q      be very quiet\n");
	fprintf(f,"  -v      be verbose\n");
	fprintf(f,"  -L      display software license\n");

	if (show_methods)
	{
#if defined(my_clock_desc)
		fprintf(f,"\nAll timings are recorded using %s.\n",my_clock_desc);
#endif
		fprintf(f,"\n\n");
		fprintf(f,"The following compression methods are available:\n");
		fprintf(f,"\n");
		fprintf(f,"  usage   name           memory          available extras\n");
		fprintf(f,"  -----   ----           ------          ----------------\n");

		for (i = 0; i <= M_LAST_COMPRESSOR; i++)
		{
			const compress_t *c;
			c = info(i,NULL);
			if (c)
			{
				char n[16];
				static const char * const s[3] = {"          ", ", ", ""};
				int j = 0;
				unsigned long m = c->mem_compress;

				sprintf(n,"-m%d",i);
				fprintf(f,"  %-6s  %-12s",n,c->name);
#if 1
				fprintf(f,"%9ld", m);
#else
				m = (m + 1023) / 1024;
				fprintf(f,"%6ld kB", m);
#endif

				if (c->decompress_safe)
					fprintf(f, "%s%s", j++ == 0 ? s[0] : s[1], "safe");
				if (c->decompress_asm)
					fprintf(f, "%s%s", j++ == 0 ? s[0] : s[1], "asm");
				if (c->decompress_asm_safe)
					fprintf(f, "%s%s", j++ == 0 ? s[0] : s[1], "asm+safe");
				if (c->decompress_asm_fast)
					fprintf(f, "%s%s", j++ == 0 ? s[0] : s[1], "fastasm");
				if (c->decompress_asm_fast_safe)
					fprintf(f, "%s%s", j++ == 0 ? s[0] : s[1], "fastasm+safe");
				if (c->optimize)
					fprintf(f, "%s%s", j++ == 0 ? s[0] : s[1], "optimize");
				if (j > 0)
					fprintf(f, s[2]);
				fprintf(f,"\n");
			}
		}
	}
	else
	{
		fprintf(f,"\n");
		fprintf(f,"Type '%s -m' to list all available methods.\n", name);
	}

	fflush(f);
	if (exit_code < 0)
		exit_code = EXIT_USAGE;
	exit(exit_code);
}


static
void license(void)
{
	FILE *f;

	f = stdout;

	fflush(stdout); fflush(stderr);

fprintf(f,
"   The LZO library is free software; you can redistribute it and/or\n"
"   modify it under the terms of the GNU General Public License as\n"
"   published by the Free Software Foundation; either version 2 of\n"
"   the License, or (at your option) any later version.\n"
"\n"
"   The LZO library is distributed in the hope that it will be useful,\n"
"   but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
"   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
"   GNU General Public License for more details.\n"
"\n"
"   You should have received a copy of the GNU General Public License\n"
"   along with the LZO library; see the file COPYING.\n"
"   If not, write to the Free Software Foundation, Inc.,\n"
"   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n"