summaryrefslogtreecommitdiffstats
path: root/contrib/syslinux-4.02/lzo/prepcore.c
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/syslinux-4.02/lzo/prepcore.c')
-rw-r--r--contrib/syslinux-4.02/lzo/prepcore.c385
1 files changed, 385 insertions, 0 deletions
diff --git a/contrib/syslinux-4.02/lzo/prepcore.c b/contrib/syslinux-4.02/lzo/prepcore.c
new file mode 100644
index 0000000..1d40067
--- /dev/null
+++ b/contrib/syslinux-4.02/lzo/prepcore.c
@@ -0,0 +1,385 @@
+/* ----------------------------------------------------------------------- *
+ *
+ * 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;
+}
generated by cgit v1.2.3-55-g7522 (git 2.39.0) at 2024-05-21 10:25:11 +0200