release/src/router/lzo/examples/precomp.c

   1 /* precomp.c -- example program: how to generate pre-compressed data
   2
   3    This file is part of the LZO real-time data compression library.
   4
   5    Copyright (C) 1996-2014 Markus Franz Xaver Johannes Oberhumer
   6    All Rights Reserved.
   7
   8    The LZO library is free software; you can redistribute it and/or
   9    modify it under the terms of the GNU General Public License as
  10    published by the Free Software Foundation; either version 2 of
  11    the License, or (at your option) any later version.
  12
  13    The LZO library is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with the LZO library; see the file COPYING.
  20    If not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  22
  23    Markus F.X.J. Oberhumer
  24    <markus@oberhumer.com>
  25    http://www.oberhumer.com/opensource/lzo/
  26  */
  27
  28
  29 /*************************************************************************
  30 // This program shows how to generate pre-compressed data.
  31 //
  32 // Please study LZO.FAQ and simple.c first.
  33 //
  34 // We will be trying both LZO1X-999 and LZO1Y-999 and choose
  35 // the algorithm that achieves the best compression ratio.
  36 **************************************************************************/
  37
  38 #include "lzo/lzoconf.h"
  39 #include "lzo/lzo1x.h"
  40 #include "lzo/lzo1y.h"
  41
  42 #define USE_LZO1X 1
  43 #define USE_LZO1Y 1
  44
  45 #define PARANOID 1
  46
  47
  48 /* portability layer */
  49 static const char *progname = NULL;
  50 #define WANT_LZO_MALLOC 1
  51 #define WANT_LZO_FREAD 1
  52 #define WANT_LZO_WILDARGV 1
  53 #define WANT_XMALLOC 1
  54 #include "examples/portab.h"
  55
  56
  57 /*************************************************************************
  58 //
  59 **************************************************************************/
  60
  61 int __lzo_cdecl_main main(int argc, char *argv[])
  62 {
  63     int r;
  64
  65     lzo_bytep in;
  66     lzo_uint in_len;
  67
  68     lzo_bytep out;
  69     lzo_uint out_bufsize;
  70     lzo_uint out_len = 0;
  71
  72     lzo_voidp wrkmem;
  73     lzo_uint wrkmem_size;
  74
  75     lzo_uint best_len;
  76     int best_compress = -1;
  77
  78     lzo_uint orig_len;
  79     lzo_uint32_t uncompressed_checksum;
  80     lzo_uint32_t compressed_checksum;
  81
  82     FILE *fp;
  83     const char *in_name = NULL;
  84     const char *out_name = NULL;
  85     long l;
  86
  87
  88     lzo_wildargv(&argc, &argv);
  89
  90     printf("\nLZO real-time data compression library (v%s, %s).\n",
  91            lzo_version_string(), lzo_version_date());
  92     printf("Copyright (C) 1996-2014 Markus Franz Xaver Johannes Oberhumer\nAll Rights Reserved.\n\n");
  93
  94     progname = argv[0];
  95     if (argc < 2 || argc > 3)
  96     {
  97         printf("usage: %s file [output-file]\n", progname);
  98         exit(1);
  99     }
 100     in_name = argv[1];
 101     if (argc > 2) out_name = argv[2];
 102
 103 /*
 104  * Step 1: initialize the LZO library
 105  */
 106     if (lzo_init() != LZO_E_OK)
 107     {
 108         printf("internal error - lzo_init() failed !!!\n");
 109         printf("(this usually indicates a compiler bug - try recompiling\nwithout optimizations, and enable '-DLZO_DEBUG' for diagnostics)\n");
 110         exit(1);
 111     }
 112
 113 /*
 114  * Step 2: allocate the work-memory
 115  */
 116     wrkmem_size = 1;
 117 #ifdef USE_LZO1X
 118     wrkmem_size = (LZO1X_999_MEM_COMPRESS > wrkmem_size) ? LZO1X_999_MEM_COMPRESS : wrkmem_size;
 119 #endif
 120 #ifdef USE_LZO1Y
 121     wrkmem_size = (LZO1Y_999_MEM_COMPRESS > wrkmem_size) ? LZO1Y_999_MEM_COMPRESS : wrkmem_size;
 122 #endif
 123     wrkmem = (lzo_voidp) xmalloc(wrkmem_size);
 124     if (wrkmem == NULL)
 125     {
 126         printf("%s: out of memory\n", progname);
 127         exit(1);
 128     }
 129
 130 /*
 131  * Step 3: open the input file
 132  */
 133     fp = fopen(in_name,"rb");
 134     if (fp == NULL)
 135     {
 136         printf("%s: cannot open file %s\n", progname, in_name);
 137         exit(1);
 138     }
 139     fseek(fp, 0, SEEK_END);
 140     l = ftell(fp);
 141     fseek(fp, 0, SEEK_SET);
 142     if (l <= 0)
 143     {
 144         printf("%s: %s: empty file\n", progname, in_name);
 145         fclose(fp); fp = NULL;
 146         exit(1);
 147     }
 148     in_len = (lzo_uint) l;
 149     out_bufsize = in_len + in_len / 16 + 64 + 3;
 150     best_len = in_len;
 151
 152 /*
 153  * Step 4: allocate compression buffers and read the file
 154  */
 155     in = (lzo_bytep) xmalloc(in_len);
 156     out = (lzo_bytep) xmalloc(out_bufsize);
 157     if (in == NULL || out == NULL)
 158     {
 159         printf("%s: out of memory\n", progname);
 160         exit(1);
 161     }
 162     in_len = (lzo_uint) lzo_fread(fp, in, in_len);
 163     printf("%s: loaded file %s: %ld bytes\n", progname, in_name, (long) in_len);
 164     fclose(fp); fp = NULL;
 165
 166 /*
 167  * Step 5: compute a checksum of the uncompressed data
 168  */
 169     uncompressed_checksum = lzo_adler32(0,NULL,0);
 170     uncompressed_checksum = lzo_adler32(uncompressed_checksum,in,in_len);
 171
 172 /*
 173  * Step 6a: compress from 'in' to 'out' with LZO1X-999
 174  */
 175 #ifdef USE_LZO1X
 176         out_len = out_bufsize;
 177         r = lzo1x_999_compress(in,in_len,out,&out_len,wrkmem);
 178         if (r != LZO_E_OK)
 179         {
 180             /* this should NEVER happen */
 181             printf("internal error - compression failed: %d\n", r);
 182             exit(1);
 183         }
 184         printf("LZO1X-999: %8lu -> %8lu\n", (unsigned long) in_len, (unsigned long) out_len);
 185         if (out_len < best_len)
 186         {
 187             best_len = out_len;
 188             best_compress = 1;      /* LZO1X-999 */
 189         }
 190 #endif /* USE_LZO1X */
 191
 192 /*
 193  * Step 6b: compress from 'in' to 'out' with LZO1Y-999
 194  */
 195 #ifdef USE_LZO1Y
 196         out_len = out_bufsize;
 197         r = lzo1y_999_compress(in,in_len,out,&out_len,wrkmem);
 198         if (r != LZO_E_OK)
 199         {
 200             /* this should NEVER happen */
 201             printf("internal error - compression failed: %d\n", r);
 202             exit(1);
 203         }
 204         printf("LZO1Y-999: %8lu -> %8lu\n", (unsigned long) in_len, (unsigned long) out_len);
 205         if (out_len < best_len)
 206         {
 207             best_len = out_len;
 208             best_compress = 2;      /* LZO1Y-999 */
 209         }
 210 #endif /* USE_LZO1Y */
 211
 212 /*
 213  * Step 7: check if compressible
 214  */
 215     if (best_len >= in_len)
 216     {
 217         printf("This file contains incompressible data.\n");
 218         return 0;
 219     }
 220
 221 /*
 222  * Step 8: compress data again using the best compressor found
 223  */
 224     out_len = out_bufsize;
 225     if (best_compress == 1)
 226         r = lzo1x_999_compress(in,in_len,out,&out_len,wrkmem);
 227     else if (best_compress == 2)
 228         r = lzo1y_999_compress(in,in_len,out,&out_len,wrkmem);
 229     else
 230         r = -100;
 231     assert(r == LZO_E_OK);
 232     assert(out_len == best_len);
 233
 234 /*
 235  * Step 9: optimize compressed data (compressed data is in 'out' buffer)
 236  */
 237 #if 1
 238     /* Optimization does not require any data in the buffer that will
 239      * hold the uncompressed data. To prove this, we clear the buffer.
 240      */
 241     lzo_memset(in,0,in_len);
 242 #endif
 243
 244     orig_len = in_len;
 245     r = -100;
 246 #ifdef USE_LZO1X
 247     if (best_compress == 1)
 248         r = lzo1x_optimize(out,out_len,in,&orig_len,NULL);
 249 #endif
 250 #ifdef USE_LZO1Y
 251     if (best_compress == 2)
 252         r = lzo1y_optimize(out,out_len,in,&orig_len,NULL);
 253 #endif
 254     if (r != LZO_E_OK || orig_len != in_len)
 255     {
 256         /* this should NEVER happen */
 257         printf("internal error - optimization failed: %d\n", r);
 258         exit(1);
 259     }
 260
 261 /*
 262  * Step 10: compute a checksum of the compressed data
 263  */
 264     compressed_checksum = lzo_adler32(0,NULL,0);
 265     compressed_checksum = lzo_adler32(compressed_checksum,out,out_len);
 266
 267 /*
 268  * Step 11: write compressed data to a file
 269  */
 270     printf("%s: %s: %ld -> %ld, checksum 0x%08lx 0x%08lx\n",
 271             progname, in_name, (long) in_len, (long) out_len,
 272             (long) uncompressed_checksum, (long) compressed_checksum);
 273
 274     if (out_name && out_name[0])
 275     {
 276         printf("%s: writing to file %s\n", progname, out_name);
 277         fp = fopen(out_name,"wb");
 278         if (fp == NULL)
 279         {
 280             printf("%s: cannot open output file %s\n", progname, out_name);
 281             exit(1);
 282         }
 283         if (lzo_fwrite(fp, out, out_len) != out_len || fclose(fp) != 0)
 284         {
 285             printf("%s: write error !!\n", progname);
 286             exit(1);
 287         }
 288     }
 289
 290 /*
 291  * Step 12: verify decompression
 292  */
 293 #ifdef PARANOID
 294     lzo_memset(in,0,in_len);    /* paranoia - clear output buffer */
 295     orig_len = in_len;
 296     r = -100;
 297 #ifdef USE_LZO1X
 298     if (best_compress == 1)
 299         r = lzo1x_decompress_safe(out,out_len,in,&orig_len,NULL);
 300 #endif
 301 #ifdef USE_LZO1Y
 302     if (best_compress == 2)
 303         r = lzo1y_decompress_safe(out,out_len,in,&orig_len,NULL);
 304 #endif
 305     if (r != LZO_E_OK || orig_len != in_len)
 306     {
 307         /* this should NEVER happen */
 308         printf("internal error - decompression failed: %d\n", r);
 309         exit(1);
 310     }
 311     if (uncompressed_checksum != lzo_adler32(lzo_adler32(0,NULL,0),in,in_len))
 312     {
 313         /* this should NEVER happen */
 314         printf("internal error - decompression data error\n");
 315         exit(1);
 316     }
 317     /* Now you could also verify decompression under similar conditions as in
 318      * your application, e.g. overlapping assembler decompression etc.
 319      */
 320 #endif
 321
 322     lzo_free(in);
 323     lzo_free(out);
 324     lzo_free(wrkmem);
 325
 326     return 0;
 327 }
 328
 329
 330 /* vim:set ts=4 sw=4 et: */