Makefile

@@ -27,7 +27,7 @@ endif
 default: lib-release zstd-release
 
 .PHONY: all
-all: | allmost examples manual
+all: | allmost examples manual contrib
 
 .PHONY: allmost
 allmost: allzstd
@@ -72,14 +72,18 @@ zstdmt:
 zlibwrapper:
 	$(MAKE) -C $(ZWRAPDIR) test
 
-.PHONY: check
-check: shortest
+.PHONY: test
+test:
+	$(MAKE) -C $(PRGDIR) allVariants MOREFLAGS+="-g -DZSTD_DEBUG=1"
+	$(MAKE) -C $(TESTDIR) $@
 
-.PHONY: test shortest
-test shortest:
-	$(MAKE) -C $(PRGDIR) allVariants MOREFLAGS="-g -DZSTD_DEBUG=1"
+.PHONY: shortest
+shortest:
 	$(MAKE) -C $(TESTDIR) $@
 
+.PHONY: check
+check: shortest
+
 .PHONY: examples
 examples:
 	CPPFLAGS=-I../lib LDFLAGS=-L../lib $(MAKE) -C examples/ all
@@ -88,6 +92,12 @@ examples:
 manual:
 	$(MAKE) -C contrib/gen_html $@
 
+.PHONY: contrib
+contrib: lib
+	$(MAKE) -C contrib/pzstd all
+	$(MAKE) -C contrib/seekable_format/examples all
+	$(MAKE) -C contrib/adaptive-compression all
+
 .PHONY: cleanTabs
 cleanTabs:
 	cd contrib; ./cleanTabs
@@ -100,6 +110,9 @@ clean:
 	@$(MAKE) -C $(ZWRAPDIR) $@ > $(VOID)
 	@$(MAKE) -C examples/ $@ > $(VOID)
 	@$(MAKE) -C contrib/gen_html $@ > $(VOID)
+	@$(MAKE) -C contrib/pzstd $@ > $(VOID)
+	@$(MAKE) -C contrib/seekable_format/examples $@ > $(VOID)
+	@$(MAKE) -C contrib/adaptive-compression $@ > $(VOID)
 	@$(RM) zstd$(EXT) zstdmt$(EXT) tmp*
 	@$(RM) -r lz4
 	@echo Cleaning completed
@@ -231,31 +244,31 @@ msanregressiontest:
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63303
 
 usan: clean
-	$(MAKE) test CC=clang MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize-recover=signed-integer-overflow -fsanitize=undefined"
+	$(MAKE) test CC=clang MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize-recover=signed-integer-overflow -fsanitize=undefined -Werror"
 
 asan: clean
-	$(MAKE) test CC=clang MOREFLAGS="-g -fsanitize=address"
+	$(MAKE) test CC=clang MOREFLAGS="-g -fsanitize=address -Werror"
 
 asan-%: clean
-	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=address" $(MAKE) -C $(TESTDIR) $*
+	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=address -Werror" $(MAKE) -C $(TESTDIR) $*
 
 msan: clean
-	$(MAKE) test CC=clang MOREFLAGS="-g -fsanitize=memory -fno-omit-frame-pointer" HAVE_LZMA=0   # datagen.c fails this test for no obvious reason
+	$(MAKE) test CC=clang MOREFLAGS="-g -fsanitize=memory -fno-omit-frame-pointer -Werror" HAVE_LZMA=0   # datagen.c fails this test for no obvious reason
 
 msan-%: clean
-	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=memory -fno-omit-frame-pointer" FUZZER_FLAGS=--no-big-tests $(MAKE) -C $(TESTDIR) HAVE_LZMA=0 $*
+	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=memory -fno-omit-frame-pointer -Werror" FUZZER_FLAGS=--no-big-tests $(MAKE) -C $(TESTDIR) HAVE_LZMA=0 $*
 
 asan32: clean
 	$(MAKE) -C $(TESTDIR) test32 CC=clang MOREFLAGS="-g -fsanitize=address"
 
 uasan: clean
-	$(MAKE) test CC=clang MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize-recover=signed-integer-overflow -fsanitize=address,undefined"
+	$(MAKE) test CC=clang MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize-recover=signed-integer-overflow -fsanitize=address,undefined -Werror"
 
 uasan-%: clean
-	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize-recover=signed-integer-overflow -fsanitize=address,undefined" $(MAKE) -C $(TESTDIR) $*
+	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize-recover=signed-integer-overflow -fsanitize=address,undefined -Werror" $(MAKE) -C $(TESTDIR) $*
 
 tsan-%: clean
-	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=thread" $(MAKE) -C $(TESTDIR) $* FUZZER_FLAGS=--no-big-tests
+	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=thread -Werror" $(MAKE) -C $(TESTDIR) $* FUZZER_FLAGS=--no-big-tests
 
 apt-install:
 	sudo apt-get -yq --no-install-suggests --no-install-recommends --force-yes install $(APT_PACKAGES)
@@ -279,6 +292,9 @@ libc6install:
 gcc6install: apt-add-repo
 	APT_PACKAGES="libc6-dev-i386 gcc-multilib gcc-6 gcc-6-multilib" $(MAKE) apt-install
 
+gcc7install: apt-add-repo
+	APT_PACKAGES="libc6-dev-i386 gcc-multilib gcc-7 gcc-7-multilib" $(MAKE) apt-install
+
 gpp6install: apt-add-repo
 	APT_PACKAGES="libc6-dev-i386 g++-multilib gcc-6 g++-6 g++-6-multilib" $(MAKE) apt-install
 

NEWS

+v1.3.4
+perf: faster speed (especially decoding speed) on recent cpus (haswell+)
+perf: much better performance associating --long with multi-threading, by @terrelln
+perf: better compression at levels 13-15
+cli : asynchronous compression by default, for faster experience (use --single-thread for former behavior)
+cli : smoother status report in multi-threading mode
+cli : added command --fast=#, for faster compression modes
+cli : fix crash when not overwriting existing files, by Pádraig Brady (@pixelb)
+api : `nbThreads` becomes `nbWorkers` : 1 triggers asynchronous mode
+api : compression levels can be negative, for even more speed
+api : ZSTD_getFrameProgression() : get precise progress status of ZSTDMT anytime
+api : ZSTDMT can accept new compression parameters during compression
+api : implemented all advanced dictionary decompression prototypes
+build: improved meson recipe, by Shawn Landden (@shawnl)
+build: VS2017 scripts, by @HaydnTrigg
+misc: all /contrib projects fixed
+misc: added /contrib/docker script by @gyscos
+
 v1.3.3
