orbea
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

add lz4 compression options to eet. remove amalgamated build too. 

SVN revision: 71111
This commit is contained in:
Carsten Haitzler 2012-05-15 12:27:56 +00:00
parent 726b718812
commit 6d8004a29d
11 changed files with 2017 additions and 268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
legacy/eet/ChangeLog
View File

@ -587,6 +587,10 @@
* Force destruction of all pending file when shuting down eet.
2012-05-14 Carsten Haitzler (The Rasterman)
* Add LZ4/LZ4HC compression & decompression capabilities
2012-05-15 Cedric Bail
* Make eet_dictionary thread safe.

18
legacy/eet/configure.ac
View File

@ -72,23 +72,6 @@ want_signature="yes"
requirement_eet=""
### Additional options to configure
# Amalgamation
AC_ARG_ENABLE([amalgamation],
[AC_HELP_STRING([--enable-amalgamation], [enable generation of one single file with all source code in it, helps compiler optimizations.])],
[if test "x${enableval}" = "xyes"; then
do_amalgamation="yes"
else
do_amalgamation="no"
fi
],
[do_amalgamation="no"]
)
AM_CONDITIONAL(EET_AMALGAMATION, test "x${do_amalgamation}" = "xyes")
EFL_ENABLE_BIN([eet])
# Old eet file format support
@ -516,7 +499,6 @@ echo "------------------------------------------------------------------------"
echo
echo "Configuration Options Summary:"
echo
echo " Amalgamation.........: ${do_amalgamation}"
echo " Secure layer.........: ${secure_layer}"
if test "x${have_gnutls}" = "xyes" || test "x${have_openssl}" = "xyes" ; then
echo " Cipher support.....: ${have_cipher}"

33
legacy/eet/src/lib/Eet.h
View File

@ -256,6 +256,39 @@ typedef enum _Eet_Error
EET_ERROR_DECRYPT_FAILED /**< Could not decrypt contents */
} Eet_Error; /**< Eet error identifiers */
/**
* @}
*/
/**
* @defgroup Eet_Compression Eet Compression Levels
* Compression modes/levels supported by Eet.
*
* @{
*/
/**
* @enum _Eet_Compression
* All the compression modes known by Eet.
*/
typedef enum _Eet_Compression
{
EET_COMPRESSION_NONE = 0, /**< No compression at all */
EET_COMPRESSION_DEFAULT = 1, /**< Default compression (Zlib) */
EET_COMPRESSION_LOW = 2, /**< Fast but minimal compression (Zlib) */
EET_COMPRESSION_MED = 6, /**< Medium compression level (Zlib) */
EET_COMPRESSION_HI = 9, /**< Slow but high compression level (Zlib) */
EET_COMPRESSION_VERYFAST = 10, /**< Very fast, but lower compression ratio (LZ4HC) */
EET_COMPRESSION_SUPERFAST = 11, /**< Very fast, but lower compression ratio (faster to compress than EET_COMPRESSION_VERYFAST) (LZ4) */
EET_COMPRESSION_LOW2 = 3, /**< Space filler for compatibility. Don't use it */
EET_COMPRESSION_MED1 = 4, /**< Space filler for compatibility. Don't use it */
EET_COMPRESSION_MED2 = 5, /**< Space filler for compatibility. Don't use it */
EET_COMPRESSION_HI1 = 7, /**< Space filler for compatibility. Don't use it */
EET_COMPRESSION_HI2 = 8 /**< Space filler for compatibility. Don't use it */
} Eet_Compression; /**< Eet compression modes */
/**
* @}
*/

2
legacy/eet/src/lib/Eet_private.h
View File

@ -125,6 +125,8 @@ struct _Eet_File_Node
unsigned int size;
unsigned int data_size;
unsigned char compression_type;
unsigned char free_name : 1;
unsigned char compression : 1;
unsigned char ciphered : 1;

130
legacy/eet/src/lib/Makefile.am
View File

@ -4,6 +4,7 @@ MAINTAINERCLEANFILES = Makefile.in
AM_CPPFLAGS = \
-I. \
-I$(top_srcdir)/src/lib \
-I$(top_srcdir)/src/lib/lz4 \
-I$(top_builddir)/src/lib \
-DPACKAGE_BIN_DIR=\"$(bindir)\" \
-DPACKAGE_LIB_DIR=\"$(libdir)\" \
@ -21,7 +22,7 @@ includesdir = $(includedir)/eet-@VMAJ@
lib_LTLIBRARIES = libeet.la
base_sources = \
libeet_la_SOURCES = \
eet_alloc.c \
eet_lib.c \
eet_data.c \
@ -30,128 +31,11 @@ eet_cipher.c \
eet_dictionary.c \
eet_node.c \
eet_utils.c \
eet_connection.c
if EET_AMALGAMATION
nodist_libeet_la_SOURCES = eet_amalgamation.c
eet_amalgamation.c: $(base_sources) Makefile
-rm -f eet_amalgamation.c
@echo "#ifdef HAVE_CONFIG_H" >> eet_amalgamation.c
@echo "# include \"config.h\"" >> eet_amalgamation.c
@echo "#endif" >> eet_amalgamation.c
@echo "#ifdef HAVE_ALLOCA_H" >> eet_amalgamation.c
@echo "# include <alloca.h>" >> eet_amalgamation.c
@echo "#elif defined __GNUC__" >> eet_amalgamation.c
@echo "# define alloca __builtin_alloca" >> eet_amalgamation.c
@echo "#elif defined _AIX" >> eet_amalgamation.c
@echo "# define alloca __alloca" >> eet_amalgamation.c
@echo "#elif defined _MSC_VER" >> eet_amalgamation.c
@echo "# include <malloc.h>" >> eet_amalgamation.c
@echo "# define alloca _alloca" >> eet_amalgamation.c
@echo "#else" >> eet_amalgamation.c
@echo "# include <stddef.h>" >> eet_amalgamation.c
@echo "# ifdef __cplusplus" >> eet_amalgamation.c
@echo "#extern \"C\"" >> eet_amalgamation.c
@echo "# endif" >> eet_amalgamation.c
@echo "#void *alloca (size_t);" >> eet_amalgamation.c
@echo "#endif" >> eet_amalgamation.c
@echo "#include <stdio.h>" >> eet_amalgamation.c
@echo "#include <string.h>" >> eet_amalgamation.c
@echo "#include <math.h>" >> eet_amalgamation.c
@echo "#include <ctype.h>" >> eet_amalgamation.c
@echo "#include <limits.h>" >> eet_amalgamation.c
@echo "#include <sys/types.h>" >> eet_amalgamation.c
@echo "#include <sys/stat.h>" >> eet_amalgamation.c
@echo "#ifdef HAVE_SIGNATURE" >> eet_amalgamation.c
@echo "# include <sys/mman.h>" >> eet_amalgamation.c
@echo "#endif" >> eet_amalgamation.c
@echo "#include <setjmp.h>" >> eet_amalgamation.c
@echo "#include <errno.h>" >> eet_amalgamation.c
@echo "#include <time.h>" >> eet_amalgamation.c
@echo "#include <fnmatch.h>" >> eet_amalgamation.c
@echo "#include <fcntl.h>" >> eet_amalgamation.c
@echo "#ifdef _WIN32" >> eet_amalgamation.c
@echo "# include <winsock2.h>" >> eet_amalgamation.c
@echo "#endif" >> eet_amalgamation.c
@echo "#ifndef _MSC_VER" >> eet_amalgamation.c
@echo "# include <unistd.h>" >> eet_amalgamation.c
@echo "#endif" >> eet_amalgamation.c
@echo "#ifdef HAVE_NETINET_IN_H" >> eet_amalgamation.c
@echo "# include <netinet/in.h>" >> eet_amalgamation.c
@echo "#endif" >> eet_amalgamation.c
@echo "#ifdef HAVE_GNUTLS" >> eet_amalgamation.c
@echo "# include <gnutls/gnutls.h>" >> eet_amalgamation.c
@echo "# include <gcrypt.h>" >> eet_amalgamation.c
@echo "#endif" >> eet_amalgamation.c
@echo "#ifdef HAVE_OPENSSL" >> eet_amalgamation.c
@echo "# include <openssl/err.h>" >> eet_amalgamation.c
@echo "# include <openssl/evp.h>" >> eet_amalgamation.c
@echo "# include <openssl/sha.h>" >> eet_amalgamation.c
@echo "#endif" >> eet_amalgamation.c
@echo "#ifdef HAVE_SIGNATURE" >> eet_amalgamation.c
@echo "# ifdef HAVE_GNUTLS" >> eet_amalgamation.c
@echo "# include <gnutls/gnutls.h>" >> eet_amalgamation.c
@echo "# include <gnutls/x509.h>" >> eet_amalgamation.c
@echo "# else" >> eet_amalgamation.c
@echo "# include <openssl/rsa.h>" >> eet_amalgamation.c
@echo "# include <openssl/objects.h>" >> eet_amalgamation.c
@echo "# include <openssl/err.h>" >> eet_amalgamation.c
@echo "# include <openssl/ssl.h>" >> eet_amalgamation.c
@echo "# include <openssl/dh.h>" >> eet_amalgamation.c
@echo "# include <openssl/dsa.h>" >> eet_amalgamation.c
@echo "# include <openssl/evp.h>" >> eet_amalgamation.c
@echo "# include <openssl/x509.h>" >> eet_amalgamation.c
@echo "# include <openssl/pem.h>" >> eet_amalgamation.c
@echo "# endif" >> eet_amalgamation.c
@echo "#endif" >> eet_amalgamation.c
@echo "#ifdef HAVE_CIPHER" >> eet_amalgamation.c
@echo "# ifdef HAVE_GNUTLS" >> eet_amalgamation.c
@echo "# include <gnutls/x509.h>" >> eet_amalgamation.c
@echo "# include <gcrypt.h>" >> eet_amalgamation.c
@echo "# else" >> eet_amalgamation.c
@echo "# include <openssl/evp.h>" >> eet_amalgamation.c
@echo "# include <openssl/hmac.h>" >> eet_amalgamation.c
@echo "# include <openssl/rand.h>" >> eet_amalgamation.c
@echo "# endif" >> eet_amalgamation.c
@echo "#endif" >> eet_amalgamation.c
@echo "#include <zlib.h>" >> eet_amalgamation.c
@echo "#include <jpeglib.h>" >> eet_amalgamation.c
@echo "#ifdef HAVE_EVIL" >> eet_amalgamation.c
@echo "# include <Evil.h>" >> eet_amalgamation.c
@echo "#endif" >> eet_amalgamation.c
@echo "#include <Eet.h>" >> eet_amalgamation.c
@echo "#include \"Eet_private.h\"" >> eet_amalgamation.c
@echo "#include \"Eet.h\"" >> eet_amalgamation.c
@for f in $(base_sources); do \
if [ `echo $$f | sed -e 's/^...\(.\).*/\1/'` != '/' ]; then \
file="$(srcdir)/$$f" ; \
else \
file="$$f" ; \
fi ; \
echo "/* file: $$file */" >> eet_amalgamation.c; \
grep -v -e '^# *include \+.\(config\|\|Evil\|Eina\|stdio\|string\|math\|ctype\|limits\|sys/types\|sys/stat\|sys/mman\|setjmp\|errno\|time\|fnmatch\|fcntl\|winsock2\|unistd\|netinet/in\|gnutls/gnutls\|gcrypt\|gnutls/x509\|openssl/rsa\|openssl/objects\|openssl/err\|openssl/ssl\|openssl/dh\|openssl/dsa\|openssl/evp\|openssl/pem\|openssl/sha\|openssl/hmac\|openssl/x509\|openssl/rand\|zlib\|jpeglib\|Eet_private\|Eet\)[.]h.*' $$file >> eet_amalgamation.c; \
done
@echo "eet_amalgamation.c generated"
else
libeet_la_SOURCES = $(base_sources)
endif
eet_connection.c \
lz4/lz4.c \
lz4/lz4.h \
lz4/lz4hc.c \
lz4/lz4hc.h
libeet_la_CFLAGS = @EET_CFLAGS@ @DEBUG_CFLAGS@
libeet_la_LIBADD = @GNUTLS_LIBS@ @OPENSSL_LIBS@ @EFL_COVERAGE_LIBS@ @EET_LIBS@ @EINA_LIBS@ @EVIL_LIBS@ -lz -ljpeg -lm

