int main(int argc, char *argv[])
{
lzo_bytep block;
lzo_uint block_len;
lzo_uint32 adler, crc;
if (argc < 0 && argv == NULL) /* avoid warning about unused args */
return 0;
if (lzo_init() != LZO_E_OK)
{
printf("lzo_init() failed !!!\n");
return 4;
}
/* prepare the block */
block_len = 128 * 1024L;
block = (lzo_bytep) lzo_malloc(block_len);
if (block == NULL)
{
printf("out of memory\n");
return 3;
}
lzo_memset(block, 0, block_len);
/* adler32 checksum */
adler = lzo_adler32(0, NULL, 0);
adler = lzo_adler32(adler, block, block_len);
if (adler != 0x001e0001UL)
{
printf("adler32 checksum error !!! (0x%08lx)\n", (long) adler);
return 2;
}
/* crc32 checksum */
crc = lzo_crc32(0, NULL, 0);
crc = lzo_crc32(crc, block, block_len);
if (crc != 0x7ee8cdcdUL)
{
printf("crc32 checksum error !!! (0x%08lx)\n", (long) crc);
return 1;
}
lzo_free(block);
printf("Checksum test passed.\n");
return 0;
}
static void init_default_dict(void)
{
lzo_uint i, j, d, dd;
dict_len = DICT_LEN;
lzo_memset(dict,0,dict_len);
/* this default dictionary does not provide good contexts... */
dd = dict_len;
if (dd >= 16 * 256)
{
dd -= 16 * 256;
for (i = 0, d = dd; i < 256; i++)
for (j = 0; j < 16; j++)
dict[d++] = (unsigned char) i;
}
dict_adler32 = lzo_adler32(0,NULL,0);
dict_adler32 = lzo_adler32(dict_adler32,dict,dict_len);
}
int __lzo_cdecl_main main(int argc, char *argv[])
{
int r;
lzo_bytep in;
lzo_bytep out;
lzo_voidp wrkmem;
lzo_uint in_len;
lzo_uint out_len;
lzo_uint new_len;
if (argc < 0 && argv == NULL) /* avoid warning about unused args */
return 0;
printf("\nLZO real-time data compression library (v%s, %s).\n",
lzo_version_string(), lzo_version_date());
printf("Copyright (C) 1996-2011 Markus Franz Xaver Johannes Oberhumer\nAll Rights Reserved.\n\n");
/*
* 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");
return 4;
}
/*
* Step 2: allocate blocks and the work-memory
*/
in = (lzo_bytep) xmalloc(IN_LEN);
out = (lzo_bytep) xmalloc(OUT_LEN);
wrkmem = (lzo_voidp) xmalloc(LZO1X_1_MEM_COMPRESS);
if (in == NULL || out == NULL || wrkmem == NULL)
{
printf("out of memory\n");
return 3;
}
/*
* Step 3: prepare the input block that will get compressed.
* We just fill it with zeros in this example program,
* but you would use your real-world data here.
*/
in_len = IN_LEN;
lzo_memset(in,0,in_len);
/*
* Step 4: compress from 'in' to 'out' with LZO1X-1
*/
r = lzo1x_1_compress(in,in_len,out,&out_len,wrkmem);
if (r == LZO_E_OK)
printf("compressed %lu bytes into %lu bytes\n",
(unsigned long) in_len, (unsigned long) out_len);
else
{
/* this should NEVER happen */
printf("internal error - compression failed: %d\n", r);
return 2;
}
/* check for an incompressible block */
if (out_len >= in_len)
{
printf("This block contains incompressible data.\n");
return 0;
}
/*
* Step 5: decompress again, now going from 'out' to 'in'
*/
new_len = in_len;
r = lzo1x_decompress(out,out_len,in,&new_len,NULL);
if (r == LZO_E_OK && new_len == in_len)
printf("decompressed %lu bytes back into %lu bytes\n",
(unsigned long) out_len, (unsigned long) in_len);
else
{
/* this should NEVER happen */
printf("internal error - decompression failed: %d\n", r);
return 1;
}
lzo_free(wrkmem);
lzo_free(out);
lzo_free(in);
printf("Simple compression test passed.\n");
return 0;
}
int __lzo_cdecl_main main(int argc, char *argv[])
{
int r;
lzo_bytep in;
lzo_uint in_len;
lzo_bytep out;
lzo_uint out_bufsize;
lzo_uint out_len = 0;
lzo_voidp wrkmem;
lzo_uint wrkmem_size;
lzo_uint best_len;
int best_compress = -1;
lzo_uint orig_len;
lzo_uint32_t uncompressed_checksum;
lzo_uint32_t compressed_checksum;
FILE *fp;
const char *in_name = NULL;
const char *out_name = NULL;
long l;
lzo_wildargv(&argc, &argv);
printf("\nLZO real-time data compression library (v%s, %s).\n",
lzo_version_string(), lzo_version_date());
printf("Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer\nAll Rights Reserved.\n\n");
progname = argv[0];
if (argc < 2 || argc > 3)
{
printf("usage: %s file [output-file]\n", progname);
exit(1);
}
in_name = argv[1];
if (argc > 2) out_name = argv[2];
/*
* 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: allocate the work-memory
*/
wrkmem_size = 1;
#ifdef USE_LZO1X
wrkmem_size = (LZO1X_999_MEM_COMPRESS > wrkmem_size) ? LZO1X_999_MEM_COMPRESS : wrkmem_size;
#endif
#ifdef USE_LZO1Y
wrkmem_size = (LZO1Y_999_MEM_COMPRESS > wrkmem_size) ? LZO1Y_999_MEM_COMPRESS : wrkmem_size;
#endif
wrkmem = (lzo_voidp) xmalloc(wrkmem_size);
if (wrkmem == NULL)
{
printf("%s: out of memory\n", progname);
exit(1);
}
/*
* Step 3: open the input file
*/
fp = fopen(in_name,"rb");
if (fp == NULL)
{
printf("%s: cannot open file %s\n", progname, in_name);
exit(1);
}
fseek(fp, 0, SEEK_END);
l = ftell(fp);
fseek(fp, 0, SEEK_SET);
if (l <= 0)
{
printf("%s: %s: empty file\n", progname, in_name);
fclose(fp); fp = NULL;
exit(1);
}
in_len = (lzo_uint) l;
out_bufsize = in_len + in_len / 16 + 64 + 3;
best_len = in_len;
/*
* Step 4: allocate compression buffers and read the file
*/
in = (lzo_bytep) xmalloc(in_len);
out = (lzo_bytep) xmalloc(out_bufsize);
if (in == NULL || out == NULL)
{
printf("%s: out of memory\n", progname);
exit(1);
}
in_len = (lzo_uint) lzo_fread(fp, in, in_len);
printf("%s: loaded file %s: %ld bytes\n", progname, in_name, (long) in_len);
fclose(fp); fp = NULL;
/*
* Step 5: compute a checksum of the uncompressed data
*/
uncompressed_checksum = lzo_adler32(0,NULL,0);
uncompressed_checksum = lzo_adler32(uncompressed_checksum,in,in_len);
/*
* Step 6a: compress from 'in' to 'out' with LZO1X-999
*/
#ifdef USE_LZO1X
out_len = out_bufsize;
r = lzo1x_999_compress(in,in_len,out,&out_len,wrkmem);
if (r != LZO_E_OK)
{
/* this should NEVER happen */
printf("internal error - compression failed: %d\n", r);
exit(1);
}
printf("LZO1X-999: %8lu -> %8lu\n", (unsigned long) in_len, (unsigned long) out_len);
if (out_len < best_len)
{
best_len = out_len;
best_compress = 1; /* LZO1X-999 */
}
#endif /* USE_LZO1X */
/*
* Step 6b: compress from 'in' to 'out' with LZO1Y-999
*/
#ifdef USE_LZO1Y
out_len = out_bufsize;
r = lzo1y_999_compress(in,in_len,out,&out_len,wrkmem);
if (r != LZO_E_OK)
{
/* this should NEVER happen */
printf("internal error - compression failed: %d\n", r);
exit(1);
}
printf("LZO1Y-999: %8lu -> %8lu\n", (unsigned long) in_len, (unsigned long) out_len);
if (out_len < best_len)
{
best_len = out_len;
best_compress = 2; /* LZO1Y-999 */
}
#endif /* USE_LZO1Y */
/*
* Step 7: check if compressible
*/
if (best_len >= in_len)
{
printf("This file contains incompressible data.\n");
return 0;
}
/*
* Step 8: compress data again using the best compressor found
*/
out_len = out_bufsize;
if (best_compress == 1)
r = lzo1x_999_compress(in,in_len,out,&out_len,wrkmem);
else if (best_compress == 2)
r = lzo1y_999_compress(in,in_len,out,&out_len,wrkmem);
else
r = -100;
assert(r == LZO_E_OK);
assert(out_len == best_len);
/*
* Step 9: optimize compressed data (compressed data is in 'out' buffer)
*/
#if 1
/* Optimization does not require any data in the buffer that will
* hold the uncompressed data. To prove this, we clear the buffer.
*/
lzo_memset(in,0,in_len);
#endif
orig_len = in_len;
r = -100;
#ifdef USE_LZO1X
if (best_compress == 1)
r = lzo1x_optimize(out,out_len,in,&orig_len,NULL);
#endif
#ifdef USE_LZO1Y
if (best_compress == 2)
r = lzo1y_optimize(out,out_len,in,&orig_len,NULL);
#endif
if (r != LZO_E_OK || orig_len != in_len)
{
/* this should NEVER happen */
printf("internal error - optimization failed: %d\n", r);
exit(1);
}
/*
* Step 10: compute a checksum of the compressed data
*/
compressed_checksum = lzo_adler32(0,NULL,0);
compressed_checksum = lzo_adler32(compressed_checksum,out,out_len);
/*
* Step 11: write compressed data to a file
*/
printf("%s: %s: %ld -> %ld, checksum 0x%08lx 0x%08lx\n",
progname, in_name, (long) in_len, (long) out_len,
(long) uncompressed_checksum, (long) compressed_checksum);
if (out_name && out_name[0])
{
printf("%s: writing to file %s\n", progname, out_name);
fp = fopen(out_name,"wb");
if (fp == NULL)
{
printf("%s: cannot open output file %s\n", progname, out_name);
exit(1);
}
if (lzo_fwrite(fp, out, out_len) != out_len || fclose(fp) != 0)
{
printf("%s: write error !!\n", progname);
exit(1);
}
}
/*
* Step 12: verify decompression
*/
#ifdef PARANOID
lzo_memset(in,0,in_len); /* paranoia - clear output buffer */
orig_len = in_len;
r = -100;
#ifdef USE_LZO1X
if (best_compress == 1)
r = lzo1x_decompress_safe(out,out_len,in,&orig_len,NULL);
#endif
#ifdef USE_LZO1Y
if (best_compress == 2)
r = lzo1y_decompress_safe(out,out_len,in,&orig_len,NULL);
#endif
if (r != LZO_E_OK || orig_len != in_len)
{
/* this should NEVER happen */
printf("internal error - decompression failed: %d\n", r);
exit(1);
}
if (uncompressed_checksum != lzo_adler32(lzo_adler32(0,NULL,0),in,in_len))
{
/* this should NEVER happen */
printf("internal error - decompression data error\n");
exit(1);
}
/* Now you could also verify decompression under similar conditions as in
* your application, e.g. overlapping assembler decompression etc.
*/
#endif
lzo_free(in);
lzo_free(out);
lzo_free(wrkmem);
return 0;
}
static
int process_file ( const compress_t *c, lzo_decompress_t decompress,
const char *method_name,
const char *file_name, lzo_uint l,
int t_loops, int c_loops, int d_loops )
{
int i;
unsigned blocks = 0;
unsigned long compressed_len = 0;
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;
}
bool DecompressLZOCompressedPackage(UPKReader *Package)
{
if (!Package->IsCompressed())
{
_LogError("Package is not compressed!", "DecompressLZO");
return false;
}
if (!Package->IsLZOCompressed() && !Package->IsFullyCompressed())
{
_LogError("Cannot decompress non-LZO compressed packages!", "DecompressLZO");
return false;
}
/// init lzo library
int lzo_err;
lzo_uint in_len;
lzo_uint out_len;
lzo_uint new_len;
if (lzo_init() != LZO_E_OK)
{
_LogError("LZO library internal error: lzo_init() failed!", "DecompressLZO");
return false;
}
lzo_memset(in, 0, IN_LEN);
std::stringstream decompressed_stream;
unsigned int NumCompressedChunks = Package->Summary.NumCompressedChunks;
if (Package->IsFullyCompressed())
{
NumCompressedChunks = 1;
}
else
{
_LogDebug("Resetting package compression flags...", "DecompressLZO");
/// reset compression flags
Package->Summary.CompressionFlags = 0;
Package->Summary.PackageFlags ^= (uint32_t)UPackageFlags::Compressed;
Package->Summary.NumCompressedChunks = 0;
/// serialize package summary
std::vector<char> sVect = Package->SerializeSummary();
decompressed_stream.write(sVect.data(), sVect.size());
}
_LogDebug("Decompressing...", "DecompressLZO");
for (unsigned int i = 0; i < NumCompressedChunks; ++i)
{
if (Package->IsFullyCompressed())
{
Package->UPKStream.seekg(0);
}
else
{
Package->UPKStream.seekg(Package->Summary.CompressedChunks[i].CompressedOffset);
}
_LogDebug("Decompressing chunk #" + ToString(i), "DecompressLZO");
uint32_t tag = 0;
Package->UPKStream.read(reinterpret_cast<char*>(&tag), 4);
if (tag != 0x9E2A83C1)
{
_LogError("Missing 0x9E2A83C1 signature!", "DecompressLZO");
return false;
}
uint32_t blockSize = 0;
Package->UPKStream.read(reinterpret_cast<char*>(&blockSize), 4);
if (blockSize != IN_LEN)
{
_LogError("Incorrect max block size!", "DecompressLZO");
return false;
}
std::vector<uint32_t> sizes(2); /// compressed/uncompressed pairs
Package->UPKStream.read(reinterpret_cast<char*>(sizes.data()), 4 * sizes.size());
size_t dataSize = sizes[1]; /// uncompressed data chunk size
unsigned numBlocks = (dataSize + blockSize - 1) / blockSize;
_LogDebug("numBlocks = " + ToString(numBlocks), "DecompressLZO");
if (numBlocks < 1)
{
_LogError("Bad data!", "DecompressLZO");
return false;
}
sizes.resize((numBlocks + 1)*2);
Package->UPKStream.read(reinterpret_cast<char*>(sizes.data()) + 8, 4 * sizes.size() - 8);
for (unsigned i = 0; i <= numBlocks; ++i)
{
_LogDebug("Compressed size = " + ToString(sizes[i * 2]) +
+ "\tUncompressed size = " + ToString(sizes[i * 2 + 1]), "DecompressLZO");
}
std::vector<unsigned char> dataChunk(dataSize);
std::vector<unsigned char> compressedData(sizes[0]);
Package->UPKStream.read(reinterpret_cast<char*>(compressedData.data()), compressedData.size());
size_t blockOffset = 0;
size_t dataOffset = 0;
for (unsigned i = 1; i <= numBlocks; ++i)
{
out_len = sizes[i * 2]; /// compressed size
lzo_memcpy(out, compressedData.data() + blockOffset, out_len);
in_len = sizes[i * 2 + 1]; /// uncompressed size
new_len = in_len;
lzo_err = lzo1x_decompress(out, out_len, in, &new_len, NULL);
if (lzo_err == LZO_E_OK && new_len == in_len)
{
_LogDebug("Decompressed " + ToString(out_len) + " bytes back into "
+ ToString(in_len), "DecompressLZO");
}
else
{
_LogError("LZO library internal error: decompression failed!", "DecompressLZO");
return false;
}
lzo_memcpy(dataChunk.data() + dataOffset, in, in_len);
blockOffset += out_len;
dataOffset += in_len;
}
decompressed_stream.write(reinterpret_cast<char*>(dataChunk.data()), dataSize);
}
_LogDebug("Package decompressed successfully.", "DecompressLZO");
Package->UPKStream.str(decompressed_stream.str());
return Package->ReadPackageHeader();
}
void _lzo1c_stats_init(lzo_stats_t *lzo_stats)
{
lzo_memset(lzo_stats,0,sizeof(*lzo_stats));
}
int main(int argc, char *argv[])
{
int r;
int lazy;
const int max_try_lazy = 5;
const lzo_uint big = 65536L; /* can result in very slow compression */
const lzo_uint32 flags = 0x1;
lzo_byte *in;
lzo_uint in_len;
lzo_byte *out;
lzo_uint out_len = 0;
lzo_byte *wrkmem;
lzo_uint wrk_len;
lzo_uint best_len;
int best_compress = -1;
int best_lazy = -1;
lzo_uint orig_len;
lzo_uint32 uncompressed_checksum;
lzo_uint32 compressed_checksum;
FILE *f;
const char *progname = NULL;
const char *in_name = NULL;
const char *out_name = NULL;
long l;
#if defined(__EMX__)
_response(&argc,&argv);
_wildcard(&argc,&argv);
#endif
printf("\nLZO real-time data compression library (v%s, %s).\n",
lzo_version_string(), lzo_version_date());
printf("Copyright (C) 1996-2002 Markus Franz Xaver Johannes Oberhumer\n\n");
progname = argv[0];
if (argc < 2 || argc > 3)
{
printf("usage: %s file [output-file]\n", progname);
exit(1);
}
in_name = argv[1];
out_name = (argc > 2) ? argv[2] : NULL;
/*
* Step 1: initialize the LZO library
*/
if (lzo_init() != LZO_E_OK)
{
printf("lzo_init() failed !!!\n");
exit(1);
}
/*
* Step 2: allocate the work-memory
*/
wrk_len = 1;
#ifdef USE_LZO1X
if (wrk_len < LZO1X_999_MEM_COMPRESS)
wrk_len = LZO1X_999_MEM_COMPRESS;
#endif
#ifdef USE_LZO1Y
if (wrk_len < LZO1Y_999_MEM_COMPRESS)
wrk_len = LZO1Y_999_MEM_COMPRESS;
#endif
wrkmem = (lzo_bytep) lzo_malloc(wrk_len);
if (wrkmem == NULL)
{
printf("%s: out of memory\n", progname);
exit(1);
}
/*
* Step 3: open the input file
*/
f = fopen(in_name,"rb");
if (f == NULL)
{
printf("%s: cannot open file %s\n", progname, in_name);
exit(1);
}
fseek(f,0,SEEK_END);
l = ftell(f);
fseek(f,0,SEEK_SET);
if (l <= 0)
{
printf("%s: %s: empty file\n", progname, in_name);
fclose(f);
exit(1);
}
in_len = (lzo_uint) l;
best_len = in_len;
/*
* Step 4: allocate compression buffers and read the file
*/
in = (lzo_bytep) lzo_malloc(in_len);
out = (lzo_bytep) lzo_malloc(in_len + in_len / 64 + 16 + 3);
if (in == NULL || out == NULL)
{
printf("%s: out of memory\n", progname);
exit(1);
}
in_len = lzo_fread(f,in,in_len);
printf("%s: loaded file %s: %ld bytes\n", progname, in_name, (long) in_len);
fclose(f);
/*
* Step 5: compute a checksum of the uncompressed data
*/
uncompressed_checksum = lzo_adler32(0,NULL,0);
uncompressed_checksum = lzo_adler32(uncompressed_checksum,in,in_len);
/*
* Step 6a: compress from `in' to `out' with LZO1X-999
*/
#ifdef USE_LZO1X
for (lazy = 0; lazy <= max_try_lazy; lazy++)
{
r = lzo1x_999_compress_internal(in,in_len,out,&out_len,wrkmem,
NULL, 0, 0,
lazy, big, big, big, big, flags);
if (r != LZO_E_OK)
{
/* this should NEVER happen */
printf("internal error - compression failed: %d\n", r);
exit(1);
}
printf("LZO1X-999: lazy =%2d: %8lu -> %8lu\n",
lazy, (long) in_len, (long) out_len);
if (out_len < best_len)
{
best_len = out_len;
best_lazy = lazy;
best_compress = 1; /* LZO1X-999 */
}
}
#endif /* USE_LZO1X */
/*
* Step 6b: compress from `in' to `out' with LZO1Y-999
*/
#ifdef USE_LZO1Y
for (lazy = 0; lazy <= max_try_lazy; lazy++)
{
r = lzo1y_999_compress_internal(in,in_len,out,&out_len,wrkmem,
NULL, 0, 0,
lazy, big, big, big, big, flags);
if (r != LZO_E_OK)
{
/* this should NEVER happen */
printf("internal error - compression failed: %d\n", r);
exit(1);
}
printf("LZO1Y-999: lazy =%2d: %8lu -> %8lu\n",
lazy, (long) in_len, (long) out_len);
if (out_len < best_len)
{
best_len = out_len;
best_lazy = lazy;
best_compress = 2; /* LZO1Y-999 */
}
}
#endif /* USE_LZO1Y */
/*
* Step 7: check if compressible
*/
if (best_len >= in_len)
{
printf("This file contains incompressible data.\n");
return 0;
}
/*
* Step 8: compress data again using the best compressor found
*/
if (best_compress == 1)
r = lzo1x_999_compress_internal(in,in_len,out,&out_len,wrkmem,
NULL, 0, 0,
best_lazy, big, big, big, big, flags);
else if (best_compress == 2)
r = lzo1y_999_compress_internal(in,in_len,out,&out_len,wrkmem,
NULL, 0, 0,
best_lazy, big, big, big, big, flags);
else
r = -100;
assert(r == LZO_E_OK);
assert(out_len == best_len);
/*
* Step 9: optimize compressed data (compressed data is in `out' buffer)
*/
#if 1
/* Optimization does not require any data in the buffer that will
* hold the uncompressed data. To prove this, we clear the buffer.
*/
lzo_memset(in,0,in_len);
#endif
orig_len = in_len;
if (best_compress == 1)
r = lzo1x_optimize(out,out_len,in,&orig_len,NULL);
else if (best_compress == 2)
r = lzo1y_optimize(out,out_len,in,&orig_len,NULL);
else
r = -100;
if (r != LZO_E_OK || orig_len != in_len)
{
/* this should NEVER happen */
printf("internal error - optimization failed: %d\n", r);
exit(1);
}
/*
* Step 10: compute a checksum of the compressed data
*/
compressed_checksum = lzo_adler32(0,NULL,0);
compressed_checksum = lzo_adler32(compressed_checksum,out,out_len);
/*
* Step 11: write compressed data to a file
*/
printf("%s: %s: %ld -> %ld, checksum 0x%08lx 0x%08lx\n",
progname, in_name, (long) in_len, (long) out_len,
(long) uncompressed_checksum, (long) compressed_checksum);
if (out_name && out_name[0])
{
printf("%s: writing to file %s\n", progname, out_name);
f = fopen(out_name,"wb");
if (f == NULL)
{
printf("%s: cannot open output file %s\n", progname, out_name);
exit(1);
}
if (lzo_fwrite(f,out,out_len) != out_len || fclose(f) != 0)
{
printf("%s: write error !!\n", progname);
exit(1);
}
}
/*
* Step 12: verify decompression
*/
#ifdef PARANOID
orig_len = in_len;
if (best_compress == 1)
r = lzo1x_decompress(out,out_len,in,&orig_len,NULL);
else if (best_compress == 2)
r = lzo1y_decompress(out,out_len,in,&orig_len,NULL);
else
r = -100;
if (r != LZO_E_OK || orig_len != in_len)
{
/* this should NEVER happen */
printf("internal error - decompression failed: %d\n", r);
exit(1);
}
if (uncompressed_checksum != lzo_adler32(lzo_adler32(0,NULL,0),in,in_len))
{
/* this should NEVER happen */
printf("internal error - decompression data error\n");
exit(1);
}
/* Now you could also verify decompression under similar conditions as in
* your application, e.g. overlapping assembler decompression etc.
*/
#endif
lzo_free(in);
lzo_free(out);
lzo_free(wrkmem);
return 0;
}
