Hello community, here is the log from the commit of package eet for openSUSE:Factory checked in at 2012-12-10 13:46:43 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/eet (Old) and /work/SRC/openSUSE:Factory/.eet.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "eet", Maintainer is "" Changes: -------- --- /work/SRC/openSUSE:Factory/eet/eet.changes 2012-12-03 09:33:33.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.eet.new/eet.changes 2012-12-10 13:46:44.000000000 +0100 @@ -1,0 +2,6 @@ +Sat Dec 8 01:50:31 UTC 2012 - [email protected] + +- Bump to 1.7.3 +- 1.7.3 is a bugfix release to coincide with the beta release of efl + +------------------------------------------------------------------- Old: ---- eet-1.7.2.tar.bz2 New: ---- eet-1.7.3.tar.bz2 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ eet.spec ++++++ --- /var/tmp/diff_new_pack.O08tMg/_old 2012-12-10 13:46:45.000000000 +0100 +++ /var/tmp/diff_new_pack.O08tMg/_new 2012-12-10 13:46:45.000000000 +0100 @@ -17,7 +17,7 @@ Name: eet -Version: 1.7.2 +Version: 1.7.3 Release: 0 Summary: Data encode/decode and storage library License: BSD-2-Clause ++++++ eet-1.7.2.tar.bz2 -> eet-1.7.3.tar.bz2 ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/eet-1.7.2/ChangeLog new/eet-1.7.3/ChangeLog --- old/eet-1.7.2/ChangeLog 2012-11-23 00:08:44.000000000 +0100 +++ new/eet-1.7.3/ChangeLog 2012-12-07 16:00:35.000000000 +0100 @@ -644,3 +644,7 @@ 1.7.2 release +2012-12-07 Luis Felipe Strano Moraes + + * 1.7.3 release + diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/eet-1.7.2/NEWS new/eet-1.7.3/NEWS --- old/eet-1.7.2/NEWS 2012-11-22 23:47:24.000000000 +0100 +++ new/eet-1.7.3/NEWS 2012-12-07 16:02:29.000000000 +0100 @@ -1,4 +1,10 @@ -Eet 1.7.2 +Eet 1.7.3 + +Changes since Eet 1.7.2: +-------------------------- + +Fixes: + * Updated lz4 code. Changes since Eet 1.7.1: -------------------------- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/eet-1.7.2/configure new/eet-1.7.3/configure --- old/eet-1.7.2/configure 2012-11-23 00:20:48.000000000 +0100 +++ new/eet-1.7.3/configure 2012-12-07 16:55:51.000000000 +0100 @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.68 for eet 1.7.2. +# Generated by GNU Autoconf 2.68 for eet 1.7.3. # # Report bugs to <[email protected]>. # @@ -570,8 +570,8 @@ # Identity of this package. PACKAGE_NAME='eet' PACKAGE_TARNAME='eet' -PACKAGE_VERSION='1.7.2' -PACKAGE_STRING='eet 1.7.2' +PACKAGE_VERSION='1.7.3' +PACKAGE_STRING='eet 1.7.3' PACKAGE_BUGREPORT='[email protected]' PACKAGE_URL='' @@ -1352,7 +1352,7 @@ # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -\`configure' configures eet 1.7.2 to adapt to many kinds of systems. +\`configure' configures eet 1.7.3 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1422,7 +1422,7 @@ if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of eet 1.7.2:";; + short | recursive ) echo "Configuration of eet 1.7.3:";; esac cat <<\_ACEOF @@ -1559,7 +1559,7 @@ test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -eet configure 1.7.2 +eet configure 1.7.3 generated by GNU Autoconf 2.68 Copyright (C) 2010 Free Software Foundation, Inc. @@ -1982,7 +1982,7 @@ This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by eet $as_me 1.7.2, which was +It was created by eet $as_me 1.7.3, which was generated by GNU Autoconf 2.68. Invocation command line was $ $0 $@ @@ -2806,7 +2806,7 @@ # Define the identity of the package. PACKAGE='eet' - VERSION='1.7.2' + VERSION='1.7.3' cat >>confdefs.h <<_ACEOF @@ -11840,7 +11840,7 @@ cat >>confdefs.h <<_ACEOF -#define VMIC 2 +#define VMIC 3 _ACEOF @@ -11848,7 +11848,7 @@ #define VREV 0 _ACEOF -version_info="8:2:7" +version_info="8:3:7" release_info="" @@ -15753,7 +15753,7 @@ # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" -This file was extended by eet $as_me 1.7.2, which was +This file was extended by eet $as_me 1.7.3, which was generated by GNU Autoconf 2.68. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -15819,7 +15819,7 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ -eet config.status 1.7.2 +eet config.status 1.7.3 configured by $0, generated by GNU Autoconf 2.68, with options \\"\$ac_cs_config\\" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/eet-1.7.2/configure.ac new/eet-1.7.3/configure.ac --- old/eet-1.7.2/configure.ac 2012-11-23 00:20:46.000000000 +0100 +++ new/eet-1.7.3/configure.ac 2012-12-07 16:55:48.000000000 +0100 @@ -2,7 +2,7 @@ ##--##--##--##--##--##--##--##--##--##--##--##--##--##--##--##--## m4_define([v_maj], [1]) m4_define([v_min], [7]) -m4_define([v_mic], [2]) +m4_define([v_mic], [3]) m4_define([v_rev], m4_esyscmd([(svnversion "${SVN_REPO_PATH:-.}" | grep -v '\(export\|Unversioned directory\)' || echo 0) | awk -F : '{printf("%s\n", $1);}' | tr -d ' :MSP\n'])) m4_if(v_rev, [0], [m4_define([v_rev], m4_esyscmd([git log 2> /dev/null | (grep -m1 git-svn-id || echo 0) | sed -e 's/.*@\([0-9]*\).*/\1/' | tr -d '\n']))]) ##-- When released, remove the dnl on the below line diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/eet-1.7.2/doc/Doxyfile new/eet-1.7.3/doc/Doxyfile --- old/eet-1.7.2/doc/Doxyfile 2012-11-23 00:20:55.000000000 +0100 +++ new/eet-1.7.3/doc/Doxyfile 2012-12-07 16:55:54.000000000 +0100 @@ -31,7 +31,7 @@ # This could be handy for archiving the generated documentation or # if some version control system is used. -PROJECT_NUMBER = 1.7.2 +PROJECT_NUMBER = 1.7.3 # Using the PROJECT_BRIEF tag one can provide an optional one line description for a project that appears at the top of each page and should give viewer a quick idea about the purpose of the project. Keep the description short. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/eet-1.7.2/eet.spec new/eet-1.7.3/eet.spec --- old/eet-1.7.2/eet.spec 2012-11-23 00:20:55.000000000 +0100 +++ new/eet-1.7.3/eet.spec 2012-12-07 16:55:54.000000000 +0100 @@ -3,7 +3,7 @@ Summary: Library for speedy data storage, retrieval, and compression. Name: eet -Version: 1.7.2 +Version: 1.7.3 Release: %{_rel} License: BSD Group: System Environment/Libraries diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/eet-1.7.2/src/lib/lz4/README new/eet-1.7.3/src/lib/lz4/README --- old/eet-1.7.2/src/lib/lz4/README 2012-11-22 12:37:03.000000000 +0100 +++ new/eet-1.7.3/src/lib/lz4/README 2012-12-07 12:48:16.000000000 +0100 @@ -4,4 +4,4 @@ [email protected] Copyright/licensing info in source files here. -this was from revsion 66. +this was from revision 84. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/eet-1.7.2/src/lib/lz4/lz4.c new/eet-1.7.3/src/lib/lz4/lz4.c --- old/eet-1.7.2/src/lib/lz4/lz4.c 2012-11-22 12:37:03.000000000 +0100 +++ new/eet-1.7.3/src/lib/lz4/lz4.c 2012-12-07 12:48:16.000000000 +0100 @@ -34,31 +34,24 @@ //************************************** // 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 +// MEMORY_USAGE : +// Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.) +// Increasing memory usage improves compression ratio +// Reduced memory usage can improve speed, due to cache effect +// Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache +#define MEMORY_USAGE 14 -// NOTCOMPRESSIBLE_CONFIRMATION : +// NOTCOMPRESSIBLE_DETECTIONLEVEL : // 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 +#define NOTCOMPRESSIBLE_DETECTIONLEVEL 6 // 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 will provide a small 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 remain within closed environment // This option is useless on Little_Endian CPU (such as x86) //#define BIG_ENDIAN_NATIVE_BUT_INCOMPATIBLE 1 @@ -98,7 +91,7 @@ //************************************** // Compiler Options //************************************** -#if __STDC_VERSION__ >= 199901L // C99 +#if __STDC_VERSION__ >= 199901L // C99 /* "restrict" is a known keyword */ #else # define restrict // Disable restrict @@ -107,7 +100,7 @@ #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 +# include <intrin.h> // For Visual 2005 # if LZ4_ARCH64 // 64-bit # pragma intrinsic(_BitScanForward64) // For Visual 2005 # pragma intrinsic(_BitScanReverse64) // For Visual 2005 @@ -181,11 +174,11 @@ //************************************** #define MINMATCH 4 -#define HASH_LOG COMPRESSIONLEVEL +#define HASH_LOG (MEMORY_USAGE-2) #define HASHTABLESIZE (1 << HASH_LOG) #define HASH_MASK (HASHTABLESIZE - 1) -#define SKIPSTRENGTH (NOTCOMPRESSIBLE_CONFIRMATION>2?NOTCOMPRESSIBLE_CONFIRMATION:2) +#define SKIPSTRENGTH (NOTCOMPRESSIBLE_DETECTIONLEVEL>2?NOTCOMPRESSIBLE_DETECTIONLEVEL: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 @@ -196,8 +189,8 @@ #define MAXD_LOG 16 #define MAX_DISTANCE ((1 << MAXD_LOG) - 1) -#define ML_BITS 4 -#define ML_MASK ((1U<<ML_BITS)-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) @@ -209,20 +202,20 @@ # 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 +# 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 +# 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)) @@ -239,7 +232,7 @@ //************************************** struct refTables { - HTYPE hashTable[HASHTABLESIZE]; + HTYPE hashTable[HASHTABLESIZE]; }; @@ -257,7 +250,7 @@ //**************************** #if LZ4_ARCH64 -inline static int LZ4_NbCommonBytes (register U64 val) +static inline int LZ4_NbCommonBytes (register U64 val) { #if defined(LZ4_BIG_ENDIAN) #if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) @@ -267,11 +260,11 @@ #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; + 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) @@ -281,15 +274,15 @@ #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]; + 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) +static inline int LZ4_NbCommonBytes (register U32 val) { #if defined(LZ4_BIG_ENDIAN) #if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) @@ -299,10 +292,10 @@ #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; + 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) @@ -312,8 +305,8 @@ #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]; + 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 } @@ -321,154 +314,173 @@ #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) +// LZ4_compressCtx : +// ----------------- +// Compress 'isize' bytes from 'source' into an output buffer 'dest' of maximum size 'maxOutputSize'. +// If it cannot achieve it, compression will stop, and result of the function will be zero. +// return : the number of bytes written in buffer 'dest', or 0 if the compression fails + +static inline int LZ4_compressCtx(void** ctx, + const char* source, + char* dest, + int isize, + int maxOutputSize) { #if HEAPMODE - struct refTables *srt = (struct refTables *) (*ctx); - HTYPE* HashTable; + struct refTables *srt = (struct refTables *) (*ctx); + HTYPE* HashTable; #else - HTYPE HashTable[HASHTABLESIZE] = {0}; + 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; + 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; + BYTE* op = (BYTE*) dest; + BYTE* const oend = op + maxOutputSize; - int len, length; - const int skipStrength = SKIPSTRENGTH; - U32 forwardH; + int len, length; + const int skipStrength = SKIPSTRENGTH; + U32 forwardH; - // Init - if (isize<MINLENGTH) goto _last_literals; + // 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)); + 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; + (void) ctx; #endif - // First Byte - HashTable[LZ4_HASH_VALUE(ip)] = ip - base; - ip++; forwardH = LZ4_HASH_VALUE(ip); + // First Byte + HashTable[LZ4_HASH_VALUE(ip)] = ip - base; + ip++; forwardH = LZ4_HASH_VALUE(ip); - // Main Loop + // 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); + { + 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 = (int)(ip - anchor); + token = op++; + if unlikely(op + length + (2 + 1 + LASTLITERALS) + (length>>8) > oend) return 0; // Check output limit +#ifdef _MSC_VER + if (length>=(int)RUN_MASK) + { + int len = length-RUN_MASK; + *token=(RUN_MASK<<ML_BITS); + if (len>254) + { + do { *op++ = 255; len -= 255; } while (len>254); + *op++ = (BYTE)len; + memcpy(op, anchor, length); + op += length; + goto _next_match; + } + else + *op++ = (BYTE)len; + } + else *token = (length<<ML_BITS); +#else + 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); +#endif - // Copy Literals - LZ4_BLINDCOPY(anchor, op, length); + // Copy Literals + LZ4_BLINDCOPY(anchor, op, length); _next_match: - // Encode Offset - LZ4_WRITE_LITTLEENDIAN_16(op,ip-ref); + // Encode Offset + LZ4_WRITE_LITTLEENDIAN_16(op,(U16)(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++; + // 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); - } + // Encode MatchLength + len = (int)(ip - anchor); + if unlikely(op + (1 + LASTLITERALS) + (len>>8) > oend) return 0; // Check output limit + 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; - } + // Encode Last Literals + { + int lastRun = (int)(iend - anchor); + if (((char*)op - dest) + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > (U32)maxOutputSize) 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); + // End + return (int) (((char*)op)-dest); } @@ -479,161 +491,192 @@ #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) +static inline int LZ4_compress64kCtx(void** ctx, + const char* source, + char* dest, + int isize, + int maxOutputSize) { #if HEAPMODE - struct refTables *srt = (struct refTables *) (*ctx); - U16* HashTable; + struct refTables *srt = (struct refTables *) (*ctx); + U16* HashTable; #else - U16 HashTable[HASH64KTABLESIZE] = {0}; + 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; + 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; + BYTE* op = (BYTE*) dest; + BYTE* const oend = op + maxOutputSize; - int len, length; - const int skipStrength = SKIPSTRENGTH; - U32 forwardH; + int len, length; + const int skipStrength = SKIPSTRENGTH; + U32 forwardH; - // Init - if (isize<MINLENGTH) goto _last_literals; + // 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)); + 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; + (void) ctx; #endif - // First Byte - ip++; forwardH = LZ4_HASH64K_VALUE(ip); + // First Byte + ip++; forwardH = LZ4_HASH64K_VALUE(ip); - // Main Loop + // 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); + { + 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] = (U16)(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 = (int)(ip - anchor); + token = op++; + if unlikely(op + length + (2 + 1 + LASTLITERALS) + (length>>8) > oend) return 0; // Check output limit +#ifdef _MSC_VER + if (length>=(int)RUN_MASK) + { + int len = length-RUN_MASK; + *token=(RUN_MASK<<ML_BITS); + if (len>254) + { + do { *op++ = 255; len -= 255; } while (len>254); + *op++ = (BYTE)len; + memcpy(op, anchor, length); + op += length; + goto _next_match; + } + else + *op++ = (BYTE)len; + } + else *token = (length<<ML_BITS); +#else + 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); +#endif - // Copy Literals - LZ4_BLINDCOPY(anchor, op, length); + // Copy Literals + LZ4_BLINDCOPY(anchor, op, length); _next_match: - // Encode Offset - LZ4_WRITE_LITTLEENDIAN_16(op,ip-ref); + // Encode Offset + LZ4_WRITE_LITTLEENDIAN_16(op,(U16)(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++; + // 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); - } + // Encode MatchLength + len = (int)(ip - anchor); + if unlikely(op + (1 + LASTLITERALS) + (len>>8) > oend) return 0; // Check output limit + 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)] = (U16)(ip - 2 - base); + + // Test next position + ref = base + HashTable[LZ4_HASH64K_VALUE(ip)]; + HashTable[LZ4_HASH64K_VALUE(ip)] = (U16)(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; - } + // Encode Last Literals + { + int lastRun = (int)(iend - anchor); + if (op + lastRun + 1 + (lastRun-RUN_MASK+255)/255 > oend) 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); + // End + return (int) (((char*)op)-dest); } - -int LZ4_compress(const char* source, - char* dest, - int isize) +int LZ4_compress_limitedOutput(const char* source, + char* dest, + int isize, + int maxOutputSize) { #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; + void* ctx = malloc(sizeof(struct refTables)); + int result; + if (isize < LZ4_64KLIMIT) + result = LZ4_compress64kCtx(&ctx, source, dest, isize, maxOutputSize); + else result = LZ4_compressCtx(&ctx, source, dest, isize, maxOutputSize); + free(ctx); + return result; #else - if (isize < (int)LZ4_64KLIMIT) return LZ4_compress64kCtx(NULL, source, dest, isize); - return LZ4_compressCtx(NULL, source, dest, isize); + if (isize < (int)LZ4_64KLIMIT) return LZ4_compress64kCtx(NULL, source, dest, isize, maxOutputSize); + return LZ4_compressCtx(NULL, source, dest, isize, maxOutputSize); #endif } +int LZ4_compress(const char* source, + char* dest, + int isize) +{ + return LZ4_compress_limitedOutput(source, dest, isize, LZ4_compressBound(isize)); +} + + //**************************** @@ -647,173 +690,172 @@ // 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) + 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) - { + // Local Variables + const BYTE* restrict ip = (const BYTE*) source; + const BYTE* ref; + + BYTE* 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 : we must necessarily stand at EOF + memcpy(op, ip, length); + ip += length; + break; // 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]; + size_t dec2table[]={0, 0, 0, -1, 0, 1, 2, 3}; + size_t dec2 = dec2table[op-ref]; #else - const int dec2 = 0; + 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 - } + *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) goto _output_error; // 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); + // end of decoding + return (int) (((char*)ip)-source); - // write overflow error detected + // write overflow error detected _output_error: - return (int) (-(((char*)ip)-source)); + return (int) (-(((char*)ip)-source)); } int LZ4_uncompress_unknownOutputSize( - const char* source, - char* dest, - int isize, - int maxOutputSize) + 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) - { + // Local Variables + const BYTE* restrict ip = (const BYTE*) source; + const BYTE* const iend = ip + isize; + const BYTE* ref; + + BYTE* 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 : writes beyond output buffer + if (ip+length != iend) goto _output_error; // Error : LZ4 format requires to consume all input at this stage + memcpy(op, ip, length); + op += length; + ip = iend; + 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]; + size_t dec2table[]={0, 0, 0, -1, 0, 1, 2, 3}; + size_t dec2 = dec2table[op-ref]; #else - const int dec2 = 0; + 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 - } + *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) goto _output_error; // 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); + // end of decoding + return (int) (((char*)op)-dest); - // write overflow error detected + // write overflow error detected _output_error: - return (int) (-(((char*)ip)-source)); + return (int) (-(((char*)ip)-source)); } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/eet-1.7.2/src/lib/lz4/lz4.h new/eet-1.7.3/src/lib/lz4/lz4.h --- old/eet-1.7.2/src/lib/lz4/lz4.h 2012-11-22 12:37:03.000000000 +0100 +++ new/eet-1.7.3/src/lib/lz4/lz4.h 2012-12-07 12:48:16.000000000 +0100 @@ -38,6 +38,14 @@ #endif +//************************************** +// Compiler Options +//************************************** +#ifdef _MSC_VER // Visual Studio +# define inline __inline // Visual is not C99, but supports some kind of inline +#endif + + //**************************** // Simple Functions //**************************** @@ -47,19 +55,22 @@ /* 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() + Compresses 'isize' bytes from 'source' into 'dest'. + Destination buffer must be already allocated, + and must be sized to handle worst cases situations (input data not compressible) + Worst case size evaluation is provided by function LZ4_compressBound() + + isize : is the input size. Max supported value is ~1.9GB + return : the number of bytes written in buffer dest + 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 + 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 outside of provided buffers, and never modifies input buffer. + note : destination buffer must be already allocated. + its size must be a minimum of 'osize' bytes. */ @@ -67,51 +78,48 @@ // Advanced Functions //**************************** -int LZ4_compressBound(int isize); +static inline int LZ4_compressBound(int isize) { return ((isize) + ((isize)/255) + 16); } +#define LZ4_COMPRESSBOUND( isize) ((isize) + ((isize)/255) + 16) /* 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) + 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. + inline function is recommended for the general case, + but macro is also provided when results need to be evaluated at compile time (such as table size allocation). + + 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); +int LZ4_compress_limitedOutput (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() +LZ4_compress_limitedOutput() : + Compress 'isize' bytes from 'source' into an output buffer 'dest' of maximum size 'maxOutputSize'. + If it cannot achieve it, compression will stop, and result of the function will be zero. + This function never writes outside of provided output buffer. + + isize : is the input size. Max supported value is ~1.9GB + maxOutputSize : is the size of the destination buffer (which must be already allocated) + return : the number of bytes written in buffer 'dest' + or 0 if the compression fails */ -int LZ4_compressCtx(void** ctx, const char* source, char* dest, int isize); -int LZ4_compress64kCtx(void** ctx, const char* source, char* dest, int isize); +int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize); /* -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. - +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() */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/eet-1.7.2/src/lib/lz4/lz4hc.c new/eet-1.7.3/src/lib/lz4/lz4hc.c --- old/eet-1.7.2/src/lib/lz4/lz4hc.c 2012-11-22 12:37:03.000000000 +0100 +++ new/eet-1.7.3/src/lib/lz4/lz4hc.c 2012-12-07 12:48:16.000000000 +0100 @@ -68,12 +68,20 @@ #ifdef _MSC_VER #define inline __forceinline // Visual is not C99, but supports some kind of inline +#include <intrin.h> // For Visual 2005 +# 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 // Visual Studio -#define bswap16(x) _byteswap_ushort(x) +#define lz4_bswap16(x) _byteswap_ushort(x) #else -#define bswap16(x) ((unsigned short int) ((((x) >> 8) & 0xffu) | (((x) & 0xffu) << 8))) +#define lz4_bswap16(x) ((unsigned short int) ((((x) >> 8) & 0xffu) | (((x) & 0xffu) << 8))) #endif @@ -174,8 +182,8 @@ #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; } +#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; } @@ -329,7 +337,7 @@ // HC4 match finder LZ4HC_Insert(hc4, ip); ref = HASH_POINTER(ip); - while ((ref > (ip-MAX_DISTANCE)) && (nbAttempts)) + while ((ref >= (ip-MAX_DISTANCE)) && (nbAttempts)) { nbAttempts--; if (*(ref+ml) == *(ip+ml)) @@ -350,7 +358,7 @@ if ((ipt<matchlimit) && (*reft == *ipt)) ipt++; _endCount: - if (ipt-ip > ml) { ml = ipt-ip; *matchpos = ref; } + if (ipt-ip > ml) { ml = (int)(ipt-ip); *matchpos = ref; } } ref = GETNEXT(ref); } @@ -366,13 +374,13 @@ INITBASE(base,hc4->base); const BYTE* ref; int nbAttempts = MAX_NB_ATTEMPTS; - int delta = ip-startLimit; + int delta = (int)(ip-startLimit); // First Match LZ4HC_Insert(hc4, ip); ref = HASH_POINTER(ip); - while ((ref > ip-MAX_DISTANCE) && (ref >= hc4->base) && (nbAttempts)) + while ((ref >= ip-MAX_DISTANCE) && (ref >= hc4->base) && (nbAttempts)) { nbAttempts--; if (*(startLimit + longest) == *(ref - delta + longest)) @@ -399,7 +407,7 @@ if ((ipt-startt) > longest) { - longest = ipt-startt; + longest = (int)(ipt-startt); *matchpos = reft; *startpos = startt; } @@ -417,7 +425,7 @@ BYTE* token; // Encode Literal length - length = *ip - *anchor; + length = (int)(*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); @@ -426,7 +434,7 @@ LZ4_BLINDCOPY(*anchor, *op, length); // Encode Offset - LZ4_WRITE_LITTLEENDIAN_16(*op,*ip-ref); + LZ4_WRITE_LITTLEENDIAN_16(*op,(U16)(*ip-ref)); // Encode MatchLength len = (int)(ml-MINMATCH); @@ -519,8 +527,8 @@ 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 (ip+new_ml > start2 + ml2 - MINMATCH) new_ml = (int)(start2 - ip) + ml2 - MINMATCH; + correction = new_ml - (int)(start2 - ip); if (correction > 0) { start2 += correction; @@ -543,8 +551,8 @@ { 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 (ip+ml > start2 + ml2 - MINMATCH) ml = (int)(start2 - ip) + ml2 - MINMATCH; + correction = ml - (int)(start2 - ip); if (correction > 0) { start2 += correction; @@ -554,7 +562,7 @@ } else { - ml = start2 - ip; + ml = (int)(start2 - ip); } } // Now, encode 2 sequences @@ -570,7 +578,7 @@ { if (start2 < ip+ml) { - int correction = (ip+ml) - start2; + int correction = (int)(ip+ml - start2); start2 += correction; ref2 += correction; ml2 -= correction; @@ -607,8 +615,8 @@ { 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 (ip + ml > start2 + ml2 - MINMATCH) ml = (int)(start2 - ip) + ml2 - MINMATCH; + correction = ml - (int)(start2 - ip); if (correction > 0) { start2 += correction; @@ -618,7 +626,7 @@ } else { - ml = start2 - ip; + ml = (int)(start2 - ip); } } LZ4_encodeSequence(&ip, &op, &anchor, ml, ref); @@ -637,7 +645,7 @@ // Encode Last Literals { - int lastRun = iend - anchor; + int lastRun = (int)(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); -- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