-perf: faster zstd_opt strategy (levels 17-19)
+perf: faster zstd_opt strategy (levels 16-19)
 fix : bug #944 : multithreading with shared ditionary and large data, reported by @gsliepen
 cli : fix : content size written in header by default
 cli : fix : improved LZ4 format support, by @felixhandte

README.md

-<p align="center"><img src="https://raw.githubusercontent.com/facebook/zstd/readme/doc/images/zstd_logo86.png" alt="Zstandard"></p>
+<p align="center"><img src="https://raw.githubusercontent.com/facebook/zstd/dev/doc/images/zstd_logo86.png" alt="Zstandard"></p>
 
 __Zstandard__, or `zstd` as short version, is a fast lossless compression algorithm,
 targeting real-time compression scenarios at zlib-level and better compression ratios.
@@ -21,24 +21,25 @@ Development branch status : [![Build Status][travisDevBadge]][travisLink]   [![B
 ### Benchmarks
 
 For reference, several fast compression algorithms were tested and compared
-on a server running Linux Debian (`Linux version 4.8.0-1-amd64`),
+on a server running Linux Debian (`Linux version 4.14.0-3-amd64`),
 with a Core i7-6700K CPU @ 4.0GHz,
 using [lzbench], an open-source in-memory benchmark by @inikep
-compiled with GCC 6.3.0,
+compiled with [gcc] 7.3.0,
 on the [Silesia compression corpus].
 
 [lzbench]: https://github.com/inikep/lzbench
 [Silesia compression corpus]: http://sun.aei.polsl.pl/~sdeor/index.php?page=silesia
+[gcc]: https://gcc.gnu.org/
 
 | Compressor name         | Ratio | Compression| Decompress.|
 | ---------------         | ------| -----------| ---------- |
-| **zstd 1.1.3 -1**       | 2.877 |   430 MB/s |  1110 MB/s |
-| zlib 1.2.8 -1           | 2.743 |   110 MB/s |   400 MB/s |
-| brotli 0.5.2 -0         | 2.708 |   400 MB/s |   430 MB/s |
+| **zstd 1.3.4 -1**       | 2.877 |   470 MB/s |  1380 MB/s |
+| zlib 1.2.11 -1          | 2.743 |   110 MB/s |   400 MB/s |
+| brotli 1.0.2 -0         | 2.701 |   410 MB/s |   430 MB/s |
 | quicklz 1.5.0 -1        | 2.238 |   550 MB/s |   710 MB/s |
 | lzo1x 2.09 -1           | 2.108 |   650 MB/s |   830 MB/s |
-| lz4 1.7.5               | 2.101 |   720 MB/s |  3600 MB/s |
-| snappy 1.1.3            | 2.091 |   500 MB/s |  1650 MB/s |
+| lz4 1.8.1               | 2.101 |   750 MB/s |  3700 MB/s |
+| snappy 1.1.4            | 2.091 |   530 MB/s |  1800 MB/s |
 | lzf 3.6 -1              | 2.077 |   400 MB/s |   860 MB/s |
 
 [zlib]:http://www.zlib.net/
@@ -50,15 +51,15 @@ Decompression speed is preserved and remains roughly the same at all settings,
 a property shared by most LZ compression algorithms, such as [zlib] or lzma.
 
 The following tests were run
-on a server running Linux Debian (`Linux version 4.8.0-1-amd64`)
+on a server running Linux Debian (`Linux version 4.14.0-3-amd64`)
 with a Core i7-6700K CPU @ 4.0GHz,
 using [lzbench], an open-source in-memory benchmark by @inikep
-compiled with GCC 6.3.0,
+compiled with [gcc] 7.3.0,
 on the [Silesia compression corpus].
 
 Compression Speed vs Ratio | Decompression Speed
 ---------------------------|--------------------
-![Compression Speed vs Ratio](doc/images/Cspeed4.png "Compression Speed vs Ratio") | ![Decompression Speed](doc/images/Dspeed4.png "Decompression Speed")
+![Compression Speed vs Ratio](doc/images/CSpeed2.png "Compression Speed vs Ratio") | ![Decompression Speed](doc/images/DSpeed3.png "Decompression Speed")
 
 A few other algorithms can produce higher compression ratios at slower speeds, falling outside of the graph.
 For a larger picture including slow modes, [click on this link](doc/images/DCspeed5.png).
@@ -128,8 +129,8 @@ A Meson project is provided within `contrib/meson`.
 
 Going into `build` directory, you will find additional possibilities:
 - Projects for Visual Studio 2005, 2008 and 2010.
-  + VS2010 project is compatible with VS2012, VS2013 and VS2015.
-- Automated build scripts for Visual compiler by @KrzysFR , in `build/VS_scripts`,
+  + VS2010 project is compatible with VS2012, VS2013, VS2015 and VS2017.
+- Automated build scripts for Visual compiler by [@KrzysFR](https://github.com/KrzysFR), in `build/VS_scripts`,
   which will build `zstd` cli and `libzstd` library without any need to open Visual Studio solution.
 
 

contrib/adaptive-compression/.gitignore

+# binaries generated
+adapt
+datagen

contrib/adaptive-compression/adapt.c

@@ -40,7 +40,6 @@ static unsigned g_compressionLevel = DEFAULT_COMPRESSION_LEVEL;
 static UTIL_time_t g_startTime;
 static size_t g_streamedSize = 0;
 static unsigned g_useProgressBar = 1;
-static UTIL_freq_t g_ticksPerSecond;
 static unsigned g_forceCompressionLevel = 0;
 static unsigned g_minCLevel = 1;
 static unsigned g_maxCLevel;
@@ -576,13 +575,12 @@ static void* compressionThread(void* arg)
             /* begin compression */
             {
                 size_t const useDictSize = MIN(getUseableDictSize(cLevel), job->dictSize);
-                size_t const dictModeError = ZSTD_setCCtxParameter(ctx->cctx, ZSTD_p_forceRawDict, 1);
                 ZSTD_parameters params = ZSTD_getParams(cLevel, 0, useDictSize);
                 params.cParams.windowLog = 23;
                 {
                     size_t const initError = ZSTD_compressBegin_advanced(ctx->cctx, job->src.start + job->dictSize - useDictSize, useDictSize, params, 0);
-                    size_t const windowSizeError = ZSTD_setCCtxParameter(ctx->cctx, ZSTD_p_forceWindow, 1);
-                    if (ZSTD_isError(dictModeError) || ZSTD_isError(initError) || ZSTD_isError(windowSizeError)) {
+                    size_t const windowSizeError = ZSTD_CCtx_setParameter(ctx->cctx, ZSTD_p_forceMaxWindow, 1);
+                    if (ZSTD_isError(initError) || ZSTD_isError(windowSizeError)) {
                         DISPLAY("Error: something went wrong while starting compression\n");
                         signalErrorToThreads(ctx);
                         return arg;
@@ -644,21 +642,17 @@ static void* compressionThread(void* arg)
 
 static void displayProgress(unsigned cLevel, unsigned last)
 {
-    UTIL_time_t currTime;
-    UTIL_getTime(&currTime);
+    UTIL_time_t currTime = UTIL_getTime();
     if (!g_useProgressBar) return;
-    {
-        double const timeElapsed = (double)(UTIL_getSpanTimeMicro(g_ticksPerSecond, g_startTime, currTime) / 1000.0);
+    {   double const timeElapsed = (double)(UTIL_getSpanTimeMicro(g_startTime, currTime) / 1000.0);
         double const sizeMB = (double)g_streamedSize / (1 << 20);
         double const avgCompRate = sizeMB * 1000 / timeElapsed;
         fprintf(stderr, "\r| Comp. Level: %2u | Time Elapsed: %7.2f s | Data Size: %7.1f MB | Avg Comp. Rate: %6.2f MB/s |", cLevel, timeElapsed/1000.0, sizeMB, avgCompRate);
         if (last) {
             fprintf(stderr, "\n");
-        }
-        else {
+        } else {
             fflush(stderr);
-        }
-    }
+    }   }
 }
 
 static void* outputThread(void* arg)
@@ -971,7 +965,6 @@ static int compressFilename(const char* const srcFilename, const char* const dst
 {
     int ret = 0;
     fcResources fcr = createFileCompressionResources(srcFilename, dstFilenameOrNull);
-    UTIL_getTime(&g_startTime);
     g_streamedSize = 0;
     ret |= performCompression(fcr.ctx, fcr.srcFile, fcr.otArg);
     ret |= freeFileCompressionResources(&fcr);
@@ -1044,8 +1037,6 @@ int main(int argCount, const char* argv[])
     filenameTable[0] = stdinmark;
     g_maxCLevel = ZSTD_maxCLevel();
 
-    UTIL_initTimer(&g_ticksPerSecond);
-
     if (filenameTable == NULL) {
         DISPLAY("Error: could not allocate sapce for filename table.\n");
         return 1;

contrib/docker/Dockerfile

+# Dockerfile
+# First image to build the binary
+FROM alpine as builder
+
+RUN apk --no-cache add make gcc libc-dev
+COPY . /src
+RUN mkdir /pkg && cd /src && make && make DESTDIR=/pkg install
+
+# Second minimal image to only keep the built binary
+FROM alpine
+
+# Copy the built files
+COPY --from=builder /pkg /
+
+# Copy the license as well
+RUN mkdir -p /usr/local/share/licenses/zstd
+COPY --from=builder /src/LICENSE /usr/local/share/licences/zstd/
+
+# Just run `zstd` if no other command is given
+CMD ["/usr/local/bin/zstd"]

contrib/docker/README.md

+
+## Requirement
+
+The `Dockerfile` script requires a version of `docker` >= 17.05
+
+## Installing docker
+
+The officiel docker install docs use a ppa with a modern version available:
+https://docs.docker.com/install/linux/docker-ce/ubuntu/
+
+## How to run
+
+`docker build -t zstd .`
+
+## test
+
+```
+echo foo | docker run -i --rm zstd | docker run -i --rm zstd zstdcat
+foo
+```

contrib/gen_html/Makefile

@@ -7,10 +7,10 @@
 # in the COPYING file in the root directory of this source tree).
 # ################################################################
 
-CFLAGS ?= -O3
-CFLAGS += -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow -Wstrict-aliasing=1 -Wswitch-enum -Wno-comment
-CFLAGS += $(MOREFLAGS)
-FLAGS   = $(CPPFLAGS) $(CFLAGS) $(CXXFLAGS) $(LDFLAGS)
+CXXFLAGS ?= -O3
+CXXFLAGS += -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow -Wstrict-aliasing=1 -Wswitch-enum -Wno-comment
+CXXFLAGS += $(MOREFLAGS)
+FLAGS   = $(CPPFLAGS) $(CXXFLAGS) $(CXXFLAGS) $(LDFLAGS)
 
 ZSTDAPI = ../../lib/zstd.h
 ZSTDMANUAL = ../../doc/zstd_manual.html

contrib/long_distance_matching/Makefile

-# ################################################################
-# Copyright (c) 2017-present, Facebook, Inc.
-# All rights reserved.
-#
-# This source code is licensed under both the BSD-style license (found in the
-# LICENSE file in the root directory of this source tree) and the GPLv2 (found
-# in the COPYING file in the root directory of this source tree).
-# ################################################################
-
-# This Makefile presumes libzstd is installed, using `sudo make install`
-
-CPPFLAGS+= -I../../lib/common
-CFLAGS  ?= -O3
-DEBUGFLAGS = -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \
-            -Wstrict-aliasing=1 -Wswitch-enum -Wdeclaration-after-statement \
-            -Wstrict-prototypes -Wundef -Wpointer-arith -Wformat-security \
-            -Wvla -Wformat=2 -Winit-self -Wfloat-equal -Wwrite-strings \
-            -Wredundant-decls
-CFLAGS  += $(DEBUGFLAGS) $(MOREFLAGS)
-FLAGS    = $(CPPFLAGS) $(CFLAGS)
-
-LDFLAGS += -lzstd
-
-.PHONY: default all clean
-
-default: all
-
-all: ldm
-
-ldm: ldm_common.c ldm.c main.c
-	$(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@
-
-clean:
-	@rm -f core *.o tmp* result* *.ldm *.ldm.dec \
-	ldm
-	@echo Cleaning completed

contrib/long_distance_matching/README.md

-This is a compression algorithm focused on finding long distance matches.
-
-It is based upon lz4 and uses nearly the same block format (github.com/lz4/lz4/blob/dev/doc/lz4_Block_format.md). The number of bytes to encode the offset is four instead of two in lz4 to reflect the longer distance matching. The block format is described in `ldm.h`.
-
-### Build
-
-Run `make`.
-
-### Compressing a file
-
-`ldm <filename>`
-
-Decompression and verification can be enabled by defining `DECOMPRESS_AND_VERIFY` in `main.c`.
-The output file names are as follows:
-- `<filename>.ldm` : compressed file
-- `<filename>.ldm.dec` : decompressed file
-
-### Parameters
-
-There are various parameters that can be tuned. These parameters can be tuned in `ldm.h` or, alternatively if `ldm_params.h` is included, in `ldm_params.h` (for easier configuration).
-
-The parameters are as follows and must all be defined:
-- `LDM_MEMORY_USAGE` : the memory usage of the underlying hash table in bytes.
-- `HASH_BUCKET_SIZE_LOG` : the log size of each bucket in the hash table (used in collision resolution).
-- `LDM_LAG` : the lag (in bytes) in inserting entries into the hash table.
-- `LDM_WINDOW_SIZE_LOG` : the log maximum window size when searching for matches.
-- `LDM_MIN_MATCH_LENGTH` : the minimum match length.
-- `INSERT_BY_TAG` : insert entries into the hash table as a function of the hash. This increases speed by reducing the number of hash table lookups and match comparisons. Certain hashes will never be inserted.
-- `USE_CHECKSUM`  : store a checksum with the hash table entries for faster comparison. This halves the number of entries the hash table can contain.
-
-The optional parameter `HASH_ONLY_EVERY_LOG` is the log inverse frequency of insertion into the hash table. That is, an entry is inserted approximately every `1 << HASH_ONLY_EVERY_LOG` times. If this parameter is not defined, the value is computed as a function of the window size and memory usage to approximate an even coverage of the window.
-
-
-### Benchmark
-
-Below is a comparison of various compression methods on a tar of four versions of llvm (versions `3.9.0`, `3.9.1`, `4.0.0`, `4.0.1`) with a total size of `727900160` B.
-
-| Method | Size | Ratio |
-|:---|---:|---:|
-|lrzip -p 32 -n -w 1 | `369968714` | `1.97`|
-|ldm | `209391361` | `3.48`|
-|lz4 | `189954338` | `3.83`|
-|lrzip -p 32 -l -w 1 | `163940343` | `4.44`|
-|zstd -1 | `126080293` | `5.77`|
-|lrzip -p 32 -n | `124821009` | `5.83`|
-|lrzip -p 32 -n -w 1 & zstd -1 | `120317909` | `6.05`|
-|zstd -3 -o | `115290952` | `6.31`|
-|lrzip -p 32 -g -L 9 -w 1 | `107168979` | `6.79`|
-|zstd -6 -o | `102772098` | `7.08`|
-|zstd -T16 -9 | `98040470` | `7.42`|
-|lrzip -p 32 -n -w 1 & zstd -T32 -19 | `88050289` | `8.27`|
-|zstd -T32 -19 | `83626098` | `8.70`|
-|lrzip -p 32 -n & zstd -1 | `36335117` | `20.03`|
-|ldm & zstd -6 | `32856232` | `22.15`|
-|lrzip -p 32 -g -L 9 | `32243594` | `22.58`|
-|lrzip -p 32 -n & zstd -6 | `30954572` | `23.52`|
-|lrzip -p 32 -n & zstd -T32 -19 | `26472064` | `27.50`|
-
-The method marked `ldm` was run with the following parameters:
-
-| Parameter | Value |
-|:---|---:|
-| `LDM_MEMORY_USAGE`    |   `23`|
-|`HASH_BUCKET_SIZE_LOG` |    `3`|
-|`LDM_LAG`              |    `0`|
-|`LDM_WINDOW_SIZE_LOG`  |   `28`|
-|`LDM_MIN_MATCH_LENGTH`|   `64`|
-|`INSERT_BY_TAG`        |    `1`|
-|`USE_CHECKSUM`         |    `1`|
-
-The compression speed was `220.5 MB/s`.
-
-### Parameter selection
-
-Below is a brief discussion of the effects of the parameters on the speed and compression ratio.
-
-#### Speed
-
-A large bottleneck in terms of speed is finding the matches and comparing to see if they are greater than the minimum match length. Generally:
-- The fewer matches found (or the lower the percentage of the literals matched), the slower the algorithm will behave.
-- Increasing `HASH_ONLY_EVERY_LOG` results in fewer inserts and, if `INSERT_BY_TAG` is set, fewer lookups in the table. This has a large effect on speed, as well as compression ratio.
-- If `HASH_ONLY_EVERY_LOG` is not set, its value is calculated based on `LDM_WINDOW_SIZE_LOG` and `LDM_MEMORY_USAGE`. Increasing `LDM_WINDOW_SIZE_LOG` has the effect of increasing `HASH_ONLY_EVERY_LOG` and increasing `LDM_MEMORY_USAGE` decreases `HASH_ONLY_EVERY_LOG`.
-- `USE_CHECKSUM` generally improves speed with hash table lookups.
-
-#### Compression ratio
-
-The compression ratio is highly correlated with the coverage of matches. As a long distance matcher, the algorithm was designed to "optimize" for long distance matches outside the zstd compression window. The compression ratio after recompressing the output of the long-distance matcher with zstd was a more important signal in development than the raw compression ratio itself.
-
-Generally, increasing `LDM_MEMORY_USAGE` will improve the compression ratio. However when using the default computed value of `HASH_ONLY_EVERY_LOG`, this increases the frequency of insertion and lookup in the table and thus may result in a decrease in speed. 
-
-Below is a table showing the speed and compression ratio when compressing the llvm tar (as described above) using different settings for `LDM_MEMORY_USAGE`. The other parameters were the same as used in the benchmark above.
-
-| `LDM_MEMORY_USAGE` | Ratio | Speed (MB/s) | Ratio after zstd -6  |
-|---:| ---: | ---: | ---: |
-| `18` | `1.85` | `232.4` | `10.92` |
-| `21` | `2.79` | `233.9` | `15.92` |
-| `23` | `3.48` | `220.5` | `18.29` |
-| `25` | `4.56` | `140.8` | `19.21` |
-
-### Compression statistics
-
-Compression statistics (and the configuration) can be enabled/disabled via `COMPUTE_STATS` and `OUTPUT_CONFIGURATION` in `ldm.h`.

contrib/long_distance_matching/ldm.h

-#ifndef LDM_H
-#define LDM_H
-
-#include "mem.h"    // from /lib/common/mem.h
-
-//#include "ldm_params.h"
-
-// =============================================================================
-// Modify the parameters in ldm_params.h if "ldm_params.h" is included.
-// Otherwise, modify the parameters here.
-// =============================================================================
-
-#ifndef LDM_PARAMS_H
-  // Defines the size of the hash table.
-  // Note that this is not the number of buckets.
-  // Currently this should be less than WINDOW_SIZE_LOG + 4.
-  #define LDM_MEMORY_USAGE 23
-
-  // The number of entries in a hash bucket.
-  #define HASH_BUCKET_SIZE_LOG 3 // The maximum is 4 for now.
-
-  // Defines the lag in inserting elements into the hash table.
-  #define LDM_LAG 0
-
-  // The maximum window size when searching for matches.
-  // The maximum value is 30
-  #define LDM_WINDOW_SIZE_LOG 28
-
-  // The minimum match length.
-  // This should be a multiple of four.
-  #define LDM_MIN_MATCH_LENGTH 64
-
-  // If INSERT_BY_TAG, insert entries into the hash table as a function of the
-  // hash. Certain hashes will not be inserted.
-  //
-  // Otherwise, insert as a function of the position.
-  #define INSERT_BY_TAG 1
-
-  // Store a checksum with the hash table entries for faster comparison.
-  // This halves the number of entries the hash table can contain.
-  #define USE_CHECKSUM 1
-#endif
-
-// Output compression statistics.
-#define COMPUTE_STATS
-
-// Output the configuration.
-#define OUTPUT_CONFIGURATION
-
-// If defined, forces the probability of insertion to be approximately
-// one per (1 << HASH_ONLY_EVERY_LOG). If not defined, the probability will be
-// calculated based on the memory usage and window size for "even" insertion
-// throughout the window.
-
-// #define HASH_ONLY_EVERY_LOG 8
-
-// =============================================================================
-
-// The number of bytes storing the compressed and decompressed size
-// in the header.
-#define LDM_COMPRESSED_SIZE 8
-#define LDM_DECOMPRESSED_SIZE 8
-#define LDM_HEADER_SIZE ((LDM_COMPRESSED_SIZE)+(LDM_DECOMPRESSED_SIZE))
-
-#define ML_BITS 4
-#define ML_MASK ((1U<<ML_BITS)-1)
-#define RUN_BITS (8-ML_BITS)
-#define RUN_MASK ((1U<<RUN_BITS)-1)
-
-// The number of bytes storing the offset.
-#define LDM_OFFSET_SIZE 4
-
-#define LDM_WINDOW_SIZE (1 << (LDM_WINDOW_SIZE_LOG))
-
-// TODO: Match lengths that are too small do not use the hash table efficiently.
-// There should be a minimum hash length given the hash table size.
-#define LDM_HASH_LENGTH LDM_MIN_MATCH_LENGTH
-
-typedef struct LDM_compressStats LDM_compressStats;
-typedef struct LDM_CCtx LDM_CCtx;
-typedef struct LDM_DCtx LDM_DCtx;
-
-/**
- *  Compresses src into dst.
- *  Returns the compressed size if successful, 0 otherwise.
- *
- *  NB: This currently ignores maxDstSize and assumes enough space is available.
- *
- *  Block format (see lz4 documentation for more information):
- *  github.com/lz4/lz4/blob/dev/doc/lz4_Block_format.md
- *
- *  A block is composed of sequences. Each sequence begins with a token, which
- *  is a one-byte value separated into two 4-bit fields.
- *
- *  The first field uses the four high bits of the token and encodes the literal
- *  length. If the field value is 0, there is no literal. If it is 15,
- *  additional bytes are added (each ranging from 0 to 255) to the previous
- *  value to produce a total length.
- *
- *  Following the token and optional length bytes are the literals.
- *
- *  Next are the 4 bytes representing the offset of the match (2 in lz4),
- *  representing the position to copy the literals.
- *
- *  The lower four bits of the token encode the match length. With additional
- *  bytes added similarly to the additional literal length bytes after the offset.
- *
- *  The last sequence is incomplete and stops right after the literals.
- */
-size_t LDM_compress(const void *src, size_t srcSize,
-                    void *dst, size_t maxDstSize);
-
-/**
- * Initialize the compression context.
- *
- * Allocates memory for the hash table.
- *
- * Returns 0 if successful, 1 otherwise.
- */
-size_t LDM_initializeCCtx(LDM_CCtx *cctx,
-                          const void *src, size_t srcSize,
-                          void *dst, size_t maxDstSize);
-
-/**
- * Frees up memory allocated in LDM_initializeCCtx().
- */
-void LDM_destroyCCtx(LDM_CCtx *cctx);
-
-/**
- * Prints the distribution of offsets in the hash table.
- *
- * The offsets are defined as the distance of the hash table entry from the
- * current input position of the cctx.
- */
-void LDM_outputHashTableOffsetHistogram(const LDM_CCtx *cctx);
-
-/**
- * Outputs compression statistics to stdout.
- */
-void LDM_printCompressStats(const LDM_compressStats *stats);
-
-/**
- * Encode the literal length followed by the literals.
- *
- * The literal length is written to the upper four bits of pToken, with
- * additional bytes written to the output as needed (see lz4).
- *
- * This is followed by literalLength bytes corresponding to the literals.
- */
-void LDM_encodeLiteralLengthAndLiterals(LDM_CCtx *cctx, BYTE *pToken,
-                                        const U64 literalLength);
-
-/**
- * Write current block (literals, literal length, match offset,
- * match length).
- */
-void LDM_outputBlock(LDM_CCtx *cctx,
-                     const U64 literalLength,
-                     const U32 offset,
-                     const U64 matchLength);
-
-/**
- * Decompresses src into dst.
- *
- * Note: assumes src does not have a header.
- */
-size_t LDM_decompress(const void *src, size_t srcSize,
-                      void *dst, size_t maxDstSize);
-
-/**
- * Initialize the decompression context.
- */
-void LDM_initializeDCtx(LDM_DCtx *dctx,
-                        const void *src, size_t compressedSize,
-                        void *dst, size_t maxDecompressedSize);
-
-/**
- * Reads the header from src and writes the compressed size and
- * decompressed size into compressedSize and decompressedSize respectively.
- *
- * NB: LDM_compress and LDM_decompress currently do not add/read headers.
- */
-void LDM_readHeader(const void *src, U64 *compressedSize,
-                    U64 *decompressedSize);
-
-/**
- * Write the compressed and decompressed size.
- */
-void LDM_writeHeader(void *memPtr, U64 compressedSize,
-                     U64 decompressedSize);
-
-/**
- * Output the configuration used.
- */
-void LDM_outputConfiguration(void);
-
-#endif /* LDM_H */

contrib/long_distance_matching/ldm_common.c

-#include <stdio.h>
-
-#include "ldm.h"
-
-/**
- * This function reads the header at the beginning of src and writes
- * the compressed and decompressed size to compressedSize and
- * decompressedSize.
- *
- * The header consists of 16 bytes: 8 bytes each in little-endian format
- * of the compressed size and the decompressed size.
- */
-void LDM_readHeader(const void *src, U64 *compressedSize,
-                    U64 *decompressedSize) {
-  const BYTE *ip = (const BYTE *)src;
-  *compressedSize = MEM_readLE64(ip);
-  *decompressedSize = MEM_readLE64(ip + 8);
-}
-
-/**
- * Writes the 16-byte header (8-bytes each of the compressedSize and
- * decompressedSize in little-endian format) to memPtr.
- */
-void LDM_writeHeader(void *memPtr, U64 compressedSize,
-                     U64 decompressedSize) {
-  MEM_writeLE64(memPtr, compressedSize);
-  MEM_writeLE64((BYTE *)memPtr + 8, decompressedSize);
-}
-
-struct LDM_DCtx {
-  size_t compressedSize;
-  size_t maxDecompressedSize;
-
-  const BYTE *ibase;   /* Base of input */
-  const BYTE *ip;      /* Current input position */
-  const BYTE *iend;    /* End of source */
-
-  const BYTE *obase;   /* Base of output */
-  BYTE *op;            /* Current output position */
-  const BYTE *oend;    /* End of output */
-};
-
-void LDM_initializeDCtx(LDM_DCtx *dctx,
-                        const void *src, size_t compressedSize,
-                        void *dst, size_t maxDecompressedSize) {
-  dctx->compressedSize = compressedSize;
-  dctx->maxDecompressedSize = maxDecompressedSize;
-
-  dctx->ibase = src;
-  dctx->ip = (const BYTE *)src;
-  dctx->iend = dctx->ip + dctx->compressedSize;
-  dctx->op = dst;
-  dctx->oend = dctx->op + dctx->maxDecompressedSize;
-}
-
-size_t LDM_decompress(const void *src, size_t compressedSize,
-                      void *dst, size_t maxDecompressedSize) {
-
-  LDM_DCtx dctx;
-  LDM_initializeDCtx(&dctx, src, compressedSize, dst, maxDecompressedSize);
-
-  while (dctx.ip < dctx.iend) {
-    BYTE *cpy;
-    const BYTE *match;
-    size_t length, offset;
-
-    /* Get the literal length. */
-    const unsigned token = *(dctx.ip)++;
-    if ((length = (token >> ML_BITS)) == RUN_MASK) {
-      unsigned s;
-      do {
-        s = *(dctx.ip)++;
-        length += s;
-      } while (s == 255);
-    }
-
-    /* Copy the literals. */
-    cpy = dctx.op + length;
-    memcpy(dctx.op, dctx.ip, length);
-    dctx.ip += length;
-    dctx.op = cpy;
-
-    //TODO: dynamic offset size?
-    /* Encode the offset. */
-    offset = MEM_read32(dctx.ip);
-    dctx.ip += LDM_OFFSET_SIZE;
-    match = dctx.op - offset;
-
-    /* Get the match length. */
-    length = token & ML_MASK;
-    if (length == ML_MASK) {
-      unsigned s;
-      do {
-        s = *(dctx.ip)++;
-        length += s;
-      } while (s == 255);
-    }
-    length += LDM_MIN_MATCH_LENGTH;
-
-    /* Copy match. */
-    cpy = dctx.op + length;
-
-    // TODO: this can be made more efficient.
-    while (match < cpy - offset && dctx.op < dctx.oend) {
-      *(dctx.op)++ = *match++;
-    }
-  }
-  return dctx.op - (BYTE *)dst;
-}

contrib/long_distance_matching/ldm_params.h

-#ifndef LDM_PARAMS_H
-#define LDM_PARAMS_H
-
-#define LDM_MEMORY_USAGE 23
-#define HASH_BUCKET_SIZE_LOG 3
-#define LDM_LAG 0
-#define LDM_WINDOW_SIZE_LOG 28
-#define LDM_MIN_MATCH_LENGTH 64
-#define INSERT_BY_TAG 1
-#define USE_CHECKSUM 1
-
-#endif  // LDM_PARAMS_H

contrib/long_distance_matching/main.c

-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <zstd.h>
-
-#include <fcntl.h>
-#include "ldm.h"
-#include "zstd.h"
-
-// #define DECOMPRESS_AND_VERIFY
-
-/* Compress file given by fname and output to oname.
- * Returns 0 if successful, error code otherwise.
- *
- * This adds a header from LDM_writeHeader to the beginning of the output.
- *
- * This might seg fault if the compressed size is > the decompress
- * size due to the mmapping and output file size allocated to be the input size
- * The compress function should check before writing or buffer writes.
- */
-static int compress(const char *fname, const char *oname) {
-  int fdin, fdout;
-  struct stat statbuf;
-  char *src, *dst;
-  size_t maxCompressedSize, compressedSize;
-
-  struct timeval tv1, tv2;
-  double timeTaken;
-
-
-  /* Open the input file. */
-  if ((fdin = open(fname, O_RDONLY)) < 0) {
-    perror("Error in file opening");
-    return 1;
-  }
-
-  /* Open the output file. */
-  if ((fdout = open(oname, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600)) < 0) {
-    perror("Can't create output file");
-    return 1;
-  }
-
-  /* Find the size of the input file. */
-  if (fstat (fdin, &statbuf) < 0) {
-    perror("Fstat error");
-    return 1;
-  }
-
-  maxCompressedSize = (statbuf.st_size + LDM_HEADER_SIZE);
-
-  // Handle case where compressed size is > decompressed size.
-  // TODO: The compress function should check before writing or buffer writes.
-  maxCompressedSize += statbuf.st_size / 255;
-
-  ftruncate(fdout, maxCompressedSize);
-
-  /* mmap the input file. */
-  if ((src = mmap(0, statbuf.st_size, PROT_READ,  MAP_SHARED, fdin, 0))
-          == (caddr_t) - 1) {
-      perror("mmap error for input");
-      return 1;
-  }
-
-  /* mmap the output file. */
-  if ((dst = mmap(0, maxCompressedSize, PROT_READ | PROT_WRITE,
-                  MAP_SHARED, fdout, 0)) == (caddr_t) - 1) {
-      perror("mmap error for output");
-      return 1;
-  }
-
-  gettimeofday(&tv1, NULL);
-
-  compressedSize = LDM_HEADER_SIZE +
-      LDM_compress(src, statbuf.st_size,
-                   dst + LDM_HEADER_SIZE, maxCompressedSize);
-
-  gettimeofday(&tv2, NULL);
-
-  // Write the header.
-  LDM_writeHeader(dst, compressedSize, statbuf.st_size);
-
-  // Truncate file to compressedSize.
-  ftruncate(fdout, compressedSize);
-
-  printf("%25s : %10lu -> %10lu - %s \n", fname,
-         (size_t)statbuf.st_size, (size_t)compressedSize, oname);
-  printf("Compression ratio: %.2fx --- %.1f%%\n",
-         (double)statbuf.st_size / (double)compressedSize,
-         (double)compressedSize / (double)(statbuf.st_size) * 100.0);
-
-  timeTaken = (double) (tv2.tv_usec - tv1.tv_usec) / 1000000 +
-              (double) (tv2.tv_sec - tv1.tv_sec),
-
-  printf("Total compress time = %.3f seconds, Average scanning speed: %.3f MB/s\n",
-         timeTaken,
-         ((double)statbuf.st_size / (double) (1 << 20)) / timeTaken);
-
-  // Close files.
-  close(fdin);
-  close(fdout);
-  return 0;
-}
-
-#ifdef DECOMPRESS_AND_VERIFY
-/* Decompress file compressed using LDM_compress.
- * The input file should have the LDM_HEADER followed by payload.
- * Returns 0 if succesful, and an error code otherwise.
- */
-static int decompress(const char *fname, const char *oname) {
-  int fdin, fdout;
-  struct stat statbuf;
-  char *src, *dst;
-  U64 compressedSize, decompressedSize;
-  size_t outSize;
-
-  /* Open the input file. */
-  if ((fdin = open(fname, O_RDONLY)) < 0) {
-    perror("Error in file opening");
-    return 1;
-  }
-
-  /* Open the output file. */
-  if ((fdout = open(oname, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600)) < 0) {
-    perror("Can't create output file");
-    return 1;
-  }
-
-  /* Find the size of the input file. */
-  if (fstat (fdin, &statbuf) < 0) {
-    perror("Fstat error");
-    return 1;
-  }
-
-  /* mmap the input file. */
-  if ((src = mmap(0, statbuf.st_size, PROT_READ,  MAP_SHARED, fdin, 0))
-          == (caddr_t) - 1) {
-      perror("mmap error for input");
-      return 1;
-  }
-
-  /* Read the header. */
-  LDM_readHeader(src, &compressedSize, &decompressedSize);
-
-  ftruncate(fdout, decompressedSize);
-
-  /* mmap the output file */
-  if ((dst = mmap(0, decompressedSize, PROT_READ | PROT_WRITE,
-                  MAP_SHARED, fdout, 0)) == (caddr_t) - 1) {
-      perror("mmap error for output");
-      return 1;
-  }
-
-  outSize = LDM_decompress(
-      src + LDM_HEADER_SIZE, statbuf.st_size - LDM_HEADER_SIZE,
-      dst, decompressedSize);
-  printf("Ret size out: %zu\n", outSize);
-
-  close(fdin);
-  close(fdout);
-  return 0;
-}
-
-/* Compare two files.
- * Returns 0 iff they are the same.
- */
-static int compare(FILE *fp0, FILE *fp1) {
-  int result = 0;
-  while (result == 0) {
-    char b0[1024];
-    char b1[1024];
-    const size_t r0 = fread(b0, 1, sizeof(b0), fp0);
-    const size_t r1 = fread(b1, 1, sizeof(b1), fp1);
-
-    result = (int)r0 - (int)r1;
-
-    if (0 == r0 || 0 == r1) break;
-
-    if (0 == result) result = memcmp(b0, b1, r0);
-  }
-  return result;
-}
-
-/* Verify the input file is the same as the decompressed file. */
-static int verify(const char *inpFilename, const char *decFilename) {
-  FILE *inpFp, *decFp;
-
-  if ((inpFp = fopen(inpFilename, "rb")) == NULL) {
-    perror("Could not open input file\n");
-    return 1;
-  }
-
-  if ((decFp = fopen(decFilename, "rb")) == NULL) {
-    perror("Could not open decompressed file\n");
-    return 1;
-  }
-
-  printf("verify : %s <-> %s\n", inpFilename, decFilename);
-  {
-    const int cmp = compare(inpFp, decFp);
-    if(0 == cmp) {
-      printf("verify : OK\n");
-    } else {
-      printf("verify : NG\n");
-      return 1;
-    }
-  }
-
-	fclose(decFp);
-	fclose(inpFp);
-  return 0;
-}
-#endif
-
-int main(int argc, const char *argv[]) {
-  const char * const exeName = argv[0];
-  char inpFilename[256] = { 0 };
-  char ldmFilename[256] = { 0 };
-  char decFilename[256] = { 0 };
-
-  if (argc < 2) {
-    printf("Wrong arguments\n");
-    printf("Usage:\n");
-    printf("%s FILE\n", exeName);
-    return 1;
-  }
-
-  snprintf(inpFilename, 256, "%s", argv[1]);
-  snprintf(ldmFilename, 256, "%s.ldm", argv[1]);
-  snprintf(decFilename, 256, "%s.ldm.dec", argv[1]);
-
- 	printf("inp = [%s]\n", inpFilename);
-	printf("ldm = [%s]\n", ldmFilename);
-	printf("dec = [%s]\n", decFilename);
-
-  /* Compress */
-  {
-    if (compress(inpFilename, ldmFilename)) {
-        printf("Compress error\n");
-        return 1;
-    }
-  }
-
-#ifdef DECOMPRESS_AND_VERIFY
-  /* Decompress */
-  {
-    struct timeval tv1, tv2;
-    gettimeofday(&tv1, NULL);
-    if (decompress(ldmFilename, decFilename)) {
-        printf("Decompress error\n");
-        return 1;
-    }
-    gettimeofday(&tv2, NULL);
-    printf("Total decompress time = %f seconds\n",
-          (double) (tv2.tv_usec - tv1.tv_usec) / 1000000 +
-          (double) (tv2.tv_sec - tv1.tv_sec));
-  }
-  /* verify */
-  if (verify(inpFilename, decFilename)) {
-    printf("Verification error\n");
-    return 1;
-  }
-#endif
-  return 0;
-}

contrib/meson/meson.build

@@ -38,21 +38,45 @@ libzstd_srcs = [
 
 libzstd_includes = [include_directories(common_dir, dictbuilder_dir, compress_dir, lib_dir)]
 
-if get_option('legacy_support')
-    message('Enabling legacy support')
-    libzstd_cflags = ['-DZSTD_LEGACY_SUPPORT=4']
+legacy = get_option('legacy_support')
+if legacy == '0'
+    legacy = 'false'
+endif
+if legacy != 'false'
+    if legacy == 'true'
+        legacy = '1'
+    endif
+    #See ZSTD_LEGACY_SUPPORT of programs/README.md
+    message('Enabling legacy support back to version 0.' + legacy)
+    legacy_int = legacy.to_int()
+    if legacy_int > 7
+        legacy_int = 7
+    endif
+    libzstd_cflags = ['-DZSTD_LEGACY_SUPPORT=' + legacy]
 
     legacy_dir = join_paths(lib_dir, 'legacy')
     libzstd_includes += [include_directories(legacy_dir)]
-    libzstd_srcs += [
-        join_paths(legacy_dir, 'zstd_v01.c'),
-        join_paths(legacy_dir, 'zstd_v02.c'),
-        join_paths(legacy_dir, 'zstd_v03.c'),
-        join_paths(legacy_dir, 'zstd_v04.c'),
-        join_paths(legacy_dir, 'zstd_v05.c'),
-        join_paths(legacy_dir, 'zstd_v06.c'),
-        join_paths(legacy_dir, 'zstd_v07.c')
-    ]
+    if legacy_int <= 1
+        libzstd_srcs += join_paths(legacy_dir, 'zstd_v01.c')
+    endif
+    if legacy_int <= 2
+        libzstd_srcs += join_paths(legacy_dir, 'zstd_v02.c')
+    endif
+    if legacy_int <= 3
+        libzstd_srcs += join_paths(legacy_dir, 'zstd_v03.c')
+    endif
+    if legacy_int <= 4
+        libzstd_srcs += join_paths(legacy_dir, 'zstd_v04.c')
+    endif
+    if legacy_int <= 5
+        libzstd_srcs += join_paths(legacy_dir, 'zstd_v05.c')
+    endif
+    if legacy_int <= 6
+        libzstd_srcs += join_paths(legacy_dir, 'zstd_v06.c')
+    endif
+    if legacy_int <= 7
+        libzstd_srcs += join_paths(legacy_dir, 'zstd_v07.c')
+    endif
 else
     libzstd_cflags = []
 endif
@@ -70,7 +94,9 @@ libzstd = library('zstd',
                   include_directories: libzstd_includes,
                   c_args: libzstd_cflags,
                   dependencies: libzstd_deps,
-                  install: true)
+                  install: true,
+                  soversion: '1',
+                 )
 
 programs_dir = join_paths('..', '..', 'programs')
 

contrib/meson/meson_options.txt

 option('multithread', type: 'boolean', value: false)
-option('legacy_support', type: 'boolean', value: false)
+option('legacy_support', type: 'string', value: '4',
+    description: 'True or false, or 7 to 1 for v0.7+ to v0.1+.')

contrib/seekable_format/zstdseek_compress.c

@@ -147,7 +147,7 @@ size_t ZSTD_seekable_initCStream(ZSTD_seekable_CStream* zcs,
 
     /* make sure maxFrameSize has a reasonable value */
     if (maxFrameSize > ZSTD_SEEKABLE_MAX_FRAME_DECOMPRESSED_SIZE) {
-        return ERROR(compressionParameter_unsupported);
+        return ERROR(frameParameter_unsupported);
     }
 
     zcs->maxFrameSize = maxFrameSize

contrib/seekable_format/zstdseek_decompress.c

@@ -125,7 +125,7 @@ static int ZSTD_seekable_seek_buff(void* opaque, S64 offset, int origin)
         newOffset = (unsigned long long)buff->size - offset;
         break;
     }
-    if (newOffset < 0 || newOffset > buff->size) {
+    if (newOffset > buff->size) {
         return -1;
     }
     buff->pos = newOffset;
@@ -145,7 +145,7 @@ typedef struct {
     int checksumFlag;
 } seekTable_t;
 
-#define SEEKABLE_BUFF_SIZE ZSTD_BLOCKSIZE_ABSOLUTEMAX
+#define SEEKABLE_BUFF_SIZE ZSTD_BLOCKSIZE_MAX
 
 struct ZSTD_seekable_s {
     ZSTD_DStream* dstream;

contrib/snap/snapcraft.yaml

+name: zstd
+version: git
+summary: Zstandard - Fast real-time compression algorithm
+description: |
+  Zstandard, or zstd as short version, is a fast lossless compression
+  algorithm, targeting real-time compression scenarios at zlib-level and better
+  compression ratios. It's backed by a very fast entropy stage, provided by
+  Huff0 and FSE library
+
+grade: devel # must be 'stable' to release into candidate/stable channels
+confinement: devmode # use 'strict' once you have the right plugs and slots
+
+apps:
+  zstd:
+    command: usr/local/bin/zstd
+    plugs: [home, removable-media]
+  zstdgrep:
+    command: usr/local/bin/zstdgrep
+    plugs: [home, removable-media]
+  zstdless:
+    command: usr/local/bin/zstdless
+    plugs: [home, removable-media]
+
+parts:
+  zstd:
+    source: .
+    plugin: make
+    build-packages: [g++]