160
legacy/eet/src/lib/eet_image.c
View File

@ -40,6 +40,9 @@ void *alloca(size_t);
#include "Eet.h"
#include "Eet_private.h"
#include "lz4.h"
#include "lz4hc.h"
/*---*/
typedef struct _JPEG_error_mgr *emptr;
@ -742,55 +745,68 @@ eet_data_image_lossless_compressed_convert(int *size,
}
{
unsigned char *d;
unsigned char *comp;
int *header;
int ret;
uLongf buflen;
d = malloc((w * h * 4) + (8 * 4));
if (!d)
return NULL;
unsigned char *d, *comp;
int *header, ret, ok = 1;
uLongf buflen = 0;
buflen = (((w * h * 101) / 100) + 3) * 4;
ret = LZ4_compressBound((w * h * 4));
if ((ret > 0) && ((uLongf)ret > buflen)) buflen = ret;
comp = malloc(buflen);
if (!comp)
if (!comp) return NULL;
switch (compression)
{
free(d);
case EET_COMPRESSION_VERYFAST:
ret = LZ4_compressHC((const char *)data, (char *)comp,
(w * h * 4));
if (ret <= 0) ok = 0;
buflen = ret;
break;
case EET_COMPRESSION_SUPERFAST:
ret = LZ4_compress((const char *)data, (char *)comp,
(w * h * 4));
if (ret <= 0) ok = 0;
buflen = ret;
break;
default: /* zlib etc. */
ret = compress2((Bytef *)comp, &buflen, (Bytef *)(data),
(uLong)(w * h * 4), compression);
if (ret != Z_OK) ok = 0;
break;
}
if ((!ok) || (buflen > (w * h * 4)))
{
free(comp);
*size = -1;
return NULL;
}
d = malloc((8 * sizeof(int)) + buflen);
if (!d)
{
free(comp);
return NULL;
}
header = (int *)d;
memset(d, 0, 32);
memset(d, 0, 8 * sizeof(int));
header[0] = 0xac1dfeed;
header[1] = w;
header[2] = h;
header[3] = alpha;
header[4] = compression;
memcpy(d + 32, data, w * h * 4);
if (_eet_image_words_bigendian)
{
unsigned int i;
for (i = 0; i < ((w * h) + 8); i++) SWAP32(header[i]);
}
ret = compress2((Bytef *)comp, &buflen,
(Bytef *)(d + 32),
(uLong)(w * h * 4),
compression);
if (ret != Z_OK || buflen > (w * h * 4))
{
free(comp);
free(d);
*size = -1;
return NULL;
}
memcpy(d + 32, comp, buflen);
*size = (8 * 4) + buflen;
memcpy(d + (8 * sizeof(int)), comp, buflen);
*size = (8 * sizeof(int)) + buflen;
free(comp);
return d;
}
@ -1577,35 +1593,75 @@ _eet_data_image_decode_inside(const void *data,
w, h, row_stride);
else
{
if (src_h == h && src_w == w && row_stride == src_w * 4)
if ((src_h == h) && (src_w == w) && (row_stride == src_w * 4))
{
uLongf dlen;
dlen = w * h * 4;
uncompress((Bytef *)d, &dlen, (Bytef *)body,
(uLongf)(size - 32));
switch (comp)
{
case EET_COMPRESSION_VERYFAST:
case EET_COMPRESSION_SUPERFAST:
if (LZ4_uncompress((const char *)body,
(char *)d, w * h * 4)
!= (size - 32)) return 0;
break;
default:
{
uLongf dlen = w * h * 4;
if (uncompress((Bytef *)d, &dlen, (Bytef *)body,
(uLongf)(size - 32)) != Z_OK)
return 0;
}
break;
}
}
else
{
Bytef *dtmp;
uLongf dlen = src_w * src_h * 4;
/* FIXME: This could create a huge alloc. So compressed
data and tile could not always work. */
dtmp = malloc(dlen);
if (!dtmp)
return 0;
uncompress(dtmp, &dlen, (Bytef *)body, (uLongf)(size - 32));
_eet_data_image_copy_buffer((unsigned int *)dtmp,
src_x, src_y, src_w, d,
w, h, row_stride);
free(dtmp);
switch (comp)
{
case EET_COMPRESSION_VERYFAST:
case EET_COMPRESSION_SUPERFAST:
{
char *dtmp;
dtmp = malloc(src_w * src_h * 4);
if (!dtmp) return 0;
if (LZ4_uncompress((const char *)body,
dtmp, w * h * 4)
!= (size - 32))
{
free(dtmp);
return 0;
}
_eet_data_image_copy_buffer((unsigned int *)dtmp,
src_x, src_y, src_w, d,
w, h, row_stride);
free(dtmp);
}
break;
default:
{
Bytef *dtmp;
uLongf dlen = src_w * src_h * 4;
/* FIXME: This could create a huge alloc. So
compressed data and tile could not always work.*/
dtmp = malloc(dlen);
if (!dtmp) return 0;
if (uncompress(dtmp, &dlen, (Bytef *)body,
(uLongf)(size - 32)) != Z_OK)
{
free(dtmp);
return 0;
}
_eet_data_image_copy_buffer((unsigned int *)dtmp,
src_x, src_y, src_w, d,
w, h, row_stride);
free(dtmp);
}
}
}
}
/* Fix swapiness. */
if (_eet_image_words_bigendian)
{

276
legacy/eet/src/lib/eet_lib.c
View File

@ -66,6 +66,9 @@ GCRY_THREAD_OPTION_PTHREAD_IMPL;
#include "Eet.h"
#include "Eet_private.h"
#include "lz4.h"
#include "lz4hc.h"
#ifndef O_BINARY
# define O_BINARY 0
#endif
@ -442,6 +445,7 @@ eet_flush2(Eet_File *ef)
int ibuf[EET_FILE2_DIRECTORY_ENTRY_COUNT];
flag = (efn->alias << 2) | (efn->ciphered << 1) | efn->compression;
flag |= efn->compression_type << 3;
ibuf[0] = (int)htonl((unsigned int)efn->offset);
ibuf[1] = (int)htonl((unsigned int)efn->size);
@ -864,6 +868,7 @@ eet_internal_read2(Eet_File *ef)
efn->compression = flag & 0x1 ? 1 : 0;
efn->ciphered = flag & 0x2 ? 1 : 0;
efn->alias = flag & 0x4 ? 1 : 0;
efn->compression_type = (flag >> 3) & 0xff;
#define EFN_TEST(Test, Ef, Efn) \
if (eet_test_close(Test, Ef)) \
@ -1719,7 +1724,7 @@ eet_read_cipher(Eet_File *ef,
void *tmp_data = NULL;
void *data_deciphered = NULL;
unsigned int data_deciphered_sz = 0;
int free_tmp = 0;
int free_tmp = 0, ret;
int compr_size = efn->size;
uLongf dlen;
@ -1765,12 +1770,27 @@ eet_read_cipher(Eet_File *ef,
/* decompress it */
dlen = size;
if (uncompress((Bytef *)data, &dlen,
tmp_data, (uLongf)compr_size))
switch (efn->compression_type)
{
if (free_tmp)
free(tmp_data);
goto on_error;
case EET_COMPRESSION_VERYFAST:
case EET_COMPRESSION_SUPERFAST:
ret = LZ4_uncompress(tmp_data, data, dlen);
if (ret != compr_size)
{
if (free_tmp)
free(tmp_data);
goto on_error;
}
break;
default:
if (uncompress((Bytef *)data, &dlen,
tmp_data, (uLongf)compr_size) != Z_OK)
{
if (free_tmp)
free(tmp_data);
goto on_error;
}
break;
}
if (free_tmp)
@ -1821,7 +1841,7 @@ eet_read_direct(Eet_File *ef,
{
Eet_File_Node *efn;
const char *data = NULL;
int size = 0;
int size = 0, ret;
if (size_ret)
*size_ret = 0;
@ -1862,23 +1882,46 @@ eet_read_direct(Eet_File *ef,
/* handle alias case */
if (efn->compression)
{
const void *retptr;
char *tmp;
int compr_size = efn->size;
uLongf dlen;
tmp = alloca(sizeof (compr_size));
dlen = size;
if (uncompress((Bytef *)tmp, &dlen, (Bytef *)data,
(uLongf)compr_size))
goto on_error;
tmp = malloc(compr_size);
if (!tmp) goto on_error;
switch (efn->compression_type)
{
case EET_COMPRESSION_VERYFAST:
case EET_COMPRESSION_SUPERFAST:
ret = LZ4_uncompress(data, tmp, size);
if (ret != compr_size)
{
free(tmp);
goto on_error;
}
break;
default:
dlen = size;
if (uncompress((Bytef *)tmp, &dlen, (Bytef *)data,
(uLongf)compr_size))
{
free(tmp);
goto on_error;
}
}
if (tmp[compr_size - 1] != '\0')
goto on_error;
{
free(tmp);
goto on_error;
}
UNLOCK_FILE(ef);
return eet_read_direct(ef, tmp, size_ret);
retptr = eet_read_direct(ef, tmp, size_ret);
free(tmp);
return retptr;
}
if (!data)
@ -1893,8 +1936,7 @@ eet_read_direct(Eet_File *ef,
}
else
/* uncompressed data */
if (efn->compression == 0
&& efn->ciphered == 0)
if ((efn->compression == 0) && (efn->ciphered == 0))
data = efn->data ? efn->data : ef->data + efn->offset; /* compressed data */
else
data = NULL;
@ -1918,7 +1960,7 @@ eet_alias_get(Eet_File *ef,
{
Eet_File_Node *efn;
const char *data = NULL;
int size = 0;
int size = 0, ret;
/* check to see its' an eet file pointer */
if (eet_check_pointer(ef))
@ -1955,23 +1997,43 @@ eet_alias_get(Eet_File *ef,
/* handle alias case */
if (efn->compression)
{
const char *retptr;
char *tmp;
int compr_size = efn->size;
uLongf dlen;
tmp = alloca(sizeof (compr_size));
dlen = size;
if (uncompress((Bytef *)tmp, &dlen, (Bytef *)data,
(uLongf)compr_size))
goto on_error;
tmp = malloc(compr_size);
if (!tmp) goto on_error;
switch (efn->compression_type)
{
case EET_COMPRESSION_VERYFAST:
case EET_COMPRESSION_SUPERFAST:
ret = LZ4_uncompress(data, tmp, size);
if (ret != compr_size)
{
free(tmp);
goto on_error;
}
break;
default:
dlen = size;
if (uncompress((Bytef *)tmp, &dlen, (Bytef *)data,
(uLongf)compr_size))
{
free(tmp);
goto on_error;
}
}
if (tmp[compr_size - 1] != '\0')
goto on_error;
UNLOCK_FILE(ef);
return eina_stringshare_add(tmp);
retptr = eina_stringshare_add(tmp);
free(tmp);
return retptr;
}
if (!data)
@ -1998,8 +2060,7 @@ eet_alias(Eet_File *ef,
Eet_File_Node *efn;
void *data2;
Eina_Bool exists_already = EINA_FALSE;
int data_size;
int hash;
int data_size, ret, hash, slen;
/* check to see its' an eet file pointer */
if (eet_check_pointer(ef))
@ -2048,32 +2109,64 @@ eet_alias(Eet_File *ef,
/* figure hash bucket */
hash = _eet_hash_gen(name, ef->header->directory->size);
slen = strlen(destination) + 1;
data_size = comp ?
12 + (((strlen(destination) + 1) * 101) / 100)
: strlen(destination) + 1;
12 + ((slen * 101) / 100)
: slen;
if (comp)
{
ret = LZ4_compressBound(slen);
if ((ret > 0) && (ret > data_size)) data_size = ret;
}
data2 = malloc(data_size);
if (!data2)
goto on_error;
if (!data2) goto on_error;
/* if we want to compress */
if (comp)
{
uLongf buflen;
/* compress the data with max compression */
buflen = (uLongf)data_size;
if (compress2((Bytef *)data2, &buflen, (Bytef *)destination,
(uLong)strlen(destination) + 1,
Z_BEST_COMPRESSION) != Z_OK)
switch (comp)
{
free(data2);
goto on_error;
case EET_COMPRESSION_VERYFAST:
ret = LZ4_compressHC((const char *)destination, (char *)data2,
slen);
if (ret <= 0)
{
free(data2);
goto on_error;
}
data_size = ret;
break;
case EET_COMPRESSION_SUPERFAST:
ret = LZ4_compress((const char *)destination, (char *)data2,
slen);
if (ret <= 0)
{
free(data2);
goto on_error;
}
data_size = ret;
break;
default:
{
uLongf buflen;
/* compress the data with max compression */
buflen = (uLongf)data_size;
if (compress2((Bytef *)data2, &buflen,
(const Bytef *)destination,
(uLong)slen, Z_BEST_COMPRESSION) != Z_OK)
{
free(data2);
goto on_error;
}
/* record compressed chunk size */
data_size = (int)buflen;
}
break;
}
/* record compressed chunk size */
data_size = (int)buflen;
if (data_size < 0 || data_size >= (int)(strlen(destination) + 1))
if ((data_size < 0) ||
(data_size >= (int)(strlen(destination) + 1)))
{
comp = 0;
data_size = strlen(destination) + 1;
@ -2083,13 +2176,11 @@ eet_alias(Eet_File *ef,
void *data3;
data3 = realloc(data2, data_size);
if (data3)
data2 = data3;
if (data3) data2 = data3;
}
}
if (!comp)
memcpy(data2, destination, data_size);
if (!comp) memcpy(data2, destination, data_size);
/* Does this node already exist? */
for (efn = ef->header->directory->nodes[hash]; efn; efn = efn->next)
@ -2101,13 +2192,13 @@ eet_alias(Eet_File *ef,
efn->alias = 1;
efn->ciphered = 0;
efn->compression = !!comp;
efn->compression_type = comp;
efn->size = data_size;
efn->data_size = strlen(destination) + 1;
efn->data = data2;
/* Put the offset above the limit to avoid direct access */
/* Put the offset above the limit to avoid direct access */
efn->offset = ef->data_size + 1;
exists_already = EINA_TRUE;
break;
}
}
@ -2131,6 +2222,7 @@ eet_alias(Eet_File *ef,
efn->alias = 1;
efn->ciphered = 0;
efn->compression = !!comp;
efn->compression_type = comp;
efn->size = data_size;
efn->data_size = strlen(destination) + 1;
efn->data = data2;
@ -2157,9 +2249,7 @@ eet_write_cipher(Eet_File *ef,
{
Eet_File_Node *efn;
void *data2 = NULL;
int exists_already = 0;
int data_size;
int hash;
int exists_already = 0, data_size, hash, ret;
/* check to see its' an eet file pointer */
if (eet_check_pointer(ef))
@ -2208,8 +2298,15 @@ eet_write_cipher(Eet_File *ef,
/* figure hash bucket */
hash = _eet_hash_gen(name, ef->header->directory->size);
UNLOCK_FILE(ef);
data_size = comp ? 12 + ((size * 101) / 100) : size;
if (comp)
{
ret = LZ4_compressBound(size);
if ((ret > 0) && (ret > data_size)) data_size = ret;
}
if (comp || !cipher_key)
{
data2 = malloc(data_size);
@ -2220,20 +2317,46 @@ eet_write_cipher(Eet_File *ef,
/* if we want to compress */
if (comp)
{
uLongf buflen;
/* compress the data with max compression */
buflen = (uLongf)data_size;
if (compress2((Bytef *)data2, &buflen, (Bytef *)data,
(uLong)size, Z_BEST_COMPRESSION) != Z_OK)
switch (comp)
{
free(data2);
goto on_error;
}
case EET_COMPRESSION_VERYFAST:
ret = LZ4_compressHC((const char *)data, (char *)data2, size);
if (ret <= 0)
{
free(data2);
LOCK_FILE(ef);
goto on_error;
}
data_size = ret;
break;
case EET_COMPRESSION_SUPERFAST:
ret = LZ4_compress((const char *)data, (char *)data2, size);
if (ret <= 0)
{
free(data2);
LOCK_FILE(ef);
goto on_error;
}
data_size = ret;
break;
default:
{
uLongf buflen;
/* record compressed chunk size */
data_size = (int)buflen;
if (data_size < 0 || data_size >= size)
/* compress the data with max compression */
buflen = (uLongf)data_size;
if (compress2((Bytef *)data2, &buflen, (Bytef *)data,
(uLong)size, Z_BEST_COMPRESSION) != Z_OK)
{
free(data2);
LOCK_FILE(ef);
goto on_error;
}
/* record compressed chunk size */
data_size = (int)buflen;
}
}
if ((data_size < 0) || (data_size >= size))
{
comp = 0;
data_size = size;
@ -2276,6 +2399,7 @@ eet_write_cipher(Eet_File *ef,
if (!comp)
memcpy(data2, data, size);
LOCK_FILE(ef);
/* Does this node already exist? */
for (efn = ef->header->directory->nodes[hash]; efn; efn = efn->next)
{
@ -2286,10 +2410,11 @@ eet_write_cipher(Eet_File *ef,
efn->alias = 0;
efn->ciphered = cipher_key ? 1 : 0;
efn->compression = !!comp;
efn->compression_type = comp;
efn->size = data_size;
efn->data_size = size;
efn->data = data2;
/* Put the offset above the limit to avoid direct access */
/* Put the offset above the limit to avoid direct access */
efn->offset = ef->data_size + 1;
exists_already = 1;
break;
@ -2315,6 +2440,7 @@ eet_write_cipher(Eet_File *ef,
efn->alias = 0;
efn->ciphered = cipher_key ? 1 : 0;
efn->compression = !!comp;
efn->compression_type = comp;
efn->size = data_size;
efn->data_size = size;
efn->data = data2;

819
legacy/eet/src/lib/lz4/lz4.c Normal file
View File

@ -0,0 +1,819 @@
/*
LZ4 - Fast LZ compression algorithm
Copyright (C) 2011-2012, Yann Collet.
BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* 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 COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, 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 OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
You can contact the author at :
- LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
- LZ4 source repository : http://code.google.com/p/lz4/
*/
//**************************************
// Tuning parameters
//**************************************
// COMPRESSIONLEVEL :
// Increasing this value improves compression ratio
// Lowering this value reduces memory usage
// Reduced memory usage typically improves speed, due to cache effect (ex : L1 32KB for Intel, L1 64KB for AMD)
// Memory usage formula : N->2^(N+2) Bytes (examples : 12 -> 16KB ; 17 -> 512KB)
#define COMPRESSIONLEVEL 12
// NOTCOMPRESSIBLE_CONFIRMATION :
// Decreasing this value will make the algorithm skip faster data segments considered "incompressible"
// This may decrease compression ratio dramatically, but will be faster on incompressible data
// Increasing this value will make the algorithm search more before declaring a segment "incompressible"
// This could improve compression a bit, but will be slower on incompressible data
// The default value (6) is recommended
#define NOTCOMPRESSIBLE_CONFIRMATION 6
// LZ4_COMPRESSMIN :
// Compression function will *fail* if it is not successful at compressing input by at least LZ4_COMPRESSMIN bytes
// Since the compression function stops working prematurely, it results in a speed gain
// The output however is unusable. Compression function result will be zero.
// Default : 0 = disabled
#define LZ4_COMPRESSMIN 0
// BIG_ENDIAN_NATIVE_BUT_INCOMPATIBLE :
// This will provide a boost to performance for big endian cpu, but the resulting compressed stream will be incompatible with little-endian CPU.
// You can set this option to 1 in situations where data will stay within closed environment
// This option is useless on Little_Endian CPU (such as x86)
//#define BIG_ENDIAN_NATIVE_BUT_INCOMPATIBLE 1
//**************************************
// CPU Feature Detection
//**************************************
// 32 or 64 bits ?
#if (defined(__x86_64__) || defined(__x86_64) || defined(__amd64__) || defined(__amd64) || defined(__ppc64__) || defined(_WIN64) || defined(__LP64__) || defined(_LP64) ) // Detects 64 bits mode
# define LZ4_ARCH64 1
#else
# define LZ4_ARCH64 0
#endif
// Little Endian or Big Endian ?
// Note : overwrite the below #define if you know your architecture endianess
#if (defined(__BIG_ENDIAN__) || defined(__BIG_ENDIAN) || defined(_BIG_ENDIAN) || defined(_ARCH_PPC) || defined(__PPC__) || defined(__PPC) || defined(PPC) || defined(__powerpc__) || defined(__powerpc) || defined(powerpc) || ((defined(__BYTE_ORDER__)&&(__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))) )
# define LZ4_BIG_ENDIAN 1
#else
// Little Endian assumed. PDP Endian and other very rare endian format are unsupported.
#endif
// Unaligned memory access is automatically enabled for "common" CPU, such as x86.
// For others CPU, the compiler will be more cautious, and insert extra code to ensure aligned access is respected
// If you know your target CPU supports unaligned memory access, you may want to force this option manually to improve performance
#if defined(__ARM_FEATURE_UNALIGNED)
# define LZ4_FORCE_UNALIGNED_ACCESS 1
#endif
// Define this parameter if your target system or compiler does not support hardware bit count
#if defined(_MSC_VER) && defined(_WIN32_WCE) // Visual Studio for Windows CE does not support Hardware bit count
# define LZ4_FORCE_SW_BITCOUNT
#endif
//**************************************
// Compiler Options
//**************************************
#if __STDC_VERSION__ >= 199901L // C99
/* "restrict" is a known keyword */
#else
# define restrict // Disable restrict
#endif
#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
#ifdef _MSC_VER // Visual Studio
# define inline __forceinline // Visual is not C99, but supports some kind of inline
# if LZ4_ARCH64 // 64-bit
# pragma intrinsic(_BitScanForward64) // For Visual 2005
# pragma intrinsic(_BitScanReverse64) // For Visual 2005
# else
# pragma intrinsic(_BitScanForward) // For Visual 2005
# pragma intrinsic(_BitScanReverse) // For Visual 2005
# endif
#endif
#ifdef _MSC_VER
# define lz4_bswap16(x) _byteswap_ushort(x)
#else
# define lz4_bswap16(x) ((unsigned short int) ((((x) >> 8) & 0xffu) | (((x) & 0xffu) << 8)))
#endif
#if (GCC_VERSION >= 302) || (__INTEL_COMPILER >= 800) || defined(__clang__)
# define expect(expr,value) (__builtin_expect ((expr),(value)) )
#else
# define expect(expr,value) (expr)
#endif
#define likely(expr) expect((expr) != 0, 1)
#define unlikely(expr) expect((expr) != 0, 0)
//**************************************
// Includes
//**************************************
#include <stdlib.h> // for malloc
#include <string.h> // for memset
#include "lz4.h"
//**************************************
// Basic Types
//**************************************
#if defined(_MSC_VER) // Visual Studio does not support 'stdint' natively
# define BYTE unsigned __int8
# define U16 unsigned __int16
# define U32 unsigned __int32
# define S32 __int32
# define U64 unsigned __int64
#else
# include <stdint.h>
# define BYTE uint8_t
# define U16 uint16_t
# define U32 uint32_t
# define S32 int32_t
# define U64 uint64_t
#endif
#ifndef LZ4_FORCE_UNALIGNED_ACCESS
# pragma pack(push, 1)
#endif
typedef struct _U16_S { U16 v; } U16_S;
typedef struct _U32_S { U32 v; } U32_S;
typedef struct _U64_S { U64 v; } U64_S;
#ifndef LZ4_FORCE_UNALIGNED_ACCESS
# pragma pack(pop)
#endif
#define A64(x) (((U64_S *)(x))->v)
#define A32(x) (((U32_S *)(x))->v)
#define A16(x) (((U16_S *)(x))->v)
//**************************************
// Constants
//**************************************
#define MINMATCH 4
#define HASH_LOG COMPRESSIONLEVEL
#define HASHTABLESIZE (1 << HASH_LOG)
#define HASH_MASK (HASHTABLESIZE - 1)
#define SKIPSTRENGTH (NOTCOMPRESSIBLE_CONFIRMATION>2?NOTCOMPRESSIBLE_CONFIRMATION:2)
#define STACKLIMIT 13
#define HEAPMODE (HASH_LOG>STACKLIMIT) // Defines if memory is allocated into the stack (local variable), or into the heap (malloc()).
#define COPYLENGTH 8
#define LASTLITERALS 5
#define MFLIMIT (COPYLENGTH+MINMATCH)
#define MINLENGTH (MFLIMIT+1)
#define MAXD_LOG 16
#define MAX_DISTANCE ((1 << MAXD_LOG) - 1)
#define ML_BITS 4
#define ML_MASK ((1U<<ML_BITS)-1)
#define RUN_BITS (8-ML_BITS)
#define RUN_MASK ((1U<<RUN_BITS)-1)
//**************************************
// Architecture-specific macros
//**************************************
#if LZ4_ARCH64 // 64-bit
# define STEPSIZE 8
# define UARCH U64
# define AARCH A64
# define LZ4_COPYSTEP(s,d) A64(d) = A64(s); d+=8; s+=8;
# define LZ4_COPYPACKET(s,d) LZ4_COPYSTEP(s,d)
# define LZ4_SECURECOPY(s,d,e) if (d<e) LZ4_WILDCOPY(s,d,e)
# define HTYPE U32
# define INITBASE(base) const BYTE* const base = ip
#else // 32-bit
# define STEPSIZE 4
# define UARCH U32
# define AARCH A32
# define LZ4_COPYSTEP(s,d) A32(d) = A32(s); d+=4; s+=4;
# define LZ4_COPYPACKET(s,d) LZ4_COPYSTEP(s,d); LZ4_COPYSTEP(s,d);
# define LZ4_SECURECOPY LZ4_WILDCOPY
# define HTYPE const BYTE*
# define INITBASE(base) const int base = 0
#endif
#if (defined(LZ4_BIG_ENDIAN) && !defined(BIG_ENDIAN_NATIVE_BUT_INCOMPATIBLE))
# define LZ4_READ_LITTLEENDIAN_16(d,s,p) { U16 v = A16(p); v = lz4_bswap16(v); d = (s) - v; }
# define LZ4_WRITE_LITTLEENDIAN_16(p,i) { U16 v = (U16)(i); v = lz4_bswap16(v); A16(p) = v; p+=2; }
#else // Little Endian
# define LZ4_READ_LITTLEENDIAN_16(d,s,p) { d = (s) - A16(p); }
# define LZ4_WRITE_LITTLEENDIAN_16(p,v) { A16(p) = v; p+=2; }
#endif
//**************************************
// Local structures
//**************************************
struct refTables
{
HTYPE hashTable[HASHTABLESIZE];
};
//**************************************
// Macros
//**************************************
#define LZ4_HASH_FUNCTION(i) (((i) * 2654435761U) >> ((MINMATCH*8)-HASH_LOG))
#define LZ4_HASH_VALUE(p) LZ4_HASH_FUNCTION(A32(p))
#define LZ4_WILDCOPY(s,d,e) do { LZ4_COPYPACKET(s,d) } while (d<e);
#define LZ4_BLINDCOPY(s,d,l) { BYTE* e=(d)+l; LZ4_WILDCOPY(s,d,e); d=e; }
//****************************
// Private functions
//****************************
#if LZ4_ARCH64
inline static int LZ4_NbCommonBytes (register U64 val)
{
#if defined(LZ4_BIG_ENDIAN)
#if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
unsigned long r = 0;
_BitScanReverse64( &r, val );
return (int)(r>>3);
#elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
return (__builtin_clzll(val) >> 3);
#else
int r;
if (!(val>>32)) { r=4; } else { r=0; val>>=32; }
if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
r += (!val);
return r;
#endif
#else
#if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
unsigned long r = 0;
_BitScanForward64( &r, val );
return (int)(r>>3);
#elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
return (__builtin_ctzll(val) >> 3);
#else
static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 };
return DeBruijnBytePos[((U64)((val & -val) * 0x0218A392CDABBD3F)) >> 58];
#endif
#endif
}
#else
inline static int LZ4_NbCommonBytes (register U32 val)
{
#if defined(LZ4_BIG_ENDIAN)
#if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
unsigned long r = 0;
_BitScanReverse( &r, val );
return (int)(r>>3);
#elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
return (__builtin_clz(val) >> 3);
#else
int r;
if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }
r += (!val);
return r;
#endif
#else
#if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
unsigned long r = 0;
_BitScanForward( &r, val );
return (int)(r>>3);
#elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
return (__builtin_ctz(val) >> 3);
#else
static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 };
return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];
#endif
#endif
}
#endif
//****************************
// Public functions
//****************************
int LZ4_compressBound(int isize)
{
return (isize + (isize/255) + 16);
}
//******************************
// Compression functions
//******************************
int LZ4_compressCtx(void** ctx,
const char* source,
char* dest,
int isize)
{
#if HEAPMODE
struct refTables *srt = (struct refTables *) (*ctx);
HTYPE* HashTable;
#else
HTYPE HashTable[HASHTABLESIZE] = {0};
#endif
const BYTE* ip = (BYTE*) source;
INITBASE(base);
const BYTE* anchor = ip;
const BYTE* const iend = ip + isize;
const BYTE* const mflimit = iend - MFLIMIT;
#define matchlimit (iend - LASTLITERALS)
BYTE* op = (BYTE*) dest;
int len, length;
const int skipStrength = SKIPSTRENGTH;
U32 forwardH;
// Init
if (isize<MINLENGTH) goto _last_literals;
#if HEAPMODE
if (*ctx == NULL)
{
srt = (struct refTables *) malloc ( sizeof(struct refTables) );
*ctx = (void*) srt;
}
HashTable = (HTYPE*)(srt->hashTable);
memset((void*)HashTable, 0, sizeof(srt->hashTable));
#else
(void) ctx;
#endif
// First Byte
HashTable[LZ4_HASH_VALUE(ip)] = ip - base;
ip++; forwardH = LZ4_HASH_VALUE(ip);
// Main Loop
for ( ; ; )
{
int findMatchAttempts = (1U << skipStrength) + 3;
const BYTE* forwardIp = ip;
const BYTE* ref;
BYTE* token;
// Find a match
do {
U32 h = forwardH;
int step = findMatchAttempts++ >> skipStrength;
ip = forwardIp;
forwardIp = ip + step;
if unlikely(forwardIp > mflimit) { goto _last_literals; }
forwardH = LZ4_HASH_VALUE(forwardIp);
ref = base + HashTable[h];
HashTable[h] = ip - base;
} while ((ref < ip - MAX_DISTANCE) || (A32(ref) != A32(ip)));
// Catch up
while ((ip>anchor) && (ref>(BYTE*)source) && unlikely(ip[-1]==ref[-1])) { ip--; ref--; }
// Encode Literal length
length = ip - anchor;
token = op++;
if (length>=(int)RUN_MASK) { *token=(RUN_MASK<<ML_BITS); len = length-RUN_MASK; for(; len > 254 ; len-=255) *op++ = 255; *op++ = (BYTE)len; }
else *token = (length<<ML_BITS);
// Copy Literals
LZ4_BLINDCOPY(anchor, op, length);
_next_match:
// Encode Offset
LZ4_WRITE_LITTLEENDIAN_16(op,ip-ref);
// Start Counting
ip+=MINMATCH; ref+=MINMATCH; // MinMatch verified
anchor = ip;
while likely(ip<matchlimit-(STEPSIZE-1))
{
UARCH diff = AARCH(ref) ^ AARCH(ip);
if (!diff) { ip+=STEPSIZE; ref+=STEPSIZE; continue; }
ip += LZ4_NbCommonBytes(diff);
goto _endCount;
}
if (LZ4_ARCH64) if ((ip<(matchlimit-3)) && (A32(ref) == A32(ip))) { ip+=4; ref+=4; }
if ((ip<(matchlimit-1)) && (A16(ref) == A16(ip))) { ip+=2; ref+=2; }
if ((ip<matchlimit) && (*ref == *ip)) ip++;
_endCount:
// Encode MatchLength
len = (ip - anchor);
if (len>=(int)ML_MASK) { *token+=ML_MASK; len-=ML_MASK; for(; len > 509 ; len-=510) { *op++ = 255; *op++ = 255; } if (len > 254) { len-=255; *op++ = 255; } *op++ = (BYTE)len; }
else *token += len;
// Test end of chunk
if (ip > mflimit) { anchor = ip; break; }
// Fill table
HashTable[LZ4_HASH_VALUE(ip-2)] = ip - 2 - base;
// Test next position
ref = base + HashTable[LZ4_HASH_VALUE(ip)];
HashTable[LZ4_HASH_VALUE(ip)] = ip - base;
if ((ref > ip - (MAX_DISTANCE + 1)) && (A32(ref) == A32(ip))) { token = op++; *token=0; goto _next_match; }
// Prepare next loop
anchor = ip++;
forwardH = LZ4_HASH_VALUE(ip);
}
_last_literals:
// Encode Last Literals
{
int lastRun = iend - anchor;
if ((LZ4_COMPRESSMIN>0) && (((op - (BYTE*)dest) + lastRun + 1 + ((lastRun-15)/255)) > isize - LZ4_COMPRESSMIN)) return 0;
if (lastRun>=(int)RUN_MASK) { *op++=(RUN_MASK<<ML_BITS); lastRun-=RUN_MASK; for(; lastRun > 254 ; lastRun-=255) *op++ = 255; *op++ = (BYTE) lastRun; }
else *op++ = (lastRun<<ML_BITS);
memcpy(op, anchor, iend - anchor);
op += iend-anchor;
}
// End
return (int) (((char*)op)-dest);
}
// Note : this function is valid only if isize < LZ4_64KLIMIT
#define LZ4_64KLIMIT ((1<<16) + (MFLIMIT-1))
#define HASHLOG64K (HASH_LOG+1)
#define HASH64KTABLESIZE (1U<<HASHLOG64K)
#define LZ4_HASH64K_FUNCTION(i) (((i) * 2654435761U) >> ((MINMATCH*8)-HASHLOG64K))
#define LZ4_HASH64K_VALUE(p) LZ4_HASH64K_FUNCTION(A32(p))
int LZ4_compress64kCtx(void** ctx,
const char* source,
char* dest,
int isize)
{
#if HEAPMODE
struct refTables *srt = (struct refTables *) (*ctx);
U16* HashTable;
#else
U16 HashTable[HASH64KTABLESIZE] = {0};
#endif
const BYTE* ip = (BYTE*) source;
const BYTE* anchor = ip;
const BYTE* const base = ip;
const BYTE* const iend = ip + isize;
const BYTE* const mflimit = iend - MFLIMIT;
#define matchlimit (iend - LASTLITERALS)
BYTE* op = (BYTE*) dest;
int len, length;
const int skipStrength = SKIPSTRENGTH;
U32 forwardH;
// Init
if (isize<MINLENGTH) goto _last_literals;
#if HEAPMODE
if (*ctx == NULL)
{
srt = (struct refTables *) malloc ( sizeof(struct refTables) );
*ctx = (void*) srt;
}
HashTable = (U16*)(srt->hashTable);
memset((void*)HashTable, 0, sizeof(srt->hashTable));
#else
(void) ctx;
#endif
// First Byte
ip++; forwardH = LZ4_HASH64K_VALUE(ip);
// Main Loop
for ( ; ; )
{
int findMatchAttempts = (1U << skipStrength) + 3;
const BYTE* forwardIp = ip;
const BYTE* ref;
BYTE* token;
// Find a match
do {
U32 h = forwardH;
int step = findMatchAttempts++ >> skipStrength;
ip = forwardIp;
forwardIp = ip + step;
if (forwardIp > mflimit) { goto _last_literals; }
forwardH = LZ4_HASH64K_VALUE(forwardIp);
ref = base + HashTable[h];
HashTable[h] = ip - base;
} while (A32(ref) != A32(ip));
// Catch up
while ((ip>anchor) && (ref>(BYTE*)source) && (ip[-1]==ref[-1])) { ip--; ref--; }
// Encode Literal length
length = ip - anchor;
token = op++;
if (length>=(int)RUN_MASK) { *token=(RUN_MASK<<ML_BITS); len = length-RUN_MASK; for(; len > 254 ; len-=255) *op++ = 255; *op++ = (BYTE)len; }
else *token = (length<<ML_BITS);
// Copy Literals
LZ4_BLINDCOPY(anchor, op, length);
_next_match:
// Encode Offset
LZ4_WRITE_LITTLEENDIAN_16(op,ip-ref);
// Start Counting
ip+=MINMATCH; ref+=MINMATCH; // MinMatch verified
anchor = ip;
while (ip<matchlimit-(STEPSIZE-1))
{
UARCH diff = AARCH(ref) ^ AARCH(ip);
if (!diff) { ip+=STEPSIZE; ref+=STEPSIZE; continue; }
ip += LZ4_NbCommonBytes(diff);
goto _endCount;
}
if (LZ4_ARCH64) if ((ip<(matchlimit-3)) && (A32(ref) == A32(ip))) { ip+=4; ref+=4; }
if ((ip<(matchlimit-1)) && (A16(ref) == A16(ip))) { ip+=2; ref+=2; }
if ((ip<matchlimit) && (*ref == *ip)) ip++;
_endCount:
// Encode MatchLength
len = (ip - anchor);
if (len>=(int)ML_MASK) { *token+=ML_MASK; len-=ML_MASK; for(; len > 509 ; len-=510) { *op++ = 255; *op++ = 255; } if (len > 254) { len-=255; *op++ = 255; } *op++ = (BYTE)len; }
else *token += len;
// Test end of chunk
if (ip > mflimit) { anchor = ip; break; }
// Fill table
HashTable[LZ4_HASH64K_VALUE(ip-2)] = ip - 2 - base;
// Test next position
ref = base + HashTable[LZ4_HASH64K_VALUE(ip)];
HashTable[LZ4_HASH64K_VALUE(ip)] = ip - base;
if (A32(ref) == A32(ip)) { token = op++; *token=0; goto _next_match; }
// Prepare next loop
anchor = ip++;
forwardH = LZ4_HASH64K_VALUE(ip);
}
_last_literals:
// Encode Last Literals
{
int lastRun = iend - anchor;
if ((LZ4_COMPRESSMIN>0) && (((op - (BYTE*)dest) + lastRun + 1 + ((lastRun-15)/255)) > isize - LZ4_COMPRESSMIN)) return 0;
if (lastRun>=(int)RUN_MASK) { *op++=(RUN_MASK<<ML_BITS); lastRun-=RUN_MASK; for(; lastRun > 254 ; lastRun-=255) *op++ = 255; *op++ = (BYTE) lastRun; }
else *op++ = (lastRun<<ML_BITS);
memcpy(op, anchor, iend - anchor);
op += iend-anchor;
}
// End
return (int) (((char*)op)-dest);
}
int LZ4_compress(const char* source,
char* dest,
int isize)
{
#if HEAPMODE
void* ctx = malloc(sizeof(struct refTables));
int result;
if (isize < LZ4_64KLIMIT)
result = LZ4_compress64kCtx(&ctx, source, dest, isize);
else result = LZ4_compressCtx(&ctx, source, dest, isize);
free(ctx);
return result;
#else
if (isize < (int)LZ4_64KLIMIT) return LZ4_compress64kCtx(NULL, source, dest, isize);
return LZ4_compressCtx(NULL, source, dest, isize);
#endif
}
//****************************
// Decompression functions
//****************************
// Note : The decoding functions LZ4_uncompress() and LZ4_uncompress_unknownOutputSize()
// are safe against "buffer overflow" attack type.
// They will never write nor read outside of the provided output buffers.
// LZ4_uncompress_unknownOutputSize() also insures that it will never read outside of the input buffer.
// A corrupted input will produce an error result, a negative int, indicating the position of the error within input stream.
int LZ4_uncompress(const char* source,
char* dest,
int osize)
{
// Local Variables
const BYTE* restrict ip = (const BYTE*) source;
const BYTE* restrict ref;
BYTE* restrict op = (BYTE*) dest;
BYTE* const oend = op + osize;
BYTE* cpy;
BYTE token;
int len, length;
size_t dec[] ={0, 3, 2, 3, 0, 0, 0, 0};
// Main Loop
while (1)
{
// get runlength
token = *ip++;
if ((length=(token>>ML_BITS)) == RUN_MASK) { for (;(len=*ip++)==255;length+=255){} length += len; }
// copy literals
cpy = op+length;
if unlikely(cpy>oend-COPYLENGTH)
{
if (cpy > oend) goto _output_error; // Error : request to write beyond destination buffer
memcpy(op, ip, length);
ip += length;
break; // Necessarily EOF
}
LZ4_WILDCOPY(ip, op, cpy); ip -= (op-cpy); op = cpy;
// get offset
LZ4_READ_LITTLEENDIAN_16(ref,cpy,ip); ip+=2;
if (ref < (BYTE* const)dest) goto _output_error; // Error : offset create reference outside destination buffer
// get matchlength
if ((length=(token&ML_MASK)) == ML_MASK) { for (;*ip==255;length+=255) {ip++;} length += *ip++; }
// copy repeated sequence
if unlikely(op-ref<STEPSIZE)
{
#if LZ4_ARCH64
size_t dec2table[]={0, 0, 0, -1, 0, 1, 2, 3};
size_t dec2 = dec2table[op-ref];
#else
const int dec2 = 0;
#endif
*op++ = *ref++;
*op++ = *ref++;
*op++ = *ref++;
*op++ = *ref++;
ref -= dec[op-ref];
A32(op)=A32(ref); op += STEPSIZE-4;
ref -= dec2;
} else { LZ4_COPYSTEP(ref,op); }
cpy = op + length - (STEPSIZE-4);
if (cpy>oend-COPYLENGTH)
{
if (cpy > oend) goto _output_error; // Error : request to write beyond destination buffer
LZ4_SECURECOPY(ref, op, (oend-COPYLENGTH));
while(op<cpy) *op++=*ref++;
op=cpy;
if (op == oend) break; // Check EOF (should never happen, since last 5 bytes are supposed to be literals)
continue;
}
LZ4_SECURECOPY(ref, op, cpy);
op=cpy; // correction
}
// end of decoding
return (int) (((char*)ip)-source);
// write overflow error detected
_output_error:
return (int) (-(((char*)ip)-source));
}
int LZ4_uncompress_unknownOutputSize(
const char* source,
char* dest,
int isize,
int maxOutputSize)
{
// Local Variables
const BYTE* restrict ip = (const BYTE*) source;
const BYTE* const iend = ip + isize;
const BYTE* restrict ref;
BYTE* restrict op = (BYTE*) dest;
BYTE* const oend = op + maxOutputSize;
BYTE* cpy;
size_t dec[] ={0, 3, 2, 3, 0, 0, 0, 0};
// Main Loop
while (ip<iend)
{
BYTE token;
int length;
// get runlength
token = *ip++;
if ((length=(token>>ML_BITS)) == RUN_MASK) { int s=255; while ((ip<iend) && (s==255)) { s=*ip++; length += s; } }
// copy literals
cpy = op+length;
if ((cpy>oend-COPYLENGTH) || (ip+length>iend-COPYLENGTH))
{
if (cpy > oend) goto _output_error; // Error : request to write beyond destination buffer
if (ip+length > iend) goto _output_error; // Error : request to read beyond source buffer
memcpy(op, ip, length);
op += length;
ip += length;
if (ip<iend) goto _output_error; // Error : LZ4 format violation
break; // Necessarily EOF, due to parsing restrictions
}
LZ4_WILDCOPY(ip, op, cpy); ip -= (op-cpy); op = cpy;
// get offset
LZ4_READ_LITTLEENDIAN_16(ref,cpy,ip); ip+=2;
if (ref < (BYTE* const)dest) goto _output_error; // Error : offset creates reference outside of destination buffer
// get matchlength
if ((length=(token&ML_MASK)) == ML_MASK) { while (ip<iend) { int s = *ip++; length +=s; if (s==255) continue; break; } }
// copy repeated sequence
if unlikely(op-ref<STEPSIZE)
{
#if LZ4_ARCH64
size_t dec2table[]={0, 0, 0, -1, 0, 1, 2, 3};
size_t dec2 = dec2table[op-ref];
#else
const int dec2 = 0;
#endif
*op++ = *ref++;
*op++ = *ref++;
*op++ = *ref++;
*op++ = *ref++;
ref -= dec[op-ref];
A32(op)=A32(ref); op += STEPSIZE-4;
ref -= dec2;
} else { LZ4_COPYSTEP(ref,op); }
cpy = op + length - (STEPSIZE-4);
if (cpy>oend-COPYLENGTH)
{
if (cpy > oend) goto _output_error; // Error : request to write outside of destination buffer
LZ4_SECURECOPY(ref, op, (oend-COPYLENGTH));
while(op<cpy) *op++=*ref++;
op=cpy;
if (op == oend) break; // Check EOF (should never happen, since last 5 bytes are supposed to be literals)
continue;
}
LZ4_SECURECOPY(ref, op, cpy);
op=cpy; // correction
}
// end of decoding
return (int) (((char*)op)-dest);
// write overflow error detected
_output_error:
return (int) (-(((char*)ip)-source));
}

120
legacy/eet/src/lib/lz4/lz4.h Normal file
View File

@ -0,0 +1,120 @@
/*
LZ4 - Fast LZ compression algorithm
Header File
Copyright (C) 2011-2012, Yann Collet.
BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* 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 COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, 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 OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
You can contact the author at :
- LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
- LZ4 source repository : http://code.google.com/p/lz4/
*/
#pragma once
#if defined (__cplusplus)
extern "C" {
#endif
//****************************
// Simple Functions
//****************************
int LZ4_compress (const char* source, char* dest, int isize);
int LZ4_uncompress (const char* source, char* dest, int osize);
/*
LZ4_compress() :
isize : is the input size. Max supported value is ~1.9GB
return : the number of bytes written in buffer dest
or 0 if the compression fails (if LZ4_COMPRESSMIN is set)
note : destination buffer must be already allocated.
destination buffer must be sized to handle worst cases situations (input data not compressible)
worst case size evaluation is provided by function LZ4_compressBound()
LZ4_uncompress() :
osize : is the output size, therefore the original size
return : the number of bytes read in the source buffer
If the source stream is malformed, the function will stop decoding and return a negative result, indicating the byte position of the faulty instruction
This function never writes beyond dest + osize, and is therefore protected against malicious data packets
note : destination buffer must be already allocated
*/
//****************************
// Advanced Functions
//****************************
int LZ4_compressBound(int isize);
/*
LZ4_compressBound() :
Provides the maximum size that LZ4 may output in a "worst case" scenario (input data not compressible)
primarily useful for memory allocation of output buffer.
isize : is the input size. Max supported value is ~1.9GB
return : maximum output size in a "worst case" scenario
note : this function is limited by "int" range (2^31-1)
*/
int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize);
/*
LZ4_uncompress_unknownOutputSize() :
isize : is the input size, therefore the compressed size
maxOutputSize : is the size of the destination buffer (which must be already allocated)
return : the number of bytes decoded in the destination buffer (necessarily <= maxOutputSize)
If the source stream is malformed, the function will stop decoding and return a negative result, indicating the byte position of the faulty instruction
This function never writes beyond dest + maxOutputSize, and is therefore protected against malicious data packets
note : Destination buffer must be already allocated.
This version is slightly slower than LZ4_uncompress()
*/
int LZ4_compressCtx(void** ctx, const char* source, char* dest, int isize);
int LZ4_compress64kCtx(void** ctx, const char* source, char* dest, int isize);
/*
LZ4_compressCtx() :
This function explicitly handles the CTX memory structure.
It avoids allocating/deallocating memory between each call, improving performance when malloc is heavily invoked.
This function is only useful when memory is allocated into the heap (HASH_LOG value beyond STACK_LIMIT)
Performance difference will be noticeable only when repetitively calling the compression function over many small segments.
Note : by default, memory is allocated into the stack, therefore "malloc" is not invoked.
LZ4_compress64kCtx() :
Same as LZ4_compressCtx(), but specific to small inputs (<64KB).
isize *Must* be <64KB, otherwise the output will be corrupted.
On first call : provide a *ctx=NULL; It will be automatically allocated.
On next calls : reuse the same ctx pointer.
Use different pointers for different threads when doing multi-threading.
*/
#if defined (__cplusplus)
}
#endif

663
legacy/eet/src/lib/lz4/lz4hc.c Normal file
View File

@ -0,0 +1,663 @@
/*
LZ4 HC - High Compression Mode of LZ4
Copyright (C) 2011-2012, Yann Collet.
BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* 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 COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, 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 OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
You can contact the author at :
- LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
- LZ4 source repository : http://code.google.com/p/lz4/
*/
//**************************************
// CPU Feature Detection
//**************************************
// 32 or 64 bits ?
#if (defined(__x86_64__) || defined(__x86_64) || defined(__amd64__) || defined(__amd64) || defined(__ppc64__) || defined(_WIN64) || defined(__LP64__) || defined(_LP64) ) // Detects 64 bits mode
#define LZ4_ARCH64 1
#else
#define LZ4_ARCH64 0
#endif
// Little Endian or Big Endian ?
#if (defined(__BIG_ENDIAN__) || defined(__BIG_ENDIAN) || defined(_BIG_ENDIAN) || defined(_ARCH_PPC) || defined(__PPC__) || defined(__PPC) || defined(PPC) || defined(__powerpc__) || defined(__powerpc) || defined(powerpc) || ((defined(__BYTE_ORDER__)&&(__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))) )
#define LZ4_BIG_ENDIAN 1
#else
// Little Endian assumed. PDP Endian and other very rare endian format are unsupported.
#endif
// Unaligned memory access is automatically enabled for "common" CPU, such as x86.
// For others CPU, the compiler will be more cautious, and insert extra code to ensure aligned access is respected
// If you know your target CPU supports unaligned memory access, you may want to force this option manually to improve performance
#if defined(__ARM_FEATURE_UNALIGNED)
#define LZ4_FORCE_UNALIGNED_ACCESS 1
#endif
//**************************************
// Compiler Options
//**************************************
#if __STDC_VERSION__ >= 199901L // C99
/* "restrict" is a known keyword */
#else
#define restrict // Disable restrict
#endif
#ifdef _MSC_VER
#define inline __forceinline // Visual is not C99, but supports some kind of inline
#endif
#ifdef _MSC_VER // Visual Studio
#define bswap16(x) _byteswap_ushort(x)
#else
#define bswap16(x) ((unsigned short int) ((((x) >> 8) & 0xffu) | (((x) & 0xffu) << 8)))
#endif
//**************************************
// Includes
//**************************************
#include <stdlib.h> // calloc, free
#include <string.h> // memset, memcpy
#include "lz4hc.h"
#define ALLOCATOR(s) calloc(1,s)
#define FREEMEM free
#define MEM_INIT memset
//**************************************
// Basic Types
//**************************************
#if defined(_MSC_VER) // Visual Studio does not support 'stdint' natively
#define BYTE unsigned __int8
#define U16 unsigned __int16
#define U32 unsigned __int32
#define S32 __int32
#define U64 unsigned __int64
#else
#include <stdint.h>
#define BYTE uint8_t
#define U16 uint16_t
#define U32 uint32_t
#define S32 int32_t
#define U64 uint64_t
#endif
#ifndef LZ4_FORCE_UNALIGNED_ACCESS
#pragma pack(push, 1)
#endif
typedef struct _U16_S { U16 v; } U16_S;
typedef struct _U32_S { U32 v; } U32_S;
typedef struct _U64_S { U64 v; } U64_S;
#ifndef LZ4_FORCE_UNALIGNED_ACCESS
#pragma pack(pop)
#endif
#define A64(x) (((U64_S *)(x))->v)
#define A32(x) (((U32_S *)(x))->v)
#define A16(x) (((U16_S *)(x))->v)
//**************************************
// Constants
//**************************************
#define MINMATCH 4
#define DICTIONARY_LOGSIZE 16
#define MAXD (1<<DICTIONARY_LOGSIZE)
#define MAXD_MASK ((U32)(MAXD - 1))
#define MAX_DISTANCE (MAXD - 1)
#define HASH_LOG (DICTIONARY_LOGSIZE-1)
#define HASHTABLESIZE (1 << HASH_LOG)
#define HASH_MASK (HASHTABLESIZE - 1)
#define MAX_NB_ATTEMPTS 256
#define ML_BITS 4
#define ML_MASK (size_t)((1U<<ML_BITS)-1)
#define RUN_BITS (8-ML_BITS)
#define RUN_MASK ((1U<<RUN_BITS)-1)
#define COPYLENGTH 8
#define LASTLITERALS 5
#define MFLIMIT (COPYLENGTH+MINMATCH)
#define MINLENGTH (MFLIMIT+1)
#define OPTIMAL_ML (int)((ML_MASK-1)+MINMATCH)
//**************************************
// Architecture-specific macros
//**************************************
#if LZ4_ARCH64 // 64-bit
#define STEPSIZE 8
#define LZ4_COPYSTEP(s,d) A64(d) = A64(s); d+=8; s+=8;
#define LZ4_COPYPACKET(s,d) LZ4_COPYSTEP(s,d)
#define UARCH U64
#define AARCH A64
#define HTYPE U32
#define INITBASE(b,s) const BYTE* const b = s
#else // 32-bit
#define STEPSIZE 4
#define LZ4_COPYSTEP(s,d) A32(d) = A32(s); d+=4; s+=4;
#define LZ4_COPYPACKET(s,d) LZ4_COPYSTEP(s,d); LZ4_COPYSTEP(s,d);
#define UARCH U32
#define AARCH A32
#define HTYPE const BYTE*
#define INITBASE(b,s) const int b = 0
#endif
#if defined(LZ4_BIG_ENDIAN)
#define LZ4_READ_LITTLEENDIAN_16(d,s,p) { U16 v = A16(p); v = bswap16(v); d = (s) - v; }
#define LZ4_WRITE_LITTLEENDIAN_16(p,i) { U16 v = (U16)(i); v = bswap16(v); A16(p) = v; p+=2; }
#else // Little Endian
#define LZ4_READ_LITTLEENDIAN_16(d,s,p) { d = (s) - A16(p); }
#define LZ4_WRITE_LITTLEENDIAN_16(p,v) { A16(p) = v; p+=2; }
#endif
//************************************************************
// Local Types
//************************************************************
typedef struct
{
const BYTE* base;
HTYPE hashTable[HASHTABLESIZE];
U16 chainTable[MAXD];
const BYTE* nextToUpdate;
} LZ4HC_Data_Structure;
//**************************************
// Macros
//**************************************
#define LZ4_WILDCOPY(s,d,e) do { LZ4_COPYPACKET(s,d) } while (d<e);
#define LZ4_BLINDCOPY(s,d,l) { BYTE* e=d+l; LZ4_WILDCOPY(s,d,e); d=e; }
#define HASH_FUNCTION(i) (((i) * 2654435761U) >> ((MINMATCH*8)-HASH_LOG))
#define HASH_VALUE(p) HASH_FUNCTION(*(U32*)(p))
#define HASH_POINTER(p) (HashTable[HASH_VALUE(p)] + base)
#define DELTANEXT(p) chainTable[(size_t)(p) & MAXD_MASK]
#define GETNEXT(p) ((p) - (size_t)DELTANEXT(p))
#define ADD_HASH(p) { size_t delta = (p) - HASH_POINTER(p); if (delta>MAX_DISTANCE) delta = MAX_DISTANCE; DELTANEXT(p) = (U16)delta; HashTable[HASH_VALUE(p)] = (p) - base; }
//**************************************
// Private functions
//**************************************
#if LZ4_ARCH64
inline static int LZ4_NbCommonBytes (register U64 val)
{
#if defined(LZ4_BIG_ENDIAN)
#if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
unsigned long r = 0;
_BitScanReverse64( &r, val );
return (int)(r>>3);
#elif defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
return (__builtin_clzll(val) >> 3);
#else
int r;
if (!(val>>32)) { r=4; } else { r=0; val>>=32; }
if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
r += (!val);
return r;
#endif
#else
#if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
unsigned long r = 0;
_BitScanForward64( &r, val );
return (int)(r>>3);
#elif defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
return (__builtin_ctzll(val) >> 3);
#else
static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 };
return DeBruijnBytePos[((U64)((val & -val) * 0x0218A392CDABBD3F)) >> 58];
#endif
#endif
}
#else
inline static int LZ4_NbCommonBytes (register U32 val)
{
#if defined(LZ4_BIG_ENDIAN)
#if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
unsigned long r = 0;
_BitScanReverse( &r, val );
return (int)(r>>3);
#elif defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
return (__builtin_clz(val) >> 3);
#else
int r;
if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }
r += (!val);
return r;
#endif
#else
#if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
unsigned long r = 0;
_BitScanForward( &r, val );
return (int)(r>>3);
#elif defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
return (__builtin_ctz(val) >> 3);
#else
static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 };
return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];
#endif
#endif
}
#endif
inline static int LZ4HC_Init (LZ4HC_Data_Structure* hc4, const BYTE* base)
{
MEM_INIT((void*)hc4->hashTable, 0, sizeof(hc4->hashTable));
MEM_INIT(hc4->chainTable, 0xFF, sizeof(hc4->chainTable));
hc4->nextToUpdate = base + LZ4_ARCH64;
hc4->base = base;
return 1;
}
inline static void* LZ4HC_Create (const BYTE* base)
{
void* hc4 = ALLOCATOR(sizeof(LZ4HC_Data_Structure));
LZ4HC_Init (hc4, base);
return hc4;
}
inline static int LZ4HC_Free (void** LZ4HC_Data)
{
FREEMEM(*LZ4HC_Data);
*LZ4HC_Data = NULL;
return (1);
}
inline static void LZ4HC_Insert (LZ4HC_Data_Structure* hc4, const BYTE* ip)
{
U16* chainTable = hc4->chainTable;
HTYPE* HashTable = hc4->hashTable;
INITBASE(base,hc4->base);
while(hc4->nextToUpdate < ip)
{
ADD_HASH(hc4->nextToUpdate);
hc4->nextToUpdate++;
}
}
inline static int LZ4HC_InsertAndFindBestMatch (LZ4HC_Data_Structure* hc4, const BYTE* ip, const BYTE* const matchlimit, const BYTE** matchpos)
{
U16* const chainTable = hc4->chainTable;
HTYPE* const HashTable = hc4->hashTable;
const BYTE* ref;
INITBASE(base,hc4->base);
int nbAttempts=MAX_NB_ATTEMPTS;
int ml=0;
// HC4 match finder
LZ4HC_Insert(hc4, ip);
ref = HASH_POINTER(ip);
while ((ref > (ip-MAX_DISTANCE)) && (nbAttempts))
{
nbAttempts--;
if (*(ref+ml) == *(ip+ml))
if (*(U32*)ref == *(U32*)ip)
{
const BYTE* reft = ref+MINMATCH;
const BYTE* ipt = ip+MINMATCH;
while (ipt<matchlimit-(STEPSIZE-1))
{
UARCH diff = AARCH(reft) ^ AARCH(ipt);
if (!diff) { ipt+=STEPSIZE; reft+=STEPSIZE; continue; }
ipt += LZ4_NbCommonBytes(diff);
goto _endCount;
}
if (LZ4_ARCH64) if ((ipt<(matchlimit-3)) && (A32(reft) == A32(ipt))) { ipt+=4; reft+=4; }
if ((ipt<(matchlimit-1)) && (A16(reft) == A16(ipt))) { ipt+=2; reft+=2; }
if ((ipt<matchlimit) && (*reft == *ipt)) ipt++;
_endCount:
if (ipt-ip > ml) { ml = ipt-ip; *matchpos = ref; }
}
ref = GETNEXT(ref);
}
return ml;
}
inline static int LZ4HC_InsertAndGetWiderMatch (LZ4HC_Data_Structure* hc4, const BYTE* ip, const BYTE* startLimit, const BYTE* matchlimit, int longest, const BYTE** matchpos, const BYTE** startpos)
{
U16* const chainTable = hc4->chainTable;
HTYPE* const HashTable = hc4->hashTable;
INITBASE(base,hc4->base);
const BYTE* ref;
int nbAttempts = MAX_NB_ATTEMPTS;
int delta = ip-startLimit;
// First Match
LZ4HC_Insert(hc4, ip);
ref = HASH_POINTER(ip);
while ((ref > ip-MAX_DISTANCE) && (ref >= hc4->base) && (nbAttempts))
{
nbAttempts--;
if (*(startLimit + longest) == *(ref - delta + longest))
if (*(U32*)ref == *(U32*)ip)
{
const BYTE* reft = ref+MINMATCH;
const BYTE* ipt = ip+MINMATCH;
const BYTE* startt = ip;
while (ipt<matchlimit-(STEPSIZE-1))
{
UARCH diff = AARCH(reft) ^ AARCH(ipt);
if (!diff) { ipt+=STEPSIZE; reft+=STEPSIZE; continue; }
ipt += LZ4_NbCommonBytes(diff);
goto _endCount;
}
if (LZ4_ARCH64) if ((ipt<(matchlimit-3)) && (A32(reft) == A32(ipt))) { ipt+=4; reft+=4; }
if ((ipt<(matchlimit-1)) && (A16(reft) == A16(ipt))) { ipt+=2; reft+=2; }
if ((ipt<matchlimit) && (*reft == *ipt)) ipt++;
_endCount:
reft = ref;
while ((startt>startLimit) && (reft > hc4->base) && (startt[-1] == reft[-1])) {startt--; reft--;}
if ((ipt-startt) > longest)
{
longest = ipt-startt;
*matchpos = reft;
*startpos = startt;
}
}
ref = GETNEXT(ref);
}
return longest;
}
inline static int LZ4_encodeSequence(const BYTE** ip, BYTE** op, const BYTE** anchor, int ml, const BYTE* ref)
{
int length, len;
BYTE* token;
// Encode Literal length
length = *ip - *anchor;
token = (*op)++;
if (length>=(int)RUN_MASK) { *token=(RUN_MASK<<ML_BITS); len = length-RUN_MASK; for(; len > 254 ; len-=255) *(*op)++ = 255; *(*op)++ = (BYTE)len; }
else *token = (length<<ML_BITS);
// Copy Literals
LZ4_BLINDCOPY(*anchor, *op, length);
// Encode Offset
LZ4_WRITE_LITTLEENDIAN_16(*op,*ip-ref);
// Encode MatchLength
len = (int)(ml-MINMATCH);
if (len>=(int)ML_MASK) { *token+=ML_MASK; len-=ML_MASK; for(; len > 509 ; len-=510) { *(*op)++ = 255; *(*op)++ = 255; } if (len > 254) { len-=255; *(*op)++ = 255; } *(*op)++ = (BYTE)len; }
else *token += len;
// Prepare next loop
*ip += ml;
*anchor = *ip;
return 0;
}
//****************************
// Compression CODE
//****************************
int LZ4_compressHCCtx(LZ4HC_Data_Structure* ctx,
const char* source,
char* dest,
int isize)
{
const BYTE* ip = (const BYTE*) source;
const BYTE* anchor = ip;
const BYTE* const iend = ip + isize;
const BYTE* const mflimit = iend - MFLIMIT;
const BYTE* const matchlimit = (iend - LASTLITERALS);
BYTE* op = (BYTE*) dest;
int ml, ml2, ml3, ml0;
const BYTE* ref=NULL;
const BYTE* start2=NULL;
const BYTE* ref2=NULL;
const BYTE* start3=NULL;
const BYTE* ref3=NULL;
const BYTE* start0;
const BYTE* ref0;
ip++;
// Main Loop
while (ip < mflimit)
{
ml = LZ4HC_InsertAndFindBestMatch (ctx, ip, matchlimit, (&ref));
if (!ml) { ip++; continue; }
// saved, in case we would skip too much
start0 = ip;
ref0 = ref;
ml0 = ml;
_Search2:
if (ip+ml < mflimit)
ml2 = LZ4HC_InsertAndGetWiderMatch(ctx, ip + ml - 2, ip + 1, matchlimit, ml, &ref2, &start2);
else ml2=ml;
if (ml2 == ml) // No better match
{
LZ4_encodeSequence(&ip, &op, &anchor, ml, ref);
continue;
}
if (start0 < ip)
{
if (start2 < ip + ml0) // empirical
{
ip = start0;
ref = ref0;
ml = ml0;
}
}
// Here, start0==ip
if ((start2 - ip) < 3) // First Match too small : removed
{
ml = ml2;
ip = start2;
ref =ref2;
goto _Search2;
}
_Search3:
// Currently we have :
// ml2 > ml1, and
// ip1+3 <= ip2 (usually < ip1+ml1)
if ((start2 - ip) < OPTIMAL_ML)
{
int correction;
int new_ml = ml;
if (new_ml > OPTIMAL_ML) new_ml = OPTIMAL_ML;
if (ip+new_ml > start2 + ml2 - MINMATCH) new_ml = start2 - ip + ml2 - MINMATCH;
correction = new_ml - (start2 - ip);
if (correction > 0)
{
start2 += correction;
ref2 += correction;
ml2 -= correction;
}
}
// Now, we have start2 = ip+new_ml, with new_ml=min(ml, OPTIMAL_ML=18)
if (start2 + ml2 < mflimit)
ml3 = LZ4HC_InsertAndGetWiderMatch(ctx, start2 + ml2 - 3, start2, matchlimit, ml2, &ref3, &start3);
else ml3=ml2;
if (ml3 == ml2) // No better match : 2 sequences to encode
{
// ip & ref are known; Now for ml
if (start2 < ip+ml)
{
if ((start2 - ip) < OPTIMAL_ML)
{
int correction;
if (ml > OPTIMAL_ML) ml = OPTIMAL_ML;
if (ip+ml > start2 + ml2 - MINMATCH) ml = start2 - ip + ml2 - MINMATCH;
correction = ml - (start2 - ip);
if (correction > 0)
{
start2 += correction;
ref2 += correction;
ml2 -= correction;
}
}
else
{
ml = start2 - ip;
}
}
// Now, encode 2 sequences
LZ4_encodeSequence(&ip, &op, &anchor, ml, ref);
ip = start2;
LZ4_encodeSequence(&ip, &op, &anchor, ml2, ref2);
continue;
}
if (start3 < ip+ml+3) // Not enough space for match 2 : remove it
{
if (start3 >= (ip+ml)) // can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1
{
if (start2 < ip+ml)
{
int correction = (ip+ml) - start2;
start2 += correction;
ref2 += correction;
ml2 -= correction;
if (ml2 < MINMATCH)
{
start2 = start3;
ref2 = ref3;
ml2 = ml3;
}
}
LZ4_encodeSequence(&ip, &op, &anchor, ml, ref);
ip = start3;
ref = ref3;
ml = ml3;
start0 = start2;
ref0 = ref2;
ml0 = ml2;
goto _Search2;
}
start2 = start3;
ref2 = ref3;
ml2 = ml3;
goto _Search3;
}
// OK, now we have 3 ascending matches; let's write at least the first one
// ip & ref are known; Now for ml
if (start2 < ip+ml)
{
if ((start2 - ip) < (int)ML_MASK)
{
int correction;
if (ml > OPTIMAL_ML) ml = OPTIMAL_ML;
if (ip + ml > start2 + ml2 - MINMATCH) ml = start2 - ip + ml2 - MINMATCH;
correction = ml - (start2 - ip);
if (correction > 0)
{
start2 += correction;
ref2 += correction;
ml2 -= correction;
}
}
else
{
ml = start2 - ip;
}
}
LZ4_encodeSequence(&ip, &op, &anchor, ml, ref);
ip = start2;
ref = ref2;
ml = ml2;
start2 = start3;
ref2 = ref3;
ml2 = ml3;
goto _Search3;
}
// Encode Last Literals
{
int lastRun = iend - anchor;
if (lastRun>=(int)RUN_MASK) { *op++=(RUN_MASK<<ML_BITS); lastRun-=RUN_MASK; for(; lastRun > 254 ; lastRun-=255) *op++ = 255; *op++ = (BYTE) lastRun; }
else *op++ = (lastRun<<ML_BITS);
memcpy(op, anchor, iend - anchor);
op += iend-anchor;
}
// End
return (int) (((char*)op)-dest);
}
int LZ4_compressHC(const char* source,
char* dest,
int isize)
{
void* ctx = LZ4HC_Create((const BYTE*)source);
int result = LZ4_compressHCCtx(ctx, source, dest, isize);
LZ4HC_Free (&ctx);
return result;
}

60
legacy/eet/src/lib/lz4/lz4hc.h Normal file
View File

@ -0,0 +1,60 @@
/*
LZ4 HC - High Compression Mode of LZ4
Header File
Copyright (C) 2011-2012, Yann Collet.
BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* 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 COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, 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 OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
You can contact the author at :
- LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
- LZ4 source repository : http://code.google.com/p/lz4/
*/
#pragma once
#if defined (__cplusplus)
extern "C" {
#endif
int LZ4_compressHC (const char* source, char* dest, int isize);
/*
LZ4_compressHC :
return : the number of bytes in compressed buffer dest
note : destination buffer must be already allocated.
To avoid any problem, size it to handle worst cases situations (input data not compressible)
Worst case size evaluation is provided by function LZ4_compressBound() (see "lz4.h")
*/
/* Note :
Decompression functions are provided within regular LZ4 source code (see "lz4.h") (BSD license)
*/
#if defined (__cplusplus)
}
#endif