Merge pull request #98 from Cyan4973/dev

v0.4.5
fixed visual warning
2015-12-18 03:59:36 +01:00 · 2015-12-18 03:19:27 +01:00 · 2015-12-18 02:51:14 +01:00 · 2015-12-18 02:14:46 +01:00 · 2015-12-18 01:26:48 +01:00 · 2015-12-17 23:50:15 +01:00
33 changed files with 1396 additions and 519 deletions
@@ -20,3 +20,21 @@
 # Visual solution files
 *.suo
 *.user
+
+# Build results
+[Dd]ebug/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+[Bb]in/
+[Oo]bj/
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
@@ -19,6 +19,7 @@ env:
  - ZSTD_TRAVIS_CI_ENV="-C programs test-zstd_nolegacy"
  - ZSTD_TRAVIS_CI_ENV=usan
  - ZSTD_TRAVIS_CI_ENV=asan
+  - ZSTD_TRAVIS_CI_ENV=asan32
  - ZSTD_TRAVIS_CI_ENV="-C programs valgrindTest"  

 matrix:
@@ -32,7 +32,7 @@
 # ################################################################

 # Version number
-export VERSION := 0.4.3
+export VERSION := 0.4.5

 PRGDIR  = programs
 ZSTDDIR = lib
@@ -96,6 +96,9 @@ usan: clean
 asan: clean
 	$(MAKE) test CC=clang MOREFLAGS="-g -fsanitize=address"

+asan32: clean
+	$(MAKE) -C $(PRGDIR) test32 CC=clang MOREFLAGS="-g -fsanitize=address"
+
 uasan: clean
 	$(MAKE) test CC=clang MOREFLAGS="-g -fsanitize=address -fsanitize=undefined"

@@ -1,3 +1,11 @@
+v0.4.5
+new : -m/--multiple : compress/decompress multiple files
+
+v0.4.4
+Fixed : high compression modes for Windows 32 bits
+new : external dictionary API extended to buffered mode and accessible through command line
+new : windows DLL project, thanks to Christophe Chevalier
+
 v0.4.3 :
 new : external dictionary API
 new : zstd-frugal
@@ -43,25 +43,39 @@ extern "C" {
 #include <stddef.h>   /* size_t */


+/* ***************************************************************
+*  Tuning parameters
+*****************************************************************/
+/*!
+*  ZSTD_DLL_EXPORT :
+*  Enable exporting of functions when building a Windows DLL
+*/
+#if defined(_WIN32) && defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
+#  define ZSTDLIB_API __declspec(dllexport)
+#else
+#  define ZSTDLIB_API
+#endif
+
+
 /* *************************************
 *  Version
 ***************************************/
 #define ZSTD_VERSION_MAJOR    0    /* for breaking interface changes  */
 #define ZSTD_VERSION_MINOR    4    /* for new (non-breaking) interface capabilities */
-#define ZSTD_VERSION_RELEASE  3    /* for tweaks, bug-fixes, or development */
+#define ZSTD_VERSION_RELEASE  5    /* for tweaks, bug-fixes, or development */
 #define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
-unsigned ZSTD_versionNumber (void);
+ZSTDLIB_API unsigned ZSTD_versionNumber (void);


 /* *************************************
 *  Simple functions
 ***************************************/
-size_t ZSTD_compress(   void* dst, size_t maxDstSize,
-                  const void* src, size_t srcSize,
-                         int  compressionLevel);
+ZSTDLIB_API size_t ZSTD_compress(   void* dst, size_t maxDstSize,
+                              const void* src, size_t srcSize,
+                                     int  compressionLevel);

-size_t ZSTD_decompress( void* dst, size_t maxOriginalSize,
-                  const void* src, size_t compressedSize);
+ZSTDLIB_API size_t ZSTD_decompress( void* dst, size_t maxOriginalSize,
+                              const void* src, size_t compressedSize);

 /**
 ZSTD_compress() :
@@ -83,25 +97,25 @@ ZSTD_decompress() :
 /* *************************************
 *  Tool functions
 ***************************************/
-size_t      ZSTD_compressBound(size_t srcSize);   /** maximum compressed size (worst case scenario) */
+ZSTDLIB_API size_t      ZSTD_compressBound(size_t srcSize);   /** maximum compressed size (worst case scenario) */

 /* Error Management */
-unsigned    ZSTD_isError(size_t code);         /** tells if a return value is an error code */
-const char* ZSTD_getErrorName(size_t code);    /** provides error code string */
+ZSTDLIB_API unsigned    ZSTD_isError(size_t code);         /** tells if a return value is an error code */
+ZSTDLIB_API const char* ZSTD_getErrorName(size_t code);    /** provides error code string */


 /* *************************************
 *  Advanced functions
 ***************************************/
 typedef struct ZSTD_CCtx_s ZSTD_CCtx;   /* incomplete type */
-ZSTD_CCtx* ZSTD_createCCtx(void);
-size_t     ZSTD_freeCCtx(ZSTD_CCtx* cctx);
+ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx(void);
+ZSTDLIB_API size_t     ZSTD_freeCCtx(ZSTD_CCtx* cctx);

 /**
 ZSTD_compressCCtx() :
    Same as ZSTD_compress(), but requires a ZSTD_CCtx working space already allocated
 */
-size_t ZSTD_compressCCtx(ZSTD_CCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize, int compressionLevel);
+ZSTDLIB_API size_t ZSTD_compressCCtx(ZSTD_CCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize, int compressionLevel);


 #if defined (__cplusplus)
@@ -160,6 +160,12 @@ size_t ZBUFF_compressInit(ZBUFF_CCtx* zbc, int compressionLevel)
 }


+ZSTDLIB_API size_t ZBUFF_compressWithDictionary(ZBUFF_CCtx* zbc, const void* src, size_t srcSize)
+{
+    ZSTD_compress_insertDictionary(zbc->zc, src, srcSize);
+    return 0;
+}
+

 /* *** Compression *** */

@@ -327,6 +333,8 @@ struct ZBUFF_DCtx_s {
    size_t outStart;
    size_t outEnd;
    size_t hPos;
+    const char* dict;
+    size_t dictSize;
    ZBUFF_dStage stage;
    unsigned char headerBuffer[ZSTD_frameHeaderSize_max];
 };   /* typedef'd to ZBUFF_DCtx within "zstd_buffered.h" */
@@ -353,17 +361,23 @@ size_t ZBUFF_freeDCtx(ZBUFF_DCtx* zbc)
 }


-
 /* *** Initialization *** */

 size_t ZBUFF_decompressInit(ZBUFF_DCtx* zbc)
 {
    zbc->stage = ZBUFFds_readHeader;
-    zbc->hPos = zbc->inPos = zbc->outStart = zbc->outEnd = 0;
+    zbc->hPos = zbc->inPos = zbc->outStart = zbc->outEnd = zbc->dictSize = 0;
    return ZSTD_resetDCtx(zbc->zc);
 }


+size_t ZBUFF_decompressWithDictionary(ZBUFF_DCtx* zbc, const void* src, size_t srcSize)
+{
+    zbc->dict = (const char*)src;
+    zbc->dictSize = srcSize;
+    return 0;
+}
+

 /* *** Decompression *** */

@@ -442,6 +456,8 @@ size_t ZBUFF_decompressContinue(ZBUFF_DCtx* zbc, void* dst, size_t* maxDstSizePt
                        if (zbc->outBuff == NULL) return ERROR(memory_allocation);
                    }
                }
+                if (zbc->dictSize)
+                    ZSTD_decompress_insertDictionary(zbc->zc, zbc->dict, zbc->dictSize);
                if (zbc->hPos)
                {
                    /* some data already loaded into headerBuffer : transfer into inBuff */
@@ -47,17 +47,32 @@ extern "C" {
 #include <stddef.h>   /* size_t */


+/* ***************************************************************
+*  Tuning parameters
+*****************************************************************/
+/*!
+*  ZSTD_DLL_EXPORT :
+*  Enable exporting of functions when building a Windows DLL
+*/
+#if defined(_WIN32) && defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
+#  define ZSTDLIB_API __declspec(dllexport)
+#else
+#  define ZSTDLIB_API
+#endif
+
+
 /* *************************************
 *  Streaming functions
 ***************************************/
 typedef struct ZBUFF_CCtx_s ZBUFF_CCtx;
-ZBUFF_CCtx* ZBUFF_createCCtx(void);
-size_t      ZBUFF_freeCCtx(ZBUFF_CCtx* cctx);
+ZSTDLIB_API ZBUFF_CCtx* ZBUFF_createCCtx(void);
+ZSTDLIB_API size_t      ZBUFF_freeCCtx(ZBUFF_CCtx* cctx);

-size_t ZBUFF_compressInit(ZBUFF_CCtx* cctx, int compressionLevel);
-size_t ZBUFF_compressContinue(ZBUFF_CCtx* cctx, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr);
-size_t ZBUFF_compressFlush(ZBUFF_CCtx* cctx, void* dst, size_t* maxDstSizePtr);
-size_t ZBUFF_compressEnd(ZBUFF_CCtx* cctx, void* dst, size_t* maxDstSizePtr);
+ZSTDLIB_API size_t ZBUFF_compressInit(ZBUFF_CCtx* cctx, int compressionLevel);
+ZSTDLIB_API size_t ZBUFF_compressWithDictionary(ZBUFF_CCtx* cctx, const void* src, size_t srcSize);
+ZSTDLIB_API size_t ZBUFF_compressContinue(ZBUFF_CCtx* cctx, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr);
+ZSTDLIB_API size_t ZBUFF_compressFlush(ZBUFF_CCtx* cctx, void* dst, size_t* maxDstSizePtr);
+ZSTDLIB_API size_t ZBUFF_compressEnd(ZBUFF_CCtx* cctx, void* dst, size_t* maxDstSizePtr);

 /** ************************************************
 *  Streaming compression
@@ -67,6 +82,9 @@ size_t ZBUFF_compressEnd(ZBUFF_CCtx* cctx, void* dst, size_t* maxDstSizePtr);
 *  Use ZBUFF_compressInit() to start a new compression operation.
 *  ZBUFF_CCtx objects can be reused multiple times.
 *
+*  Optionally, a reference to a static dictionary can be created with ZBUFF_compressWithDictionary()
+*  Note that the dictionary content must remain accessible during the compression process.
+*
 *  Use ZBUFF_compressContinue() repetitively to consume input stream.
 *  *srcSizePtr and *maxDstSizePtr can be any size.
 *  The function will report how many bytes were read or written within *srcSizePtr and *maxDstSizePtr.
@@ -97,11 +115,13 @@ size_t ZBUFF_compressEnd(ZBUFF_CCtx* cctx, void* dst, size_t* maxDstSizePtr);


 typedef struct ZBUFF_DCtx_s ZBUFF_DCtx;
-ZBUFF_DCtx* ZBUFF_createDCtx(void);
-size_t      ZBUFF_freeDCtx(ZBUFF_DCtx* dctx);
+ZSTDLIB_API ZBUFF_DCtx* ZBUFF_createDCtx(void);
+ZSTDLIB_API size_t      ZBUFF_freeDCtx(ZBUFF_DCtx* dctx);

-size_t ZBUFF_decompressInit(ZBUFF_DCtx* dctx);
-size_t ZBUFF_decompressContinue(ZBUFF_DCtx* dctx, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr);
+ZSTDLIB_API size_t ZBUFF_decompressInit(ZBUFF_DCtx* dctx);
+ZSTDLIB_API size_t ZBUFF_decompressWithDictionary(ZBUFF_DCtx* dctx, const void* src, size_t srcSize);
+
+ZSTDLIB_API size_t ZBUFF_decompressContinue(ZBUFF_DCtx* dctx, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr);

 /** ************************************************
 *  Streaming decompression
@@ -111,6 +131,10 @@ size_t ZBUFF_decompressContinue(ZBUFF_DCtx* dctx, void* dst, size_t* maxDstSizeP
 *  Use ZBUFF_decompressInit() to start a new decompression operation.
 *  ZBUFF_DCtx objects can be reused multiple times.
 *
+*  Optionally, a reference to a static dictionary can be set, using ZBUFF_decompressWithDictionary()
+*  It must be the same content as the one set during compression phase.
+*  Dictionary content must remain accessible during the decompression process.
+*
 *  Use ZBUFF_decompressContinue() repetitively to consume your input.
 *  *srcSizePtr and *maxDstSizePtr can be any size.
 *  The function will report how many bytes were read or written by modifying *srcSizePtr and *maxDstSizePtr.
@@ -129,15 +153,15 @@ size_t ZBUFF_decompressContinue(ZBUFF_DCtx* dctx, void* dst, size_t* maxDstSizeP
 /* *************************************
 *  Tool functions
 ***************************************/
-unsigned ZBUFF_isError(size_t errorCode);
-const char* ZBUFF_getErrorName(size_t errorCode);
+ZSTDLIB_API unsigned ZBUFF_isError(size_t errorCode);
+ZSTDLIB_API const char* ZBUFF_getErrorName(size_t errorCode);

 /** The below functions provide recommended buffer sizes for Compression or Decompression operations.
 *   These sizes are not compulsory, they just tend to offer better latency */
-size_t ZBUFF_recommendedCInSize(void);
-size_t ZBUFF_recommendedCOutSize(void);
-size_t ZBUFF_recommendedDInSize(void);
-size_t ZBUFF_recommendedDOutSize(void);
+ZSTDLIB_API size_t ZBUFF_recommendedCInSize(void);
+ZSTDLIB_API size_t ZBUFF_recommendedCOutSize(void);
+ZSTDLIB_API size_t ZBUFF_recommendedDInSize(void);
+ZSTDLIB_API size_t ZBUFF_recommendedDOutSize(void);


 #if defined (__cplusplus)
@@ -52,7 +52,7 @@ extern "C" {
 /* *************************************
 *  Advanced Streaming functions
 ***************************************/
-size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* cctx, ZSTD_parameters params);
+ZSTDLIB_API size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* cctx, ZSTD_parameters params);


 #if defined (__cplusplus)
@@ -65,6 +65,7 @@
 /* *************************************
 *  Constants
 ***************************************/
+unsigned ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; }
 static const U32 g_searchStrength = 8;


@@ -599,7 +600,7 @@ static unsigned ZSTD_NbCommonBytes (register size_t val)
 #       if defined(_MSC_VER) && defined(_WIN64)
            unsigned long r = 0;
            _BitScanForward64( &r, (U64)val );
-            return (int)(r>>3);
+            return (unsigned)(r>>3);
 #       elif defined(__GNUC__) && (__GNUC__ >= 3)
            return (__builtin_ctzll((U64)val) >> 3);
 #       else
@@ -612,7 +613,7 @@ static unsigned ZSTD_NbCommonBytes (register size_t val)
 #       if defined(_MSC_VER)
            unsigned long r=0;
            _BitScanForward( &r, (U32)val );
-            return (int)(r>>3);
+            return (unsigned)(r>>3);
 #       elif defined(__GNUC__) && (__GNUC__ >= 3)
            return (__builtin_ctz((U32)val) >> 3);
 #       else
@@ -1025,7 +1026,7 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, co
    size_t commonLengthSmaller=0, commonLengthLarger=0;
    const BYTE* const base = zc->base;
    const BYTE* match = base + matchIndex;
-    U32 current = (U32)(ip-base);
+    const U32 current = (U32)(ip-base);
    const U32 btLow = btMask >= current ? 0 : current - btMask;
    U32* smallerPtr = bt + 2*(current&btMask);
    U32* largerPtr  = bt + 2*(current&btMask) + 1;
@@ -1033,13 +1034,14 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, co
    const U32 windowLow = zc->lowLimit;

    if ( (current-matchIndex == 1)   /* RLE */
+        && (matchIndex > windowLow)
        && (MEM_read64(match) == MEM_read64(ip)) )
    {
        size_t rleLength = ZSTD_count(ip+8, match+8, iend) + 8;
        return (U32)(rleLength - mls);
    }

