/* lzotest.c -- very comprehensive test driver for the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2014 Markus Franz Xaver Johannes Oberhumer
All Rights Reserved.
The LZO library is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.
The LZO library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the LZO library; see the file COPYING.
If not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
Markus F.X.J. Oberhumer
<markus@oberhumer.com>
http://www.oberhumer.com/opensource/lzo/
*/
#include "lzo/lzoconf.h"
/*************************************************************************
// util
**************************************************************************/
/* portability layer */
#define WANT_LZO_MALLOC 1
#define WANT_LZO_FREAD 1
#define WANT_LZO_WILDARGV 1
#define WANT_LZO_PCLOCK 1
#define LZO_WANT_ACCLIB_GETOPT 1
#include "examples/portab.h"
#if defined(HAVE_STRNICMP) && !defined(HAVE_STRNCASECMP)
# define strncasecmp(a,b,c) strnicmp(a,b,c)
# define HAVE_STRNCASECMP 1
#endif
#if 0
# define is_digit(x) (isdigit((unsigned char)(x)))
# define is_space(x) (isspace((unsigned char)(x)))
#else
# define is_digit(x) ((unsigned)(x) - '0' <= 9)
# define is_space(x) ((x)==' ' || (x)=='\t' || (x)=='\r' || (x)=='\n')
#endif
/*************************************************************************
// compression include section
**************************************************************************/
#define HAVE_LZO1_H 1
#define HAVE_LZO1A_H 1
#define HAVE_LZO1B_H 1
#define HAVE_LZO1C_H 1
#define HAVE_LZO1F_H 1
#define HAVE_LZO1X_H 1
#define HAVE_LZO1Y_H 1
#define HAVE_LZO1Z_H 1
#define HAVE_LZO2A_H 1
#if defined(NO_ZLIB_H) || (SIZEOF_INT < 4)
#undef HAVE_ZLIB_H
#endif
#if defined(NO_BZLIB_H) || (SIZEOF_INT != 4)
#undef HAVE_BZLIB_H
#endif
#if 0 && defined(LZO_OS_DOS16)
/* don't make this test program too big */
#undef HAVE_LZO1_H
#undef HAVE_LZO1A_H
#undef HAVE_LZO1C_H
#undef HAVE_LZO1Z_H
#undef HAVE_LZO2A_H
#undef HAVE_LZO2B_H
#undef HAVE_ZLIB_H
#endif
/* LZO algorithms */
#if defined(HAVE_LZO1_H)
# include "lzo/lzo1.h"
#endif
#if defined(HAVE_LZO1A_H)
# include "lzo/lzo1a.h"
#endif
#if defined(HAVE_LZO1B_H)
# include "lzo/lzo1b.h"
#endif
#if defined(HAVE_LZO1C_H)
# include "lzo/lzo1c.h"
#endif
#if defined(HAVE_LZO1F_H)
# include "lzo/lzo1f.h"
#endif
#if defined(HAVE_LZO1X_H)
# include "lzo/lzo1x.h"
# if defined(__LZO_PROFESSIONAL__)
# include "lzo/lzopro/lzo1x.h"
# endif
#endif
#if defined(HAVE_LZO1Y_H)
# include "lzo/lzo1y.h"
# if defined(__LZO_PROFESSIONAL__)
# include "lzo/lzopro/lzo1y.h"
# endif
#endif
#if defined(HAVE_LZO1Z_H)
# include "lzo/lzo1z.h"
#endif
#if defined(HAVE_LZO2A_H)
# include "lzo/lzo2a.h"
#endif
#if defined(HAVE_LZO2B_H)
# include "lzo/lzo2b.h"
#endif
#if defined(__LZO_PROFESSIONAL__)
# include "lzopro/t_config.ch"
#endif
/* other compressors */
#if defined(HAVE_ZLIB_H)
# include <zlib.h>
# define ALG_ZLIB 1
#endif
#if defined(HAVE_BZLIB_H)
# include <bzlib.h>
# define ALG_BZIP2 1
#endif
/*************************************************************************
// enumerate all methods
**************************************************************************/
enum {
/* compression algorithms */
M_LZO1B_1 = 1,
M_LZO1B_2, M_LZO1B_3, M_LZO1B_4, M_LZO1B_5,
M_LZO1B_6, M_LZO1B_7, M_LZO1B_8, M_LZO1B_9,
M_LZO1C_1 = 11,
M_LZO1C_2, M_LZO1C_3, M_LZO1C_4, M_LZO1C_5,
M_LZO1C_6, M_LZO1C_7, M_LZO1C_8, M_LZO1C_9,
M_LZO1 = 21,
M_LZO1A = 31,
M_LZO1B_99 = 901,
M_LZO1B_999 = 902,
M_LZO1C_99 = 911,
M_LZO1C_999 = 912,
M_LZO1_99 = 921,
M_LZO1A_99 = 931,
M_LZO1F_1 = 61,
M_LZO1F_999 = 962,
M_LZO1X_1 = 71,
M_LZO1X_1_11 = 111,
M_LZO1X_1_12 = 112,
M_LZO1X_1_15 = 115,
M_LZO1X_999 = 972,
M_LZO1Y_1 = 81,
M_LZO1Y_999 = 982,
M_LZO1Z_999 = 992,
M_LZO2A_999 = 942,
M_LZO2B_999 = 952,
M_LAST_LZO_COMPRESSOR = 998,
/* other compressors */
#if defined(ALG_ZLIB)
M_ZLIB_8_1 = 1101,
M_ZLIB_8_2, M_ZLIB_8_3, M_ZLIB_8_4, M_ZLIB_8_5,
M_ZLIB_8_6, M_ZLIB_8_7, M_ZLIB_8_8, M_ZLIB_8_9,
#endif
#if defined(ALG_BZIP2)
M_BZIP2_1 = 1201,
M_BZIP2_2, M_BZIP2_3, M_BZIP2_4, M_BZIP2_5,
M_BZIP2_6, M_BZIP2_7, M_BZIP2_8, M_BZIP2_9,
#endif
/* dummy compressor - for benchmarking */
M_MEMCPY = 999,
M_LAST_COMPRESSOR = 4999,
/* dummy algorithms - for benchmarking */
M_MEMSET = 5001,
/* checksum algorithms - for benchmarking */
M_ADLER32 = 6001,
M_CRC32 = 6002,
#if defined(ALG_ZLIB)
M_Z_ADLER32 = 6011,
M_Z_CRC32 = 6012,
#endif
#if defined(__LZO_PROFESSIONAL__)
# include "lzopro/m_enum.ch"
#endif
M_UNUSED
};
/*************************************************************************
// command line options
**************************************************************************/
int opt_verbose = 2;
long opt_c_loops = 0;
long opt_d_loops = 0;
const char *opt_corpus_path = NULL;
const char *opt_dump_compressed_data = NULL;
lzo_bool opt_use_safe_decompressor = 0;
lzo_bool opt_use_asm_decompressor = 0;
lzo_bool opt_use_asm_fast_decompressor = 0;
lzo_bool opt_optimize_compressed_data = 0;
int opt_dict = 0;
lzo_uint opt_max_dict_len = LZO_UINT_MAX;
const char *opt_dictionary_file = NULL;
lzo_bool opt_read_from_stdin = 0;
/* set these to 1 to measure the speed impact of a checksum */
lzo_bool opt_compute_adler32 = 0;
lzo_bool opt_compute_crc32 = 0;
static lzo_uint32_t adler_in, adler_out;
static lzo_uint32_t crc_in, crc_out;
lzo_bool opt_execution_time = 0;
int opt_pclock = -1;
lzo_bool opt_clear_wrkmem = 0;
static const lzo_bool opt_try_to_compress_0_bytes = 1;
/*************************************************************************
// misc globals
**************************************************************************/
static const char *progname = "";
static lzo_pclock_handle_t pch;
/* for statistics and benchmark */
int opt_totals = 0;
static unsigned long total_n = 0;
static unsigned long total_c_len = 0;
static unsigned long total_d_len = 0;
static unsigned long total_blocks = 0;
static double total_perc = 0.0;
static const char *total_method_name = NULL;
static unsigned total_method_names = 0;
/* Note: the average value of a rate (e.g. compression speed) is defined
* by the Harmonic Mean (and _not_ by the Arithmethic Mean ) */
static unsigned long total_c_mbs_n = 0;
static unsigned long total_d_mbs_n = 0;
static double total_c_mbs_harmonic = 0.0;
static double total_d_mbs_harmonic = 0.0;
static double total_c_mbs_sum = 0.0;
static double total_d_mbs_sum = 0.0;
#if defined(HAVE_LZO1X_H)
int default_method = M_LZO1X_1;
#elif defined(HAVE_LZO1B_H)
int default_method = M_LZO1B_1;
#elif defined(HAVE_LZO1C_H)
int default_method = M_LZO1C_1;
#elif defined(HAVE_LZO1F_H)
int default_method = M_LZO1F_1;
#elif defined(HAVE_LZO1Y_H)
int default_method = M_LZO1Y_1;
#else
int default_method = M_MEMCPY;
#endif
static const int benchmark_methods[] = {
M_LZO1B_1, M_LZO1B_9,
M_LZO1C_1, M_LZO1C_9,
M_LZO1F_1,
M_LZO1X_1,
0
};
static const int x1_methods[] = {
M_LZO1, M_LZO1A, M_LZO1B_1, M_LZO1C_1, M_LZO1F_1, M_LZO1X_1, M_LZO1Y_1,
0
};
static const int x99_methods[] = {
M_LZO1_99, M_LZO1A_99, M_LZO1B_99, M_LZO1C_99,
0
};
static const int x999_methods[] = {
M_LZO1B_999, M_LZO1C_999, M_LZO1F_999, M_LZO1X_999, M_LZO1Y_999,
M_LZO1Z_999,
M_LZO2A_999,
0
};
/* exit codes of this test program */
#define EXIT_OK 0
#define EXIT_USAGE 1
#define EXIT_FILE 2
#define EXIT_MEM 3
#define EXIT_ADLER 4
#define EXIT_LZO_ERROR 5
#define EXIT_LZO_INIT 6
#define EXIT_INTERNAL 7
/*************************************************************************
// memory setup
**************************************************************************/
static lzo_uint opt_block_size;
static lzo_uint opt_max_data_len;
typedef struct {
lzo_bytep ptr;
lzo_uint len;
lzo_uint32_t adler;
lzo_uint32_t crc;
lzo_bytep alloc_ptr;
lzo_uint alloc_len;
lzo_uint saved_len;
} mblock_t;
static mblock_t file_data; /* original uncompressed data */
static mblock_t block_c; /* compressed data */
static mblock_t block_d; /* decompressed data */
static mblock_t block_w; /* wrkmem */
static mblock_t dict;
static void mb_alloc_extra(mblock_t *mb, lzo_uint len, lzo_uint extra_bottom, lzo_uint extra_top)
{
lzo_uint align = (lzo_uint) sizeof(lzo_align_t);
mb->alloc_ptr = mb->ptr = NULL;
mb->alloc_len = mb->len = 0;
mb->alloc_len = extra_bottom + len + extra_top;
if (mb->alloc_len == 0) mb->alloc_len = 1;
mb->alloc_ptr = (lzo_bytep) lzo_malloc(mb->alloc_len);
if (mb->alloc_ptr == NULL) {
fprintf(stderr, "%s: out of memory (wanted %lu bytes)\n", progname, (unsigned long)mb->alloc_len);
exit(EXIT_MEM);
}
if (mb->alloc_len >= align && __lzo_align_gap(mb->alloc_ptr, align) != 0) {
fprintf(stderr, "%s: C library problem: malloc() returned misaligned pointer!\n", progname);
exit(EXIT_MEM);
}
mb->ptr = mb->alloc_ptr + extra_bottom;
mb->len = mb->saved_len = len;
mb->adler = 1;
mb->crc = 0;
}
static void mb_alloc(mblock_t *mb, lzo_uint len)
{
mb_alloc_extra(mb, len, 0, 0);
}
static void mb_free(mblock_t *mb)
{
if (!mb) return;
if (mb->alloc_ptr) lzo_free(mb->alloc_ptr);
mb->alloc_ptr = mb->ptr = NULL;
mb->alloc_len = mb->len = 0;
}
static lzo_uint get_max_compression_expansion(int m, lzo_uint bl)
{
if (m == M_MEMCPY || m >= M_LAST_COMPRESSOR)
return 0;
if (m == M_LZO2A_999 || m == M_LZO2B_999)
return bl / 8 + 256;
if (m > 0 && m < M_LAST_LZO_COMPRESSOR)
return bl / 16 + 64 + 3;
return bl / 8 + 256;
}
static lzo_uint get_max_decompression_overrun(int m, lzo_uint bl)
{
LZO_UNUSED(m);
LZO_UNUSED(bl);
/* may overwrite 3 bytes past the end of the decompressed block */
if (opt_use_asm_fast_decompressor)
return (lzo_uint) sizeof(lzo_voidp) - 1;
return 0;
}
/*************************************************************************
// dictionary support
**************************************************************************/
static void dict_alloc(lzo_uint max_dict_len)
{
lzo_uint l = 0xbfff; /* MAX_DICT_LEN */
if (max_dict_len > 0 && l > max_dict_len)
l = max_dict_len;
mb_alloc(&dict, l);
}
/* this default dictionary does not provide good contexts... */
static void dict_set_default(void)
{
lzo_uint d = 0;
unsigned i, j;
dict.len = 16 * 256;
if (dict.len > dict.alloc_len)
dict.len = dict.alloc_len;
lzo_memset(dict.ptr, 0, dict.len);
for (i = 0; i < 256; i++)
for (j = 0; j < 16; j++) {
if (d >= dict.len)
goto done;
dict.ptr[d++] = (unsigned char) i;
}
done:
dict.adler = lzo_adler32(1, dict.ptr, dict.len);
}
static void dict_load(const char *file_name)
{
FILE *fp;
dict.len = 0;
fp = fopen(file_name, "rb");
if (fp)
{
dict.len = (lzo_uint) lzo_fread(fp, dict.ptr, dict.alloc_len);
(void) fclose(fp);
dict.adler = lzo_adler32(1, dict.ptr, dict.len);
}
}
/*************************************************************************
// compression database
**************************************************************************/
typedef struct
{
const char * name;
int id;
lzo_uint32_t mem_compress;
lzo_uint32_t mem_decompress;
lzo_compress_t compress;
lzo_optimize_t optimize;
lzo_decompress_t decompress;
lzo_decompress_t decompress_safe;
lzo_decompress_t decompress_asm;
lzo_decompress_t decompress_asm_safe;
lzo_decompress_t decompress_asm_fast;
lzo_decompress_t decompress_asm_fast_safe;
lzo_compress_dict_t compress_dict;
lzo_decompress_dict_t decompress_dict_safe;
}
compress_t;
#include "asm.h"
#ifdef __cplusplus
extern "C" {
#endif
#include "wrap.h"
#define M_PRIVATE LZO_PRIVATE
#define m_uint lzo_uint
#define m_uint32_t lzo_uint32_t
#define m_voidp lzo_voidp
#define m_bytep lzo_bytep
#define m_uintp lzo_uintp
#include "wrapmisc.h"
#ifdef __cplusplus
} /* extern "C" */
#endif
static const compress_t compress_database[] = {
#include "db.h"
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};
/*************************************************************************
// method info
**************************************************************************/
static
lzo_decompress_t get_decomp_info ( const compress_t *c, const char **nn )
{
lzo_decompress_t d = 0;
const char *n = NULL;
/* safe has priority over asm/fast */
if (!d && opt_use_safe_decompressor && opt_use_asm_fast_decompressor)
{
d = c->decompress_asm_fast_safe;
n = " [fs]";
}
if (!d && opt_use_safe_decompressor && opt_use_asm_decompressor)
{
d = c->decompress_asm_safe;
n = " [as]";
}
if (!d && opt_use_safe_decompressor)
{
d = c->decompress_safe;
n = " [s]";
}
if (!d && opt_use_asm_fast_decompressor)
{
d = c->decompress_asm_fast;
n = " [f]";
}
if (!d && opt_use_asm_decompressor)
{
d = c->decompress_asm;
n = " [a]";
}
if (!d)
{
d = c->decompress;
n = "";
}
if (!d)
n = "(null)";
if (opt_dict && c->decompress_dict_safe)
n = "";
if (nn)
*nn = n;
return d;
}
static
const compress_t *find_method_by_id ( int method )
{
const compress_t *db;
size_t size = sizeof(compress_database) / sizeof(*(compress_database));
size_t i;
db = compress_database;
for (i = 0; i < size && db->name != NULL; i++, db++)
{
if (method == db->id)
return db;
}
return NULL;
}
static
const compress_t *find_method_by_name ( const char *name )
{
const compress_t *db;
size_t size = sizeof(compress_database) / sizeof(*(compress_database));
size_t i;
db = compress_database;
for (i = 0; i < size && db->name != NULL; i++, db++)
{
size_t n = strlen(db->name);
#if defined(HAVE_STRNCASECMP)
if (strncasecmp(name,db->name,n) == 0 && (!name[n] || name[n] == ','))
return db;
#else
if (strncmp(name,db->name,n) == 0 && (!name[n] || name[n] == ','))
return db;
#endif
}
return NULL;
}
static
lzo_bool is_compressor ( const compress_t *c )
{
return (c->id <= M_LAST_COMPRESSOR || c->id >= 9721);
}
/*************************************************************************
// check that memory gets accessed within bounds
**************************************************************************/
static void memchecker_init ( mblock_t *mb, lzo_uint l, unsigned char random_byte )
{
lzo_uint i;
lzo_uint len = (lzo_uint) l;
lzo_bytep p;
assert(len <= mb->len);
/* bottom */
p = mb->ptr;
for (i = 0; i < 16 && p > mb->alloc_ptr; i++)
*--p = random_byte++;
/* top */
p = mb->ptr + len;
for (i = 0; i < 16 && p < mb->alloc_ptr + mb->alloc_len; i++)
*p++ = random_byte++;
#if 0 || defined(LZO_DEBUG)
/* fill in garbage */
p = mb->ptr;
random_byte |= 1;
for (i = 0; i < len; i++, random_byte += 2)
*p++ = random_byte;
#endif
}
static int memchecker_check ( mblock_t *mb, lzo_uint l, unsigned char random_byte )
{
lzo_uint i;
lzo_uint len = (lzo_uint) l;
lzo_bytep p;
assert(len <= mb->len);
/* bottom */
p = mb->ptr;
for (i = 0; i < 16 && p > mb->alloc_ptr; i++)
if (*--p != random_byte++)
return -1;
/* top */
p = mb->ptr + len;
for (i = 0; i < 16 && p < mb->alloc_ptr + mb->alloc_len; i++)
if (*p++ != random_byte++)
return -1;
return 0;
}
/*************************************************************************
// compress a block
**************************************************************************/
static
int call_compressor ( const compress_t *c,
const lzo_bytep src, lzo_uint src_len,
lzo_bytep dst, lzo_uintp dst_len )
{
int r = -100;
if (c && c->compress && block_w.len >= c->mem_compress)
{
unsigned char random_byte = (unsigned char) src_len;
memchecker_init(&block_w, c->mem_compress, random_byte);
if (opt_clear_wrkmem)
lzo_memset(block_w.ptr, 0, c->mem_compress);
if (opt_dict && c->compress_dict)
r = c->compress_dict(src,src_len,dst,dst_len,block_w.ptr,dict.ptr,dict.len);
else
r = c->compress(src,src_len,dst,dst_len,block_w.ptr);
if (memchecker_check(&block_w, c->mem_compress, random_byte) != 0)
printf("WARNING: wrkmem overwrite error (compress) !!!\n");
}
if (r == 0 && opt_compute_adler32)
{
lzo_uint32_t adler;
adler = lzo_adler32(0, NULL, 0);
adler = lzo_adler32(adler, src, src_len);
adler_in = adler;
}
if (r == 0 && opt_compute_crc32)
{
lzo_uint32_t crc;
crc = lzo_crc32(0, NULL, 0);
crc = lzo_crc32(crc, src, src_len);
crc_in = crc;
}
return r;
}
/*************************************************************************
// decompress a block
**************************************************************************/
static
int call_decompressor ( const compress_t *c, lzo_decompress_t d,
const lzo_bytep src, lzo_uint src_len,
lzo_bytep dst, lzo_uintp dst_len )
{
int r = -100;
if (c && d && block_w.len >= c->mem_decompress)
{
unsigned char random_byte = (unsigned char) src_len;
memchecker_init(&block_w, c->mem_decompress, random_byte);
if (opt_clear_wrkmem)
lzo_memset(block_w.ptr, 0, c->mem_decompress);
if (opt_dict && c->decompress_dict_safe)
r = c->decompress_dict_safe(src,src_len,dst,dst_len,block_w.ptr,dict.ptr,dict.len);
else
r = d(src,src_len,dst,dst_len,block_w.ptr);
if (memchecker_check(&block_w, c->mem_decompress, random_byte) != 0)
printf("WARNING: wrkmem overwrite error (decompress) !!!\n");
}
if (r == 0 && opt_compute_adler32)
adler_out = lzo_adler32(1, dst, *dst_len);
if (r == 0 && opt_compute_crc32)
crc_out = lzo_crc32(0, dst, *dst_len);
return r;
}
/*************************************************************************
// optimize a block
**************************************************************************/
static
int call_optimizer ( const compress_t *c,
lzo_bytep src, lzo_uint src_len,
lzo_bytep dst, lzo_uintp dst_len )
{
if (c && c->optimize && block_w.len >= c->mem_decompress)
return c->optimize(src,src_len,dst,dst_len,block_w.ptr);
return 0;
}
/***********************************************************************
// read a file
************************************************************************/
static int load_file(const char *file_name, lzo_uint max_data_len)
{
FILE *fp;
#if (HAVE_FTELLO)
off_t ll = -1;
#else
long ll = -1;
#endif
lzo_uint l;
int r;
mblock_t *mb = &file_data;
mb_free(mb);
fp = fopen(file_name, "rb");
if (fp == NULL)
{
fflush(stdout); fflush(stderr);
fprintf(stderr, "%s: ", file_name);
fflush(stderr);
perror("fopen");
fflush(stdout); fflush(stderr);
return EXIT_FILE;
}
r = fseek(fp, 0, SEEK_END);
if (r == 0)
{
#if (HAVE_FTELLO)
ll = ftello(fp);
#else
ll = ftell(fp);
#endif
r = fseek(fp, 0, SEEK_SET);
}
if (r != 0 || ll < 0)
{
fflush(stdout); fflush(stderr);
fprintf(stderr, "%s: ", file_name);
fflush(stderr);
perror("fseek");
fflush(stdout); fflush(stderr);
(void) fclose(fp);
return EXIT_FILE;
}
l = (lzo_uint) ll;
if (l > max_data_len) l = max_data_len;
#if (HAVE_FTELLO)
if ((off_t) l != ll) l = max_data_len;
#else
if ((long) l != ll) l = max_data_len;
#endif
mb_alloc(mb, l);
mb->len = (lzo_uint) lzo_fread(fp, mb->ptr, mb->len);
r = ferror(fp);
if (fclose(fp) != 0 || r != 0)
{
mb_free(mb);
fflush(stdout); fflush(stderr);
fprintf(stderr, "%s: ", file_name);
fflush(stderr);
perror("fclose");
fflush(stdout); fflush(stderr);
return EXIT_FILE;
}
return EXIT_OK;
}
/***********************************************************************
// print some compression statistics
************************************************************************/
static double t_div(double a, double b)
{
return b > 0.00001 ? a / b : 0;
}
static double set_perc_d(double perc, char *s)
{
if (perc <= 0.0) {
strcpy(s, "0.0");
return 0;
}
if (perc <= 100 - 1.0 / 16) {
sprintf(s, "%4.1f", perc);
}
else {
long p = (long) (perc + 0.5);
if (p < 100)
strcpy(s, "???");
else if (p >= 9999)
strcpy(s, "9999");
else
sprintf(s, "%ld", p);
}
return perc;
}
static double set_perc(unsigned long c_len, unsigned long d_len, char *s)
{
double perc = 0.0;
if (d_len > 0)
perc = c_len * 100.0 / d_len;
return set_perc_d(perc, s);
}
static
void print_stats ( const char *method_name, const char *file_name,
long t_loops, long c_loops, long d_loops,
double t_secs, double c_secs, double d_secs,
unsigned long c_len, unsigned long d_len,
unsigned long blocks )
{
unsigned long x_len = d_len;
unsigned long t_bytes, c_bytes, d_bytes;
double c_mbs, d_mbs, t_mbs;
double perc;
char perc_str[4+1];
perc = set_perc(c_len, d_len, perc_str);
c_bytes = x_len * c_loops * t_loops;
d_bytes = x_len * d_loops * t_loops;
t_bytes = c_bytes + d_bytes;
if (opt_pclock == 0)
c_secs = d_secs = t_secs = 0.0;
/* speed in uncompressed megabytes per second (1 megabyte = 1.000.000 bytes) */
c_mbs = (c_secs > 0.001) ? (c_bytes / c_secs) / 1000000.0 : 0;
d_mbs = (d_secs > 0.001) ? (d_bytes / d_secs) / 1000000.0 : 0;
t_mbs = (t_secs > 0.001) ? (t_bytes / t_secs) / 1000000.0 : 0;
total_n++;
total_c_len += c_len;
total_d_len += d_len;
total_blocks += blocks;
total_perc += perc;
if (c_mbs > 0) {
total_c_mbs_n += 1;
total_c_mbs_harmonic += 1.0 / c_mbs;
total_c_mbs_sum += c_mbs;
}
if (d_mbs > 0) {
total_d_mbs_n += 1;
total_d_mbs_harmonic += 1.0 / d_mbs;
total_d_mbs_sum += d_mbs;
}
if (opt_verbose >= 2)
{
printf(" compressed into %lu bytes, %s%% (%s%.3f bits/byte)\n",
c_len, perc_str, "", perc * 0.08);
#if 0
printf("%-15s %5ld: ","overall", t_loops);
printf("%10lu bytes, %8.2f secs, %8.3f MB/sec\n",
t_bytes, t_secs, t_mbs);
#else
LZO_UNUSED(t_mbs);
#endif
printf("%-15s %5ld: ","compress", c_loops);
printf("%10lu bytes, %8.2f secs, %8.3f MB/sec\n",
c_bytes, c_secs, c_mbs);
printf("%-15s %5ld: ","decompress", d_loops);
printf("%10lu bytes, %8.2f secs, %8.3f MB/sec\n",
d_bytes, d_secs, d_mbs);
printf("\n");
}
/* create a line for util/table.pl */
if (opt_verbose >= 1)
{
/* get basename */
const char *n, *nn, *b;
for (nn = n = b = file_name; *nn; nn++)
if (*nn == '/' || *nn == '\\' || *nn == ':')
b = nn + 1;
else
n = b;
printf("%-13s| %-14s %8lu %4lu %9lu %4s %s%8.3f %8.3f |\n",
method_name, n, d_len, blocks, c_len, perc_str, "", c_mbs, d_mbs);
}
if (opt_verbose >= 2)
printf("\n");
}
static
void print_totals ( void )
{
char perc_str[4+1];
if ((opt_verbose >= 1 && total_n > 1) || (opt_totals >= 2))
{
unsigned long n = total_n > 0 ? total_n : 1;
const char *t1 = "-------";
const char *t2 = total_method_names == 1 ? total_method_name : "";
#if 1 && defined(__LZOLIB_PCLOCK_CH_INCLUDED)
char pclock_mode[32+1];
sprintf(pclock_mode, "[clock=%d]", pch.mode);
t1 = pclock_mode;
if (opt_pclock == 0) t1 = t2;
#endif
#if 1
set_perc_d(total_perc / n, perc_str);
printf("%-13s %-12s %10lu %4.1f %9lu %4s %8.3f %8.3f\n",
t1, "***AVG***",
total_d_len / n, total_blocks * 1.0 / n, total_c_len / n, perc_str,
t_div((double)total_c_mbs_n, total_c_mbs_harmonic),
t_div((double)total_d_mbs_n, total_d_mbs_harmonic));
#endif
set_perc(total_c_len, total_d_len, perc_str);
printf("%-13s %-12s %10lu %4lu %9lu %4s %s%8.3f %8.3f\n",
t2, "***TOTALS***",
total_d_len, total_blocks, total_c_len, perc_str, "",
t_div((double)total_c_mbs_n, total_c_mbs_harmonic),
t_div((double)total_d_mbs_n, total_d_mbs_harmonic));
}
}
/*************************************************************************
// compress and decompress a file
**************************************************************************/
static __lzo_noinline
int process_file ( const compress_t *c, lzo_decompress_t decompress,
const char *method_name,
const char *file_name,
long t_loops, long c_loops, long d_loops )
{
long t_i;
unsigned long blocks = 0;
unsigned long compressed_len = 0;
double t_time = 0, c_time = 0, d_time = 0;
lzo_pclock_t t_start, t_stop, x_start, x_stop;
FILE *fp_dump = NULL;
if (opt_dump_compressed_data)
fp_dump = fopen(opt_dump_compressed_data,"wb");
/* process the file */
lzo_pclock_flush_cpu_cache(&pch, 0);
lzo_pclock_read(&pch, &t_start);
for (t_i = 0; t_i < t_loops; t_i++)
{
lzo_uint len, c_len, c_len_max, d_len = 0;
const lzo_bytep d = file_data.ptr;
len = file_data.len;
c_len = 0;
blocks = 0;
/* process blocks */
if (len > 0 || opt_try_to_compress_0_bytes) do
{
lzo_uint bl;
long c_i;
int r;
unsigned char random_byte = (unsigned char) file_data.len;
#if 1 && defined(CLOCKS_PER_SEC)
random_byte = (unsigned char) (random_byte ^ clock());
#endif
blocks++;
bl = len > opt_block_size ? opt_block_size : len;
/* update lengths for memchecker_xxx() */
block_c.len = bl + get_max_compression_expansion(c->id, bl);
block_d.len = bl + get_max_decompression_overrun(c->id, bl);
#if defined(__LZO_CHECKER)
/* malloc a block of the exact size to detect any overrun */
assert(block_c.alloc_ptr == NULL);
assert(block_d.alloc_ptr == NULL);
mb_alloc(&block_c, block_c.len);
mb_alloc(&block_d, block_d.len);
#endif
assert(block_c.len <= block_c.saved_len);
assert(block_d.len <= block_d.saved_len);
memchecker_init(&block_c, block_c.len, random_byte);
memchecker_init(&block_d, block_d.len, random_byte);
/* compress the block */
c_len = c_len_max = 0;
lzo_pclock_flush_cpu_cache(&pch, 0);
lzo_pclock_read(&pch, &x_start);
for (r = 0, c_i = 0; c_i < c_loops; c_i++)
{
c_len = block_c.len;
r = call_compressor(c, d, bl, block_c.ptr, &c_len);
if (r != 0)
break;
if (c_len > c_len_max)
c_len_max = c_len;
if (c_len > block_c.len)
goto compress_overrun;
}
lzo_pclock_read(&pch, &x_stop);
c_time += lzo_pclock_get_elapsed(&pch, &x_start, &x_stop);
if (r != 0)
{
printf(" compression failed in block %lu (%d) (%lu %lu)\n",
blocks, r, (unsigned long)c_len, (unsigned long)bl);
return EXIT_LZO_ERROR;
}
if (memchecker_check(&block_c, block_c.len, random_byte) != 0)
{
compress_overrun:
printf(" compression overwrite error in block %lu "
"(%lu %lu %lu %lu)\n",
blocks, (unsigned long)c_len, (unsigned long)d_len, (unsigned long)bl, (unsigned long)block_c.len);
return EXIT_LZO_ERROR;
}
/* optimize the compressed block */
if (c_len < bl && opt_optimize_compressed_data)
{
d_len = bl;
r = call_optimizer(c, block_c.ptr, c_len, block_d.ptr, &d_len);
if (r != 0 || d_len != bl)
{
printf(" optimization failed in block %lu (%d) "
"(%lu %lu %lu)\n", blocks, r,
(unsigned long)c_len, (unsigned long)d_len, (unsigned long)bl);
return EXIT_LZO_ERROR;
}
if (memchecker_check(&block_c, block_c.len, random_byte) != 0 ||
memchecker_check(&block_d, block_d.len, random_byte) != 0)
{
printf(" optimize overwrite error in block %lu "
"(%lu %lu %lu %lu)\n",
blocks, (unsigned long)c_len, (unsigned long)d_len, (unsigned long)bl, (unsigned long)block_c.len);
return EXIT_LZO_ERROR;
}
}
/* dump compressed data to disk */
if (fp_dump)
{
lzo_uint l = (lzo_uint) lzo_fwrite(fp_dump, block_c.ptr, c_len);
if (l != c_len || fflush(fp_dump) != 0) {
/* write error */
(void) fclose(fp_dump); fp_dump = NULL;
}
}
/* decompress the block and verify */
lzo_pclock_flush_cpu_cache(&pch, 0);
lzo_pclock_read(&pch, &x_start);
for (r = 0, c_i = 0; c_i < d_loops; c_i++)
{
d_len = bl;
r = call_decompressor(c, decompress, block_c.ptr, c_len, block_d.ptr, &d_len);
if (r != 0 || d_len != bl)
break;
}
lzo_pclock_read(&pch, &x_stop);
d_time += lzo_pclock_get_elapsed(&pch, &x_start, &x_stop);
if (r != 0)
{
printf(" decompression failed in block %lu (%d) "
"(%lu %lu %lu)\n", blocks, r,
(unsigned long)c_len, (unsigned long)d_len, (unsigned long)bl);
return EXIT_LZO_ERROR;
}
if (d_len != bl)
{
printf(" decompression size error in block %lu (%lu %lu %lu)\n",
blocks, (unsigned long)c_len, (unsigned long)d_len, (unsigned long)bl);
return EXIT_LZO_ERROR;
}
if (is_compressor(c))
{
if (lzo_memcmp(d, block_d.ptr, bl) != 0)
{
lzo_uint x = 0;
while (x < bl && block_d.ptr[x] == d[x])
x++;
printf(" decompression data error in block %lu at offset "
"%lu (%lu %lu)\n", blocks, (unsigned long)x,
(unsigned long)c_len, (unsigned long)d_len);
if (opt_compute_adler32)
printf(" checksum: 0x%08lx 0x%08lx\n",
(unsigned long)adler_in, (unsigned 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)block_d.ptr[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 %lu (%lu %lu)\n",
blocks, (unsigned long)c_len, (unsigned long)d_len);
printf(" adler32: 0x%08lx 0x%08lx\n",
(unsigned long)adler_in, (unsigned long)adler_out);
printf(" crc32: 0x%08lx 0x%08lx\n",
(unsigned long)crc_in, (unsigned long)crc_out);
return EXIT_LZO_ERROR;
}
}
if (memchecker_check(&block_d, block_d.len, random_byte) != 0)
{
printf(" decompression overwrite error in block %lu "
"(%lu %lu %lu %lu)\n",
blocks, (unsigned long)c_len, (unsigned long)d_len,
(unsigned long)bl, (unsigned long)block_d.len);
return EXIT_LZO_ERROR;
}
#if defined(__LZO_CHECKER)
/* free in reverse order of allocations */
mb_free(&block_d);
mb_free(&block_c);
#endif
d += bl;
len -= bl;
compressed_len += (unsigned long) c_len_max;
}
while (len > 0);
}
lzo_pclock_read(&pch, &t_stop);
t_time += lzo_pclock_get_elapsed(&pch, &t_start, &t_stop);
if (fp_dump) {
(void) fclose(fp_dump); fp_dump = NULL;
}
opt_dump_compressed_data = NULL; /* only dump the first file */
print_stats(method_name, file_name,
t_loops, c_loops, d_loops,
t_time, c_time, d_time,
compressed_len, (unsigned long) file_data.len, blocks);
if (total_method_name != c->name) {
total_method_name = c->name;
total_method_names += 1;
}
return EXIT_OK;
}
static
int do_file ( int method, const char *file_name,
long c_loops, long d_loops,
lzo_uint32_tp p_adler, lzo_uint32_tp p_crc )
{
int r;
const compress_t *c;
lzo_decompress_t decompress;
lzo_uint32_t adler, crc;
char method_name[256+1];
const char *n;
const long t_loops = 1;
adler_in = adler_out = 0;
crc_in = crc_out = 0;
if (p_adler)
*p_adler = 0;
if (p_crc)
*p_crc = 0;
c = find_method_by_id(method);
if (c == NULL || c->name == NULL || c->compress == NULL)
return EXIT_INTERNAL;
decompress = get_decomp_info(c,&n);
if (!decompress || n == NULL || block_w.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, opt_max_data_len);
if (r != 0)
return r;
/* compute some checksums */
adler = lzo_adler32(0, NULL, 0);
adler = lzo_adler32(adler, file_data.ptr, file_data.len);
if (p_adler)
*p_adler = adler;
crc = lzo_crc32(0, NULL, 0);
crc = lzo_crc32(crc, file_data.ptr, file_data.len);
if (p_crc)
*p_crc = crc;
if (opt_verbose >= 2)
{
printf("File %s: %lu bytes (0x%08lx, 0x%08lx)\n",
file_name, (unsigned long) file_data.len, (unsigned long) adler, (unsigned long) crc);
printf(" compressing %lu bytes (%ld/%ld/%ld loops, %lu block-size)\n",
(unsigned long) file_data.len, t_loops, c_loops, d_loops, (unsigned long) opt_block_size);
printf(" %s\n", method_name);
}
r = process_file(c, decompress, method_name, file_name,
t_loops, c_loops, d_loops);
return r;
}
/*************************************************************************
// Calgary Corpus and Silesia Corpus test suite driver
**************************************************************************/
struct corpus_entry_t
{
const char *name;
long loops;
lzo_uint32_t adler;
lzo_uint32_t crc;
};
const struct corpus_entry_t *opt_corpus = NULL;
static const struct corpus_entry_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 }
};
static const struct corpus_entry_t silesia_corpus[] =
{
{ "dickens", 1, 0x170f606fL, 0xaf3a6b76L },
{ "mozilla", 1, 0x1188dd4eL, 0x7fb0ab7dL },
{ "mr", 1, 0xaea14b97L, 0xa341883fL },
{ "nci", 1, 0x0af16f1fL, 0x60ff63d3L },
{ "ooffice", 1, 0x83c8f689L, 0xa023e1faL },
{ "osdb", 1, 0xb825b790L, 0xa0ca388cL },
{ "reymont", 1, 0xce5c82caL, 0x50d35f03L },
{ "samba", 1, 0x19dbb9f5L, 0x2beac5f3L },
{ "sao", 1, 0x7edfc4a9L, 0xfda125bfL },
{ "webster", 1, 0xf2962fc6L, 0x01f5a2e9L },
{ "xml", 1, 0xeccd03d6L, 0xff8f3051L },
{ "x-ray", 1, 0xc95435a0L, 0xc86a35c6L },
{ NULL, 0, 0x00000000L, 0x00000000L }
};
static
int do_corpus ( const struct corpus_entry_t *corpus, int method, const char *path,
long c_loops, long 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_t adler, crc;
long c = c_loops * corpus[i].loops;
long 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",
(unsigned long) crc, (unsigned long) corpus[i].crc);
return EXIT_INTERNAL;
}
}
return EXIT_OK;
}
/*************************************************************************
// usage
**************************************************************************/
static
void usage ( const char *name, int exit_code, lzo_bool show_methods )
{
FILE *fp;
int i;
fp = stdout;
fflush(stdout); fflush(stderr);
fprintf(fp,"Usage: %s [option..] file...\n", name);
fprintf(fp,"\n");
fprintf(fp,"Options:\n");
fprintf(fp," -m# compression method\n");
fprintf(fp," -b# set input block size (default %lu, max %lu)\n",
(unsigned long) opt_block_size, (unsigned long) opt_max_data_len);
fprintf(fp," -n# number of compression/decompression runs\n");
fprintf(fp," -c# number of compression runs\n");
fprintf(fp," -d# number of decompression runs\n");
fprintf(fp," -S use safe decompressor (if available)\n");
fprintf(fp," -A use assembler decompressor (if available)\n");
fprintf(fp," -F use fast assembler decompressor (if available)\n");
fprintf(fp," -O optimize compressed data (if available)\n");
fprintf(fp," -s DIR process Calgary Corpus test suite in directory `DIR'\n");
fprintf(fp," -@ read list of files to compress from stdin\n");
fprintf(fp," -q be quiet\n");
fprintf(fp," -Q be very quiet\n");
fprintf(fp," -v be verbose\n");
fprintf(fp," -L display software license\n");
if (show_methods)
{
#if defined(__LZOLIB_PCLOCK_CH_INCLUDED)
lzo_pclock_t t_dummy;
lzo_pclock_read(&pch, &t_dummy);
(void) lzo_pclock_get_elapsed(&pch, &t_dummy, &t_dummy);
fprintf(fp,"\nAll timings are recorded using pclock mode %d %s.\n", pch.mode, pch.name);
#endif
fprintf(fp,"\n\n");
fprintf(fp,"The following compression methods are available:\n");
fprintf(fp,"\n");
fprintf(fp," usage name memory available extras\n");
fprintf(fp," ----- ---- ------ ----------------\n");
for (i = 0; i <= M_LAST_COMPRESSOR; i++)
{
const compress_t *c;
c = find_method_by_id(i);
if (c)
{
char n[16];
const char *sep = " ";
unsigned long m = c->mem_compress;
sprintf(n,"-m%d",i);
fprintf(fp," %-6s %-13s",n,c->name);
#if 1
fprintf(fp,"%9lu", m);
#else
m = (m + 1023) / 1024;
fprintf(fp,"%6lu KiB", m);
#endif
if (c->decompress_safe)
{ fprintf(fp, "%s%s", sep, "safe"); sep = ", "; }
if (c->decompress_asm)
{ fprintf(fp, "%s%s", sep, "asm"); sep = ", "; }
if (c->decompress_asm_safe)
{ fprintf(fp, "%s%s", sep, "asm+safe"); sep = ", "; }
if (c->decompress_asm_fast)
{ fprintf(fp, "%s%s", sep, "fastasm"); sep = ", "; }
if (c->decompress_asm_fast_safe)
{ fprintf(fp, "%s%s", sep, "fastasm+safe"); sep = ", "; }
if (c->optimize)
{ fprintf(fp, "%s%s", sep, "optimize"); sep = ", "; }
fprintf(fp, "\n");
}
}
}
else
{
fprintf(fp,"\n");
fprintf(fp,"Type '%s -m' to list all available methods.\n", name);
}
fflush(fp);
if (exit_code < 0)
exit_code = EXIT_USAGE;
exit(exit_code);
}
static
void license(void)
{
FILE *fp;
fp = stdout;
fflush(stdout); fflush(stderr);
#if defined(__LZO_PROFESSIONAL__)
# include "lzopro/license.ch"
#else
fprintf(fp,
" 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"
);
fprintf(fp,
"\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"
" 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n"
"\n"
" Markus F.X.J. Oberhumer\n"
" <markus@oberhumer.com>\n"
" http://www.oberhumer.com/opensource/lzo/\n"
"\n"
);
#endif
fflush(fp);
exit(EXIT_OK);
}
/*************************************************************************
// parse method option '-m'
**************************************************************************/
static int methods[256+1];
static int methods_n = 0;
static void add_method(int m)
{
int i;
if (m > 0)
{
if (!find_method_by_id(m)) {
fprintf(stdout,"%s: invalid method %d\n",progname,m);
exit(EXIT_USAGE);
}
for (i = 0; i < methods_n; i++)
if (methods[i] == m)
return;
if (methods_n >= 256)
{
fprintf(stderr,"%s: too many methods\n",progname);
exit(EXIT_USAGE);
}
methods[methods_n++] = m;
methods[methods_n] = 0;
}
}
static void add_methods(const int *ml)
{
while (*ml != 0)
add_method(*ml++);
}
static void add_all_methods(int first, int last)
{
int m;
for (m = first; m <= last; m++)
if (find_method_by_id(m) != NULL)
add_method(m);
}
static int m_strcmp(const char *a, const char *b)
{
size_t n;
if (a[0] == 0 || b[0] == 0)
return 1;
n = strlen(b);
if (strncmp(a,b,n) == 0 && (a[n] == 0 || a[n] == ','))
return 0;
return 1;
}
static lzo_bool m_strisdigit(const char *s)
{
for (;;)
{
if (!is_digit(*s))
return 0;
s++;
if (*s == 0 || *s == ',')
break;
}
return 1;
}
static void parse_methods(const char *p)
{
const compress_t *c;
for (;;)
{
if (p == NULL || p[0] == 0)
usage(progname,-1,1);
else if ((c = find_method_by_name(p)) != NULL)
add_method(c->id);
else if (m_strcmp(p,"all") == 0 || m_strcmp(p,"avail") == 0)
add_all_methods(1,M_LAST_COMPRESSOR);
else if (m_strcmp(p,"ALL") == 0)
{
add_all_methods(1,M_LAST_COMPRESSOR);
add_all_methods(9721,9729);
add_all_methods(9781,9789);
}
else if (m_strcmp(p,"lzo") == 0)
add_all_methods(1,M_MEMCPY);
else if (m_strcmp(p,"bench") == 0)
add_methods(benchmark_methods);
else if (m_strcmp(p,"m1") == 0)
add_methods(x1_methods);
else if (m_strcmp(p,"m99") == 0)
add_methods(x99_methods);
else if (m_strcmp(p,"m999") == 0)
add_methods(x999_methods);
else if (m_strcmp(p,"1x999") == 0)
add_all_methods(9721,9729);
else if (m_strcmp(p,"1y999") == 0)
add_all_methods(9821,9829);
#if defined(ALG_ZLIB)
else if (m_strcmp(p,"zlib") == 0)
add_all_methods(M_ZLIB_8_1,M_ZLIB_8_9);
#endif
#if defined(ALG_BZIP2)
else if (m_strcmp(p,"bzip2") == 0)
add_all_methods(M_BZIP2_1,M_BZIP2_9);
#endif
#if defined(__LZO_PROFESSIONAL__)
# include "lzopro/t_opt_m.ch"
#endif
else if (m_strisdigit(p))
add_method(atoi(p));
else
{
printf("%s: invalid method '%s'\n\n",progname,p);
exit(EXIT_USAGE);
}
while (*p && *p != ',')
p++;
while (*p == ',')
p++;
if (*p == 0)
return;
}
}
/*************************************************************************
// options
**************************************************************************/
enum {
OPT_LONGOPT_ONLY = 512,
OPT_ADLER32,
OPT_CALGARY_CORPUS,
OPT_CLEAR_WRKMEM,
OPT_CRC32,
OPT_DICT,
OPT_DUMP,
OPT_EXECUTION_TIME,
OPT_MAX_DATA_LEN,
OPT_MAX_DICT_LEN,
OPT_SILESIA_CORPUS,
OPT_PCLOCK,
OPT_UNUSED
};
static const struct lzo_getopt_longopt_t longopts[] =
{
/* { name has_arg *flag val } */
{"help", 0, 0, 'h'+256}, /* give help */
{"license", 0, 0, 'L'}, /* display software license */
{"quiet", 0, 0, 'q'}, /* quiet mode */
{"verbose", 0, 0, 'v'}, /* verbose mode */
{"version", 0, 0, 'V'+256}, /* display version number */
{"adler32", 0, 0, OPT_ADLER32},
{"calgary-corpus", 1, 0, OPT_CALGARY_CORPUS},
{"clear-wrkmem", 0, 0, OPT_CLEAR_WRKMEM},
{"clock", 1, 0, OPT_PCLOCK},
{"corpus", 1, 0, OPT_CALGARY_CORPUS},
{"crc32", 0, 0, OPT_CRC32},
{"dict", 1, 0, OPT_DICT},
{"dump-compressed", 1, 0, OPT_DUMP},
{"execution-time", 0, 0, OPT_EXECUTION_TIME},
{"max-data-length", 1, 0, OPT_MAX_DATA_LEN},
{"max-dict-length", 1, 0, OPT_MAX_DICT_LEN},
{"silesia-corpus", 1, 0, OPT_SILESIA_CORPUS},
{"uclock", 1, 0, OPT_PCLOCK},
{"methods", 1, 0, 'm'},
{"totals", 0, 0, 'T'},
{ 0, 0, 0, 0 }
};
static int do_option(lzo_getopt_p g, int optc)
{
#define mfx_optarg g->optarg
switch (optc)
{
case 'A':
opt_use_asm_decompressor = 1;
break;
case 'b':
opt_block_size = 0; /* set to opt_max_data_len later */
if (mfx_optarg)
{
if (!mfx_optarg || !is_digit(mfx_optarg[0]))
return optc;
opt_block_size = atol(mfx_optarg);
}
break;
case 'c':
case 'C':
if (!mfx_optarg || !is_digit(mfx_optarg[0]))
return optc;
opt_c_loops = atol(mfx_optarg);
break;
case 'd':
case 'D':
if (!mfx_optarg || !is_digit(mfx_optarg[0]))
return optc;
opt_d_loops = atol(mfx_optarg);
break;
case 'F':
opt_use_asm_fast_decompressor = 1;
break;
case 'h':
case 'H':
case '?':
case 'h'+256:
usage(progname,EXIT_OK,0);
break;
case 'L':
license();
break;
case 'm':
parse_methods(mfx_optarg);
break;
case 'n':
if (!mfx_optarg || !is_digit(mfx_optarg[0]))
return optc;
opt_c_loops = opt_d_loops = atol(mfx_optarg);
break;
case 'O':
opt_optimize_compressed_data = 1;
break;
case 'q':
opt_verbose -= 1;
break;
case 'Q':
opt_verbose = 0;
break;
case 's':
case OPT_CALGARY_CORPUS:
if (!mfx_optarg || !mfx_optarg[0])
return optc;
opt_corpus_path = mfx_optarg;
opt_corpus = calgary_corpus;
break;
case OPT_SILESIA_CORPUS:
if (!mfx_optarg || !mfx_optarg[0])
return optc;
opt_corpus_path = mfx_optarg;
opt_corpus = silesia_corpus;
break;
case 'S':
opt_use_safe_decompressor = 1;
break;
case 'T':
opt_totals += 1;
break;
case 'v':
opt_verbose += 1;
break;
case 'V':
case 'V'+256:
exit(EXIT_OK);
break;
case '@':
opt_read_from_stdin = 1;
break;
case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9':
/* this is a dirty hack... */
if (g->shortpos == 0) {
char m[2]; m[0] = (char) optc; m[1] = 0;
parse_methods(m);
} else {
const char *m = &g->argv[g->optind][g->shortpos-1];
parse_methods(m);
++g->optind; g->shortpos = 0;
}
break;
case OPT_ADLER32:
opt_compute_adler32 = 1;
break;
case OPT_CLEAR_WRKMEM:
opt_clear_wrkmem = 1;
break;
case OPT_CRC32:
opt_compute_crc32 = 1;
break;
case OPT_DICT:
opt_dict = 1;
opt_dictionary_file = mfx_optarg;
break;
case OPT_EXECUTION_TIME:
opt_execution_time = 1;
break;
case OPT_DUMP:
opt_dump_compressed_data = mfx_optarg;
break;
case OPT_MAX_DATA_LEN:
if (!mfx_optarg || !is_digit(mfx_optarg[0]))
return optc;
opt_max_data_len = atol(mfx_optarg);
break;
case OPT_MAX_DICT_LEN:
if (!mfx_optarg || !is_digit(mfx_optarg[0]))
return optc;
opt_max_dict_len = atol(mfx_optarg);
break;
case OPT_PCLOCK:
if (!mfx_optarg || !is_digit(mfx_optarg[0]))
return optc;
opt_pclock = atoi(mfx_optarg);
#if defined(__LZOLIB_PCLOCK_CH_INCLUDED)
if (opt_pclock > 0)
pch.mode = opt_pclock;
#endif
break;
case '\0':
return -1;
case ':':
return -2;
default:
fprintf(stderr,"%s: internal error in getopt (%d)\n",progname,optc);
return -3;
}
return 0;
#undef mfx_optarg
}
static void handle_opterr(lzo_getopt_p g, const char *f, void *v)
{
struct A { va_list ap; };
struct A *a = (struct A *) v;
fprintf( stderr, "%s: ", g->progname);
if (a)
vfprintf(stderr, f, a->ap);
else
fprintf( stderr, "UNKNOWN GETOPT ERROR");
fprintf( stderr, "\n");
}
static int get_options(int argc, char **argv)
{
lzo_getopt_t mfx_getopt;
int optc;
static const char shortopts[] =
"Ab::c:C:d:D:FhHLm::n:OqQs:STvV@123456789";
lzo_getopt_init(&mfx_getopt, 1, argc, argv);
mfx_getopt.progname = progname;
mfx_getopt.opterr = handle_opterr;
while ((optc = lzo_getopt(&mfx_getopt, shortopts, longopts, NULL)) >= 0)
{
if (do_option(&mfx_getopt, optc) != 0)
exit(EXIT_USAGE);
}
return mfx_getopt.optind;
}
/*************************************************************************
// main
**************************************************************************/
int __lzo_cdecl_main main(int argc, char *argv[])
{
int r = EXIT_OK;
int i, ii;
int m;
time_t t_total;
const char *s;
lzo_wildargv(&argc, &argv);
lzo_pclock_open_default(&pch);
progname = argv[0];
for (s = progname; *s; s++)
if ((*s == '/' || *s == '\\') && s[1])
progname = s + 1;
#if defined(__LZO_PROFESSIONAL__)
printf("\nLZO Professional real-time data compression library (v%s, %s).\n",
lzo_version_string(), lzo_version_date());
printf("Copyright (C) 1996-2014 Markus Franz Xaver Johannes Oberhumer\nAll Rights Reserved.\n\n");
#else
printf("\nLZO real-time data compression library (v%s, %s).\n",
lzo_version_string(), lzo_version_date());
printf("Copyright (C) 1996-2014 Markus Franz Xaver Johannes Oberhumer\nAll Rights Reserved.\n\n");
#endif
/*
* Step 1: initialize the LZO library
*/
if (lzo_init() != LZO_E_OK)
{
printf("internal error - lzo_init() failed !!!\n");
printf("(this usually indicates a compiler bug - try recompiling\nwithout optimizations, and enable `-DLZO_DEBUG' for diagnostics)\n");
exit(1);
}
/*
* Step 2: setup default options
*/
opt_max_data_len = 64 * 1024L * 1024L;
opt_block_size = 256 * 1024L;
#if (LZO_ARCH_M68K && LZO_OS_TOS)
/* reduce memory requirements for 14 MB machines */
opt_max_data_len = 8 * 1024L * 1024L;
#endif
/*
* Step 3: parse options
*/
if (argc < 2)
usage(progname,-1,0);
i = get_options(argc,argv);
if (methods_n == 0)
add_method(default_method);
if (methods_n > 1 && opt_read_from_stdin)
{
printf("%s: cannot use multiple methods and '-@'\n", progname);
exit(EXIT_USAGE);
}
if (opt_block_size == 0)
opt_block_size = opt_max_data_len;
if (opt_block_size > opt_max_data_len)
opt_block_size = opt_max_data_len;
if (opt_c_loops < 1)
opt_c_loops = 1;
if (opt_d_loops < 1)
opt_d_loops = 1;
/*
* Step 4: start work
*/
block_w.len = 0;
for (ii = 0; ii < methods_n; ii++) {
const compress_t *c = find_method_by_id(methods[ii]);
assert(c != NULL);
if (c->mem_compress > block_w.len)
block_w.len = c->mem_compress;
if (c->mem_decompress > block_w.len)
block_w.len = c->mem_decompress;
}
mb_alloc(&block_w, block_w.len);
lzo_memset(block_w.ptr, 0, block_w.len);
#if !defined(__LZO_CHECKER)
mb_alloc_extra(&block_c, opt_block_size + get_max_compression_expansion(-1, opt_block_size), 16, 16);
mb_alloc_extra(&block_d, opt_block_size + get_max_decompression_overrun(-1, opt_block_size), 16, 16);
#endif
if (opt_dict)
{
opt_optimize_compressed_data = 0;
dict_alloc(opt_max_dict_len);
if (opt_dictionary_file)
{
dict_load(opt_dictionary_file);
if (dict.len > 0)
printf("Using dictionary '%s', %lu bytes, ID 0x%08lx.\n",
opt_dictionary_file,
(unsigned long) dict.len, (unsigned long) dict.adler);
}
if (dict.len == 0)
{
dict_set_default();
printf("Using default dictionary, %lu bytes, ID 0x%08lx.\n",
(unsigned long) dict.len, (unsigned long) dict.adler);
}
}
t_total = time(NULL);
ii = i;
for (m = 0; m < methods_n && r == EXIT_OK; m++)
{
int method = methods[m];
i = ii;
if (i >= argc && opt_corpus_path == NULL && !opt_read_from_stdin)
usage(progname,-1,0);
if (m == 0 && opt_verbose >= 1)
printf("%lu block-size\n\n", (unsigned long) opt_block_size);
assert(find_method_by_id(method) != NULL);
if (opt_corpus_path != NULL)
r = do_corpus(opt_corpus, method, opt_corpus_path,
opt_c_loops, opt_d_loops);
else
{
for ( ; i < argc && r == EXIT_OK; i++)
{
r = do_file(method,argv[i],opt_c_loops,opt_d_loops,NULL,NULL);
if (r == EXIT_FILE) /* ignore file errors */
r = EXIT_OK;
}
if (opt_read_from_stdin)
{
char buf[512], *p;
while (r == EXIT_OK && fgets(buf,sizeof(buf)-1,stdin) != NULL)
{
buf[sizeof(buf)-1] = 0;
p = buf + strlen(buf);
while (p > buf && is_space(p[-1]))
*--p = 0;
p = buf;
while (*p && is_space(*p))
p++;
if (*p)
r = do_file(method,p,opt_c_loops,opt_d_loops,NULL,NULL);
if (r == EXIT_FILE) /* ignore file errors */
r = EXIT_OK;
}
opt_read_from_stdin = 0;
}
}
}
t_total = time(NULL) - t_total;
if (opt_totals)
print_totals();
if (opt_execution_time || (methods_n > 1 && opt_verbose >= 1))
printf("\n%s: execution time: %lu seconds\n", progname, (unsigned long) t_total);
if (r != EXIT_OK)
printf("\n%s: exit code: %d\n", progname, r);
lzo_pclock_close(&pch);
return r;
}
/* vim:set ts=4 sw=4 et: */