388 lines
10 KiB
C
388 lines
10 KiB
C
/* ----------------------------------------------------------------------- *
|
|
*
|
|
* Copyright 2009 Intel Corporation; author: H. Peter Anvin
|
|
*
|
|
* This program 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, Inc., 51 Franklin St, Fifth Floor,
|
|
* Boston MA 02110-1301, USA; either version 2 of the License, or
|
|
* (at your option) any later version; incorporated herein by reference.
|
|
*
|
|
* ----------------------------------------------------------------------- */
|
|
|
|
/*
|
|
This file is based in part on:
|
|
|
|
precomp2.c -- example program: how to generate pre-compressed data
|
|
|
|
This file is part of the LZO real-time data compression library.
|
|
|
|
Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer
|
|
Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer
|
|
Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer
|
|
Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer
|
|
Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer
|
|
Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer
|
|
Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer
|
|
Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer
|
|
Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer
|
|
Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer
|
|
Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer
|
|
Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer
|
|
Copyright (C) 1996 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/
|
|
*/
|
|
|
|
#include "lzo/lzoconf.h"
|
|
#include "lzo/lzo1x.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 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 flags);
|
|
|
|
#define PARANOID 1
|
|
|
|
#include <assert.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <inttypes.h>
|
|
#include <stdarg.h>
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
|
|
#ifdef __GNUC__
|
|
# define noreturn void __attribute__((noreturn))
|
|
#else
|
|
# define noreturn void
|
|
#endif
|
|
|
|
struct prefix {
|
|
uint32_t pfx_start;
|
|
uint32_t pfx_compressed;
|
|
uint32_t pfx_cdatalen;
|
|
uint32_t pfx_checksum;
|
|
uint32_t pfx_maxlma;
|
|
};
|
|
|
|
static inline uint32_t get_32(const uint32_t * p)
|
|
{
|
|
#if defined(__i386__) || defined(__x86_64__)
|
|
/* Littleendian and unaligned-capable */
|
|
return *p;
|
|
#else
|
|
const uint8_t *pp = (const uint8_t *)p;
|
|
return (uint32_t) pp[0] + ((uint32_t) pp[1] << 8) +
|
|
((uint32_t) pp[2] << 16) + ((uint32_t) pp[3] << 24);
|
|
#endif
|
|
}
|
|
|
|
static inline void set_32(uint32_t * p, uint32_t v)
|
|
{
|
|
#if defined(__i386__) || defined(__x86_64__)
|
|
/* Littleendian and unaligned-capable */
|
|
*p = v;
|
|
#else
|
|
uint8_t *pp = (uint8_t *) p;
|
|
pp[0] = (v & 0xff);
|
|
pp[1] = ((v >> 8) & 0xff);
|
|
pp[2] = ((v >> 16) & 0xff);
|
|
pp[3] = ((v >> 24) & 0xff);
|
|
#endif
|
|
}
|
|
|
|
const char *progname = NULL;
|
|
const char *in_name = NULL;
|
|
const char *out_name = NULL;
|
|
|
|
static noreturn error(const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
fprintf(stderr, "%s: ", progname);
|
|
if (in_name)
|
|
fprintf(stderr, "%s: ", in_name);
|
|
vfprintf(stderr, fmt, ap);
|
|
fputc('\n', stderr);
|
|
va_end(ap);
|
|
|
|
exit(1);
|
|
}
|
|
|
|
static void *xzalloc(size_t n)
|
|
{
|
|
void *p = calloc(n, 1);
|
|
if (!p)
|
|
error("out of memory");
|
|
return p;
|
|
}
|
|
|
|
/*************************************************************************
|
|
//
|
|
**************************************************************************/
|
|
|
|
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_bytep in;
|
|
lzo_bytep infile;
|
|
lzo_uint in_len, infile_len, start, offset, soff;
|
|
|
|
lzo_bytep out;
|
|
lzo_uint out_bufsize;
|
|
lzo_uint out_len = 0;
|
|
lzo_uint outfile_len;
|
|
|
|
lzo_bytep test;
|
|
|
|
lzo_byte wrkmem[LZO1X_999_MEM_COMPRESS];
|
|
|
|
lzo_uint best_len;
|
|
int best_lazy = -1;
|
|
|
|
lzo_uint orig_len;
|
|
lzo_uint32 uncompressed_checksum;
|
|
lzo_uint32 compressed_checksum;
|
|
|
|
FILE *f;
|
|
long l;
|
|
|
|
struct prefix *prefix;
|
|
|
|
progname = argv[0];
|
|
if (argc != 3) {
|
|
fprintf(stderr, "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)
|
|
error("internal error - lzo_init() failed!");
|
|
|
|
/*
|
|
* Step 3: open the input file
|
|
*/
|
|
f = fopen(in_name, "rb");
|
|
if (!f)
|
|
error("cannot open file: %s", strerror(errno));
|
|
|
|
fseek(f, 0, SEEK_END);
|
|
l = ftell(f);
|
|
fseek(f, 0, SEEK_SET);
|
|
if (l <= 0) {
|
|
error("empty file", progname, in_name);
|
|
fclose(f);
|
|
exit(1);
|
|
}
|
|
infile_len = (lzo_uint) l;
|
|
out_bufsize = infile_len + infile_len / 16 + 64 + 3 + 2048;
|
|
|
|
/*
|
|
* Step 4: allocate compression buffers and read the file
|
|
*/
|
|
infile = xzalloc(infile_len);
|
|
out = xzalloc(out_bufsize);
|
|
infile_len = fread(infile, 1, infile_len, f);
|
|
fclose(f);
|
|
|
|
/*
|
|
* Select the portion which is for compression...
|
|
*/
|
|
prefix = (struct prefix *)infile;
|
|
start = get_32(&prefix->pfx_start);
|
|
offset = get_32(&prefix->pfx_compressed);
|
|
in = infile + offset;
|
|
in_len = infile_len - offset;
|
|
best_len = in_len;
|
|
|
|
/*
|
|
* 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
|
|
*/
|
|
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 */
|
|
error("internal error - compression failed: %d", r);
|
|
|
|
if (out_len < best_len) {
|
|
best_len = out_len;
|
|
best_lazy = lazy;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Step 7: check if compressible
|
|
*/
|
|
if (best_len >= in_len) {
|
|
fprintf(stderr, "%s: %s: this file contains incompressible data.",
|
|
progname, in_name);
|
|
/* do it anyway */
|
|
}
|
|
|
|
/*
|
|
* Step 8: compress data again using the best compressor found
|
|
*/
|
|
out_len = out_bufsize;
|
|
r = lzo1x_999_compress_internal(in, in_len, out, &out_len, wrkmem,
|
|
NULL, 0, 0,
|
|
best_lazy, big, big, big, big, flags);
|
|
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.
|
|
*/
|
|
memset(in, 0, in_len);
|
|
#endif
|
|
|
|
orig_len = in_len;
|
|
r = lzo1x_optimize(out, out_len, in, &orig_len, NULL);
|
|
if (r != LZO_E_OK || orig_len != in_len) {
|
|
/* this should NEVER happen */
|
|
error("internal error - optimization failed: %d", r);
|
|
}
|
|
|
|
/*
|
|
* 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
|
|
*/
|
|
/* Make sure we have up to 2048 bytes of zero after the output */
|
|
memset(out + out_len, 0, 2048);
|
|
|
|
outfile_len = out_len;
|
|
|
|
soff = get_32(&prefix->pfx_cdatalen);
|
|
set_32((uint32_t *) (infile + soff), out_len);
|
|
|
|
soff = get_32(&prefix->pfx_checksum);
|
|
if (soff) {
|
|
/* ISOLINUX padding and checksumming */
|
|
uint32_t csum = 0;
|
|
unsigned int ptr;
|
|
outfile_len =
|
|
((offset - start + out_len + 2047) & ~2047) - (offset - start);
|
|
for (ptr = 64; ptr < offset; ptr += 4)
|
|
csum += get_32((uint32_t *) (infile + ptr));
|
|
for (ptr = 0; ptr < outfile_len; ptr += 4)
|
|
csum += get_32((uint32_t *) (out + ptr));
|
|
|
|
set_32((uint32_t *) (infile + soff), offset - start + outfile_len);
|
|
set_32((uint32_t *) (infile + soff + 4), csum);
|
|
}
|
|
|
|
/*
|
|
if (offset+outfile_len > get_32(&prefix->pfx_maxlma))
|
|
error("output too big (%lu, max %lu)",
|
|
(unsigned long)offset+outfile_len,
|
|
(unsigned long)get_32(&prefix->pfx_maxlma));
|
|
*/
|
|
|
|
f = fopen(out_name, "wb");
|
|
if (!f)
|
|
error("cannot open output file %s: %s", out_name, strerror(errno));
|
|
|
|
if (fwrite(infile + start, 1, offset - start, f) != offset - start ||
|
|
fwrite(out, 1, outfile_len, f) != outfile_len || fclose(f))
|
|
error("write error");
|
|
|
|
/*
|
|
* Step 12: verify decompression
|
|
*/
|
|
#ifdef PARANOID
|
|
orig_len = in_len * 2;
|
|
test = xzalloc(orig_len);
|
|
r = lzo1x_decompress_safe(out, out_len, test, &orig_len, NULL);
|
|
|
|
if (r != LZO_E_OK || orig_len != in_len) {
|
|
/* this should NEVER happen */
|
|
error("internal error - decompression failed: %d", r);
|
|
}
|
|
|
|
if (memcmp(test, in, in_len)) {
|
|
/* this should NEVER happen */
|
|
error("internal error - decompression data error");
|
|
}
|
|
|
|
/* Now you could also verify decompression under similar conditions as in
|
|
* your application, e.g. overlapping assembler decompression etc.
|
|
*/
|
|
|
|
free(test);
|
|
#endif
|
|
|
|
free(infile);
|
|
free(out);
|
|
|
|
return 0;
|
|
}
|