void Init_lzoruby() {
if (lzo_init() != LZO_E_OK) {
rb_warn("internal error - lzo_init() failed !!!");
return;
}
LZO = rb_define_module("LZO");
LZO_Error = rb_define_class_under(LZO, "Error", rb_eStandardError);
rb_define_const(LZO, "VERSION", rb_str_new2(VERSION));
rb_define_const(LZO, "LZO_VERSION", rb_str_new2(lzo_version_string()));
rb_define_module_function(LZO, "compress", lzoruby_compress, -1);
rb_define_module_function(LZO, "decompress", lzoruby_decompress, 1);
rb_define_module_function(LZO, "adler32", lzoruby_adler32, 2);
}
int __lzo_cdecl_main main(int argc, char *argv[])
{
int r;
int i = 1;
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-2011 Markus Franz Xaver Johannes Oberhumer\nAll Rights Reserved.\n\n");
progname = argv[0];
if (i < argc && argv[i][0] == '-')
opt_overhead = atoi(&argv[i++][1]);
#if 1
if (opt_overhead != 0 && opt_overhead < 8)
{
printf("%s: invalid overhead value %ld\n", progname, (long)opt_overhead);
exit(1);
}
#endif
if (i >= argc)
{
printf("usage: %s [-overhead_in_bytes] file..\n", progname);
exit(1);
}
/*
* 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: process files
*/
for (r = 0; r == 0 && i < argc; i++)
r = do_file(argv[i]);
printf("\nDone. Successfully processed %lu bytes in %lu files.\n",
total_in, total_files);
return r;
}
int __stdcall LZOGetMsg(char* buf, int bufsz, int msgID)
{
#pragma EXPORT
char* b = (char*)lastError;
if(msgID==0){
sprintf(b,"LZO real-time data compression library (v%s, %s).\n", lzo_version_string(), lzo_version_date());
strcat(b,"Copyright (C) 1996-2015 All Rights Reserved.\n");
strcat(b,"Markus Franz Xaver Johannes Oberhumer");
}
int sz = strlen(b);
if(sz==0) return 0;
if(sz >= bufsz-2) return 0;
strcpy(buf,b);
}
int __lzo_cdecl_main main(int argc, char *argv[])
{
int i = 1;
int r;
const char *dict_name;
FILE *f;
time_t t_total;
int level = 7;
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-2008 Markus Franz Xaver Johannes Oberhumer\nAll Rights Reserved.\n\n");
progname = argv[0];
if (i < argc && argv[i][0] == '-' && isdigit(argv[i][1]))
level = atoi(&argv[i++][1]);
if (i + 1 >= argc || level < 1 || level > 9)
{
printf("usage: %s [-level] [ dictionary-file | -n ] file...\n", progname);
exit(1);
}
printf("Compression level is LZO1X-999/%d\n", level);
/*
* 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: prepare the dictionary
*/
dict = (lzo_bytep) lzo_malloc(DICT_LEN);
if (dict == NULL)
{
printf("%s: out of memory\n", progname);
exit(1);
}
dict_name = argv[i++];
if (strcmp(dict_name,"-n") == 0)
{
dict_name = "empty";
dict_len = 0;
}
else
{
f = fopen(dict_name,"rb");
if (!f)
{
printf("%s: cannot open dictionary file %s\n", progname, dict_name);
exit(1);
}
dict_len = (lzo_uint) lzo_fread(f,dict,DICT_LEN);
fclose(f);
}
dict_adler32 = lzo_adler32(0,NULL,0);
dict_adler32 = lzo_adler32(dict_adler32,dict,dict_len);
printf("Using dictionary '%s', %ld bytes, ID 0x%08lx.\n",
dict_name, (long) dict_len, (long) dict_adler32);
/*
* Step 3: process files
*/
t_total = time(NULL);
for (r = 0; r == 0 && i < argc; i++)
r = do_file(argv[i], level);
t_total = time(NULL) - t_total;
lzo_free(dict);
if (total_n > 1)
print_file("***TOTALS***",total_d_len,total_c_len);
printf("Dictionary compression test %s, execution time %lu seconds.\n",
r == 0 ? "passed" : "FAILED", (unsigned long) t_total);
return r;
}
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;
}
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;
}
int main(int argc, char *argv[])
{
int r=0;
lzo_uint in_len, out_len, new_len;
struct stat in_fstat;
lzo_uint org_fsize=0,org_lines=0,max_bsize=IN_LEN;
void *com_cache;
void *data_cache;
void *workmem;
FILE *fi,*fo;
if (argc < 2){ /* avoid warning about unused args */
printf("\nLZO real-time data compression library (v%s, %s).\n",
lzo_version_string(), lzo_version_date());
printf("Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer\n\n");
printf("use %s <input file> <output file> [-s]\n",argv[0]);
return 0;
}
stat(argv[1], &in_fstat);
org_fsize=in_fstat.st_size;
if(!(fi=fopen(argv[1],"rb"))){
printf("open input file %s error!\n",argv[1]);
return(2);
}
if(!(fo=fopen(argv[2],"wb"))){
printf("creat output file error!\n");
return(3);
}
if(!(data_cache=malloc(IN_LEN))){
printf("malloc block space error!\n");
return(4);
}
if(!(com_cache=malloc(OUT_LEN))){
printf("malloc block space error!\n");
return(4);
}
if(!(workmem=malloc(WORK_LEN))){
printf("malloc block space error!\n");
return(4);
}
if (lzo_init() != LZO_E_OK)
{
printf("lzo_init() failed !!!\n");
return (5);
}
fwrite(PLZOMARK,sizeof(PLZOMARK)-1,1,fo);
fwrite(&org_fsize,sizeof(org_fsize),1,fo);
fwrite(&org_lines,sizeof(org_lines),1,fo);
fwrite(&max_bsize,sizeof(max_bsize),1,fo);
if(argc == 3)
puts("begin to compress.");
in_len=IN_LEN;
while(!feof(fi)){
new_len=fread(data_cache, 1, in_len, fi);
if(new_len > 0)
r = lzo1x_1_compress(data_cache, new_len, com_cache, &out_len, workmem);
else
break;
if (r != LZO_E_OK )
{
printf("internal error - compression failed: %d\n", r);
return 4;
}
if(argc==3)
printf("compressed %lu bytes into %lu bytes\n",(long) in_len, (long) out_len);
fwrite(BLOCKMARK,2,1,fo);
fwrite(&out_len,4,1,fo);
fwrite(&new_len,4,1,fo);
fwrite(com_cache,(size_t) out_len, 1, fo);
}
fwrite(BLOCKMARK,2,1,fo);
out_len=0;
fwrite(&out_len,4,1,fo);
fclose(fi);
fclose(fo);
free(com_cache);
free(data_cache);
free(workmem);
return 0;
}
