383 lines
11 KiB
C
Executable File
383 lines
11 KiB
C
Executable File
/* precomp2.c -- example program: how to generate pre-compressed data
|
|
|
|
This file is part of the LZO real-time data compression library.
|
|
|
|
Copyright (C) 1996-2015 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/
|
|
*/
|
|
|
|
|
|
/*************************************************************************
|
|
// This program shows how to generate pre-compressed data.
|
|
//
|
|
// Please study precomp.c first.
|
|
//
|
|
// We will be trying LZO1X-999 and LZO1Y-999, and we will be trying
|
|
// various parameters using the internal interface to squeeze out
|
|
// a little bit of extra compression.
|
|
//
|
|
// NOTE: this program can be quite slow for highly redundant files
|
|
**************************************************************************/
|
|
|
|
#include <lzo/lzoconf.h>
|
|
#include <lzo/lzo1x.h>
|
|
#include <lzo/lzo1y.h>
|
|
|
|
LZO_EXTERN(int)
|
|
lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len,
|
|
lzo_bytep out, lzo_uintp out_len,
|
|
lzo_voidp wrkmem,
|
|
const lzo_bytep dict, lzo_uint dict_len,
|
|
lzo_callback_p cb,
|
|
int try_lazy,
|
|
lzo_uint good_length,
|
|
lzo_uint max_lazy,
|
|
lzo_uint nice_length,
|
|
lzo_uint max_chain,
|
|
lzo_uint32_t flags );
|
|
|
|
LZO_EXTERN(int)
|
|
lzo1y_999_compress_internal ( const lzo_bytep in , lzo_uint in_len,
|
|
lzo_bytep out, lzo_uintp out_len,
|
|
lzo_voidp wrkmem,
|
|
const lzo_bytep dict, lzo_uint dict_len,
|
|
lzo_callback_p cb,
|
|
int try_lazy,
|
|
lzo_uint good_length,
|
|
lzo_uint max_lazy,
|
|
lzo_uint nice_length,
|
|
lzo_uint max_chain,
|
|
lzo_uint32_t flags );
|
|
|
|
#define USE_LZO1X 1
|
|
#define USE_LZO1Y 1
|
|
|
|
#define PARANOID 1
|
|
|
|
|
|
/* portability layer */
|
|
static const char *progname = NULL;
|
|
#define WANT_LZO_MALLOC 1
|
|
#define WANT_LZO_FREAD 1
|
|
#define WANT_LZO_WILDARGV 1
|
|
#define WANT_XMALLOC 1
|
|
#include "examples/portab.h"
|
|
|
|
|
|
/*************************************************************************
|
|
//
|
|
**************************************************************************/
|
|
|
|
int __lzo_cdecl_main 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_t flags = 0x1;
|
|
|
|
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;
|
|
int best_lazy = -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-2015 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
|
|
for (lazy = 0; lazy <= max_try_lazy; lazy++)
|
|
{
|
|
out_len = out_bufsize;
|
|
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, (unsigned long) in_len, (unsigned 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++)
|
|
{
|
|
out_len = out_bufsize;
|
|
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, (unsigned long) in_len, (unsigned 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
|
|
*/
|
|
out_len = out_bufsize;
|
|
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;
|
|
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;
|
|
}
|
|
|
|
|
|
/* vim:set ts=4 sw=4 et: */
|