static void read_dict(const char *file_name) { FILE *f; dict_len = 0; f = fopen(file_name,"rb"); if (f) { dict_len = lzo_fread(f,dict,DICT_LEN); fclose(f); dict_adler32 = lzo_adler32(0,NULL,0); dict_adler32 = lzo_adler32(dict_adler32,dict,dict_len); } }
int do_file ( const char *in_name, int level ) { int r; lzo_bytep in; lzo_bytep out; lzo_bytep newb; lzo_bytep wrkmem; lzo_uint in_len; lzo_uint out_len; lzo_uint new_len; long l; FILE *f; /* * Step 1: open the input file */ f = fopen(in_name,"rb"); if (f == 0) { printf("%s: cannot open file %s\n", progname, in_name); return 0; /* no error */ } fseek(f,0,SEEK_END); l = ftell(f); fseek(f,0,SEEK_SET); if (l <= 0) { printf("%s: %s: empty file -- skipping\n", progname, in_name); fclose(f); return 0; } in_len = (lzo_uint) l; /* * Step 2: allocate compression buffers and read the file */ in = (lzo_bytep) lzo_malloc(in_len); out = (lzo_bytep) lzo_malloc(in_len + in_len / 16 + 64 + 3); newb = (lzo_bytep) lzo_malloc(in_len); wrkmem = (lzo_bytep) lzo_malloc(LZO1X_999_MEM_COMPRESS); if (in == NULL || out == NULL || newb == NULL || wrkmem == NULL) { printf("%s: out of memory\n", progname); exit(1); } in_len = (lzo_uint) lzo_fread(f,in,in_len); fclose(f); /* * Step 3: compress from `in' to `out' with LZO1X-999 */ r = lzo1x_999_compress_level(in,in_len,out,&out_len,wrkmem, dict, dict_len, 0, level); if (r != LZO_E_OK) { /* this should NEVER happen */ printf("internal error - compression failed: %d\n", r); return 1; } print_file(in_name,in_len,out_len); /* * Step 4: decompress again, now going from `out' to `newb' */ new_len = in_len; r = lzo1x_decompress_dict_safe(out,out_len,newb,&new_len,NULL,dict,dict_len); if (r != LZO_E_OK) { /* this should NEVER happen */ printf("internal error - decompression failed: %d\n", r); return 1; } /* * Step 5: verify decompression */ if (new_len != in_len || lzo_memcmp(in,newb,in_len) != 0) { /* this should NEVER happen */ printf("internal error - decompression data error\n"); return 1; } /* free buffers in reverse order to help malloc() */ lzo_free(wrkmem); lzo_free(newb); lzo_free(out); lzo_free(in); return 0; }
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_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 load_file ( const char *file_name, lzo_uintp len ) { FILE *f; long ll = -1; unsigned long ul; lzo_uint l; int r; #if 0 if (last_file && strcmp(file_name,last_file) == 0) { *len = last_len; return EXIT_OK; } #endif *len = 0; unload_file(); f = fopen(file_name,"rb"); if (f == NULL) { fprintf(stderr,"%s: ",file_name); perror("fopen"); fflush(stderr); return EXIT_FILE; } r = fseek(f,0,SEEK_END); if (r == 0) { ll = ftell(f); r = fseek(f,0,SEEK_SET); } if (r != 0 || ll < 0) { fprintf(stderr,"%s: ",file_name); perror("fseek"); fflush(stderr); return EXIT_FILE; } ul = ll; #ifdef USE_MALLOC l = (ul >= LZO_UINT_MAX - 512 ? LZO_UINT_MAX - 512 : (lzo_uint) ul); if (opt_max_data_len > 0 && l > opt_max_data_len) l = opt_max_data_len; _data = malloc (l + 256); if (_data == NULL) { perror("malloc"); fflush(stderr); return EXIT_MEM; } #else l = (ul >= DATA_LEN ? (lzo_uint) DATA_LEN : (lzo_uint) ul); if (opt_max_data_len > 0 && l > opt_max_data_len) l = opt_max_data_len; #endif data = LZO_PTR_ALIGN_UP(_data,256); l = lzo_fread(f,data,l); if (fclose(f) != 0) { unload_file(); fprintf(stderr,"%s: ",file_name); perror("fclose"); fflush(stderr); return EXIT_FILE; } last_file = file_name; last_len = l; *len = l; return EXIT_OK; }
int do_file ( const char *in_name ) { int r; FILE *fp = NULL; long l; lzo_voidp wrkmem = NULL; lzo_bytep in = NULL; lzo_uint in_len; /* uncompressed length */ lzo_bytep out = NULL; lzo_uint out_len; /* compressed length */ lzo_bytep overlap = NULL; lzo_uint overhead; lzo_uint offset; lzo_uint new_len = 0; /* * Step 1: open the input file */ fp = fopen(in_name, "rb"); if (fp == NULL) { printf("%s: %s: cannot open file\n", progname, in_name); goto next_file; } fseek(fp, 0, SEEK_END); l = ftell(fp); fseek(fp, 0, SEEK_SET); if (l <= 0) { printf("%s: %s: empty file -- skipping\n", progname, in_name); goto next_file; } in_len = (lzo_uint) l; /* * Step 2: allocate compression buffers and read the file */ in = (lzo_bytep) xmalloc(in_len); out = (lzo_bytep) xmalloc(in_len + in_len / 16 + 64 + 3); wrkmem = (lzo_voidp) xmalloc(LZO1X_1_MEM_COMPRESS); in_len = (lzo_uint) lzo_fread(fp, in, in_len); fclose(fp); fp = NULL; printf("%s: %s: read %lu bytes\n", progname, in_name, (unsigned long) in_len); total_files++; total_in += (unsigned long) in_len; /* * Step 3: compress from 'in' to 'out' with LZO1X-1 */ r = lzo1x_1_compress(in,in_len,out,&out_len,wrkmem); if (r != LZO_E_OK || out_len > in_len + in_len / 16 + 64 + 3) { /* this should NEVER happen */ printf("internal error - compression failed: %d\n", r); exit(1); } printf("%-26s %8lu -> %8lu\n", "LZO1X-1:", (unsigned long) in_len, (unsigned long) out_len); /***** Step 4: overlapping compression *****/ /* * Step 4a: allocate the 'overlap' buffer for overlapping compression */ overhead = in_len > 0xbfff ? 0xbfff : in_len; overhead += in_len / 16 + 64 + 3; overlap = (lzo_bytep) xmalloc(in_len + overhead); /* * Step 4b: prepare data in 'overlap' buffer. * copy uncompressed data at the top of the overlap buffer */ /*** offset = in_len + overhead - in_len; ***/ offset = overhead; lzo_memcpy(overlap + offset, in, in_len); /* * Step 4c: do an in-place compression within the 'overlap' buffer */ r = lzo1x_1_compress(overlap+offset,in_len,overlap,&new_len,wrkmem); if (r != LZO_E_OK) { /* this should NEVER happen */ printf("overlapping compression failed: %d\n", r); exit(1); } /* * Step 4d: verify overlapping compression */ if (new_len != out_len || lzo_memcmp(out,overlap,out_len) != 0) { /* As compression is non-deterministic there can be a difference * in the representation of the compressed data (but this usually * happens very seldom). So we have to verify the overlapping * compression by doing a temporary decompression. */ lzo_uint ll = in_len; lzo_bytep tmp = (lzo_bytep) xmalloc(ll); r = lzo1x_decompress_safe(overlap, new_len, tmp, &ll, NULL); if (r != LZO_E_OK || ll != in_len || lzo_memcmp(in, tmp, ll) != 0) { /* this should NEVER happen */ printf("overlapping compression data error\n"); exit(1); } lzo_free(tmp); } printf("overlapping compression: %8lu -> %8lu overhead: %7lu\n", (unsigned long) in_len, (unsigned long) new_len, (unsigned long) overhead); lzo_free(overlap); overlap = NULL; /***** Step 5: overlapping decompression *****/ /* * Step 5a: allocate the 'overlap' buffer for in-place decompression */ if (opt_overhead == 0 || out_len >= in_len) overhead = in_len / 16 + 64 + 3; else overhead = opt_overhead; overlap = (lzo_bytep) xmalloc(in_len + overhead); /* * Step 5b: prepare data in 'overlap' buffer. * copy compressed data at the top of the overlap buffer */ offset = in_len + overhead - out_len; lzo_memcpy(overlap + offset, out, out_len); /* * Step 5c: do an in-place decompression within the 'overlap' buffer */ new_len = in_len; r = lzo1x_decompress(overlap+offset,out_len,overlap,&new_len,NULL); if (r != LZO_E_OK) { /* this may happen if overhead is too small */ printf("overlapping decompression failed: %d - increase 'opt_overhead'\n", r); exit(1); } /* * Step 5d: verify decompression */ if (new_len != in_len || lzo_memcmp(in,overlap,in_len) != 0) { /* this may happen if overhead is too small */ printf("overlapping decompression data error - increase 'opt_overhead'\n"); exit(1); } printf("overlapping decompression: %8lu -> %8lu overhead: %7lu\n", (unsigned long) out_len, (unsigned long) new_len, (unsigned long) overhead); lzo_free(overlap); overlap = NULL; next_file: lzo_free(overlap); lzo_free(wrkmem); lzo_free(out); lzo_free(in); if (fp) fclose(fp); 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; }