mirror of
https://github.com/ZDoom/raze-gles.git
synced 2024-12-25 03:00:46 +00:00
Replace LibLZF with FastLZ (http://www.fastlz.org/lzf.htm)
git-svn-id: https://svn.eduke32.com/eduke32@1455 1a8010ca-5511-0410-912e-c29ae57300e0
This commit is contained in:
terminx
parent
3aaab4b63d
commit
402221cad3
12 changed files with 676 additions and 731 deletions
|
|
@ -129,8 +129,7 @@ ENGINEOBJS+= \
|
||||||
$(OBJ)/textfont.$o \
|
$(OBJ)/textfont.$o \
|
||||||
$(OBJ)/smalltextfont.$o \
|
$(OBJ)/smalltextfont.$o \
|
||||||
$(OBJ)/kplib.$o \
|
$(OBJ)/kplib.$o \
|
||||||
$(OBJ)/lzf_c.$o \
|
$(OBJ)/fastlz.$o \
|
||||||
$(OBJ)/lzf_d.$o \
|
|
||||||
$(OBJ)/md4.$o \
|
$(OBJ)/md4.$o \
|
||||||
$(OBJ)/osd.$o \
|
$(OBJ)/osd.$o \
|
||||||
$(OBJ)/pragmas.$o \
|
$(OBJ)/pragmas.$o \
|
||||||
|
|
|
||||||
|
|
@ -10,15 +10,14 @@ $(OBJ)/config.$o: $(SRC)/config.c $(INC)/compat.h $(INC)/osd.h $(INC)/editor.h
|
||||||
$(OBJ)/crc32.$o: $(SRC)/crc32.c $(INC)/crc32.h
|
$(OBJ)/crc32.$o: $(SRC)/crc32.c $(INC)/crc32.h
|
||||||
$(OBJ)/defs.$o: $(SRC)/defs.c $(INC)/build.h $(INC)/baselayer.h $(INC)/scriptfile.h $(INC)/compat.h
|
$(OBJ)/defs.$o: $(SRC)/defs.c $(INC)/build.h $(INC)/baselayer.h $(INC)/scriptfile.h $(INC)/compat.h
|
||||||
$(OBJ)/engine.$o: $(SRC)/engine.c $(INC)/compat.h $(INC)/build.h $(INC)/pragmas.h $(INC)/cache1d.h $(INC)/a.h $(INC)/osd.h $(INC)/baselayer.h $(SRC)/engine_priv.h $(INC)/polymost.h $(INC)/hightile.h $(INC)/mdsprite.h $(INC)/polymer.h
|
$(OBJ)/engine.$o: $(SRC)/engine.c $(INC)/compat.h $(INC)/build.h $(INC)/pragmas.h $(INC)/cache1d.h $(INC)/a.h $(INC)/osd.h $(INC)/baselayer.h $(SRC)/engine_priv.h $(INC)/polymost.h $(INC)/hightile.h $(INC)/mdsprite.h $(INC)/polymer.h
|
||||||
$(OBJ)/polymost.$o: $(SRC)/polymost.c $(INC)/md4.h $(INC)/lzf.h $(INC)/lzwnew.h $(SRC)/engine_priv.h $(INC)/polymost.h $(INC)/hightile.h $(INC)/mdsprite.h
|
$(OBJ)/polymost.$o: $(SRC)/polymost.c $(INC)/md4.h $(INC)/fastlz.h $(INC)/lzwnew.h $(SRC)/engine_priv.h $(INC)/polymost.h $(INC)/hightile.h $(INC)/mdsprite.h
|
||||||
$(OBJ)/hightile.$o: $(SRC)/hightile.c $(INC)/kplib.h $(INC)/hightile.h
|
$(OBJ)/hightile.$o: $(SRC)/hightile.c $(INC)/kplib.h $(INC)/hightile.h
|
||||||
$(OBJ)/mdsprite.$o: $(SRC)/mdsprite.c $(SRC)/engine_priv.h $(INC)/polymost.h $(INC)/hightile.h $(INC)/mdsprite.h
|
$(OBJ)/mdsprite.$o: $(SRC)/mdsprite.c $(SRC)/engine_priv.h $(INC)/polymost.h $(INC)/hightile.h $(INC)/mdsprite.h
|
||||||
$(OBJ)/textfont.$o: $(SRC)/textfont.c
|
$(OBJ)/textfont.$o: $(SRC)/textfont.c
|
||||||
$(OBJ)/smalltextfont.$o: $(SRC)/smalltextfont.c
|
$(OBJ)/smalltextfont.$o: $(SRC)/smalltextfont.c
|
||||||
$(OBJ)/glbuild.$o: $(SRC)/glbuild.c $(INC)/glbuild.h $(INC)/baselayer.h
|
$(OBJ)/glbuild.$o: $(SRC)/glbuild.c $(INC)/glbuild.h $(INC)/baselayer.h
|
||||||
$(OBJ)/kplib.$o: $(SRC)/kplib.c $(INC)/compat.h
|
$(OBJ)/kplib.$o: $(SRC)/kplib.c $(INC)/compat.h
|
||||||
$(OBJ)/lzf_c.$o: $(SRC)/lzf_c.c $(SRC)/lzfP.h
|
$(OBJ)/fastlz.$o: $(SRC)/fastlz.c $(INC)/fastlz.h
|
||||||
$(OBJ)/lzf_d.$o: $(SRC)/lzf_d.c $(SRC)/lzfP.h
|
|
||||||
$(OBJ)/lzwnew.$o: $(SRC)/lzwnew.c
|
$(OBJ)/lzwnew.$o: $(SRC)/lzwnew.c
|
||||||
$(OBJ)/md4.$o: $(SRC)/md4.c $(INC)/md4.h $(INC)/compat.h
|
$(OBJ)/md4.$o: $(SRC)/md4.c $(INC)/md4.h $(INC)/compat.h
|
||||||
$(OBJ)/mmulti_null.$o: $(SRC)/mmulti_null.c $(INC)/mmulti.h
|
$(OBJ)/mmulti_null.$o: $(SRC)/mmulti_null.c $(INC)/mmulti.h
|
||||||
|
|
|
||||||
|
|
@ -72,8 +72,7 @@ ENGINEOBJS= \
|
||||||
$(OBJ)\smalltextfont.$o \
|
$(OBJ)\smalltextfont.$o \
|
||||||
$(OBJ)\glbuild.$o \
|
$(OBJ)\glbuild.$o \
|
||||||
$(OBJ)\kplib.$o \
|
$(OBJ)\kplib.$o \
|
||||||
$(OBJ)\lzf_c.$o \
|
$(OBJ)\fastlz.$o \
|
||||||
$(OBJ)\lzf_d.$o \
|
|
||||||
$(OBJ)\lzwnew.$o \
|
$(OBJ)\lzwnew.$o \
|
||||||
$(OBJ)\md4.$o \
|
$(OBJ)\md4.$o \
|
||||||
$(OBJ)\mmulti_unstable.$o \
|
$(OBJ)\mmulti_unstable.$o \
|
||||||
|
|
|
||||||
100
polymer/eduke32/build/include/fastlz.h
Normal file
100
polymer/eduke32/build/include/fastlz.h
Normal file
|
|
@ -0,0 +1,100 @@
|
||||||
|
/*
|
||||||
|
FastLZ - lightning-fast lossless compression library
|
||||||
|
|
||||||
|
Copyright (C) 2007 Ariya Hidayat (ariya@kde.org)
|
||||||
|
Copyright (C) 2006 Ariya Hidayat (ariya@kde.org)
|
||||||
|
Copyright (C) 2005 Ariya Hidayat (ariya@kde.org)
|
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||||
|
of this software and associated documentation files (the "Software"), to deal
|
||||||
|
in the Software without restriction, including without limitation the rights
|
||||||
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||||
|
copies of the Software, and to permit persons to whom the Software is
|
||||||
|
furnished to do so, subject to the following conditions:
|
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included in
|
||||||
|
all copies or substantial portions of the Software.
|
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||||
|
THE SOFTWARE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef FASTLZ_H
|
||||||
|
#define FASTLZ_H
|
||||||
|
|
||||||
|
#define FASTLZ_VERSION 0x000100
|
||||||
|
|
||||||
|
#define FASTLZ_VERSION_MAJOR 0
|
||||||
|
#define FASTLZ_VERSION_MINOR 0
|
||||||
|
#define FASTLZ_VERSION_REVISION 0
|
||||||
|
|
||||||
|
#define FASTLZ_VERSION_STRING "0.1.0"
|
||||||
|
|
||||||
|
#if defined (__cplusplus)
|
||||||
|
extern "C" {
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
Compress a block of data in the input buffer and returns the size of
|
||||||
|
compressed block. The size of input buffer is specified by length. The
|
||||||
|
minimum input buffer size is 16.
|
||||||
|
|
||||||
|
The output buffer must be at least 5% larger than the input buffer
|
||||||
|
and can not be smaller than 66 bytes.
|
||||||
|
|
||||||
|
If the input is not compressible, the return value might be larger than
|
||||||
|
length (input buffer size).
|
||||||
|
|
||||||
|
The input buffer and the output buffer can not overlap.
|
||||||
|
*/
|
||||||
|
|
||||||
|
int fastlz_compress(const void* input, int length, void* output);
|
||||||
|
|
||||||
|
/**
|
||||||
|
Decompress a block of compressed data and returns the size of the
|
||||||
|
decompressed block. If error occurs, e.g. the compressed data is
|
||||||
|
corrupted or the output buffer is not large enough, then 0 (zero)
|
||||||
|
will be returned instead.
|
||||||
|
|
||||||
|
The input buffer and the output buffer can not overlap.
|
||||||
|
|
||||||
|
Decompression is memory safe and guaranteed not to write the output buffer
|
||||||
|
more than what is specified in maxout.
|
||||||
|
*/
|
||||||
|
|
||||||
|
int fastlz_decompress(const void* input, int length, void* output, int maxout);
|
||||||
|
|
||||||
|
/**
|
||||||
|
Compress a block of data in the input buffer and returns the size of
|
||||||
|
compressed block. The size of input buffer is specified by length. The
|
||||||
|
minimum input buffer size is 16.
|
||||||
|
|
||||||
|
The output buffer must be at least 5% larger than the input buffer
|
||||||
|
and can not be smaller than 66 bytes.
|
||||||
|
|
||||||
|
If the input is not compressible, the return value might be larger than
|
||||||
|
length (input buffer size).
|
||||||
|
|
||||||
|
The input buffer and the output buffer can not overlap.
|
||||||
|
|
||||||
|
Compression level can be specified in parameter level. At the moment,
|
||||||
|
only level 1 and level 2 are supported.
|
||||||
|
Level 1 is the fastest compression and generally useful for short data.
|
||||||
|
Level 2 is slightly slower but it gives better compression ratio.
|
||||||
|
|
||||||
|
Note that the compressed data, regardless of the level, can always be
|
||||||
|
decompressed using the function fastlz_decompress above.
|
||||||
|
*/
|
||||||
|
|
||||||
|
int fastlz_compress_level(int level, const void* input, int length, void* output);
|
||||||
|
|
||||||
|
#if defined (__cplusplus)
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#endif /* FASTLZ_H */
|
||||||
|
|
@ -1,99 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2000-2007 Marc Alexander Lehmann <schmorp@schmorp.de>
|
|
||||||
*
|
|
||||||
* Redistribution and use in source and binary forms, with or without modifica-
|
|
||||||
* tion, are permitted provided that the following conditions are met:
|
|
||||||
*
|
|
||||||
* 1. Redistributions of source code must retain the above copyright notice,
|
|
||||||
* this list of conditions and the following disclaimer.
|
|
||||||
*
|
|
||||||
* 2. Redistributions in binary form must reproduce the above copyright
|
|
||||||
* notice, this list of conditions and the following disclaimer in the
|
|
||||||
* documentation and/or other materials provided with the distribution.
|
|
||||||
*
|
|
||||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
||||||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
|
|
||||||
* CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
|
||||||
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
|
|
||||||
* CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
||||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
||||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
||||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
|
|
||||||
* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
|
||||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
||||||
*
|
|
||||||
* Alternatively, the contents of this file may be used under the terms of
|
|
||||||
* the GNU General Public License ("GPL") version 2 or any later version,
|
|
||||||
* in which case the provisions of the GPL are applicable instead of
|
|
||||||
* the above. If you wish to allow the use of your version of this file
|
|
||||||
* only under the terms of the GPL and not to allow others to use your
|
|
||||||
* version of this file under the BSD license, indicate your decision
|
|
||||||
* by deleting the provisions above and replace them with the notice
|
|
||||||
* and other provisions required by the GPL. If you do not delete the
|
|
||||||
* provisions above, a recipient may use your version of this file under
|
|
||||||
* either the BSD or the GPL.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef LZF_H
|
|
||||||
#define LZF_H
|
|
||||||
|
|
||||||
/***********************************************************************
|
|
||||||
**
|
|
||||||
** lzf -- an extremely fast/free compression/decompression-method
|
|
||||||
** http://liblzf.plan9.de/
|
|
||||||
**
|
|
||||||
** This algorithm is believed to be patent-free.
|
|
||||||
**
|
|
||||||
***********************************************************************/
|
|
||||||
|
|
||||||
#define LZF_VERSION 0x0105 /* 1.5 */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Compress in_len bytes stored at the memory block starting at
|
|
||||||
* in_data and write the result to out_data, up to a maximum length
|
|
||||||
* of out_len bytes.
|
|
||||||
*
|
|
||||||
* If the output buffer is not large enough or any error occurs
|
|
||||||
* return 0, otherwise return the number of bytes used (which might
|
|
||||||
* be considerably larger than in_len, so it makes sense to always
|
|
||||||
* use out_len == in_len - 1), to ensure _some_ compression, and store
|
|
||||||
* the data uncompressed otherwise.
|
|
||||||
*
|
|
||||||
* lzf_compress might use different algorithms on different systems and
|
|
||||||
* even different runs, thus might result in different compressed strings
|
|
||||||
* depending on the phase of the moon or similar factors. However, all
|
|
||||||
* these strings are architecture-independent and will result in the
|
|
||||||
* original data when decompressed using lzf_decompress.
|
|
||||||
*
|
|
||||||
* The buffers must not be overlapping.
|
|
||||||
*
|
|
||||||
* If the option LZF_STATE_ARG is enabled, an extra argument must be
|
|
||||||
* supplied which is not reflected in this header file. Refer to lzfP.h
|
|
||||||
* and lzf_c.c.
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
uint32_t
|
|
||||||
lzf_compress (const void *const in_data, uint32_t in_len,
|
|
||||||
void *out_data, uint32_t out_len);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Decompress data compressed with some version of the lzf_compress
|
|
||||||
* function and stored at location in_data and length in_len. The result
|
|
||||||
* will be stored at out_data up to a maximum of out_len characters.
|
|
||||||
*
|
|
||||||
* If the output buffer is not large enough to hold the decompressed
|
|
||||||
* data, a 0 is returned and errno is set to E2BIG. Otherwise the number
|
|
||||||
* of decompressed bytes (i.e. the original length of the data) is
|
|
||||||
* returned.
|
|
||||||
*
|
|
||||||
* If an error in the compressed data is detected, a zero is returned and
|
|
||||||
* errno is set to EINVAL.
|
|
||||||
*
|
|
||||||
* This function is very fast, about as fast as a copying loop.
|
|
||||||
*/
|
|
||||||
uint32_t
|
|
||||||
lzf_decompress (const void *const in_data, uint32_t in_len,
|
|
||||||
void *out_data, uint32_t out_len);
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
551
polymer/eduke32/build/src/fastlz.c
Normal file
551
polymer/eduke32/build/src/fastlz.c
Normal file
|
|
@ -0,0 +1,551 @@
|
||||||
|
/*
|
||||||
|
FastLZ - lightning-fast lossless compression library
|
||||||
|
|
||||||
|
Copyright (C) 2007 Ariya Hidayat (ariya@kde.org)
|
||||||
|
Copyright (C) 2006 Ariya Hidayat (ariya@kde.org)
|
||||||
|
Copyright (C) 2005 Ariya Hidayat (ariya@kde.org)
|
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||||
|
of this software and associated documentation files (the "Software"), to deal
|
||||||
|
in the Software without restriction, including without limitation the rights
|
||||||
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||||
|
copies of the Software, and to permit persons to whom the Software is
|
||||||
|
furnished to do so, subject to the following conditions:
|
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included in
|
||||||
|
all copies or substantial portions of the Software.
|
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||||
|
THE SOFTWARE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#if !defined(FASTLZ__COMPRESSOR) && !defined(FASTLZ_DECOMPRESSOR)
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Always check for bound when decompressing.
|
||||||
|
* Generally it is best to leave it defined.
|
||||||
|
*/
|
||||||
|
#define FASTLZ_SAFE
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Give hints to the compiler for branch prediction optimization.
|
||||||
|
*/
|
||||||
|
#if defined(__GNUC__) && (__GNUC__ > 2)
|
||||||
|
#define FASTLZ_EXPECT_CONDITIONAL(c) (__builtin_expect((c), 1))
|
||||||
|
#define FASTLZ_UNEXPECT_CONDITIONAL(c) (__builtin_expect((c), 0))
|
||||||
|
#else
|
||||||
|
#define FASTLZ_EXPECT_CONDITIONAL(c) (c)
|
||||||
|
#define FASTLZ_UNEXPECT_CONDITIONAL(c) (c)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Use inlined functions for supported systems.
|
||||||
|
*/
|
||||||
|
#if defined(__GNUC__) || defined(__DMC__) || defined(__POCC__) || defined(__WATCOMC__) || defined(__SUNPRO_C)
|
||||||
|
#define FASTLZ_INLINE inline
|
||||||
|
#elif defined(__BORLANDC__) || defined(_MSC_VER) || defined(__LCC__)
|
||||||
|
#define FASTLZ_INLINE __inline
|
||||||
|
#else
|
||||||
|
#define FASTLZ_INLINE
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Prevent accessing more than 8-bit at once, except on x86 architectures.
|
||||||
|
*/
|
||||||
|
#if !defined(FASTLZ_STRICT_ALIGN)
|
||||||
|
#define FASTLZ_STRICT_ALIGN
|
||||||
|
#if defined(__i386__) || defined(__386) /* GNU C, Sun Studio */
|
||||||
|
#undef FASTLZ_STRICT_ALIGN
|
||||||
|
#elif defined(__i486__) || defined(__i586__) || defined(__i686__) /* GNU C */
|
||||||
|
#undef FASTLZ_STRICT_ALIGN
|
||||||
|
#elif defined(_M_IX86) /* Intel, MSVC */
|
||||||
|
#undef FASTLZ_STRICT_ALIGN
|
||||||
|
#elif defined(__386)
|
||||||
|
#undef FASTLZ_STRICT_ALIGN
|
||||||
|
#elif defined(_X86_) /* MinGW */
|
||||||
|
#undef FASTLZ_STRICT_ALIGN
|
||||||
|
#elif defined(__I86__) /* Digital Mars */
|
||||||
|
#undef FASTLZ_STRICT_ALIGN
|
||||||
|
#endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/*
|
||||||
|
* FIXME: use preprocessor magic to set this on different platforms!
|
||||||
|
*/
|
||||||
|
typedef unsigned char flzuint8;
|
||||||
|
typedef unsigned short flzuint16;
|
||||||
|
typedef unsigned int flzuint32;
|
||||||
|
|
||||||
|
/* prototypes */
|
||||||
|
int fastlz_compress(const void* input, int length, void* output);
|
||||||
|
int fastlz_compress_level(int level, const void* input, int length, void* output);
|
||||||
|
int fastlz_decompress(const void* input, int length, void* output, int maxout);
|
||||||
|
|
||||||
|
#define MAX_COPY 32
|
||||||
|
#define MAX_LEN 264 /* 256 + 8 */
|
||||||
|
#define MAX_DISTANCE 8192
|
||||||
|
|
||||||
|
#if !defined(FASTLZ_STRICT_ALIGN)
|
||||||
|
#define FASTLZ_READU16(p) *((const flzuint16*)(p))
|
||||||
|
#else
|
||||||
|
#define FASTLZ_READU16(p) ((p)[0] | (p)[1]<<8)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#define HASH_LOG 13
|
||||||
|
#define HASH_SIZE (1<< HASH_LOG)
|
||||||
|
#define HASH_MASK (HASH_SIZE-1)
|
||||||
|
#define HASH_FUNCTION(v,p) { v = FASTLZ_READU16(p); v ^= FASTLZ_READU16(p+1)^(v>>(16-HASH_LOG));v &= HASH_MASK; }
|
||||||
|
|
||||||
|
#undef FASTLZ_LEVEL
|
||||||
|
#define FASTLZ_LEVEL 1
|
||||||
|
|
||||||
|
#undef FASTLZ_COMPRESSOR
|
||||||
|
#undef FASTLZ_DECOMPRESSOR
|
||||||
|
#define FASTLZ_COMPRESSOR fastlz1_compress
|
||||||
|
#define FASTLZ_DECOMPRESSOR fastlz1_decompress
|
||||||
|
static FASTLZ_INLINE int FASTLZ_COMPRESSOR(const void* input, int length, void* output);
|
||||||
|
static FASTLZ_INLINE int FASTLZ_DECOMPRESSOR(const void* input, int length, void* output, int maxout);
|
||||||
|
#include "fastlz.c"
|
||||||
|
|
||||||
|
#undef FASTLZ_LEVEL
|
||||||
|
#define FASTLZ_LEVEL 2
|
||||||
|
|
||||||
|
#undef MAX_DISTANCE
|
||||||
|
#define MAX_DISTANCE 8191
|
||||||
|
#define MAX_FARDISTANCE (65535+MAX_DISTANCE-1)
|
||||||
|
|
||||||
|
#undef FASTLZ_COMPRESSOR
|
||||||
|
#undef FASTLZ_DECOMPRESSOR
|
||||||
|
#define FASTLZ_COMPRESSOR fastlz2_compress
|
||||||
|
#define FASTLZ_DECOMPRESSOR fastlz2_decompress
|
||||||
|
static FASTLZ_INLINE int FASTLZ_COMPRESSOR(const void* input, int length, void* output);
|
||||||
|
static FASTLZ_INLINE int FASTLZ_DECOMPRESSOR(const void* input, int length, void* output, int maxout);
|
||||||
|
#include "fastlz.c"
|
||||||
|
|
||||||
|
int fastlz_compress(const void* input, int length, void* output)
|
||||||
|
{
|
||||||
|
/* for short block, choose fastlz1 */
|
||||||
|
if(length < 65536)
|
||||||
|
return fastlz1_compress(input, length, output);
|
||||||
|
|
||||||
|
/* else... */
|
||||||
|
return fastlz2_compress(input, length, output);
|
||||||
|
}
|
||||||
|
|
||||||
|
int fastlz_decompress(const void* input, int length, void* output, int maxout)
|
||||||
|
{
|
||||||
|
/* magic identifier for compression level */
|
||||||
|
int level = ((*(const flzuint8*)input) >> 5) + 1;
|
||||||
|
|
||||||
|
if(level == 1)
|
||||||
|
return fastlz1_decompress(input, length, output, maxout);
|
||||||
|
if(level == 2)
|
||||||
|
return fastlz2_decompress(input, length, output, maxout);
|
||||||
|
|
||||||
|
/* unknown level, trigger error */
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
int fastlz_compress_level(int level, const void* input, int length, void* output)
|
||||||
|
{
|
||||||
|
if(level == 1)
|
||||||
|
return fastlz1_compress(input, length, output);
|
||||||
|
if(level == 2)
|
||||||
|
return fastlz2_compress(input, length, output);
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
#else /* !defined(FASTLZ_COMPRESSOR) && !defined(FASTLZ_DECOMPRESSOR) */
|
||||||
|
|
||||||
|
static FASTLZ_INLINE int FASTLZ_COMPRESSOR(const void* input, int length, void* output)
|
||||||
|
{
|
||||||
|
const flzuint8* ip = (const flzuint8*) input;
|
||||||
|
const flzuint8* ip_bound = ip + length - 2;
|
||||||
|
const flzuint8* ip_limit = ip + length - 12;
|
||||||
|
flzuint8* op = (flzuint8*) output;
|
||||||
|
|
||||||
|
const flzuint8* htab[HASH_SIZE];
|
||||||
|
const flzuint8** hslot;
|
||||||
|
flzuint32 hval;
|
||||||
|
|
||||||
|
flzuint32 copy;
|
||||||
|
|
||||||
|
/* sanity check */
|
||||||
|
if(FASTLZ_UNEXPECT_CONDITIONAL(length < 4))
|
||||||
|
{
|
||||||
|
if(length)
|
||||||
|
{
|
||||||
|
/* create literal copy only */
|
||||||
|
*op++ = length-1;
|
||||||
|
ip_bound++;
|
||||||
|
while(ip <= ip_bound)
|
||||||
|
*op++ = *ip++;
|
||||||
|
return length+1;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* initializes hash table */
|
||||||
|
for (hslot = htab; hslot < htab + HASH_SIZE; hslot++)
|
||||||
|
*hslot = ip;
|
||||||
|
|
||||||
|
/* we start with literal copy */
|
||||||
|
copy = 2;
|
||||||
|
*op++ = MAX_COPY-1;
|
||||||
|
*op++ = *ip++;
|
||||||
|
*op++ = *ip++;
|
||||||
|
|
||||||
|
/* main loop */
|
||||||
|
while(FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit))
|
||||||
|
{
|
||||||
|
const flzuint8* ref;
|
||||||
|
flzuint32 distance;
|
||||||
|
|
||||||
|
/* minimum match length */
|
||||||
|
flzuint32 len = 3;
|
||||||
|
|
||||||
|
/* comparison starting-point */
|
||||||
|
const flzuint8* anchor = ip;
|
||||||
|
|
||||||
|
/* check for a run */
|
||||||
|
#if FASTLZ_LEVEL==2
|
||||||
|
if(ip[0] == ip[-1] && FASTLZ_READU16(ip-1)==FASTLZ_READU16(ip+1))
|
||||||
|
{
|
||||||
|
distance = 1;
|
||||||
|
ip += 3;
|
||||||
|
ref = anchor - 1 + 3;
|
||||||
|
goto match;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* find potential match */
|
||||||
|
HASH_FUNCTION(hval,ip);
|
||||||
|
hslot = htab + hval;
|
||||||
|
ref = htab[hval];
|
||||||
|
|
||||||
|
/* calculate distance to the match */
|
||||||
|
distance = anchor - ref;
|
||||||
|
|
||||||
|
/* update hash table */
|
||||||
|
*hslot = anchor;
|
||||||
|
|
||||||
|
/* is this a match? check the first 3 bytes */
|
||||||
|
if(distance==0 ||
|
||||||
|
#if FASTLZ_LEVEL==1
|
||||||
|
(distance >= MAX_DISTANCE) ||
|
||||||
|
#else
|
||||||
|
(distance >= MAX_FARDISTANCE) ||
|
||||||
|
#endif
|
||||||
|
*ref++ != *ip++ || *ref++!=*ip++ || *ref++!=*ip++)
|
||||||
|
goto literal;
|
||||||
|
|
||||||
|
#if FASTLZ_LEVEL==2
|
||||||
|
/* far, needs at least 5-byte match */
|
||||||
|
if(distance >= MAX_DISTANCE)
|
||||||
|
{
|
||||||
|
if(*ip++ != *ref++ || *ip++!= *ref++)
|
||||||
|
goto literal;
|
||||||
|
len += 2;
|
||||||
|
}
|
||||||
|
|
||||||
|
match:
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* last matched byte */
|
||||||
|
ip = anchor + len;
|
||||||
|
|
||||||
|
/* distance is biased */
|
||||||
|
distance--;
|
||||||
|
|
||||||
|
if(!distance)
|
||||||
|
{
|
||||||
|
/* zero distance means a run */
|
||||||
|
flzuint8 x = ip[-1];
|
||||||
|
while(ip < ip_bound)
|
||||||
|
if(*ref++ != x) break; else ip++;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
for(;;)
|
||||||
|
{
|
||||||
|
/* safe because the outer check against ip limit */
|
||||||
|
if(*ref++ != *ip++) break;
|
||||||
|
if(*ref++ != *ip++) break;
|
||||||
|
if(*ref++ != *ip++) break;
|
||||||
|
if(*ref++ != *ip++) break;
|
||||||
|
if(*ref++ != *ip++) break;
|
||||||
|
if(*ref++ != *ip++) break;
|
||||||
|
if(*ref++ != *ip++) break;
|
||||||
|
if(*ref++ != *ip++) break;
|
||||||
|
while(ip < ip_bound)
|
||||||
|
if(*ref++ != *ip++) break;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* if we have copied something, adjust the copy count */
|
||||||
|
if(copy)
|
||||||
|
/* copy is biased, '0' means 1 byte copy */
|
||||||
|
*(op-copy-1) = copy-1;
|
||||||
|
else
|
||||||
|
/* back, to overwrite the copy count */
|
||||||
|
op--;
|
||||||
|
|
||||||
|
/* reset literal counter */
|
||||||
|
copy = 0;
|
||||||
|
|
||||||
|
/* length is biased, '1' means a match of 3 bytes */
|
||||||
|
ip -= 3;
|
||||||
|
len = ip - anchor;
|
||||||
|
|
||||||
|
/* encode the match */
|
||||||
|
#if FASTLZ_LEVEL==2
|
||||||
|
if(distance < MAX_DISTANCE)
|
||||||
|
{
|
||||||
|
if(len < 7)
|
||||||
|
{
|
||||||
|
*op++ = (len << 5) + (distance >> 8);
|
||||||
|
*op++ = (distance & 255);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
*op++ = (7 << 5) + (distance >> 8);
|
||||||
|
for(len-=7; len >= 255; len-= 255)
|
||||||
|
*op++ = 255;
|
||||||
|
*op++ = len;
|
||||||
|
*op++ = (distance & 255);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
/* far away, but not yet in the another galaxy... */
|
||||||
|
if(len < 7)
|
||||||
|
{
|
||||||
|
distance -= MAX_DISTANCE;
|
||||||
|
*op++ = (len << 5) + 31;
|
||||||
|
*op++ = 255;
|
||||||
|
*op++ = distance >> 8;
|
||||||
|
*op++ = distance & 255;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
distance -= MAX_DISTANCE;
|
||||||
|
*op++ = (7 << 5) + 31;
|
||||||
|
for(len-=7; len >= 255; len-= 255)
|
||||||
|
*op++ = 255;
|
||||||
|
*op++ = len;
|
||||||
|
*op++ = 255;
|
||||||
|
*op++ = distance >> 8;
|
||||||
|
*op++ = distance & 255;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
|
||||||
|
if(FASTLZ_UNEXPECT_CONDITIONAL(len > MAX_LEN-2))
|
||||||
|
while(len > MAX_LEN-2)
|
||||||
|
{
|
||||||
|
*op++ = (7 << 5) + (distance >> 8);
|
||||||
|
*op++ = MAX_LEN - 2 - 7 -2;
|
||||||
|
*op++ = (distance & 255);
|
||||||
|
len -= MAX_LEN-2;
|
||||||
|
}
|
||||||
|
|
||||||
|
if(len < 7)
|
||||||
|
{
|
||||||
|
*op++ = (len << 5) + (distance >> 8);
|
||||||
|
*op++ = (distance & 255);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
*op++ = (7 << 5) + (distance >> 8);
|
||||||
|
*op++ = len - 7;
|
||||||
|
*op++ = (distance & 255);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* update the hash at match boundary */
|
||||||
|
HASH_FUNCTION(hval,ip);
|
||||||
|
htab[hval] = ip++;
|
||||||
|
HASH_FUNCTION(hval,ip);
|
||||||
|
htab[hval] = ip++;
|
||||||
|
|
||||||
|
/* assuming literal copy */
|
||||||
|
*op++ = MAX_COPY-1;
|
||||||
|
|
||||||
|
continue;
|
||||||
|
|
||||||
|
literal:
|
||||||
|
*op++ = *anchor++;
|
||||||
|
ip = anchor;
|
||||||
|
copy++;
|
||||||
|
if(FASTLZ_UNEXPECT_CONDITIONAL(copy == MAX_COPY))
|
||||||
|
{
|
||||||
|
copy = 0;
|
||||||
|
*op++ = MAX_COPY-1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* left-over as literal copy */
|
||||||
|
ip_bound++;
|
||||||
|
while(ip <= ip_bound)
|
||||||
|
{
|
||||||
|
*op++ = *ip++;
|
||||||
|
copy++;
|
||||||
|
if(copy == MAX_COPY)
|
||||||
|
{
|
||||||
|
copy = 0;
|
||||||
|
*op++ = MAX_COPY-1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* if we have copied something, adjust the copy length */
|
||||||
|
if(copy)
|
||||||
|
*(op-copy-1) = copy-1;
|
||||||
|
else
|
||||||
|
op--;
|
||||||
|
|
||||||
|
#if FASTLZ_LEVEL==2
|
||||||
|
/* marker for fastlz2 */
|
||||||
|
*(flzuint8*)output |= (1 << 5);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
return op - (flzuint8*)output;
|
||||||
|
}
|
||||||
|
|
||||||
|
static FASTLZ_INLINE int FASTLZ_DECOMPRESSOR(const void* input, int length, void* output, int maxout)
|
||||||
|
{
|
||||||
|
const flzuint8* ip = (const flzuint8*) input;
|
||||||
|
const flzuint8* ip_limit = ip + length;
|
||||||
|
flzuint8* op = (flzuint8*) output;
|
||||||
|
flzuint8* op_limit = op + maxout;
|
||||||
|
flzuint32 ctrl = (*ip++) & 31;
|
||||||
|
int loop = 1;
|
||||||
|
|
||||||
|
do
|
||||||
|
{
|
||||||
|
const flzuint8* ref = op;
|
||||||
|
flzuint32 len = ctrl >> 5;
|
||||||
|
flzuint32 ofs = (ctrl & 31) << 8;
|
||||||
|
|
||||||
|
if(ctrl >= 32)
|
||||||
|
{
|
||||||
|
#if FASTLZ_LEVEL==2
|
||||||
|
flzuint8 code;
|
||||||
|
#endif
|
||||||
|
len--;
|
||||||
|
ref -= ofs;
|
||||||
|
if (len == 7-1)
|
||||||
|
#if FASTLZ_LEVEL==1
|
||||||
|
len += *ip++;
|
||||||
|
ref -= *ip++;
|
||||||
|
#else
|
||||||
|
do
|
||||||
|
{
|
||||||
|
code = *ip++;
|
||||||
|
len += code;
|
||||||
|
} while (code==255);
|
||||||
|
code = *ip++;
|
||||||
|
ref -= code;
|
||||||
|
|
||||||
|
/* match from 16-bit distance */
|
||||||
|
if(FASTLZ_UNEXPECT_CONDITIONAL(code==255))
|
||||||
|
if(FASTLZ_EXPECT_CONDITIONAL(ofs==(31 << 8)))
|
||||||
|
{
|
||||||
|
ofs = (*ip++) << 8;
|
||||||
|
ofs += *ip++;
|
||||||
|
ref = op - ofs - MAX_DISTANCE;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef FASTLZ_SAFE
|
||||||
|
if (FASTLZ_UNEXPECT_CONDITIONAL(op + len + 3 > op_limit))
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
if (FASTLZ_UNEXPECT_CONDITIONAL(ref-1 < (flzuint8 *)output))
|
||||||
|
return 0;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
if(FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit))
|
||||||
|
ctrl = *ip++;
|
||||||
|
else
|
||||||
|
loop = 0;
|
||||||
|
|
||||||
|
if(ref == op)
|
||||||
|
{
|
||||||
|
/* optimize copy for a run */
|
||||||
|
flzuint8 b = ref[-1];
|
||||||
|
*op++ = b;
|
||||||
|
*op++ = b;
|
||||||
|
*op++ = b;
|
||||||
|
for(; len; --len)
|
||||||
|
*op++ = b;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
#if !defined(FASTLZ_STRICT_ALIGN)
|
||||||
|
const flzuint16* p;
|
||||||
|
flzuint16* q;
|
||||||
|
#endif
|
||||||
|
/* copy from reference */
|
||||||
|
ref--;
|
||||||
|
*op++ = *ref++;
|
||||||
|
*op++ = *ref++;
|
||||||
|
*op++ = *ref++;
|
||||||
|
|
||||||
|
#if !defined(FASTLZ_STRICT_ALIGN)
|
||||||
|
/* copy a byte, so that now it's word aligned */
|
||||||
|
if(len & 1)
|
||||||
|
{
|
||||||
|
*op++ = *ref++;
|
||||||
|
len--;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* copy 16-bit at once */
|
||||||
|
q = (flzuint16*) op;
|
||||||
|
op += len;
|
||||||
|
p = (const flzuint16*) ref;
|
||||||
|
for(len>>=1; len > 4; len-=4)
|
||||||
|
{
|
||||||
|
*q++ = *p++;
|
||||||
|
*q++ = *p++;
|
||||||
|
*q++ = *p++;
|
||||||
|
*q++ = *p++;
|
||||||
|
}
|
||||||
|
for(; len; --len)
|
||||||
|
*q++ = *p++;
|
||||||
|
#else
|
||||||
|
for(; len; --len)
|
||||||
|
*op++ = *ref++;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
ctrl++;
|
||||||
|
#ifdef FASTLZ_SAFE
|
||||||
|
if (FASTLZ_UNEXPECT_CONDITIONAL(op + ctrl > op_limit))
|
||||||
|
return 0;
|
||||||
|
if (FASTLZ_UNEXPECT_CONDITIONAL(ip + ctrl > ip_limit))
|
||||||
|
return 0;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
*op++ = *ip++;
|
||||||
|
for(--ctrl; ctrl; ctrl--)
|
||||||
|
*op++ = *ip++;
|
||||||
|
|
||||||
|
loop = FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit);
|
||||||
|
if(loop)
|
||||||
|
ctrl = *ip++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
while(FASTLZ_EXPECT_CONDITIONAL(loop));
|
||||||
|
|
||||||
|
return op - (flzuint8*)output;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif /* !defined(FASTLZ_COMPRESSOR) && !defined(FASTLZ_DECOMPRESSOR) */
|
||||||
|
|
@ -1,159 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2000-2007 Marc Alexander Lehmann <schmorp@schmorp.de>
|
|
||||||
*
|
|
||||||
* Redistribution and use in source and binary forms, with or without modifica-
|
|
||||||
* tion, are permitted provided that the following conditions are met:
|
|
||||||
*
|
|
||||||
* 1. Redistributions of source code must retain the above copyright notice,
|
|
||||||
* this list of conditions and the following disclaimer.
|
|
||||||
*
|
|
||||||
* 2. Redistributions in binary form must reproduce the above copyright
|
|
||||||
* notice, this list of conditions and the following disclaimer in the
|
|
||||||
* documentation and/or other materials provided with the distribution.
|
|
||||||
*
|
|
||||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
||||||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
|
|
||||||
* CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
|
||||||
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
|
|
||||||
* CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
||||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
||||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
||||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
|
|
||||||
* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
|
||||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
||||||
*
|
|
||||||
* Alternatively, the contents of this file may be used under the terms of
|
|
||||||
* the GNU General Public License ("GPL") version 2 or any later version,
|
|
||||||
* in which case the provisions of the GPL are applicable instead of
|
|
||||||
* the above. If you wish to allow the use of your version of this file
|
|
||||||
* only under the terms of the GPL and not to allow others to use your
|
|
||||||
* version of this file under the BSD license, indicate your decision
|
|
||||||
* by deleting the provisions above and replace them with the notice
|
|
||||||
* and other provisions required by the GPL. If you do not delete the
|
|
||||||
* provisions above, a recipient may use your version of this file under
|
|
||||||
* either the BSD or the GPL.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef LZFP_h
|
|
||||||
#define LZFP_h
|
|
||||||
|
|
||||||
#define STANDALONE 1 /* at the moment, this is ok. */
|
|
||||||
|
|
||||||
#ifndef STANDALONE
|
|
||||||
# include "lzf.h"
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Size of hashtable is (1 << HLOG) * sizeof (char *)
|
|
||||||
* decompression is independent of the hash table size
|
|
||||||
* the difference between 15 and 14 is very small
|
|
||||||
* for small blocks (and 14 is usually a bit faster).
|
|
||||||
* For a low-memory/faster configuration, use HLOG == 13;
|
|
||||||
* For best compression, use 15 or 16 (or more, up to 23).
|
|
||||||
*/
|
|
||||||
#ifndef HLOG
|
|
||||||
# define HLOG 16
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Sacrifice very little compression quality in favour of compression speed.
|
|
||||||
* This gives almost the same compression as the default code, and is
|
|
||||||
* (very roughly) 15% faster. This is the preferred mode of operation.
|
|
||||||
*/
|
|
||||||
#ifndef VERY_FAST
|
|
||||||
# define VERY_FAST 1
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Sacrifice some more compression quality in favour of compression speed.
|
|
||||||
* (roughly 1-2% worse compression for large blocks and
|
|
||||||
* 9-10% for small, redundant, blocks and >>20% better speed in both cases)
|
|
||||||
* In short: when in need for speed, enable this for binary data,
|
|
||||||
* possibly disable this for text data.
|
|
||||||
*/
|
|
||||||
#ifndef ULTRA_FAST
|
|
||||||
# define ULTRA_FAST 0
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Unconditionally aligning does not cost very much, so do it if unsure
|
|
||||||
*/
|
|
||||||
#ifndef STRICT_ALIGN
|
|
||||||
# define STRICT_ALIGN !(defined(__i386) || defined (__amd64))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
* You may choose to pre-set the hash table (might be faster on some
|
|
||||||
* modern cpus and large (>>64k) blocks, and also makes compression
|
|
||||||
* deterministic/repeatable when the configuration otherwise is the same).
|
|
||||||
*/
|
|
||||||
#ifndef INIT_HTAB
|
|
||||||
# define INIT_HTAB 1
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Avoid assigning values to errno variable? for some embedding purposes
|
|
||||||
* (linux kernel for example), this is neccessary. NOTE: this breaks
|
|
||||||
* the documentation in lzf.h.
|
|
||||||
*/
|
|
||||||
#ifndef AVOID_ERRNO
|
|
||||||
# define AVOID_ERRNO 0
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Wether to pass the LZF_STATE variable as argument, or allocate it
|
|
||||||
* on the stack. For small-stack environments, define this to 1.
|
|
||||||
* NOTE: this breaks the prototype in lzf.h.
|
|
||||||
*/
|
|
||||||
#ifndef LZF_STATE_ARG
|
|
||||||
# define LZF_STATE_ARG 0
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Wether to add extra checks for input validity in lzf_decompress
|
|
||||||
* and return EINVAL if the input stream has been corrupted. This
|
|
||||||
* only shields against overflowing the input buffer and will not
|
|
||||||
* detect most corrupted streams.
|
|
||||||
* This check is not normally noticable on modern hardware
|
|
||||||
* (<1% slowdown), but might slow down older cpus considerably.
|
|
||||||
*/
|
|
||||||
#ifndef CHECK_INPUT
|
|
||||||
# define CHECK_INPUT 1
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*****************************************************************************/
|
|
||||||
/* nothing should be changed below */
|
|
||||||
|
|
||||||
typedef unsigned char u8;
|
|
||||||
|
|
||||||
typedef const u8 *LZF_STATE[1 << (HLOG)];
|
|
||||||
|
|
||||||
#if !STRICT_ALIGN
|
|
||||||
/* for unaligned accesses we need a 16 bit datatype. */
|
|
||||||
# include <limits.h>
|
|
||||||
# if USHRT_MAX == 65535
|
|
||||||
typedef unsigned short u16;
|
|
||||||
# elif UINT_MAX == 65535
|
|
||||||
typedef unsigned int u16;
|
|
||||||
# else
|
|
||||||
# undef STRICT_ALIGN
|
|
||||||
# define STRICT_ALIGN 1
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if ULTRA_FAST
|
|
||||||
# if defined(VERY_FAST)
|
|
||||||
# undef VERY_FAST
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if INIT_HTAB
|
|
||||||
# ifdef __cplusplus
|
|
||||||
# include <cstring>
|
|
||||||
# else
|
|
||||||
# include <string.h>
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
@ -1,289 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2000-2007 Marc Alexander Lehmann <schmorp@schmorp.de>
|
|
||||||
*
|
|
||||||
* Redistribution and use in source and binary forms, with or without modifica-
|
|
||||||
* tion, are permitted provided that the following conditions are met:
|
|
||||||
*
|
|
||||||
* 1. Redistributions of source code must retain the above copyright notice,
|
|
||||||
* this list of conditions and the following disclaimer.
|
|
||||||
*
|
|
||||||
* 2. Redistributions in binary form must reproduce the above copyright
|
|
||||||
* notice, this list of conditions and the following disclaimer in the
|
|
||||||
* documentation and/or other materials provided with the distribution.
|
|
||||||
*
|
|
||||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
||||||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
|
|
||||||
* CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
|
||||||
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
|
|
||||||
* CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
||||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
||||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
||||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
|
|
||||||
* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
|
||||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
||||||
*
|
|
||||||
* Alternatively, the contents of this file may be used under the terms of
|
|
||||||
* the GNU General Public License ("GPL") version 2 or any later version,
|
|
||||||
* in which case the provisions of the GPL are applicable instead of
|
|
||||||
* the above. If you wish to allow the use of your version of this file
|
|
||||||
* only under the terms of the GPL and not to allow others to use your
|
|
||||||
* version of this file under the BSD license, indicate your decision
|
|
||||||
* by deleting the provisions above and replace them with the notice
|
|
||||||
* and other provisions required by the GPL. If you do not delete the
|
|
||||||
* provisions above, a recipient may use your version of this file under
|
|
||||||
* either the BSD or the GPL.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "lzfP.h"
|
|
||||||
|
|
||||||
#define HSIZE (1 << (HLOG))
|
|
||||||
|
|
||||||
/*
|
|
||||||
* don't play with this unless you benchmark!
|
|
||||||
* decompression is not dependent on the hash function
|
|
||||||
* the hashing function might seem strange, just believe me
|
|
||||||
* it works ;)
|
|
||||||
*/
|
|
||||||
#ifndef FRST
|
|
||||||
# define FRST(p) (((p[0]) << 8) | p[1])
|
|
||||||
# define NEXT(v,p) (((v) << 8) | p[2])
|
|
||||||
# if ULTRA_FAST
|
|
||||||
# define IDX(h) ((( h >> (3*8 - HLOG)) - h ) & (HSIZE - 1))
|
|
||||||
# elif VERY_FAST
|
|
||||||
# define IDX(h) ((( h >> (3*8 - HLOG)) - h*5) & (HSIZE - 1))
|
|
||||||
# else
|
|
||||||
# define IDX(h) ((((h ^ (h << 5)) >> (3*8 - HLOG)) - h*5) & (HSIZE - 1))
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
/*
|
|
||||||
* IDX works because it is very similar to a multiplicative hash, e.g.
|
|
||||||
* ((h * 57321 >> (3*8 - HLOG)) & (HSIZE - 1))
|
|
||||||
* the latter is also quite fast on newer CPUs, and compresses similarly.
|
|
||||||
*
|
|
||||||
* the next one is also quite good, albeit slow ;)
|
|
||||||
* (int)(cos(h & 0xffffff) * 1e6)
|
|
||||||
*/
|
|
||||||
|
|
||||||
#if 0
|
|
||||||
/* original lzv-like hash function, much worse and thus slower */
|
|
||||||
# define FRST(p) (p[0] << 5) ^ p[1]
|
|
||||||
# define NEXT(v,p) ((v) << 5) ^ p[2]
|
|
||||||
# define IDX(h) ((h) & (HSIZE - 1))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define MAX_LIT (1 << 5)
|
|
||||||
#define MAX_OFF (1 << 13)
|
|
||||||
#define MAX_REF ((1 << 8) + (1 << 3))
|
|
||||||
|
|
||||||
#if __GNUC__ >= 3
|
|
||||||
# define expect(expr,value) __builtin_expect ((expr),(value))
|
|
||||||
# define inline inline
|
|
||||||
#else
|
|
||||||
# define expect(expr,value) (expr)
|
|
||||||
# define inline static
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define expect_false(expr) expect ((expr) != 0, 0)
|
|
||||||
#define expect_true(expr) expect ((expr) != 0, 1)
|
|
||||||
|
|
||||||
/*
|
|
||||||
* compressed format
|
|
||||||
*
|
|
||||||
* 000LLLLL <L+1> ; literal
|
|
||||||
* LLLooooo oooooooo ; backref L
|
|
||||||
* 111ooooo LLLLLLLL oooooooo ; backref L+7
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
unsigned int
|
|
||||||
lzf_compress(const void *const in_data, unsigned int in_len,
|
|
||||||
void *out_data, unsigned int out_len
|
|
||||||
#if LZF_STATE_ARG
|
|
||||||
, LZF_STATE htab
|
|
||||||
#endif
|
|
||||||
)
|
|
||||||
{
|
|
||||||
#if !LZF_STATE_ARG
|
|
||||||
LZF_STATE htab;
|
|
||||||
#endif
|
|
||||||
const u8 **hslot;
|
|
||||||
const u8 *ip = (const u8 *)in_data;
|
|
||||||
u8 *op = (u8 *)out_data;
|
|
||||||
const u8 *in_end = ip + in_len;
|
|
||||||
u8 *out_end = op + out_len;
|
|
||||||
const u8 *ref;
|
|
||||||
|
|
||||||
/* off requires a type wide enough to hold a general pointer difference.
|
|
||||||
* ISO C doesn't have that (size_t might not be enough and ptrdiff_t only
|
|
||||||
* works for differences within a single object). We also assume that no
|
|
||||||
* no bit pattern traps. Since the only platform that is both non-POSIX
|
|
||||||
* and fails to support both assumptions is windows 64 bit, we make a
|
|
||||||
* special workaround for it.
|
|
||||||
*/
|
|
||||||
#if defined (WIN32) && defined (_M_X64)
|
|
||||||
unsigned _int64 off; /* workaround for missing POSIX compliance */
|
|
||||||
#else
|
|
||||||
unsigned long off;
|
|
||||||
#endif
|
|
||||||
unsigned int hval;
|
|
||||||
int lit;
|
|
||||||
|
|
||||||
if (!in_len || !out_len)
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
#if INIT_HTAB
|
|
||||||
memset(htab, 0, sizeof(htab));
|
|
||||||
# if 0
|
|
||||||
for (hslot = htab; hslot < htab + HSIZE; hslot++)
|
|
||||||
*hslot++ = ip;
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
lit = 0; op++; /* start run */
|
|
||||||
|
|
||||||
hval = FRST(ip);
|
|
||||||
while (ip < in_end - 2)
|
|
||||||
{
|
|
||||||
hval = NEXT(hval, ip);
|
|
||||||
hslot = htab + IDX(hval);
|
|
||||||
ref = *hslot; *hslot = ip;
|
|
||||||
|
|
||||||
if (1
|
|
||||||
#if INIT_HTAB
|
|
||||||
&& ref < ip /* the next test will actually take care of this, but this is faster */
|
|
||||||
#endif
|
|
||||||
&& (off = ip - ref - 1) < MAX_OFF
|
|
||||||
&& ip + 4 < in_end
|
|
||||||
&& ref > (u8 *)in_data
|
|
||||||
#if STRICT_ALIGN
|
|
||||||
&& ref[0] == ip[0]
|
|
||||||
&& ref[1] == ip[1]
|
|
||||||
&& ref[2] == ip[2]
|
|
||||||
#else
|
|
||||||
&& *(u16 *)ref == *(u16 *)ip
|
|
||||||
&& ref[2] == ip[2]
|
|
||||||
#endif
|
|
||||||
)
|
|
||||||
{
|
|
||||||
/* match found at *ref++ */
|
|
||||||
unsigned int len = 2;
|
|
||||||
unsigned int maxlen = in_end - ip - len;
|
|
||||||
maxlen = maxlen > MAX_REF ? MAX_REF : maxlen;
|
|
||||||
|
|
||||||
op [- lit - 1] = lit - 1; /* stop run */
|
|
||||||
op -= !lit; /* undo run if length is zero */
|
|
||||||
|
|
||||||
if (expect_false(op + 3 + 1 >= out_end))
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
for (;;)
|
|
||||||
{
|
|
||||||
if (expect_true(maxlen > 16))
|
|
||||||
{
|
|
||||||
len++; if (ref [len] != ip [len]) break;
|
|
||||||
len++; if (ref [len] != ip [len]) break;
|
|
||||||
len++; if (ref [len] != ip [len]) break;
|
|
||||||
len++; if (ref [len] != ip [len]) break;
|
|
||||||
|
|
||||||
len++; if (ref [len] != ip [len]) break;
|
|
||||||
len++; if (ref [len] != ip [len]) break;
|
|
||||||
len++; if (ref [len] != ip [len]) break;
|
|
||||||
len++; if (ref [len] != ip [len]) break;
|
|
||||||
|
|
||||||
len++; if (ref [len] != ip [len]) break;
|
|
||||||
len++; if (ref [len] != ip [len]) break;
|
|
||||||
len++; if (ref [len] != ip [len]) break;
|
|
||||||
len++; if (ref [len] != ip [len]) break;
|
|
||||||
|
|
||||||
len++; if (ref [len] != ip [len]) break;
|
|
||||||
len++; if (ref [len] != ip [len]) break;
|
|
||||||
len++; if (ref [len] != ip [len]) break;
|
|
||||||
len++; if (ref [len] != ip [len]) break;
|
|
||||||
}
|
|
||||||
|
|
||||||
do
|
|
||||||
len++;
|
|
||||||
while (len < maxlen && ref[len] == ip[len]);
|
|
||||||
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
len -= 2;
|
|
||||||
ip++;
|
|
||||||
|
|
||||||
if (len < 7)
|
|
||||||
{
|
|
||||||
*op++ = (off >> 8) + (len << 5);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
*op++ = (off >> 8) + (7 << 5);
|
|
||||||
*op++ = len - 7;
|
|
||||||
}
|
|
||||||
|
|
||||||
*op++ = off;
|
|
||||||
|
|
||||||
#if ULTRA_FAST || VERY_FAST
|
|
||||||
ip += len;
|
|
||||||
#if VERY_FAST && !ULTRA_FAST
|
|
||||||
--ip;
|
|
||||||
#endif
|
|
||||||
hval = FRST(ip);
|
|
||||||
|
|
||||||
hval = NEXT(hval, ip);
|
|
||||||
htab[IDX(hval)] = ip;
|
|
||||||
ip++;
|
|
||||||
|
|
||||||
#if VERY_FAST && !ULTRA_FAST
|
|
||||||
hval = NEXT(hval, ip);
|
|
||||||
htab[IDX(hval)] = ip;
|
|
||||||
ip++;
|
|
||||||
#endif
|
|
||||||
#else
|
|
||||||
do
|
|
||||||
{
|
|
||||||
hval = NEXT(hval, ip);
|
|
||||||
htab[IDX(hval)] = ip;
|
|
||||||
ip++;
|
|
||||||
}
|
|
||||||
while (len--);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
lit = 0; op++; /* start run */
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
/* one more literal byte we must copy */
|
|
||||||
if (expect_false(op >= out_end))
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
lit++; *op++ = *ip++;
|
|
||||||
|
|
||||||
if (expect_false(lit == MAX_LIT))
|
|
||||||
{
|
|
||||||
op [- lit - 1] = lit - 1; /* stop run */
|
|
||||||
lit = 0; op++; /* start run */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (op + 3 > out_end) /* at most 3 bytes can be missing here */
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
while (ip < in_end)
|
|
||||||
{
|
|
||||||
lit++; *op++ = *ip++;
|
|
||||||
|
|
||||||
if (expect_false(lit == MAX_LIT))
|
|
||||||
{
|
|
||||||
op [- lit - 1] = lit - 1; /* stop run */
|
|
||||||
lit = 0; op++; /* start run */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
op [- lit - 1] = lit - 1; /* end run */
|
|
||||||
op -= !lit; /* undo run if length is zero */
|
|
||||||
|
|
||||||
return op - (u8 *)out_data;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
@ -1,148 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2000-2007 Marc Alexander Lehmann <schmorp@schmorp.de>
|
|
||||||
*
|
|
||||||
* Redistribution and use in source and binary forms, with or without modifica-
|
|
||||||
* tion, are permitted provided that the following conditions are met:
|
|
||||||
*
|
|
||||||
* 1. Redistributions of source code must retain the above copyright notice,
|
|
||||||
* this list of conditions and the following disclaimer.
|
|
||||||
*
|
|
||||||
* 2. Redistributions in binary form must reproduce the above copyright
|
|
||||||
* notice, this list of conditions and the following disclaimer in the
|
|
||||||
* documentation and/or other materials provided with the distribution.
|
|
||||||
*
|
|
||||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
||||||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
|
|
||||||
* CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
|
||||||
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
|
|
||||||
* CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
||||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
||||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
||||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
|
|
||||||
* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
|
||||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
||||||
*
|
|
||||||
* Alternatively, the contents of this file may be used under the terms of
|
|
||||||
* the GNU General Public License ("GPL") version 2 or any later version,
|
|
||||||
* in which case the provisions of the GPL are applicable instead of
|
|
||||||
* the above. If you wish to allow the use of your version of this file
|
|
||||||
* only under the terms of the GPL and not to allow others to use your
|
|
||||||
* version of this file under the BSD license, indicate your decision
|
|
||||||
* by deleting the provisions above and replace them with the notice
|
|
||||||
* and other provisions required by the GPL. If you do not delete the
|
|
||||||
* provisions above, a recipient may use your version of this file under
|
|
||||||
* either the BSD or the GPL.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "lzfP.h"
|
|
||||||
|
|
||||||
#if AVOID_ERRNO
|
|
||||||
# define SET_ERRNO(n)
|
|
||||||
#else
|
|
||||||
# include <errno.h>
|
|
||||||
# define SET_ERRNO(n) errno = (n)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if (__i386 || __amd64) && __GNUC__ >= 3
|
|
||||||
# define lzf_movsb(dst, src, len) \
|
|
||||||
asm ("rep movsb" \
|
|
||||||
: "=D" (dst), "=S" (src), "=c" (len) \
|
|
||||||
: "0" (dst), "1" (src), "2" (len));
|
|
||||||
#endif
|
|
||||||
|
|
||||||
unsigned int
|
|
||||||
lzf_decompress(const void *const in_data, unsigned int in_len,
|
|
||||||
void *out_data, unsigned int out_len)
|
|
||||||
{
|
|
||||||
u8 const *ip = (const u8 *)in_data;
|
|
||||||
u8 *op = (u8 *)out_data;
|
|
||||||
u8 const *const in_end = ip + in_len;
|
|
||||||
u8 *const out_end = op + out_len;
|
|
||||||
|
|
||||||
do
|
|
||||||
{
|
|
||||||
unsigned int ctrl = *ip++;
|
|
||||||
|
|
||||||
if (ctrl < (1 << 5)) /* literal run */
|
|
||||||
{
|
|
||||||
ctrl++;
|
|
||||||
|
|
||||||
if (op + ctrl > out_end)
|
|
||||||
{
|
|
||||||
SET_ERRNO(E2BIG);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#if CHECK_INPUT
|
|
||||||
if (ip + ctrl > in_end)
|
|
||||||
{
|
|
||||||
SET_ERRNO(EINVAL);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef lzf_movsb
|
|
||||||
lzf_movsb(op, ip, ctrl);
|
|
||||||
#else
|
|
||||||
do
|
|
||||||
*op++ = *ip++;
|
|
||||||
while (--ctrl);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
else /* back reference */
|
|
||||||
{
|
|
||||||
unsigned int len = ctrl >> 5;
|
|
||||||
|
|
||||||
u8 *ref = op - ((ctrl & 0x1f) << 8) - 1;
|
|
||||||
|
|
||||||
#if CHECK_INPUT
|
|
||||||
if (ip >= in_end)
|
|
||||||
{
|
|
||||||
SET_ERRNO(EINVAL);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
if (len == 7)
|
|
||||||
{
|
|
||||||
len += *ip++;
|
|
||||||
#if CHECK_INPUT
|
|
||||||
if (ip >= in_end)
|
|
||||||
{
|
|
||||||
SET_ERRNO(EINVAL);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
ref -= *ip++;
|
|
||||||
|
|
||||||
if (op + len + 2 > out_end)
|
|
||||||
{
|
|
||||||
SET_ERRNO(E2BIG);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (ref < (u8 *)out_data)
|
|
||||||
{
|
|
||||||
SET_ERRNO(EINVAL);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef lzf_movsb
|
|
||||||
len += 2;
|
|
||||||
lzf_movsb(op, ref, len);
|
|
||||||
#else
|
|
||||||
*op++ = *ref++;
|
|
||||||
*op++ = *ref++;
|
|
||||||
|
|
||||||
do
|
|
||||||
*op++ = *ref++;
|
|
||||||
while (--len);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
}
|
|
||||||
while (ip < in_end);
|
|
||||||
|
|
||||||
return op - (u8 *)out_data;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
@ -248,7 +248,7 @@ void drawline2d(float x0, float y0, float x1, float y1, char col)
|
||||||
#define USEKENFILTER 1
|
#define USEKENFILTER 1
|
||||||
|
|
||||||
#ifdef USELZF
|
#ifdef USELZF
|
||||||
# include "lzf.h"
|
# include "fastlz.h"
|
||||||
#else
|
#else
|
||||||
# include "lzwnew.h"
|
# include "lzwnew.h"
|
||||||
#endif
|
#endif
|
||||||
|
|
@ -6055,7 +6055,7 @@ int32_t dxtfilter(int32_t fil, texcachepicture *pict, char *pic, void *midbuf, c
|
||||||
if (glusetexcachecompression)
|
if (glusetexcachecompression)
|
||||||
{
|
{
|
||||||
#ifdef USELZF
|
#ifdef USELZF
|
||||||
cleng = lzf_compress(pic, miplen, packbuf, miplen-1);
|
cleng = fastlz_compress(pic, miplen, packbuf/*, miplen-1*/);
|
||||||
if (cleng == 0)
|
if (cleng == 0)
|
||||||
{
|
{
|
||||||
// failed to compress
|
// failed to compress
|
||||||
|
|
@ -6097,7 +6097,7 @@ int32_t dxtfilter(int32_t fil, texcachepicture *pict, char *pic, void *midbuf, c
|
||||||
{
|
{
|
||||||
#ifdef USELZF
|
#ifdef USELZF
|
||||||
j = (miplen/stride)*8;
|
j = (miplen/stride)*8;
|
||||||
cleng = lzf_compress(midbuf,j,packbuf,j-1);
|
cleng = fastlz_compress(midbuf,j,packbuf/*,j-1*/);
|
||||||
if (cleng == 0)
|
if (cleng == 0)
|
||||||
{
|
{
|
||||||
cleng = j;
|
cleng = j;
|
||||||
|
|
@ -6128,7 +6128,7 @@ int32_t dxtfilter(int32_t fil, texcachepicture *pict, char *pic, void *midbuf, c
|
||||||
{
|
{
|
||||||
#ifdef USELZF
|
#ifdef USELZF
|
||||||
j = (miplen/stride)*4;
|
j = (miplen/stride)*4;
|
||||||
cleng = lzf_compress(midbuf,j,packbuf,j-1);
|
cleng = fastlz_compress(midbuf,j,packbuf/*,j-1*/);
|
||||||
if (cleng == 0)
|
if (cleng == 0)
|
||||||
{
|
{
|
||||||
cleng = j;
|
cleng = j;
|
||||||
|
|
@ -6164,7 +6164,7 @@ int32_t dxtfilter(int32_t fil, texcachepicture *pict, char *pic, void *midbuf, c
|
||||||
{
|
{
|
||||||
#ifdef USELZF
|
#ifdef USELZF
|
||||||
j = (miplen/stride)*4;
|
j = (miplen/stride)*4;
|
||||||
cleng = lzf_compress(midbuf,j,packbuf,j-1);
|
cleng = fastlz_compress(midbuf,j,packbuf/*,j-1*/);
|
||||||
if (cleng == 0)
|
if (cleng == 0)
|
||||||
{
|
{
|
||||||
cleng = j;
|
cleng = j;
|
||||||
|
|
@ -6198,7 +6198,7 @@ int32_t dedxtfilter(int32_t fil, texcachepicture *pict, char *pic, void *midbuf,
|
||||||
if (ispacked && cleng < pict->size) inbuf = packbuf; else inbuf = pic;
|
if (ispacked && cleng < pict->size) inbuf = packbuf; else inbuf = pic;
|
||||||
if (kread(fil, inbuf, cleng) != cleng) return -1;
|
if (kread(fil, inbuf, cleng) != cleng) return -1;
|
||||||
if (ispacked && cleng < pict->size)
|
if (ispacked && cleng < pict->size)
|
||||||
if (lzf_decompress(packbuf, cleng, pic, pict->size) == 0) return -1;
|
if (fastlz_decompress(packbuf, cleng, pic, pict->size) == 0) return -1;
|
||||||
#else
|
#else
|
||||||
if (ispacked) inbuf = packbuf; else inbuf = pic;
|
if (ispacked) inbuf = packbuf; else inbuf = pic;
|
||||||
if (kread(fil, inbuf, cleng) != cleng) return -1;
|
if (kread(fil, inbuf, cleng) != cleng) return -1;
|
||||||
|
|
@ -6225,7 +6225,7 @@ int32_t dedxtfilter(int32_t fil, texcachepicture *pict, char *pic, void *midbuf,
|
||||||
if (ispacked && cleng < j) inbuf = packbuf; else inbuf = midbuf;
|
if (ispacked && cleng < j) inbuf = packbuf; else inbuf = midbuf;
|
||||||
if (Bread(fil,inbuf,cleng) < cleng) return -1;
|
if (Bread(fil,inbuf,cleng) < cleng) return -1;
|
||||||
if (ispacked && cleng < j)
|
if (ispacked && cleng < j)
|
||||||
if (lzf_decompress(packbuf,cleng,midbuf,j) == 0) return -1;
|
if (fastlz_decompress(packbuf,cleng,midbuf,j) == 0) return -1;
|
||||||
#else
|
#else
|
||||||
if (Bread(fil,inbuf,cleng) < cleng) return -1;
|
if (Bread(fil,inbuf,cleng) < cleng) return -1;
|
||||||
if (ispacked && lzwuncompress(packbuf,cleng,midbuf,j) != j) return -1;
|
if (ispacked && lzwuncompress(packbuf,cleng,midbuf,j) != j) return -1;
|
||||||
|
|
@ -6243,7 +6243,7 @@ int32_t dedxtfilter(int32_t fil, texcachepicture *pict, char *pic, void *midbuf,
|
||||||
if (ispacked && cleng < j) inbuf = packbuf; else inbuf = midbuf;
|
if (ispacked && cleng < j) inbuf = packbuf; else inbuf = midbuf;
|
||||||
if (Bread(fil,inbuf,cleng) < cleng) return -1;
|
if (Bread(fil,inbuf,cleng) < cleng) return -1;
|
||||||
if (ispacked && cleng < j)
|
if (ispacked && cleng < j)
|
||||||
if (lzf_decompress(packbuf,cleng,midbuf,j) == 0) return -1;
|
if (fastlz_decompress(packbuf,cleng,midbuf,j) == 0) return -1;
|
||||||
#else
|
#else
|
||||||
if (Bread(fil,inbuf,cleng) < cleng) return -1;
|
if (Bread(fil,inbuf,cleng) < cleng) return -1;
|
||||||
if (ispacked && lzwuncompress(packbuf,cleng,midbuf,j) != j) return -1;
|
if (ispacked && lzwuncompress(packbuf,cleng,midbuf,j) != j) return -1;
|
||||||
|
|
@ -6263,7 +6263,7 @@ int32_t dedxtfilter(int32_t fil, texcachepicture *pict, char *pic, void *midbuf,
|
||||||
if (ispacked && cleng < j) inbuf = packbuf; else inbuf = midbuf;
|
if (ispacked && cleng < j) inbuf = packbuf; else inbuf = midbuf;
|
||||||
if (Bread(fil,inbuf,cleng) < cleng) return -1;
|
if (Bread(fil,inbuf,cleng) < cleng) return -1;
|
||||||
if (ispacked && cleng < j)
|
if (ispacked && cleng < j)
|
||||||
if (lzf_decompress(packbuf,cleng,midbuf,j) == 0) return -1;
|
if (fastlz_decompress(packbuf,cleng,midbuf,j) == 0) return -1;
|
||||||
#else
|
#else
|
||||||
if (Bread(fil,inbuf,cleng) < cleng) return -1;
|
if (Bread(fil,inbuf,cleng) < cleng) return -1;
|
||||||
if (ispacked && lzwuncompress(packbuf,cleng,midbuf,j) != j) return -1;
|
if (ispacked && lzwuncompress(packbuf,cleng,midbuf,j) != j) return -1;
|
||||||
|
|
|
||||||
|
|
@ -125,7 +125,7 @@
|
||||||
>
|
>
|
||||||
</File>
|
</File>
|
||||||
<File
|
<File
|
||||||
RelativePath=".\build\include\lzf.h"
|
RelativePath=".\build\include\fastlz.h"
|
||||||
>
|
>
|
||||||
</File>
|
</File>
|
||||||
<File
|
<File
|
||||||
|
|
@ -277,15 +277,7 @@
|
||||||
>
|
>
|
||||||
</File>
|
</File>
|
||||||
<File
|
<File
|
||||||
RelativePath=".\build\src\lzf_c.c"
|
RelativePath=".\build\src\fastlz.c"
|
||||||
>
|
|
||||||
</File>
|
|
||||||
<File
|
|
||||||
RelativePath=".\build\src\lzf_d.c"
|
|
||||||
>
|
|
||||||
</File>
|
|
||||||
<File
|
|
||||||
RelativePath=".\build\src\lzfP.h"
|
|
||||||
>
|
>
|
||||||
</File>
|
</File>
|
||||||
<File
|
<File
|
||||||
|
|
|
||||||
|
|
@ -42,7 +42,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||||
#include "fx_man.h"
|
#include "fx_man.h"
|
||||||
|
|
||||||
#include "macros.h"
|
#include "macros.h"
|
||||||
#include "lzf.h"
|
#include "fastlz.h"
|
||||||
|
|
||||||
#ifdef _WIN32
|
#ifdef _WIN32
|
||||||
#define WIN32_LEAN_AND_MEAN
|
#define WIN32_LEAN_AND_MEAN
|
||||||
|
|
@ -226,8 +226,8 @@ void create_map_snapshot(void)
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
mapstate->sectors = (sectortype *)Bcalloc(1, sizeof(sectortype) * numsectors);
|
mapstate->sectors = (sectortype *)Bcalloc(1, sizeof(sectortype) * numsectors);
|
||||||
mapstate->sectsiz = j = lzf_compress(§or[0], sizeof(sectortype) * numsectors,
|
mapstate->sectsiz = j = fastlz_compress(§or[0], sizeof(sectortype) * numsectors,
|
||||||
&mapstate->sectors[0], sizeof(sectortype) * numsectors);
|
&mapstate->sectors[0]/*, sizeof(sectortype) * numsectors*/);
|
||||||
mapstate->sectors = (sectortype *)Brealloc(mapstate->sectors, j);
|
mapstate->sectors = (sectortype *)Brealloc(mapstate->sectors, j);
|
||||||
mapstate->sectcrc = tempcrc;
|
mapstate->sectcrc = tempcrc;
|
||||||
}
|
}
|
||||||
|
|
@ -247,8 +247,8 @@ void create_map_snapshot(void)
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
mapstate->walls = (walltype *)Bcalloc(1, sizeof(walltype) * numwalls);
|
mapstate->walls = (walltype *)Bcalloc(1, sizeof(walltype) * numwalls);
|
||||||
mapstate->wallsiz = j = lzf_compress(&wall[0], sizeof(walltype) * numwalls,
|
mapstate->wallsiz = j = fastlz_compress(&wall[0], sizeof(walltype) * numwalls,
|
||||||
&mapstate->walls[0], sizeof(walltype) * numwalls);
|
&mapstate->walls[0]/*, sizeof(walltype) * numwalls*/);
|
||||||
mapstate->walls = (walltype *)Brealloc(mapstate->walls, j);
|
mapstate->walls = (walltype *)Brealloc(mapstate->walls, j);
|
||||||
mapstate->wallcrc = tempcrc;
|
mapstate->wallcrc = tempcrc;
|
||||||
}
|
}
|
||||||
|
|
@ -280,8 +280,8 @@ void create_map_snapshot(void)
|
||||||
i++;
|
i++;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
mapstate->spritesiz = j = lzf_compress(&tspri[0], sizeof(spritetype) * numsprites,
|
mapstate->spritesiz = j = fastlz_compress(&tspri[0], sizeof(spritetype) * numsprites,
|
||||||
&mapstate->sprites[0], sizeof(spritetype) * numsprites);
|
&mapstate->sprites[0]/*, sizeof(spritetype) * numsprites*/);
|
||||||
mapstate->sprites = (spritetype *)Brealloc(mapstate->sprites, j);
|
mapstate->sprites = (spritetype *)Brealloc(mapstate->sprites, j);
|
||||||
mapstate->spritecrc = tempcrc;
|
mapstate->spritecrc = tempcrc;
|
||||||
Bfree(tspri);
|
Bfree(tspri);
|
||||||
|
|
@ -352,13 +352,13 @@ int32_t map_undoredo(int32_t dir)
|
||||||
|
|
||||||
if (mapstate->numsectors)
|
if (mapstate->numsectors)
|
||||||
{
|
{
|
||||||
lzf_decompress(&mapstate->sectors[0], mapstate->sectsiz, §or[0], sizeof(sectortype) * numsectors);
|
fastlz_decompress(&mapstate->sectors[0], mapstate->sectsiz, §or[0], sizeof(sectortype) * numsectors);
|
||||||
|
|
||||||
if (mapstate->numwalls)
|
if (mapstate->numwalls)
|
||||||
lzf_decompress(&mapstate->walls[0], mapstate->wallsiz, &wall[0], sizeof(walltype) * numwalls);
|
fastlz_decompress(&mapstate->walls[0], mapstate->wallsiz, &wall[0], sizeof(walltype) * numwalls);
|
||||||
|
|
||||||
if (mapstate->numsprites)
|
if (mapstate->numsprites)
|
||||||
lzf_decompress(&mapstate->sprites[0], mapstate->spritesiz, &sprite[0], sizeof(spritetype) * numsprites);
|
fastlz_decompress(&mapstate->sprites[0], mapstate->spritesiz, &sprite[0], sizeof(spritetype) * numsprites);
|
||||||
}
|
}
|
||||||
|
|
||||||
updatenumsprites();
|
updatenumsprites();
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue