From a748f275bc9c3972677f8f531ca225c5d0428e2f Mon Sep 17 00:00:00 2001 From: raster Date: Tue, 15 May 2012 12:27:56 +0000 Subject: [PATCH] add lz4 compression options to eet. remove amalgamated build too. git-svn-id: svn+ssh://svn.enlightenment.org/var/svn/e/trunk/eet@71111 7cbeb6ba-43b4-40fd-8cce-4c39aea84d33 --- ChangeLog | 4 + configure.ac | 18 -- src/lib/Eet.h | 33 ++ src/lib/Eet_private.h | 2 + src/lib/Makefile.am | 130 +------- src/lib/eet_image.c | 160 ++++++---- src/lib/eet_lib.c | 276 ++++++++++++----- src/lib/lz4/lz4.c | 819 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/lib/lz4/lz4.h | 120 ++++++++ src/lib/lz4/lz4hc.c | 663 ++++++++++++++++++++++++++++++++++++++++ src/lib/lz4/lz4hc.h | 60 ++++ 11 files changed, 2017 insertions(+), 268 deletions(-) create mode 100644 src/lib/lz4/lz4.c create mode 100644 src/lib/lz4/lz4.h create mode 100644 src/lib/lz4/lz4hc.c create mode 100644 src/lib/lz4/lz4hc.h diff --git a/ChangeLog b/ChangeLog index 43e85b2..9df47e5 100644 --- a/ChangeLog +++ b/ChangeLog @@ -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. diff --git a/configure.ac b/configure.ac index 882fda8..8e9a0c3 100644 --- a/configure.ac +++ b/configure.ac @@ -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}" diff --git a/src/lib/Eet.h b/src/lib/Eet.h index 6207294..c525a9b 100644 --- a/src/lib/Eet.h +++ b/src/lib/Eet.h @@ -259,6 +259,39 @@ typedef enum _Eet_Error /** * @} */ + +/** + * @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 */ + +/** + * @} + */ /** * Initialize the EET library. diff --git a/src/lib/Eet_private.h b/src/lib/Eet_private.h index afd4685..20c12d7 100644 --- a/src/lib/Eet_private.h +++ b/src/lib/Eet_private.h @@ -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; diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am index ae60168..952cc9d 100644 --- a/src/lib/Makefile.am +++ b/src/lib/Makefile.am @@ -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 " >> 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 " >> eet_amalgamation.c - @echo "# define alloca _alloca" >> eet_amalgamation.c - @echo "#else" >> eet_amalgamation.c - @echo "# include " >> 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 " >> eet_amalgamation.c - @echo "#include " >> eet_amalgamation.c - @echo "#include " >> eet_amalgamation.c - @echo "#include " >> eet_amalgamation.c - @echo "#include " >> eet_amalgamation.c - @echo "#include " >> eet_amalgamation.c - @echo "#include " >> eet_amalgamation.c - @echo "#ifdef HAVE_SIGNATURE" >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "#endif" >> eet_amalgamation.c - @echo "#include " >> eet_amalgamation.c - @echo "#include " >> eet_amalgamation.c - @echo "#include " >> eet_amalgamation.c - @echo "#include " >> eet_amalgamation.c - @echo "#include " >> eet_amalgamation.c - - @echo "#ifdef _WIN32" >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "#endif" >> eet_amalgamation.c - - @echo "#ifndef _MSC_VER" >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "#endif" >> eet_amalgamation.c - - @echo "#ifdef HAVE_NETINET_IN_H" >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "#endif" >> eet_amalgamation.c - - @echo "#ifdef HAVE_GNUTLS" >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "#endif" >> eet_amalgamation.c - - @echo "#ifdef HAVE_OPENSSL" >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "#endif" >> eet_amalgamation.c - - @echo "#ifdef HAVE_SIGNATURE" >> eet_amalgamation.c - @echo "# ifdef HAVE_GNUTLS" >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "# else" >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "# include " >> 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 " >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "# else" >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "# endif" >> eet_amalgamation.c - @echo "#endif" >> eet_amalgamation.c - - @echo "#include " >> eet_amalgamation.c - @echo "#include " >> eet_amalgamation.c - - @echo "#ifdef HAVE_EVIL" >> eet_amalgamation.c - @echo "# include " >> eet_amalgamation.c - @echo "#endif" >> eet_amalgamation.c - - @echo "#include " >> 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 diff --git a/src/lib/eet_image.c b/src/lib/eet_image.c index b622236..00acda8 100644 --- a/src/lib/eet_image.c +++ b/src/lib/eet_image.c @@ -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) + { + 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(d); + free(comp); + *size = -1; return NULL; } - header = (int *)d; - memset(d, 0, 32); + d = malloc((8 * sizeof(int)) + buflen); + if (!d) + { + free(comp); + return NULL; + } + header = (int *)d; + 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) { diff --git a/src/lib/eet_lib.c b/src/lib/eet_lib.c index a3295f4..a350d11 100644 --- a/src/lib/eet_lib.c +++ b/src/lib/eet_lib.c @@ -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; diff --git a/src/lib/lz4/lz4.c b/src/lib/lz4/lz4.c new file mode 100644 index 0000000..06e2829 --- /dev/null +++ b/src/lib/lz4/lz4.c @@ -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 // for malloc +#include // 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 +# 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<> ((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>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 (isizehashTable); + 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< 254 ; len-=255) *op++ = 255; *op++ = (BYTE)len; } + else *token = (length<=(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< 254 ; lastRun-=255) *op++ = 255; *op++ = (BYTE) lastRun; } + else *op++ = (lastRun<> ((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 (isizehashTable); + 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< 254 ; len-=255) *op++ = 255; *op++ = (BYTE)len; } + else *token = (length<=(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< 254 ; lastRun-=255) *op++ = 255; *op++ = (BYTE) lastRun; } + else *op++ = (lastRun<>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-refoend-COPYLENGTH) + { + if (cpy > oend) goto _output_error; // Error : request to write beyond destination buffer + LZ4_SECURECOPY(ref, op, (oend-COPYLENGTH)); + while(op>ML_BITS)) == RUN_MASK) { int s=255; while ((ipoend-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 (ipoend-COPYLENGTH) + { + if (cpy > oend) goto _output_error; // Error : request to write outside of destination buffer + LZ4_SECURECOPY(ref, op, (oend-COPYLENGTH)); + while(op= 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 // calloc, free +#include // 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 +#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<> ((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 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 (iptstartLimit) && (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< 254 ; len-=255) *(*op)++ = 255; *(*op)++ = (BYTE)len; } + else *token = (length<=(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< 254 ; lastRun-=255) *op++ = 255; *op++ = (BYTE) lastRun; } + else *op++ = (lastRun<