-    hashTable[h] = (U32)(ip - base);   /* Update Hash Table */
+    hashTable[h] = current;   /* Update Hash Table */

    while (nbCompares-- && (matchIndex > windowLow))
    {
@@ -1102,7 +1104,7 @@ size_t ZSTD_insertBtAndFindBestMatch (
    size_t bestLength = 0;
    U32 dummy32;   /* to be nullified at the end */

-    hashTable[h] = (U32)(ip-base);   /* Update Hash Table */
+    hashTable[h] = current;   /* Update Hash Table */

    while (nbCompares-- && (matchIndex > windowLow))
    {
@@ -1212,7 +1214,7 @@ static U32 ZSTD_insertBt1_extDict(ZSTD_CCtx* zc, const BYTE* const ip, const U32
    const BYTE* const dictEnd = dictBase + dictLimit;
    const BYTE* const prefixStart = base + dictLimit;
    const BYTE* match = base + matchIndex;
-    U32 current = (U32)(ip-base);
+    const U32 current = (U32)(ip-base);
    const U32 btLow = btMask >= current ? 0 : current - btMask;
    U32* smallerPtr = bt + 2*(current&btMask);
    U32* largerPtr  = bt + 2*(current&btMask) + 1;
@@ -1226,7 +1228,7 @@ static U32 ZSTD_insertBt1_extDict(ZSTD_CCtx* zc, const BYTE* const ip, const U32
        return (U32)(rleLength - mls);
    }

-    hashTable[h] = (U32)(ip - base);   /* Update Hash Table */
+    hashTable[h] = current;   /* Update Hash Table */

    while (nbCompares-- && (matchIndex > windowLow))
    {
@@ -1317,7 +1319,7 @@ size_t ZSTD_insertBtAndFindBestMatch_extDict (
    size_t bestLength = 0;
    U32 dummy32;   /* to be nullified at the end */

-    hashTable[h] = (U32)(ip-base);   /* Update Hash Table */
+    hashTable[h] = current;   /* Update Hash Table */

    while (nbCompares-- && (matchIndex > windowLow))
    {
@@ -1725,7 +1727,7 @@ size_t ZSTD_compressBlock_lazy_extDict_generic(ZSTD_CCtx* ctx,

    /* init */
    ZSTD_resetSeqStore(seqStorePtr);
-    if (((ip-base) - dictLimit) < REPCODE_STARTVALUE) ip += REPCODE_STARTVALUE;
+    if ((ip - prefixStart) < REPCODE_STARTVALUE) ip += REPCODE_STARTVALUE;

    /* Match Loop */
    while (ip < ilimit)
@@ -2007,13 +2009,16 @@ size_t ZSTD_compressContinue (ZSTD_CCtx* zc,
    }

    /* preemptive overflow correction */
-    if ((zc->base > ip) || (zc->lowLimit > (1<<30) ))
+    if (zc->lowLimit > (1<<30))
    {
-        U32 correction = zc->lowLimit-1;
+        U32 btplus = (zc->params.strategy == ZSTD_btlazy2);
+        U32 contentMask = (1 << (zc->params.contentLog - btplus)) - 1;
+        U32 newLowLimit = zc->lowLimit & contentMask;   /* preserve position % contentSize */
+        U32 correction = zc->lowLimit - newLowLimit;
        ZSTD_reduceIndex(zc, correction);
        zc->base += correction;
        zc->dictBase += correction;
-        zc->lowLimit -= correction;
+        zc->lowLimit = newLowLimit;
        zc->dictLimit -= correction;
        if (zc->nextToUpdate < correction) zc->nextToUpdate = 0;
        else zc->nextToUpdate -= correction;
@@ -2097,7 +2102,7 @@ size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* ctx,
 ZSTD_parameters ZSTD_getParams(int compressionLevel, U64 srcSizeHint)
 {
    ZSTD_parameters result;
-    int tableID = ((srcSizeHint-1) <= 128 KB) + ((srcSizeHint-1) <= 16 KB);   /* intentional underflow for srcSizeHint == 0 */
+    int tableID = ((srcSizeHint-1) <= 256 KB) + ((srcSizeHint-1) <= 128 KB) + ((srcSizeHint-1) <= 16 KB);   /* intentional underflow for srcSizeHint == 0 */
    if (compressionLevel<=0) compressionLevel = 1;
    if (compressionLevel > ZSTD_MAX_CLEVEL) compressionLevel = ZSTD_MAX_CLEVEL;
    result = ZSTD_defaultParameters[tableID][compressionLevel];
@@ -2112,7 +2117,7 @@ size_t ZSTD_compressBegin(ZSTD_CCtx* ctx, void* dst, size_t maxDstSize, int comp
 }


-/** ZSTD_compressEnd
+/*! ZSTD_compressEnd
 *   Write frame epilogue
 *   @return : nb of bytes written into dst (or an error code) */
 size_t ZSTD_compressEnd(ZSTD_CCtx* ctx, void* dst, size_t maxDstSize)
@@ -2134,6 +2139,7 @@ size_t ZSTD_compressEnd(ZSTD_CCtx* ctx, void* dst, size_t maxDstSize)
 size_t ZSTD_compress_advanced (ZSTD_CCtx* ctx,
                               void* dst, size_t maxDstSize,
                         const void* src, size_t srcSize,
+                         const void* dict,size_t dictSize,
                               ZSTD_parameters params)
 {
    BYTE* const ostart = (BYTE*)dst;
@@ -2146,9 +2152,15 @@ size_t ZSTD_compress_advanced (ZSTD_CCtx* ctx,
    op += oSize;
    maxDstSize -= oSize;

+    /* dictionary */
+    if (dict)
+    {
+        oSize = ZSTD_compress_insertDictionary(ctx, dict, dictSize);
+        if (ZSTD_isError(oSize)) return oSize;
+    }
+
    /* body (compression) */
-    ctx->base = (const BYTE*)src;
-    oSize = ZSTD_compress_generic (ctx, op,  maxDstSize, src, srcSize);
+    oSize = ZSTD_compressContinue (ctx, op,  maxDstSize, src, srcSize);
    if(ZSTD_isError(oSize)) return oSize;
    op += oSize;
    maxDstSize -= oSize;
@@ -2161,9 +2173,14 @@ size_t ZSTD_compress_advanced (ZSTD_CCtx* ctx,
    return (op - ostart);
 }

+size_t ZSTD_compress_usingDict(ZSTD_CCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize, const void* dict, size_t dictSize, int compressionLevel)
+{
+    return ZSTD_compress_advanced(ctx, dst, maxDstSize, src, srcSize, dict, dictSize, ZSTD_getParams(compressionLevel, srcSize+dictSize));
+}
+
 size_t ZSTD_compressCCtx (ZSTD_CCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize, int compressionLevel)
 {
-    return ZSTD_compress_advanced(ctx, dst, maxDstSize, src, srcSize, ZSTD_getParams(compressionLevel, srcSize));
+    return ZSTD_compress_advanced(ctx, dst, maxDstSize, src, srcSize, NULL, 0, ZSTD_getParams(compressionLevel, srcSize));
 }

 size_t ZSTD_compress(void* dst, size_t maxDstSize, const void* src, size_t srcSize, int compressionLevel)
@@ -2175,3 +2192,4 @@ size_t ZSTD_compress(void* dst, size_t maxDstSize, const void* src, size_t srcSi
    free(ctxBody.workSpace);   /* can't free ctxBody, since it's on stack; free heap content */
    return result;
 }
+
@@ -527,14 +527,11 @@ FORCE_INLINE size_t ZSTD_execSequence(BYTE* op,
    *litPtr = litEnd;   /* update for next sequence */

    /* copy Match */
-    /* check */
-    //if (match > oLitEnd) return ERROR(corruption_detected);   /* address space overflow test (is clang optimizer wrongly removing this test ?) */
-    if (sequence.offset > (size_t)oLitEnd) return ERROR(corruption_detected);   /* address space overflow test (this test seems preserved by clang optimizer) */
-
-    if (match < base)
+    if (sequence.offset > (size_t)(oLitEnd - base))
    {
        /* offset beyond prefix */
-        if (match < vBase) return ERROR(corruption_detected);
+        if (sequence.offset > (size_t)(oLitEnd - vBase))
+            return ERROR(corruption_detected);
        match = dictEnd - (base-match);
        if (match + sequence.matchLength <= dictEnd)
        {
@@ -679,7 +676,10 @@ static size_t ZSTD_decompressBlock(
 }


-size_t ZSTD_decompressDCtx(ZSTD_DCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+size_t ZSTD_decompress_usingDict(ZSTD_DCtx* ctx,
+                                 void* dst, size_t maxDstSize,
+                                 const void* src, size_t srcSize,
+                                 const void* dict, size_t dictSize)
 {
    const BYTE* ip = (const BYTE*)src;
    const BYTE* iend = ip + srcSize;
@@ -689,9 +689,19 @@ size_t ZSTD_decompressDCtx(ZSTD_DCtx* ctx, void* dst, size_t maxDstSize, const v
    size_t remainingSize = srcSize;
    blockProperties_t blockProperties;

-
    /* init */
-    ctx->vBase = ctx->base = ctx->dictEnd = dst;
+    ZSTD_resetDCtx(ctx);
+    if (dict)
+    {
+        ZSTD_decompress_insertDictionary(ctx, dict, dictSize);
+        ctx->dictEnd = ctx->previousDstEnd;
+        ctx->vBase = (const char*)dst - ((const char*)(ctx->previousDstEnd) - (const char*)(ctx->base));
+        ctx->base = dst;
+    }
+    else
+    {
+        ctx->vBase = ctx->base = ctx->dictEnd = dst;
+    }

    /* Frame Header */
    {
@@ -752,10 +762,16 @@ size_t ZSTD_decompressDCtx(ZSTD_DCtx* ctx, void* dst, size_t maxDstSize, const v
    return op-ostart;
 }

+
+size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    return ZSTD_decompress_usingDict(dctx, dst, maxDstSize, src, srcSize, NULL, 0);
+}
+
 size_t ZSTD_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
 {
-    ZSTD_DCtx ctx;
-    return ZSTD_decompressDCtx(&ctx, dst, maxDstSize, src, srcSize);
+    ZSTD_DCtx dctx;
+    return ZSTD_decompressDCtx(&dctx, dst, maxDstSize, src, srcSize);
 }


@@ -773,8 +789,6 @@ size_t ZSTD_decompressContinue(ZSTD_DCtx* ctx, void* dst, size_t maxDstSize, con
    if (srcSize != ctx->expected) return ERROR(srcSize_wrong);
    if (dst != ctx->previousDstEnd)   /* not contiguous */
    {
-        if ((dst > ctx->base) && (dst < ctx->previousDstEnd))   /* rolling buffer : new segment into dictionary */
-            ctx->base = (char*)dst;   /* temporary affectation, for vBase calculation */
        ctx->dictEnd = ctx->previousDstEnd;
        ctx->vBase = (const char*)dst - ((const char*)(ctx->previousDstEnd) - (const char*)(ctx->base));
        ctx->base = dst;
@@ -80,37 +80,64 @@ typedef struct


 /* *************************************
-*  Advanced function
+*  Advanced functions
 ***************************************/
 /** ZSTD_getParams
 *   return ZSTD_parameters structure for a selected compression level and srcSize.
 *   srcSizeHint value is optional, select 0 if not known */
-ZSTD_parameters ZSTD_getParams(int compressionLevel, U64 srcSizeHint);
+ZSTDLIB_API ZSTD_parameters ZSTD_getParams(int compressionLevel, U64 srcSizeHint);

 /** ZSTD_validateParams
 *   correct params value to remain within authorized range */
-void ZSTD_validateParams(ZSTD_parameters* params);
+ZSTDLIB_API void ZSTD_validateParams(ZSTD_parameters* params);
+
+/** ZSTD_compress_usingDict
+*   Same as ZSTD_compressCCtx(), using a Dictionary content as prefix
+*   Note : dict can be NULL, in which case, it's equivalent to ZSTD_compressCCtx() */
+ZSTDLIB_API size_t ZSTD_compress_usingDict(ZSTD_CCtx* ctx,
+                                           void* dst, size_t maxDstSize,
+                                     const void* src, size_t srcSize,
+                                     const void* dict,size_t dictSize,
+                                           int compressionLevel);

 /** ZSTD_compress_advanced
-*   Same as ZSTD_compressCCtx(), with fine-tune control of each compression parameter */
-size_t ZSTD_compress_advanced (ZSTD_CCtx* ctx,
-                               void* dst, size_t maxDstSize,
-                         const void* src, size_t srcSize,
-                               ZSTD_parameters params);
+*   Same as ZSTD_compress_usingDict(), with fine-tune control of each compression parameter */
+ZSTDLIB_API size_t ZSTD_compress_advanced (ZSTD_CCtx* ctx,
+                                           void* dst, size_t maxDstSize,
+                                     const void* src, size_t srcSize,
+                                     const void* dict,size_t dictSize,
+                                           ZSTD_parameters params);
+
+/** Decompression context management */
+typedef struct ZSTD_DCtx_s ZSTD_DCtx;
+ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx(void);
+ZSTDLIB_API size_t     ZSTD_freeDCtx(ZSTD_DCtx* dctx);
+
+/** ZSTD_decompressDCtx
+*   Same as ZSTD_decompress, with pre-allocated DCtx structure */
+size_t ZSTD_decompressDCtx(ZSTD_DCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
+
+/** ZSTD_decompress_usingDict
+*   Same as ZSTD_decompressDCtx, using a Dictionary content as prefix
+*   Note : dict can be NULL, in which case, it's equivalent to ZSTD_decompressDCtx() */
+size_t ZSTD_decompress_usingDict(ZSTD_DCtx* ctx,
+                                 void* dst, size_t maxDstSize,
+                                 const void* src, size_t srcSize,
+                                 const void* dict, size_t dictSize);


 /* **************************************
-*  Streaming functions (bufferless mode)
+*  Streaming functions (direct mode)
 ****************************************/
-size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, void* dst, size_t maxDstSize, int compressionLevel);
-size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* ctx, void* dst, size_t maxDstSize, ZSTD_parameters params);
-size_t ZSTD_compress_insertDictionary(ZSTD_CCtx* ctx, const void* src, size_t srcSize);
+ZSTDLIB_API size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, void* dst, size_t maxDstSize, int compressionLevel);
+ZSTDLIB_API size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* ctx, void* dst, size_t maxDstSize, ZSTD_parameters params);
+ZSTDLIB_API size_t ZSTD_compress_insertDictionary(ZSTD_CCtx* ctx, const void* src, size_t srcSize);

-size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
-size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t maxDstSize);
+ZSTDLIB_API size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
+ZSTDLIB_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t maxDstSize);

 /**
-  Streaming compression, bufferless mode
+  Streaming compression, direct mode (bufferless)

  A ZSTD_CCtx object is required to track streaming operations.
  Use ZSTD_createCCtx() / ZSTD_freeCCtx() to manage it.
@@ -120,7 +147,7 @@ size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t maxDstSize);
  Use ZSTD_compressBegin().
  You may also prefer the advanced derivative ZSTD_compressBegin_advanced(), for finer parameter control.

-  It's then possible to add a dictionary with ZSTD_compressDictionary()
+  It's then possible to add a dictionary with ZSTD_compress_insertDictionary()
  Note that dictionary presence is a "hidden" information,
  the decoder needs to be aware that it is required for proper decoding, or decoding will fail.

@@ -131,20 +158,17 @@ size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t maxDstSize);

  Finish a frame with ZSTD_compressEnd(), which will write the epilogue.
  Without it, the frame will be considered incomplete by decoders.
-  You can then re-use ZSTD_CCtx to compress new frames.
+
+  You can then reuse ZSTD_CCtx to compress new frames.
 */


-typedef struct ZSTD_DCtx_s ZSTD_DCtx;
-ZSTD_DCtx* ZSTD_createDCtx(void);
-size_t     ZSTD_freeDCtx(ZSTD_DCtx* dctx);
+ZSTDLIB_API size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx);
+ZSTDLIB_API size_t ZSTD_getFrameParams(ZSTD_parameters* params, const void* src, size_t srcSize);
+ZSTDLIB_API void   ZSTD_decompress_insertDictionary(ZSTD_DCtx* ctx, const void* src, size_t srcSize);

-size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx);
-size_t ZSTD_getFrameParams(ZSTD_parameters* params, const void* src, size_t srcSize);
-void   ZSTD_decompress_insertDictionary(ZSTD_DCtx* ctx, const void* src, size_t srcSize);
-
-size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx);
-size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
+ZSTDLIB_API size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx);
+ZSTDLIB_API size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);

 /**
  Streaming decompression, bufferless mode
@@ -160,7 +184,8 @@ size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, co
           >0 : means there is not enough data into src. Provides the expected size to successfully decode header.
           errorCode, which can be tested using ZSTD_isError() (For example, if it's not a ZSTD header)

-  Then, you can optionally insert a dictionary. This operation must mimic the compressor behavior, otherwise decompression will fail or be corrupted.
+  Then, you can optionally insert a dictionary.
+  This operation must mimic the compressor behavior, otherwise decompression will fail or be corrupted.

  Then it's possible to start decompression.
  Use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively.
@@ -180,7 +205,8 @@ size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, co
 *  Pre-defined compression levels
 ***************************************/
 #define ZSTD_MAX_CLEVEL 20
-static const ZSTD_parameters ZSTD_defaultParameters[3][ZSTD_MAX_CLEVEL+1] = {
+ZSTDLIB_API unsigned ZSTD_maxCLevel (void);
+static const ZSTD_parameters ZSTD_defaultParameters[4][ZSTD_MAX_CLEVEL+1] = {
 {   /* "default" */
    /*    W,  C,  H,  S,  L, strat */
    { 0, 18, 12, 12,  1,  4, ZSTD_fast    },  /* level  0 - never used */
@@ -205,6 +231,30 @@ static const ZSTD_parameters ZSTD_defaultParameters[3][ZSTD_MAX_CLEVEL+1] = {
    { 0, 25, 26, 23,  5,  5, ZSTD_btlazy2 },  /* level 19 */
    { 0, 26, 27, 25,  9,  5, ZSTD_btlazy2 },  /* level 20 */
 },
+{   /* for srcSize <= 256 KB */
+    /*     W,  C,  H,  S,  L, strat */
+    {  0, 18, 13, 14,  1,  7, ZSTD_fast    },  /* level  0 - never used */
+    {  0, 18, 14, 15,  1,  6, ZSTD_fast    },  /* level  1 */
+    {  0, 18, 14, 15,  1,  5, ZSTD_fast    },  /* level  2 */
+    {  0, 18, 12, 15,  3,  7, ZSTD_greedy  },  /* level  3 */
+    {  0, 18, 13, 15,  4,  7, ZSTD_greedy  },  /* level  4 */
+    {  0, 18, 14, 15,  5,  7, ZSTD_greedy  },  /* level  5 */
+    {  0, 18, 13, 15,  4,  7, ZSTD_lazy    },  /* level  6 */
+    {  0, 18, 14, 16,  5,  7, ZSTD_lazy    },  /* level  7 */
+    {  0, 18, 15, 16,  6,  7, ZSTD_lazy    },  /* level  8 */
+    {  0, 18, 15, 15,  7,  7, ZSTD_lazy    },  /* level  9 */
+    {  0, 18, 16, 16,  7,  7, ZSTD_lazy    },  /* level 10 */
+    {  0, 18, 16, 16,  8,  4, ZSTD_lazy    },  /* level 11 */
+    {  0, 18, 17, 16,  8,  4, ZSTD_lazy    },  /* level 12 */
+    {  0, 18, 17, 16,  9,  4, ZSTD_lazy    },  /* level 13 */
+    {  0, 18, 18, 16,  9,  4, ZSTD_lazy    },  /* level 14 */
+    {  0, 18, 17, 17,  9,  4, ZSTD_lazy2   },  /* level 15 */
+    {  0, 18, 18, 18,  9,  4, ZSTD_lazy2   },  /* level 16 */
+    {  0, 18, 18, 18, 10,  4, ZSTD_lazy2   },  /* level 17 */
+    {  0, 18, 18, 18, 11,  4, ZSTD_lazy2   },  /* level 18 */
+    {  0, 18, 18, 18, 12,  4, ZSTD_lazy2   },  /* level 19 */
+    {  0, 18, 18, 18, 13,  4, ZSTD_lazy2   },  /* level 20 */
+},
 {   /* for srcSize <= 128 KB */
    /*    W,  C,  H,  S,  L, strat */
    { 0, 17, 12, 12,  1,  4, ZSTD_fast    },  /* level  0 - never used */
@@ -30,7 +30,7 @@
 # fullbench32: Same as fullbench, but forced to compile in 32-bits mode
 # ##########################################################################

-VERSION?= 0.4.3
+VERSION?= 0.4.5

 DESTDIR?=
 PREFIX ?= /usr/local
@@ -94,8 +94,8 @@ zstd-noBench: $(ZSTD_FILES) $(ZSTDDIR)/zstd_buffered.c \
        zstdcli.c fileio.c $(ZSTD_FILEIO_LEGACY)
 	$(CC)      $(FLAGS) -DZSTD_NOBENCH $^ -o zstd$(EXT)

-zstd-frugal: clean
-	CFLAGS=-Os $(MAKE) zstd-noBench ZSTD_LEGACY_SUPPORT=0 
+zstd-frugal: clean 
+	$(MAKE) zstd-noBench ZSTD_LEGACY_SUPPORT=0 

 fullbench  : $(ZSTD_FILES) \
        datagen.c fullbench.c
@@ -169,77 +169,7 @@ test32: test-zstd32 test-fullbench32 test-fuzzer32 test-zbuff32
 test-all: test test32 valgrindTest

 zstd-playTests: datagen
-	@echo "\n**** frame concatenation **** "
-	@echo "hello " > hello.tmp
-	@echo "world!" > world.tmp
-	@cat hello.tmp world.tmp > helloworld.tmp
-	$(ZSTD) hello.tmp > hello.zstd
-	$(ZSTD) world.tmp > world.zstd
-	@cat hello.zstd world.zstd > helloworld.zstd
-	$(ZSTD) -df helloworld.zstd > result.tmp
-	cat result.tmp
-	sdiff helloworld.tmp result.tmp
-	@rm *.tmp *.zstd
-	@echo frame concatenation test completed
-	@echo "**** flush write error test **** "
-	echo foo | $(ZSTD) > /dev/full; if [ $$? -eq 0 ] ; then echo "write error not detected!"; false; fi
-	echo foo | $(ZSTD) | $(ZSTD) -d > /dev/full; if [ $$? -eq 0 ] ; then echo "write error not detected!"; false; fi
-	@echo "**** zstd round-trip tests **** "
-	@./datagen             | md5sum > tmp1
-	./datagen              | $(ZSTD) -v    | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	./datagen              | $(ZSTD) -6 -v | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	@./datagen -g270000000 | md5sum > tmp1
-	./datagen -g270000000  | $(ZSTD) -v    | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	./datagen -g270000000  | $(ZSTD) -v2   | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	./datagen -g270000000  | $(ZSTD) -v3   | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	@./datagen -g140000000 -P60| md5sum > tmp1
-	./datagen -g140000000 -P60 | $(ZSTD) -v4   | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	./datagen -g140000000 -P60 | $(ZSTD) -v5   | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	./datagen -g140000000 -P60 | $(ZSTD) -v6   | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	@./datagen -g70000000 -P70 | md5sum > tmp1
-	./datagen -g70000000 -P70  | $(ZSTD) -v7   | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	./datagen -g70000000 -P70  | $(ZSTD) -v8   | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	./datagen -g70000000 -P70  | $(ZSTD) -v9   | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	@./datagen -g35000000 -P75 | md5sum > tmp1
-	./datagen -g35000000 -P75  | $(ZSTD) -v10  | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	./datagen -g35000000 -P75  | $(ZSTD) -v11  | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	./datagen -g35000000 -P75  | $(ZSTD) -v12  | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	@./datagen -g18000000 -P80 | md5sum > tmp1
-	./datagen -g18000000 -P80  | $(ZSTD) -v13  | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	./datagen -g18000000 -P80  | $(ZSTD) -v14  | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	./datagen -g18000000 -P80  | $(ZSTD) -v15  | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	./datagen -g18000000 -P80  | $(ZSTD) -v16  | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	./datagen -g18000000 -P80  | $(ZSTD) -v17  | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	@./datagen -g50000000 -P94 | md5sum > tmp1
-	./datagen -g50000000 -P94  | $(ZSTD) -v18  | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	./datagen -g50000000 -P94  | $(ZSTD) -v19  | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	@./datagen -g99000000 -P99 | md5sum > tmp1
-	./datagen -g99000000 -P99  | $(ZSTD) -v20  | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
-	./datagen -g6000000000 -P99| md5sum > tmp1
-	./datagen -g6000000000 -P99| $(ZSTD) -vq   | $(ZSTD) -d  | md5sum > tmp2
-	@diff tmp1 tmp2   
+	ZSTD=$(ZSTD) ./playTests.sh --test-large-data

 test-zstd: ZSTD = ./zstd
 test-zstd: zstd zstd-playTests
@@ -27,7 +27,10 @@
 *  Compiler Options
 ****************************************/
 /* Disable some Visual warning messages */
-#define _CRT_SECURE_NO_WARNINGS                  /* fopen */
+#ifdef _MSC_VER
+#  define _CRT_SECURE_NO_WARNINGS                /* fopen */
+#  pragma warning(disable : 4127)                /* disable: C4127: conditional expression is constant */
+#endif

 /* Unix Large Files support (>4GB) */
 #define _FILE_OFFSET_BITS 64
@@ -60,7 +63,7 @@
 #endif

 #include "mem.h"
-#include "zstd.h"
+#include "zstd_static.h"
 #include "xxhash.h"
 #include "datagen.h"      /* RDG_genBuffer */

@@ -72,6 +75,10 @@
 #  define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
 #endif

+#ifdef _MSC_VER
+#define snprintf sprintf_s
+#endif
+

 /* *************************************
 *  Constants
@@ -90,9 +97,28 @@ static U32 g_compressibilityDefault = 50;


 /* *************************************
-*  Macros
+*  console display
 ***************************************/
-#define DISPLAY(...) fprintf(stderr, __VA_ARGS__)
+#define DISPLAY(...)         fprintf(stderr, __VA_ARGS__)
+#define DISPLAYLEVEL(l, ...) if (g_displayLevel>=l) { DISPLAY(__VA_ARGS__); }
+static U32 g_displayLevel = 2;   /* 0 : no display;   1: errors;   2 : + result + interaction + warnings;   3 : + progression;   4 : + information */
+
+
+/* *************************************
+*  Exceptions
+***************************************/
+#ifndef DEBUG
+#  define DEBUG 0
+#endif
+#define DEBUGOUTPUT(...) if (DEBUG) DISPLAY(__VA_ARGS__);
+#define EXM_THROW(error, ...)                                             \
+{                                                                         \
+    DEBUGOUTPUT("Error defined at %s, line %i : \n", __FILE__, __LINE__); \
+    DISPLAYLEVEL(1, "Error %i : ", error);                                \
+    DISPLAYLEVEL(1, __VA_ARGS__);                                         \
+    DISPLAYLEVEL(1, "\n");                                                \
+    exit(error);                                                          \
+}


 /* *************************************
@@ -156,13 +182,27 @@ static int BMK_GetMilliSpan( int nTimeStart )
  return nSpan;
 }

+static U64 BMK_getFileSize(const char* infilename)
+{
+    int r;
+#if defined(_MSC_VER)
+    struct _stat64 statbuf;
+    r = _stat64(infilename, &statbuf);
+#else
+    struct stat statbuf;
+    r = stat(infilename, &statbuf);
+#endif
+    if (r || !S_ISREG(statbuf.st_mode)) return 0;   /* No good... */
+    return (U64)statbuf.st_size;
+}
+

 /* ********************************************************
 *  Bench functions
 **********************************************************/
 typedef struct
 {
-    char*  srcPtr;
+    const char* srcPtr;
    size_t srcSize;
    char*  cPtr;
    size_t cRoom;
@@ -171,57 +211,55 @@ typedef struct
    size_t resSize;
 } blockParam_t;

-typedef size_t (*compressor_t) (void* dst, size_t maxDstSize, const void* src, size_t srcSize, int compressionLevel);
-
 #define MIN(a,b) ((a)<(b) ? (a) : (b))

-static int BMK_benchMem(void* srcBuffer, size_t srcSize, const char* fileName, int cLevel)
+static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
+                        const char* displayName, int cLevel,
+                        const size_t* fileSizes, U32 nbFiles,
+                        const void* dictBuffer, size_t dictBufferSize)
 {
    const size_t blockSize = (g_blockSize ? g_blockSize : srcSize) + (!srcSize);   /* avoid div by 0 */
-    const U32 nbBlocks = (U32) ((srcSize + (blockSize-1)) / blockSize);
-    blockParam_t* const blockTable = (blockParam_t*) malloc(nbBlocks * sizeof(blockParam_t));
-    const size_t maxCompressedSize = (size_t)nbBlocks * ZSTD_compressBound(blockSize);
+    const U32 maxNbBlocks = (U32) ((srcSize + (blockSize-1)) / blockSize) + nbFiles;
+    blockParam_t* const blockTable = (blockParam_t*) malloc(maxNbBlocks * sizeof(blockParam_t));
+    const size_t maxCompressedSize = ZSTD_compressBound(srcSize) + (maxNbBlocks * 1024);   /* add some room for safety */
    void* const compressedBuffer = malloc(maxCompressedSize);
    void* const resultBuffer = malloc(srcSize);
-    const compressor_t compressor = ZSTD_compress;
-    U64 crcOrig;
+    ZSTD_CCtx* ctx = ZSTD_createCCtx();
+    ZSTD_DCtx* dctx = ZSTD_createDCtx();
+    U64 crcOrig = XXH64(srcBuffer, srcSize, 0);
+    U32 nbBlocks = 0;

    /* init */
-    if (strlen(fileName)>16)
-        fileName += strlen(fileName)-16;
+    if (strlen(displayName)>17) displayName += strlen(displayName)-17;   /* can only display 17 characters */

    /* Memory allocation & restrictions */
-    if (!compressedBuffer || !resultBuffer || !blockTable)
-    {
-        DISPLAY("\nError: not enough memory!\n");
-        free(compressedBuffer);
-        free(resultBuffer);
-        free(blockTable);
-        return 12;
-    }
-
-    /* Calculating input Checksum */
-    crcOrig = XXH64(srcBuffer, srcSize, 0);
+    if (!compressedBuffer || !resultBuffer || !blockTable || !ctx || !dctx)
+        EXM_THROW(31, "not enough memory");

    /* Init blockTable data */
    {
-        U32 i;
-        size_t remaining = srcSize;
-        char* srcPtr = (char*)srcBuffer;
+        U32 fileNb;
+        const char* srcPtr = (const char*)srcBuffer;
        char* cPtr = (char*)compressedBuffer;
        char* resPtr = (char*)resultBuffer;
-        for (i=0; i<nbBlocks; i++)
+        for (fileNb=0; fileNb<nbFiles; fileNb++)
        {
-            size_t thisBlockSize = MIN(remaining, blockSize);
-            blockTable[i].srcPtr = srcPtr;
-            blockTable[i].cPtr = cPtr;
-            blockTable[i].resPtr = resPtr;
-            blockTable[i].srcSize = thisBlockSize;
-            blockTable[i].cRoom = ZSTD_compressBound(thisBlockSize);
-            srcPtr += thisBlockSize;
-            cPtr += blockTable[i].cRoom;
-            resPtr += thisBlockSize;
-            remaining -= thisBlockSize;
+            size_t remaining = fileSizes[fileNb];
+            U32 nbBlocksforThisFile = (U32)((remaining + (blockSize-1)) / blockSize);
+            U32 blockEnd = nbBlocks + nbBlocksforThisFile;
+            for ( ; nbBlocks<blockEnd; nbBlocks++)
+            {
+                size_t thisBlockSize = MIN(remaining, blockSize);
+                blockTable[nbBlocks].srcPtr = srcPtr;
+                blockTable[nbBlocks].cPtr = cPtr;
+                blockTable[nbBlocks].resPtr = resPtr;
+                blockTable[nbBlocks].srcSize = thisBlockSize;
+                blockTable[nbBlocks].cRoom = ZSTD_compressBound(thisBlockSize);
+                srcPtr += thisBlockSize;
+                cPtr += blockTable[nbBlocks].cRoom;
+                resPtr += thisBlockSize;
+                remaining -= thisBlockSize;
+            }
        }
    }

@@ -244,7 +282,7 @@ static int BMK_benchMem(void* srcBuffer, size_t srcSize, const char* fileName, i
            U32 blockNb;

            /* Compression */
-            DISPLAY("%2i-%-17.17s :%10u ->\r", loopNb, fileName, (U32)srcSize);
+            DISPLAY("%2i-%-17.17s :%10u ->\r", loopNb, displayName, (U32)srcSize);
            memset(compressedBuffer, 0xE5, maxCompressedSize);

            nbLoops = 0;
@@ -254,7 +292,11 @@ static int BMK_benchMem(void* srcBuffer, size_t srcSize, const char* fileName, i
            while (BMK_GetMilliSpan(milliTime) < TIMELOOP)
            {
                for (blockNb=0; blockNb<nbBlocks; blockNb++)
-                    blockTable[blockNb].cSize = compressor(blockTable[blockNb].cPtr,  blockTable[blockNb].cRoom, blockTable[blockNb].srcPtr,blockTable[blockNb].srcSize, cLevel);
+                    blockTable[blockNb].cSize = ZSTD_compress_usingDict(ctx,
+                                                              blockTable[blockNb].cPtr,  blockTable[blockNb].cRoom,
+                                                              blockTable[blockNb].srcPtr,blockTable[blockNb].srcSize,
+                                                              dictBuffer, dictBufferSize,
+                                                              cLevel);
                nbLoops++;
            }
            milliTime = BMK_GetMilliSpan(milliTime);
@@ -264,7 +306,7 @@ static int BMK_benchMem(void* srcBuffer, size_t srcSize, const char* fileName, i
                cSize += blockTable[blockNb].cSize;
            if ((double)milliTime < fastestC*nbLoops) fastestC = (double)milliTime / nbLoops;
            ratio = (double)srcSize / (double)cSize;
-            DISPLAY("%2i-%-17.17s :%10i ->%10i (%5.3f),%6.1f MB/s\r", loopNb, fileName, (int)srcSize, (int)cSize, ratio, (double)srcSize / fastestC / 1000.);
+            DISPLAY("%2i-%-17.17s :%10i ->%10i (%5.3f),%6.1f MB/s\r", loopNb, displayName, (int)srcSize, (int)cSize, ratio, (double)srcSize / fastestC / 1000.);

 #if 1
            /* Decompression */
@@ -277,13 +319,15 @@ static int BMK_benchMem(void* srcBuffer, size_t srcSize, const char* fileName, i
            for ( ; BMK_GetMilliSpan(milliTime) < TIMELOOP; nbLoops++)
            {
                for (blockNb=0; blockNb<nbBlocks; blockNb++)
-                    blockTable[blockNb].resSize = ZSTD_decompress(blockTable[blockNb].resPtr, blockTable[blockNb].srcSize,
-                                                                  blockTable[blockNb].cPtr, blockTable[blockNb].cSize);
+                    blockTable[blockNb].resSize = ZSTD_decompress_usingDict(dctx,
+                                                                blockTable[blockNb].resPtr, blockTable[blockNb].srcSize,
+                                                                blockTable[blockNb].cPtr, blockTable[blockNb].cSize,
+                                                                dictBuffer, dictBufferSize);
            }
            milliTime = BMK_GetMilliSpan(milliTime);

            if ((double)milliTime < fastestD*nbLoops) fastestD = (double)milliTime / nbLoops;
-            DISPLAY("%2i-%-17.17s :%10i ->%10i (%5.3f),%6.1f MB/s ,%6.1f MB/s\r", loopNb, fileName, (int)srcSize, (int)cSize, ratio, (double)srcSize / fastestC / 1000., (double)srcSize / fastestD / 1000.);
+            DISPLAY("%2i-%-17.17s :%10i ->%10i (%5.3f),%6.1f MB/s ,%6.1f MB/s\r", loopNb, displayName, (int)srcSize, (int)cSize, ratio, (double)srcSize / fastestC / 1000., (double)srcSize / fastestD / 1000.);

            /* CRC Checking */
            crcCheck = XXH64(resultBuffer, srcSize, 0);
@@ -291,10 +335,10 @@ static int BMK_benchMem(void* srcBuffer, size_t srcSize, const char* fileName, i
            {
                unsigned u;
                unsigned eBlockSize = (unsigned)(MIN(65536*2, blockSize));
-                DISPLAY("\n!!! WARNING !!! %14s : Invalid Checksum : %x != %x\n", fileName, (unsigned)crcOrig, (unsigned)crcCheck);
+                DISPLAY("\n!!! WARNING !!! %14s : Invalid Checksum : %x != %x\n", displayName, (unsigned)crcOrig, (unsigned)crcCheck);
                for (u=0; u<srcSize; u++)
                {
-                    if (((BYTE*)srcBuffer)[u] != ((BYTE*)resultBuffer)[u])
+                    if (((const BYTE*)srcBuffer)[u] != ((const BYTE*)resultBuffer)[u])
                    {
                        printf("Decoding error at pos %u (block %u, pos %u) \n", u, u / eBlockSize, u % eBlockSize);
                        break;
@@ -306,30 +350,20 @@ static int BMK_benchMem(void* srcBuffer, size_t srcSize, const char* fileName, i
        }

        if (crcOrig == crcCheck)
-            DISPLAY("%2i-%-17.17s :%10i ->%10i (%5.3f),%6.1f MB/s ,%6.1f MB/s \n", cLevel, fileName, (int)srcSize, (int)cSize, ratio, (double)srcSize / fastestC / 1000., (double)srcSize / fastestD / 1000.);
+            DISPLAY("%2i-%-17.17s :%10i ->%10i (%5.3f),%6.1f MB/s ,%6.1f MB/s \n", cLevel, displayName, (int)srcSize, (int)cSize, ratio, (double)srcSize / fastestC / 1000., (double)srcSize / fastestD / 1000.);
+        else
+            DISPLAY("X \n");
    }

-    /* End cleaning */
+    /* clean up */
    free(compressedBuffer);
    free(resultBuffer);
+    ZSTD_freeCCtx(ctx);
+    ZSTD_freeDCtx(dctx);
    return 0;
 }


-static U64 BMK_GetFileSize(const char* infilename)
-{
-    int r;
-#if defined(_MSC_VER)
-    struct _stat64 statbuf;
-    r = _stat64(infilename, &statbuf);
-#else
-    struct stat statbuf;
-    r = stat(infilename, &statbuf);
-#endif
-    if (r || !S_ISREG(statbuf.st_mode)) return 0;   /* No good... */
-    return (U64)statbuf.st_size;
-}
-
 static size_t BMK_findMaxMem(U64 requiredMem)
 {
    size_t step = 64 MB;
@@ -349,124 +383,143 @@ static size_t BMK_findMaxMem(U64 requiredMem)
    return (size_t)(requiredMem - step);
 }

-static int BMK_benchOneFile(const char* inFileName, int cLevel)
+static void BMK_benchCLevel(void* srcBuffer, size_t benchedSize,
+                            const char* displayName, int cLevel,
+                            const size_t* fileSizes, unsigned nbFiles,
+                            const void* dictBuffer, size_t dictBufferSize)
 {
-    FILE*  inFile;
-    U64    inFileSize;
-    size_t benchedSize, readSize;
-    void* srcBuffer;
-    int result=0;
-
-    /* Check file existence */
-    inFile = fopen(inFileName, "rb");
-    if (inFile == NULL)
-    {
-        DISPLAY("Pb opening %s\n", inFileName);
-        return 11;
-    }
-
-    /* Memory allocation & restrictions */
-    inFileSize = BMK_GetFileSize(inFileName);
-    benchedSize = BMK_findMaxMem(inFileSize * 3) / 3;
-    if ((U64)benchedSize > inFileSize) benchedSize = (size_t)inFileSize;
-    if (benchedSize < inFileSize)
-        DISPLAY("Not enough memory for '%s' full size; testing %i MB only...\n", inFileName, (int)(benchedSize >> 20));
-    srcBuffer = malloc(benchedSize);
-    if (!srcBuffer)
-    {
-        DISPLAY("\nError: not enough memory!\n");
-        fclose(inFile);
-        return 12;
-    }
-
-    /* Fill input buffer */
-    DISPLAY("Loading %s...       \r", inFileName);
-    readSize = fread(srcBuffer, 1, benchedSize, inFile);
-    fclose(inFile);
-
-    if (readSize != benchedSize)
-    {
-        DISPLAY("\nError: problem reading file '%s' !!    \n", inFileName);
-        free(srcBuffer);
-        return 13;
-    }
-
-    /* Bench */
-    if (cLevel<0)
+    if (cLevel < 0)
    {
        int l;
        for (l=1; l <= -cLevel; l++)
-            result = BMK_benchMem(srcBuffer, benchedSize, inFileName, l);
+            BMK_benchMem(srcBuffer, benchedSize,
+                         displayName, l,
+                         fileSizes, nbFiles,
+                         dictBuffer, dictBufferSize);
+        return;
    }
-    else
-        result = BMK_benchMem(srcBuffer, benchedSize, inFileName, cLevel);
+    BMK_benchMem(srcBuffer, benchedSize,
+                 displayName, cLevel,
+                 fileSizes, nbFiles,
+                 dictBuffer, dictBufferSize);
+}
+
+static U64 BMK_getTotalFileSize(const char** fileNamesTable, unsigned nbFiles)
+{
+    U64 total = 0;
+    unsigned n;
+    for (n=0; n<nbFiles; n++)
+        total += BMK_getFileSize(fileNamesTable[n]);
+    return total;
+}
+
+static void BMK_loadFiles(void* buffer, size_t bufferSize,
+                          size_t* fileSizes,
+                          const char** fileNamesTable, unsigned nbFiles)
+{
+    BYTE* buff = (BYTE*)buffer;
+    size_t pos = 0;
+    unsigned n;
+
+    for (n=0; n<nbFiles; n++)
+    {
+        size_t readSize;
+        U64 fileSize = BMK_getFileSize(fileNamesTable[n]);
+        FILE* f = fopen(fileNamesTable[n], "rb");
+        if (f==NULL) EXM_THROW(10, "impossible to open file %s", fileNamesTable[n]);
+        DISPLAYLEVEL(2, "Loading %s...       \r", fileNamesTable[n]);
+        if (fileSize > bufferSize-pos) fileSize = bufferSize-pos;
+        readSize = fread(buff+pos, 1, (size_t)fileSize, f);
+        if (readSize != (size_t)fileSize) EXM_THROW(11, "could not read %s", fileNamesTable[n]);
+        pos += readSize;
+        fileSizes[n] = (size_t)fileSize;
+        fclose(f);
+    }
+}
+
+static void BMK_benchFileTable(const char** fileNamesTable, unsigned nbFiles,
+                               const char* dictFileName, int cLevel)
+{
+    void* srcBuffer;
+    size_t benchedSize;
+    void* dictBuffer = NULL;
+    size_t dictBufferSize = 0;
+    size_t* fileSizes = (size_t*)malloc(nbFiles * sizeof(size_t));
+    U64 totalSizeToLoad = BMK_getTotalFileSize(fileNamesTable, nbFiles);
+    char mfName[20] = {0};
+    const char* displayName = NULL;
+
+    if (!fileSizes) EXM_THROW(12, "not enough memory for fileSizes");
+
+    /* Load dictionary */
+    if (dictFileName != NULL)
+    {
+        U64 dictFileSize = BMK_getFileSize(dictFileName);
+        if (dictFileSize > 64 MB) EXM_THROW(10, "dictionary file %s too large", dictFileName);
+        dictBufferSize = (size_t)dictFileSize;
+        dictBuffer = malloc(dictBufferSize);
+        if (dictBuffer==NULL) EXM_THROW(11, "not enough memory for dictionary (%u bytes)", (U32)dictBufferSize);
+        BMK_loadFiles(dictBuffer, dictBufferSize, fileSizes, &dictFileName, 1);
+    }
+
+    /* Memory allocation & restrictions */
+    benchedSize = BMK_findMaxMem(totalSizeToLoad * 3) / 3;
+    if ((U64)benchedSize > totalSizeToLoad) benchedSize = (size_t)totalSizeToLoad;
+    if (benchedSize < totalSizeToLoad)
+        DISPLAY("Not enough memory; testing %u MB only...\n", (U32)(benchedSize >> 20));
+    srcBuffer = malloc(benchedSize);
+    if (!srcBuffer) EXM_THROW(12, "not enough memory");
+
+    /* Load input buffer */
+    BMK_loadFiles(srcBuffer, benchedSize, fileSizes, fileNamesTable, nbFiles);
+
+    /* Bench */
+    snprintf (mfName, sizeof(mfName), " %u files", nbFiles);
+    if (nbFiles > 1) displayName = mfName;
+    else displayName = fileNamesTable[0];
+
+    BMK_benchCLevel(srcBuffer, benchedSize,
+                    displayName, cLevel,
+                    fileSizes, nbFiles,
+                    dictBuffer, dictBufferSize);

    /* clean up */
    free(srcBuffer);
-    DISPLAY("\n");
-    return result;
+    free(dictBuffer);
+    free(fileSizes);
 }


-static int BMK_syntheticTest(int cLevel, double compressibility)
+static void BMK_syntheticTest(int cLevel, double compressibility)
 {
+    char name[20] = {0};
    size_t benchedSize = 10000000;
    void* srcBuffer = malloc(benchedSize);
-    int result=0;
-    char name[20] = {0};

    /* Memory allocation */
-    if (!srcBuffer)
-    {
-        DISPLAY("\nError: not enough memory!\n");
-        free(srcBuffer);
-        return 12;
-    }
+    if (!srcBuffer) EXM_THROW(21, "not enough memory");

    /* Fill input buffer */
    RDG_genBuffer(srcBuffer, benchedSize, compressibility, 0.0, 0);

    /* Bench */
-#ifdef _MSC_VER
-    sprintf_s(name, 20, "Synthetic %2u%%", (unsigned)(compressibility*100));
-#else
-    snprintf (name, 20, "Synthetic %2u%%", (unsigned)(compressibility*100));
-#endif
-    /* Bench */
-    if (cLevel<0)
-    {
-        int l;
-        for (l=1; l <= -cLevel; l++)
-            result = BMK_benchMem(srcBuffer, benchedSize, name, l);
-    }
-    else
-        result = BMK_benchMem(srcBuffer, benchedSize, name, cLevel);
+    snprintf (name, sizeof(name), "Synthetic %2u%%", (unsigned)(compressibility*100));
+    BMK_benchCLevel(srcBuffer, benchedSize, name, cLevel, &benchedSize, 1, NULL, 0);

-    /* End */
+    /* clean up */
    free(srcBuffer);
-    DISPLAY("\n");
-    return result;
 }


-int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles, unsigned cLevel)
+int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles,
+                   const char* dictFileName, int cLevel)
 {
    double compressibility = (double)g_compressibilityDefault / 100;

    if (nbFiles == 0)
-    {
        BMK_syntheticTest(cLevel, compressibility);
-    }
    else
-    {
-        /* Loop for each file */
-        unsigned fileIdx = 0;
-        while (fileIdx<nbFiles)
-        {
-            BMK_benchOneFile(fileNamesTable[fileIdx], cLevel);
-            fileIdx++;
-        }
-    }
+        BMK_benchFileTable(fileNamesTable, nbFiles, dictFileName, cLevel);
    return 0;
 }

@@ -26,7 +26,8 @@


 /* Main function */
-int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles, unsigned cLevel);
+int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles,
+                   const char* dictFileName, int cLevel);

 /* Set Parameters */
 void BMK_SetNbIterations(int nbLoops);
@@ -121,6 +121,7 @@

 #define CACHELINE 64

+#define MAX_DICT_SIZE (512 KB)

 /* *************************************
 *  Macros
@@ -174,52 +175,6 @@ static unsigned FIO_GetMilliSpan(clock_t nPrevious)
 }


-static void FIO_getFileHandles(FILE** pfinput, FILE** pfoutput, const char* input_filename, const char* output_filename)
-{
-    if (!strcmp (input_filename, stdinmark))
-    {
-        DISPLAYLEVEL(4,"Using stdin for input\n");
-        *pfinput = stdin;
-        SET_BINARY_MODE(stdin);
-    }
-    else
-    {
-        *pfinput = fopen(input_filename, "rb");
-    }
-
-    if (!strcmp (output_filename, stdoutmark))
-    {
-        DISPLAYLEVEL(4,"Using stdout for output\n");
-        *pfoutput = stdout;
-        SET_BINARY_MODE(stdout);
-    }
-    else
-    {
-        /* Check if destination file already exists */
-        *pfoutput=0;
-        if (strcmp(output_filename,nulmark)) *pfoutput = fopen( output_filename, "rb" );
-        if (*pfoutput!=0)
-        {
-            fclose(*pfoutput);
-            if (!g_overwrite)
-            {
-                char ch;
-                if (g_displayLevel <= 1)   /* No interaction possible */
-                    EXM_THROW(11, "Operation aborted : %s already exists", output_filename);
-                DISPLAYLEVEL(2, "Warning : %s already exists\n", output_filename);
-                DISPLAYLEVEL(2, "Overwrite ? (Y/N) : ");
-                ch = (char)getchar();
-                if ((ch!='Y') && (ch!='y')) EXM_THROW(11, "Operation aborted : %s already exists", output_filename);
-            }
-        }
-        *pfoutput = fopen( output_filename, "wb" );
-    }
-
-    if ( *pfinput==0 ) EXM_THROW(12, "Pb opening src : %s", input_filename);
-    if ( *pfoutput==0) EXM_THROW(13, "Pb opening dst : %s", output_filename);
-}
-
-
 static U64 FIO_getFileSize(const char* infilename)
 {
    int r;
@@ -235,39 +190,182 @@ static U64 FIO_getFileSize(const char* infilename)
 }


-unsigned long long FIO_compressFilename(const char* output_filename, const char* input_filename, int cLevel)
+static int FIO_getFiles(FILE** fileOutPtr, FILE** fileInPtr,
+                        const char* dstFileName, const char* srcFileName)
 {
-    U64 filesize = 0;
-    U64 compressedfilesize = 0;
-    BYTE* inBuff;
-    BYTE* outBuff;
-    size_t inBuffSize = ZBUFF_recommendedCInSize();
-    size_t outBuffSize = ZBUFF_recommendedCOutSize();
-    FILE* finput;
-    FILE* foutput;
-    size_t sizeCheck, errorCode;
+    if (!strcmp (srcFileName, stdinmark))
+    {
+        DISPLAYLEVEL(4,"Using stdin for input\n");
+        *fileInPtr = stdin;
+        SET_BINARY_MODE(stdin);
+    }
+    else
+    {
+        *fileInPtr = fopen(srcFileName, "rb");
+    }
+
+    if ( *fileInPtr==0 )
+    {
+        DISPLAYLEVEL(1, "Unable to access file for processing: %s\n", srcFileName);
+        return 1;
+    }
+
+    if (!strcmp (dstFileName, stdoutmark))
+    {
+        DISPLAYLEVEL(4,"Using stdout for output\n");
+        *fileOutPtr = stdout;
+        SET_BINARY_MODE(stdout);
+    }
+    else
+    {
+        /* Check if destination file already exists */
+        if (!g_overwrite)
+        {
+            *fileOutPtr = fopen( dstFileName, "rb" );
+            if (*fileOutPtr != 0)
+            {
+                /* prompt for overwrite authorization */
+                int ch = 'N';
+                fclose(*fileOutPtr);
+                DISPLAY("Warning : %s already exists \n", dstFileName);
+                if ((g_displayLevel <= 1) || (*fileInPtr == stdin))
+                {
+                    /* No interaction possible */
+                    DISPLAY("Operation aborted : %s already exists \n", dstFileName);
+                    return 1;
+                }
+                DISPLAY("Overwrite ? (y/N) : ");
+                while((ch = getchar()) != '\n' && ch != EOF);   /* flush integrated */
+                if ((ch!='Y') && (ch!='y'))
+                {
+                    DISPLAY("No. Operation aborted : %s already exists \n", dstFileName);
+                    return 1;
+                }
+            }
+        }
+        *fileOutPtr = fopen( dstFileName, "wb" );
+    }
+
+    if (*fileOutPtr==0) EXM_THROW(13, "Pb opening %s", dstFileName);
+
+    return 0;
+}
+
+/*!FIO_loadFile
+*  creates a buffer, pointed by *bufferPtr,
+*  loads "filename" content into it
+*  up to MAX_DICT_SIZE bytes
+*/
+static size_t FIO_loadFile(void** bufferPtr, const char* fileName)
+{
+    FILE* fileHandle;
+    size_t readSize;
+    U64 fileSize;
+
+    *bufferPtr = NULL;
+    if (fileName == NULL)
+        return 0;
+
+    DISPLAYLEVEL(4,"Loading %s as dictionary \n", fileName);
+    fileHandle = fopen(fileName, "rb");
+    if (fileHandle==0) EXM_THROW(31, "Error opening file %s", fileName);
+    fileSize = FIO_getFileSize(fileName);
+    if (fileSize > MAX_DICT_SIZE)
+    {
+        int seekResult;
+        if (fileSize > 1 GB) EXM_THROW(32, "Dictionary file %s is too large", fileName);   /* avoid extreme cases */
+        DISPLAYLEVEL(2,"Dictionary %s is too large : using last %u bytes only \n", fileName, MAX_DICT_SIZE);
+        seekResult = fseek(fileHandle, (long int)(fileSize-MAX_DICT_SIZE), SEEK_SET);   /* use end of file */
+        if (seekResult != 0) EXM_THROW(33, "Error seeking into file %s", fileName);
+        fileSize = MAX_DICT_SIZE;
+    }
+    *bufferPtr = (BYTE*)malloc((size_t)fileSize);
+    if (*bufferPtr==NULL) EXM_THROW(34, "Allocation error : not enough memory for dictBuffer");
+    readSize = fread(*bufferPtr, 1, (size_t)fileSize, fileHandle);
+    if (readSize!=fileSize) EXM_THROW(35, "Error reading dictionary file %s", fileName);
+    fclose(fileHandle);
+    return (size_t)fileSize;
+}
+
+
+/* **********************************************************************
+*  Compression
+************************************************************************/
+typedef struct {
+    void*  srcBuffer;
+    size_t srcBufferSize;
+    void*  dstBuffer;
+    size_t dstBufferSize;
+    void*  dictBuffer;
+    size_t dictBufferSize;
    ZBUFF_CCtx* ctx;
+} cRess_t;
+
+static cRess_t FIO_createCResources(const char* dictFileName)
+{
+    cRess_t ress;
+
+    ress.ctx = ZBUFF_createCCtx();
+    if (ress.ctx == NULL) EXM_THROW(30, "Allocation error : can't create ZBUFF context");

    /* Allocate Memory */
-    ctx = ZBUFF_createCCtx();
-    inBuff  = (BYTE*)malloc(inBuffSize);
-    outBuff = (BYTE*)malloc(outBuffSize);
-    if (!inBuff || !outBuff || !ctx) EXM_THROW(21, "Allocation error : not enough memory");
+    ress.srcBufferSize = ZBUFF_recommendedCInSize();
+    ress.srcBuffer = malloc(ress.srcBufferSize);
+    ress.dstBufferSize = ZBUFF_recommendedCOutSize();
+    ress.dstBuffer = malloc(ress.dstBufferSize);
+    if (!ress.srcBuffer || !ress.dstBuffer) EXM_THROW(31, "Allocation error : not enough memory");
+
+    /* dictionary */
+    ress.dictBufferSize = FIO_loadFile(&(ress.dictBuffer), dictFileName);
+
+    return ress;
+}
+
+static void FIO_freeCResources(cRess_t ress)
+{
+    size_t errorCode;
+    free(ress.srcBuffer);
+    free(ress.dstBuffer);
+    free(ress.dictBuffer);
+    errorCode = ZBUFF_freeCCtx(ress.ctx);
+    if (ZBUFF_isError(errorCode)) EXM_THROW(38, "Error : can't release ZBUFF context resource : %s", ZBUFF_getErrorName(errorCode));
+}
+
+
+/*
+ * FIO_compressFilename_extRess()
+ * result : 0 : compression completed correctly
+ *          1 : missing or pb opening srcFileName
+ */
+static int FIO_compressFilename_extRess(cRess_t ress,
+                                        const char* dstFileName, const char* srcFileName,
+                                        int cLevel)
+{
+    FILE* srcFile;
+    FILE* dstFile;
+    U64 filesize = 0;
+    U64 compressedfilesize = 0;
+    size_t dictSize = ress.dictBufferSize;
+    size_t sizeCheck, errorCode;
+
+    /* File check */
+    if (FIO_getFiles(&dstFile, &srcFile, dstFileName, srcFileName)) return 1;

    /* init */
-    FIO_getFileHandles(&finput, &foutput, input_filename, output_filename);
-    filesize = FIO_getFileSize(input_filename);
-    errorCode = ZBUFF_compressInit_advanced(ctx, ZSTD_getParams(cLevel, filesize));
-    if (ZBUFF_isError(errorCode)) EXM_THROW(22, "Error initializing compression");
-    filesize = 0;
+    filesize = FIO_getFileSize(srcFileName) + dictSize;
+    errorCode = ZBUFF_compressInit_advanced(ress.ctx, ZSTD_getParams(cLevel, filesize));
+    if (ZBUFF_isError(errorCode)) EXM_THROW(21, "Error initializing compression");
+    errorCode = ZBUFF_compressWithDictionary(ress.ctx, ress.dictBuffer, ress.dictBufferSize);
+    if (ZBUFF_isError(errorCode)) EXM_THROW(22, "Error initializing dictionary");

    /* Main compression loop */
+    filesize = 0;
    while (1)
    {
        size_t inSize;

        /* Fill input Buffer */
-        inSize = fread(inBuff, (size_t)1, inBuffSize, finput);
+        inSize = fread(ress.srcBuffer, (size_t)1, ress.srcBufferSize, srcFile);
        if (inSize==0) break;
        filesize += inSize;
        DISPLAYUPDATE(2, "\rRead : %u MB  ", (U32)(filesize>>20));
@@ -275,8 +373,8 @@ unsigned long long FIO_compressFilename(const char* output_filename, const char*
        {
            /* Compress (buffered streaming ensures appropriate formatting) */
            size_t usedInSize = inSize;
-            size_t cSize = outBuffSize;
-            size_t result = ZBUFF_compressContinue(ctx, outBuff, &cSize, inBuff, &usedInSize);
+            size_t cSize = ress.dstBufferSize;
+            size_t result = ZBUFF_compressContinue(ress.ctx, ress.dstBuffer, &cSize, ress.srcBuffer, &usedInSize);
            if (ZBUFF_isError(result))
                EXM_THROW(23, "Compression error : %s ", ZBUFF_getErrorName(result));
            if (inSize != usedInSize)
@@ -284,8 +382,8 @@ unsigned long long FIO_compressFilename(const char* output_filename, const char*
                EXM_THROW(24, "Compression error : input block not fully consumed");

            /* Write cBlock */
-            sizeCheck = fwrite(outBuff, 1, cSize, foutput);
-            if (sizeCheck!=cSize) EXM_THROW(25, "Write error : cannot write compressed block into %s", output_filename);
+            sizeCheck = fwrite(ress.dstBuffer, 1, cSize, dstFile);
+            if (sizeCheck!=cSize) EXM_THROW(25, "Write error : cannot write compressed block into %s", dstFileName);
            compressedfilesize += cSize;
        }

@@ -294,12 +392,12 @@ unsigned long long FIO_compressFilename(const char* output_filename, const char*

    /* End of Frame */
    {
-        size_t cSize = outBuffSize;
-        size_t result = ZBUFF_compressEnd(ctx, outBuff, &cSize);
+        size_t cSize = ress.dstBufferSize;
+        size_t result = ZBUFF_compressEnd(ress.ctx, ress.dstBuffer, &cSize);
        if (result!=0) EXM_THROW(26, "Compression error : cannot create frame end");

-        sizeCheck = fwrite(outBuff, 1, cSize, foutput);
-        if (sizeCheck!=cSize) EXM_THROW(27, "Write error : cannot write frame end into %s", output_filename);
+        sizeCheck = fwrite(ress.dstBuffer, 1, cSize, dstFile);
+        if (sizeCheck!=cSize) EXM_THROW(27, "Write error : cannot write frame end into %s", dstFileName);
        compressedfilesize += cSize;
    }

@@ -309,49 +407,149 @@ unsigned long long FIO_compressFilename(const char* output_filename, const char*
        (unsigned long long) filesize, (unsigned long long) compressedfilesize, (double)compressedfilesize/filesize*100);

    /* clean */
-    free(inBuff);
-    free(outBuff);
-    ZBUFF_freeCCtx(ctx);
-    fclose(finput);
-    if (fclose(foutput)) EXM_THROW(28, "Write error : cannot properly close %s", output_filename);
+    fclose(srcFile);
+    if (fclose(dstFile)) EXM_THROW(28, "Write error : cannot properly close %s", dstFileName);

-    return compressedfilesize;
+    return 0;
 }


-unsigned long long FIO_decompressFrame(FILE* foutput, FILE* finput,
-                                       BYTE* inBuff, size_t inBuffSize, size_t alreadyLoaded,
-                                       BYTE* outBuff, size_t outBuffSize,
-                                       ZBUFF_DCtx* dctx)
+int FIO_compressFilename(const char* dstFileName, const char* srcFileName,
+                         const char* dictFileName, int compressionLevel)
+{
+    clock_t start, end;
+    cRess_t ress;
+    int issueWithSrcFile = 0;
+
+    /* Init */
+    start = clock();
+    ress = FIO_createCResources(dictFileName);
+
+    /* Compress File */
+    issueWithSrcFile += FIO_compressFilename_extRess(ress, dstFileName, srcFileName, compressionLevel);
+
+    /* Free resources */
+    FIO_freeCResources(ress);
+
+    /* Final Status */
+    end = clock();
+    {
+        double seconds = (double)(end - start) / CLOCKS_PER_SEC;
+        DISPLAYLEVEL(4, "Completed in %.2f sec \n", seconds);
+    }
+
+    return issueWithSrcFile;
+}
+
+
+#define FNSPACE 30
+int FIO_compressMultipleFilenames(const char** inFileNamesTable, unsigned nbFiles,
+                                  const char* suffix,
+                                  const char* dictFileName, int compressionLevel)
+{
+    unsigned u;
+    int missed_files = 0;
+    char* dstFileName = (char*)malloc(FNSPACE);
+    size_t dfnSize = FNSPACE;
+    const size_t suffixSize = strlen(suffix);
+    cRess_t ress;
+
+    /* init */
+    ress = FIO_createCResources(dictFileName);
+
+    /* loop on each file */
+    for (u=0; u<nbFiles; u++)
+    {
+        size_t ifnSize = strlen(inFileNamesTable[u]);
+        if (dfnSize <= ifnSize+suffixSize+1) { free(dstFileName); dfnSize = ifnSize + 20; dstFileName = (char*)malloc(dfnSize); }
+        strcpy(dstFileName, inFileNamesTable[u]);
+        strcat(dstFileName, suffix);
+
+        missed_files += FIO_compressFilename_extRess(ress, dstFileName, inFileNamesTable[u], compressionLevel);
+    }
+
+    /* Close & Free */
+    FIO_freeCResources(ress);
+    free(dstFileName);
+
+    return missed_files;
+}
+
+
+/* **************************************************************************
+*  Decompression
+****************************************************************************/
+typedef struct {
+    void*  srcBuffer;
+    size_t srcBufferSize;
+    void*  dstBuffer;
+    size_t dstBufferSize;
+    void*  dictBuffer;
+    size_t dictBufferSize;
+    ZBUFF_DCtx* dctx;
+} dRess_t;
+
+static dRess_t FIO_createDResources(const char* dictFileName)
+{
+    dRess_t ress;
+
+    /* init */
+    ress.dctx = ZBUFF_createDCtx();
+    if (ress.dctx==NULL) EXM_THROW(60, "Can't create ZBUFF decompression context");
+
+    /* Allocate Memory */
+    ress.srcBufferSize = ZBUFF_recommendedDInSize();
+    ress.srcBuffer = malloc(ress.srcBufferSize);
+    ress.dstBufferSize = ZBUFF_recommendedDOutSize();
+    ress.dstBuffer = malloc(ress.dstBufferSize);
+    if (!ress.srcBuffer || !ress.dstBuffer) EXM_THROW(61, "Allocation error : not enough memory");
+
+    /* dictionary */
+    ress.dictBufferSize = FIO_loadFile(&(ress.dictBuffer), dictFileName);
+
+    return ress;
+}
+
+static void FIO_freeDResources(dRess_t ress)
+{
+    size_t errorCode = ZBUFF_freeDCtx(ress.dctx);
+    if (ZBUFF_isError(errorCode)) EXM_THROW(69, "Error : can't free ZBUFF context resource : %s", ZBUFF_getErrorName(errorCode));
+    free(ress.srcBuffer);
+    free(ress.dstBuffer);
+    free(ress.dictBuffer);
+}
+
+
+unsigned long long FIO_decompressFrame(dRess_t ress,
+                                       FILE* foutput, FILE* finput, size_t alreadyLoaded)
 {
    U64    frameSize = 0;
    size_t readSize=alreadyLoaded;

    /* Main decompression Loop */
-    ZBUFF_decompressInit(dctx);
+    ZBUFF_decompressInit(ress.dctx);
+    ZBUFF_decompressWithDictionary(ress.dctx, ress.dictBuffer, ress.dictBufferSize);
    while (1)
    {
        /* Decode */
        size_t sizeCheck;
-        size_t inSize=readSize, decodedSize=outBuffSize;
-        size_t inStart=0;
-        size_t toRead = ZBUFF_decompressContinue(dctx, outBuff, &decodedSize, inBuff+inStart, &inSize);
+        size_t inSize=readSize, decodedSize=ress.dstBufferSize;
+        size_t toRead = ZBUFF_decompressContinue(ress.dctx, ress.dstBuffer, &decodedSize, ress.srcBuffer, &inSize);
        if (ZBUFF_isError(toRead)) EXM_THROW(36, "Decoding error : %s", ZBUFF_getErrorName(toRead));
        readSize -= inSize;
-        inStart += inSize;

        /* Write block */
-        sizeCheck = fwrite(outBuff, 1, decodedSize, foutput);
+        sizeCheck = fwrite(ress.dstBuffer, 1, decodedSize, foutput);
        if (sizeCheck != decodedSize) EXM_THROW(37, "Write error : unable to write data block to destination file");
        frameSize += decodedSize;
        DISPLAYUPDATE(2, "\rDecoded : %u MB...     ", (U32)(frameSize>>20) );

        if (toRead == 0) break;
-        if (readSize) continue;   /* still some data left within inBuff */
+        if (readSize) EXM_THROW(38, "Decoding error : should consume entire input");

        /* Fill input buffer */
-        if (toRead > inBuffSize) EXM_THROW(34, "too large block");
-        readSize = fread(inBuff, 1, toRead, finput);
+        if (toRead > ress.srcBufferSize) EXM_THROW(34, "too large block");
+        readSize = fread(ress.srcBuffer, 1, toRead, finput);
        if (readSize != toRead) EXM_THROW(35, "Read error");
    }

@@ -359,57 +557,96 @@ unsigned long long FIO_decompressFrame(FILE* foutput, FILE* finput,
 }


-unsigned long long FIO_decompressFilename(const char* output_filename, const char* input_filename)
+static int FIO_decompressFile_extRess(dRess_t ress,
+                                      const char* dstFileName, const char* srcFileName)
 {
-    FILE* finput, *foutput;
-    BYTE* inBuff=NULL;
-    size_t inBuffSize = ZBUFF_recommendedDInSize();
-    BYTE* outBuff=NULL;
-    size_t outBuffSize = ZBUFF_recommendedDOutSize();
-    U64   filesize = 0;
-    size_t toRead;
-
+    unsigned long long filesize = 0;
+    FILE* srcFile;
+    FILE* dstFile;

    /* Init */
-    ZBUFF_DCtx* dctx = ZBUFF_createDCtx();
-    FIO_getFileHandles(&finput, &foutput, input_filename, output_filename);
-
-    /* Allocate Memory (if needed) */
-    inBuff  = (BYTE*)malloc(inBuffSize);
-    outBuff  = (BYTE*)malloc(outBuffSize);
-    if (!inBuff || !outBuff) EXM_THROW(33, "Allocation error : not enough memory");
+    if (FIO_getFiles(&dstFile, &srcFile, dstFileName, srcFileName)) return 1;

    /* for each frame */
    for ( ; ; )
    {
        size_t sizeCheck;
        /* check magic number -> version */
-        toRead = 4;
-        sizeCheck = fread(inBuff, (size_t)1, toRead, finput);
+        size_t toRead = 4;
+        sizeCheck = fread(ress.srcBuffer, (size_t)1, toRead, srcFile);
        if (sizeCheck==0) break;   /* no more input */
        if (sizeCheck != toRead) EXM_THROW(31, "Read error : cannot read header");
 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT==1)
-        if (ZSTD_isLegacy(MEM_readLE32(inBuff)))
+        if (ZSTD_isLegacy(MEM_readLE32(ress.srcBuffer)))
        {
-            filesize += FIO_decompressLegacyFrame(foutput, finput, MEM_readLE32(inBuff));
+            filesize += FIO_decompressLegacyFrame(dstFile, srcFile, MEM_readLE32(ress.srcBuffer));
            continue;
        }
 #endif   /* ZSTD_LEGACY_SUPPORT */

-        filesize += FIO_decompressFrame(foutput, finput, inBuff, inBuffSize, toRead, outBuff, outBuffSize, dctx);
+        filesize += FIO_decompressFrame(ress, dstFile, srcFile, toRead);
    }

+    /* Final Status */
    DISPLAYLEVEL(2, "\r%79s\r", "");
-    DISPLAYLEVEL(2, "Decoded %llu bytes   \n", (long long unsigned)filesize);
+    DISPLAYLEVEL(2, "Successfully decoded %llu bytes \n", filesize);

-    /* clean */
-    free(inBuff);
-    free(outBuff);
-    ZBUFF_freeDCtx(dctx);
-    fclose(finput);
-    if (fclose(foutput)) EXM_THROW(38, "Write error : cannot properly close %s", output_filename);
+    /* Close */
+    fclose(srcFile);
+    if (fclose(dstFile)) EXM_THROW(38, "Write error : cannot properly close %s", dstFileName);

-    return filesize;
+    return 0;
 }


+int FIO_decompressFilename(const char* dstFileName, const char* srcFileName,
+                           const char* dictFileName)
+{
+    int missingFiles = 0;
+    dRess_t ress = FIO_createDResources(dictFileName);
+
+    missingFiles += FIO_decompressFile_extRess(ress, dstFileName, srcFileName);
+
+    FIO_freeDResources(ress);
+    return missingFiles;
+}
+
+
+#define MAXSUFFIXSIZE 8
+int FIO_decompressMultipleFilenames(const char** srcNamesTable, unsigned nbFiles,
+                                    const char* suffix,
+                                    const char* dictFileName)
+{
+    unsigned u;
+    int skippedFiles = 0;
+    int missingFiles = 0;
+    char* dstFileName = (char*)malloc(FNSPACE);
+    size_t dfnSize = FNSPACE;
+    const size_t suffixSize = strlen(suffix);
+    dRess_t ress;
+
+	if (dstFileName==NULL) EXM_THROW(70, "not enough memory for dstFileName");
+    ress = FIO_createDResources(dictFileName);
+
+    for (u=0; u<nbFiles; u++)
+    {
+        const char* srcFileName = srcNamesTable[u];
+        size_t sfnSize = strlen(srcFileName);
+        const char* suffixPtr = srcFileName + sfnSize - suffixSize;
+        if (dfnSize <= sfnSize-suffixSize+1) { free(dstFileName); dfnSize = sfnSize + 20; dstFileName = (char*)malloc(dfnSize); if (dstFileName==NULL) EXM_THROW(71, "not enough memory for dstFileName"); }
+        if (sfnSize <= suffixSize  ||  strcmp(suffixPtr, suffix) != 0)
+        {
+            DISPLAYLEVEL(1, "File extension doesn't match expected extension (%4s); will not process file: %s\n", suffix, srcFileName);
+            skippedFiles++;
+            continue;
+        }
+        memcpy(dstFileName, srcFileName, sfnSize - suffixSize);
+        dstFileName[sfnSize-suffixSize] = '\0';
+
+        missingFiles += FIO_decompressFile_extRess(ress, dstFileName, srcFileName);
+    }
+
+    FIO_freeDResources(ress);
+    free(dstFileName);
+    return missingFiles + skippedFiles;
+}
@@ -50,19 +50,35 @@ void FIO_setNotificationLevel(unsigned level);


 /* *************************************
-*  Stream/File functions
+*  Single File functions
 ***************************************/
-unsigned long long FIO_compressFilename (const char* outfilename, const char* infilename, int compressionLevel);
-unsigned long long FIO_decompressFilename (const char* outfilename, const char* infilename);
+int FIO_compressFilename (const char* outfilename, const char* infilename, const char* dictFileName, int compressionLevel);
+int FIO_decompressFilename (const char* outfilename, const char* infilename, const char* dictFileName);
 /**
 FIO_compressFilename :
-    @result : size of compressed file
+    @result : 0 == ok;  1 == pb with src file.

 FIO_decompressFilename :
-    @result : size of regenerated file
+    @result : 0 == ok;  1 == pb with src file.
 */


+/* *************************************
+*  Multiple File functions
+***************************************/
+int FIO_compressMultipleFilenames(const char** srcNamesTable, unsigned nbFiles,
+                                  const char* suffix,
+                                  const char* dictFileName, int compressionLevel);
+int FIO_decompressMultipleFilenames(const char** srcNamesTable, unsigned nbFiles,
+                                    const char* suffix,
+                                    const char* dictFileName);
+/**
+FIO_compressMultipleFilenames :
+    @result : nb of missing files
+FIO_decompressMultipleFilenames :
+    @result : nb of missing or skipped files
+*/
+

 #if defined (__cplusplus)
 }
@@ -235,7 +235,7 @@ size_t local_ZSTD_decodeLiteralsBlock(void* dst, size_t dstSize, void* buff2, co

 size_t local_ZSTD_decodeSeqHeaders(void* dst, size_t dstSize, void* buff2, const void* src, size_t srcSize)
 {
-    U32 DTableML[1<<11], DTableLL[1<<10], DTableOffb[1<<9];
+    U32 DTableML[FSE_DTABLE_SIZE_U32(10)], DTableLL[FSE_DTABLE_SIZE_U32(10)], DTableOffb[FSE_DTABLE_SIZE_U32(9)];   /* MLFSELog, LLFSELog and OffFSELog are not public values */
    const BYTE* dumps;
    size_t length;
    int nbSeq;
@@ -245,7 +245,6 @@ size_t local_ZSTD_decodeSeqHeaders(void* dst, size_t dstSize, void* buff2, const



-
 /*********************************************************
 *  Bench functions
 *********************************************************/
@@ -429,7 +428,7 @@ int benchFiles(char** fileNamesTable, int nbFiles, U32 benchNb)
            return 11;
        }

-        // Memory allocation & restrictions
+        /* Memory allocation & restrictions */
        inFileSize = BMK_GetFileSize(inFileName);
        benchedSize = (size_t) BMK_findMaxMem(inFileSize*3) / 3;
        if ((U64)benchedSize > inFileSize) benchedSize = (size_t)inFileSize;
@@ -342,6 +342,7 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
                    blockTable[blockNb].cSize = ZSTD_compress_advanced(ctx,
                                                    blockTable[blockNb].cPtr,  blockTable[blockNb].cRoom,
                                                    blockTable[blockNb].srcPtr, blockTable[blockNb].srcSize,
+                                                    NULL, 0,
                                                    params);
                nbLoops++;
            }
@@ -0,0 +1,104 @@
+#!/bin/sh -e
+
+die() {
+    echo "$@" 1>&2
+    exit 1
+}
+
+roundTripTest() {
+    if [ -n "$3" ]; then
+        local c="$3"
+        local p="$2"
+    else
+        local c="$2"
+    fi
+
+    rm -f tmp1 tmp2
+    echo "roundTripTest: ./datagen $1 $p | $ZSTD -v$c | $ZSTD -d"
+    ./datagen $1 $p | md5sum > tmp1
+    ./datagen $1 $p | $ZSTD -v$c | $ZSTD -d  | md5sum > tmp2
+    diff -q tmp1 tmp2
+}
+
+[ -n "$ZSTD" ] || die "ZSTD variable must be defined!"
+
+printf "\n**** frame concatenation **** "
+
+echo "hello " > hello.tmp
+echo "world!" > world.tmp
+cat hello.tmp world.tmp > helloworld.tmp
+$ZSTD hello.tmp > hello.zstd
+$ZSTD world.tmp > world.zstd
+cat hello.zstd world.zstd > helloworld.zstd
+$ZSTD -df helloworld.zstd > result.tmp
+cat result.tmp
+sdiff helloworld.tmp result.tmp
+rm ./*.tmp ./*.zstd
+
+echo frame concatenation test completed
+
+echo "**** flush write error test **** "
+
+echo "echo foo | $ZSTD > /dev/full"
+echo foo | $ZSTD > /dev/full && die "write error not detected!"
+echo "echo foo | $ZSTD | $ZSTD -d > /dev/full"
+echo foo | $ZSTD | $ZSTD -d > /dev/full && die "write error not detected!"
+
+
+echo "*** dictionary tests *** "
+
+./datagen > tmpDict
+./datagen -g1M | md5sum > tmp1
+./datagen -g1M | $ZSTD -D tmpDict | $ZSTD -D tmpDict -dv | md5sum > tmp2
+diff -q tmp1 tmp2
+
+echo "*** multiple files tests *** "
+
+./datagen -s1        > tmp1 2> /dev/null
+./datagen -s2 -g100K > tmp2 2> /dev/null
+./datagen -s3 -g1M   > tmp3 2> /dev/null
+$ZSTD -f -m tmp*
+ls -ls tmp*
+rm tmp1 tmp2 tmp3
+$ZSTD -df -m *.zst
+ls -ls tmp*
+$ZSTD -f -m tmp1 notHere tmp2 && die "missing file not detected!"
+rm tmp*
+
+echo "**** zstd round-trip tests **** "
+
+roundTripTest
+roundTripTest '' 6
+
+if [ "$1" != "--test-large-data" ]; then
+    echo "Skipping large data tests"
+    exit 0
+fi
+
+roundTripTest -g270000000 1
+roundTripTest -g270000000 2
+roundTripTest -g270000000 3
+
+roundTripTest -g140000000 -P60 4
+roundTripTest -g140000000 -P60 5
+roundTripTest -g140000000 -P60 6
+
+roundTripTest -g70000000 -P70 7
+roundTripTest -g70000000 -P70 8
+roundTripTest -g70000000 -P70 9
+
+roundTripTest -g35000000 -P75 10
+roundTripTest -g35000000 -P75 11
+roundTripTest -g35000000 -P75 12
+
+roundTripTest -g18000000 -P80 13
+roundTripTest -g18000000 -P80 14
+roundTripTest -g18000000 -P80 15
+roundTripTest -g18000000 -P80 16
+roundTripTest -g18000000 -P80 17
+
+roundTripTest -g50000000 -P94 18
+roundTripTest -g50000000 -P94 19
+
+roundTripTest -g99000000 -P99 20
+roundTripTest -g6000000000 -P99 q
@@ -161,6 +161,7 @@ static int basicUnitTests(U32 seed, double compressibility)
    ZBUFF_compressInit(zc, 1);
    readSize = CNBufferSize;
    genSize = compressedBufferSize;
+    ZBUFF_compressWithDictionary(zc, CNBuffer, 128 KB);
    result = ZBUFF_compressContinue(zc, compressedBuffer, &genSize, CNBuffer, &readSize);
    if (ZBUFF_isError(result)) goto _output_error;
    if (readSize != CNBufferSize) goto _output_error;   /* entire input should be consumed */
@@ -174,6 +175,7 @@ static int basicUnitTests(U32 seed, double compressibility)
    /* Basic decompression test */
    DISPLAYLEVEL(4, "test%3i : decompress %u bytes : ", testNb++, COMPRESSIBLE_NOISE_LENGTH);
    ZBUFF_decompressInit(zd);
+    ZBUFF_decompressWithDictionary(zd, CNBuffer, 128 KB);
    readSize = cSize;
    genSize = CNBufferSize;
    result = ZBUFF_decompressContinue(zd, decodedBuffer, &genSize, compressedBuffer, &readSize);
@@ -244,7 +246,6 @@ int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibilit
    U32 coreSeed = seed, lseed = 0;
    ZBUFF_CCtx* zc;
    ZBUFF_DCtx* zd;
-    XXH64_state_t crc64;
    U32 startTime = FUZ_GetMilliStart();

    /* allocation */
@@ -280,10 +281,12 @@ int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibilit
    for ( ; (testNb <= nbTests) || (FUZ_GetMilliSpan(startTime) < g_testTime); testNb++ )
    {
        size_t sampleSize, sampleStart;
-        size_t cSize;
+        const BYTE* dict;
+        size_t cSize, dictSize;
        size_t maxTestSize, totalTestSize, readSize, totalCSize, genSize, totalGenSize;
        size_t errorCode;
        U32 sampleSizeLog, buffNb, n, nbChunks;
+        XXH64_state_t crc64;
        U64 crcOrig, crcDest;

        /* init */
@@ -316,6 +319,15 @@ int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibilit
        maxTestSize = (size_t)1 << sampleSizeLog;
        maxTestSize += FUZ_rand(&lseed) & (maxTestSize-1);
        ZBUFF_compressInit(zc, (FUZ_rand(&lseed) % (20 - (sampleSizeLog/3))) + 1);
+
+        sampleSizeLog = FUZ_rand(&lseed) % maxSampleLog;
+        sampleSize = (size_t)1 << sampleSizeLog;
+        sampleSize += FUZ_rand(&lseed) & (sampleSize-1);
+        sampleStart = FUZ_rand(&lseed) % (srcBufferSize - sampleSize);
+        dict = srcBuffer + sampleStart;
+        dictSize = sampleSize;
+        ZBUFF_compressWithDictionary(zc, dict, dictSize);
+
        totalTestSize = 0;
        cSize = 0;
        for (n=0; n<nbChunks; n++)
@@ -363,6 +375,7 @@ int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibilit

        /* multi - fragments decompression test */
        ZBUFF_decompressInit(zd);
+        ZBUFF_decompressWithDictionary(zd, dict, dictSize);
        totalCSize = 0;
        totalGenSize = 0;
        while (totalCSize < cSize)
@@ -31,12 +31,21 @@ is equivalent to
 It is based on the \fBLZ77\fR family, with FSE & huff0 entropy stage.
 zstd offers compression speed > 200 MB/s per core.
 It also features a fast decoder, with speed > 500 MB/s per core.
+
+\fBzstd\fR command line is generally similar to gzip, but features the following differences :
+ - Original files are preserved
+ - By default, \fBzstd file1 file2\fR means : compress file1 \fBinto\fR file2.
+     Use \fB-m\fR command if you want : compress file1 into file1.zstd and file2 into file2.zst
+ - By default, when compressing files, \fBzstd\fR displays advancement notification and result summary.
+     Use \fB-q\fR to turn them off
+
+
 \fBzstd\fR supports the following options :

 .SH OPTIONS
 .TP
-.B \-1
- fast compression (default)
+.B \-#
+ # compression level [1-19](default:1)
 .TP
 .B \-d
 decompression
@@ -44,6 +53,14 @@ It also features a fast decoder, with speed > 500 MB/s per core.
 .B \-f
 overwrite output without prompting
 .TP
+.BR \-m ", " --multiple
+ multiple files mode
+ In this mode, multiple files on the command line means compression or decompression of each named file
+ Notifications are also turned off by default
+.TP
+.B \-D
+ Use next file as dictionary content for compress / decompression
+.TP
 .BR \-h/\-H ", " --help
 display help/long help and exit
 .TP
@@ -53,20 +70,17 @@ It also features a fast decoder, with speed > 500 MB/s per core.
 .BR \-v ", " --verbose
 verbose mode
 .TP
-.B \-q
- suppress warnings; specify twice to suppress errors too
+.BR \-q ", " --quiet
+ suppress warnings and notifications; specify twice to suppress errors too
 .TP
-.B \-c
+.B \-c 
 force write to standard output, even if it is the console
 .TP
-.B \-t
- test compressed file integrity
-.TP
 .B \-z
 force compression
 .TP
-.B \-b
- benchmark file(s)
+.B \-b#
+ benchmark file(s) using compression level #
 .TP
 .B \-i#
 iteration loops [1-9](default : 3), benchmark mode only
@@ -43,23 +43,26 @@
 #include <stdio.h>    /* fprintf, getchar */
 #include <stdlib.h>   /* exit, calloc, free */
 #include <string.h>   /* strcmp, strlen */
-#include "bench.h"    /* BMK_benchFiles, BMK_SetNbIterations */
 #include "fileio.h"
+#ifndef ZSTD_NOBENCH
+#  include "bench.h"  /* BMK_benchFiles, BMK_SetNbIterations */
+#endif
+#include "zstd.h"     /* ZSTD version numbers */


 /**************************************
 *  OS-specific Includes
 **************************************/
 #if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__)
-#  include <fcntl.h>    // _O_BINARY
-#  include <io.h>       // _setmode, _isatty
+#  include <fcntl.h>    /* _O_BINARY */
+#  include <io.h>       /* _setmode, _isatty */
 #  ifdef __MINGW32__
   /* int _fileno(FILE *stream);   // seems no longer useful // MINGW somehow forgets to include this windows declaration into <stdio.h> */
 #  endif
 #  define SET_BINARY_MODE(file) _setmode(_fileno(file), _O_BINARY)
 #  define IS_CONSOLE(stdStream) _isatty(_fileno(stdStream))
 #else
-#  include <unistd.h>   // isatty
+#  include <unistd.h>   /* isatty */
 #  define SET_BINARY_MODE(file)
 #  define IS_CONSOLE(stdStream) isatty(fileno(stdStream))
 #endif
@@ -70,7 +73,9 @@
 **************************************/
 #define COMPRESSOR_NAME "zstd command line interface"
 #ifndef ZSTD_VERSION
-#  define ZSTD_VERSION "v0.4.2"
+#  define QUOTE(str) #str
+#  define EXPAND_AND_QUOTE(str) QUOTE(str)
+#  define ZSTD_VERSION "v" EXPAND_AND_QUOTE(ZSTD_VERSION_MAJOR) "." EXPAND_AND_QUOTE(ZSTD_VERSION_MINOR) "." EXPAND_AND_QUOTE(ZSTD_VERSION_RELEASE)
 #endif
 #define AUTHOR "Yann Collet"
 #define WELCOME_MESSAGE "*** %s %i-bits %s, by %s (%s) ***\n", COMPRESSOR_NAME, (int)(sizeof(void*)*8), ZSTD_VERSION, AUTHOR, __DATE__
@@ -118,8 +123,7 @@ static int usage(const char* programName)
    DISPLAY( "input   : a filename\n");
    DISPLAY( "          with no FILE, or when FILE is - , read standard input\n");
    DISPLAY( "Arguments :\n");
-    DISPLAY( " -1     : Fast compression (default) \n");
-    DISPLAY( " -19    : High compression \n");
+    DISPLAY( " -#     : # compression level (1-19, default:1) \n");
    DISPLAY( " -d     : decompression (default for %s extension)\n", ZSTD_EXTENSION);
    //DISPLAY( " -z     : force compression\n");
    DISPLAY( " -f     : overwrite output without prompting \n");
@@ -136,8 +140,9 @@ static int usage_advanced(const char* programName)
    DISPLAY( " -V     : display Version number and exit\n");
    DISPLAY( " -v     : verbose mode\n");
    DISPLAY( " -q     : suppress warnings; specify twice to suppress errors too\n");
+    DISPLAY( " -m     : multiple input filenames mode \n");
    DISPLAY( " -c     : force write to standard output, even if it is the console\n");
-    //DISPLAY( " -t     : test compressed file integrity\n");
+    DISPLAY( " -D file: use file content as Dictionary \n");
 #ifndef ZSTD_NOBENCH
    DISPLAY( "Benchmark arguments :\n");
    DISPLAY( " -b#    : benchmark file(s), using # compression level (default : 1) \n");
@@ -171,21 +176,25 @@ int main(int argCount, const char** argv)
        bench=0,
        decode=0,
        forceStdout=0,
-        main_pause=0;
+        main_pause=0,
+        nextEntryIsDictionary=0,
+        multiple=0,
+        operationResult=0;
    unsigned cLevel = 1;
+    const char** filenameTable = (const char**)malloc(argCount * sizeof(const char*));   /* argCount >= 1 */
+    unsigned filenameIdx = 0;
    const char* programName = argv[0];
-    const char* inFileName = NULL;
    const char* outFileName = NULL;
+    const char* dictFileName = NULL;
    char* dynNameSpace = NULL;
    const char extension[] = ZSTD_EXTENSION;
-    unsigned fileNameStart = 0;
-    unsigned nbFiles = 0;
    int rangeBench = 1;

    /* init */
-    (void)rangeBench; (void)nbFiles; (void)fileNameStart;   /* not used when ZSTD_NOBENCH set */
+    (void)rangeBench;   /* not used when ZSTD_NOBENCH set */
+    if (filenameTable==NULL) { DISPLAY("not enough memory\n"); exit(1); }
    displayOut = stderr;
-    /* Pick out basename component. Don't rely on stdlib because of conflicting behavior. */
+    /* Pick out program name from path. Don't rely on stdlib because of conflicting behavior */
    for (i = (int)strlen(programName); i > 0; i--) { if (programName[i] == '/') { i++; break; } }
    programName += i;

@@ -203,7 +212,9 @@ int main(int argCount, const char** argv)
        /* long commands (--long-word) */
        if (!strcmp(argument, "--version")) { displayOut=stdout; DISPLAY(WELCOME_MESSAGE); return 0; }
        if (!strcmp(argument, "--help")) { displayOut=stdout; return usage_advanced(programName); }
+        if (!strcmp(argument, "--multiple")) { multiple=1; continue; }
        if (!strcmp(argument, "--verbose")) { displayLevel=4; continue; }
+        if (!strcmp(argument, "--quiet")) { displayLevel--; continue; }

        /* Decode commands (note : aggregated commands are allowed) */
        if (argument[0]=='-')
@@ -211,9 +222,8 @@ int main(int argCount, const char** argv)
            /* '-' means stdin/stdout */
            if (argument[1]==0)
            {
-                if (!inFileName) inFileName=stdinmark;
-                else outFileName=stdoutmark;
-                continue;
+                if (!filenameIdx) { filenameIdx=1, filenameTable[0]=stdinmark; continue; }
+                outFileName=stdoutmark; continue;
            }

            argument++;
@@ -246,11 +256,17 @@ int main(int argCount, const char** argv)
                    /* Decoding */
                case 'd': decode=1; argument++; break;

+                    /* Multiple input files */
+                case 'm': multiple=1; argument++; break;
+
                    /* Force stdout, even if stdout==console */
                case 'c': forceStdout=1; outFileName=stdoutmark; displayLevel=1; argument++; break;

-                    // Test
-                //case 't': decode=1; LZ4IO_setOverwrite(1); output_filename=nulmark; break;
+                    /* Use file content as dictionary */
+                case 'D': nextEntryIsDictionary = 1; argument++; break;
+
+                    /* Test -- not implemented */
+                /* case 't': decode=1; LZ4IO_setOverwrite(1); output_filename=nulmark; break; */

                    /* Overwrite */
                case 'f': FIO_overwriteMode(); argument++; break;
@@ -261,7 +277,7 @@ int main(int argCount, const char** argv)
                    /* Quiet mode */
                case 'q': displayLevel--; argument++; break;

-                    /* keep source file (default anyway, so useless; only for xz/lzma compatibility) */
+                    /* keep source file (default anyway, so useless; for gzip/xz compatibility) */
                case 'k': argument++; break;

 #ifndef ZSTD_NOBENCH
@@ -310,16 +326,16 @@ int main(int argCount, const char** argv)
            continue;
        }

-        /* first provided filename is input */
-        if (!inFileName) { inFileName = argument; fileNameStart = i; nbFiles = argCount-i; continue; }
-
-        /* second provided filename is output */
-        if (!outFileName)
+        /* dictionary */
+        if (nextEntryIsDictionary)
        {
-            outFileName = argument;
-            if (!strcmp (outFileName, nullString)) outFileName = nulmark;
+            nextEntryIsDictionary = 0;
+            dictFileName = argument;
            continue;
        }
+
+        /* add filename to list */
+        filenameTable[filenameIdx++] = argument;
    }

    /* Welcome message (if verbose) */
@@ -329,27 +345,28 @@ int main(int argCount, const char** argv)
    if (bench)
    {
 #ifndef ZSTD_NOBENCH
-        BMK_benchFiles(argv+fileNameStart, nbFiles, cLevel*rangeBench);
+        BMK_benchFiles(filenameTable, filenameIdx, dictFileName, cLevel*rangeBench);
 #endif
        goto _end;
    }

    /* No input filename ==> use stdin */
-    if(!inFileName) { inFileName=stdinmark; }
+    if(!filenameIdx) filenameIdx=1, filenameTable[0]=stdinmark;

    /* Check if input defined as console; trigger an error in this case */
-    if (!strcmp(inFileName, stdinmark) && IS_CONSOLE(stdin) ) return badusage(programName);
+    if (!strcmp(filenameTable[0], stdinmark) && IS_CONSOLE(stdin) ) return badusage(programName);

    /* No output filename ==> try to select one automatically (when possible) */
-    while (!outFileName)
+    if (filenameIdx>=2) outFileName = filenameTable[1];
+    while (!outFileName)   /* while : just to allow break statement */
    {
        if (!IS_CONSOLE(stdout)) { outFileName=stdoutmark; break; }   /* Default to stdout whenever possible (i.e. not a console) */
        if (!decode)   /* compression to file */
        {
-            size_t l = strlen(inFileName);
+            size_t l = strlen(filenameTable[0]);
            dynNameSpace = (char*)calloc(1,l+5);
            if (dynNameSpace==NULL) { DISPLAY("not enough memory\n"); exit(1); }
-            strcpy(dynNameSpace, inFileName);
+            strcpy(dynNameSpace, filenameTable[0]);
            strcpy(dynNameSpace+l, ZSTD_EXTENSION);
            outFileName = dynNameSpace;
            DISPLAYLEVEL(2, "Compressed filename will be : %s \n", outFileName);
@@ -357,8 +374,8 @@ int main(int argCount, const char** argv)
        }
        /* decompression to file (automatic name will work only if input filename has correct format extension) */
        {
-            size_t filenameSize = strlen(inFileName);
-            if (strcmp(inFileName + (filenameSize-4), extension))
+            size_t filenameSize = strlen(filenameTable[0]);
+            if (strcmp(filenameTable[0] + (filenameSize-4), extension))
            {
                 DISPLAYLEVEL(1, "unknown suffix - cannot determine destination filename\n");
                 return badusage(programName);
@@ -366,7 +383,7 @@ int main(int argCount, const char** argv)
            dynNameSpace = (char*)calloc(1,filenameSize+1);
            if (dynNameSpace==NULL) { DISPLAY("not enough memory\n"); exit(1); }
            outFileName = dynNameSpace;
-            strcpy(dynNameSpace, inFileName);
+            strcpy(dynNameSpace, filenameTable[0]);
            dynNameSpace[filenameSize-4]=0;
            DISPLAYLEVEL(2, "Decoding file %s \n", outFileName);
        }
@@ -375,18 +392,36 @@ int main(int argCount, const char** argv)
    /* Check if output is defined as console; trigger an error in this case */
    if (!strcmp(outFileName,stdoutmark) && IS_CONSOLE(stdout) && !forceStdout) return badusage(programName);

-    /* No warning message in pure pipe mode (stdin + stdout) */
-    if (!strcmp(inFileName, stdinmark) && !strcmp(outFileName,stdoutmark) && (displayLevel==2)) displayLevel=1;
+    /* No warning message in pure pipe mode (stdin + stdout) or multiple mode */
+    if (!strcmp(filenameTable[0], stdinmark) && !strcmp(outFileName,stdoutmark) && (displayLevel==2)) displayLevel=1;
+    if (multiple && (displayLevel==2)) displayLevel=1;
+
+    if ((!multiple) && (filenameIdx>2))
+    {
+        DISPLAY("Too many files on the command line (%u > 2). Do you mean -m ? \n", filenameIdx);
+        return filenameIdx;
+    }

    /* IO Stream/File */
    FIO_setNotificationLevel(displayLevel);
    if (decode)
-        FIO_decompressFilename(outFileName, inFileName);
+    {
+      if (multiple)
+        operationResult = FIO_decompressMultipleFilenames(filenameTable, filenameIdx, ZSTD_EXTENSION, dictFileName);
+      else
+        operationResult = FIO_decompressFilename(outFileName, filenameTable[0], dictFileName);
+    }
    else
-        FIO_compressFilename(outFileName, inFileName, cLevel);
+    {
+        if (multiple)
+          operationResult = FIO_compressMultipleFilenames(filenameTable, filenameIdx, ZSTD_EXTENSION, dictFileName, cLevel);
+        else
+          operationResult = FIO_compressFilename(outFileName, filenameTable[0], dictFileName, cLevel);
+    }

 _end:
    if (main_pause) waitEnter();
    free(dynNameSpace);
-    return 0;
+    free((void*)filenameTable);
+    return operationResult;
 }
@@ -27,26 +27,26 @@
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v110</PlatformToolset>
+    <PlatformToolset>v120</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v110</PlatformToolset>
+    <PlatformToolset>v120</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v110</PlatformToolset>
+    <PlatformToolset>v120</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v110</PlatformToolset>
+    <PlatformToolset>v120</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
@@ -111,7 +111,7 @@
      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <TreatWarningAsError>true</TreatWarningAsError>
      <EnablePREfast>true</EnablePREfast>
-      <AdditionalOptions>/analyze:stacksize19000 %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>/analyze:stacksize25000 %(AdditionalOptions)</AdditionalOptions>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
@@ -129,7 +129,7 @@
      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <EnablePREfast>true</EnablePREfast>
      <TreatWarningAsError>true</TreatWarningAsError>
-      <AdditionalOptions>/analyze:stacksize19000 %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>/analyze:stacksize25000 %(AdditionalOptions)</AdditionalOptions>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
@@ -149,7 +149,7 @@
      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <TreatWarningAsError>true</TreatWarningAsError>
      <EnablePREfast>true</EnablePREfast>
-      <AdditionalOptions>/analyze:stacksize19000 %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>/analyze:stacksize25000 %(AdditionalOptions)</AdditionalOptions>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
@@ -27,26 +27,26 @@
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v110</PlatformToolset>
+    <PlatformToolset>v120</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v110</PlatformToolset>
+    <PlatformToolset>v120</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v110</PlatformToolset>
+    <PlatformToolset>v120</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v110</PlatformToolset>
+    <PlatformToolset>v120</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
@@ -111,7 +111,7 @@
      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <TreatWarningAsError>true</TreatWarningAsError>
      <EnablePREfast>true</EnablePREfast>
-      <AdditionalOptions>/analyze:stacksize19000 %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>/analyze:stacksize25000 %(AdditionalOptions)</AdditionalOptions>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
@@ -129,7 +129,7 @@
      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <EnablePREfast>true</EnablePREfast>
      <TreatWarningAsError>true</TreatWarningAsError>
-      <AdditionalOptions>/analyze:stacksize19000 %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>/analyze:stacksize25000 %(AdditionalOptions)</AdditionalOptions>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
@@ -149,7 +149,7 @@
      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <TreatWarningAsError>true</TreatWarningAsError>
      <EnablePREfast>true</EnablePREfast>
-      <AdditionalOptions>/analyze:stacksize19000 %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>/analyze:stacksize25000 %(AdditionalOptions)</AdditionalOptions>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
@@ -1,12 +1,16 @@

 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Express 2012 for Windows Desktop
+# Visual Studio 14
+VisualStudioVersion = 14.0.24720.0
+MinimumVisualStudioVersion = 10.0.40219.1
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "zstd", "zstd\zstd.vcxproj", "{4E52A41A-F33B-4C7A-8C36-A1A6B4F4277C}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fuzzer", "fuzzer\fuzzer.vcxproj", "{6FD4352B-346C-4703-96EA-D4A8B9A6976E}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fullbench", "fullbench\fullbench.vcxproj", "{61ABD629-1CC8-4FD7-9281-6B8DBB9D3DF8}"
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "zstdlib", "zstdlib\zstdlib.vcxproj", "{8BFD8150-94D5-4BF9-8A50-7BD9929A0850}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Win32 = Debug|Win32
@@ -39,6 +43,14 @@ Global
 		{61ABD629-1CC8-4FD7-9281-6B8DBB9D3DF8}.Release|Win32.Build.0 = Release|Win32
 		{61ABD629-1CC8-4FD7-9281-6B8DBB9D3DF8}.Release|x64.ActiveCfg = Release|x64
 		{61ABD629-1CC8-4FD7-9281-6B8DBB9D3DF8}.Release|x64.Build.0 = Release|x64
+		{8BFD8150-94D5-4BF9-8A50-7BD9929A0850}.Debug|Win32.ActiveCfg = Debug|Win32
+		{8BFD8150-94D5-4BF9-8A50-7BD9929A0850}.Debug|Win32.Build.0 = Debug|Win32
+		{8BFD8150-94D5-4BF9-8A50-7BD9929A0850}.Debug|x64.ActiveCfg = Debug|x64
+		{8BFD8150-94D5-4BF9-8A50-7BD9929A0850}.Debug|x64.Build.0 = Debug|x64
+		{8BFD8150-94D5-4BF9-8A50-7BD9929A0850}.Release|Win32.ActiveCfg = Release|Win32
+		{8BFD8150-94D5-4BF9-8A50-7BD9929A0850}.Release|Win32.Build.0 = Release|Win32
+		{8BFD8150-94D5-4BF9-8A50-7BD9929A0850}.Release|x64.ActiveCfg = Release|x64
+		{8BFD8150-94D5-4BF9-8A50-7BD9929A0850}.Release|x64.Build.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -63,27 +63,27 @@
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v110</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v120</PlatformToolset>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v110</PlatformToolset>
+    <PlatformToolset>v120</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v110</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v110</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
@@ -104,7 +104,7 @@
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>$(SolutionDir)..\..\programs\legacy;$(SolutionDir)..\..\lib;$(SolutionDir)..\..\lib\legacy;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath);</IncludePath>
+    <IncludePath>$(SolutionDir)..\..\programs\legacy;$(SolutionDir)..\..\lib\legacy;$(SolutionDir)..\..\lib;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath);</IncludePath>
    <RunCodeAnalysis>true</RunCodeAnalysis>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@@ -0,0 +1,216 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\lib\fse.c" />
+    <ClCompile Include="..\..\..\lib\huff0.c" />
+    <ClCompile Include="..\..\..\lib\zstd_buffered.c" />
+    <ClCompile Include="..\..\..\lib\zstd_compress.c" />
+    <ClCompile Include="..\..\..\lib\zstd_decompress.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\lib\bitstream.h" />
+    <ClInclude Include="..\..\..\lib\error.h" />
+    <ClInclude Include="..\..\..\lib\fse.h" />
+    <ClInclude Include="..\..\..\lib\fse_static.h" />
+    <ClInclude Include="..\..\..\lib\huff0.h" />
+    <ClInclude Include="..\..\..\lib\huff0_static.h" />
+    <ClInclude Include="..\..\..\lib\mem.h" />
+    <ClInclude Include="..\..\..\lib\zstd.h" />
+    <ClInclude Include="..\..\..\lib\zstd_buffered.h" />
+    <ClInclude Include="..\..\..\lib\zstd_buffered_static.h" />
+    <ClInclude Include="..\..\..\lib\zstd_internal.h" />
+    <ClInclude Include="..\..\..\lib\zstd_static.h" />
+    <ClInclude Include="resource.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="zstdlib.rc" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{8BFD8150-94D5-4BF9-8A50-7BD9929A0850}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>zstdlib</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <TargetName>zstdlib_x86</TargetName>
+    <IntDir>$(Platform)\$(Configuration)\</IntDir>
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IncludePath>$(SolutionDir)..\..\programs\legacy;$(SolutionDir)..\..\lib\legacy;$(SolutionDir)..\..\lib;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath);</IncludePath>
+    <RunCodeAnalysis>true</RunCodeAnalysis>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <TargetName>zstdlib_x64</TargetName>
+    <IntDir>$(Platform)\$(Configuration)\</IntDir>
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IncludePath>$(SolutionDir)..\..\programs\legacy;$(SolutionDir)..\..\lib\legacy;$(SolutionDir)..\..\lib;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath);</IncludePath>
+    <RunCodeAnalysis>true</RunCodeAnalysis>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>zstdlib_x86</TargetName>
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\</IntDir>
+    <IncludePath>$(SolutionDir)..\..\programs\legacy;$(SolutionDir)..\..\lib\legacy;$(SolutionDir)..\..\lib;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath);</IncludePath>
+    <RunCodeAnalysis>false</RunCodeAnalysis>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>zstdlib_x64</TargetName>
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\</IntDir>
+    <IncludePath>$(SolutionDir)..\..\programs\legacy;$(SolutionDir)..\..\lib\legacy;$(SolutionDir)..\..\lib;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath);</IncludePath>
+    <RunCodeAnalysis>false</RunCodeAnalysis>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level4</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>ZSTD_DLL_EXPORT=1;ZSTD_HEAPMODE=0;ZSTD_LEGACY_SUPPORT=0;WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>true</MinimalRebuild>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <EnablePREfast>true</EnablePREfast>
+      <AdditionalOptions>/analyze:stacksize25000 %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level4</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>ZSTD_DLL_EXPORT=1;ZSTD_HEAPMODE=0;ZSTD_LEGACY_SUPPORT=0;WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <TreatWarningAsError>false</TreatWarningAsError>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <EnablePREfast>true</EnablePREfast>
+      <AdditionalOptions>/analyze:stacksize25000 %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level4</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>ZSTD_DLL_EXPORT=1;ZSTD_HEAPMODE=0;ZSTD_LEGACY_SUPPORT=0;WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <EnablePREfast>true</EnablePREfast>
+      <AdditionalOptions>/analyze:stacksize25000 %(AdditionalOptions)</AdditionalOptions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <AssemblerOutput>All</AssemblerOutput>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level4</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>ZSTD_DLL_EXPORT=1;ZSTD_HEAPMODE=0;ZSTD_LEGACY_SUPPORT=0;WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <TreatWarningAsError>false</TreatWarningAsError>
+      <EnablePREfast>false</EnablePREfast>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <OmitFramePointers>true</OmitFramePointers>
+      <AssemblerOutput>All</AssemblerOutput>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\lib\fse.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\lib\huff0.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\lib\zstd_buffered.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\lib\zstd_compress.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\lib\zstd_decompress.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\lib\fse.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\lib\fse_static.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\lib\zstd.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\lib\zstd_static.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\lib\huff0.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\lib\huff0_static.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="resource.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\lib\error.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\lib\bitstream.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\lib\zstd_internal.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\lib\zstd_buffered.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\lib\zstd_buffered_static.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\lib\mem.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="zstdlib.rc">
+      <Filter>Resource Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
+</Project>
Author	SHA1	Message	Date
Yann Collet	ef774a68bb	Merge pull request #98 from Cyan4973/dev v0.4.5	2015-12-18 03:59:36 +01:00
Yann Collet	324a3e27c3	fixed visual warning	2015-12-18 03:19:27 +01:00
Yann Collet	6a4583542a	fixed asan warning	2015-12-18 02:51:14 +01:00
Yann Collet	17d188fa38	robust file list	2015-12-18 02:14:46 +01:00
Yann Collet	31683c0b28	benchmark can use dictionary	2015-12-18 01:26:48 +01:00
Yann Collet	fdcad6d3e1	added ZSTD_compress_usingDict()	2015-12-17 23:50:15 +01:00
Yann Collet	035c5429ba	fix test32	2015-12-17 23:12:07 +01:00
Yann Collet	deb078b9b1	added : -m : decompress multiple files	2015-12-17 20:30:14 +01:00
Yann Collet	9d90922d49	refactored file compression	2015-12-17 14:09:55 +01:00
Yann Collet	24c98f2b4b	fixed : conversion warning	2015-12-17 02:48:26 +01:00
Yann Collet	4f13703b2f	added : -m : compress multiple files in a single command	2015-12-17 02:23:58 +01:00
Yann Collet	367060b874	larger cBuffer	2015-12-17 00:07:10 +01:00
Yann Collet	f54f57023c	update params for 256K	2015-12-16 19:38:54 +01:00
Yann Collet	ad84ac9375	reduce memory usage	2015-12-16 03:57:46 +01:00
Yann Collet	880486ff05	fix g++ warning	2015-12-16 03:37:21 +01:00
Yann Collet	a52c98d23a	fix Visual warning	2015-12-16 03:12:31 +01:00
Yann Collet	7061135d33	faster init for multi-files bench	2015-12-16 03:01:03 +01:00
Yann Collet	6c8b925ab9	fixed Visual warning	2015-12-16 02:44:56 +01:00
Yann Collet	ed699e692d	benchmark multiple files	2015-12-16 02:37:24 +01:00
Yann Collet	7a3ab588c7	minor fixes	2015-12-15 11:25:12 +01:00
Yann Collet	c95aa912e0	Merge pull request #96 from Cyan4973/dev v0.4.4	2015-12-14 13:46:54 +01:00
Yann Collet	397f1ffd52	fixed test script	2015-12-13 14:05:00 +01:00
Yann Collet	5d4fa0ed9b	fixed arm-specific shadow warning	2015-12-13 13:58:51 +01:00
Yann Collet	60348b91f3	fixed silent conversion warnings	2015-12-13 13:44:23 +01:00
Yann Collet	f6f3d7526a	external dictionary capability added to command line	2015-12-13 13:35:21 +01:00
Yann Collet	0700585fb9	fixed asan warning	2015-12-12 12:54:48 +01:00
Yann Collet	188b6ed6c7	fixed g++ warning	2015-12-12 12:44:44 +01:00
Yann Collet	3a061a4c9f	extended static dictionary to buffered mode	2015-12-12 11:17:42 +01:00
Yann Collet	6c3e2e7855	fixed : high compression modes for Windows 32 bits	2015-12-11 10:44:07 +01:00
Yann Collet	9f5ab1a4f5	fix 32-bits windows decoding on high-compression archives	2015-12-11 00:27:41 +01:00
Yann Collet	7b7027f21e	windows project are now VS2013	2015-12-10 23:53:21 +01:00
Yann Collet	8329191c63	Merge pull request #95 from KrzysFR/zstdlib_vcproj Add a Visual Studio project for building zstdlib.dll on Windows	2015-12-10 23:45:57 +01:00
Christophe Chevalier	fa9df079a4	Add a Visual Studio project for building zstdlib.dll on Windows - Exports all methods marked with ZSTDLIB_API (ZSTD_DLL_EXPORT=1) - Build without support for legacy version (ZSTD_LEGACY_SUPPORT=0)	2015-12-10 16:25:12 +01:00
Yann Collet	695a6cb463	fixed #94	2015-12-10 15:51:38 +01:00
Yann Collet	3882fd016e	Merge pull request #91 from KrzysFR/zstdlib_api Add __declspec(dllexport) via optional ZSTDLIB_API macro when building a DLL for Windows	2015-12-10 14:08:10 +01:00
Christophe Chevalier	2abb04d90d	Added ZSTDLIB_API to new ZSTD_maxCLevel method	2015-12-09 23:55:23 +01:00
Christophe Chevalier	7b05324a71	Only define ZSTDLIB_API when building a Windows DLL	2015-12-09 17:12:12 +01:00
Christophe Chevalier	844baf4fc5	Merge remote-tracking branch 'upstream/dev' into zstdlib_api	2015-12-09 15:45:57 +01:00
Yann Collet	d608088ca3	added : ZSTD_maxCLevel() added : 256KB blocks mode	2015-12-09 09:05:22 +01:00
Yann Collet	9ad743e74d	Merge pull request #93 from annulen/playTests Move tests from zstd-playTests target to separate shell script.	2015-12-08 18:45:17 +01:00
Konstantin Tokarev	2b465840a8	Re-added accidentally lost round-trip tests for compression levels > 12.	2015-12-08 19:36:42 +03:00
Konstantin Tokarev	0b570b59d2	playTests.sh: Added --test-large-data switch.	2015-12-08 18:47:43 +03:00
Konstantin Tokarev	76be378513	playTests.sh: refactored round-trip tests	2015-12-08 18:36:37 +03:00
Konstantin Tokarev	d66db2ff04	Move tests from zstd-playTests target to separate shell script. This patch allows me to run tests on MIPS board which lacks make.	2015-12-08 18:11:10 +03:00
Yann Collet	0cde77bc5e	fixed comment (reported by @annulen)	2015-12-08 14:47:46 +01:00
Christophe Chevalier	d2199e7250	Added ZSTDLIB_API definition to zstd_buffered.h which does not seem to include zstd.h	2015-12-07 19:01:41 +01:00
Christophe Chevalier	c6e845398a	Add ZSTDLIB_API macro to prefix all exported methods with__declspec(dllexport) when building a DLL (on windows)	2015-12-07 17:48:53 +01:00