This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6199

zstandard: vendor python-zstandard 0.11
ClosedPublic

Authored by indygreg on Apr 4 2019, 9:21 PM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG675775c33ab6: zstandard: vendor python-zstandard 0.11
Summary

The upstream source distribution from PyPI was extracted. Unwanted
files were removed.

The clang-format ignore list was updated to reflect the new source
of files.

The project contains a vendored copy of zstandard 1.3.8. The old
version was 1.3.6. This should result in some minor performance wins.

test-check-py3-compat.t was updated to reflect now-passing tests on
Python 3.8.

Some HTTP tests were updated to reflect new zstd compression output.

  1. no-check-commit because 3rd party code has different style guidelines

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

indygreg created this revision.Apr 4 2019, 9:21 PM
pulkit accepted this revision.Apr 5 2019, 7:41 AM
Closed by commit rHG675775c33ab6: zstandard: vendor python-zstandard 0.11 (authored by indygreg). · Explain WhyApr 5 2019, 7:57 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mcontrib/clang-format-ignorelist (5 lines)
Mcontrib/python-zstandard/MANIFEST.in (1 line)
Mcontrib/python-zstandard/NEWS.rst (218 lines)
Mcontrib/python-zstandard/README.rst (177 lines)
Mcontrib/python-zstandard/c-ext/compressionchunker.c (4 lines)
Mcontrib/python-zstandard/c-ext/compressiondict.c (10 lines)
Mcontrib/python-zstandard/c-ext/compressionparams.c (365 lines)
Mcontrib/python-zstandard/c-ext/compressionreader.c (604 lines)
Mcontrib/python-zstandard/c-ext/compressionwriter.c (246 lines)
Mcontrib/python-zstandard/c-ext/compressobj.c (6 lines)
Mcontrib/python-zstandard/c-ext/compressor.c (57 lines)
Mcontrib/python-zstandard/c-ext/compressoriterator.c (6 lines)
Mcontrib/python-zstandard/c-ext/constants.c (11 lines)
Mcontrib/python-zstandard/c-ext/decompressionreader.c (511 lines)
Mcontrib/python-zstandard/c-ext/decompressionwriter.c (127 lines)
Mcontrib/python-zstandard/c-ext/decompressobj.c (19 lines)
Mcontrib/python-zstandard/c-ext/decompressor.c (39 lines)
Mcontrib/python-zstandard/c-ext/decompressoriterator.c (2 lines)
Mcontrib/python-zstandard/c-ext/python-zstandard.h (34 lines)
Mcontrib/python-zstandard/make_cffi.py (2 lines)
Mcontrib/python-zstandard/setup.py (28 lines)
Mcontrib/python-zstandard/setup_zstd.py (2 lines)
Mcontrib/python-zstandard/tests/common.py (42 lines)
Mcontrib/python-zstandard/tests/test_buffer_util.py (27 lines)
Mcontrib/python-zstandard/tests/test_compressor.py (358 lines)
Mcontrib/python-zstandard/tests/test_compressor_fuzzing.py (401 lines)
Mcontrib/python-zstandard/tests/test_data_structures.py (50 lines)
Mcontrib/python-zstandard/tests/test_data_structures_fuzzing.py (31 lines)
Mcontrib/python-zstandard/tests/test_decompressor.py (485 lines)
Mcontrib/python-zstandard/tests/test_decompressor_fuzzing.py (273 lines)
Mcontrib/python-zstandard/tests/test_module_attributes.py (9 lines)
Mcontrib/python-zstandard/zstandard/__init__.py (10 lines)
Vcontrib/python-zstandard/{zstandard/cffi.py ← zstd_cffi.py} (1203 lines)
Mcontrib/python-zstandard/zstd.c (2 lines)
Mcontrib/python-zstandard/zstd/common/bitstream.h (23 lines)
Mcontrib/python-zstandard/zstd/common/compiler.h (31 lines)
Mcontrib/python-zstandard/zstd/common/cpu.h (2 lines)
Mcontrib/python-zstandard/zstd/common/debug.h (33 lines)
Mcontrib/python-zstandard/zstd/common/error_private.c (6 lines)
Mcontrib/python-zstandard/zstd/common/fse.h (4 lines)
Mcontrib/python-zstandard/zstd/common/huf.h (26 lines)
Mcontrib/python-zstandard/zstd/common/mem.h (10 lines)
Mcontrib/python-zstandard/zstd/common/pool.c (2 lines)
Mcontrib/python-zstandard/zstd/common/zstd_common.c (4 lines)
Mcontrib/python-zstandard/zstd/common/zstd_errors.h (1 line)
Mcontrib/python-zstandard/zstd/common/zstd_internal.h (13 lines)
Mcontrib/python-zstandard/zstd/compress/fse_compress.c (6 lines)
Mcontrib/python-zstandard/zstd/compress/hist.h (19 lines)
Mcontrib/python-zstandard/zstd/compress/hist.c (30 lines)
Mcontrib/python-zstandard/zstd/compress/huf_compress.c (64 lines)
Mcontrib/python-zstandard/zstd/compress/zstd_compress.c (994 lines)
Mcontrib/python-zstandard/zstd/compress/zstd_compress_internal.h (118 lines)
Mcontrib/python-zstandard/zstd/compress/zstd_double_fast.c (8 lines)
Mcontrib/python-zstandard/zstd/compress/zstd_fast.c (30 lines)
Mcontrib/python-zstandard/zstd/compress/zstd_lazy.c (64 lines)
Mcontrib/python-zstandard/zstd/compress/zstd_ldm.h (8 lines)
Mcontrib/python-zstandard/zstd/compress/zstd_ldm.c (85 lines)
Mcontrib/python-zstandard/zstd/compress/zstd_opt.h (8 lines)
Mcontrib/python-zstandard/zstd/compress/zstd_opt.c (181 lines)
Mcontrib/python-zstandard/zstd/compress/zstdmt_compress.h (28 lines)
Mcontrib/python-zstandard/zstd/compress/zstdmt_compress.c (302 lines)
Mcontrib/python-zstandard/zstd/decompress/huf_decompress.c (220 lines)
AMcontrib/python-zstandard/zstd/decompress/zstd_ddict.h (44 lines)
AMcontrib/python-zstandard/zstd/decompress/zstd_ddict.c (240 lines)
Mcontrib/python-zstandard/zstd/decompress/zstd_decompress.c (1924 lines)
AMcontrib/python-zstandard/zstd/decompress/zstd_decompress_block.h (59 lines)
AMcontrib/python-zstandard/zstd/decompress/zstd_decompress_block.c (1307 lines)
AMcontrib/python-zstandard/zstd/decompress/zstd_decompress_internal.h (168 lines)
Mcontrib/python-zstandard/zstd/dictBuilder/cover.c (24 lines)
Mcontrib/python-zstandard/zstd/dictBuilder/fastcover.c (30 lines)
Mcontrib/python-zstandard/zstd/dictBuilder/zdict.c (56 lines)
Mcontrib/python-zstandard/zstd/zstd.h (1566 lines)
Vcontrib/python-zstandard/{zstd_cffi.py → zstandard/cffi.py}
Mtests/test-check-py3-compat.t (8 lines)
Mtests/test-http-api-httpv2.t (2 lines)
Mtests/test-http-protocol.t (2 lines)

Diff 14672

contrib/clang-format-ignorelist

contrib/python-zstandard/zstd/compress/zstd_lazy.h contrib/python-zstandard/zstd/compress/zstd_lazy.h
contrib/python-zstandard/zstd/compress/zstd_ldm.c contrib/python-zstandard/zstd/compress/zstd_ldm.c
contrib/python-zstandard/zstd/compress/zstd_ldm.h contrib/python-zstandard/zstd/compress/zstd_ldm.h
contrib/python-zstandard/zstd/compress/zstdmt_compress.c contrib/python-zstandard/zstd/compress/zstdmt_compress.c
contrib/python-zstandard/zstd/compress/zstdmt_compress.h contrib/python-zstandard/zstd/compress/zstdmt_compress.h
contrib/python-zstandard/zstd/compress/zstd_opt.c contrib/python-zstandard/zstd/compress/zstd_opt.c
contrib/python-zstandard/zstd/compress/zstd_opt.h contrib/python-zstandard/zstd/compress/zstd_opt.h
contrib/python-zstandard/zstd/decompress/huf_decompress.c contrib/python-zstandard/zstd/decompress/huf_decompress.c
contrib/python-zstandard/zstd/decompress/zstd_ddict.c
contrib/python-zstandard/zstd/decompress/zstd_ddict.h
contrib/python-zstandard/zstd/decompress/zstd_decompress_block.c
contrib/python-zstandard/zstd/decompress/zstd_decompress_block.h
contrib/python-zstandard/zstd/decompress/zstd_decompress_internal.h
contrib/python-zstandard/zstd/decompress/zstd_decompress.c contrib/python-zstandard/zstd/decompress/zstd_decompress.c
contrib/python-zstandard/zstd/deprecated/zbuff_common.c contrib/python-zstandard/zstd/deprecated/zbuff_common.c
contrib/python-zstandard/zstd/deprecated/zbuff_compress.c contrib/python-zstandard/zstd/deprecated/zbuff_compress.c
contrib/python-zstandard/zstd/deprecated/zbuff_decompress.c contrib/python-zstandard/zstd/deprecated/zbuff_decompress.c
contrib/python-zstandard/zstd/deprecated/zbuff.h contrib/python-zstandard/zstd/deprecated/zbuff.h
contrib/python-zstandard/zstd/dictBuilder/cover.c contrib/python-zstandard/zstd/dictBuilder/cover.c
contrib/python-zstandard/zstd/dictBuilder/cover.h contrib/python-zstandard/zstd/dictBuilder/cover.h
contrib/python-zstandard/zstd/dictBuilder/divsufsort.c contrib/python-zstandard/zstd/dictBuilder/divsufsort.c

contrib/python-zstandard/MANIFEST.in

graft c-ext graft c-ext
graft debian graft debian
graft zstd graft zstd
graft tests graft tests
include make_cffi.py include make_cffi.py
include setup_zstd.py include setup_zstd.py
include zstd.c include zstd.c
include zstd_cffi.py
include LICENSE include LICENSE
include NEWS.rst include NEWS.rst

contrib/python-zstandard/NEWS.rst

=============== ===============
Version History Version History
=============== ===============
1.0.0 (not yet released) 1.0.0 (not yet released)
======================== ========================
Actions Blocking Release Actions Blocking Release
------------------------ ------------------------
* compression and decompression APIs that support ``io.rawIOBase`` interface * compression and decompression APIs that support ``io.RawIOBase`` interface
(#13). (#13).
* ``stream_writer()`` APIs should support ``io.RawIOBase`` interface.
* Properly handle non-blocking I/O and partial writes for objects implementing
``io.RawIOBase``.
* Make ``write_return_read=True`` the default for objects implementing
``io.RawIOBase``.
* Audit for consistent and proper behavior of ``flush()`` and ``close()`` for
all objects implementing ``io.RawIOBase``. Is calling ``close()`` on
wrapped stream acceptable, should ``__exit__`` always call ``close()``,
should ``close()`` imply ``flush()``, etc.
* Consider making reads across frames configurable behavior.
* Refactor module names so C and CFFI extensions live under ``zstandard`` * Refactor module names so C and CFFI extensions live under ``zstandard``
package. package.
* Overall API design review. * Overall API design review.
* Use Python allocator where possible. * Use Python allocator where possible.
* Figure out what to do about experimental APIs not implemented by CFFI. * Figure out what to do about experimental APIs not implemented by CFFI.
* APIs for auto adjusting compression parameters based on input size. e.g. * APIs for auto adjusting compression parameters based on input size. e.g.
clamping the window log so it isn't too large for input. clamping the window log so it isn't too large for input.
* Consider allowing compressor and decompressor instances to be thread safe, * Consider allowing compressor and decompressor instances to be thread safe,
compression parameters. compression parameters.
* Consider exposing ``ZSTDMT_toFlushNow()``. * Consider exposing ``ZSTDMT_toFlushNow()``.
* Expose ``ZDICT_trainFromBuffer_fastCover()``, * Expose ``ZDICT_trainFromBuffer_fastCover()``,
``ZDICT_optimizeTrainFromBuffer_fastCover``. ``ZDICT_optimizeTrainFromBuffer_fastCover``.
* Expose and enforce ``ZSTD_minCLevel()`` for minimum compression level. * Expose and enforce ``ZSTD_minCLevel()`` for minimum compression level.
* Consider a ``chunker()`` API for decompression. * Consider a ``chunker()`` API for decompression.
* Consider stats for ``chunker()`` API, including finding the last consumed * Consider stats for ``chunker()`` API, including finding the last consumed
offset of input data. offset of input data.
* Consider exposing ``ZSTD_cParam_getBounds()`` and
``ZSTD_dParam_getBounds()`` APIs.
* Consider controls over resetting compression contexts (session only, parameters,
or session and parameters).
* Actually use the CFFI backend in fuzzing tests.
Other Actions Not Blocking Release Other Actions Not Blocking Release
--------------------------------------- ---------------------------------------
* Support for block compression APIs. * Support for block compression APIs.
* API for ensuring max memory ceiling isn't exceeded. * API for ensuring max memory ceiling isn't exceeded.
* Move off nose for testing. * Move off nose for testing.
0.11.0 (released 2019-02-24)
============================
Backwards Compatibility Nodes
-----------------------------
* ``ZstdDecompressor.read()`` now allows reading sizes of ``-1`` or ``0``
and defaults to ``-1``, per the documented behavior of
``io.RawIOBase.read()``. Previously, we required an argument that was
a positive value.
* The ``readline()``, ``readlines()``, ``__iter__``, and ``__next__`` methods
of ``ZstdDecompressionReader()`` now raise ``io.UnsupportedOperation``
instead of ``NotImplementedError``.
* ``ZstdDecompressor.stream_reader()`` now accepts a ``read_across_frames``
argument. The default value will likely be changed in a future release
and consumers are advised to pass the argument to avoid unwanted change
of behavior in the future.
* ``setup.py`` now always disables the CFFI backend if the installed
CFFI package does not meet the minimum version requirements. Before, it was
possible for the CFFI backend to be generated and a run-time error to
occur.
* In the CFFI backend, ``CompressionReader`` and ``DecompressionReader``
were renamed to ``ZstdCompressionReader`` and ``ZstdDecompressionReader``,
respectively so naming is identical to the C extension. This should have
no meaningful end-user impact, as instances aren't meant to be
constructed directly.
* ``ZstdDecompressor.stream_writer()`` now accepts a ``write_return_read``
argument to control whether ``write()`` returns the number of bytes
read from the source / written to the decompressor. It defaults to off,
which preserves the existing behavior of returning the number of bytes
emitted from the decompressor. The default will change in a future release
so behavior aligns with the specified behavior of ``io.RawIOBase``.
* ``ZstdDecompressionWriter.__exit__`` now calls ``self.close()``. This
will result in that stream plus the underlying stream being closed as
well. If this behavior is not desirable, do not use instances as
context managers.
* ``ZstdCompressor.stream_writer()`` now accepts a ``write_return_read``
argument to control whether ``write()`` returns the number of bytes read
from the source / written to the compressor. It defaults to off, which
preserves the existing behavior of returning the number of bytes emitted
from the compressor. The default will change in a future release so
behavior aligns with the specified behavior of ``io.RawIOBase``.
* ``ZstdCompressionWriter.__exit__`` now calls ``self.close()``. This will
result in that stream plus any underlying stream being closed as well. If
this behavior is not desirable, do not use instances as context managers.
* ``ZstdDecompressionWriter`` no longer requires being used as a context
manager (#57).
* ``ZstdCompressionWriter`` no longer requires being used as a context
manager (#57).
* The ``overlap_size_log`` attribute on ``CompressionParameters`` instances
has been deprecated and will be removed in a future release. The
``overlap_log`` attribute should be used instead.
* The ``overlap_size_log`` argument to ``CompressionParameters`` has been
deprecated and will be removed in a future release. The ``overlap_log``
argument should be used instead.
* The ``ldm_hash_every_log`` attribute on ``CompressionParameters`` instances
has been deprecated and will be removed in a future release. The
``ldm_hash_rate_log`` attribute should be used instead.
* The ``ldm_hash_every_log`` argument to ``CompressionParameters`` has been
deprecated and will be removed in a future release. The ``ldm_hash_rate_log``
argument should be used instead.
* The ``compression_strategy`` argument to ``CompressionParameters`` has been
deprecated and will be removed in a future release. The ``strategy``
argument should be used instead.
* The ``SEARCHLENGTH_MIN`` and ``SEARCHLENGTH_MAX`` constants are deprecated
and will be removed in a future release. Use ``MINMATCH_MIN`` and
``MINMATCH_MAX`` instead.
* The ``zstd_cffi`` module has been renamed to ``zstandard.cffi``. As had
been documented in the ``README`` file since the ``0.9.0`` release, the
module should not be imported directly at its new location. Instead,
``import zstandard`` to cause an appropriate backend module to be loaded
automatically.
Bug Fixes
---------
* CFFI backend could encounter a failure when sending an empty chunk into
``ZstdDecompressionObj.decompress()``. The issue has been fixed.
* CFFI backend could encounter an error when calling
``ZstdDecompressionReader.read()`` if there was data remaining in an
internal buffer. The issue has been fixed. (#71)
Changes
-------
* ``ZstDecompressionObj.decompress()`` now properly handles empty inputs in
the CFFI backend.
* ``ZstdCompressionReader`` now implements ``read1()`` and ``readinto1()``.
These are part of the ``io.BufferedIOBase`` interface.
* ``ZstdCompressionReader`` has gained a ``readinto(b)`` method for reading
compressed output into an existing buffer.
* ``ZstdCompressionReader.read()`` now defaults to ``size=-1`` and accepts
read sizes of ``-1`` and ``0``. The new behavior aligns with the documented
behavior of ``io.RawIOBase``.
* ``ZstdCompressionReader`` now implements ``readall()``. Previously, this
method raised ``NotImplementedError``.
* ``ZstdDecompressionReader`` now implements ``read1()`` and ``readinto1()``.
These are part of the ``io.BufferedIOBase`` interface.
* ``ZstdDecompressionReader.read()`` now defaults to ``size=-1`` and accepts
read sizes of ``-1`` and ``0``. The new behavior aligns with the documented
behavior of ``io.RawIOBase``.
* ``ZstdDecompressionReader()`` now implements ``readall()``. Previously, this
method raised ``NotImplementedError``.
* The ``readline()``, ``readlines()``, ``__iter__``, and ``__next__`` methods
of ``ZstdDecompressionReader()`` now raise ``io.UnsupportedOperation``
instead of ``NotImplementedError``. This reflects a decision to never
implement text-based I/O on (de)compressors and keep the low-level API
operating in the binary domain. (#13)
* ``README.rst`` now documented how to achieve linewise iteration using
an ``io.TextIOWrapper`` with a ``ZstdDecompressionReader``.
* ``ZstdDecompressionReader`` has gained a ``readinto(b)`` method for
reading decompressed output into an existing buffer. This allows chaining
to an ``io.TextIOWrapper`` on Python 3 without using an ``io.BufferedReader``.
* ``ZstdDecompressor.stream_reader()`` now accepts a ``read_across_frames``
argument to control behavior when the input data has multiple zstd
*frames*. When ``False`` (the default for backwards compatibility), a
``read()`` will stop when the end of a zstd *frame* is encountered. When
``True``, ``read()`` can potentially return data spanning multiple zstd
*frames*. The default will likely be changed to ``True`` in a future
release.
* ``setup.py`` now performs CFFI version sniffing and disables the CFFI
backend if CFFI is too old. Previously, we only used ``install_requires``
to enforce the CFFI version and not all build modes would properly enforce
the minimum CFFI version. (#69)
* CFFI's ``ZstdDecompressionReader.read()`` now properly handles data
remaining in any internal buffer. Before, repeated ``read()`` could
result in *random* errors. (#71)
* Upgraded various Python packages in CI environment.
* Upgrade to hypothesis 4.5.11.
* In the CFFI backend, ``CompressionReader`` and ``DecompressionReader``
were renamed to ``ZstdCompressionReader`` and ``ZstdDecompressionReader``,
respectively.
* ``ZstdDecompressor.stream_writer()`` now accepts a ``write_return_read``
argument to control whether ``write()`` returns the number of bytes read
from the source. It defaults to ``False`` to preserve backwards
compatibility.
* ``ZstdDecompressor.stream_writer()`` now implements the ``io.RawIOBase``
interface and behaves as a proper stream object.
* ``ZstdCompressor.stream_writer()`` now accepts a ``write_return_read``
argument to control whether ``write()`` returns the number of bytes read
from the source. It defaults to ``False`` to preserve backwards
compatibility.
* ``ZstdCompressionWriter`` now implements the ``io.RawIOBase`` interface and
behaves as a proper stream object. ``close()`` will now close the stream
and the underlying stream (if possible). ``__exit__`` will now call
``close()``. Methods like ``writable()`` and ``fileno()`` are implemented.
* ``ZstdDecompressionWriter`` no longer must be used as a context manager.
* ``ZstdCompressionWriter`` no longer must be used as a context manager.
When not using as a context manager, it is important to call
``flush(FRAME_FRAME)`` or the compression stream won't be properly
terminated and decoders may complain about malformed input.
* ``ZstdCompressionWriter.flush()`` (what is returned from
``ZstdCompressor.stream_writer()``) now accepts an argument controlling the
flush behavior. Its value can be one of the new constants
``FLUSH_BLOCK`` or ``FLUSH_FRAME``.
* ``ZstdDecompressionObj`` instances now have a ``flush([length=None])`` method.
This provides parity with standard library equivalent types. (#65)
* ``CompressionParameters`` no longer redundantly store individual compression
parameters on each instance. Instead, compression parameters are stored inside
the underlying ``ZSTD_CCtx_params`` instance. Attributes for obtaining
parameters are now properties rather than instance variables.
* Exposed the ``STRATEGY_BTULTRA2`` constant.
* ``CompressionParameters`` instances now expose an ``overlap_log`` attribute.
This behaves identically to the ``overlap_size_log`` attribute.
* ``CompressionParameters()`` now accepts an ``overlap_log`` argument that
behaves identically to the ``overlap_size_log`` argument. An error will be
raised if both arguments are specified.
* ``CompressionParameters`` instances now expose an ``ldm_hash_rate_log``
attribute. This behaves identically to the ``ldm_hash_every_log`` attribute.
* ``CompressionParameters()`` now accepts a ``ldm_hash_rate_log`` argument that
behaves identically to the ``ldm_hash_every_log`` argument. An error will be
raised if both arguments are specified.
* ``CompressionParameters()`` now accepts a ``strategy`` argument that behaves
identically to the ``compression_strategy`` argument. An error will be raised
if both arguments are specified.
* The ``MINMATCH_MIN`` and ``MINMATCH_MAX`` constants were added. They are
semantically equivalent to the old ``SEARCHLENGTH_MIN`` and
``SEARCHLENGTH_MAX`` constants.
* Bundled zstandard library upgraded from 1.3.7 to 1.3.8.
* ``setup.py`` denotes support for Python 3.7 (Python 3.7 was supported and
tested in the 0.10 release).
* ``zstd_cffi`` module has been renamed to ``zstandard.cffi``.
* ``ZstdCompressor.stream_writer()`` now reuses a buffer in order to avoid
allocating a new buffer for every operation. This should result in faster
performance in cases where ``write()`` or ``flush()`` are being called
frequently. (#62)
* Bundled zstandard library upgraded from 1.3.6 to 1.3.7.
0.10.2 (released 2018-11-03)
============================
Bug Fixes
---------
* ``zstd_cffi.py`` added to ``setup.py`` (#60).
Changes
-------
* Change some integer casts to avoid ``ssize_t`` (#61).
0.10.1 (released 2018-10-08) 0.10.1 (released 2018-10-08)
============================ ============================
Backwards Compatibility Notes Backwards Compatibility Notes
----------------------------- -----------------------------
* ``ZstdCompressor.stream_reader().closed`` is now a property instead of a * ``ZstdCompressor.stream_reader().closed`` is now a property instead of a
method (#58). method (#58).

contrib/python-zstandard/README.rst

the author. For convenience, that repository is frequently synchronized to the author. For convenience, that repository is frequently synchronized to
https://github.com/indygreg/python-zstandard. https://github.com/indygreg/python-zstandard.
| |ci-status| |win-ci-status| | |ci-status| |win-ci-status|
Requirements Requirements
============ ============
This extension is designed to run with Python 2.7, 3.4, 3.5, and 3.6 This extension is designed to run with Python 2.7, 3.4, 3.5, 3.6, and 3.7
on common platforms (Linux, Windows, and OS X). x86 and x86_64 are well-tested on common platforms (Linux, Windows, and OS X). On PyPy (both PyPy2 and PyPy3) we support version 6.0.0 and above.
on Windows. Only x86_64 is well-tested on Linux and macOS. x86 and x86_64 are well-tested on Windows. Only x86_64 is well-tested on Linux and macOS.
Installing Installing
========== ==========
This package is uploaded to PyPI at https://pypi.python.org/pypi/zstandard. This package is uploaded to PyPI at https://pypi.python.org/pypi/zstandard.
So, to install this package:: So, to install this package::
$ pip install zstandard $ pip install zstandard
with cctx.stream_reader(fh) as reader: with cctx.stream_reader(fh) as reader:
while True: while True:
chunk = reader.read(16384) chunk = reader.read(16384)
if not chunk: if not chunk:
break break
# Do something with compressed chunk. # Do something with compressed chunk.
When the context manager exists or ``close()`` is called, the stream is closed, When the context manager exits or ``close()`` is called, the stream is closed,
underlying resources are released, and future operations against the compression underlying resources are released, and future operations against the compression
stream will fail. stream will fail.
The ``source`` argument to ``stream_reader()`` can be any object with a The ``source`` argument to ``stream_reader()`` can be any object with a
``read(size)`` method or any object implementing the *buffer protocol*. ``read(size)`` method or any object implementing the *buffer protocol*.
``stream_reader()`` accepts a ``size`` argument specifying how large the input ``stream_reader()`` accepts a ``size`` argument specifying how large the input
stream is. This is used to adjust compression parameters so they are stream is. This is used to adjust compression parameters so they are
(even if the underlying source is seekable). ``readline()`` and (even if the underlying source is seekable). ``readline()`` and
``readlines()`` are not implemented because they don't make sense for ``readlines()`` are not implemented because they don't make sense for
compressed data. ``tell()`` returns the number of compressed bytes compressed data. ``tell()`` returns the number of compressed bytes
emitted so far. emitted so far.
Streaming Input API Streaming Input API
^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
``stream_writer(fh)`` (which behaves as a context manager) allows you to *stream* ``stream_writer(fh)`` allows you to *stream* data into a compressor.
data into a compressor.::
cctx = zstd.ZstdCompressor(level=10) Returned instances implement the ``io.RawIOBase`` interface. Only methods
with cctx.stream_writer(fh) as compressor: that involve writing will do useful things.
compressor.write(b'chunk 0')
compressor.write(b'chunk 1')
...
The argument to ``stream_writer()`` must have a ``write(data)`` method. As The argument to ``stream_writer()`` must have a ``write(data)`` method. As
compressed data is available, ``write()`` will be called with the compressed compressed data is available, ``write()`` will be called with the compressed
data as its argument. Many common Python types implement ``write()``, including data as its argument. Many common Python types implement ``write()``, including
open file handles and ``io.BytesIO``. open file handles and ``io.BytesIO``.
``stream_writer()`` returns an object representing a streaming compressor The ``write(data)`` method is used to feed data into the compressor.
instance. It **must** be used as a context manager. That object's
``write(data)`` method is used to feed data into the compressor. The ``flush([flush_mode=FLUSH_BLOCK])`` method can be called to evict whatever
data remains within the compressor's internal state into the output object. This
A ``flush()`` method can be called to evict whatever data remains within the may result in 0 or more ``write()`` calls to the output object. This method
compressor's internal state into the output object. This may result in 0 or accepts an optional ``flush_mode`` argument to control the flushing behavior.
more ``write()`` calls to the output object. Its value can be any of the ``FLUSH_*`` constants.
Both ``write()`` and ``flush()`` return the number of bytes written to the Both ``write()`` and ``flush()`` return the number of bytes written to the
object's ``write()``. In many cases, small inputs do not accumulate enough object's ``write()``. In many cases, small inputs do not accumulate enough
data to cause a write and ``write()`` will return ``0``. data to cause a write and ``write()`` will return ``0``.
Calling ``close()`` will mark the stream as closed and subsequent I/O
operations will raise ``ValueError`` (per the documented behavior of
``io.RawIOBase``). ``close()`` will also call ``close()`` on the underlying
stream if such a method exists.
Typically usage is as follows::
cctx = zstd.ZstdCompressor(level=10)
compressor = cctx.stream_writer(fh)
compressor.write(b'chunk 0\n')
compressor.write(b'chunk 1\n')
compressor.flush()
# Receiver will be able to decode ``chunk 0\nchunk 1\n`` at this point.
# Receiver is also expecting more data in the zstd *frame*.
compressor.write(b'chunk 2\n')
compressor.flush(zstd.FLUSH_FRAME)
# Receiver will be able to decode ``chunk 0\nchunk 1\nchunk 2``.
# Receiver is expecting no more data, as the zstd frame is closed.
# Any future calls to ``write()`` at this point will construct a new
# zstd frame.
Instances can be used as context managers. Exiting the context manager is
the equivalent of calling ``close()``, which is equivalent to calling
``flush(zstd.FLUSH_FRAME)``::
cctx = zstd.ZstdCompressor(level=10)
with cctx.stream_writer(fh) as compressor:
compressor.write(b'chunk 0')
compressor.write(b'chunk 1')
...
.. important::
If ``flush(FLUSH_FRAME)`` is not called, emitted data doesn't constitute
a full zstd *frame* and consumers of this data may complain about malformed
input. It is recommended to use instances as a context manager to ensure
*frames* are properly finished.
If the size of the data being fed to this streaming compressor is known, If the size of the data being fed to this streaming compressor is known,
you can declare it before compression begins:: you can declare it before compression begins::
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
with cctx.stream_writer(fh, size=data_len) as compressor: with cctx.stream_writer(fh, size=data_len) as compressor:
compressor.write(chunk0) compressor.write(chunk0)
compressor.write(chunk1) compressor.write(chunk1)
... ...
Thte total number of bytes written so far are exposed via ``tell()``:: Thte total number of bytes written so far are exposed via ``tell()``::
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
with cctx.stream_writer(fh) as compressor: with cctx.stream_writer(fh) as compressor:
... ...
total_written = compressor.tell() total_written = compressor.tell()
``stream_writer()`` accepts a ``write_return_read`` boolean argument to control
the return value of ``write()``. When ``False`` (the default), ``write()`` returns
the number of bytes that were ``write()``en to the underlying object. When
``True``, ``write()`` returns the number of bytes read from the input that
were subsequently written to the compressor. ``True`` is the *proper* behavior
for ``write()`` as specified by the ``io.RawIOBase`` interface and will become
the default value in a future release.
Streaming Output API Streaming Output API
^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
``read_to_iter(reader)`` provides a mechanism to stream data out of a ``read_to_iter(reader)`` provides a mechanism to stream data out of a
compressor as an iterator of data chunks.:: compressor as an iterator of data chunks.::
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
for chunk in cctx.read_to_iter(fh): for chunk in cctx.read_to_iter(fh):
Absolute and relative positions (``SEEK_SET`` and ``SEEK_CUR``) forward Absolute and relative positions (``SEEK_SET`` and ``SEEK_CUR``) forward
of the current position are allowed. Offsets behind the current read of the current position are allowed. Offsets behind the current read
position and offsets relative to the end of stream are not allowed and position and offsets relative to the end of stream are not allowed and
will raise ``ValueError`` if attempted. will raise ``ValueError`` if attempted.
``tell()`` returns the number of decompressed bytes read so far. ``tell()`` returns the number of decompressed bytes read so far.
Not all I/O methods are implemented. Notably missing is support for Not all I/O methods are implemented. Notably missing is support for
``readline()``, ``readlines()``, and linewise iteration support. Support for ``readline()``, ``readlines()``, and linewise iteration support. This is
these is planned for a future release. because streams operate on binary data - not text data. If you want to
convert decompressed output to text, you can chain an ``io.TextIOWrapper``
to the stream::
with open(path, 'rb') as fh:
dctx = zstd.ZstdDecompressor()
stream_reader = dctx.stream_reader(fh)
text_stream = io.TextIOWrapper(stream_reader, encoding='utf-8')
for line in text_stream:
...
The ``read_across_frames`` argument to ``stream_reader()`` controls the
behavior of read operations when the end of a zstd *frame* is encountered.
When ``False`` (the default), a read will complete when the end of a
zstd *frame* is encountered. When ``True``, a read can potentially
return data spanning multiple zstd *frames*.
Streaming Input API Streaming Input API
^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
``stream_writer(fh)`` can be used to incrementally send compressed data to a ``stream_writer(fh)`` allows you to *stream* data into a decompressor.
decompressor.::
Returned instances implement the ``io.RawIOBase`` interface. Only methods
that involve writing will do useful things.
The argument to ``stream_writer()`` is typically an object that also implements
``io.RawIOBase``. But any object with a ``write(data)`` method will work. Many
common Python types conform to this interface, including open file handles
and ``io.BytesIO``.
Behavior is similar to ``ZstdCompressor.stream_writer()``: compressed data
is sent to the decompressor by calling ``write(data)`` and decompressed
output is written to the underlying stream by calling its ``write(data)``
method.::
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
with dctx.stream_writer(fh) as decompressor: decompressor = dctx.stream_writer(fh)
decompressor.write(compressed_data) decompressor.write(compressed_data)
...
This behaves similarly to ``zstd.ZstdCompressor``: compressed data is written to
the decompressor by calling ``write(data)`` and decompressed output is written
to the output object by calling its ``write(data)`` method.
Calls to ``write()`` will return the number of bytes written to the output Calls to ``write()`` will return the number of bytes written to the output
object. Not all inputs will result in bytes being written, so return values object. Not all inputs will result in bytes being written, so return values
of ``0`` are possible. of ``0`` are possible.
Like the ``stream_writer()`` compressor, instances can be used as context
managers. However, context managers add no extra special behavior and offer
little to no benefit to being used.
Calling ``close()`` will mark the stream as closed and subsequent I/O operations
will raise ``ValueError`` (per the documented behavior of ``io.RawIOBase``).
``close()`` will also call ``close()`` on the underlying stream if such a
method exists.
The size of chunks being ``write()`` to the destination can be specified:: The size of chunks being ``write()`` to the destination can be specified::
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
with dctx.stream_writer(fh, write_size=16384) as decompressor: with dctx.stream_writer(fh, write_size=16384) as decompressor:
pass pass
You can see how much memory is being used by the decompressor:: You can see how much memory is being used by the decompressor::
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
with dctx.stream_writer(fh) as decompressor: with dctx.stream_writer(fh) as decompressor:
byte_size = decompressor.memory_size() byte_size = decompressor.memory_size()
``stream_writer()`` accepts a ``write_return_read`` boolean argument to control
the return value of ``write()``. When ``False`` (the default)``, ``write()``
returns the number of bytes that were ``write()``en to the underlying stream.
When ``True``, ``write()`` returns the number of bytes read from the input.
``True`` is the *proper* behavior for ``write()`` as specified by the
``io.RawIOBase`` interface and will become the default in a future release.
Streaming Output API Streaming Output API
^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
``read_to_iter(fh)`` provides a mechanism to stream decompressed data out of a ``read_to_iter(fh)`` provides a mechanism to stream decompressed data out of a
compressed source as an iterator of data chunks.:: compressed source as an iterator of data chunks.::
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
for chunk in dctx.read_to_iter(fh): for chunk in dctx.read_to_iter(fh):
dobj = dctx.decompressobj(write_size=1048576) dobj = dctx.decompressobj(write_size=1048576)
.. note:: .. note::
Because calls to ``decompress()`` may need to perform multiple Because calls to ``decompress()`` may need to perform multiple
memory (re)allocations, this streaming decompression API isn't as memory (re)allocations, this streaming decompression API isn't as
efficient as other APIs. efficient as other APIs.
For compatibility with the standard library APIs, instances expose a
``flush([length=None])`` method. This method no-ops and has no meaningful
side-effects, making it safe to call any time.
Batch Decompression API Batch Decompression API
^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^
(Experimental. Not yet supported in CFFI bindings.) (Experimental. Not yet supported in CFFI bindings.)
``multi_decompress_to_buffer()`` performs decompression of multiple ``multi_decompress_to_buffer()`` performs decompression of multiple
frames as a single operation and returns a ``BufferWithSegmentsCollection`` frames as a single operation and returns a ``BufferWithSegmentsCollection``
containing decompressed data for all inputs. containing decompressed data for all inputs.
* format * format
* compression_level * compression_level
* window_log * window_log
* hash_log * hash_log
* chain_log * chain_log
* search_log * search_log
* min_match * min_match
* target_length * target_length
* compression_strategy * strategy
* compression_strategy (deprecated: same as ``strategy``)
* write_content_size * write_content_size
* write_checksum * write_checksum
* write_dict_id * write_dict_id
* job_size * job_size
* overlap_size_log * overlap_log
* overlap_size_log (deprecated: same as ``overlap_log``)
* force_max_window * force_max_window
* enable_ldm * enable_ldm
* ldm_hash_log * ldm_hash_log
* ldm_min_match * ldm_min_match
* ldm_bucket_size_log * ldm_bucket_size_log
* ldm_hash_every_log * ldm_hash_rate_log
* ldm_hash_every_log (deprecated: same as ``ldm_hash_rate_log``)
* threads * threads
Some of these are very low-level settings. It may help to consult the official Some of these are very low-level settings. It may help to consult the official
zstandard documentation for their behavior. Look for the ``ZSTD_p_*`` constants zstandard documentation for their behavior. Look for the ``ZSTD_p_*`` constants
in ``zstd.h`` (https://github.com/facebook/zstd/blob/dev/lib/zstd.h). in ``zstd.h`` (https://github.com/facebook/zstd/blob/dev/lib/zstd.h).
Frame Inspection Frame Inspection
---------------- ----------------
DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE
Recommended chunk size for decompression output Recommended chunk size for decompression output
FRAME_HEADER FRAME_HEADER
bytes containing header of the Zstandard frame bytes containing header of the Zstandard frame
MAGIC_NUMBER MAGIC_NUMBER
Frame header as an integer Frame header as an integer
FLUSH_BLOCK
Flushing behavior that denotes to flush a zstd block. A decompressor will
be able to decode all data fed into the compressor so far.
FLUSH_FRAME
Flushing behavior that denotes to end a zstd frame. Any new data fed
to the compressor will start a new frame.
CONTENTSIZE_UNKNOWN CONTENTSIZE_UNKNOWN
Value for content size when the content size is unknown. Value for content size when the content size is unknown.
CONTENTSIZE_ERROR CONTENTSIZE_ERROR
Value for content size when content size couldn't be determined. Value for content size when content size couldn't be determined.
WINDOWLOG_MIN WINDOWLOG_MIN
Minimum value for compression parameter Minimum value for compression parameter
WINDOWLOG_MAX WINDOWLOG_MAX
Maximum value for compression parameter Maximum value for compression parameter
CHAINLOG_MIN CHAINLOG_MIN
Minimum value for compression parameter Minimum value for compression parameter
CHAINLOG_MAX CHAINLOG_MAX
Maximum value for compression parameter Maximum value for compression parameter
HASHLOG_MIN HASHLOG_MIN
Minimum value for compression parameter Minimum value for compression parameter
HASHLOG_MAX HASHLOG_MAX
Maximum value for compression parameter Maximum value for compression parameter
SEARCHLOG_MIN SEARCHLOG_MIN
Minimum value for compression parameter Minimum value for compression parameter
SEARCHLOG_MAX SEARCHLOG_MAX
Maximum value for compression parameter Maximum value for compression parameter
MINMATCH_MIN
Minimum value for compression parameter
MINMATCH_MAX
Maximum value for compression parameter
SEARCHLENGTH_MIN SEARCHLENGTH_MIN
Minimum value for compression parameter Minimum value for compression parameter
Deprecated: use ``MINMATCH_MIN``
SEARCHLENGTH_MAX SEARCHLENGTH_MAX
Maximum value for compression parameter Maximum value for compression parameter
Deprecated: use ``MINMATCH_MAX``
TARGETLENGTH_MIN TARGETLENGTH_MIN
Minimum value for compression parameter Minimum value for compression parameter
STRATEGY_FAST STRATEGY_FAST
Compression strategy Compression strategy
STRATEGY_DFAST STRATEGY_DFAST
Compression strategy Compression strategy
STRATEGY_GREEDY STRATEGY_GREEDY
Compression strategy Compression strategy
STRATEGY_LAZY STRATEGY_LAZY
Compression strategy Compression strategy
STRATEGY_LAZY2 STRATEGY_LAZY2
Compression strategy Compression strategy
STRATEGY_BTLAZY2 STRATEGY_BTLAZY2
Compression strategy Compression strategy
STRATEGY_BTOPT STRATEGY_BTOPT
Compression strategy Compression strategy
STRATEGY_BTULTRA STRATEGY_BTULTRA
Compression strategy Compression strategy
STRATEGY_BTULTRA2
Compression strategy
FORMAT_ZSTD1 FORMAT_ZSTD1
Zstandard frame format Zstandard frame format
FORMAT_ZSTD1_MAGICLESS FORMAT_ZSTD1_MAGICLESS
Zstandard frame format without magic header Zstandard frame format without magic header
Performance Considerations Performance Considerations
-------------------------- --------------------------

contrib/python-zstandard/c-ext/compressionchunker.c

if (chunker->finished) { if (chunker->finished) {
return NULL; return NULL;
} }
/* If we have data left in the input, consume it. */ /* If we have data left in the input, consume it. */
while (chunker->input.pos < chunker->input.size) { while (chunker->input.pos < chunker->input.size) {
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_compress_generic(chunker->compressor->cctx, &chunker->output, zresult = ZSTD_compressStream2(chunker->compressor->cctx, &chunker->output,
&chunker->input, ZSTD_e_continue); &chunker->input, ZSTD_e_continue);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
/* Input is fully consumed. */ /* Input is fully consumed. */
if (chunker->input.pos == chunker->input.size) { if (chunker->input.pos == chunker->input.size) {
chunker->input.src = NULL; chunker->input.src = NULL;
chunker->input.pos = 0; chunker->input.pos = 0;
chunker->input.size = 0; chunker->input.size = 0;
zFlushMode = ZSTD_e_end; zFlushMode = ZSTD_e_end;
} }
else { else {
PyErr_SetString(ZstdError, "unhandled compression mode; this should never happen"); PyErr_SetString(ZstdError, "unhandled compression mode; this should never happen");
return NULL; return NULL;
} }
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_compress_generic(chunker->compressor->cctx, &chunker->output, zresult = ZSTD_compressStream2(chunker->compressor->cctx, &chunker->output,
&chunker->input, zFlushMode); &chunker->input, zFlushMode);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "zstd compress error: %s", PyErr_Format(ZstdError, "zstd compress error: %s",
ZSTD_getErrorName(zresult)); ZSTD_getErrorName(zresult));
return NULL; return NULL;
} }

contrib/python-zstandard/c-ext/compressiondict.c

return NULL; return NULL;
} }
} }
if (level) { if (level) {
cParams = ZSTD_getCParams(level, 0, self->dictSize); cParams = ZSTD_getCParams(level, 0, self->dictSize);
} }
else { else {
cParams.chainLog = compressionParams->chainLog; if (to_cparams(compressionParams, &cParams)) {
cParams.hashLog = compressionParams->hashLog; return NULL;
cParams.searchLength = compressionParams->minMatch; }
cParams.searchLog = compressionParams->searchLog;
cParams.strategy = compressionParams->compressionStrategy;
cParams.targetLength = compressionParams->targetLength;
cParams.windowLog = compressionParams->windowLog;
} }
assert(!self->cdict); assert(!self->cdict);
self->cdict = ZSTD_createCDict_advanced(self->dictData, self->dictSize, self->cdict = ZSTD_createCDict_advanced(self->dictData, self->dictSize,
ZSTD_dlm_byRef, self->dictType, cParams, ZSTD_defaultCMem); ZSTD_dlm_byRef, self->dictType, cParams, ZSTD_defaultCMem);
if (!self->cdict) { if (!self->cdict) {
PyErr_SetString(ZstdError, "unable to precompute dictionary"); PyErr_SetString(ZstdError, "unable to precompute dictionary");

contrib/python-zstandard/c-ext/compressionparams.c

/** /**
* Copyright (c) 2016-present, Gregory Szorc * Copyright (c) 2016-present, Gregory Szorc
* All rights reserved. * All rights reserved.
* *
* This software may be modified and distributed under the terms * This software may be modified and distributed under the terms
* of the BSD license. See the LICENSE file for details. * of the BSD license. See the LICENSE file for details.
*/ */
#include "python-zstandard.h" #include "python-zstandard.h"
extern PyObject* ZstdError; extern PyObject* ZstdError;
int set_parameter(ZSTD_CCtx_params* params, ZSTD_cParameter param, unsigned value) { int set_parameter(ZSTD_CCtx_params* params, ZSTD_cParameter param, int value) {
size_t zresult = ZSTD_CCtxParam_setParameter(params, param, value); size_t zresult = ZSTD_CCtxParam_setParameter(params, param, value);
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "unable to set compression context parameter: %s", PyErr_Format(ZstdError, "unable to set compression context parameter: %s",
ZSTD_getErrorName(zresult)); ZSTD_getErrorName(zresult));
return 1; return 1;
} }
return 0; return 0;
} }
#define TRY_SET_PARAMETER(params, param, value) if (set_parameter(params, param, value)) return -1; #define TRY_SET_PARAMETER(params, param, value) if (set_parameter(params, param, value)) return -1;
#define TRY_COPY_PARAMETER(source, dest, param) { \
int result; \
size_t zresult = ZSTD_CCtxParam_getParameter(source, param, &result); \
if (ZSTD_isError(zresult)) { \
return 1; \
} \
zresult = ZSTD_CCtxParam_setParameter(dest, param, result); \
if (ZSTD_isError(zresult)) { \
return 1; \
} \
}
int set_parameters(ZSTD_CCtx_params* params, ZstdCompressionParametersObject* obj) { int set_parameters(ZSTD_CCtx_params* params, ZstdCompressionParametersObject* obj) {
TRY_SET_PARAMETER(params, ZSTD_p_format, obj->format); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_nbWorkers);
TRY_SET_PARAMETER(params, ZSTD_p_compressionLevel, (unsigned)obj->compressionLevel);
TRY_SET_PARAMETER(params, ZSTD_p_windowLog, obj->windowLog); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_format);
TRY_SET_PARAMETER(params, ZSTD_p_hashLog, obj->hashLog); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_compressionLevel);
TRY_SET_PARAMETER(params, ZSTD_p_chainLog, obj->chainLog); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_windowLog);
TRY_SET_PARAMETER(params, ZSTD_p_searchLog, obj->searchLog); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_hashLog);
TRY_SET_PARAMETER(params, ZSTD_p_minMatch, obj->minMatch); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_chainLog);
TRY_SET_PARAMETER(params, ZSTD_p_targetLength, obj->targetLength); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_searchLog);
TRY_SET_PARAMETER(params, ZSTD_p_compressionStrategy, obj->compressionStrategy); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_minMatch);
TRY_SET_PARAMETER(params, ZSTD_p_contentSizeFlag, obj->contentSizeFlag); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_targetLength);
TRY_SET_PARAMETER(params, ZSTD_p_checksumFlag, obj->checksumFlag); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_strategy);
TRY_SET_PARAMETER(params, ZSTD_p_dictIDFlag, obj->dictIDFlag); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_contentSizeFlag);
TRY_SET_PARAMETER(params, ZSTD_p_nbWorkers, obj->threads); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_checksumFlag);
TRY_SET_PARAMETER(params, ZSTD_p_jobSize, obj->jobSize); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_dictIDFlag);
TRY_SET_PARAMETER(params, ZSTD_p_overlapSizeLog, obj->overlapSizeLog); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_jobSize);
TRY_SET_PARAMETER(params, ZSTD_p_forceMaxWindow, obj->forceMaxWindow); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_overlapLog);
TRY_SET_PARAMETER(params, ZSTD_p_enableLongDistanceMatching, obj->enableLongDistanceMatching); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_forceMaxWindow);
TRY_SET_PARAMETER(params, ZSTD_p_ldmHashLog, obj->ldmHashLog); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_enableLongDistanceMatching);
TRY_SET_PARAMETER(params, ZSTD_p_ldmMinMatch, obj->ldmMinMatch); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_ldmHashLog);
TRY_SET_PARAMETER(params, ZSTD_p_ldmBucketSizeLog, obj->ldmBucketSizeLog); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_ldmMinMatch);
TRY_SET_PARAMETER(params, ZSTD_p_ldmHashEveryLog, obj->ldmHashEveryLog); TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_ldmBucketSizeLog);
TRY_COPY_PARAMETER(obj->params, params, ZSTD_c_ldmHashRateLog);
return 0; return 0;
} }
int reset_params(ZstdCompressionParametersObject* params) { int reset_params(ZstdCompressionParametersObject* params) {
if (params->params) { if (params->params) {
ZSTD_CCtxParams_reset(params->params); ZSTD_CCtxParams_reset(params->params);
} }
else { else {
params->params = ZSTD_createCCtxParams(); params->params = ZSTD_createCCtxParams();
if (!params->params) { if (!params->params) {
PyErr_NoMemory(); PyErr_NoMemory();
return 1; return 1;
} }
} }
return set_parameters(params->params, params); return set_parameters(params->params, params);
} }
#define TRY_GET_PARAMETER(params, param, value) { \
size_t zresult = ZSTD_CCtxParam_getParameter(params, param, value); \
if (ZSTD_isError(zresult)) { \
PyErr_Format(ZstdError, "unable to retrieve parameter: %s", ZSTD_getErrorName(zresult)); \
return 1; \
} \
}
int to_cparams(ZstdCompressionParametersObject* params, ZSTD_compressionParameters* cparams) {
int value;
TRY_GET_PARAMETER(params->params, ZSTD_c_windowLog, &value);
cparams->windowLog = value;
TRY_GET_PARAMETER(params->params, ZSTD_c_chainLog, &value);
cparams->chainLog = value;
TRY_GET_PARAMETER(params->params, ZSTD_c_hashLog, &value);
cparams->hashLog = value;
TRY_GET_PARAMETER(params->params, ZSTD_c_searchLog, &value);
cparams->searchLog = value;
TRY_GET_PARAMETER(params->params, ZSTD_c_minMatch, &value);
cparams->minMatch = value;
TRY_GET_PARAMETER(params->params, ZSTD_c_targetLength, &value);
cparams->targetLength = value;
TRY_GET_PARAMETER(params->params, ZSTD_c_strategy, &value);
cparams->strategy = value;
return 0;
}
static int ZstdCompressionParameters_init(ZstdCompressionParametersObject* self, PyObject* args, PyObject* kwargs) { static int ZstdCompressionParameters_init(ZstdCompressionParametersObject* self, PyObject* args, PyObject* kwargs) {
static char* kwlist[] = { static char* kwlist[] = {
"format", "format",
"compression_level", "compression_level",
"window_log", "window_log",
"hash_log", "hash_log",
"chain_log", "chain_log",
"search_log", "search_log",
"min_match", "min_match",
"target_length", "target_length",
"compression_strategy", "compression_strategy",
"strategy",
"write_content_size", "write_content_size",
"write_checksum", "write_checksum",
"write_dict_id", "write_dict_id",
"job_size", "job_size",
"overlap_log",
"overlap_size_log", "overlap_size_log",
"force_max_window", "force_max_window",
"enable_ldm", "enable_ldm",
"ldm_hash_log", "ldm_hash_log",
"ldm_min_match", "ldm_min_match",
"ldm_bucket_size_log", "ldm_bucket_size_log",
"ldm_hash_rate_log",
"ldm_hash_every_log", "ldm_hash_every_log",
"threads", "threads",
NULL NULL
}; };
unsigned format = 0; int format = 0;
int compressionLevel = 0; int compressionLevel = 0;
unsigned windowLog = 0; int windowLog = 0;
unsigned hashLog = 0; int hashLog = 0;
unsigned chainLog = 0; int chainLog = 0;
unsigned searchLog = 0; int searchLog = 0;
unsigned minMatch = 0; int minMatch = 0;
unsigned targetLength = 0; int targetLength = 0;
unsigned compressionStrategy = 0; int compressionStrategy = -1;
unsigned contentSizeFlag = 1; int strategy = -1;
unsigned checksumFlag = 0; int contentSizeFlag = 1;
unsigned dictIDFlag = 0; int checksumFlag = 0;
unsigned jobSize = 0; int dictIDFlag = 0;
unsigned overlapSizeLog = 0; int jobSize = 0;
unsigned forceMaxWindow = 0; int overlapLog = -1;
unsigned enableLDM = 0; int overlapSizeLog = -1;
unsigned ldmHashLog = 0; int forceMaxWindow = 0;
unsigned ldmMinMatch = 0; int enableLDM = 0;
unsigned ldmBucketSizeLog = 0; int ldmHashLog = 0;
unsigned ldmHashEveryLog = 0; int ldmMinMatch = 0;
int ldmBucketSizeLog = 0;
int ldmHashRateLog = -1;
int ldmHashEveryLog = -1;
int threads = 0; int threads = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"|IiIIIIIIIIIIIIIIIIIIi:CompressionParameters", "|iiiiiiiiiiiiiiiiiiiiiiii:CompressionParameters",
kwlist, &format, &compressionLevel, &windowLog, &hashLog, &chainLog, kwlist, &format, &compressionLevel, &windowLog, &hashLog, &chainLog,
&searchLog, &minMatch, &targetLength, &compressionStrategy, &searchLog, &minMatch, &targetLength, &compressionStrategy, &strategy,
&contentSizeFlag, &checksumFlag, &dictIDFlag, &jobSize, &overlapSizeLog, &contentSizeFlag, &checksumFlag, &dictIDFlag, &jobSize, &overlapLog,
&forceMaxWindow, &enableLDM, &ldmHashLog, &ldmMinMatch, &ldmBucketSizeLog, &overlapSizeLog, &forceMaxWindow, &enableLDM, &ldmHashLog, &ldmMinMatch,
&ldmHashEveryLog, &threads)) { &ldmBucketSizeLog, &ldmHashRateLog, &ldmHashEveryLog, &threads)) {
return -1;
}
if (reset_params(self)) {
return -1; return -1;
} }
if (threads < 0) { if (threads < 0) {
threads = cpu_count(); threads = cpu_count();
} }
self->format = format; /* We need to set ZSTD_c_nbWorkers before ZSTD_c_jobSize and ZSTD_c_overlapLog
self->compressionLevel = compressionLevel; * because setting ZSTD_c_nbWorkers resets the other parameters. */
self->windowLog = windowLog; TRY_SET_PARAMETER(self->params, ZSTD_c_nbWorkers, threads);
self->hashLog = hashLog;
self->chainLog = chainLog; TRY_SET_PARAMETER(self->params, ZSTD_c_format, format);
self->searchLog = searchLog; TRY_SET_PARAMETER(self->params, ZSTD_c_compressionLevel, compressionLevel);
self->minMatch = minMatch; TRY_SET_PARAMETER(self->params, ZSTD_c_windowLog, windowLog);
self->targetLength = targetLength; TRY_SET_PARAMETER(self->params, ZSTD_c_hashLog, hashLog);
self->compressionStrategy = compressionStrategy; TRY_SET_PARAMETER(self->params, ZSTD_c_chainLog, chainLog);
self->contentSizeFlag = contentSizeFlag; TRY_SET_PARAMETER(self->params, ZSTD_c_searchLog, searchLog);
self->checksumFlag = checksumFlag; TRY_SET_PARAMETER(self->params, ZSTD_c_minMatch, minMatch);
self->dictIDFlag = dictIDFlag; TRY_SET_PARAMETER(self->params, ZSTD_c_targetLength, targetLength);
self->threads = threads;
self->jobSize = jobSize;
self->overlapSizeLog = overlapSizeLog;
self->forceMaxWindow = forceMaxWindow;
self->enableLongDistanceMatching = enableLDM;
self->ldmHashLog = ldmHashLog;
self->ldmMinMatch = ldmMinMatch;
self->ldmBucketSizeLog = ldmBucketSizeLog;
self->ldmHashEveryLog = ldmHashEveryLog;
if (reset_params(self)) { if (compressionStrategy != -1 && strategy != -1) {
PyErr_SetString(PyExc_ValueError, "cannot specify both compression_strategy and strategy");
return -1; return -1;
} }
if (compressionStrategy != -1) {
strategy = compressionStrategy;
}
else if (strategy == -1) {
strategy = 0;
}
TRY_SET_PARAMETER(self->params, ZSTD_c_strategy, strategy);
TRY_SET_PARAMETER(self->params, ZSTD_c_contentSizeFlag, contentSizeFlag);
TRY_SET_PARAMETER(self->params, ZSTD_c_checksumFlag, checksumFlag);
TRY_SET_PARAMETER(self->params, ZSTD_c_dictIDFlag, dictIDFlag);
TRY_SET_PARAMETER(self->params, ZSTD_c_jobSize, jobSize);
if (overlapLog != -1 && overlapSizeLog != -1) {
PyErr_SetString(PyExc_ValueError, "cannot specify both overlap_log and overlap_size_log");
return -1;
}
if (overlapSizeLog != -1) {
overlapLog = overlapSizeLog;
}
else if (overlapLog == -1) {
overlapLog = 0;
}
TRY_SET_PARAMETER(self->params, ZSTD_c_overlapLog, overlapLog);
TRY_SET_PARAMETER(self->params, ZSTD_c_forceMaxWindow, forceMaxWindow);
TRY_SET_PARAMETER(self->params, ZSTD_c_enableLongDistanceMatching, enableLDM);
TRY_SET_PARAMETER(self->params, ZSTD_c_ldmHashLog, ldmHashLog);
TRY_SET_PARAMETER(self->params, ZSTD_c_ldmMinMatch, ldmMinMatch);
TRY_SET_PARAMETER(self->params, ZSTD_c_ldmBucketSizeLog, ldmBucketSizeLog);
if (ldmHashRateLog != -1 && ldmHashEveryLog != -1) {
PyErr_SetString(PyExc_ValueError, "cannot specify both ldm_hash_rate_log and ldm_hash_everyLog");
return -1;
}
if (ldmHashEveryLog != -1) {
ldmHashRateLog = ldmHashEveryLog;
}
else if (ldmHashRateLog == -1) {
ldmHashRateLog = 0;
}
TRY_SET_PARAMETER(self->params, ZSTD_c_ldmHashRateLog, ldmHashRateLog);
return 0; return 0;
} }
PyDoc_STRVAR(ZstdCompressionParameters_from_level__doc__, PyDoc_STRVAR(ZstdCompressionParameters_from_level__doc__,
"Create a CompressionParameters from a compression level and target sizes\n" "Create a CompressionParameters from a compression level and target sizes\n"
); );
ZstdCompressionParametersObject* CompressionParameters_from_level(PyObject* undef, PyObject* args, PyObject* kwargs) { ZstdCompressionParametersObject* CompressionParameters_from_level(PyObject* undef, PyObject* args, PyObject* kwargs) {
goto cleanup; goto cleanup;
} }
PyDict_SetItemString(kwargs, "search_log", val); PyDict_SetItemString(kwargs, "search_log", val);
Py_DECREF(val); Py_DECREF(val);
} }
val = PyDict_GetItemString(kwargs, "min_match"); val = PyDict_GetItemString(kwargs, "min_match");
if (!val) { if (!val) {
val = PyLong_FromUnsignedLong(params.searchLength); val = PyLong_FromUnsignedLong(params.minMatch);
if (!val) { if (!val) {
goto cleanup; goto cleanup;
} }
PyDict_SetItemString(kwargs, "min_match", val); PyDict_SetItemString(kwargs, "min_match", val);
Py_DECREF(val); Py_DECREF(val);
} }
val = PyDict_GetItemString(kwargs, "target_length"); val = PyDict_GetItemString(kwargs, "target_length");
if (self->params) { if (self->params) {
ZSTD_freeCCtxParams(self->params); ZSTD_freeCCtxParams(self->params);
self->params = NULL; self->params = NULL;
} }
PyObject_Del(self); PyObject_Del(self);
} }
#define PARAM_GETTER(name, param) PyObject* ZstdCompressionParameters_get_##name(PyObject* self, void* unused) { \
int result; \
size_t zresult; \
ZstdCompressionParametersObject* p = (ZstdCompressionParametersObject*)(self); \
zresult = ZSTD_CCtxParam_getParameter(p->params, param, &result); \
if (ZSTD_isError(zresult)) { \
PyErr_Format(ZstdError, "unable to get compression parameter: %s", \
ZSTD_getErrorName(zresult)); \
return NULL; \
} \
return PyLong_FromLong(result); \
}
PARAM_GETTER(format, ZSTD_c_format)
PARAM_GETTER(compression_level, ZSTD_c_compressionLevel)
PARAM_GETTER(window_log, ZSTD_c_windowLog)
PARAM_GETTER(hash_log, ZSTD_c_hashLog)
PARAM_GETTER(chain_log, ZSTD_c_chainLog)
PARAM_GETTER(search_log, ZSTD_c_searchLog)
PARAM_GETTER(min_match, ZSTD_c_minMatch)
PARAM_GETTER(target_length, ZSTD_c_targetLength)
PARAM_GETTER(compression_strategy, ZSTD_c_strategy)
PARAM_GETTER(write_content_size, ZSTD_c_contentSizeFlag)
PARAM_GETTER(write_checksum, ZSTD_c_checksumFlag)
PARAM_GETTER(write_dict_id, ZSTD_c_dictIDFlag)
PARAM_GETTER(job_size, ZSTD_c_jobSize)
PARAM_GETTER(overlap_log, ZSTD_c_overlapLog)
PARAM_GETTER(force_max_window, ZSTD_c_forceMaxWindow)
PARAM_GETTER(enable_ldm, ZSTD_c_enableLongDistanceMatching)
PARAM_GETTER(ldm_hash_log, ZSTD_c_ldmHashLog)
PARAM_GETTER(ldm_min_match, ZSTD_c_ldmMinMatch)
PARAM_GETTER(ldm_bucket_size_log, ZSTD_c_ldmBucketSizeLog)
PARAM_GETTER(ldm_hash_rate_log, ZSTD_c_ldmHashRateLog)
PARAM_GETTER(threads, ZSTD_c_nbWorkers)
static PyMethodDef ZstdCompressionParameters_methods[] = { static PyMethodDef ZstdCompressionParameters_methods[] = {
{ {
"from_level", "from_level",
(PyCFunction)CompressionParameters_from_level, (PyCFunction)CompressionParameters_from_level,
METH_VARARGS | METH_KEYWORDS | METH_STATIC, METH_VARARGS | METH_KEYWORDS | METH_STATIC,
ZstdCompressionParameters_from_level__doc__ ZstdCompressionParameters_from_level__doc__
}, },
{ {
"estimated_compression_context_size", "estimated_compression_context_size",
(PyCFunction)ZstdCompressionParameters_estimated_compression_context_size, (PyCFunction)ZstdCompressionParameters_estimated_compression_context_size,
METH_NOARGS, METH_NOARGS,
ZstdCompressionParameters_estimated_compression_context_size__doc__ ZstdCompressionParameters_estimated_compression_context_size__doc__
}, },
{ NULL, NULL } { NULL, NULL }
}; };
static PyMemberDef ZstdCompressionParameters_members[] = { #define GET_SET_ENTRY(name) { #name, ZstdCompressionParameters_get_##name, NULL, NULL, NULL }
{ "format", T_UINT,
offsetof(ZstdCompressionParametersObject, format), READONLY, static PyGetSetDef ZstdCompressionParameters_getset[] = {
"compression format" }, GET_SET_ENTRY(format),
{ "compression_level", T_INT, GET_SET_ENTRY(compression_level),
offsetof(ZstdCompressionParametersObject, compressionLevel), READONLY, GET_SET_ENTRY(window_log),
"compression level" }, GET_SET_ENTRY(hash_log),
{ "window_log", T_UINT, GET_SET_ENTRY(chain_log),
offsetof(ZstdCompressionParametersObject, windowLog), READONLY, GET_SET_ENTRY(search_log),
"window log" }, GET_SET_ENTRY(min_match),
{ "hash_log", T_UINT, GET_SET_ENTRY(target_length),
offsetof(ZstdCompressionParametersObject, hashLog), READONLY, GET_SET_ENTRY(compression_strategy),
"hash log" }, GET_SET_ENTRY(write_content_size),
{ "chain_log", T_UINT, GET_SET_ENTRY(write_checksum),
offsetof(ZstdCompressionParametersObject, chainLog), READONLY, GET_SET_ENTRY(write_dict_id),
"chain log" }, GET_SET_ENTRY(threads),
{ "search_log", T_UINT, GET_SET_ENTRY(job_size),
offsetof(ZstdCompressionParametersObject, searchLog), READONLY, GET_SET_ENTRY(overlap_log),
"search log" }, /* TODO remove this deprecated attribute */
{ "min_match", T_UINT, { "overlap_size_log", ZstdCompressionParameters_get_overlap_log, NULL, NULL, NULL },
offsetof(ZstdCompressionParametersObject, minMatch), READONLY, GET_SET_ENTRY(force_max_window),
"search length" }, GET_SET_ENTRY(enable_ldm),
{ "target_length", T_UINT, GET_SET_ENTRY(ldm_hash_log),
offsetof(ZstdCompressionParametersObject, targetLength), READONLY, GET_SET_ENTRY(ldm_min_match),
"target length" }, GET_SET_ENTRY(ldm_bucket_size_log),
{ "compression_strategy", T_UINT, GET_SET_ENTRY(ldm_hash_rate_log),
offsetof(ZstdCompressionParametersObject, compressionStrategy), READONLY, /* TODO remove this deprecated attribute */
"compression strategy" }, { "ldm_hash_every_log", ZstdCompressionParameters_get_ldm_hash_rate_log, NULL, NULL, NULL },
{ "write_content_size", T_UINT,
offsetof(ZstdCompressionParametersObject, contentSizeFlag), READONLY,
"whether to write content size in frames" },
{ "write_checksum", T_UINT,
offsetof(ZstdCompressionParametersObject, checksumFlag), READONLY,
"whether to write checksum in frames" },
{ "write_dict_id", T_UINT,
offsetof(ZstdCompressionParametersObject, dictIDFlag), READONLY,
"whether to write dictionary ID in frames" },
{ "threads", T_UINT,
offsetof(ZstdCompressionParametersObject, threads), READONLY,
"number of threads to use" },
{ "job_size", T_UINT,
offsetof(ZstdCompressionParametersObject, jobSize), READONLY,
"size of compression job when using multiple threads" },
{ "overlap_size_log", T_UINT,
offsetof(ZstdCompressionParametersObject, overlapSizeLog), READONLY,
"Size of previous input reloaded at the beginning of each job" },
{ "force_max_window", T_UINT,
offsetof(ZstdCompressionParametersObject, forceMaxWindow), READONLY,
"force back references to remain smaller than window size" },
{ "enable_ldm", T_UINT,
offsetof(ZstdCompressionParametersObject, enableLongDistanceMatching), READONLY,
"whether to enable long distance matching" },
{ "ldm_hash_log", T_UINT,
offsetof(ZstdCompressionParametersObject, ldmHashLog), READONLY,
"Size of the table for long distance matching, as a power of 2" },
{ "ldm_min_match", T_UINT,
offsetof(ZstdCompressionParametersObject, ldmMinMatch), READONLY,
"minimum size of searched matches for long distance matcher" },
{ "ldm_bucket_size_log", T_UINT,
offsetof(ZstdCompressionParametersObject, ldmBucketSizeLog), READONLY,
"log size of each bucket in the LDM hash table for collision resolution" },
{ "ldm_hash_every_log", T_UINT,
offsetof(ZstdCompressionParametersObject, ldmHashEveryLog), READONLY,
"frequency of inserting/looking up entries in the LDM hash table" },
{ NULL } { NULL }
}; };
PyTypeObject ZstdCompressionParametersType = { PyTypeObject ZstdCompressionParametersType = {
PyVarObject_HEAD_INIT(NULL, 0) PyVarObject_HEAD_INIT(NULL, 0)
"ZstdCompressionParameters", /* tp_name */ "ZstdCompressionParameters", /* tp_name */
sizeof(ZstdCompressionParametersObject), /* tp_basicsize */ sizeof(ZstdCompressionParametersObject), /* tp_basicsize */
0, /* tp_itemsize */ 0, /* tp_itemsize */
ZstdCompressionParameters__doc__, /* tp_doc */ ZstdCompressionParameters__doc__, /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
0, /* tp_weaklistoffset */ 0, /* tp_weaklistoffset */
0, /* tp_iter */ 0, /* tp_iter */
0, /* tp_iternext */ 0, /* tp_iternext */
ZstdCompressionParameters_methods, /* tp_methods */ ZstdCompressionParameters_methods, /* tp_methods */
ZstdCompressionParameters_members, /* tp_members */ 0, /* tp_members */
0, /* tp_getset */ ZstdCompressionParameters_getset, /* tp_getset */
0, /* tp_base */ 0, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
(initproc)ZstdCompressionParameters_init, /* tp_init */ (initproc)ZstdCompressionParameters_init, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */
PyType_GenericNew, /* tp_new */ PyType_GenericNew, /* tp_new */

contrib/python-zstandard/c-ext/compressionreader.c

Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyObject* reader_tell(ZstdCompressionReader* self) { static PyObject* reader_tell(ZstdCompressionReader* self) {
/* TODO should this raise OSError since stream isn't seekable? */ /* TODO should this raise OSError since stream isn't seekable? */
return PyLong_FromUnsignedLongLong(self->bytesCompressed); return PyLong_FromUnsignedLongLong(self->bytesCompressed);
} }
int read_compressor_input(ZstdCompressionReader* self) {
if (self->finishedInput) {
return 0;
}
if (self->input.pos != self->input.size) {
return 0;
}
if (self->reader) {
Py_buffer buffer;
assert(self->readResult == NULL);
self->readResult = PyObject_CallMethod(self->reader, "read",
"k", self->readSize);
if (NULL == self->readResult) {
return -1;
}
memset(&buffer, 0, sizeof(buffer));
if (0 != PyObject_GetBuffer(self->readResult, &buffer, PyBUF_CONTIG_RO)) {
return -1;
}
/* EOF */
if (0 == buffer.len) {
self->finishedInput = 1;
Py_CLEAR(self->readResult);
}
else {
self->input.src = buffer.buf;
self->input.size = buffer.len;
self->input.pos = 0;
}
PyBuffer_Release(&buffer);
}
else {
assert(self->buffer.buf);
self->input.src = self->buffer.buf;
self->input.size = self->buffer.len;
self->input.pos = 0;
}
return 1;
}
int compress_input(ZstdCompressionReader* self, ZSTD_outBuffer* output) {
size_t oldPos;
size_t zresult;
/* If we have data left over, consume it. */
if (self->input.pos < self->input.size) {
oldPos = output->pos;
Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_compressStream2(self->compressor->cctx,
output, &self->input, ZSTD_e_continue);
Py_END_ALLOW_THREADS
self->bytesCompressed += output->pos - oldPos;
/* Input exhausted. Clear out state tracking. */
if (self->input.pos == self->input.size) {
memset(&self->input, 0, sizeof(self->input));
Py_CLEAR(self->readResult);
if (self->buffer.buf) {
self->finishedInput = 1;
}
}
if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "zstd compress error: %s", ZSTD_getErrorName(zresult));
return -1;
}
}
if (output->pos && output->pos == output->size) {
return 1;
}
else {
return 0;
}
}
static PyObject* reader_read(ZstdCompressionReader* self, PyObject* args, PyObject* kwargs) { static PyObject* reader_read(ZstdCompressionReader* self, PyObject* args, PyObject* kwargs) {
static char* kwlist[] = { static char* kwlist[] = {
"size", "size",
NULL NULL
}; };
Py_ssize_t size = -1; Py_ssize_t size = -1;
PyObject* result = NULL; PyObject* result = NULL;
char* resultBuffer; char* resultBuffer;
Py_ssize_t resultSize; Py_ssize_t resultSize;
size_t zresult; size_t zresult;
size_t oldPos; size_t oldPos;
int readResult, compressResult;
if (self->closed) { if (self->closed) {
PyErr_SetString(PyExc_ValueError, "stream is closed"); PyErr_SetString(PyExc_ValueError, "stream is closed");
return NULL; return NULL;
} }
if (self->finishedOutput) { if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|n", kwlist, &size)) {
return PyBytes_FromStringAndSize("", 0); return NULL;
} }
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "n", kwlist, &size)) { if (size < -1) {
PyErr_SetString(PyExc_ValueError, "cannot read negative amounts less than -1");
return NULL; return NULL;
} }
if (size < 1) { if (size == -1) {
PyErr_SetString(PyExc_ValueError, "cannot read negative or size 0 amounts"); return PyObject_CallMethod((PyObject*)self, "readall", NULL);
return NULL; }
if (self->finishedOutput || size == 0) {
return PyBytes_FromStringAndSize("", 0);
} }
result = PyBytes_FromStringAndSize(NULL, size); result = PyBytes_FromStringAndSize(NULL, size);
if (NULL == result) { if (NULL == result) {
return NULL; return NULL;
} }
PyBytes_AsStringAndSize(result, &resultBuffer, &resultSize); PyBytes_AsStringAndSize(result, &resultBuffer, &resultSize);
self->output.dst = resultBuffer; self->output.dst = resultBuffer;
self->output.size = resultSize; self->output.size = resultSize;
self->output.pos = 0; self->output.pos = 0;
readinput: readinput:
/* If we have data left over, consume it. */ compressResult = compress_input(self, &self->output);
if (self->input.pos < self->input.size) {
oldPos = self->output.pos;
Py_BEGIN_ALLOW_THREADS if (-1 == compressResult) {
zresult = ZSTD_compress_generic(self->compressor->cctx, Py_XDECREF(result);
&self->output, &self->input, ZSTD_e_continue); return NULL;
}
else if (0 == compressResult) {
/* There is room in the output. We fall through to below, which will
* either get more input for us or will attempt to end the stream.
*/
}
else if (1 == compressResult) {
memset(&self->output, 0, sizeof(self->output));
return result;
}
else {
assert(0);
}
Py_END_ALLOW_THREADS readResult = read_compressor_input(self);
self->bytesCompressed += self->output.pos - oldPos; if (-1 == readResult) {
return NULL;
}
else if (0 == readResult) { }
else if (1 == readResult) { }
else {
assert(0);
}
/* Input exhausted. Clear out state tracking. */ if (self->input.size) {
if (self->input.pos == self->input.size) { goto readinput;
memset(&self->input, 0, sizeof(self->input)); }
Py_CLEAR(self->readResult);
if (self->buffer.buf) { /* Else EOF */
self->finishedInput = 1; oldPos = self->output.pos;
zresult = ZSTD_compressStream2(self->compressor->cctx, &self->output,
&self->input, ZSTD_e_end);
self->bytesCompressed += self->output.pos - oldPos;
if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "error ending compression stream: %s",
ZSTD_getErrorName(zresult));
Py_XDECREF(result);
return NULL;
} }
assert(self->output.pos);
if (0 == zresult) {
self->finishedOutput = 1;
} }
if (ZSTD_isError(zresult)) { if (safe_pybytes_resize(&result, self->output.pos)) {
PyErr_Format(ZstdError, "zstd compress error: %s", ZSTD_getErrorName(zresult)); Py_XDECREF(result);
return NULL; return NULL;
} }
if (self->output.pos) {
/* If no more room in output, emit it. */
if (self->output.pos == self->output.size) {
memset(&self->output, 0, sizeof(self->output)); memset(&self->output, 0, sizeof(self->output));
return result; return result;
} }
/* static PyObject* reader_read1(ZstdCompressionReader* self, PyObject* args, PyObject* kwargs) {
* There is room in the output. We fall through to below, which will either static char* kwlist[] = {
* get more input for us or will attempt to end the stream. "size",
NULL
};
Py_ssize_t size = -1;
PyObject* result = NULL;
char* resultBuffer;
Py_ssize_t resultSize;
ZSTD_outBuffer output;
int compressResult;
size_t oldPos;
size_t zresult;
if (self->closed) {
PyErr_SetString(PyExc_ValueError, "stream is closed");
return NULL;
}
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|n:read1", kwlist, &size)) {
return NULL;
}
if (size < -1) {
PyErr_SetString(PyExc_ValueError, "cannot read negative amounts less than -1");
return NULL;
}
if (self->finishedOutput || size == 0) {
return PyBytes_FromStringAndSize("", 0);
}
if (size == -1) {
size = ZSTD_CStreamOutSize();
}
result = PyBytes_FromStringAndSize(NULL, size);
if (NULL == result) {
return NULL;
}
PyBytes_AsStringAndSize(result, &resultBuffer, &resultSize);
output.dst = resultBuffer;
output.size = resultSize;
output.pos = 0;
/* read1() is supposed to use at most 1 read() from the underlying stream.
However, we can't satisfy this requirement with compression because
not every input will generate output. We /could/ flush the compressor,
but this may not be desirable. We allow multiple read() from the
underlying stream. But unlike read(), we return as soon as output data
is available.
*/ */
compressResult = compress_input(self, &output);
if (-1 == compressResult) {
Py_XDECREF(result);
return NULL;
}
else if (0 == compressResult || 1 == compressResult) { }
else {
assert(0);
} }
/* Fall through to gather more input. */ if (output.pos) {
goto finally;
} }
if (!self->finishedInput) { while (!self->finishedInput) {
if (self->reader) { int readResult = read_compressor_input(self);
Py_buffer buffer;
assert(self->readResult == NULL); if (-1 == readResult) {
self->readResult = PyObject_CallMethod(self->reader, "read", Py_XDECREF(result);
"k", self->readSize);
if (self->readResult == NULL) {
return NULL; return NULL;
} }
else if (0 == readResult || 1 == readResult) { }
else {
assert(0);
}
memset(&buffer, 0, sizeof(buffer)); compressResult = compress_input(self, &output);
if (0 != PyObject_GetBuffer(self->readResult, &buffer, PyBUF_CONTIG_RO)) { if (-1 == compressResult) {
Py_XDECREF(result);
return NULL; return NULL;
} }
else if (0 == compressResult || 1 == compressResult) { }
else {
assert(0);
}
if (output.pos) {
goto finally;
}
}
/* EOF */ /* EOF */
if (0 == buffer.len) { oldPos = output.pos;
self->finishedInput = 1;
Py_CLEAR(self->readResult); zresult = ZSTD_compressStream2(self->compressor->cctx, &output, &self->input,
ZSTD_e_end);
self->bytesCompressed += output.pos - oldPos;
if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "error ending compression stream: %s",
ZSTD_getErrorName(zresult));
Py_XDECREF(result);
return NULL;
} }
else {
self->input.src = buffer.buf; if (zresult == 0) {
self->input.size = buffer.len; self->finishedOutput = 1;
self->input.pos = 0;
} }
PyBuffer_Release(&buffer); finally:
if (result) {
if (safe_pybytes_resize(&result, output.pos)) {
Py_XDECREF(result);
return NULL;
}
}
return result;
}
static PyObject* reader_readall(PyObject* self) {
PyObject* chunks = NULL;
PyObject* empty = NULL;
PyObject* result = NULL;
/* Our strategy is to collect chunks into a list then join all the
* chunks at the end. We could potentially use e.g. an io.BytesIO. But
* this feels simple enough to implement and avoids potentially expensive
* reallocations of large buffers.
*/
chunks = PyList_New(0);
if (NULL == chunks) {
return NULL;
}
while (1) {
PyObject* chunk = PyObject_CallMethod(self, "read", "i", 1048576);
if (NULL == chunk) {
Py_DECREF(chunks);
return NULL;
}
if (!PyBytes_Size(chunk)) {
Py_DECREF(chunk);
break;
}
if (PyList_Append(chunks, chunk)) {
Py_DECREF(chunk);
Py_DECREF(chunks);
return NULL;
}
Py_DECREF(chunk);
}
empty = PyBytes_FromStringAndSize("", 0);
if (NULL == empty) {
Py_DECREF(chunks);
return NULL;
}
result = PyObject_CallMethod(empty, "join", "O", chunks);
Py_DECREF(empty);
Py_DECREF(chunks);
return result;
}
static PyObject* reader_readinto(ZstdCompressionReader* self, PyObject* args) {
Py_buffer dest;
ZSTD_outBuffer output;
int readResult, compressResult;
PyObject* result = NULL;
size_t zresult;
size_t oldPos;
if (self->closed) {
PyErr_SetString(PyExc_ValueError, "stream is closed");
return NULL;
}
if (self->finishedOutput) {
return PyLong_FromLong(0);
}
if (!PyArg_ParseTuple(args, "w*:readinto", &dest)) {
return NULL;
}
if (!PyBuffer_IsContiguous(&dest, 'C') || dest.ndim > 1) {
PyErr_SetString(PyExc_ValueError,
"destination buffer should be contiguous and have at most one dimension");
goto finally;
}
output.dst = dest.buf;
output.size = dest.len;
output.pos = 0;
compressResult = compress_input(self, &output);
if (-1 == compressResult) {
goto finally;
}
else if (0 == compressResult) { }
else if (1 == compressResult) {
result = PyLong_FromSize_t(output.pos);
goto finally;
} }
else { else {
assert(self->buffer.buf); assert(0);
}
self->input.src = self->buffer.buf; while (!self->finishedInput) {
self->input.size = self->buffer.len; readResult = read_compressor_input(self);
self->input.pos = 0;
if (-1 == readResult) {
goto finally;
} }
else if (0 == readResult || 1 == readResult) {}
else {
assert(0);
} }
if (self->input.size) { compressResult = compress_input(self, &output);
goto readinput;
if (-1 == compressResult) {
goto finally;
}
else if (0 == compressResult) { }
else if (1 == compressResult) {
result = PyLong_FromSize_t(output.pos);
goto finally;
}
else {
assert(0);
}
} }
/* Else EOF */ /* EOF */
oldPos = self->output.pos; oldPos = output.pos;
zresult = ZSTD_compress_generic(self->compressor->cctx, &self->output, zresult = ZSTD_compressStream2(self->compressor->cctx, &output, &self->input,
&self->input, ZSTD_e_end); ZSTD_e_end);
self->bytesCompressed += self->output.pos - oldPos; self->bytesCompressed += self->output.pos - oldPos;
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "error ending compression stream: %s", PyErr_Format(ZstdError, "error ending compression stream: %s",
ZSTD_getErrorName(zresult)); ZSTD_getErrorName(zresult));
return NULL; goto finally;
} }
assert(self->output.pos); assert(output.pos);
if (0 == zresult) { if (0 == zresult) {
self->finishedOutput = 1; self->finishedOutput = 1;
} }
if (safe_pybytes_resize(&result, self->output.pos)) { result = PyLong_FromSize_t(output.pos);
Py_XDECREF(result);
return NULL;
}
memset(&self->output, 0, sizeof(self->output)); finally:
PyBuffer_Release(&dest);
return result; return result;
} }
static PyObject* reader_readall(PyObject* self) { static PyObject* reader_readinto1(ZstdCompressionReader* self, PyObject* args) {
PyErr_SetNone(PyExc_NotImplementedError); Py_buffer dest;
PyObject* result = NULL;
ZSTD_outBuffer output;
int compressResult;
size_t oldPos;
size_t zresult;
if (self->closed) {
PyErr_SetString(PyExc_ValueError, "stream is closed");
return NULL; return NULL;
} }
if (self->finishedOutput) {
return PyLong_FromLong(0);
}
if (!PyArg_ParseTuple(args, "w*:readinto1", &dest)) {
return NULL;
}
if (!PyBuffer_IsContiguous(&dest, 'C') || dest.ndim > 1) {
PyErr_SetString(PyExc_ValueError,
"destination buffer should be contiguous and have at most one dimension");
goto finally;
}
output.dst = dest.buf;
output.size = dest.len;
output.pos = 0;
compressResult = compress_input(self, &output);
if (-1 == compressResult) {
goto finally;
}
else if (0 == compressResult || 1 == compressResult) { }
else {
assert(0);
}
if (output.pos) {
result = PyLong_FromSize_t(output.pos);
goto finally;
}
while (!self->finishedInput) {
int readResult = read_compressor_input(self);
if (-1 == readResult) {
goto finally;
}
else if (0 == readResult || 1 == readResult) { }
else {
assert(0);
}
compressResult = compress_input(self, &output);
if (-1 == compressResult) {
goto finally;
}
else if (0 == compressResult) { }
else if (1 == compressResult) {
result = PyLong_FromSize_t(output.pos);
goto finally;
}
else {
assert(0);
}
/* If we produced output and we're not done with input, emit
* that output now, as we've hit restrictions of read1().
*/
if (output.pos && !self->finishedInput) {
result = PyLong_FromSize_t(output.pos);
goto finally;
}
/* Otherwise we either have no output or we've exhausted the
* input. Either we try to get more input or we fall through
* to EOF below */
}
/* EOF */
oldPos = output.pos;
zresult = ZSTD_compressStream2(self->compressor->cctx, &output, &self->input,
ZSTD_e_end);
self->bytesCompressed += self->output.pos - oldPos;
if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "error ending compression stream: %s",
ZSTD_getErrorName(zresult));
goto finally;
}
assert(output.pos);
if (0 == zresult) {
self->finishedOutput = 1;
}
result = PyLong_FromSize_t(output.pos);
finally:
PyBuffer_Release(&dest);
return result;
}
static PyObject* reader_iter(PyObject* self) { static PyObject* reader_iter(PyObject* self) {
set_unsupported_operation(); set_unsupported_operation();
return NULL; return NULL;
} }
static PyObject* reader_iternext(PyObject* self) { static PyObject* reader_iternext(PyObject* self) {
set_unsupported_operation(); set_unsupported_operation();
return NULL; return NULL;
} }
static PyMethodDef reader_methods[] = { static PyMethodDef reader_methods[] = {
{ "__enter__", (PyCFunction)reader_enter, METH_NOARGS, { "__enter__", (PyCFunction)reader_enter, METH_NOARGS,
PyDoc_STR("Enter a compression context") }, PyDoc_STR("Enter a compression context") },
{ "__exit__", (PyCFunction)reader_exit, METH_VARARGS, { "__exit__", (PyCFunction)reader_exit, METH_VARARGS,
PyDoc_STR("Exit a compression context") }, PyDoc_STR("Exit a compression context") },
{ "close", (PyCFunction)reader_close, METH_NOARGS, { "close", (PyCFunction)reader_close, METH_NOARGS,
PyDoc_STR("Close the stream so it cannot perform any more operations") }, PyDoc_STR("Close the stream so it cannot perform any more operations") },
{ "flush", (PyCFunction)reader_flush, METH_NOARGS, PyDoc_STR("no-ops") }, { "flush", (PyCFunction)reader_flush, METH_NOARGS, PyDoc_STR("no-ops") },
{ "isatty", (PyCFunction)reader_isatty, METH_NOARGS, PyDoc_STR("Returns False") }, { "isatty", (PyCFunction)reader_isatty, METH_NOARGS, PyDoc_STR("Returns False") },
{ "readable", (PyCFunction)reader_readable, METH_NOARGS, { "readable", (PyCFunction)reader_readable, METH_NOARGS,
PyDoc_STR("Returns True") }, PyDoc_STR("Returns True") },
{ "read", (PyCFunction)reader_read, METH_VARARGS | METH_KEYWORDS, PyDoc_STR("read compressed data") }, { "read", (PyCFunction)reader_read, METH_VARARGS | METH_KEYWORDS, PyDoc_STR("read compressed data") },
{ "read1", (PyCFunction)reader_read1, METH_VARARGS | METH_KEYWORDS, NULL },
{ "readall", (PyCFunction)reader_readall, METH_NOARGS, PyDoc_STR("Not implemented") }, { "readall", (PyCFunction)reader_readall, METH_NOARGS, PyDoc_STR("Not implemented") },
{ "readinto", (PyCFunction)reader_readinto, METH_VARARGS, NULL },
{ "readinto1", (PyCFunction)reader_readinto1, METH_VARARGS, NULL },
{ "readline", (PyCFunction)reader_readline, METH_VARARGS, PyDoc_STR("Not implemented") }, { "readline", (PyCFunction)reader_readline, METH_VARARGS, PyDoc_STR("Not implemented") },
{ "readlines", (PyCFunction)reader_readlines, METH_VARARGS, PyDoc_STR("Not implemented") }, { "readlines", (PyCFunction)reader_readlines, METH_VARARGS, PyDoc_STR("Not implemented") },
{ "seekable", (PyCFunction)reader_seekable, METH_NOARGS, { "seekable", (PyCFunction)reader_seekable, METH_NOARGS,
PyDoc_STR("Returns False") }, PyDoc_STR("Returns False") },
{ "tell", (PyCFunction)reader_tell, METH_NOARGS, { "tell", (PyCFunction)reader_tell, METH_NOARGS,
PyDoc_STR("Returns current number of bytes compressed") }, PyDoc_STR("Returns current number of bytes compressed") },
{ "writable", (PyCFunction)reader_writable, METH_NOARGS, { "writable", (PyCFunction)reader_writable, METH_NOARGS,
PyDoc_STR("Returns False") }, PyDoc_STR("Returns False") },

contrib/python-zstandard/c-ext/compressionwriter.c

PyDoc_STRVAR(ZstdCompresssionWriter__doc__, PyDoc_STRVAR(ZstdCompresssionWriter__doc__,
"""A context manager used for writing compressed output to a writer.\n" """A context manager used for writing compressed output to a writer.\n"
); );
static void ZstdCompressionWriter_dealloc(ZstdCompressionWriter* self) { static void ZstdCompressionWriter_dealloc(ZstdCompressionWriter* self) {
Py_XDECREF(self->compressor); Py_XDECREF(self->compressor);
Py_XDECREF(self->writer); Py_XDECREF(self->writer);
PyMem_Free(self->output.dst);
self->output.dst = NULL;
PyObject_Del(self); PyObject_Del(self);
} }
static PyObject* ZstdCompressionWriter_enter(ZstdCompressionWriter* self) { static PyObject* ZstdCompressionWriter_enter(ZstdCompressionWriter* self) {
size_t zresult; if (self->closed) {
PyErr_SetString(PyExc_ValueError, "stream is closed");
if (self->entered) {
PyErr_SetString(ZstdError, "cannot __enter__ multiple times");
return NULL; return NULL;
} }
zresult = ZSTD_CCtx_setPledgedSrcSize(self->compressor->cctx, self->sourceSize); if (self->entered) {
if (ZSTD_isError(zresult)) { PyErr_SetString(ZstdError, "cannot __enter__ multiple times");
PyErr_Format(ZstdError, "error setting source size: %s",
ZSTD_getErrorName(zresult));
return NULL; return NULL;
} }
self->entered = 1; self->entered = 1;
Py_INCREF(self); Py_INCREF(self);
return (PyObject*)self; return (PyObject*)self;
} }
static PyObject* ZstdCompressionWriter_exit(ZstdCompressionWriter* self, PyObject* args) { static PyObject* ZstdCompressionWriter_exit(ZstdCompressionWriter* self, PyObject* args) {
PyObject* exc_type; PyObject* exc_type;
PyObject* exc_value; PyObject* exc_value;
PyObject* exc_tb; PyObject* exc_tb;
size_t zresult;
ZSTD_outBuffer output;
PyObject* res;
if (!PyArg_ParseTuple(args, "OOO:__exit__", &exc_type, &exc_value, &exc_tb)) { if (!PyArg_ParseTuple(args, "OOO:__exit__", &exc_type, &exc_value, &exc_tb)) {
return NULL; return NULL;
} }
self->entered = 0; self->entered = 0;
if (exc_type == Py_None && exc_value == Py_None && exc_tb == Py_None) { if (exc_type == Py_None && exc_value == Py_None && exc_tb == Py_None) {
ZSTD_inBuffer inBuffer; PyObject* result = PyObject_CallMethod((PyObject*)self, "close", NULL);
inBuffer.src = NULL; if (NULL == result) {
inBuffer.size = 0;
inBuffer.pos = 0;
output.dst = PyMem_Malloc(self->outSize);
if (!output.dst) {
return PyErr_NoMemory();
}
output.size = self->outSize;
output.pos = 0;
while (1) {
zresult = ZSTD_compress_generic(self->compressor->cctx, &output, &inBuffer, ZSTD_e_end);
if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "error ending compression stream: %s",
ZSTD_getErrorName(zresult));
PyMem_Free(output.dst);
return NULL; return NULL;
} }
if (output.pos) {
#if PY_MAJOR_VERSION >= 3
res = PyObject_CallMethod(self->writer, "write", "y#",
#else
res = PyObject_CallMethod(self->writer, "write", "s#",
#endif
output.dst, output.pos);
Py_XDECREF(res);
}
if (!zresult) {
break;
}
output.pos = 0;
}
PyMem_Free(output.dst);
} }
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
static PyObject* ZstdCompressionWriter_memory_size(ZstdCompressionWriter* self) { static PyObject* ZstdCompressionWriter_memory_size(ZstdCompressionWriter* self) {
return PyLong_FromSize_t(ZSTD_sizeof_CCtx(self->compressor->cctx)); return PyLong_FromSize_t(ZSTD_sizeof_CCtx(self->compressor->cctx));
} }
static PyObject* ZstdCompressionWriter_write(ZstdCompressionWriter* self, PyObject* args, PyObject* kwargs) { static PyObject* ZstdCompressionWriter_write(ZstdCompressionWriter* self, PyObject* args, PyObject* kwargs) {
static char* kwlist[] = { static char* kwlist[] = {
"data", "data",
NULL NULL
}; };
PyObject* result = NULL; PyObject* result = NULL;
Py_buffer source; Py_buffer source;
size_t zresult; size_t zresult;
ZSTD_inBuffer input; ZSTD_inBuffer input;
ZSTD_outBuffer output;
PyObject* res; PyObject* res;
Py_ssize_t totalWrite = 0; Py_ssize_t totalWrite = 0;
#if PY_MAJOR_VERSION >= 3 #if PY_MAJOR_VERSION >= 3
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*:write", if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*:write",
#else #else
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s*:write", if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s*:write",
#endif #endif
kwlist, &source)) { kwlist, &source)) {
return NULL; return NULL;
} }
if (!self->entered) {
PyErr_SetString(ZstdError, "compress must be called from an active context manager");
goto finally;
}
if (!PyBuffer_IsContiguous(&source, 'C') || source.ndim > 1) { if (!PyBuffer_IsContiguous(&source, 'C') || source.ndim > 1) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"data buffer should be contiguous and have at most one dimension"); "data buffer should be contiguous and have at most one dimension");
goto finally; goto finally;
} }
output.dst = PyMem_Malloc(self->outSize); if (self->closed) {
if (!output.dst) { PyErr_SetString(PyExc_ValueError, "stream is closed");
PyErr_NoMemory(); return NULL;
goto finally;
} }
output.size = self->outSize;
output.pos = 0; self->output.pos = 0;
input.src = source.buf; input.src = source.buf;
input.size = source.len; input.size = source.len;
input.pos = 0; input.pos = 0;
while ((ssize_t)input.pos < source.len) { while (input.pos < (size_t)source.len) {
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_compress_generic(self->compressor->cctx, &output, &input, ZSTD_e_continue); zresult = ZSTD_compressStream2(self->compressor->cctx, &self->output, &input, ZSTD_e_continue);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyMem_Free(output.dst);
PyErr_Format(ZstdError, "zstd compress error: %s", ZSTD_getErrorName(zresult)); PyErr_Format(ZstdError, "zstd compress error: %s", ZSTD_getErrorName(zresult));
goto finally; goto finally;
} }
/* Copy data from output buffer to writer. */ /* Copy data from output buffer to writer. */
if (output.pos) { if (self->output.pos) {
#if PY_MAJOR_VERSION >= 3 #if PY_MAJOR_VERSION >= 3
res = PyObject_CallMethod(self->writer, "write", "y#", res = PyObject_CallMethod(self->writer, "write", "y#",
#else #else
res = PyObject_CallMethod(self->writer, "write", "s#", res = PyObject_CallMethod(self->writer, "write", "s#",
#endif #endif
output.dst, output.pos); self->output.dst, self->output.pos);
Py_XDECREF(res); Py_XDECREF(res);
totalWrite += output.pos; totalWrite += self->output.pos;
self->bytesCompressed += output.pos; self->bytesCompressed += self->output.pos;
} }
output.pos = 0; self->output.pos = 0;
} }
PyMem_Free(output.dst); if (self->writeReturnRead) {
result = PyLong_FromSize_t(input.pos);
}
else {
result = PyLong_FromSsize_t(totalWrite); result = PyLong_FromSsize_t(totalWrite);
}
finally: finally:
PyBuffer_Release(&source); PyBuffer_Release(&source);
return result; return result;
} }
static PyObject* ZstdCompressionWriter_flush(ZstdCompressionWriter* self, PyObject* args) { static PyObject* ZstdCompressionWriter_flush(ZstdCompressionWriter* self, PyObject* args, PyObject* kwargs) {
static char* kwlist[] = {
"flush_mode",
NULL
};
size_t zresult; size_t zresult;
ZSTD_outBuffer output;
ZSTD_inBuffer input; ZSTD_inBuffer input;
PyObject* res; PyObject* res;
Py_ssize_t totalWrite = 0; Py_ssize_t totalWrite = 0;
unsigned flush_mode = 0;
ZSTD_EndDirective flush;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|I:flush",
kwlist, &flush_mode)) {
return NULL;
}
if (!self->entered) { switch (flush_mode) {
PyErr_SetString(ZstdError, "flush must be called from an active context manager"); case 0:
flush = ZSTD_e_flush;
break;
case 1:
flush = ZSTD_e_end;
break;
default:
PyErr_Format(PyExc_ValueError, "unknown flush_mode: %d", flush_mode);
return NULL;
}
if (self->closed) {
PyErr_SetString(PyExc_ValueError, "stream is closed");
return NULL; return NULL;
} }
self->output.pos = 0;
input.src = NULL; input.src = NULL;
input.size = 0; input.size = 0;
input.pos = 0; input.pos = 0;
output.dst = PyMem_Malloc(self->outSize);
if (!output.dst) {
return PyErr_NoMemory();
}
output.size = self->outSize;
output.pos = 0;
while (1) { while (1) {
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_compress_generic(self->compressor->cctx, &output, &input, ZSTD_e_flush); zresult = ZSTD_compressStream2(self->compressor->cctx, &self->output, &input, flush);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyMem_Free(output.dst);
PyErr_Format(ZstdError, "zstd compress error: %s", ZSTD_getErrorName(zresult)); PyErr_Format(ZstdError, "zstd compress error: %s", ZSTD_getErrorName(zresult));
return NULL; return NULL;
} }
/* Copy data from output buffer to writer. */ /* Copy data from output buffer to writer. */
if (output.pos) { if (self->output.pos) {
#if PY_MAJOR_VERSION >= 3 #if PY_MAJOR_VERSION >= 3
res = PyObject_CallMethod(self->writer, "write", "y#", res = PyObject_CallMethod(self->writer, "write", "y#",
#else #else
res = PyObject_CallMethod(self->writer, "write", "s#", res = PyObject_CallMethod(self->writer, "write", "s#",
#endif #endif
output.dst, output.pos); self->output.dst, self->output.pos);
Py_XDECREF(res); Py_XDECREF(res);
totalWrite += output.pos; totalWrite += self->output.pos;
self->bytesCompressed += output.pos; self->bytesCompressed += self->output.pos;
} }
output.pos = 0; self->output.pos = 0;
if (!zresult) { if (!zresult) {
break; break;
} }
} }
PyMem_Free(output.dst);
return PyLong_FromSsize_t(totalWrite); return PyLong_FromSsize_t(totalWrite);
} }
static PyObject* ZstdCompressionWriter_close(ZstdCompressionWriter* self) {
PyObject* result;
if (self->closed) {
Py_RETURN_NONE;
}
result = PyObject_CallMethod((PyObject*)self, "flush", "I", 1);
self->closed = 1;
if (NULL == result) {
return NULL;
}
/* Call close on underlying stream as well. */
if (PyObject_HasAttrString(self->writer, "close")) {
return PyObject_CallMethod(self->writer, "close", NULL);
}
Py_RETURN_NONE;
}
static PyObject* ZstdCompressionWriter_fileno(ZstdCompressionWriter* self) {
if (PyObject_HasAttrString(self->writer, "fileno")) {
return PyObject_CallMethod(self->writer, "fileno", NULL);
}
else {
PyErr_SetString(PyExc_OSError, "fileno not available on underlying writer");
return NULL;
}
}
static PyObject* ZstdCompressionWriter_tell(ZstdCompressionWriter* self) { static PyObject* ZstdCompressionWriter_tell(ZstdCompressionWriter* self) {
return PyLong_FromUnsignedLongLong(self->bytesCompressed); return PyLong_FromUnsignedLongLong(self->bytesCompressed);
} }
static PyObject* ZstdCompressionWriter_writelines(PyObject* self, PyObject* args) {
PyErr_SetNone(PyExc_NotImplementedError);
return NULL;
}
static PyObject* ZstdCompressionWriter_false(PyObject* self, PyObject* args) {
Py_RETURN_FALSE;
}
static PyObject* ZstdCompressionWriter_true(PyObject* self, PyObject* args) {
Py_RETURN_TRUE;
}
static PyObject* ZstdCompressionWriter_unsupported(PyObject* self, PyObject* args, PyObject* kwargs) {
PyObject* iomod;
PyObject* exc;
iomod = PyImport_ImportModule("io");
if (NULL == iomod) {
return NULL;
}
exc = PyObject_GetAttrString(iomod, "UnsupportedOperation");
if (NULL == exc) {
Py_DECREF(iomod);
return NULL;
}
PyErr_SetNone(exc);
Py_DECREF(exc);
Py_DECREF(iomod);
return NULL;
}
static PyMethodDef ZstdCompressionWriter_methods[] = { static PyMethodDef ZstdCompressionWriter_methods[] = {
{ "__enter__", (PyCFunction)ZstdCompressionWriter_enter, METH_NOARGS, { "__enter__", (PyCFunction)ZstdCompressionWriter_enter, METH_NOARGS,
PyDoc_STR("Enter a compression context.") }, PyDoc_STR("Enter a compression context.") },
{ "__exit__", (PyCFunction)ZstdCompressionWriter_exit, METH_VARARGS, { "__exit__", (PyCFunction)ZstdCompressionWriter_exit, METH_VARARGS,
PyDoc_STR("Exit a compression context.") }, PyDoc_STR("Exit a compression context.") },
{ "close", (PyCFunction)ZstdCompressionWriter_close, METH_NOARGS, NULL },
{ "fileno", (PyCFunction)ZstdCompressionWriter_fileno, METH_NOARGS, NULL },
{ "isatty", (PyCFunction)ZstdCompressionWriter_false, METH_NOARGS, NULL },
{ "readable", (PyCFunction)ZstdCompressionWriter_false, METH_NOARGS, NULL },
{ "readline", (PyCFunction)ZstdCompressionWriter_unsupported, METH_VARARGS | METH_KEYWORDS, NULL },
{ "readlines", (PyCFunction)ZstdCompressionWriter_unsupported, METH_VARARGS | METH_KEYWORDS, NULL },
{ "seek", (PyCFunction)ZstdCompressionWriter_unsupported, METH_VARARGS | METH_KEYWORDS, NULL },
{ "seekable", ZstdCompressionWriter_false, METH_NOARGS, NULL },
{ "truncate", (PyCFunction)ZstdCompressionWriter_unsupported, METH_VARARGS | METH_KEYWORDS, NULL },
{ "writable", ZstdCompressionWriter_true, METH_NOARGS, NULL },
{ "writelines", ZstdCompressionWriter_writelines, METH_VARARGS, NULL },
{ "read", (PyCFunction)ZstdCompressionWriter_unsupported, METH_VARARGS | METH_KEYWORDS, NULL },
{ "readall", (PyCFunction)ZstdCompressionWriter_unsupported, METH_VARARGS | METH_KEYWORDS, NULL },
{ "readinto", (PyCFunction)ZstdCompressionWriter_unsupported, METH_VARARGS | METH_KEYWORDS, NULL },
{ "memory_size", (PyCFunction)ZstdCompressionWriter_memory_size, METH_NOARGS, { "memory_size", (PyCFunction)ZstdCompressionWriter_memory_size, METH_NOARGS,
PyDoc_STR("Obtain the memory size of the underlying compressor") }, PyDoc_STR("Obtain the memory size of the underlying compressor") },
{ "write", (PyCFunction)ZstdCompressionWriter_write, METH_VARARGS | METH_KEYWORDS, { "write", (PyCFunction)ZstdCompressionWriter_write, METH_VARARGS | METH_KEYWORDS,
PyDoc_STR("Compress data") }, PyDoc_STR("Compress data") },
{ "flush", (PyCFunction)ZstdCompressionWriter_flush, METH_NOARGS, { "flush", (PyCFunction)ZstdCompressionWriter_flush, METH_VARARGS | METH_KEYWORDS,
PyDoc_STR("Flush data and finish a zstd frame") }, PyDoc_STR("Flush data and finish a zstd frame") },
{ "tell", (PyCFunction)ZstdCompressionWriter_tell, METH_NOARGS, { "tell", (PyCFunction)ZstdCompressionWriter_tell, METH_NOARGS,
PyDoc_STR("Returns current number of bytes compressed") }, PyDoc_STR("Returns current number of bytes compressed") },
{ NULL, NULL } { NULL, NULL }
}; };
static PyMemberDef ZstdCompressionWriter_members[] = {
{ "closed", T_BOOL, offsetof(ZstdCompressionWriter, closed), READONLY, NULL },
{ NULL }
};
PyTypeObject ZstdCompressionWriterType = { PyTypeObject ZstdCompressionWriterType = {
PyVarObject_HEAD_INIT(NULL, 0) PyVarObject_HEAD_INIT(NULL, 0)
"zstd.ZstdCompressionWriter", /* tp_name */ "zstd.ZstdCompressionWriter", /* tp_name */
sizeof(ZstdCompressionWriter), /* tp_basicsize */ sizeof(ZstdCompressionWriter), /* tp_basicsize */
0, /* tp_itemsize */ 0, /* tp_itemsize */
(destructor)ZstdCompressionWriter_dealloc, /* tp_dealloc */ (destructor)ZstdCompressionWriter_dealloc, /* tp_dealloc */
0, /* tp_print */ 0, /* tp_print */
0, /* tp_getattr */ 0, /* tp_getattr */
ZstdCompresssionWriter__doc__, /* tp_doc */ ZstdCompresssionWriter__doc__, /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
0, /* tp_weaklistoffset */ 0, /* tp_weaklistoffset */
0, /* tp_iter */ 0, /* tp_iter */
0, /* tp_iternext */ 0, /* tp_iternext */
ZstdCompressionWriter_methods, /* tp_methods */ ZstdCompressionWriter_methods, /* tp_methods */
0, /* tp_members */ ZstdCompressionWriter_members, /* tp_members */
0, /* tp_getset */ 0, /* tp_getset */
0, /* tp_base */ 0, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
0, /* tp_init */ 0, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */

contrib/python-zstandard/c-ext/compressobj.c

"data buffer should be contiguous and have at most one dimension"); "data buffer should be contiguous and have at most one dimension");
goto finally; goto finally;
} }
input.src = source.buf; input.src = source.buf;
input.size = source.len; input.size = source.len;
input.pos = 0; input.pos = 0;
while ((ssize_t)input.pos < source.len) { while (input.pos < (size_t)source.len) {
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_compress_generic(self->compressor->cctx, &self->output, zresult = ZSTD_compressStream2(self->compressor->cctx, &self->output,
&input, ZSTD_e_continue); &input, ZSTD_e_continue);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "zstd compress error: %s", ZSTD_getErrorName(zresult)); PyErr_Format(ZstdError, "zstd compress error: %s", ZSTD_getErrorName(zresult));
Py_CLEAR(result); Py_CLEAR(result);
goto finally; goto finally;
} }
assert(self->output.pos == 0); assert(self->output.pos == 0);
input.src = NULL; input.src = NULL;
input.size = 0; input.size = 0;
input.pos = 0; input.pos = 0;
while (1) { while (1) {
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_compress_generic(self->compressor->cctx, &self->output, zresult = ZSTD_compressStream2(self->compressor->cctx, &self->output,
&input, zFlushMode); &input, zFlushMode);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "error ending compression stream: %s", PyErr_Format(ZstdError, "error ending compression stream: %s",
ZSTD_getErrorName(zresult)); ZSTD_getErrorName(zresult));
return NULL; return NULL;
} }

contrib/python-zstandard/c-ext/compressor.c

} }
if (params) { if (params) {
if (set_parameters(self->params, params)) { if (set_parameters(self->params, params)) {
return -1; return -1;
} }
} }
else { else {
if (set_parameter(self->params, ZSTD_p_compressionLevel, level)) { if (set_parameter(self->params, ZSTD_c_compressionLevel, level)) {
return -1; return -1;
} }
if (set_parameter(self->params, ZSTD_p_contentSizeFlag, if (set_parameter(self->params, ZSTD_c_contentSizeFlag,
writeContentSize ? PyObject_IsTrue(writeContentSize) : 1)) { writeContentSize ? PyObject_IsTrue(writeContentSize) : 1)) {
return -1; return -1;
} }
if (set_parameter(self->params, ZSTD_p_checksumFlag, if (set_parameter(self->params, ZSTD_c_checksumFlag,
writeChecksum ? PyObject_IsTrue(writeChecksum) : 0)) { writeChecksum ? PyObject_IsTrue(writeChecksum) : 0)) {
return -1; return -1;
} }
if (set_parameter(self->params, ZSTD_p_dictIDFlag, if (set_parameter(self->params, ZSTD_c_dictIDFlag,
writeDictID ? PyObject_IsTrue(writeDictID) : 1)) { writeDictID ? PyObject_IsTrue(writeDictID) : 1)) {
return -1; return -1;
} }
if (threads) { if (threads) {
if (set_parameter(self->params, ZSTD_p_nbWorkers, threads)) { if (set_parameter(self->params, ZSTD_c_nbWorkers, threads)) {
return -1; return -1;
} }
} }
} }
if (dict) { if (dict) {
self->dict = dict; self->dict = dict;
Py_INCREF(dict); Py_INCREF(dict);
return NULL; return NULL;
} }
if (!PyObject_HasAttrString(dest, "write")) { if (!PyObject_HasAttrString(dest, "write")) {
PyErr_SetString(PyExc_ValueError, "second argument must have a write() method"); PyErr_SetString(PyExc_ValueError, "second argument must have a write() method");
return NULL; return NULL;
} }
ZSTD_CCtx_reset(self->cctx); ZSTD_CCtx_reset(self->cctx, ZSTD_reset_session_only);
zresult = ZSTD_CCtx_setPledgedSrcSize(self->cctx, sourceSize); zresult = ZSTD_CCtx_setPledgedSrcSize(self->cctx, sourceSize);
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "error setting source size: %s", PyErr_Format(ZstdError, "error setting source size: %s",
ZSTD_getErrorName(zresult)); ZSTD_getErrorName(zresult));
return NULL; return NULL;
} }
/* Send data to compressor */ /* Send data to compressor */
input.src = readBuffer; input.src = readBuffer;
input.size = readSize; input.size = readSize;
input.pos = 0; input.pos = 0;
while (input.pos < input.size) { while (input.pos < input.size) {
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_compress_generic(self->cctx, &output, &input, ZSTD_e_continue); zresult = ZSTD_compressStream2(self->cctx, &output, &input, ZSTD_e_continue);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
res = NULL; res = NULL;
PyErr_Format(ZstdError, "zstd compress error: %s", ZSTD_getErrorName(zresult)); PyErr_Format(ZstdError, "zstd compress error: %s", ZSTD_getErrorName(zresult));
goto finally; goto finally;
} }
Py_CLEAR(readResult); Py_CLEAR(readResult);
} }
/* We've finished reading. Now flush the compressor stream. */ /* We've finished reading. Now flush the compressor stream. */
assert(input.pos == input.size); assert(input.pos == input.size);
while (1) { while (1) {
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_compress_generic(self->cctx, &output, &input, ZSTD_e_end); zresult = ZSTD_compressStream2(self->cctx, &output, &input, ZSTD_e_end);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "error ending compression stream: %s", PyErr_Format(ZstdError, "error ending compression stream: %s",
ZSTD_getErrorName(zresult)); ZSTD_getErrorName(zresult));
res = NULL; res = NULL;
goto finally; goto finally;
} }
sourceSize = result->buffer.len; sourceSize = result->buffer.len;
} }
else { else {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"must pass an object with a read() method or that conforms to the buffer protocol"); "must pass an object with a read() method or that conforms to the buffer protocol");
goto except; goto except;
} }
ZSTD_CCtx_reset(self->cctx); ZSTD_CCtx_reset(self->cctx, ZSTD_reset_session_only);
zresult = ZSTD_CCtx_setPledgedSrcSize(self->cctx, sourceSize); zresult = ZSTD_CCtx_setPledgedSrcSize(self->cctx, sourceSize);
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "error setting source source: %s", PyErr_Format(ZstdError, "error setting source source: %s",
ZSTD_getErrorName(zresult)); ZSTD_getErrorName(zresult));
goto except; goto except;
} }
} }
if (!PyBuffer_IsContiguous(&source, 'C') || source.ndim > 1) { if (!PyBuffer_IsContiguous(&source, 'C') || source.ndim > 1) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"data buffer should be contiguous and have at most one dimension"); "data buffer should be contiguous and have at most one dimension");
goto finally; goto finally;
} }
ZSTD_CCtx_reset(self->cctx); ZSTD_CCtx_reset(self->cctx, ZSTD_reset_session_only);
destSize = ZSTD_compressBound(source.len); destSize = ZSTD_compressBound(source.len);
output = PyBytes_FromStringAndSize(NULL, destSize); output = PyBytes_FromStringAndSize(NULL, destSize);
if (!output) { if (!output) {
goto finally; goto finally;
} }
zresult = ZSTD_CCtx_setPledgedSrcSize(self->cctx, source.len); zresult = ZSTD_CCtx_setPledgedSrcSize(self->cctx, source.len);
outBuffer.dst = PyBytes_AsString(output); outBuffer.dst = PyBytes_AsString(output);
outBuffer.size = destSize; outBuffer.size = destSize;
outBuffer.pos = 0; outBuffer.pos = 0;
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
/* By avoiding ZSTD_compress(), we don't necessarily write out content /* By avoiding ZSTD_compress(), we don't necessarily write out content
size. This means the argument to ZstdCompressor to control frame size. This means the argument to ZstdCompressor to control frame
parameters is honored. */ parameters is honored. */
zresult = ZSTD_compress_generic(self->cctx, &outBuffer, &inBuffer, ZSTD_e_end); zresult = ZSTD_compressStream2(self->cctx, &outBuffer, &inBuffer, ZSTD_e_end);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "cannot compress: %s", ZSTD_getErrorName(zresult)); PyErr_Format(ZstdError, "cannot compress: %s", ZSTD_getErrorName(zresult));
Py_CLEAR(output); Py_CLEAR(output);
goto finally; goto finally;
} }
else if (zresult) { else if (zresult) {
size_t outSize = ZSTD_CStreamOutSize(); size_t outSize = ZSTD_CStreamOutSize();
ZstdCompressionObj* result = NULL; ZstdCompressionObj* result = NULL;
size_t zresult; size_t zresult;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|K:compressobj", kwlist, &inSize)) { if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|K:compressobj", kwlist, &inSize)) {
return NULL; return NULL;
} }
ZSTD_CCtx_reset(self->cctx); ZSTD_CCtx_reset(self->cctx, ZSTD_reset_session_only);
zresult = ZSTD_CCtx_setPledgedSrcSize(self->cctx, inSize); zresult = ZSTD_CCtx_setPledgedSrcSize(self->cctx, inSize);
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "error setting source size: %s", PyErr_Format(ZstdError, "error setting source size: %s",
ZSTD_getErrorName(zresult)); ZSTD_getErrorName(zresult));
return NULL; return NULL;
} }
sourceSize = result->buffer.len; sourceSize = result->buffer.len;
} }
else { else {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"must pass an object with a read() method or conforms to buffer protocol"); "must pass an object with a read() method or conforms to buffer protocol");
goto except; goto except;
} }
ZSTD_CCtx_reset(self->cctx); ZSTD_CCtx_reset(self->cctx, ZSTD_reset_session_only);
zresult = ZSTD_CCtx_setPledgedSrcSize(self->cctx, sourceSize); zresult = ZSTD_CCtx_setPledgedSrcSize(self->cctx, sourceSize);
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "error setting source size: %s", PyErr_Format(ZstdError, "error setting source size: %s",
ZSTD_getErrorName(zresult)); ZSTD_getErrorName(zresult));
return NULL; return NULL;
} }
"for a compressor output stream.\n" "for a compressor output stream.\n"
); );
static ZstdCompressionWriter* ZstdCompressor_stream_writer(ZstdCompressor* self, PyObject* args, PyObject* kwargs) { static ZstdCompressionWriter* ZstdCompressor_stream_writer(ZstdCompressor* self, PyObject* args, PyObject* kwargs) {
static char* kwlist[] = { static char* kwlist[] = {
"writer", "writer",
"size", "size",
"write_size", "write_size",
"write_return_read",
NULL NULL
}; };
PyObject* writer; PyObject* writer;
ZstdCompressionWriter* result; ZstdCompressionWriter* result;
size_t zresult;
unsigned long long sourceSize = ZSTD_CONTENTSIZE_UNKNOWN; unsigned long long sourceSize = ZSTD_CONTENTSIZE_UNKNOWN;
size_t outSize = ZSTD_CStreamOutSize(); size_t outSize = ZSTD_CStreamOutSize();
PyObject* writeReturnRead = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|Kk:stream_writer", kwlist, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|KkO:stream_writer", kwlist,
&writer, &sourceSize, &outSize)) { &writer, &sourceSize, &outSize, &writeReturnRead)) {
return NULL; return NULL;
} }
if (!PyObject_HasAttrString(writer, "write")) { if (!PyObject_HasAttrString(writer, "write")) {
PyErr_SetString(PyExc_ValueError, "must pass an object with a write() method"); PyErr_SetString(PyExc_ValueError, "must pass an object with a write() method");
return NULL; return NULL;
} }
ZSTD_CCtx_reset(self->cctx); ZSTD_CCtx_reset(self->cctx, ZSTD_reset_session_only);
zresult = ZSTD_CCtx_setPledgedSrcSize(self->cctx, sourceSize);
if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "error setting source size: %s",
ZSTD_getErrorName(zresult));
return NULL;
}
result = (ZstdCompressionWriter*)PyObject_CallObject((PyObject*)&ZstdCompressionWriterType, NULL); result = (ZstdCompressionWriter*)PyObject_CallObject((PyObject*)&ZstdCompressionWriterType, NULL);
if (!result) { if (!result) {
return NULL; return NULL;
} }
result->output.dst = PyMem_Malloc(outSize);
if (!result->output.dst) {
Py_DECREF(result);
return (ZstdCompressionWriter*)PyErr_NoMemory();
}
result->output.pos = 0;
result->output.size = outSize;
result->compressor = self; result->compressor = self;
Py_INCREF(result->compressor); Py_INCREF(result->compressor);
result->writer = writer; result->writer = writer;
Py_INCREF(result->writer); Py_INCREF(result->writer);
result->sourceSize = sourceSize;
result->outSize = outSize; result->outSize = outSize;
result->bytesCompressed = 0; result->bytesCompressed = 0;
result->writeReturnRead = writeReturnRead ? PyObject_IsTrue(writeReturnRead) : 0;
return result; return result;
} }
PyDoc_STRVAR(ZstdCompressor_chunker__doc__, PyDoc_STRVAR(ZstdCompressor_chunker__doc__,
"Create an object for iterative compressing to same-sized chunks.\n" "Create an object for iterative compressing to same-sized chunks.\n"
); );
ZstdCompressionChunker* chunker; ZstdCompressionChunker* chunker;
size_t zresult; size_t zresult;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Kk:chunker", kwlist, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Kk:chunker", kwlist,
&sourceSize, &chunkSize)) { &sourceSize, &chunkSize)) {
return NULL; return NULL;
} }
ZSTD_CCtx_reset(self->cctx); ZSTD_CCtx_reset(self->cctx, ZSTD_reset_session_only);
zresult = ZSTD_CCtx_setPledgedSrcSize(self->cctx, sourceSize); zresult = ZSTD_CCtx_setPledgedSrcSize(self->cctx, sourceSize);
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "error setting source size: %s", PyErr_Format(ZstdError, "error setting source size: %s",
ZSTD_getErrorName(zresult)); ZSTD_getErrorName(zresult));
return NULL; return NULL;
} }
zresult = ZSTD_CCtx_setPledgedSrcSize(state->cctx, sourceSize); zresult = ZSTD_CCtx_setPledgedSrcSize(state->cctx, sourceSize);
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
state->error = WorkerError_zstd; state->error = WorkerError_zstd;
state->zresult = zresult; state->zresult = zresult;
state->errorOffset = inputOffset; state->errorOffset = inputOffset;
break; break;
} }
zresult = ZSTD_compress_generic(state->cctx, &opOutBuffer, &opInBuffer, ZSTD_e_end); zresult = ZSTD_compressStream2(state->cctx, &opOutBuffer, &opInBuffer, ZSTD_e_end);
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
state->error = WorkerError_zstd; state->error = WorkerError_zstd;
state->zresult = zresult; state->zresult = zresult;
state->errorOffset = inputOffset; state->errorOffset = inputOffset;
break; break;
} }
else if (zresult) { else if (zresult) {
state->error = WorkerError_nospace; state->error = WorkerError_nospace;

contrib/python-zstandard/c-ext/compressoriterator.c

return NULL; return NULL;
} }
feedcompressor: feedcompressor:
/* If we have data left in the input, consume it. */ /* If we have data left in the input, consume it. */
if (self->input.pos < self->input.size) { if (self->input.pos < self->input.size) {
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_compress_generic(self->compressor->cctx, &self->output, zresult = ZSTD_compressStream2(self->compressor->cctx, &self->output,
&self->input, ZSTD_e_continue); &self->input, ZSTD_e_continue);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
/* Release the Python object holding the input buffer. */ /* Release the Python object holding the input buffer. */
if (self->input.pos == self->input.size) { if (self->input.pos == self->input.size) {
self->input.src = NULL; self->input.src = NULL;
self->input.pos = 0; self->input.pos = 0;
self->input.size = 0; self->input.size = 0;
} }
/* EOF */ /* EOF */
if (0 == readSize) { if (0 == readSize) {
self->input.src = NULL; self->input.src = NULL;
self->input.size = 0; self->input.size = 0;
self->input.pos = 0; self->input.pos = 0;
zresult = ZSTD_compress_generic(self->compressor->cctx, &self->output, zresult = ZSTD_compressStream2(self->compressor->cctx, &self->output,
&self->input, ZSTD_e_end); &self->input, ZSTD_e_end);
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "error ending compression stream: %s", PyErr_Format(ZstdError, "error ending compression stream: %s",
ZSTD_getErrorName(zresult)); ZSTD_getErrorName(zresult));
return NULL; return NULL;
} }
assert(self->output.pos); assert(self->output.pos);
if (0 == zresult) { if (0 == zresult) {
self->finishedOutput = 1; self->finishedOutput = 1;
} }
chunk = PyBytes_FromStringAndSize(self->output.dst, self->output.pos); chunk = PyBytes_FromStringAndSize(self->output.dst, self->output.pos);
self->output.pos = 0; self->output.pos = 0;
return chunk; return chunk;
} }
/* New data from reader. Feed into compressor. */ /* New data from reader. Feed into compressor. */
self->input.src = readBuffer; self->input.src = readBuffer;
self->input.size = readSize; self->input.size = readSize;
self->input.pos = 0; self->input.pos = 0;
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_compress_generic(self->compressor->cctx, &self->output, zresult = ZSTD_compressStream2(self->compressor->cctx, &self->output,
&self->input, ZSTD_e_continue); &self->input, ZSTD_e_continue);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
/* The input buffer currently points to memory managed by Python /* The input buffer currently points to memory managed by Python
(readBuffer). This object was allocated by this function. If it wasn't (readBuffer). This object was allocated by this function. If it wasn't
fully consumed, we need to release it in a subsequent function call. fully consumed, we need to release it in a subsequent function call.
If it is fully consumed, do that now. If it is fully consumed, do that now.
*/ */

contrib/python-zstandard/c-ext/constants.c

#else #else
version = PyString_FromString(PYTHON_ZSTANDARD_VERSION); version = PyString_FromString(PYTHON_ZSTANDARD_VERSION);
#endif #endif
PyModule_AddObject(mod, "__version__", version); PyModule_AddObject(mod, "__version__", version);
ZstdError = PyErr_NewException("zstd.ZstdError", NULL, NULL); ZstdError = PyErr_NewException("zstd.ZstdError", NULL, NULL);
PyModule_AddObject(mod, "ZstdError", ZstdError); PyModule_AddObject(mod, "ZstdError", ZstdError);
PyModule_AddIntConstant(mod, "FLUSH_BLOCK", 0);
PyModule_AddIntConstant(mod, "FLUSH_FRAME", 1);
PyModule_AddIntConstant(mod, "COMPRESSOBJ_FLUSH_FINISH", compressorobj_flush_finish); PyModule_AddIntConstant(mod, "COMPRESSOBJ_FLUSH_FINISH", compressorobj_flush_finish);
PyModule_AddIntConstant(mod, "COMPRESSOBJ_FLUSH_BLOCK", compressorobj_flush_block); PyModule_AddIntConstant(mod, "COMPRESSOBJ_FLUSH_BLOCK", compressorobj_flush_block);
/* For now, the version is a simple tuple instead of a dedicated type. */ /* For now, the version is a simple tuple instead of a dedicated type. */
zstdVersion = PyTuple_New(3); zstdVersion = PyTuple_New(3);
PyTuple_SetItem(zstdVersion, 0, PyLong_FromLong(ZSTD_VERSION_MAJOR)); PyTuple_SetItem(zstdVersion, 0, PyLong_FromLong(ZSTD_VERSION_MAJOR));
PyTuple_SetItem(zstdVersion, 1, PyLong_FromLong(ZSTD_VERSION_MINOR)); PyTuple_SetItem(zstdVersion, 1, PyLong_FromLong(ZSTD_VERSION_MINOR));
PyTuple_SetItem(zstdVersion, 2, PyLong_FromLong(ZSTD_VERSION_RELEASE)); PyTuple_SetItem(zstdVersion, 2, PyLong_FromLong(ZSTD_VERSION_RELEASE));
PyModule_AddIntConstant(mod, "WINDOWLOG_MAX", ZSTD_WINDOWLOG_MAX); PyModule_AddIntConstant(mod, "WINDOWLOG_MAX", ZSTD_WINDOWLOG_MAX);
PyModule_AddIntConstant(mod, "CHAINLOG_MIN", ZSTD_CHAINLOG_MIN); PyModule_AddIntConstant(mod, "CHAINLOG_MIN", ZSTD_CHAINLOG_MIN);
PyModule_AddIntConstant(mod, "CHAINLOG_MAX", ZSTD_CHAINLOG_MAX); PyModule_AddIntConstant(mod, "CHAINLOG_MAX", ZSTD_CHAINLOG_MAX);
PyModule_AddIntConstant(mod, "HASHLOG_MIN", ZSTD_HASHLOG_MIN); PyModule_AddIntConstant(mod, "HASHLOG_MIN", ZSTD_HASHLOG_MIN);
PyModule_AddIntConstant(mod, "HASHLOG_MAX", ZSTD_HASHLOG_MAX); PyModule_AddIntConstant(mod, "HASHLOG_MAX", ZSTD_HASHLOG_MAX);
PyModule_AddIntConstant(mod, "HASHLOG3_MAX", ZSTD_HASHLOG3_MAX); PyModule_AddIntConstant(mod, "HASHLOG3_MAX", ZSTD_HASHLOG3_MAX);
PyModule_AddIntConstant(mod, "SEARCHLOG_MIN", ZSTD_SEARCHLOG_MIN); PyModule_AddIntConstant(mod, "SEARCHLOG_MIN", ZSTD_SEARCHLOG_MIN);
PyModule_AddIntConstant(mod, "SEARCHLOG_MAX", ZSTD_SEARCHLOG_MAX); PyModule_AddIntConstant(mod, "SEARCHLOG_MAX", ZSTD_SEARCHLOG_MAX);
PyModule_AddIntConstant(mod, "SEARCHLENGTH_MIN", ZSTD_SEARCHLENGTH_MIN); PyModule_AddIntConstant(mod, "MINMATCH_MIN", ZSTD_MINMATCH_MIN);
PyModule_AddIntConstant(mod, "SEARCHLENGTH_MAX", ZSTD_SEARCHLENGTH_MAX); PyModule_AddIntConstant(mod, "MINMATCH_MAX", ZSTD_MINMATCH_MAX);
/* TODO SEARCHLENGTH_* is deprecated. */
PyModule_AddIntConstant(mod, "SEARCHLENGTH_MIN", ZSTD_MINMATCH_MIN);
PyModule_AddIntConstant(mod, "SEARCHLENGTH_MAX", ZSTD_MINMATCH_MAX);
PyModule_AddIntConstant(mod, "TARGETLENGTH_MIN", ZSTD_TARGETLENGTH_MIN); PyModule_AddIntConstant(mod, "TARGETLENGTH_MIN", ZSTD_TARGETLENGTH_MIN);
PyModule_AddIntConstant(mod, "TARGETLENGTH_MAX", ZSTD_TARGETLENGTH_MAX); PyModule_AddIntConstant(mod, "TARGETLENGTH_MAX", ZSTD_TARGETLENGTH_MAX);
PyModule_AddIntConstant(mod, "LDM_MINMATCH_MIN", ZSTD_LDM_MINMATCH_MIN); PyModule_AddIntConstant(mod, "LDM_MINMATCH_MIN", ZSTD_LDM_MINMATCH_MIN);
PyModule_AddIntConstant(mod, "LDM_MINMATCH_MAX", ZSTD_LDM_MINMATCH_MAX); PyModule_AddIntConstant(mod, "LDM_MINMATCH_MAX", ZSTD_LDM_MINMATCH_MAX);
PyModule_AddIntConstant(mod, "LDM_BUCKETSIZELOG_MAX", ZSTD_LDM_BUCKETSIZELOG_MAX); PyModule_AddIntConstant(mod, "LDM_BUCKETSIZELOG_MAX", ZSTD_LDM_BUCKETSIZELOG_MAX);
PyModule_AddIntConstant(mod, "STRATEGY_FAST", ZSTD_fast); PyModule_AddIntConstant(mod, "STRATEGY_FAST", ZSTD_fast);
PyModule_AddIntConstant(mod, "STRATEGY_DFAST", ZSTD_dfast); PyModule_AddIntConstant(mod, "STRATEGY_DFAST", ZSTD_dfast);
PyModule_AddIntConstant(mod, "STRATEGY_GREEDY", ZSTD_greedy); PyModule_AddIntConstant(mod, "STRATEGY_GREEDY", ZSTD_greedy);
PyModule_AddIntConstant(mod, "STRATEGY_LAZY", ZSTD_lazy); PyModule_AddIntConstant(mod, "STRATEGY_LAZY", ZSTD_lazy);
PyModule_AddIntConstant(mod, "STRATEGY_LAZY2", ZSTD_lazy2); PyModule_AddIntConstant(mod, "STRATEGY_LAZY2", ZSTD_lazy2);
PyModule_AddIntConstant(mod, "STRATEGY_BTLAZY2", ZSTD_btlazy2); PyModule_AddIntConstant(mod, "STRATEGY_BTLAZY2", ZSTD_btlazy2);
PyModule_AddIntConstant(mod, "STRATEGY_BTOPT", ZSTD_btopt); PyModule_AddIntConstant(mod, "STRATEGY_BTOPT", ZSTD_btopt);
PyModule_AddIntConstant(mod, "STRATEGY_BTULTRA", ZSTD_btultra); PyModule_AddIntConstant(mod, "STRATEGY_BTULTRA", ZSTD_btultra);
PyModule_AddIntConstant(mod, "STRATEGY_BTULTRA2", ZSTD_btultra2);
PyModule_AddIntConstant(mod, "DICT_TYPE_AUTO", ZSTD_dct_auto); PyModule_AddIntConstant(mod, "DICT_TYPE_AUTO", ZSTD_dct_auto);
PyModule_AddIntConstant(mod, "DICT_TYPE_RAWCONTENT", ZSTD_dct_rawContent); PyModule_AddIntConstant(mod, "DICT_TYPE_RAWCONTENT", ZSTD_dct_rawContent);
PyModule_AddIntConstant(mod, "DICT_TYPE_FULLDICT", ZSTD_dct_fullDict); PyModule_AddIntConstant(mod, "DICT_TYPE_FULLDICT", ZSTD_dct_fullDict);
PyModule_AddIntConstant(mod, "FORMAT_ZSTD1", ZSTD_f_zstd1); PyModule_AddIntConstant(mod, "FORMAT_ZSTD1", ZSTD_f_zstd1);
PyModule_AddIntConstant(mod, "FORMAT_ZSTD1_MAGICLESS", ZSTD_f_zstd1_magicless); PyModule_AddIntConstant(mod, "FORMAT_ZSTD1_MAGICLESS", ZSTD_f_zstd1_magicless);
} }

contrib/python-zstandard/c-ext/decompressionreader.c

static PyObject* reader_flush(PyObject* self) { static PyObject* reader_flush(PyObject* self) {
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyObject* reader_isatty(PyObject* self) { static PyObject* reader_isatty(PyObject* self) {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
/**
* Read available input.
*
* Returns 0 if no data was added to input.
* Returns 1 if new input data is available.
* Returns -1 on error and sets a Python exception as a side-effect.
*/
int read_decompressor_input(ZstdDecompressionReader* self) {
if (self->finishedInput) {
return 0;
}
if (self->input.pos != self->input.size) {
return 0;
}
if (self->reader) {
Py_buffer buffer;
assert(self->readResult == NULL);
self->readResult = PyObject_CallMethod(self->reader, "read",
"k", self->readSize);
if (NULL == self->readResult) {
return -1;
}
memset(&buffer, 0, sizeof(buffer));
if (0 != PyObject_GetBuffer(self->readResult, &buffer, PyBUF_CONTIG_RO)) {
return -1;
}
/* EOF */
if (0 == buffer.len) {
self->finishedInput = 1;
Py_CLEAR(self->readResult);
}
else {
self->input.src = buffer.buf;
self->input.size = buffer.len;
self->input.pos = 0;
}
PyBuffer_Release(&buffer);
}
else {
assert(self->buffer.buf);
/*
* We should only get here once since expectation is we always
* exhaust input buffer before reading again.
*/
assert(self->input.src == NULL);
self->input.src = self->buffer.buf;
self->input.size = self->buffer.len;
self->input.pos = 0;
}
return 1;
}
/**
* Decompresses available input into an output buffer.
*
* Returns 0 if we need more input.
* Returns 1 if output buffer should be emitted.
* Returns -1 on error and sets a Python exception.
*/
int decompress_input(ZstdDecompressionReader* self, ZSTD_outBuffer* output) {
size_t zresult;
if (self->input.pos >= self->input.size) {
return 0;
}
Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_decompressStream(self->decompressor->dctx, output, &self->input);
Py_END_ALLOW_THREADS
/* Input exhausted. Clear our state tracking. */
if (self->input.pos == self->input.size) {
memset(&self->input, 0, sizeof(self->input));
Py_CLEAR(self->readResult);
if (self->buffer.buf) {
self->finishedInput = 1;
}
}
if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "zstd decompress error: %s", ZSTD_getErrorName(zresult));
return -1;
}
/* We fulfilled the full read request. Signal to emit. */
if (output->pos && output->pos == output->size) {
return 1;
}
/* We're at the end of a frame and we aren't allowed to return data
spanning frames. */
else if (output->pos && zresult == 0 && !self->readAcrossFrames) {
return 1;
}
/* There is more room in the output. Signal to collect more data. */
return 0;
}
static PyObject* reader_read(ZstdDecompressionReader* self, PyObject* args, PyObject* kwargs) { static PyObject* reader_read(ZstdDecompressionReader* self, PyObject* args, PyObject* kwargs) {
static char* kwlist[] = { static char* kwlist[] = {
"size", "size",
NULL NULL
}; };
Py_ssize_t size = -1; Py_ssize_t size = -1;
PyObject* result = NULL; PyObject* result = NULL;
char* resultBuffer; char* resultBuffer;
Py_ssize_t resultSize; Py_ssize_t resultSize;
ZSTD_outBuffer output; ZSTD_outBuffer output;
size_t zresult; int decompressResult, readResult;
if (self->closed) { if (self->closed) {
PyErr_SetString(PyExc_ValueError, "stream is closed"); PyErr_SetString(PyExc_ValueError, "stream is closed");
return NULL; return NULL;
} }
if (self->finishedOutput) { if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|n", kwlist, &size)) {
return PyBytes_FromStringAndSize("", 0); return NULL;
} }
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "n", kwlist, &size)) { if (size < -1) {
PyErr_SetString(PyExc_ValueError, "cannot read negative amounts less than -1");
return NULL; return NULL;
} }
if (size < 1) { if (size == -1) {
PyErr_SetString(PyExc_ValueError, "cannot read negative or size 0 amounts"); return PyObject_CallMethod((PyObject*)self, "readall", NULL);
return NULL; }
if (self->finishedOutput || size == 0) {
return PyBytes_FromStringAndSize("", 0);
} }
result = PyBytes_FromStringAndSize(NULL, size); result = PyBytes_FromStringAndSize(NULL, size);
if (NULL == result) { if (NULL == result) {
return NULL; return NULL;
} }
PyBytes_AsStringAndSize(result, &resultBuffer, &resultSize); PyBytes_AsStringAndSize(result, &resultBuffer, &resultSize);
output.dst = resultBuffer; output.dst = resultBuffer;
output.size = resultSize; output.size = resultSize;
output.pos = 0; output.pos = 0;
readinput: readinput:
/* Consume input data left over from last time. */ decompressResult = decompress_input(self, &output);
if (self->input.pos < self->input.size) {
Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_decompress_generic(self->decompressor->dctx,
&output, &self->input);
Py_END_ALLOW_THREADS
/* Input exhausted. Clear our state tracking. */ if (-1 == decompressResult) {
if (self->input.pos == self->input.size) { Py_XDECREF(result);
memset(&self->input, 0, sizeof(self->input)); return NULL;
Py_CLEAR(self->readResult); }
else if (0 == decompressResult) { }
else if (1 == decompressResult) {
self->bytesDecompressed += output.pos;
if (self->buffer.buf) { if (output.pos != output.size) {
self->finishedInput = 1; if (safe_pybytes_resize(&result, output.pos)) {
Py_XDECREF(result);
return NULL;
}
}
return result;
} }
else {
assert(0);
} }
if (ZSTD_isError(zresult)) { readResult = read_decompressor_input(self);
PyErr_Format(ZstdError, "zstd decompress error: %s", ZSTD_getErrorName(zresult));
if (-1 == readResult) {
Py_XDECREF(result);
return NULL; return NULL;
} }
else if (0 == zresult) { else if (0 == readResult) {}
self->finishedOutput = 1; else if (1 == readResult) {}
else {
assert(0);
}
if (self->input.size) {
goto readinput;
}
/* EOF */
self->bytesDecompressed += output.pos;
if (safe_pybytes_resize(&result, output.pos)) {
Py_XDECREF(result);
return NULL;
} }
/* We fulfilled the full read request. Emit it. */
if (output.pos && output.pos == output.size) {
self->bytesDecompressed += output.size;
return result; return result;
} }
/* static PyObject* reader_read1(ZstdDecompressionReader* self, PyObject* args, PyObject* kwargs) {
* There is more room in the output. Fall through to try to collect static char* kwlist[] = {
* more data so we can try to fill the output. "size",
*/ NULL
};
Py_ssize_t size = -1;
PyObject* result = NULL;
char* resultBuffer;
Py_ssize_t resultSize;
ZSTD_outBuffer output;
if (self->closed) {
PyErr_SetString(PyExc_ValueError, "stream is closed");
return NULL;
} }
if (!self->finishedInput) { if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|n", kwlist, &size)) {
if (self->reader) { return NULL;
Py_buffer buffer; }
assert(self->readResult == NULL); if (size < -1) {
self->readResult = PyObject_CallMethod(self->reader, "read", PyErr_SetString(PyExc_ValueError, "cannot read negative amounts less than -1");
"k", self->readSize);
if (NULL == self->readResult) {
return NULL; return NULL;
} }
memset(&buffer, 0, sizeof(buffer)); if (self->finishedOutput || size == 0) {
return PyBytes_FromStringAndSize("", 0);
}
if (0 != PyObject_GetBuffer(self->readResult, &buffer, PyBUF_CONTIG_RO)) { if (size == -1) {
size = ZSTD_DStreamOutSize();
}
result = PyBytes_FromStringAndSize(NULL, size);
if (NULL == result) {
return NULL; return NULL;
} }
/* EOF */ PyBytes_AsStringAndSize(result, &resultBuffer, &resultSize);
if (0 == buffer.len) {
self->finishedInput = 1; output.dst = resultBuffer;
Py_CLEAR(self->readResult); output.size = resultSize;
output.pos = 0;
/* read1() is supposed to use at most 1 read() from the underlying stream.
* However, we can't satisfy this requirement with decompression due to the
* nature of how decompression works. Our strategy is to read + decompress
* until we get any output, at which point we return. This satisfies the
* intent of the read1() API to limit read operations.
*/
while (!self->finishedInput) {
int readResult, decompressResult;
readResult = read_decompressor_input(self);
if (-1 == readResult) {
Py_XDECREF(result);
return NULL;
} }
else if (0 == readResult || 1 == readResult) { }
else { else {
self->input.src = buffer.buf; assert(0);
self->input.size = buffer.len;
self->input.pos = 0;
} }
PyBuffer_Release(&buffer); decompressResult = decompress_input(self, &output);
if (-1 == decompressResult) {
Py_XDECREF(result);
return NULL;
} }
else if (0 == decompressResult || 1 == decompressResult) { }
else { else {
assert(self->buffer.buf); assert(0);
/* }
* We should only get here once since above block will exhaust
* source buffer until finishedInput is set.
*/
assert(self->input.src == NULL);
self->input.src = self->buffer.buf; if (output.pos) {
self->input.size = self->buffer.len; break;
self->input.pos = 0; }
} }
self->bytesDecompressed += output.pos;
if (safe_pybytes_resize(&result, output.pos)) {
Py_XDECREF(result);
return NULL;
}
return result;
}
static PyObject* reader_readinto(ZstdDecompressionReader* self, PyObject* args) {
Py_buffer dest;
ZSTD_outBuffer output;
int decompressResult, readResult;
PyObject* result = NULL;
if (self->closed) {
PyErr_SetString(PyExc_ValueError, "stream is closed");
return NULL;
}
if (self->finishedOutput) {
return PyLong_FromLong(0);
}
if (!PyArg_ParseTuple(args, "w*:readinto", &dest)) {
return NULL;
}
if (!PyBuffer_IsContiguous(&dest, 'C') || dest.ndim > 1) {
PyErr_SetString(PyExc_ValueError,
"destination buffer should be contiguous and have at most one dimension");
goto finally;
}
output.dst = dest.buf;
output.size = dest.len;
output.pos = 0;
readinput:
decompressResult = decompress_input(self, &output);
if (-1 == decompressResult) {
goto finally;
}
else if (0 == decompressResult) { }
else if (1 == decompressResult) {
self->bytesDecompressed += output.pos;
result = PyLong_FromSize_t(output.pos);
goto finally;
}
else {
assert(0);
}
readResult = read_decompressor_input(self);
if (-1 == readResult) {
goto finally;
}
else if (0 == readResult) {}
else if (1 == readResult) {}
else {
assert(0);
} }
if (self->input.size) { if (self->input.size) {
goto readinput; goto readinput;
} }
/* EOF */ /* EOF */
self->bytesDecompressed += output.pos; self->bytesDecompressed += output.pos;
result = PyLong_FromSize_t(output.pos);
if (safe_pybytes_resize(&result, output.pos)) { finally:
Py_XDECREF(result); PyBuffer_Release(&dest);
return result;
}
static PyObject* reader_readinto1(ZstdDecompressionReader* self, PyObject* args) {
Py_buffer dest;
ZSTD_outBuffer output;
PyObject* result = NULL;
if (self->closed) {
PyErr_SetString(PyExc_ValueError, "stream is closed");
return NULL;
}
if (self->finishedOutput) {
return PyLong_FromLong(0);
}
if (!PyArg_ParseTuple(args, "w*:readinto1", &dest)) {
return NULL; return NULL;
} }
if (!PyBuffer_IsContiguous(&dest, 'C') || dest.ndim > 1) {
PyErr_SetString(PyExc_ValueError,
"destination buffer should be contiguous and have at most one dimension");
goto finally;
}
output.dst = dest.buf;
output.size = dest.len;
output.pos = 0;
while (!self->finishedInput && !self->finishedOutput) {
int decompressResult, readResult;
readResult = read_decompressor_input(self);
if (-1 == readResult) {
goto finally;
}
else if (0 == readResult || 1 == readResult) {}
else {
assert(0);
}
decompressResult = decompress_input(self, &output);
if (-1 == decompressResult) {
goto finally;
}
else if (0 == decompressResult || 1 == decompressResult) {}
else {
assert(0);
}
if (output.pos) {
break;
}
}
self->bytesDecompressed += output.pos;
result = PyLong_FromSize_t(output.pos);
finally:
PyBuffer_Release(&dest);
return result; return result;
} }
static PyObject* reader_readall(PyObject* self) { static PyObject* reader_readall(PyObject* self) {
PyErr_SetNone(PyExc_NotImplementedError); PyObject* chunks = NULL;
PyObject* empty = NULL;
PyObject* result = NULL;
/* Our strategy is to collect chunks into a list then join all the
* chunks at the end. We could potentially use e.g. an io.BytesIO. But
* this feels simple enough to implement and avoids potentially expensive
* reallocations of large buffers.
*/
chunks = PyList_New(0);
if (NULL == chunks) {
return NULL;
}
while (1) {
PyObject* chunk = PyObject_CallMethod(self, "read", "i", 1048576);
if (NULL == chunk) {
Py_DECREF(chunks);
return NULL;
}
if (!PyBytes_Size(chunk)) {
Py_DECREF(chunk);
break;
}
if (PyList_Append(chunks, chunk)) {
Py_DECREF(chunk);
Py_DECREF(chunks);
return NULL; return NULL;
} }
Py_DECREF(chunk);
}
empty = PyBytes_FromStringAndSize("", 0);
if (NULL == empty) {
Py_DECREF(chunks);
return NULL;
}
result = PyObject_CallMethod(empty, "join", "O", chunks);
Py_DECREF(empty);
Py_DECREF(chunks);
return result;
}
static PyObject* reader_readline(PyObject* self) { static PyObject* reader_readline(PyObject* self) {
PyErr_SetNone(PyExc_NotImplementedError); set_unsupported_operation();
return NULL; return NULL;
} }
static PyObject* reader_readlines(PyObject* self) { static PyObject* reader_readlines(PyObject* self) {
PyErr_SetNone(PyExc_NotImplementedError); set_unsupported_operation();
return NULL; return NULL;
} }
static PyObject* reader_seek(ZstdDecompressionReader* self, PyObject* args) { static PyObject* reader_seek(ZstdDecompressionReader* self, PyObject* args) {
Py_ssize_t pos; Py_ssize_t pos;
int whence = 0; int whence = 0;
unsigned long long readAmount = 0; unsigned long long readAmount = 0;
size_t defaultOutSize = ZSTD_DStreamOutSize(); size_t defaultOutSize = ZSTD_DStreamOutSize();
} }
static PyObject* reader_writelines(PyObject* self, PyObject* args) { static PyObject* reader_writelines(PyObject* self, PyObject* args) {
set_unsupported_operation(); set_unsupported_operation();
return NULL; return NULL;
} }
static PyObject* reader_iter(PyObject* self) { static PyObject* reader_iter(PyObject* self) {
PyErr_SetNone(PyExc_NotImplementedError); set_unsupported_operation();
return NULL; return NULL;
} }
static PyObject* reader_iternext(PyObject* self) { static PyObject* reader_iternext(PyObject* self) {
PyErr_SetNone(PyExc_NotImplementedError); set_unsupported_operation();
return NULL; return NULL;
} }
static PyMethodDef reader_methods[] = { static PyMethodDef reader_methods[] = {
{ "__enter__", (PyCFunction)reader_enter, METH_NOARGS, { "__enter__", (PyCFunction)reader_enter, METH_NOARGS,
PyDoc_STR("Enter a compression context") }, PyDoc_STR("Enter a compression context") },
{ "__exit__", (PyCFunction)reader_exit, METH_VARARGS, { "__exit__", (PyCFunction)reader_exit, METH_VARARGS,
PyDoc_STR("Exit a compression context") }, PyDoc_STR("Exit a compression context") },
{ "close", (PyCFunction)reader_close, METH_NOARGS, { "close", (PyCFunction)reader_close, METH_NOARGS,
PyDoc_STR("Close the stream so it cannot perform any more operations") }, PyDoc_STR("Close the stream so it cannot perform any more operations") },
{ "flush", (PyCFunction)reader_flush, METH_NOARGS, PyDoc_STR("no-ops") }, { "flush", (PyCFunction)reader_flush, METH_NOARGS, PyDoc_STR("no-ops") },
{ "isatty", (PyCFunction)reader_isatty, METH_NOARGS, PyDoc_STR("Returns False") }, { "isatty", (PyCFunction)reader_isatty, METH_NOARGS, PyDoc_STR("Returns False") },
{ "readable", (PyCFunction)reader_readable, METH_NOARGS, { "readable", (PyCFunction)reader_readable, METH_NOARGS,
PyDoc_STR("Returns True") }, PyDoc_STR("Returns True") },
{ "read", (PyCFunction)reader_read, METH_VARARGS | METH_KEYWORDS, { "read", (PyCFunction)reader_read, METH_VARARGS | METH_KEYWORDS,
PyDoc_STR("read compressed data") }, PyDoc_STR("read compressed data") },
{ "read1", (PyCFunction)reader_read1, METH_VARARGS | METH_KEYWORDS,
PyDoc_STR("read compressed data") },
{ "readinto", (PyCFunction)reader_readinto, METH_VARARGS, NULL },
{ "readinto1", (PyCFunction)reader_readinto1, METH_VARARGS, NULL },
{ "readall", (PyCFunction)reader_readall, METH_NOARGS, PyDoc_STR("Not implemented") }, { "readall", (PyCFunction)reader_readall, METH_NOARGS, PyDoc_STR("Not implemented") },
{ "readline", (PyCFunction)reader_readline, METH_NOARGS, PyDoc_STR("Not implemented") }, { "readline", (PyCFunction)reader_readline, METH_NOARGS, PyDoc_STR("Not implemented") },
{ "readlines", (PyCFunction)reader_readlines, METH_NOARGS, PyDoc_STR("Not implemented") }, { "readlines", (PyCFunction)reader_readlines, METH_NOARGS, PyDoc_STR("Not implemented") },
{ "seek", (PyCFunction)reader_seek, METH_VARARGS, PyDoc_STR("Seek the stream") }, { "seek", (PyCFunction)reader_seek, METH_VARARGS, PyDoc_STR("Seek the stream") },
{ "seekable", (PyCFunction)reader_seekable, METH_NOARGS, { "seekable", (PyCFunction)reader_seekable, METH_NOARGS,
PyDoc_STR("Returns True") }, PyDoc_STR("Returns True") },
{ "tell", (PyCFunction)reader_tell, METH_NOARGS, { "tell", (PyCFunction)reader_tell, METH_NOARGS,
PyDoc_STR("Returns current number of bytes compressed") }, PyDoc_STR("Returns current number of bytes compressed") },

contrib/python-zstandard/c-ext/decompressionwriter.c

static void ZstdDecompressionWriter_dealloc(ZstdDecompressionWriter* self) { static void ZstdDecompressionWriter_dealloc(ZstdDecompressionWriter* self) {
Py_XDECREF(self->decompressor); Py_XDECREF(self->decompressor);
Py_XDECREF(self->writer); Py_XDECREF(self->writer);
PyObject_Del(self); PyObject_Del(self);
} }
static PyObject* ZstdDecompressionWriter_enter(ZstdDecompressionWriter* self) { static PyObject* ZstdDecompressionWriter_enter(ZstdDecompressionWriter* self) {
if (self->entered) { if (self->closed) {
PyErr_SetString(ZstdError, "cannot __enter__ multiple times"); PyErr_SetString(PyExc_ValueError, "stream is closed");
return NULL; return NULL;
} }
if (ensure_dctx(self->decompressor, 1)) { if (self->entered) {
PyErr_SetString(ZstdError, "cannot __enter__ multiple times");
return NULL; return NULL;
} }
self->entered = 1; self->entered = 1;
Py_INCREF(self); Py_INCREF(self);
return (PyObject*)self; return (PyObject*)self;
} }
static PyObject* ZstdDecompressionWriter_exit(ZstdDecompressionWriter* self, PyObject* args) { static PyObject* ZstdDecompressionWriter_exit(ZstdDecompressionWriter* self, PyObject* args) {
self->entered = 0; self->entered = 0;
if (NULL == PyObject_CallMethod((PyObject*)self, "close", NULL)) {
return NULL;
}
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
static PyObject* ZstdDecompressionWriter_memory_size(ZstdDecompressionWriter* self) { static PyObject* ZstdDecompressionWriter_memory_size(ZstdDecompressionWriter* self) {
return PyLong_FromSize_t(ZSTD_sizeof_DCtx(self->decompressor->dctx)); return PyLong_FromSize_t(ZSTD_sizeof_DCtx(self->decompressor->dctx));
} }
static PyObject* ZstdDecompressionWriter_write(ZstdDecompressionWriter* self, PyObject* args, PyObject* kwargs) { static PyObject* ZstdDecompressionWriter_write(ZstdDecompressionWriter* self, PyObject* args, PyObject* kwargs) {
} }
if (!PyBuffer_IsContiguous(&source, 'C') || source.ndim > 1) { if (!PyBuffer_IsContiguous(&source, 'C') || source.ndim > 1) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"data buffer should be contiguous and have at most one dimension"); "data buffer should be contiguous and have at most one dimension");
goto finally; goto finally;
} }
if (!self->entered) { if (self->closed) {
PyErr_SetString(ZstdError, "write must be called from an active context manager"); PyErr_SetString(PyExc_ValueError, "stream is closed");
goto finally; return NULL;
} }
output.dst = PyMem_Malloc(self->outSize); output.dst = PyMem_Malloc(self->outSize);
if (!output.dst) { if (!output.dst) {
PyErr_NoMemory(); PyErr_NoMemory();
goto finally; goto finally;
} }
output.size = self->outSize; output.size = self->outSize;
output.pos = 0; output.pos = 0;
input.src = source.buf; input.src = source.buf;
input.size = source.len; input.size = source.len;
input.pos = 0; input.pos = 0;
while ((ssize_t)input.pos < source.len) { while (input.pos < (size_t)source.len) {
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_decompress_generic(self->decompressor->dctx, &output, &input); zresult = ZSTD_decompressStream(self->decompressor->dctx, &output, &input);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyMem_Free(output.dst); PyMem_Free(output.dst);
PyErr_Format(ZstdError, "zstd decompress error: %s", PyErr_Format(ZstdError, "zstd decompress error: %s",
ZSTD_getErrorName(zresult)); ZSTD_getErrorName(zresult));
goto finally; goto finally;
} }
if (output.pos) { if (output.pos) {
#if PY_MAJOR_VERSION >= 3 #if PY_MAJOR_VERSION >= 3
res = PyObject_CallMethod(self->writer, "write", "y#", res = PyObject_CallMethod(self->writer, "write", "y#",
#else #else
res = PyObject_CallMethod(self->writer, "write", "s#", res = PyObject_CallMethod(self->writer, "write", "s#",
#endif #endif
output.dst, output.pos); output.dst, output.pos);
Py_XDECREF(res); Py_XDECREF(res);
totalWrite += output.pos; totalWrite += output.pos;
output.pos = 0; output.pos = 0;
} }
} }
PyMem_Free(output.dst); PyMem_Free(output.dst);
if (self->writeReturnRead) {
result = PyLong_FromSize_t(input.pos);
}
else {
result = PyLong_FromSsize_t(totalWrite); result = PyLong_FromSsize_t(totalWrite);
}
finally: finally:
PyBuffer_Release(&source); PyBuffer_Release(&source);
return result; return result;
} }
static PyObject* ZstdDecompressionWriter_close(ZstdDecompressionWriter* self) {
PyObject* result;
if (self->closed) {
Py_RETURN_NONE;
}
result = PyObject_CallMethod((PyObject*)self, "flush", NULL);
self->closed = 1;
if (NULL == result) {
return NULL;
}
/* Call close on underlying stream as well. */
if (PyObject_HasAttrString(self->writer, "close")) {
return PyObject_CallMethod(self->writer, "close", NULL);
}
Py_RETURN_NONE;
}
static PyObject* ZstdDecompressionWriter_fileno(ZstdDecompressionWriter* self) {
if (PyObject_HasAttrString(self->writer, "fileno")) {
return PyObject_CallMethod(self->writer, "fileno", NULL);
}
else {
PyErr_SetString(PyExc_OSError, "fileno not available on underlying writer");
return NULL;
}
}
static PyObject* ZstdDecompressionWriter_flush(ZstdDecompressionWriter* self) {
if (self->closed) {
PyErr_SetString(PyExc_ValueError, "stream is closed");
return NULL;
}
if (PyObject_HasAttrString(self->writer, "flush")) {
return PyObject_CallMethod(self->writer, "flush", NULL);
}
else {
Py_RETURN_NONE;
}
}
static PyObject* ZstdDecompressionWriter_false(PyObject* self, PyObject* args) {
Py_RETURN_FALSE;
}
static PyObject* ZstdDecompressionWriter_true(PyObject* self, PyObject* args) {
Py_RETURN_TRUE;
}
static PyObject* ZstdDecompressionWriter_unsupported(PyObject* self, PyObject* args, PyObject* kwargs) {
PyObject* iomod;
PyObject* exc;
iomod = PyImport_ImportModule("io");
if (NULL == iomod) {
return NULL;
}
exc = PyObject_GetAttrString(iomod, "UnsupportedOperation");
if (NULL == exc) {
Py_DECREF(iomod);
return NULL;
}
PyErr_SetNone(exc);
Py_DECREF(exc);
Py_DECREF(iomod);
return NULL;
}
static PyMethodDef ZstdDecompressionWriter_methods[] = { static PyMethodDef ZstdDecompressionWriter_methods[] = {
{ "__enter__", (PyCFunction)ZstdDecompressionWriter_enter, METH_NOARGS, { "__enter__", (PyCFunction)ZstdDecompressionWriter_enter, METH_NOARGS,
PyDoc_STR("Enter a decompression context.") }, PyDoc_STR("Enter a decompression context.") },
{ "__exit__", (PyCFunction)ZstdDecompressionWriter_exit, METH_VARARGS, { "__exit__", (PyCFunction)ZstdDecompressionWriter_exit, METH_VARARGS,
PyDoc_STR("Exit a decompression context.") }, PyDoc_STR("Exit a decompression context.") },
{ "memory_size", (PyCFunction)ZstdDecompressionWriter_memory_size, METH_NOARGS, { "memory_size", (PyCFunction)ZstdDecompressionWriter_memory_size, METH_NOARGS,
PyDoc_STR("Obtain the memory size in bytes of the underlying decompressor.") }, PyDoc_STR("Obtain the memory size in bytes of the underlying decompressor.") },
{ "close", (PyCFunction)ZstdDecompressionWriter_close, METH_NOARGS, NULL },
{ "fileno", (PyCFunction)ZstdDecompressionWriter_fileno, METH_NOARGS, NULL },
{ "flush", (PyCFunction)ZstdDecompressionWriter_flush, METH_NOARGS, NULL },
{ "isatty", ZstdDecompressionWriter_false, METH_NOARGS, NULL },
{ "readable", ZstdDecompressionWriter_false, METH_NOARGS, NULL },
{ "readline", (PyCFunction)ZstdDecompressionWriter_unsupported, METH_VARARGS | METH_KEYWORDS, NULL },
{ "readlines", (PyCFunction)ZstdDecompressionWriter_unsupported, METH_VARARGS | METH_KEYWORDS, NULL },
{ "seek", (PyCFunction)ZstdDecompressionWriter_unsupported, METH_VARARGS | METH_KEYWORDS, NULL },
{ "seekable", ZstdDecompressionWriter_false, METH_NOARGS, NULL },
{ "tell", (PyCFunction)ZstdDecompressionWriter_unsupported, METH_VARARGS | METH_KEYWORDS, NULL },
{ "truncate", (PyCFunction)ZstdDecompressionWriter_unsupported, METH_VARARGS | METH_KEYWORDS, NULL },
{ "writable", ZstdDecompressionWriter_true, METH_NOARGS, NULL },
{ "writelines" , (PyCFunction)ZstdDecompressionWriter_unsupported, METH_VARARGS | METH_KEYWORDS, NULL },
{ "read", (PyCFunction)ZstdDecompressionWriter_unsupported, METH_VARARGS | METH_KEYWORDS, NULL },
{ "readall", (PyCFunction)ZstdDecompressionWriter_unsupported, METH_VARARGS | METH_KEYWORDS, NULL },
{ "readinto", (PyCFunction)ZstdDecompressionWriter_unsupported, METH_VARARGS | METH_KEYWORDS, NULL },
{ "write", (PyCFunction)ZstdDecompressionWriter_write, METH_VARARGS | METH_KEYWORDS, { "write", (PyCFunction)ZstdDecompressionWriter_write, METH_VARARGS | METH_KEYWORDS,
PyDoc_STR("Compress data") }, PyDoc_STR("Compress data") },
{ NULL, NULL } { NULL, NULL }
}; };
static PyMemberDef ZstdDecompressionWriter_members[] = {
{ "closed", T_BOOL, offsetof(ZstdDecompressionWriter, closed), READONLY, NULL },
{ NULL }
};
PyTypeObject ZstdDecompressionWriterType = { PyTypeObject ZstdDecompressionWriterType = {
PyVarObject_HEAD_INIT(NULL, 0) PyVarObject_HEAD_INIT(NULL, 0)
"zstd.ZstdDecompressionWriter", /* tp_name */ "zstd.ZstdDecompressionWriter", /* tp_name */
sizeof(ZstdDecompressionWriter),/* tp_basicsize */ sizeof(ZstdDecompressionWriter),/* tp_basicsize */
0, /* tp_itemsize */ 0, /* tp_itemsize */
(destructor)ZstdDecompressionWriter_dealloc, /* tp_dealloc */ (destructor)ZstdDecompressionWriter_dealloc, /* tp_dealloc */
0, /* tp_print */ 0, /* tp_print */
0, /* tp_getattr */ 0, /* tp_getattr */
ZstdDecompressionWriter__doc, /* tp_doc */ ZstdDecompressionWriter__doc, /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
0, /* tp_weaklistoffset */ 0, /* tp_weaklistoffset */
0, /* tp_iter */ 0, /* tp_iter */
0, /* tp_iternext */ 0, /* tp_iternext */
ZstdDecompressionWriter_methods,/* tp_methods */ ZstdDecompressionWriter_methods,/* tp_methods */
0, /* tp_members */ ZstdDecompressionWriter_members,/* tp_members */
0, /* tp_getset */ 0, /* tp_getset */
0, /* tp_base */ 0, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
0, /* tp_init */ 0, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */

contrib/python-zstandard/c-ext/decompressobj.c

PyErr_NoMemory(); PyErr_NoMemory();
goto except; goto except;
} }
output.size = self->outSize; output.size = self->outSize;
output.pos = 0; output.pos = 0;
while (1) { while (1) {
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_decompress_generic(self->decompressor->dctx, &output, &input); zresult = ZSTD_decompressStream(self->decompressor->dctx, &output, &input);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "zstd decompressor error: %s", PyErr_Format(ZstdError, "zstd decompressor error: %s",
ZSTD_getErrorName(zresult)); ZSTD_getErrorName(zresult));
goto except; goto except;
} }
finally: finally:
PyMem_Free(output.dst); PyMem_Free(output.dst);
PyBuffer_Release(&source); PyBuffer_Release(&source);
return result; return result;
} }
static PyObject* DecompressionObj_flush(ZstdDecompressionObj* self, PyObject* args, PyObject* kwargs) {
static char* kwlist[] = {
"length",
NULL
};
PyObject* length = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:flush", kwlist, &length)) {
return NULL;
}
Py_RETURN_NONE;
}
static PyMethodDef DecompressionObj_methods[] = { static PyMethodDef DecompressionObj_methods[] = {
{ "decompress", (PyCFunction)DecompressionObj_decompress, { "decompress", (PyCFunction)DecompressionObj_decompress,
METH_VARARGS | METH_KEYWORDS, PyDoc_STR("decompress data") }, METH_VARARGS | METH_KEYWORDS, PyDoc_STR("decompress data") },
{ "flush", (PyCFunction)DecompressionObj_flush,
METH_VARARGS | METH_KEYWORDS, PyDoc_STR("no-op") },
{ NULL, NULL } { NULL, NULL }
}; };
PyTypeObject ZstdDecompressionObjType = { PyTypeObject ZstdDecompressionObjType = {
PyVarObject_HEAD_INIT(NULL, 0) PyVarObject_HEAD_INIT(NULL, 0)
"zstd.ZstdDecompressionObj", /* tp_name */ "zstd.ZstdDecompressionObj", /* tp_name */
sizeof(ZstdDecompressionObj), /* tp_basicsize */ sizeof(ZstdDecompressionObj), /* tp_basicsize */
0, /* tp_itemsize */ 0, /* tp_itemsize */

contrib/python-zstandard/c-ext/decompressor.c

extern PyObject* ZstdError; extern PyObject* ZstdError;
/** /**
* Ensure the ZSTD_DCtx on a decompressor is initiated and ready for a new operation. * Ensure the ZSTD_DCtx on a decompressor is initiated and ready for a new operation.
*/ */
int ensure_dctx(ZstdDecompressor* decompressor, int loadDict) { int ensure_dctx(ZstdDecompressor* decompressor, int loadDict) {
size_t zresult; size_t zresult;
ZSTD_DCtx_reset(decompressor->dctx); ZSTD_DCtx_reset(decompressor->dctx, ZSTD_reset_session_only);
if (decompressor->maxWindowSize) { if (decompressor->maxWindowSize) {
zresult = ZSTD_DCtx_setMaxWindowSize(decompressor->dctx, decompressor->maxWindowSize); zresult = ZSTD_DCtx_setMaxWindowSize(decompressor->dctx, decompressor->maxWindowSize);
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "unable to set max window size: %s", PyErr_Format(ZstdError, "unable to set max window size: %s",
ZSTD_getErrorName(zresult)); ZSTD_getErrorName(zresult));
return 1; return 1;
} }
/* Send data to decompressor */ /* Send data to decompressor */
input.src = readBuffer; input.src = readBuffer;
input.size = readSize; input.size = readSize;
input.pos = 0; input.pos = 0;
while (input.pos < input.size) { while (input.pos < input.size) {
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_decompress_generic(self->dctx, &output, &input); zresult = ZSTD_decompressStream(self->dctx, &output, &input);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "zstd decompressor error: %s", PyErr_Format(ZstdError, "zstd decompressor error: %s",
ZSTD_getErrorName(zresult)); ZSTD_getErrorName(zresult));
res = NULL; res = NULL;
goto finally; goto finally;
} }
outBuffer.size = destCapacity; outBuffer.size = destCapacity;
outBuffer.pos = 0; outBuffer.pos = 0;
inBuffer.src = source.buf; inBuffer.src = source.buf;
inBuffer.size = source.len; inBuffer.size = source.len;
inBuffer.pos = 0; inBuffer.pos = 0;
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_decompress_generic(self->dctx, &outBuffer, &inBuffer); zresult = ZSTD_decompressStream(self->dctx, &outBuffer, &inBuffer);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "decompression error: %s", ZSTD_getErrorName(zresult)); PyErr_Format(ZstdError, "decompression error: %s", ZSTD_getErrorName(zresult));
Py_CLEAR(result); Py_CLEAR(result);
goto finally; goto finally;
} }
else if (zresult) { else if (zresult) {
Py_CLEAR(result); Py_CLEAR(result);
finally: finally:
return result; return result;
} }
PyDoc_STRVAR(Decompressor_stream_reader__doc__, PyDoc_STRVAR(Decompressor_stream_reader__doc__,
"stream_reader(source, [read_size=default])\n" "stream_reader(source, [read_size=default, [read_across_frames=False]])\n"
"\n" "\n"
"Obtain an object that behaves like an I/O stream that can be used for\n" "Obtain an object that behaves like an I/O stream that can be used for\n"
"reading decompressed output from an object.\n" "reading decompressed output from an object.\n"
"\n" "\n"
"The source object can be any object with a ``read(size)`` method or that\n" "The source object can be any object with a ``read(size)`` method or that\n"
"conforms to the buffer protocol.\n" "conforms to the buffer protocol.\n"
"\n"
"``read_across_frames`` controls the behavior of ``read()`` when the end\n"
"of a zstd frame is reached. When ``True``, ``read()`` can potentially\n"
"return data belonging to multiple zstd frames. When ``False``, ``read()``\n"
"will return when the end of a frame is reached.\n"
); );
static ZstdDecompressionReader* Decompressor_stream_reader(ZstdDecompressor* self, PyObject* args, PyObject* kwargs) { static ZstdDecompressionReader* Decompressor_stream_reader(ZstdDecompressor* self, PyObject* args, PyObject* kwargs) {
static char* kwlist[] = { static char* kwlist[] = {
"source", "source",
"read_size", "read_size",
"read_across_frames",
NULL NULL
}; };
PyObject* source; PyObject* source;
size_t readSize = ZSTD_DStreamInSize(); size_t readSize = ZSTD_DStreamInSize();
PyObject* readAcrossFrames = NULL;
ZstdDecompressionReader* result; ZstdDecompressionReader* result;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|k:stream_reader", kwlist, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|kO:stream_reader", kwlist,
&source, &readSize)) { &source, &readSize, &readAcrossFrames)) {
return NULL; return NULL;
} }
if (ensure_dctx(self, 1)) { if (ensure_dctx(self, 1)) {
return NULL; return NULL;
} }
result = (ZstdDecompressionReader*)PyObject_CallObject((PyObject*)&ZstdDecompressionReaderType, NULL); result = (ZstdDecompressionReader*)PyObject_CallObject((PyObject*)&ZstdDecompressionReaderType, NULL);
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"must pass an object with a read() method or that conforms to the buffer protocol"); "must pass an object with a read() method or that conforms to the buffer protocol");
Py_CLEAR(result); Py_CLEAR(result);
return NULL; return NULL;
} }
result->decompressor = self; result->decompressor = self;
Py_INCREF(self); Py_INCREF(self);
result->readAcrossFrames = readAcrossFrames ? PyObject_IsTrue(readAcrossFrames) : 0;
return result; return result;
} }
PyDoc_STRVAR(Decompressor_stream_writer__doc__, PyDoc_STRVAR(Decompressor_stream_writer__doc__,
"Create a context manager to write decompressed data to an object.\n" "Create a context manager to write decompressed data to an object.\n"
"\n" "\n"
"The passed object must have a ``write()`` method.\n" "The passed object must have a ``write()`` method.\n"
"\n" "\n"
"The caller feeds intput data to the object by calling ``write(data)``.\n" "The caller feeds intput data to the object by calling ``write(data)``.\n"
"Decompressed data is written to the argument given as it is decompressed.\n" "Decompressed data is written to the argument given as it is decompressed.\n"
"\n" "\n"
"An optional ``write_size`` argument defines the size of chunks to\n" "An optional ``write_size`` argument defines the size of chunks to\n"
"``write()`` to the writer. It defaults to the default output size for a zstd\n" "``write()`` to the writer. It defaults to the default output size for a zstd\n"
"streaming decompressor.\n" "streaming decompressor.\n"
); );
static ZstdDecompressionWriter* Decompressor_stream_writer(ZstdDecompressor* self, PyObject* args, PyObject* kwargs) { static ZstdDecompressionWriter* Decompressor_stream_writer(ZstdDecompressor* self, PyObject* args, PyObject* kwargs) {
static char* kwlist[] = { static char* kwlist[] = {
"writer", "writer",
"write_size", "write_size",
"write_return_read",
NULL NULL
}; };
PyObject* writer; PyObject* writer;
size_t outSize = ZSTD_DStreamOutSize(); size_t outSize = ZSTD_DStreamOutSize();
PyObject* writeReturnRead = NULL;
ZstdDecompressionWriter* result; ZstdDecompressionWriter* result;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|k:stream_writer", kwlist, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|kO:stream_writer", kwlist,
&writer, &outSize)) { &writer, &outSize, &writeReturnRead)) {
return NULL; return NULL;
} }
if (!PyObject_HasAttrString(writer, "write")) { if (!PyObject_HasAttrString(writer, "write")) {
PyErr_SetString(PyExc_ValueError, "must pass an object with a write() method"); PyErr_SetString(PyExc_ValueError, "must pass an object with a write() method");
return NULL; return NULL;
} }
if (ensure_dctx(self, 1)) {
return NULL;
}
result = (ZstdDecompressionWriter*)PyObject_CallObject((PyObject*)&ZstdDecompressionWriterType, NULL); result = (ZstdDecompressionWriter*)PyObject_CallObject((PyObject*)&ZstdDecompressionWriterType, NULL);
if (!result) { if (!result) {
return NULL; return NULL;
} }
result->decompressor = self; result->decompressor = self;
Py_INCREF(result->decompressor); Py_INCREF(result->decompressor);
result->writer = writer; result->writer = writer;
Py_INCREF(result->writer); Py_INCREF(result->writer);
result->outSize = outSize; result->outSize = outSize;
result->writeReturnRead = writeReturnRead ? PyObject_IsTrue(writeReturnRead) : 0;
return result; return result;
} }
PyDoc_STRVAR(Decompressor_decompress_content_dict_chain__doc__, PyDoc_STRVAR(Decompressor_decompress_content_dict_chain__doc__,
"Decompress a series of chunks using the content dictionary chaining technique\n" "Decompress a series of chunks using the content dictionary chaining technique\n"
); );
outBuffer.size = buffer1Size; outBuffer.size = buffer1Size;
outBuffer.pos = 0; outBuffer.pos = 0;
inBuffer.src = chunkData; inBuffer.src = chunkData;
inBuffer.size = chunkSize; inBuffer.size = chunkSize;
inBuffer.pos = 0; inBuffer.pos = 0;
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_decompress_generic(self->dctx, &outBuffer, &inBuffer); zresult = ZSTD_decompressStream(self->dctx, &outBuffer, &inBuffer);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "could not decompress chunk 0: %s", ZSTD_getErrorName(zresult)); PyErr_Format(ZstdError, "could not decompress chunk 0: %s", ZSTD_getErrorName(zresult));
goto finally; goto finally;
} }
else if (zresult) { else if (zresult) {
PyErr_Format(ZstdError, "chunk 0 did not decompress full frame"); PyErr_Format(ZstdError, "chunk 0 did not decompress full frame");
goto finally; goto finally;
goto finally; goto finally;
} }
outBuffer.dst = buffer2; outBuffer.dst = buffer2;
outBuffer.size = buffer2Size; outBuffer.size = buffer2Size;
outBuffer.pos = 0; outBuffer.pos = 0;
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_decompress_generic(self->dctx, &outBuffer, &inBuffer); zresult = ZSTD_decompressStream(self->dctx, &outBuffer, &inBuffer);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "could not decompress chunk %zd: %s", PyErr_Format(ZstdError, "could not decompress chunk %zd: %s",
chunkIndex, ZSTD_getErrorName(zresult)); chunkIndex, ZSTD_getErrorName(zresult));
goto finally; goto finally;
} }
else if (zresult) { else if (zresult) {
PyErr_Format(ZstdError, "chunk %zd did not decompress full frame", PyErr_Format(ZstdError, "chunk %zd did not decompress full frame",
goto finally; goto finally;
} }
outBuffer.dst = buffer1; outBuffer.dst = buffer1;
outBuffer.size = buffer1Size; outBuffer.size = buffer1Size;
outBuffer.pos = 0; outBuffer.pos = 0;
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_decompress_generic(self->dctx, &outBuffer, &inBuffer); zresult = ZSTD_decompressStream(self->dctx, &outBuffer, &inBuffer);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
PyErr_Format(ZstdError, "could not decompress chunk %zd: %s", PyErr_Format(ZstdError, "could not decompress chunk %zd: %s",
chunkIndex, ZSTD_getErrorName(zresult)); chunkIndex, ZSTD_getErrorName(zresult));
goto finally; goto finally;
} }
else if (zresult) { else if (zresult) {
PyErr_Format(ZstdError, "chunk %zd did not decompress full frame", PyErr_Format(ZstdError, "chunk %zd did not decompress full frame",
outBuffer.dst = dest; outBuffer.dst = dest;
outBuffer.size = decompressedSize; outBuffer.size = decompressedSize;
outBuffer.pos = 0; outBuffer.pos = 0;
inBuffer.src = source; inBuffer.src = source;
inBuffer.size = sourceSize; inBuffer.size = sourceSize;
inBuffer.pos = 0; inBuffer.pos = 0;
zresult = ZSTD_decompress_generic(state->dctx, &outBuffer, &inBuffer); zresult = ZSTD_decompressStream(state->dctx, &outBuffer, &inBuffer);
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
state->error = WorkerError_zstd; state->error = WorkerError_zstd;
state->zresult = zresult; state->zresult = zresult;
state->errorOffset = frameIndex; state->errorOffset = frameIndex;
return; return;
} }
else if (zresult || outBuffer.pos != decompressedSize) { else if (zresult || outBuffer.pos != decompressedSize) {
state->error = WorkerError_sizeMismatch; state->error = WorkerError_sizeMismatch;

contrib/python-zstandard/c-ext/decompressoriterator.c

return result; return result;
} }
self->output.dst = PyBytes_AsString(chunk); self->output.dst = PyBytes_AsString(chunk);
self->output.size = self->outSize; self->output.size = self->outSize;
self->output.pos = 0; self->output.pos = 0;
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
zresult = ZSTD_decompress_generic(self->decompressor->dctx, &self->output, &self->input); zresult = ZSTD_decompressStream(self->decompressor->dctx, &self->output, &self->input);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
/* We're done with the pointer. Nullify to prevent anyone from getting a /* We're done with the pointer. Nullify to prevent anyone from getting a
handle on a Python object. */ handle on a Python object. */
self->output.dst = NULL; self->output.dst = NULL;
if (ZSTD_isError(zresult)) { if (ZSTD_isError(zresult)) {
Py_DECREF(chunk); Py_DECREF(chunk);

contrib/python-zstandard/c-ext/python-zstandard.h

#include "structmember.h" #include "structmember.h"
#define ZSTD_STATIC_LINKING_ONLY #define ZSTD_STATIC_LINKING_ONLY
#define ZDICT_STATIC_LINKING_ONLY #define ZDICT_STATIC_LINKING_ONLY
#include <zstd.h> #include <zstd.h>
#include <zdict.h> #include <zdict.h>
/* Remember to change the string in zstandard/__init__ as well */ /* Remember to change the string in zstandard/__init__ as well */
#define PYTHON_ZSTANDARD_VERSION "0.10.1" #define PYTHON_ZSTANDARD_VERSION "0.11.0"
typedef enum { typedef enum {
compressorobj_flush_finish, compressorobj_flush_finish,
compressorobj_flush_block, compressorobj_flush_block,
} CompressorObj_Flush; } CompressorObj_Flush;
/* /*
Represents a ZstdCompressionParameters type. Represents a ZstdCompressionParameters type.
This type holds all the low-level compression parameters that can be set. This type holds all the low-level compression parameters that can be set.
*/ */
typedef struct { typedef struct {
PyObject_HEAD PyObject_HEAD
ZSTD_CCtx_params* params; ZSTD_CCtx_params* params;
unsigned format;
int compressionLevel;
unsigned windowLog;
unsigned hashLog;
unsigned chainLog;
unsigned searchLog;
unsigned minMatch;
unsigned targetLength;
unsigned compressionStrategy;
unsigned contentSizeFlag;
unsigned checksumFlag;
unsigned dictIDFlag;
unsigned threads;
unsigned jobSize;
unsigned overlapSizeLog;
unsigned forceMaxWindow;
unsigned enableLongDistanceMatching;
unsigned ldmHashLog;
unsigned ldmMinMatch;
unsigned ldmBucketSizeLog;
unsigned ldmHashEveryLog;
} ZstdCompressionParametersObject; } ZstdCompressionParametersObject;
extern PyTypeObject ZstdCompressionParametersType; extern PyTypeObject ZstdCompressionParametersType;
/* /*
Represents a FrameParameters type. Represents a FrameParameters type.
This type is basically a wrapper around ZSTD_frameParams. This type is basically a wrapper around ZSTD_frameParams.
extern PyTypeObject ZstdCompressionObjType; extern PyTypeObject ZstdCompressionObjType;
typedef struct { typedef struct {
PyObject_HEAD PyObject_HEAD
ZstdCompressor* compressor; ZstdCompressor* compressor;
PyObject* writer; PyObject* writer;
unsigned long long sourceSize; ZSTD_outBuffer output;
size_t outSize; size_t outSize;
int entered; int entered;
int closed;
int writeReturnRead;
unsigned long long bytesCompressed; unsigned long long bytesCompressed;
} ZstdCompressionWriter; } ZstdCompressionWriter;
extern PyTypeObject ZstdCompressionWriterType; extern PyTypeObject ZstdCompressionWriterType;
typedef struct { typedef struct {
PyObject_HEAD PyObject_HEAD
PyObject_HEAD PyObject_HEAD
/* Parent decompressor to which this object is associated. */ /* Parent decompressor to which this object is associated. */
ZstdDecompressor* decompressor; ZstdDecompressor* decompressor;
/* Object to read() from (if reading from a stream). */ /* Object to read() from (if reading from a stream). */
PyObject* reader; PyObject* reader;
/* Size for read() operations on reader. */ /* Size for read() operations on reader. */
size_t readSize; size_t readSize;
/* Whether a read() can return data spanning multiple zstd frames. */
int readAcrossFrames;
/* Buffer to read from (if reading from a buffer). */ /* Buffer to read from (if reading from a buffer). */
Py_buffer buffer; Py_buffer buffer;
/* Whether the context manager is active. */ /* Whether the context manager is active. */
int entered; int entered;
/* Whether we've closed the stream. */ /* Whether we've closed the stream. */
int closed; int closed;
typedef struct { typedef struct {
PyObject_HEAD PyObject_HEAD
ZstdDecompressor* decompressor; ZstdDecompressor* decompressor;
PyObject* writer; PyObject* writer;
size_t outSize; size_t outSize;
int entered; int entered;
int closed;
int writeReturnRead;
} ZstdDecompressionWriter; } ZstdDecompressionWriter;
extern PyTypeObject ZstdDecompressionWriterType; extern PyTypeObject ZstdDecompressionWriterType;
typedef struct { typedef struct {
PyObject_HEAD PyObject_HEAD
ZstdDecompressor* decompressor; ZstdDecompressor* decompressor;
/* Array of first offset in each buffer instance. 0th entry corresponds /* Array of first offset in each buffer instance. 0th entry corresponds
to number of elements in the 0th buffer. 1st entry corresponds to the to number of elements in the 0th buffer. 1st entry corresponds to the
sum of elements in 0th and 1st buffers. */ sum of elements in 0th and 1st buffers. */
Py_ssize_t* firstElements; Py_ssize_t* firstElements;
} ZstdBufferWithSegmentsCollection; } ZstdBufferWithSegmentsCollection;
extern PyTypeObject ZstdBufferWithSegmentsCollectionType; extern PyTypeObject ZstdBufferWithSegmentsCollectionType;
int set_parameter(ZSTD_CCtx_params* params, ZSTD_cParameter param, unsigned value); int set_parameter(ZSTD_CCtx_params* params, ZSTD_cParameter param, int value);
int set_parameters(ZSTD_CCtx_params* params, ZstdCompressionParametersObject* obj); int set_parameters(ZSTD_CCtx_params* params, ZstdCompressionParametersObject* obj);
int to_cparams(ZstdCompressionParametersObject* params, ZSTD_compressionParameters* cparams);
FrameParametersObject* get_frame_parameters(PyObject* self, PyObject* args, PyObject* kwargs); FrameParametersObject* get_frame_parameters(PyObject* self, PyObject* args, PyObject* kwargs);
int ensure_ddict(ZstdCompressionDict* dict); int ensure_ddict(ZstdCompressionDict* dict);
int ensure_dctx(ZstdDecompressor* decompressor, int loadDict); int ensure_dctx(ZstdDecompressor* decompressor, int loadDict);
ZstdCompressionDict* train_dictionary(PyObject* self, PyObject* args, PyObject* kwargs); ZstdCompressionDict* train_dictionary(PyObject* self, PyObject* args, PyObject* kwargs);
ZstdBufferWithSegments* BufferWithSegments_FromMemory(void* data, unsigned long long dataSize, BufferSegment* segments, Py_ssize_t segmentsSize); ZstdBufferWithSegments* BufferWithSegments_FromMemory(void* data, unsigned long long dataSize, BufferSegment* segments, Py_ssize_t segmentsSize);
Py_ssize_t BufferWithSegmentsCollection_length(ZstdBufferWithSegmentsCollection*); Py_ssize_t BufferWithSegmentsCollection_length(ZstdBufferWithSegmentsCollection*);
int cpu_count(void); int cpu_count(void);
size_t roundpow2(size_t); size_t roundpow2(size_t);
int safe_pybytes_resize(PyObject** obj, Py_ssize_t size); int safe_pybytes_resize(PyObject** obj, Py_ssize_t size);

contrib/python-zstandard/make_cffi.py

'compress/zstd_compress.c', 'compress/zstd_compress.c',
'compress/zstd_double_fast.c', 'compress/zstd_double_fast.c',
'compress/zstd_fast.c', 'compress/zstd_fast.c',
'compress/zstd_lazy.c', 'compress/zstd_lazy.c',
'compress/zstd_ldm.c', 'compress/zstd_ldm.c',
'compress/zstd_opt.c', 'compress/zstd_opt.c',
'compress/zstdmt_compress.c', 'compress/zstdmt_compress.c',
'decompress/huf_decompress.c', 'decompress/huf_decompress.c',
'decompress/zstd_ddict.c',
'decompress/zstd_decompress.c', 'decompress/zstd_decompress.c',
'decompress/zstd_decompress_block.c',
'dictBuilder/cover.c', 'dictBuilder/cover.c',
'dictBuilder/fastcover.c', 'dictBuilder/fastcover.c',
'dictBuilder/divsufsort.c', 'dictBuilder/divsufsort.c',
'dictBuilder/zdict.c', 'dictBuilder/zdict.c',
)] )]
# Headers whose preprocessed output will be fed into cdef(). # Headers whose preprocessed output will be fed into cdef().
HEADERS = [os.path.join(HERE, 'zstd', *p) for p in ( HEADERS = [os.path.join(HERE, 'zstd', *p) for p in (

contrib/python-zstandard/setup.py

#!/usr/bin/env python #!/usr/bin/env python
# Copyright (c) 2016-present, Gregory Szorc # Copyright (c) 2016-present, Gregory Szorc
# All rights reserved. # All rights reserved.
# #
# This software may be modified and distributed under the terms # This software may be modified and distributed under the terms
# of the BSD license. See the LICENSE file for details. # of the BSD license. See the LICENSE file for details.
from __future__ import print_function
from distutils.version import LooseVersion
import os import os
import sys import sys
from setuptools import setup from setuptools import setup
# Need change in 1.10 for ffi.from_buffer() to handle all buffer types
# (like memoryview).
# Need feature in 1.11 for ffi.gc() to declare size of objects so we avoid
# garbage collection pitfalls.
MINIMUM_CFFI_VERSION = '1.11'
try: try:
import cffi import cffi
# PyPy (and possibly other distros) have CFFI distributed as part of
# them. The install_requires for CFFI below won't work. We need to sniff
# out the CFFI version here and reject CFFI if it is too old.
cffi_version = LooseVersion(cffi.__version__)
if cffi_version < LooseVersion(MINIMUM_CFFI_VERSION):
print('CFFI 1.11 or newer required (%s found); '
'not building CFFI backend' % cffi_version,
file=sys.stderr)
cffi = None
except ImportError: except ImportError:
cffi = None cffi = None
import setup_zstd import setup_zstd
SUPPORT_LEGACY = False SUPPORT_LEGACY = False
SYSTEM_ZSTD = False SYSTEM_ZSTD = False
WARNINGS_AS_ERRORS = False WARNINGS_AS_ERRORS = False
warnings_as_errors=WARNINGS_AS_ERRORS), warnings_as_errors=WARNINGS_AS_ERRORS),
] ]
install_requires = [] install_requires = []
if cffi: if cffi:
import make_cffi import make_cffi
extensions.append(make_cffi.ffi.distutils_extension()) extensions.append(make_cffi.ffi.distutils_extension())
install_requires.append('cffi>=%s' % MINIMUM_CFFI_VERSION)
# Need change in 1.10 for ffi.from_buffer() to handle all buffer types
# (like memoryview).
# Need feature in 1.11 for ffi.gc() to declare size of objects so we avoid
# garbage collection pitfalls.
install_requires.append('cffi>=1.11')
version = None version = None
with open('c-ext/python-zstandard.h', 'r') as fh: with open('c-ext/python-zstandard.h', 'r') as fh:
for line in fh: for line in fh:
if not line.startswith('#define PYTHON_ZSTANDARD_VERSION'): if not line.startswith('#define PYTHON_ZSTANDARD_VERSION'):
continue continue
'Development Status :: 4 - Beta', 'Development Status :: 4 - Beta',
'Intended Audience :: Developers', 'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License', 'License :: OSI Approved :: BSD License',
'Programming Language :: C', 'Programming Language :: C',
'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
], ],
keywords='zstandard zstd compression', keywords='zstandard zstd compression',
packages=['zstandard'], packages=['zstandard'],
ext_modules=extensions, ext_modules=extensions,
test_suite='tests', test_suite='tests',
install_requires=install_requires, install_requires=install_requires,
) )

contrib/python-zstandard/setup_zstd.py

'compress/zstd_compress.c', 'compress/zstd_compress.c',
'compress/zstd_double_fast.c', 'compress/zstd_double_fast.c',
'compress/zstd_fast.c', 'compress/zstd_fast.c',
'compress/zstd_lazy.c', 'compress/zstd_lazy.c',
'compress/zstd_ldm.c', 'compress/zstd_ldm.c',
'compress/zstd_opt.c', 'compress/zstd_opt.c',
'compress/zstdmt_compress.c', 'compress/zstdmt_compress.c',
'decompress/huf_decompress.c', 'decompress/huf_decompress.c',
'decompress/zstd_ddict.c',
'decompress/zstd_decompress.c', 'decompress/zstd_decompress.c',
'decompress/zstd_decompress_block.c',
'dictBuilder/cover.c', 'dictBuilder/cover.c',
'dictBuilder/divsufsort.c', 'dictBuilder/divsufsort.c',
'dictBuilder/fastcover.c', 'dictBuilder/fastcover.c',
'dictBuilder/zdict.c', 'dictBuilder/zdict.c',
)] )]
zstd_sources_legacy = ['zstd/%s' % p for p in ( zstd_sources_legacy = ['zstd/%s' % p for p in (
'deprecated/zbuff_common.c', 'deprecated/zbuff_common.c',

contrib/python-zstandard/tests/common.py

new_method = types.UnboundMethodType(new_fn, fn.im_self, new_method = types.UnboundMethodType(new_fn, fn.im_self,
fn.im_class) fn.im_class)
setattr(cls, name, new_method) setattr(cls, name, new_method)
return cls return cls
class OpCountingBytesIO(io.BytesIO): class NonClosingBytesIO(io.BytesIO):
"""BytesIO that saves the underlying buffer on close().
This allows us to access written data after close().
"""
def __init__(self, *args, **kwargs):
super(NonClosingBytesIO, self).__init__(*args, **kwargs)
self._saved_buffer = None
def close(self):
self._saved_buffer = self.getvalue()
return super(NonClosingBytesIO, self).close()
def getvalue(self):
if self.closed:
return self._saved_buffer
else:
return super(NonClosingBytesIO, self).getvalue()
class OpCountingBytesIO(NonClosingBytesIO):
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
self._flush_count = 0
self._read_count = 0 self._read_count = 0
self._write_count = 0 self._write_count = 0
return super(OpCountingBytesIO, self).__init__(*args, **kwargs) return super(OpCountingBytesIO, self).__init__(*args, **kwargs)
def flush(self):
self._flush_count += 1
return super(OpCountingBytesIO, self).flush()
def read(self, *args): def read(self, *args):
self._read_count += 1 self._read_count += 1
return super(OpCountingBytesIO, self).read(*args) return super(OpCountingBytesIO, self).read(*args)
def write(self, data): def write(self, data):
self._write_count += 1 self._write_count += 1
return super(OpCountingBytesIO, self).write(data) return super(OpCountingBytesIO, self).write(data)
try: try:
with open(os.path.join(root, f), 'rb') as fh: with open(os.path.join(root, f), 'rb') as fh:
data = fh.read() data = fh.read()
if data: if data:
_source_files.append(data) _source_files.append(data)
except OSError: except OSError:
pass pass
# Also add some actual random data.
_source_files.append(os.urandom(100))
_source_files.append(os.urandom(1000))
_source_files.append(os.urandom(10000))
_source_files.append(os.urandom(100000))
_source_files.append(os.urandom(1000000))
return _source_files return _source_files
def generate_samples(): def generate_samples():
inputs = [ inputs = [
b'foo', b'foo',
b'bar', b'bar',
b'abcdef', b'abcdef',
b'sometext', b'sometext',
b'baz', b'baz',
] ]
samples = [] samples = []
for i in range(128): for i in range(128):
samples.append(inputs[i % 5]) samples.append(inputs[i % 5])
samples.append(inputs[i % 5] * (i + 3)) samples.append(inputs[i % 5] * (i + 3))
samples.append(inputs[-(i % 5)] * (i + 2)) samples.append(inputs[-(i % 5)] * (i + 2))
return samples return samples
if hypothesis: if hypothesis:
default_settings = hypothesis.settings() default_settings = hypothesis.settings(deadline=10000)
hypothesis.settings.register_profile('default', default_settings) hypothesis.settings.register_profile('default', default_settings)
ci_settings = hypothesis.settings(max_examples=2500, ci_settings = hypothesis.settings(deadline=20000, max_examples=1000)
max_iterations=2500)
hypothesis.settings.register_profile('ci', ci_settings) hypothesis.settings.register_profile('ci', ci_settings)
expensive_settings = hypothesis.settings(deadline=None, max_examples=10000)
hypothesis.settings.register_profile('expensive', expensive_settings)
hypothesis.settings.load_profile( hypothesis.settings.load_profile(
os.environ.get('HYPOTHESIS_PROFILE', 'default')) os.environ.get('HYPOTHESIS_PROFILE', 'default'))

contrib/python-zstandard/tests/test_buffer_util.py

import struct import struct
import unittest import unittest
import zstandard as zstd import zstandard as zstd
ss = struct.Struct('=QQ') ss = struct.Struct('=QQ')
class TestBufferWithSegments(unittest.TestCase): class TestBufferWithSegments(unittest.TestCase):
def test_arguments(self): def test_arguments(self):
if not hasattr(zstd, 'BufferWithSegments'):
self.skipTest('BufferWithSegments not available')
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
zstd.BufferWithSegments() zstd.BufferWithSegments()
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
zstd.BufferWithSegments(b'foo') zstd.BufferWithSegments(b'foo')
# Segments data should be a multiple of 16. # Segments data should be a multiple of 16.
with self.assertRaisesRegexp(ValueError, 'segments array size is not a multiple of 16'): with self.assertRaisesRegexp(ValueError, 'segments array size is not a multiple of 16'):
zstd.BufferWithSegments(b'foo', b'\x00\x00') zstd.BufferWithSegments(b'foo', b'\x00\x00')
def test_invalid_offset(self): def test_invalid_offset(self):
if not hasattr(zstd, 'BufferWithSegments'):
self.skipTest('BufferWithSegments not available')
with self.assertRaisesRegexp(ValueError, 'offset within segments array references memory'): with self.assertRaisesRegexp(ValueError, 'offset within segments array references memory'):
zstd.BufferWithSegments(b'foo', ss.pack(0, 4)) zstd.BufferWithSegments(b'foo', ss.pack(0, 4))
def test_invalid_getitem(self): def test_invalid_getitem(self):
if not hasattr(zstd, 'BufferWithSegments'):
self.skipTest('BufferWithSegments not available')
b = zstd.BufferWithSegments(b'foo', ss.pack(0, 3)) b = zstd.BufferWithSegments(b'foo', ss.pack(0, 3))
with self.assertRaisesRegexp(IndexError, 'offset must be non-negative'): with self.assertRaisesRegexp(IndexError, 'offset must be non-negative'):
test = b[-10] test = b[-10]
with self.assertRaisesRegexp(IndexError, 'offset must be less than 1'): with self.assertRaisesRegexp(IndexError, 'offset must be less than 1'):
test = b[1] test = b[1]
with self.assertRaisesRegexp(IndexError, 'offset must be less than 1'): with self.assertRaisesRegexp(IndexError, 'offset must be less than 1'):
test = b[2] test = b[2]
def test_single(self): def test_single(self):
if not hasattr(zstd, 'BufferWithSegments'):
self.skipTest('BufferWithSegments not available')
b = zstd.BufferWithSegments(b'foo', ss.pack(0, 3)) b = zstd.BufferWithSegments(b'foo', ss.pack(0, 3))
self.assertEqual(len(b), 1) self.assertEqual(len(b), 1)
self.assertEqual(b.size, 3) self.assertEqual(b.size, 3)
self.assertEqual(b.tobytes(), b'foo') self.assertEqual(b.tobytes(), b'foo')
self.assertEqual(len(b[0]), 3) self.assertEqual(len(b[0]), 3)
self.assertEqual(b[0].offset, 0) self.assertEqual(b[0].offset, 0)
self.assertEqual(b[0].tobytes(), b'foo') self.assertEqual(b[0].tobytes(), b'foo')
def test_multiple(self): def test_multiple(self):
if not hasattr(zstd, 'BufferWithSegments'):
self.skipTest('BufferWithSegments not available')
b = zstd.BufferWithSegments(b'foofooxfooxy', b''.join([ss.pack(0, 3), b = zstd.BufferWithSegments(b'foofooxfooxy', b''.join([ss.pack(0, 3),
ss.pack(3, 4), ss.pack(3, 4),
ss.pack(7, 5)])) ss.pack(7, 5)]))
self.assertEqual(len(b), 3) self.assertEqual(len(b), 3)
self.assertEqual(b.size, 12) self.assertEqual(b.size, 12)
self.assertEqual(b.tobytes(), b'foofooxfooxy') self.assertEqual(b.tobytes(), b'foofooxfooxy')
self.assertEqual(b[0].tobytes(), b'foo') self.assertEqual(b[0].tobytes(), b'foo')
self.assertEqual(b[1].tobytes(), b'foox') self.assertEqual(b[1].tobytes(), b'foox')
self.assertEqual(b[2].tobytes(), b'fooxy') self.assertEqual(b[2].tobytes(), b'fooxy')
class TestBufferWithSegmentsCollection(unittest.TestCase): class TestBufferWithSegmentsCollection(unittest.TestCase):
def test_empty_constructor(self): def test_empty_constructor(self):
if not hasattr(zstd, 'BufferWithSegmentsCollection'):
self.skipTest('BufferWithSegmentsCollection not available')
with self.assertRaisesRegexp(ValueError, 'must pass at least 1 argument'): with self.assertRaisesRegexp(ValueError, 'must pass at least 1 argument'):
zstd.BufferWithSegmentsCollection() zstd.BufferWithSegmentsCollection()
def test_argument_validation(self): def test_argument_validation(self):
if not hasattr(zstd, 'BufferWithSegmentsCollection'):
self.skipTest('BufferWithSegmentsCollection not available')
with self.assertRaisesRegexp(TypeError, 'arguments must be BufferWithSegments'): with self.assertRaisesRegexp(TypeError, 'arguments must be BufferWithSegments'):
zstd.BufferWithSegmentsCollection(None) zstd.BufferWithSegmentsCollection(None)
with self.assertRaisesRegexp(TypeError, 'arguments must be BufferWithSegments'): with self.assertRaisesRegexp(TypeError, 'arguments must be BufferWithSegments'):
zstd.BufferWithSegmentsCollection(zstd.BufferWithSegments(b'foo', ss.pack(0, 3)), zstd.BufferWithSegmentsCollection(zstd.BufferWithSegments(b'foo', ss.pack(0, 3)),
None) None)
with self.assertRaisesRegexp(ValueError, 'ZstdBufferWithSegments cannot be empty'): with self.assertRaisesRegexp(ValueError, 'ZstdBufferWithSegments cannot be empty'):
zstd.BufferWithSegmentsCollection(zstd.BufferWithSegments(b'', b'')) zstd.BufferWithSegmentsCollection(zstd.BufferWithSegments(b'', b''))
def test_length(self): def test_length(self):
if not hasattr(zstd, 'BufferWithSegmentsCollection'):
self.skipTest('BufferWithSegmentsCollection not available')
b1 = zstd.BufferWithSegments(b'foo', ss.pack(0, 3)) b1 = zstd.BufferWithSegments(b'foo', ss.pack(0, 3))
b2 = zstd.BufferWithSegments(b'barbaz', b''.join([ss.pack(0, 3), b2 = zstd.BufferWithSegments(b'barbaz', b''.join([ss.pack(0, 3),
ss.pack(3, 3)])) ss.pack(3, 3)]))
c = zstd.BufferWithSegmentsCollection(b1) c = zstd.BufferWithSegmentsCollection(b1)
self.assertEqual(len(c), 1) self.assertEqual(len(c), 1)
self.assertEqual(c.size(), 3) self.assertEqual(c.size(), 3)
c = zstd.BufferWithSegmentsCollection(b2) c = zstd.BufferWithSegmentsCollection(b2)
self.assertEqual(len(c), 2) self.assertEqual(len(c), 2)
self.assertEqual(c.size(), 6) self.assertEqual(c.size(), 6)
c = zstd.BufferWithSegmentsCollection(b1, b2) c = zstd.BufferWithSegmentsCollection(b1, b2)
self.assertEqual(len(c), 3) self.assertEqual(len(c), 3)
self.assertEqual(c.size(), 9) self.assertEqual(c.size(), 9)
def test_getitem(self): def test_getitem(self):
if not hasattr(zstd, 'BufferWithSegmentsCollection'):
self.skipTest('BufferWithSegmentsCollection not available')
b1 = zstd.BufferWithSegments(b'foo', ss.pack(0, 3)) b1 = zstd.BufferWithSegments(b'foo', ss.pack(0, 3))
b2 = zstd.BufferWithSegments(b'barbaz', b''.join([ss.pack(0, 3), b2 = zstd.BufferWithSegments(b'barbaz', b''.join([ss.pack(0, 3),
ss.pack(3, 3)])) ss.pack(3, 3)]))
c = zstd.BufferWithSegmentsCollection(b1, b2) c = zstd.BufferWithSegmentsCollection(b1, b2)
with self.assertRaisesRegexp(IndexError, 'offset must be less than 3'): with self.assertRaisesRegexp(IndexError, 'offset must be less than 3'):
c[3] c[3]
with self.assertRaisesRegexp(IndexError, 'offset must be less than 3'): with self.assertRaisesRegexp(IndexError, 'offset must be less than 3'):
c[4] c[4]
self.assertEqual(c[0].tobytes(), b'foo') self.assertEqual(c[0].tobytes(), b'foo')
self.assertEqual(c[1].tobytes(), b'bar') self.assertEqual(c[1].tobytes(), b'bar')
self.assertEqual(c[2].tobytes(), b'baz') self.assertEqual(c[2].tobytes(), b'baz')

contrib/python-zstandard/tests/test_compressor.py

import hashlib import hashlib
import io import io
import os
import struct import struct
import sys import sys
import tarfile import tarfile
import tempfile
import unittest import unittest
import zstandard as zstd import zstandard as zstd
from .common import ( from .common import (
make_cffi, make_cffi,
NonClosingBytesIO,
OpCountingBytesIO, OpCountingBytesIO,
) )
if sys.version_info[0] >= 3: if sys.version_info[0] >= 3:
next = lambda it: it.__next__() next = lambda it: it.__next__()
else: else:
next = lambda it: it.next() next = lambda it: it.next()
cobj = cctx.compressobj() cobj = cctx.compressobj()
result = cobj.compress(b''.join(chunks)) + cobj.flush() result = cobj.compress(b''.join(chunks)) + cobj.flush()
self.assertEqual(len(result), 999) self.assertEqual(len(result), 999)
self.assertEqual(result[0:4], b'\x28\xb5\x2f\xfd') self.assertEqual(result[0:4], b'\x28\xb5\x2f\xfd')
params = zstd.get_frame_parameters(result) params = zstd.get_frame_parameters(result)
self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN) self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
self.assertEqual(params.window_size, 1048576) self.assertEqual(params.window_size, 2097152)
self.assertEqual(params.dict_id, 0) self.assertEqual(params.dict_id, 0)
self.assertFalse(params.has_checksum) self.assertFalse(params.has_checksum)
def test_write_checksum(self): def test_write_checksum(self):
cctx = zstd.ZstdCompressor(level=1) cctx = zstd.ZstdCompressor(level=1)
cobj = cctx.compressobj() cobj = cctx.compressobj()
no_checksum = cobj.compress(b'foobar') + cobj.flush() no_checksum = cobj.compress(b'foobar') + cobj.flush()
cctx = zstd.ZstdCompressor(level=1, write_checksum=True) cctx = zstd.ZstdCompressor(level=1, write_checksum=True)
def test_compress_after_finished(self): def test_compress_after_finished(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
cobj = cctx.compressobj() cobj = cctx.compressobj()
cobj.compress(b'foo') cobj.compress(b'foo')
cobj.flush() cobj.flush()
with self.assertRaisesRegexp(zstd.ZstdError, 'cannot call compress\(\) after compressor'): with self.assertRaisesRegexp(zstd.ZstdError, r'cannot call compress\(\) after compressor'):
cobj.compress(b'foo') cobj.compress(b'foo')
with self.assertRaisesRegexp(zstd.ZstdError, 'compressor object already finished'): with self.assertRaisesRegexp(zstd.ZstdError, 'compressor object already finished'):
cobj.flush() cobj.flush()
def test_flush_block_repeated(self): def test_flush_block_repeated(self):
cctx = zstd.ZstdCompressor(level=1) cctx = zstd.ZstdCompressor(level=1)
cobj = cctx.compressobj() cobj = cctx.compressobj()
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
r, w = cctx.copy_stream(source, dest) r, w = cctx.copy_stream(source, dest)
self.assertEqual(r, 255 * 16384) self.assertEqual(r, 255 * 16384)
self.assertEqual(w, 999) self.assertEqual(w, 999)
params = zstd.get_frame_parameters(dest.getvalue()) params = zstd.get_frame_parameters(dest.getvalue())
self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN) self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
self.assertEqual(params.window_size, 1048576) self.assertEqual(params.window_size, 2097152)
self.assertEqual(params.dict_id, 0) self.assertEqual(params.dict_id, 0)
self.assertFalse(params.has_checksum) self.assertFalse(params.has_checksum)
def test_write_checksum(self): def test_write_checksum(self):
source = io.BytesIO(b'foobar') source = io.BytesIO(b'foobar')
no_checksum = io.BytesIO() no_checksum = io.BytesIO()
cctx = zstd.ZstdCompressor(level=1) cctx = zstd.ZstdCompressor(level=1)
with cctx.stream_reader(b'foo' * 60) as reader: with cctx.stream_reader(b'foo' * 60) as reader:
with self.assertRaises(io.UnsupportedOperation): with self.assertRaises(io.UnsupportedOperation):
reader.readline() reader.readline()
with self.assertRaises(io.UnsupportedOperation): with self.assertRaises(io.UnsupportedOperation):
reader.readlines() reader.readlines()
# This could probably be implemented someday.
with self.assertRaises(NotImplementedError):
reader.readall()
with self.assertRaises(io.UnsupportedOperation): with self.assertRaises(io.UnsupportedOperation):
iter(reader) iter(reader)
with self.assertRaises(io.UnsupportedOperation): with self.assertRaises(io.UnsupportedOperation):
next(reader) next(reader)
with self.assertRaises(OSError): with self.assertRaises(OSError):
reader.writelines([]) reader.writelines([])
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
with cctx.stream_reader(b'foo' * 60) as reader: with cctx.stream_reader(b'foo' * 60) as reader:
reader.close() reader.close()
self.assertTrue(reader.closed) self.assertTrue(reader.closed)
with self.assertRaisesRegexp(ValueError, 'stream is closed'): with self.assertRaisesRegexp(ValueError, 'stream is closed'):
reader.read(10) reader.read(10)
def test_read_bad_size(self): def test_read_sizes(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
foo = cctx.compress(b'foo')
with cctx.stream_reader(b'foo') as reader: with cctx.stream_reader(b'foo') as reader:
with self.assertRaisesRegexp(ValueError, 'cannot read negative or size 0 amounts'): with self.assertRaisesRegexp(ValueError, 'cannot read negative amounts less than -1'):
reader.read(-1) reader.read(-2)
with self.assertRaisesRegexp(ValueError, 'cannot read negative or size 0 amounts'): self.assertEqual(reader.read(0), b'')
reader.read(0) self.assertEqual(reader.read(), foo)
def test_read_buffer(self): def test_read_buffer(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
source = b''.join([b'foo' * 60, b'bar' * 60, b'baz' * 60]) source = b''.join([b'foo' * 60, b'bar' * 60, b'baz' * 60])
frame = cctx.compress(source) frame = cctx.compress(source)
with cctx.stream_reader(source) as reader: with cctx.stream_reader(source) as reader:
with cctx.stream_reader(source, size=2) as reader: with cctx.stream_reader(source, size=2) as reader:
with self.assertRaisesRegexp(zstd.ZstdError, 'Src size is incorrect'): with self.assertRaisesRegexp(zstd.ZstdError, 'Src size is incorrect'):
reader.read(10) reader.read(10)
# Try another compression operation. # Try another compression operation.
with cctx.stream_reader(source, size=42): with cctx.stream_reader(source, size=42):
pass pass
def test_readall(self):
cctx = zstd.ZstdCompressor()
frame = cctx.compress(b'foo' * 1024)
reader = cctx.stream_reader(b'foo' * 1024)
self.assertEqual(reader.readall(), frame)
def test_readinto(self):
cctx = zstd.ZstdCompressor()
foo = cctx.compress(b'foo')
reader = cctx.stream_reader(b'foo')
with self.assertRaises(Exception):
reader.readinto(b'foobar')
# readinto() with sufficiently large destination.
b = bytearray(1024)
reader = cctx.stream_reader(b'foo')
self.assertEqual(reader.readinto(b), len(foo))
self.assertEqual(b[0:len(foo)], foo)
self.assertEqual(reader.readinto(b), 0)
self.assertEqual(b[0:len(foo)], foo)
# readinto() with small reads.
b = bytearray(1024)
reader = cctx.stream_reader(b'foo', read_size=1)
self.assertEqual(reader.readinto(b), len(foo))
self.assertEqual(b[0:len(foo)], foo)
# Too small destination buffer.
b = bytearray(2)
reader = cctx.stream_reader(b'foo')
self.assertEqual(reader.readinto(b), 2)
self.assertEqual(b[:], foo[0:2])
self.assertEqual(reader.readinto(b), 2)
self.assertEqual(b[:], foo[2:4])
self.assertEqual(reader.readinto(b), 2)
self.assertEqual(b[:], foo[4:6])
def test_readinto1(self):
cctx = zstd.ZstdCompressor()
foo = b''.join(cctx.read_to_iter(io.BytesIO(b'foo')))
reader = cctx.stream_reader(b'foo')
with self.assertRaises(Exception):
reader.readinto1(b'foobar')
b = bytearray(1024)
source = OpCountingBytesIO(b'foo')
reader = cctx.stream_reader(source)
self.assertEqual(reader.readinto1(b), len(foo))
self.assertEqual(b[0:len(foo)], foo)
self.assertEqual(source._read_count, 2)
# readinto1() with small reads.
b = bytearray(1024)
source = OpCountingBytesIO(b'foo')
reader = cctx.stream_reader(source, read_size=1)
self.assertEqual(reader.readinto1(b), len(foo))
self.assertEqual(b[0:len(foo)], foo)
self.assertEqual(source._read_count, 4)
def test_read1(self):
cctx = zstd.ZstdCompressor()
foo = b''.join(cctx.read_to_iter(io.BytesIO(b'foo')))
b = OpCountingBytesIO(b'foo')
reader = cctx.stream_reader(b)
self.assertEqual(reader.read1(), foo)
self.assertEqual(b._read_count, 2)
b = OpCountingBytesIO(b'foo')
reader = cctx.stream_reader(b)
self.assertEqual(reader.read1(0), b'')
self.assertEqual(reader.read1(2), foo[0:2])
self.assertEqual(b._read_count, 2)
self.assertEqual(reader.read1(2), foo[2:4])
self.assertEqual(reader.read1(1024), foo[4:])
@make_cffi @make_cffi
class TestCompressor_stream_writer(unittest.TestCase): class TestCompressor_stream_writer(unittest.TestCase):
def test_empty(self): def test_io_api(self):
buffer = io.BytesIO()
cctx = zstd.ZstdCompressor()
writer = cctx.stream_writer(buffer)
self.assertFalse(writer.isatty())
self.assertFalse(writer.readable())
with self.assertRaises(io.UnsupportedOperation):
writer.readline()
with self.assertRaises(io.UnsupportedOperation):
writer.readline(42)
with self.assertRaises(io.UnsupportedOperation):
writer.readline(size=42)
with self.assertRaises(io.UnsupportedOperation):
writer.readlines()
with self.assertRaises(io.UnsupportedOperation):
writer.readlines(42)
with self.assertRaises(io.UnsupportedOperation):
writer.readlines(hint=42)
with self.assertRaises(io.UnsupportedOperation):
writer.seek(0)
with self.assertRaises(io.UnsupportedOperation):
writer.seek(10, os.SEEK_SET)
self.assertFalse(writer.seekable())
with self.assertRaises(io.UnsupportedOperation):
writer.truncate()
with self.assertRaises(io.UnsupportedOperation):
writer.truncate(42)
with self.assertRaises(io.UnsupportedOperation):
writer.truncate(size=42)
self.assertTrue(writer.writable())
with self.assertRaises(NotImplementedError):
writer.writelines([])
with self.assertRaises(io.UnsupportedOperation):
writer.read()
with self.assertRaises(io.UnsupportedOperation):
writer.read(42)
with self.assertRaises(io.UnsupportedOperation):
writer.read(size=42)
with self.assertRaises(io.UnsupportedOperation):
writer.readall()
with self.assertRaises(io.UnsupportedOperation):
writer.readinto(None)
with self.assertRaises(io.UnsupportedOperation):
writer.fileno()
self.assertFalse(writer.closed)
def test_fileno_file(self):
with tempfile.TemporaryFile('wb') as tf:
cctx = zstd.ZstdCompressor()
writer = cctx.stream_writer(tf)
self.assertEqual(writer.fileno(), tf.fileno())
def test_close(self):
buffer = NonClosingBytesIO()
cctx = zstd.ZstdCompressor(level=1)
writer = cctx.stream_writer(buffer)
writer.write(b'foo' * 1024)
self.assertFalse(writer.closed)
self.assertFalse(buffer.closed)
writer.close()
self.assertTrue(writer.closed)
self.assertTrue(buffer.closed)
with self.assertRaisesRegexp(ValueError, 'stream is closed'):
writer.write(b'foo')
with self.assertRaisesRegexp(ValueError, 'stream is closed'):
writer.flush()
with self.assertRaisesRegexp(ValueError, 'stream is closed'):
with writer:
pass
self.assertEqual(buffer.getvalue(),
b'\x28\xb5\x2f\xfd\x00\x48\x55\x00\x00\x18\x66\x6f'
b'\x6f\x01\x00\xfa\xd3\x77\x43')
# Context manager exit should close stream.
buffer = io.BytesIO() buffer = io.BytesIO()
writer = cctx.stream_writer(buffer)
with writer:
writer.write(b'foo')
self.assertTrue(writer.closed)
def test_empty(self):
buffer = NonClosingBytesIO()
cctx = zstd.ZstdCompressor(level=1, write_content_size=False) cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
with cctx.stream_writer(buffer) as compressor: with cctx.stream_writer(buffer) as compressor:
compressor.write(b'') compressor.write(b'')
result = buffer.getvalue() result = buffer.getvalue()
self.assertEqual(result, b'\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00') self.assertEqual(result, b'\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00')
params = zstd.get_frame_parameters(result) params = zstd.get_frame_parameters(result)
self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN) self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
self.assertEqual(params.window_size, 524288) self.assertEqual(params.window_size, 524288)
self.assertEqual(params.dict_id, 0) self.assertEqual(params.dict_id, 0)
self.assertFalse(params.has_checksum) self.assertFalse(params.has_checksum)
# Test without context manager.
buffer = io.BytesIO()
compressor = cctx.stream_writer(buffer)
self.assertEqual(compressor.write(b''), 0)
self.assertEqual(buffer.getvalue(), b'')
self.assertEqual(compressor.flush(zstd.FLUSH_FRAME), 9)
result = buffer.getvalue()
self.assertEqual(result, b'\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00')
params = zstd.get_frame_parameters(result)
self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
self.assertEqual(params.window_size, 524288)
self.assertEqual(params.dict_id, 0)
self.assertFalse(params.has_checksum)
# Test write_return_read=True
compressor = cctx.stream_writer(buffer, write_return_read=True)
self.assertEqual(compressor.write(b''), 0)
def test_input_types(self): def test_input_types(self):
expected = b'\x28\xb5\x2f\xfd\x00\x48\x19\x00\x00\x66\x6f\x6f' expected = b'\x28\xb5\x2f\xfd\x00\x48\x19\x00\x00\x66\x6f\x6f'
cctx = zstd.ZstdCompressor(level=1) cctx = zstd.ZstdCompressor(level=1)
mutable_array = bytearray(3) mutable_array = bytearray(3)
mutable_array[:] = b'foo' mutable_array[:] = b'foo'
sources = [ sources = [
memoryview(b'foo'), memoryview(b'foo'),
bytearray(b'foo'), bytearray(b'foo'),
mutable_array, mutable_array,
] ]
for source in sources: for source in sources:
buffer = io.BytesIO() buffer = NonClosingBytesIO()
with cctx.stream_writer(buffer) as compressor: with cctx.stream_writer(buffer) as compressor:
compressor.write(source) compressor.write(source)
self.assertEqual(buffer.getvalue(), expected) self.assertEqual(buffer.getvalue(), expected)
compressor = cctx.stream_writer(buffer, write_return_read=True)
self.assertEqual(compressor.write(source), len(source))
def test_multiple_compress(self): def test_multiple_compress(self):
buffer = io.BytesIO() buffer = NonClosingBytesIO()
cctx = zstd.ZstdCompressor(level=5) cctx = zstd.ZstdCompressor(level=5)
with cctx.stream_writer(buffer) as compressor: with cctx.stream_writer(buffer) as compressor:
self.assertEqual(compressor.write(b'foo'), 0) self.assertEqual(compressor.write(b'foo'), 0)
self.assertEqual(compressor.write(b'bar'), 0) self.assertEqual(compressor.write(b'bar'), 0)
self.assertEqual(compressor.write(b'x' * 8192), 0) self.assertEqual(compressor.write(b'x' * 8192), 0)
result = buffer.getvalue() result = buffer.getvalue()
self.assertEqual(result, self.assertEqual(result,
b'\x28\xb5\x2f\xfd\x00\x50\x75\x00\x00\x38\x66\x6f' b'\x28\xb5\x2f\xfd\x00\x58\x75\x00\x00\x38\x66\x6f'
b'\x6f\x62\x61\x72\x78\x01\x00\xfc\xdf\x03\x23')
# Test without context manager.
buffer = io.BytesIO()
compressor = cctx.stream_writer(buffer)
self.assertEqual(compressor.write(b'foo'), 0)
self.assertEqual(compressor.write(b'bar'), 0)
self.assertEqual(compressor.write(b'x' * 8192), 0)
self.assertEqual(compressor.flush(zstd.FLUSH_FRAME), 23)
result = buffer.getvalue()
self.assertEqual(result,
b'\x28\xb5\x2f\xfd\x00\x58\x75\x00\x00\x38\x66\x6f'
b'\x6f\x62\x61\x72\x78\x01\x00\xfc\xdf\x03\x23') b'\x6f\x62\x61\x72\x78\x01\x00\xfc\xdf\x03\x23')
# Test with write_return_read=True.
compressor = cctx.stream_writer(buffer, write_return_read=True)
self.assertEqual(compressor.write(b'foo'), 3)
self.assertEqual(compressor.write(b'barbiz'), 6)
self.assertEqual(compressor.write(b'x' * 8192), 8192)
def test_dictionary(self): def test_dictionary(self):
samples = [] samples = []
for i in range(128): for i in range(128):
samples.append(b'foo' * 64) samples.append(b'foo' * 64)
samples.append(b'bar' * 64) samples.append(b'bar' * 64)
samples.append(b'foobar' * 64) samples.append(b'foobar' * 64)
d = zstd.train_dictionary(8192, samples) d = zstd.train_dictionary(8192, samples)
h = hashlib.sha1(d.as_bytes()).hexdigest() h = hashlib.sha1(d.as_bytes()).hexdigest()
self.assertEqual(h, '2b3b6428da5bf2c9cc9d4bb58ba0bc5990dd0e79') self.assertEqual(h, '88ca0d38332aff379d4ced166a51c280a7679aad')
buffer = io.BytesIO() buffer = NonClosingBytesIO()
cctx = zstd.ZstdCompressor(level=9, dict_data=d) cctx = zstd.ZstdCompressor(level=9, dict_data=d)
with cctx.stream_writer(buffer) as compressor: with cctx.stream_writer(buffer) as compressor:
self.assertEqual(compressor.write(b'foo'), 0) self.assertEqual(compressor.write(b'foo'), 0)
self.assertEqual(compressor.write(b'bar'), 0) self.assertEqual(compressor.write(b'bar'), 0)
self.assertEqual(compressor.write(b'foo' * 16384), 0) self.assertEqual(compressor.write(b'foo' * 16384), 0)
compressed = buffer.getvalue() compressed = buffer.getvalue()
params = zstd.get_frame_parameters(compressed) params = zstd.get_frame_parameters(compressed)
self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN) self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
self.assertEqual(params.window_size, 2097152) self.assertEqual(params.window_size, 2097152)
self.assertEqual(params.dict_id, d.dict_id()) self.assertEqual(params.dict_id, d.dict_id())
self.assertFalse(params.has_checksum) self.assertFalse(params.has_checksum)
h = hashlib.sha1(compressed).hexdigest() h = hashlib.sha1(compressed).hexdigest()
self.assertEqual(h, '23f88344263678478f5f82298e0a5d1833125786') self.assertEqual(h, '8703b4316f274d26697ea5dd480f29c08e85d940')
source = b'foo' + b'bar' + (b'foo' * 16384) source = b'foo' + b'bar' + (b'foo' * 16384)
dctx = zstd.ZstdDecompressor(dict_data=d) dctx = zstd.ZstdDecompressor(dict_data=d)
self.assertEqual(dctx.decompress(compressed, max_output_size=len(source)), self.assertEqual(dctx.decompress(compressed, max_output_size=len(source)),
source) source)
def test_compression_params(self): def test_compression_params(self):
params = zstd.ZstdCompressionParameters( params = zstd.ZstdCompressionParameters(
window_log=20, window_log=20,
chain_log=6, chain_log=6,
hash_log=12, hash_log=12,
min_match=5, min_match=5,
search_log=4, search_log=4,
target_length=10, target_length=10,
compression_strategy=zstd.STRATEGY_FAST) strategy=zstd.STRATEGY_FAST)
buffer = io.BytesIO() buffer = NonClosingBytesIO()
cctx = zstd.ZstdCompressor(compression_params=params) cctx = zstd.ZstdCompressor(compression_params=params)
with cctx.stream_writer(buffer) as compressor: with cctx.stream_writer(buffer) as compressor:
self.assertEqual(compressor.write(b'foo'), 0) self.assertEqual(compressor.write(b'foo'), 0)
self.assertEqual(compressor.write(b'bar'), 0) self.assertEqual(compressor.write(b'bar'), 0)
self.assertEqual(compressor.write(b'foobar' * 16384), 0) self.assertEqual(compressor.write(b'foobar' * 16384), 0)
compressed = buffer.getvalue() compressed = buffer.getvalue()
params = zstd.get_frame_parameters(compressed) params = zstd.get_frame_parameters(compressed)
self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN) self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
self.assertEqual(params.window_size, 1048576) self.assertEqual(params.window_size, 1048576)
self.assertEqual(params.dict_id, 0) self.assertEqual(params.dict_id, 0)
self.assertFalse(params.has_checksum) self.assertFalse(params.has_checksum)
h = hashlib.sha1(compressed).hexdigest() h = hashlib.sha1(compressed).hexdigest()
self.assertEqual(h, '2a8111d72eb5004cdcecbdac37da9f26720d30ef') self.assertEqual(h, '2a8111d72eb5004cdcecbdac37da9f26720d30ef')
def test_write_checksum(self): def test_write_checksum(self):
no_checksum = io.BytesIO() no_checksum = NonClosingBytesIO()
cctx = zstd.ZstdCompressor(level=1) cctx = zstd.ZstdCompressor(level=1)
with cctx.stream_writer(no_checksum) as compressor: with cctx.stream_writer(no_checksum) as compressor:
self.assertEqual(compressor.write(b'foobar'), 0) self.assertEqual(compressor.write(b'foobar'), 0)
with_checksum = io.BytesIO() with_checksum = NonClosingBytesIO()
cctx = zstd.ZstdCompressor(level=1, write_checksum=True) cctx = zstd.ZstdCompressor(level=1, write_checksum=True)
with cctx.stream_writer(with_checksum) as compressor: with cctx.stream_writer(with_checksum) as compressor:
self.assertEqual(compressor.write(b'foobar'), 0) self.assertEqual(compressor.write(b'foobar'), 0)
no_params = zstd.get_frame_parameters(no_checksum.getvalue()) no_params = zstd.get_frame_parameters(no_checksum.getvalue())
with_params = zstd.get_frame_parameters(with_checksum.getvalue()) with_params = zstd.get_frame_parameters(with_checksum.getvalue())
self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN) self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
self.assertEqual(with_params.content_size, zstd.CONTENTSIZE_UNKNOWN) self.assertEqual(with_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
self.assertEqual(no_params.dict_id, 0) self.assertEqual(no_params.dict_id, 0)
self.assertEqual(with_params.dict_id, 0) self.assertEqual(with_params.dict_id, 0)
self.assertFalse(no_params.has_checksum) self.assertFalse(no_params.has_checksum)
self.assertTrue(with_params.has_checksum) self.assertTrue(with_params.has_checksum)
self.assertEqual(len(with_checksum.getvalue()), self.assertEqual(len(with_checksum.getvalue()),
len(no_checksum.getvalue()) + 4) len(no_checksum.getvalue()) + 4)
def test_write_content_size(self): def test_write_content_size(self):
no_size = io.BytesIO() no_size = NonClosingBytesIO()
cctx = zstd.ZstdCompressor(level=1, write_content_size=False) cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
with cctx.stream_writer(no_size) as compressor: with cctx.stream_writer(no_size) as compressor:
self.assertEqual(compressor.write(b'foobar' * 256), 0) self.assertEqual(compressor.write(b'foobar' * 256), 0)
with_size = io.BytesIO() with_size = NonClosingBytesIO()
cctx = zstd.ZstdCompressor(level=1) cctx = zstd.ZstdCompressor(level=1)
with cctx.stream_writer(with_size) as compressor: with cctx.stream_writer(with_size) as compressor:
self.assertEqual(compressor.write(b'foobar' * 256), 0) self.assertEqual(compressor.write(b'foobar' * 256), 0)
# Source size is not known in streaming mode, so header not # Source size is not known in streaming mode, so header not
# written. # written.
self.assertEqual(len(with_size.getvalue()), self.assertEqual(len(with_size.getvalue()),
len(no_size.getvalue())) len(no_size.getvalue()))
# Declaring size will write the header. # Declaring size will write the header.
with_size = io.BytesIO() with_size = NonClosingBytesIO()
with cctx.stream_writer(with_size, size=len(b'foobar' * 256)) as compressor: with cctx.stream_writer(with_size, size=len(b'foobar' * 256)) as compressor:
self.assertEqual(compressor.write(b'foobar' * 256), 0) self.assertEqual(compressor.write(b'foobar' * 256), 0)
no_params = zstd.get_frame_parameters(no_size.getvalue()) no_params = zstd.get_frame_parameters(no_size.getvalue())
with_params = zstd.get_frame_parameters(with_size.getvalue()) with_params = zstd.get_frame_parameters(with_size.getvalue())
self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN) self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
self.assertEqual(with_params.content_size, 1536) self.assertEqual(with_params.content_size, 1536)
self.assertEqual(no_params.dict_id, 0) self.assertEqual(no_params.dict_id, 0)
self.assertEqual(with_params.dict_id, 0) self.assertEqual(with_params.dict_id, 0)
self.assertFalse(no_params.has_checksum) self.assertFalse(no_params.has_checksum)
self.assertFalse(with_params.has_checksum) self.assertFalse(with_params.has_checksum)
self.assertEqual(len(with_size.getvalue()), self.assertEqual(len(with_size.getvalue()),
len(no_size.getvalue()) + 1) len(no_size.getvalue()) + 1)
def test_no_dict_id(self): def test_no_dict_id(self):
samples = [] samples = []
for i in range(128): for i in range(128):
samples.append(b'foo' * 64) samples.append(b'foo' * 64)
samples.append(b'bar' * 64) samples.append(b'bar' * 64)
samples.append(b'foobar' * 64) samples.append(b'foobar' * 64)
d = zstd.train_dictionary(1024, samples) d = zstd.train_dictionary(1024, samples)
with_dict_id = io.BytesIO() with_dict_id = NonClosingBytesIO()
cctx = zstd.ZstdCompressor(level=1, dict_data=d) cctx = zstd.ZstdCompressor(level=1, dict_data=d)
with cctx.stream_writer(with_dict_id) as compressor: with cctx.stream_writer(with_dict_id) as compressor:
self.assertEqual(compressor.write(b'foobarfoobar'), 0) self.assertEqual(compressor.write(b'foobarfoobar'), 0)
self.assertEqual(with_dict_id.getvalue()[4:5], b'\x03') self.assertEqual(with_dict_id.getvalue()[4:5], b'\x03')
cctx = zstd.ZstdCompressor(level=1, dict_data=d, write_dict_id=False) cctx = zstd.ZstdCompressor(level=1, dict_data=d, write_dict_id=False)
no_dict_id = io.BytesIO() no_dict_id = NonClosingBytesIO()
with cctx.stream_writer(no_dict_id) as compressor: with cctx.stream_writer(no_dict_id) as compressor:
self.assertEqual(compressor.write(b'foobarfoobar'), 0) self.assertEqual(compressor.write(b'foobarfoobar'), 0)
self.assertEqual(no_dict_id.getvalue()[4:5], b'\x00') self.assertEqual(no_dict_id.getvalue()[4:5], b'\x00')
no_params = zstd.get_frame_parameters(no_dict_id.getvalue()) no_params = zstd.get_frame_parameters(no_dict_id.getvalue())
with_params = zstd.get_frame_parameters(with_dict_id.getvalue()) with_params = zstd.get_frame_parameters(with_dict_id.getvalue())
self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN) self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
trailing = dest.getvalue()[offset:] trailing = dest.getvalue()[offset:]
# 3 bytes block header + 4 bytes frame checksum # 3 bytes block header + 4 bytes frame checksum
self.assertEqual(len(trailing), 7) self.assertEqual(len(trailing), 7)
header = trailing[0:3] header = trailing[0:3]
self.assertEqual(header, b'\x01\x00\x00') self.assertEqual(header, b'\x01\x00\x00')
def test_multithreaded(self): def test_flush_frame(self):
cctx = zstd.ZstdCompressor(level=3)
dest = OpCountingBytesIO()
with cctx.stream_writer(dest) as compressor:
self.assertEqual(compressor.write(b'foobar' * 8192), 0)
self.assertEqual(compressor.flush(zstd.FLUSH_FRAME), 23)
compressor.write(b'biz' * 16384)
self.assertEqual(dest.getvalue(),
# Frame 1.
b'\x28\xb5\x2f\xfd\x00\x58\x75\x00\x00\x30\x66\x6f\x6f'
b'\x62\x61\x72\x01\x00\xf7\xbf\xe8\xa5\x08'
# Frame 2.
b'\x28\xb5\x2f\xfd\x00\x58\x5d\x00\x00\x18\x62\x69\x7a'
b'\x01\x00\xfa\x3f\x75\x37\x04')
def test_bad_flush_mode(self):
cctx = zstd.ZstdCompressor()
dest = io.BytesIO() dest = io.BytesIO()
with cctx.stream_writer(dest) as compressor:
with self.assertRaisesRegexp(ValueError, 'unknown flush_mode: 42'):
compressor.flush(flush_mode=42)
def test_multithreaded(self):
dest = NonClosingBytesIO()
cctx = zstd.ZstdCompressor(threads=2) cctx = zstd.ZstdCompressor(threads=2)
with cctx.stream_writer(dest) as compressor: with cctx.stream_writer(dest) as compressor:
compressor.write(b'a' * 1048576) compressor.write(b'a' * 1048576)
compressor.write(b'b' * 1048576) compressor.write(b'b' * 1048576)
compressor.write(b'c' * 1048576) compressor.write(b'c' * 1048576)
self.assertEqual(len(dest.getvalue()), 295) self.assertEqual(len(dest.getvalue()), 295)
with cctx.stream_writer(dest, size=2) as compressor: with cctx.stream_writer(dest, size=2) as compressor:
compressor.write(b'foo') compressor.write(b'foo')
# Test another operation. # Test another operation.
with cctx.stream_writer(dest, size=42): with cctx.stream_writer(dest, size=42):
pass pass
def test_tarfile_compat(self): def test_tarfile_compat(self):
raise unittest.SkipTest('not yet fully working') dest = NonClosingBytesIO()
dest = io.BytesIO()
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
with cctx.stream_writer(dest) as compressor: with cctx.stream_writer(dest) as compressor:
with tarfile.open('tf', mode='w', fileobj=compressor) as tf: with tarfile.open('tf', mode='w|', fileobj=compressor) as tf:
tf.add(__file__, 'test_compressor.py') tf.add(__file__, 'test_compressor.py')
dest.seek(0) dest = io.BytesIO(dest.getvalue())
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
with dctx.stream_reader(dest) as reader: with dctx.stream_reader(dest) as reader:
with tarfile.open(mode='r:', fileobj=reader) as tf: with tarfile.open(mode='r|', fileobj=reader) as tf:
for member in tf: for member in tf:
self.assertEqual(member.name, 'test_compressor.py') self.assertEqual(member.name, 'test_compressor.py')
@make_cffi @make_cffi
class TestCompressor_read_to_iter(unittest.TestCase): class TestCompressor_read_to_iter(unittest.TestCase):
def test_type_validation(self): def test_type_validation(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
# Object with read() works. # Object with read() works.
for chunk in cctx.read_to_iter(io.BytesIO()): for chunk in cctx.read_to_iter(io.BytesIO()):
pass pass
it = chunker.compress(b'') it = chunker.compress(b'')
with self.assertRaises(StopIteration): with self.assertRaises(StopIteration):
next(it) next(it)
it = chunker.finish() it = chunker.finish()
self.assertEqual(next(it), b'\x28\xb5\x2f\xfd\x00\x50\x01\x00\x00') self.assertEqual(next(it), b'\x28\xb5\x2f\xfd\x00\x58\x01\x00\x00')
with self.assertRaises(StopIteration): with self.assertRaises(StopIteration):
next(it) next(it)
def test_simple_input(self): def test_simple_input(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
chunker = cctx.chunker() chunker = cctx.chunker()
it = chunker.compress(b'foobar') it = chunker.compress(b'foobar')
with self.assertRaises(StopIteration): with self.assertRaises(StopIteration):
next(it) next(it)
it = chunker.compress(b'baz' * 30) it = chunker.compress(b'baz' * 30)
with self.assertRaises(StopIteration): with self.assertRaises(StopIteration):
next(it) next(it)
it = chunker.finish() it = chunker.finish()
self.assertEqual(next(it), self.assertEqual(next(it),
b'\x28\xb5\x2f\xfd\x00\x50\x7d\x00\x00\x48\x66\x6f' b'\x28\xb5\x2f\xfd\x00\x58\x7d\x00\x00\x48\x66\x6f'
b'\x6f\x62\x61\x72\x62\x61\x7a\x01\x00\xe4\xe4\x8e') b'\x6f\x62\x61\x72\x62\x61\x7a\x01\x00\xe4\xe4\x8e')
with self.assertRaises(StopIteration): with self.assertRaises(StopIteration):
next(it) next(it)
def test_input_size(self): def test_input_size(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
chunker = cctx.chunker(size=1024) chunker = cctx.chunker(size=1024)
chunks = list(chunker.compress(b'foo' * 1024)) chunks = list(chunker.compress(b'foo' * 1024))
self.assertEqual(chunks, []) self.assertEqual(chunks, [])
chunks = list(chunker.finish()) chunks = list(chunker.finish())
self.assertTrue(all(len(chunk) == 1 for chunk in chunks)) self.assertTrue(all(len(chunk) == 1 for chunk in chunks))
self.assertEqual( self.assertEqual(
b''.join(chunks), b''.join(chunks),
b'\x28\xb5\x2f\xfd\x00\x50\x55\x00\x00\x18\x66\x6f\x6f\x01\x00' b'\x28\xb5\x2f\xfd\x00\x58\x55\x00\x00\x18\x66\x6f\x6f\x01\x00'
b'\xfa\xd3\x77\x43') b'\xfa\xd3\x77\x43')
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
self.assertEqual(dctx.decompress(b''.join(chunks), self.assertEqual(dctx.decompress(b''.join(chunks),
max_output_size=10000), max_output_size=10000),
b'foo' * 1024) b'foo' * 1024)
def test_input_types(self): def test_input_types(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
mutable_array = bytearray(3) mutable_array = bytearray(3)
mutable_array[:] = b'foo' mutable_array[:] = b'foo'
sources = [ sources = [
memoryview(b'foo'), memoryview(b'foo'),
bytearray(b'foo'), bytearray(b'foo'),
mutable_array, mutable_array,
] ]
for source in sources: for source in sources:
chunker = cctx.chunker() chunker = cctx.chunker()
self.assertEqual(list(chunker.compress(source)), []) self.assertEqual(list(chunker.compress(source)), [])
self.assertEqual(list(chunker.finish()), [ self.assertEqual(list(chunker.finish()), [
b'\x28\xb5\x2f\xfd\x00\x50\x19\x00\x00\x66\x6f\x6f' b'\x28\xb5\x2f\xfd\x00\x58\x19\x00\x00\x66\x6f\x6f'
]) ])
def test_flush(self): def test_flush(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
chunker = cctx.chunker() chunker = cctx.chunker()
self.assertEqual(list(chunker.compress(b'foo' * 1024)), []) self.assertEqual(list(chunker.compress(b'foo' * 1024)), [])
self.assertEqual(list(chunker.compress(b'bar' * 1024)), []) self.assertEqual(list(chunker.compress(b'bar' * 1024)), [])
chunks1 = list(chunker.flush()) chunks1 = list(chunker.flush())
self.assertEqual(chunks1, [ self.assertEqual(chunks1, [
b'\x28\xb5\x2f\xfd\x00\x50\x8c\x00\x00\x30\x66\x6f\x6f\x62\x61\x72' b'\x28\xb5\x2f\xfd\x00\x58\x8c\x00\x00\x30\x66\x6f\x6f\x62\x61\x72'
b'\x02\x00\xfa\x03\xfe\xd0\x9f\xbe\x1b\x02' b'\x02\x00\xfa\x03\xfe\xd0\x9f\xbe\x1b\x02'
]) ])
self.assertEqual(list(chunker.flush()), []) self.assertEqual(list(chunker.flush()), [])
self.assertEqual(list(chunker.flush()), []) self.assertEqual(list(chunker.flush()), [])
self.assertEqual(list(chunker.compress(b'baz' * 1024)), []) self.assertEqual(list(chunker.compress(b'baz' * 1024)), [])
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
chunker = cctx.chunker() chunker = cctx.chunker()
list(chunker.compress(b'foo')) list(chunker.compress(b'foo'))
list(chunker.finish()) list(chunker.finish())
with self.assertRaisesRegexp( with self.assertRaisesRegexp(
zstd.ZstdError, zstd.ZstdError,
'cannot call compress\(\) after compression finished'): r'cannot call compress\(\) after compression finished'):
list(chunker.compress(b'foo')) list(chunker.compress(b'foo'))
def test_flush_after_finish(self): def test_flush_after_finish(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
chunker = cctx.chunker() chunker = cctx.chunker()
list(chunker.compress(b'foo')) list(chunker.compress(b'foo'))
list(chunker.finish()) list(chunker.finish())
with self.assertRaisesRegexp( with self.assertRaisesRegexp(
zstd.ZstdError, zstd.ZstdError,
'cannot call flush\(\) after compression finished'): r'cannot call flush\(\) after compression finished'):
list(chunker.flush()) list(chunker.flush())
def test_finish_after_finish(self): def test_finish_after_finish(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
chunker = cctx.chunker() chunker = cctx.chunker()
list(chunker.compress(b'foo')) list(chunker.compress(b'foo'))
list(chunker.finish()) list(chunker.finish())
with self.assertRaisesRegexp( with self.assertRaisesRegexp(
zstd.ZstdError, zstd.ZstdError,
'cannot call finish\(\) after compression finished'): r'cannot call finish\(\) after compression finished'):
list(chunker.finish()) list(chunker.finish())
class TestCompressor_multi_compress_to_buffer(unittest.TestCase): class TestCompressor_multi_compress_to_buffer(unittest.TestCase):
def test_invalid_inputs(self): def test_invalid_inputs(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
if not hasattr(cctx, 'multi_compress_to_buffer'):
self.skipTest('multi_compress_to_buffer not available')
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
cctx.multi_compress_to_buffer(True) cctx.multi_compress_to_buffer(True)
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
cctx.multi_compress_to_buffer((1, 2)) cctx.multi_compress_to_buffer((1, 2))
with self.assertRaisesRegexp(TypeError, 'item 0 not a bytes like object'): with self.assertRaisesRegexp(TypeError, 'item 0 not a bytes like object'):
cctx.multi_compress_to_buffer([u'foo']) cctx.multi_compress_to_buffer([u'foo'])
def test_empty_input(self): def test_empty_input(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
if not hasattr(cctx, 'multi_compress_to_buffer'):
self.skipTest('multi_compress_to_buffer not available')
with self.assertRaisesRegexp(ValueError, 'no source elements found'): with self.assertRaisesRegexp(ValueError, 'no source elements found'):
cctx.multi_compress_to_buffer([]) cctx.multi_compress_to_buffer([])
with self.assertRaisesRegexp(ValueError, 'source elements are empty'): with self.assertRaisesRegexp(ValueError, 'source elements are empty'):
cctx.multi_compress_to_buffer([b'', b'', b'']) cctx.multi_compress_to_buffer([b'', b'', b''])
def test_list_input(self): def test_list_input(self):
cctx = zstd.ZstdCompressor(write_checksum=True) cctx = zstd.ZstdCompressor(write_checksum=True)
if not hasattr(cctx, 'multi_compress_to_buffer'):
self.skipTest('multi_compress_to_buffer not available')
original = [b'foo' * 12, b'bar' * 6] original = [b'foo' * 12, b'bar' * 6]
frames = [cctx.compress(c) for c in original] frames = [cctx.compress(c) for c in original]
b = cctx.multi_compress_to_buffer(original) b = cctx.multi_compress_to_buffer(original)
self.assertIsInstance(b, zstd.BufferWithSegmentsCollection) self.assertIsInstance(b, zstd.BufferWithSegmentsCollection)
self.assertEqual(len(b), 2) self.assertEqual(len(b), 2)
self.assertEqual(b.size(), 44) self.assertEqual(b.size(), 44)
self.assertEqual(b[0].tobytes(), frames[0]) self.assertEqual(b[0].tobytes(), frames[0])
self.assertEqual(b[1].tobytes(), frames[1]) self.assertEqual(b[1].tobytes(), frames[1])
def test_buffer_with_segments_input(self): def test_buffer_with_segments_input(self):
cctx = zstd.ZstdCompressor(write_checksum=True) cctx = zstd.ZstdCompressor(write_checksum=True)
if not hasattr(cctx, 'multi_compress_to_buffer'):
self.skipTest('multi_compress_to_buffer not available')
original = [b'foo' * 4, b'bar' * 6] original = [b'foo' * 4, b'bar' * 6]
frames = [cctx.compress(c) for c in original] frames = [cctx.compress(c) for c in original]
offsets = struct.pack('=QQQQ', 0, len(original[0]), offsets = struct.pack('=QQQQ', 0, len(original[0]),
len(original[0]), len(original[1])) len(original[0]), len(original[1]))
segments = zstd.BufferWithSegments(b''.join(original), offsets) segments = zstd.BufferWithSegments(b''.join(original), offsets)
result = cctx.multi_compress_to_buffer(segments) result = cctx.multi_compress_to_buffer(segments)
self.assertEqual(len(result), 2) self.assertEqual(len(result), 2)
self.assertEqual(result.size(), 47) self.assertEqual(result.size(), 47)
self.assertEqual(result[0].tobytes(), frames[0]) self.assertEqual(result[0].tobytes(), frames[0])
self.assertEqual(result[1].tobytes(), frames[1]) self.assertEqual(result[1].tobytes(), frames[1])
def test_buffer_with_segments_collection_input(self): def test_buffer_with_segments_collection_input(self):
cctx = zstd.ZstdCompressor(write_checksum=True) cctx = zstd.ZstdCompressor(write_checksum=True)
if not hasattr(cctx, 'multi_compress_to_buffer'):
self.skipTest('multi_compress_to_buffer not available')
original = [ original = [
b'foo1', b'foo1',
b'foo2' * 2, b'foo2' * 2,
b'foo3' * 3, b'foo3' * 3,
b'foo4' * 4, b'foo4' * 4,
b'foo5' * 5, b'foo5' * 5,
] ]
def test_multiple_threads(self): def test_multiple_threads(self):
# threads argument will cause multi-threaded ZSTD APIs to be used, which will # threads argument will cause multi-threaded ZSTD APIs to be used, which will
# make output different. # make output different.
refcctx = zstd.ZstdCompressor(write_checksum=True) refcctx = zstd.ZstdCompressor(write_checksum=True)
reference = [refcctx.compress(b'x' * 64), refcctx.compress(b'y' * 64)] reference = [refcctx.compress(b'x' * 64), refcctx.compress(b'y' * 64)]
cctx = zstd.ZstdCompressor(write_checksum=True) cctx = zstd.ZstdCompressor(write_checksum=True)
if not hasattr(cctx, 'multi_compress_to_buffer'):
self.skipTest('multi_compress_to_buffer not available')
frames = [] frames = []
frames.extend(b'x' * 64 for i in range(256)) frames.extend(b'x' * 64 for i in range(256))
frames.extend(b'y' * 64 for i in range(256)) frames.extend(b'y' * 64 for i in range(256))
result = cctx.multi_compress_to_buffer(frames, threads=-1) result = cctx.multi_compress_to_buffer(frames, threads=-1)
self.assertEqual(len(result), 512) self.assertEqual(len(result), 512)
for i in range(512): for i in range(512):
if i < 256: if i < 256:
self.assertEqual(result[i].tobytes(), reference[0]) self.assertEqual(result[i].tobytes(), reference[0])
else: else:
self.assertEqual(result[i].tobytes(), reference[1]) self.assertEqual(result[i].tobytes(), reference[1])

contrib/python-zstandard/tests/test_compressor_fuzzing.py

import io import io
import os import os
import unittest import unittest
try: try:
import hypothesis import hypothesis
import hypothesis.strategies as strategies import hypothesis.strategies as strategies
except ImportError: except ImportError:
raise unittest.SkipTest('hypothesis not available') raise unittest.SkipTest('hypothesis not available')
import zstandard as zstd import zstandard as zstd
from . common import ( from . common import (
make_cffi, make_cffi,
NonClosingBytesIO,
random_input_data, random_input_data,
) )
@unittest.skipUnless('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set') @unittest.skipUnless('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
@make_cffi @make_cffi
class TestCompressor_stream_reader_fuzzing(unittest.TestCase): class TestCompressor_stream_reader_fuzzing(unittest.TestCase):
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384),
read_size=strategies.integers(-1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE))
def test_stream_source_read(self, original, level, source_read_size,
read_size):
if read_size == 0:
read_size = -1
refctx = zstd.ZstdCompressor(level=level)
ref_frame = refctx.compress(original)
cctx = zstd.ZstdCompressor(level=level)
with cctx.stream_reader(io.BytesIO(original), size=len(original),
read_size=source_read_size) as reader:
chunks = []
while True:
chunk = reader.read(read_size)
if not chunk:
break
chunks.append(chunk)
self.assertEqual(b''.join(chunks), ref_frame)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384),
read_size=strategies.integers(-1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE))
def test_buffer_source_read(self, original, level, source_read_size,
read_size):
if read_size == 0:
read_size = -1
refctx = zstd.ZstdCompressor(level=level)
ref_frame = refctx.compress(original)
cctx = zstd.ZstdCompressor(level=level)
with cctx.stream_reader(original, size=len(original),
read_size=source_read_size) as reader:
chunks = []
while True:
chunk = reader.read(read_size)
if not chunk:
break
chunks.append(chunk)
self.assertEqual(b''.join(chunks), ref_frame)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()), @hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5), level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384), source_read_size=strategies.integers(1, 16384),
read_sizes=strategies.data()) read_sizes=strategies.data())
def test_stream_source_read_variance(self, original, level, source_read_size, def test_stream_source_read_variance(self, original, level, source_read_size,
read_sizes): read_sizes):
refctx = zstd.ZstdCompressor(level=level) refctx = zstd.ZstdCompressor(level=level)
ref_frame = refctx.compress(original) ref_frame = refctx.compress(original)
cctx = zstd.ZstdCompressor(level=level) cctx = zstd.ZstdCompressor(level=level)
with cctx.stream_reader(io.BytesIO(original), size=len(original), with cctx.stream_reader(io.BytesIO(original), size=len(original),
read_size=source_read_size) as reader: read_size=source_read_size) as reader:
chunks = [] chunks = []
while True: while True:
read_size = read_sizes.draw(strategies.integers(1, 16384)) read_size = read_sizes.draw(strategies.integers(-1, 16384))
chunk = reader.read(read_size) chunk = reader.read(read_size)
if not chunk and read_size:
if not chunk:
break break
chunks.append(chunk) chunks.append(chunk)
self.assertEqual(b''.join(chunks), ref_frame) self.assertEqual(b''.join(chunks), ref_frame)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()), @hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5), level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384), source_read_size=strategies.integers(1, 16384),
read_sizes=strategies.data()) read_sizes=strategies.data())
def test_buffer_source_read_variance(self, original, level, source_read_size, def test_buffer_source_read_variance(self, original, level, source_read_size,
read_sizes): read_sizes):
refctx = zstd.ZstdCompressor(level=level) refctx = zstd.ZstdCompressor(level=level)
ref_frame = refctx.compress(original) ref_frame = refctx.compress(original)
cctx = zstd.ZstdCompressor(level=level) cctx = zstd.ZstdCompressor(level=level)
with cctx.stream_reader(original, size=len(original), with cctx.stream_reader(original, size=len(original),
read_size=source_read_size) as reader: read_size=source_read_size) as reader:
chunks = [] chunks = []
while True: while True:
read_size = read_sizes.draw(strategies.integers(1, 16384)) read_size = read_sizes.draw(strategies.integers(-1, 16384))
chunk = reader.read(read_size) chunk = reader.read(read_size)
if not chunk and read_size:
break
chunks.append(chunk)
self.assertEqual(b''.join(chunks), ref_frame)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384),
read_size=strategies.integers(1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE))
def test_stream_source_readinto(self, original, level,
source_read_size, read_size):
refctx = zstd.ZstdCompressor(level=level)
ref_frame = refctx.compress(original)
cctx = zstd.ZstdCompressor(level=level)
with cctx.stream_reader(io.BytesIO(original), size=len(original),
read_size=source_read_size) as reader:
chunks = []
while True:
b = bytearray(read_size)
count = reader.readinto(b)
if not count:
break
chunks.append(bytes(b[0:count]))
self.assertEqual(b''.join(chunks), ref_frame)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384),
read_size=strategies.integers(1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE))
def test_buffer_source_readinto(self, original, level,
source_read_size, read_size):
refctx = zstd.ZstdCompressor(level=level)
ref_frame = refctx.compress(original)
cctx = zstd.ZstdCompressor(level=level)
with cctx.stream_reader(original, size=len(original),
read_size=source_read_size) as reader:
chunks = []
while True:
b = bytearray(read_size)
count = reader.readinto(b)
if not count:
break
chunks.append(bytes(b[0:count]))
self.assertEqual(b''.join(chunks), ref_frame)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384),
read_sizes=strategies.data())
def test_stream_source_readinto_variance(self, original, level,
source_read_size, read_sizes):
refctx = zstd.ZstdCompressor(level=level)
ref_frame = refctx.compress(original)
cctx = zstd.ZstdCompressor(level=level)
with cctx.stream_reader(io.BytesIO(original), size=len(original),
read_size=source_read_size) as reader:
chunks = []
while True:
read_size = read_sizes.draw(strategies.integers(1, 16384))
b = bytearray(read_size)
count = reader.readinto(b)
if not count:
break
chunks.append(bytes(b[0:count]))
self.assertEqual(b''.join(chunks), ref_frame)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384),
read_sizes=strategies.data())
def test_buffer_source_readinto_variance(self, original, level,
source_read_size, read_sizes):
refctx = zstd.ZstdCompressor(level=level)
ref_frame = refctx.compress(original)
cctx = zstd.ZstdCompressor(level=level)
with cctx.stream_reader(original, size=len(original),
read_size=source_read_size) as reader:
chunks = []
while True:
read_size = read_sizes.draw(strategies.integers(1, 16384))
b = bytearray(read_size)
count = reader.readinto(b)
if not count:
break
chunks.append(bytes(b[0:count]))
self.assertEqual(b''.join(chunks), ref_frame)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384),
read_size=strategies.integers(-1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE))
def test_stream_source_read1(self, original, level, source_read_size,
read_size):
if read_size == 0:
read_size = -1
refctx = zstd.ZstdCompressor(level=level)
ref_frame = refctx.compress(original)
cctx = zstd.ZstdCompressor(level=level)
with cctx.stream_reader(io.BytesIO(original), size=len(original),
read_size=source_read_size) as reader:
chunks = []
while True:
chunk = reader.read1(read_size)
if not chunk: if not chunk:
break break
chunks.append(chunk) chunks.append(chunk)
self.assertEqual(b''.join(chunks), ref_frame) self.assertEqual(b''.join(chunks), ref_frame)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384),
read_size=strategies.integers(-1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE))
def test_buffer_source_read1(self, original, level, source_read_size,
read_size):
if read_size == 0:
read_size = -1
refctx = zstd.ZstdCompressor(level=level)
ref_frame = refctx.compress(original)
cctx = zstd.ZstdCompressor(level=level)
with cctx.stream_reader(original, size=len(original),
read_size=source_read_size) as reader:
chunks = []
while True:
chunk = reader.read1(read_size)
if not chunk:
break
chunks.append(chunk)
self.assertEqual(b''.join(chunks), ref_frame)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384),
read_sizes=strategies.data())
def test_stream_source_read1_variance(self, original, level, source_read_size,
read_sizes):
refctx = zstd.ZstdCompressor(level=level)
ref_frame = refctx.compress(original)
cctx = zstd.ZstdCompressor(level=level)
with cctx.stream_reader(io.BytesIO(original), size=len(original),
read_size=source_read_size) as reader:
chunks = []
while True:
read_size = read_sizes.draw(strategies.integers(-1, 16384))
chunk = reader.read1(read_size)
if not chunk and read_size:
break
chunks.append(chunk)
self.assertEqual(b''.join(chunks), ref_frame)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384),
read_sizes=strategies.data())
def test_buffer_source_read1_variance(self, original, level, source_read_size,
read_sizes):
refctx = zstd.ZstdCompressor(level=level)
ref_frame = refctx.compress(original)
cctx = zstd.ZstdCompressor(level=level)
with cctx.stream_reader(original, size=len(original),
read_size=source_read_size) as reader:
chunks = []
while True:
read_size = read_sizes.draw(strategies.integers(-1, 16384))
chunk = reader.read1(read_size)
if not chunk and read_size:
break
chunks.append(chunk)
self.assertEqual(b''.join(chunks), ref_frame)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384),
read_size=strategies.integers(1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE))
def test_stream_source_readinto1(self, original, level, source_read_size,
read_size):
if read_size == 0:
read_size = -1
refctx = zstd.ZstdCompressor(level=level)
ref_frame = refctx.compress(original)
cctx = zstd.ZstdCompressor(level=level)
with cctx.stream_reader(io.BytesIO(original), size=len(original),
read_size=source_read_size) as reader:
chunks = []
while True:
b = bytearray(read_size)
count = reader.readinto1(b)
if not count:
break
chunks.append(bytes(b[0:count]))
self.assertEqual(b''.join(chunks), ref_frame)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384),
read_size=strategies.integers(1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE))
def test_buffer_source_readinto1(self, original, level, source_read_size,
read_size):
if read_size == 0:
read_size = -1
refctx = zstd.ZstdCompressor(level=level)
ref_frame = refctx.compress(original)
cctx = zstd.ZstdCompressor(level=level)
with cctx.stream_reader(original, size=len(original),
read_size=source_read_size) as reader:
chunks = []
while True:
b = bytearray(read_size)
count = reader.readinto1(b)
if not count:
break
chunks.append(bytes(b[0:count]))
self.assertEqual(b''.join(chunks), ref_frame)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384),
read_sizes=strategies.data())
def test_stream_source_readinto1_variance(self, original, level, source_read_size,
read_sizes):
refctx = zstd.ZstdCompressor(level=level)
ref_frame = refctx.compress(original)
cctx = zstd.ZstdCompressor(level=level)
with cctx.stream_reader(io.BytesIO(original), size=len(original),
read_size=source_read_size) as reader:
chunks = []
while True:
read_size = read_sizes.draw(strategies.integers(1, 16384))
b = bytearray(read_size)
count = reader.readinto1(b)
if not count:
break
chunks.append(bytes(b[0:count]))
self.assertEqual(b''.join(chunks), ref_frame)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384),
read_sizes=strategies.data())
def test_buffer_source_readinto1_variance(self, original, level, source_read_size,
read_sizes):
refctx = zstd.ZstdCompressor(level=level)
ref_frame = refctx.compress(original)
cctx = zstd.ZstdCompressor(level=level)
with cctx.stream_reader(original, size=len(original),
read_size=source_read_size) as reader:
chunks = []
while True:
read_size = read_sizes.draw(strategies.integers(1, 16384))
b = bytearray(read_size)
count = reader.readinto1(b)
if not count:
break
chunks.append(bytes(b[0:count]))
self.assertEqual(b''.join(chunks), ref_frame)
@unittest.skipUnless('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set') @unittest.skipUnless('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
@make_cffi @make_cffi
class TestCompressor_stream_writer_fuzzing(unittest.TestCase): class TestCompressor_stream_writer_fuzzing(unittest.TestCase):
@hypothesis.given(original=strategies.sampled_from(random_input_data()), @hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5), level=strategies.integers(min_value=1, max_value=5),
write_size=strategies.integers(min_value=1, max_value=1048576)) write_size=strategies.integers(min_value=1, max_value=1048576))
def test_write_size_variance(self, original, level, write_size): def test_write_size_variance(self, original, level, write_size):
refctx = zstd.ZstdCompressor(level=level) refctx = zstd.ZstdCompressor(level=level)
ref_frame = refctx.compress(original) ref_frame = refctx.compress(original)
cctx = zstd.ZstdCompressor(level=level) cctx = zstd.ZstdCompressor(level=level)
b = io.BytesIO() b = NonClosingBytesIO()
with cctx.stream_writer(b, size=len(original), write_size=write_size) as compressor: with cctx.stream_writer(b, size=len(original), write_size=write_size) as compressor:
compressor.write(original) compressor.write(original)
self.assertEqual(b.getvalue(), ref_frame) self.assertEqual(b.getvalue(), ref_frame)
@unittest.skipUnless('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set') @unittest.skipUnless('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
@make_cffi @make_cffi
# Use a content dictionary because it is cheap to create. # Use a content dictionary because it is cheap to create.
if use_dict: if use_dict:
kwargs['dict_data'] = zstd.ZstdCompressionDict(original[0]) kwargs['dict_data'] = zstd.ZstdCompressionDict(original[0])
cctx = zstd.ZstdCompressor(level=1, cctx = zstd.ZstdCompressor(level=1,
write_checksum=True, write_checksum=True,
**kwargs) **kwargs)
if not hasattr(cctx, 'multi_compress_to_buffer'):
self.skipTest('multi_compress_to_buffer not available')
result = cctx.multi_compress_to_buffer(original, threads=-1) result = cctx.multi_compress_to_buffer(original, threads=-1)
self.assertEqual(len(result), len(original)) self.assertEqual(len(result), len(original))
# The frame produced via the batch APIs may not be bit identical to that # The frame produced via the batch APIs may not be bit identical to that
# produced by compress() because compression parameters are adjusted # produced by compress() because compression parameters are adjusted
# from the first input in batch mode. So the only thing we can do is # from the first input in batch mode. So the only thing we can do is
# verify the decompressed data matches the input. # verify the decompressed data matches the input.
chunks = list(chunker.finish()) chunks = list(chunker.finish())
compressed_chunks.extend(chunks) compressed_chunks.extend(chunks)
decompressed_chunks.append(dobj.decompress(b''.join(chunks))) decompressed_chunks.append(dobj.decompress(b''.join(chunks)))
self.assertEqual(dctx.decompress(b''.join(compressed_chunks), self.assertEqual(dctx.decompress(b''.join(compressed_chunks),
max_output_size=len(original)), max_output_size=len(original)),
original) original)
self.assertEqual(b''.join(decompressed_chunks), original) self.assertEqual(b''.join(decompressed_chunks), original)
No newline at end of file No newline at end of file

contrib/python-zstandard/tests/test_data_structures.py

@make_cffi @make_cffi
class TestCompressionParameters(unittest.TestCase): class TestCompressionParameters(unittest.TestCase):
def test_bounds(self): def test_bounds(self):
zstd.ZstdCompressionParameters(window_log=zstd.WINDOWLOG_MIN, zstd.ZstdCompressionParameters(window_log=zstd.WINDOWLOG_MIN,
chain_log=zstd.CHAINLOG_MIN, chain_log=zstd.CHAINLOG_MIN,
hash_log=zstd.HASHLOG_MIN, hash_log=zstd.HASHLOG_MIN,
search_log=zstd.SEARCHLOG_MIN, search_log=zstd.SEARCHLOG_MIN,
min_match=zstd.SEARCHLENGTH_MIN + 1, min_match=zstd.MINMATCH_MIN + 1,
target_length=zstd.TARGETLENGTH_MIN, target_length=zstd.TARGETLENGTH_MIN,
compression_strategy=zstd.STRATEGY_FAST) strategy=zstd.STRATEGY_FAST)
zstd.ZstdCompressionParameters(window_log=zstd.WINDOWLOG_MAX, zstd.ZstdCompressionParameters(window_log=zstd.WINDOWLOG_MAX,
chain_log=zstd.CHAINLOG_MAX, chain_log=zstd.CHAINLOG_MAX,
hash_log=zstd.HASHLOG_MAX, hash_log=zstd.HASHLOG_MAX,
search_log=zstd.SEARCHLOG_MAX, search_log=zstd.SEARCHLOG_MAX,
min_match=zstd.SEARCHLENGTH_MAX - 1, min_match=zstd.MINMATCH_MAX - 1,
target_length=zstd.TARGETLENGTH_MAX, target_length=zstd.TARGETLENGTH_MAX,
compression_strategy=zstd.STRATEGY_BTULTRA) strategy=zstd.STRATEGY_BTULTRA2)
def test_from_level(self): def test_from_level(self):
p = zstd.ZstdCompressionParameters.from_level(1) p = zstd.ZstdCompressionParameters.from_level(1)
self.assertIsInstance(p, zstd.CompressionParameters) self.assertIsInstance(p, zstd.CompressionParameters)
self.assertEqual(p.window_log, 19) self.assertEqual(p.window_log, 19)
p = zstd.ZstdCompressionParameters.from_level(-4) p = zstd.ZstdCompressionParameters.from_level(-4)
self.assertEqual(p.window_log, 19) self.assertEqual(p.window_log, 19)
def test_members(self): def test_members(self):
p = zstd.ZstdCompressionParameters(window_log=10, p = zstd.ZstdCompressionParameters(window_log=10,
chain_log=6, chain_log=6,
hash_log=7, hash_log=7,
search_log=4, search_log=4,
min_match=5, min_match=5,
target_length=8, target_length=8,
compression_strategy=1) strategy=1)
self.assertEqual(p.window_log, 10) self.assertEqual(p.window_log, 10)
self.assertEqual(p.chain_log, 6) self.assertEqual(p.chain_log, 6)
self.assertEqual(p.hash_log, 7) self.assertEqual(p.hash_log, 7)
self.assertEqual(p.search_log, 4) self.assertEqual(p.search_log, 4)
self.assertEqual(p.min_match, 5) self.assertEqual(p.min_match, 5)
self.assertEqual(p.target_length, 8) self.assertEqual(p.target_length, 8)
self.assertEqual(p.compression_strategy, 1) self.assertEqual(p.compression_strategy, 1)
p = zstd.ZstdCompressionParameters(compression_level=2) p = zstd.ZstdCompressionParameters(compression_level=2)
self.assertEqual(p.compression_level, 2) self.assertEqual(p.compression_level, 2)
p = zstd.ZstdCompressionParameters(threads=4) p = zstd.ZstdCompressionParameters(threads=4)
self.assertEqual(p.threads, 4) self.assertEqual(p.threads, 4)
p = zstd.ZstdCompressionParameters(threads=2, job_size=1048576, p = zstd.ZstdCompressionParameters(threads=2, job_size=1048576,
overlap_size_log=6) overlap_log=6)
self.assertEqual(p.threads, 2) self.assertEqual(p.threads, 2)
self.assertEqual(p.job_size, 1048576) self.assertEqual(p.job_size, 1048576)
self.assertEqual(p.overlap_log, 6)
self.assertEqual(p.overlap_size_log, 6) self.assertEqual(p.overlap_size_log, 6)
p = zstd.ZstdCompressionParameters(compression_level=-1) p = zstd.ZstdCompressionParameters(compression_level=-1)
self.assertEqual(p.compression_level, -1) self.assertEqual(p.compression_level, -1)
p = zstd.ZstdCompressionParameters(compression_level=-2) p = zstd.ZstdCompressionParameters(compression_level=-2)
self.assertEqual(p.compression_level, -2) self.assertEqual(p.compression_level, -2)
p = zstd.ZstdCompressionParameters(force_max_window=True) p = zstd.ZstdCompressionParameters(force_max_window=True)
self.assertEqual(p.force_max_window, 1) self.assertEqual(p.force_max_window, 1)
p = zstd.ZstdCompressionParameters(enable_ldm=True) p = zstd.ZstdCompressionParameters(enable_ldm=True)
self.assertEqual(p.enable_ldm, 1) self.assertEqual(p.enable_ldm, 1)
p = zstd.ZstdCompressionParameters(ldm_hash_log=7) p = zstd.ZstdCompressionParameters(ldm_hash_log=7)
self.assertEqual(p.ldm_hash_log, 7) self.assertEqual(p.ldm_hash_log, 7)
p = zstd.ZstdCompressionParameters(ldm_min_match=6) p = zstd.ZstdCompressionParameters(ldm_min_match=6)
self.assertEqual(p.ldm_min_match, 6) self.assertEqual(p.ldm_min_match, 6)
p = zstd.ZstdCompressionParameters(ldm_bucket_size_log=7) p = zstd.ZstdCompressionParameters(ldm_bucket_size_log=7)
self.assertEqual(p.ldm_bucket_size_log, 7) self.assertEqual(p.ldm_bucket_size_log, 7)
p = zstd.ZstdCompressionParameters(ldm_hash_every_log=8) p = zstd.ZstdCompressionParameters(ldm_hash_rate_log=8)
self.assertEqual(p.ldm_hash_every_log, 8) self.assertEqual(p.ldm_hash_every_log, 8)
self.assertEqual(p.ldm_hash_rate_log, 8)
def test_estimated_compression_context_size(self): def test_estimated_compression_context_size(self):
p = zstd.ZstdCompressionParameters(window_log=20, p = zstd.ZstdCompressionParameters(window_log=20,
chain_log=16, chain_log=16,
hash_log=17, hash_log=17,
search_log=1, search_log=1,
min_match=5, min_match=5,
target_length=16, target_length=16,
compression_strategy=zstd.STRATEGY_DFAST) strategy=zstd.STRATEGY_DFAST)
# 32-bit has slightly different values from 64-bit. # 32-bit has slightly different values from 64-bit.
self.assertAlmostEqual(p.estimated_compression_context_size(), 1294072, self.assertAlmostEqual(p.estimated_compression_context_size(), 1294072,
delta=250) delta=250)
def test_strategy(self):
with self.assertRaisesRegexp(ValueError, 'cannot specify both compression_strategy'):
zstd.ZstdCompressionParameters(strategy=0, compression_strategy=0)
p = zstd.ZstdCompressionParameters(strategy=2)
self.assertEqual(p.compression_strategy, 2)
p = zstd.ZstdCompressionParameters(strategy=3)
self.assertEqual(p.compression_strategy, 3)
def test_ldm_hash_rate_log(self):
with self.assertRaisesRegexp(ValueError, 'cannot specify both ldm_hash_rate_log'):
zstd.ZstdCompressionParameters(ldm_hash_rate_log=8, ldm_hash_every_log=4)
p = zstd.ZstdCompressionParameters(ldm_hash_rate_log=8)
self.assertEqual(p.ldm_hash_every_log, 8)
p = zstd.ZstdCompressionParameters(ldm_hash_every_log=16)
self.assertEqual(p.ldm_hash_every_log, 16)
def test_overlap_log(self):
with self.assertRaisesRegexp(ValueError, 'cannot specify both overlap_log'):
zstd.ZstdCompressionParameters(overlap_log=1, overlap_size_log=9)
p = zstd.ZstdCompressionParameters(overlap_log=2)
self.assertEqual(p.overlap_log, 2)
self.assertEqual(p.overlap_size_log, 2)
p = zstd.ZstdCompressionParameters(overlap_size_log=4)
self.assertEqual(p.overlap_log, 4)
self.assertEqual(p.overlap_size_log, 4)
@make_cffi @make_cffi
class TestFrameParameters(unittest.TestCase): class TestFrameParameters(unittest.TestCase):
def test_invalid_type(self): def test_invalid_type(self):
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
zstd.get_frame_parameters(None) zstd.get_frame_parameters(None)
# Python 3 doesn't appear to convert unicode to Py_buffer. # Python 3 doesn't appear to convert unicode to Py_buffer.

contrib/python-zstandard/tests/test_data_structures_fuzzing.py

s_windowlog = strategies.integers(min_value=zstd.WINDOWLOG_MIN, s_windowlog = strategies.integers(min_value=zstd.WINDOWLOG_MIN,
max_value=zstd.WINDOWLOG_MAX) max_value=zstd.WINDOWLOG_MAX)
s_chainlog = strategies.integers(min_value=zstd.CHAINLOG_MIN, s_chainlog = strategies.integers(min_value=zstd.CHAINLOG_MIN,
max_value=zstd.CHAINLOG_MAX) max_value=zstd.CHAINLOG_MAX)
s_hashlog = strategies.integers(min_value=zstd.HASHLOG_MIN, s_hashlog = strategies.integers(min_value=zstd.HASHLOG_MIN,
max_value=zstd.HASHLOG_MAX) max_value=zstd.HASHLOG_MAX)
s_searchlog = strategies.integers(min_value=zstd.SEARCHLOG_MIN, s_searchlog = strategies.integers(min_value=zstd.SEARCHLOG_MIN,
max_value=zstd.SEARCHLOG_MAX) max_value=zstd.SEARCHLOG_MAX)
s_searchlength = strategies.integers(min_value=zstd.SEARCHLENGTH_MIN, s_minmatch = strategies.integers(min_value=zstd.MINMATCH_MIN,
max_value=zstd.SEARCHLENGTH_MAX) max_value=zstd.MINMATCH_MAX)
s_targetlength = strategies.integers(min_value=zstd.TARGETLENGTH_MIN, s_targetlength = strategies.integers(min_value=zstd.TARGETLENGTH_MIN,
max_value=zstd.TARGETLENGTH_MAX) max_value=zstd.TARGETLENGTH_MAX)
s_strategy = strategies.sampled_from((zstd.STRATEGY_FAST, s_strategy = strategies.sampled_from((zstd.STRATEGY_FAST,
zstd.STRATEGY_DFAST, zstd.STRATEGY_DFAST,
zstd.STRATEGY_GREEDY, zstd.STRATEGY_GREEDY,
zstd.STRATEGY_LAZY, zstd.STRATEGY_LAZY,
zstd.STRATEGY_LAZY2, zstd.STRATEGY_LAZY2,
zstd.STRATEGY_BTLAZY2, zstd.STRATEGY_BTLAZY2,
zstd.STRATEGY_BTOPT, zstd.STRATEGY_BTOPT,
zstd.STRATEGY_BTULTRA)) zstd.STRATEGY_BTULTRA,
zstd.STRATEGY_BTULTRA2))
@make_cffi @make_cffi
@unittest.skipUnless('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set') @unittest.skipUnless('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
class TestCompressionParametersHypothesis(unittest.TestCase): class TestCompressionParametersHypothesis(unittest.TestCase):
@hypothesis.given(s_windowlog, s_chainlog, s_hashlog, s_searchlog, @hypothesis.given(s_windowlog, s_chainlog, s_hashlog, s_searchlog,
s_searchlength, s_targetlength, s_strategy) s_minmatch, s_targetlength, s_strategy)
def test_valid_init(self, windowlog, chainlog, hashlog, searchlog, def test_valid_init(self, windowlog, chainlog, hashlog, searchlog,
searchlength, targetlength, strategy): minmatch, targetlength, strategy):
zstd.ZstdCompressionParameters(window_log=windowlog, zstd.ZstdCompressionParameters(window_log=windowlog,
chain_log=chainlog, chain_log=chainlog,
hash_log=hashlog, hash_log=hashlog,
search_log=searchlog, search_log=searchlog,
min_match=searchlength, min_match=minmatch,
target_length=targetlength, target_length=targetlength,
compression_strategy=strategy) strategy=strategy)
@hypothesis.given(s_windowlog, s_chainlog, s_hashlog, s_searchlog, @hypothesis.given(s_windowlog, s_chainlog, s_hashlog, s_searchlog,
s_searchlength, s_targetlength, s_strategy) s_minmatch, s_targetlength, s_strategy)
def test_estimated_compression_context_size(self, windowlog, chainlog, def test_estimated_compression_context_size(self, windowlog, chainlog,
hashlog, searchlog, hashlog, searchlog,
searchlength, targetlength, minmatch, targetlength,
strategy): strategy):
if searchlength == zstd.SEARCHLENGTH_MIN and strategy in (zstd.STRATEGY_FAST, zstd.STRATEGY_GREEDY): if minmatch == zstd.MINMATCH_MIN and strategy in (zstd.STRATEGY_FAST, zstd.STRATEGY_GREEDY):
searchlength += 1 minmatch += 1
elif searchlength == zstd.SEARCHLENGTH_MAX and strategy != zstd.STRATEGY_FAST: elif minmatch == zstd.MINMATCH_MAX and strategy != zstd.STRATEGY_FAST:
searchlength -= 1 minmatch -= 1
p = zstd.ZstdCompressionParameters(window_log=windowlog, p = zstd.ZstdCompressionParameters(window_log=windowlog,
chain_log=chainlog, chain_log=chainlog,
hash_log=hashlog, hash_log=hashlog,
search_log=searchlog, search_log=searchlog,
min_match=searchlength, min_match=minmatch,
target_length=targetlength, target_length=targetlength,
compression_strategy=strategy) strategy=strategy)
size = p.estimated_compression_context_size() size = p.estimated_compression_context_size()

contrib/python-zstandard/tests/test_decompressor.py

import io import io
import os import os
import random import random
import struct import struct
import sys import sys
import tempfile
import unittest import unittest
import zstandard as zstd import zstandard as zstd
from .common import ( from .common import (
generate_samples, generate_samples,
make_cffi, make_cffi,
NonClosingBytesIO,
OpCountingBytesIO, OpCountingBytesIO,
) )
if sys.version_info[0] >= 3: if sys.version_info[0] >= 3:
next = lambda it: it.__next__() next = lambda it: it.__next__()
else: else:
next = lambda it: it.next() next = lambda it: it.next()
with open(__file__, 'rb') as fh: with open(__file__, 'rb') as fh:
source = fh.read() source = fh.read()
# If we write a content size, the decompressor engages single pass # If we write a content size, the decompressor engages single pass
# mode and the window size doesn't come into play. # mode and the window size doesn't come into play.
cctx = zstd.ZstdCompressor(write_content_size=False) cctx = zstd.ZstdCompressor(write_content_size=False)
frame = cctx.compress(source) frame = cctx.compress(source)
dctx = zstd.ZstdDecompressor(max_window_size=1) dctx = zstd.ZstdDecompressor(max_window_size=2**zstd.WINDOWLOG_MIN)
with self.assertRaisesRegexp( with self.assertRaisesRegexp(
zstd.ZstdError, 'decompression error: Frame requires too much memory'): zstd.ZstdError, 'decompression error: Frame requires too much memory'):
dctx.decompress(frame, max_output_size=len(source)) dctx.decompress(frame, max_output_size=len(source))
@make_cffi @make_cffi
class TestDecompressor_copy_stream(unittest.TestCase): class TestDecompressor_copy_stream(unittest.TestCase):
with self.assertRaisesRegexp(ValueError, 'cannot __enter__ multiple times'): with self.assertRaisesRegexp(ValueError, 'cannot __enter__ multiple times'):
with reader as reader2: with reader as reader2:
pass pass
def test_not_implemented(self): def test_not_implemented(self):
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
with dctx.stream_reader(b'foo') as reader: with dctx.stream_reader(b'foo') as reader:
with self.assertRaises(NotImplementedError): with self.assertRaises(io.UnsupportedOperation):
reader.readline() reader.readline()
with self.assertRaises(NotImplementedError): with self.assertRaises(io.UnsupportedOperation):
reader.readlines() reader.readlines()
with self.assertRaises(NotImplementedError): with self.assertRaises(io.UnsupportedOperation):
reader.readall()
with self.assertRaises(NotImplementedError):
iter(reader) iter(reader)
with self.assertRaises(NotImplementedError): with self.assertRaises(io.UnsupportedOperation):
next(reader) next(reader)
with self.assertRaises(io.UnsupportedOperation): with self.assertRaises(io.UnsupportedOperation):
reader.write(b'foo') reader.write(b'foo')
with self.assertRaises(io.UnsupportedOperation): with self.assertRaises(io.UnsupportedOperation):
reader.writelines([]) reader.writelines([])
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
with dctx.stream_reader(b'foo') as reader: with dctx.stream_reader(b'foo') as reader:
reader.close() reader.close()
self.assertTrue(reader.closed) self.assertTrue(reader.closed)
with self.assertRaisesRegexp(ValueError, 'stream is closed'): with self.assertRaisesRegexp(ValueError, 'stream is closed'):
reader.read(1) reader.read(1)
def test_bad_read_size(self): def test_read_sizes(self):
cctx = zstd.ZstdCompressor()
foo = cctx.compress(b'foo')
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
with dctx.stream_reader(b'foo') as reader: with dctx.stream_reader(foo) as reader:
with self.assertRaisesRegexp(ValueError, 'cannot read negative or size 0 amounts'): with self.assertRaisesRegexp(ValueError, 'cannot read negative amounts less than -1'):
reader.read(-1) reader.read(-2)
with self.assertRaisesRegexp(ValueError, 'cannot read negative or size 0 amounts'): self.assertEqual(reader.read(0), b'')
reader.read(0) self.assertEqual(reader.read(), b'foo')
def test_read_buffer(self): def test_read_buffer(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
source = b''.join([b'foo' * 60, b'bar' * 60, b'baz' * 60]) source = b''.join([b'foo' * 60, b'bar' * 60, b'baz' * 60])
frame = cctx.compress(source) frame = cctx.compress(source)
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
def test_read_after_error(self): def test_read_after_error(self):
source = io.BytesIO(b'') source = io.BytesIO(b'')
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
reader = dctx.stream_reader(source) reader = dctx.stream_reader(source)
with reader: with reader:
with self.assertRaises(TypeError): reader.read(0)
reader.read()
with reader: with reader:
with self.assertRaisesRegexp(ValueError, 'stream is closed'): with self.assertRaisesRegexp(ValueError, 'stream is closed'):
reader.read(100) reader.read(100)
def test_partial_read(self):
# Inspired by https://github.com/indygreg/python-zstandard/issues/71.
buffer = io.BytesIO()
cctx = zstd.ZstdCompressor()
writer = cctx.stream_writer(buffer)
writer.write(bytearray(os.urandom(1000000)))
writer.flush(zstd.FLUSH_FRAME)
buffer.seek(0)
dctx = zstd.ZstdDecompressor()
reader = dctx.stream_reader(buffer)
while True:
chunk = reader.read(8192)
if not chunk:
break
def test_read_multiple_frames(self):
cctx = zstd.ZstdCompressor()
source = io.BytesIO()
writer = cctx.stream_writer(source)
writer.write(b'foo')
writer.flush(zstd.FLUSH_FRAME)
writer.write(b'bar')
writer.flush(zstd.FLUSH_FRAME)
dctx = zstd.ZstdDecompressor()
reader = dctx.stream_reader(source.getvalue())
self.assertEqual(reader.read(2), b'fo')
self.assertEqual(reader.read(2), b'o')
self.assertEqual(reader.read(2), b'ba')
self.assertEqual(reader.read(2), b'r')
source.seek(0)
reader = dctx.stream_reader(source)
self.assertEqual(reader.read(2), b'fo')
self.assertEqual(reader.read(2), b'o')
self.assertEqual(reader.read(2), b'ba')
self.assertEqual(reader.read(2), b'r')
reader = dctx.stream_reader(source.getvalue())
self.assertEqual(reader.read(3), b'foo')
self.assertEqual(reader.read(3), b'bar')
source.seek(0)
reader = dctx.stream_reader(source)
self.assertEqual(reader.read(3), b'foo')
self.assertEqual(reader.read(3), b'bar')
reader = dctx.stream_reader(source.getvalue())
self.assertEqual(reader.read(4), b'foo')
self.assertEqual(reader.read(4), b'bar')
source.seek(0)
reader = dctx.stream_reader(source)
self.assertEqual(reader.read(4), b'foo')
self.assertEqual(reader.read(4), b'bar')
reader = dctx.stream_reader(source.getvalue())
self.assertEqual(reader.read(128), b'foo')
self.assertEqual(reader.read(128), b'bar')
source.seek(0)
reader = dctx.stream_reader(source)
self.assertEqual(reader.read(128), b'foo')
self.assertEqual(reader.read(128), b'bar')
# Now tests for reads spanning frames.
reader = dctx.stream_reader(source.getvalue(), read_across_frames=True)
self.assertEqual(reader.read(3), b'foo')
self.assertEqual(reader.read(3), b'bar')
source.seek(0)
reader = dctx.stream_reader(source, read_across_frames=True)
self.assertEqual(reader.read(3), b'foo')
self.assertEqual(reader.read(3), b'bar')
reader = dctx.stream_reader(source.getvalue(), read_across_frames=True)
self.assertEqual(reader.read(6), b'foobar')
source.seek(0)
reader = dctx.stream_reader(source, read_across_frames=True)
self.assertEqual(reader.read(6), b'foobar')
reader = dctx.stream_reader(source.getvalue(), read_across_frames=True)
self.assertEqual(reader.read(7), b'foobar')
source.seek(0)
reader = dctx.stream_reader(source, read_across_frames=True)
self.assertEqual(reader.read(7), b'foobar')
reader = dctx.stream_reader(source.getvalue(), read_across_frames=True)
self.assertEqual(reader.read(128), b'foobar')
source.seek(0)
reader = dctx.stream_reader(source, read_across_frames=True)
self.assertEqual(reader.read(128), b'foobar')
def test_readinto(self):
cctx = zstd.ZstdCompressor()
foo = cctx.compress(b'foo')
dctx = zstd.ZstdDecompressor()
# Attempting to readinto() a non-writable buffer fails.
# The exact exception varies based on the backend.
reader = dctx.stream_reader(foo)
with self.assertRaises(Exception):
reader.readinto(b'foobar')
# readinto() with sufficiently large destination.
b = bytearray(1024)
reader = dctx.stream_reader(foo)
self.assertEqual(reader.readinto(b), 3)
self.assertEqual(b[0:3], b'foo')
self.assertEqual(reader.readinto(b), 0)
self.assertEqual(b[0:3], b'foo')
# readinto() with small reads.
b = bytearray(1024)
reader = dctx.stream_reader(foo, read_size=1)
self.assertEqual(reader.readinto(b), 3)
self.assertEqual(b[0:3], b'foo')
# Too small destination buffer.
b = bytearray(2)
reader = dctx.stream_reader(foo)
self.assertEqual(reader.readinto(b), 2)
self.assertEqual(b[:], b'fo')
def test_readinto1(self):
cctx = zstd.ZstdCompressor()
foo = cctx.compress(b'foo')
dctx = zstd.ZstdDecompressor()
reader = dctx.stream_reader(foo)
with self.assertRaises(Exception):
reader.readinto1(b'foobar')
# Sufficiently large destination.
b = bytearray(1024)
reader = dctx.stream_reader(foo)
self.assertEqual(reader.readinto1(b), 3)
self.assertEqual(b[0:3], b'foo')
self.assertEqual(reader.readinto1(b), 0)
self.assertEqual(b[0:3], b'foo')
# readinto() with small reads.
b = bytearray(1024)
reader = dctx.stream_reader(foo, read_size=1)
self.assertEqual(reader.readinto1(b), 3)
self.assertEqual(b[0:3], b'foo')
# Too small destination buffer.
b = bytearray(2)
reader = dctx.stream_reader(foo)
self.assertEqual(reader.readinto1(b), 2)
self.assertEqual(b[:], b'fo')
def test_readall(self):
cctx = zstd.ZstdCompressor()
foo = cctx.compress(b'foo')
dctx = zstd.ZstdDecompressor()
reader = dctx.stream_reader(foo)
self.assertEqual(reader.readall(), b'foo')
def test_read1(self):
cctx = zstd.ZstdCompressor()
foo = cctx.compress(b'foo')
dctx = zstd.ZstdDecompressor()
b = OpCountingBytesIO(foo)
reader = dctx.stream_reader(b)
self.assertEqual(reader.read1(), b'foo')
self.assertEqual(b._read_count, 1)
b = OpCountingBytesIO(foo)
reader = dctx.stream_reader(b)
self.assertEqual(reader.read1(0), b'')
self.assertEqual(reader.read1(2), b'fo')
self.assertEqual(b._read_count, 1)
self.assertEqual(reader.read1(1), b'o')
self.assertEqual(b._read_count, 1)
self.assertEqual(reader.read1(1), b'')
self.assertEqual(b._read_count, 2)
def test_read_lines(self):
cctx = zstd.ZstdCompressor()
source = b'\n'.join(('line %d' % i).encode('ascii') for i in range(1024))
frame = cctx.compress(source)
dctx = zstd.ZstdDecompressor()
reader = dctx.stream_reader(frame)
tr = io.TextIOWrapper(reader, encoding='utf-8')
lines = []
for line in tr:
lines.append(line.encode('utf-8'))
self.assertEqual(len(lines), 1024)
self.assertEqual(b''.join(lines), source)
reader = dctx.stream_reader(frame)
tr = io.TextIOWrapper(reader, encoding='utf-8')
lines = tr.readlines()
self.assertEqual(len(lines), 1024)
self.assertEqual(''.join(lines).encode('utf-8'), source)
reader = dctx.stream_reader(frame)
tr = io.TextIOWrapper(reader, encoding='utf-8')
lines = []
while True:
line = tr.readline()
if not line:
break
lines.append(line.encode('utf-8'))
self.assertEqual(len(lines), 1024)
self.assertEqual(b''.join(lines), source)
@make_cffi @make_cffi
class TestDecompressor_decompressobj(unittest.TestCase): class TestDecompressor_decompressobj(unittest.TestCase):
def test_simple(self): def test_simple(self):
data = zstd.ZstdCompressor(level=1).compress(b'foobar') data = zstd.ZstdCompressor(level=1).compress(b'foobar')
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
dobj = dctx.decompressobj() dobj = dctx.decompressobj()
self.assertEqual(dobj.decompress(data), b'foobar') self.assertEqual(dobj.decompress(data), b'foobar')
self.assertIsNone(dobj.flush())
self.assertIsNone(dobj.flush(10))
self.assertIsNone(dobj.flush(length=100))
def test_input_types(self): def test_input_types(self):
compressed = zstd.ZstdCompressor(level=1).compress(b'foo') compressed = zstd.ZstdCompressor(level=1).compress(b'foo')
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
mutable_array = bytearray(len(compressed)) mutable_array = bytearray(len(compressed))
mutable_array[:] = compressed mutable_array[:] = compressed
sources = [ sources = [
memoryview(compressed), memoryview(compressed),
bytearray(compressed), bytearray(compressed),
mutable_array, mutable_array,
] ]
for source in sources: for source in sources:
dobj = dctx.decompressobj() dobj = dctx.decompressobj()
self.assertIsNone(dobj.flush())
self.assertIsNone(dobj.flush(10))
self.assertIsNone(dobj.flush(length=100))
self.assertEqual(dobj.decompress(source), b'foo') self.assertEqual(dobj.decompress(source), b'foo')
self.assertIsNone(dobj.flush())
def test_reuse(self): def test_reuse(self):
data = zstd.ZstdCompressor(level=1).compress(b'foobar') data = zstd.ZstdCompressor(level=1).compress(b'foobar')
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
dobj = dctx.decompressobj() dobj = dctx.decompressobj()
dobj.decompress(data) dobj.decompress(data)
with self.assertRaisesRegexp(zstd.ZstdError, 'cannot use a decompressobj'): with self.assertRaisesRegexp(zstd.ZstdError, 'cannot use a decompressobj'):
dobj.decompress(data) dobj.decompress(data)
self.assertIsNone(dobj.flush())
def test_bad_write_size(self): def test_bad_write_size(self):
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
with self.assertRaisesRegexp(ValueError, 'write_size must be positive'): with self.assertRaisesRegexp(ValueError, 'write_size must be positive'):
dctx.decompressobj(write_size=0) dctx.decompressobj(write_size=0)
def test_write_size(self): def test_write_size(self):
source = b'foo' * 64 + b'bar' * 128 source = b'foo' * 64 + b'bar' * 128
data = zstd.ZstdCompressor(level=1).compress(source) data = zstd.ZstdCompressor(level=1).compress(source)
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
for i in range(128): for i in range(128):
dobj = dctx.decompressobj(write_size=i + 1) dobj = dctx.decompressobj(write_size=i + 1)
self.assertEqual(dobj.decompress(data), source) self.assertEqual(dobj.decompress(data), source)
def decompress_via_writer(data): def decompress_via_writer(data):
buffer = io.BytesIO() buffer = io.BytesIO()
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
with dctx.stream_writer(buffer) as decompressor: decompressor = dctx.stream_writer(buffer)
decompressor.write(data) decompressor.write(data)
return buffer.getvalue() return buffer.getvalue()
@make_cffi @make_cffi
class TestDecompressor_stream_writer(unittest.TestCase): class TestDecompressor_stream_writer(unittest.TestCase):
def test_io_api(self):
buffer = io.BytesIO()
dctx = zstd.ZstdDecompressor()
writer = dctx.stream_writer(buffer)
self.assertFalse(writer.closed)
self.assertFalse(writer.isatty())
self.assertFalse(writer.readable())
with self.assertRaises(io.UnsupportedOperation):
writer.readline()
with self.assertRaises(io.UnsupportedOperation):
writer.readline(42)
with self.assertRaises(io.UnsupportedOperation):
writer.readline(size=42)
with self.assertRaises(io.UnsupportedOperation):
writer.readlines()
with self.assertRaises(io.UnsupportedOperation):
writer.readlines(42)
with self.assertRaises(io.UnsupportedOperation):
writer.readlines(hint=42)
with self.assertRaises(io.UnsupportedOperation):
writer.seek(0)
with self.assertRaises(io.UnsupportedOperation):
writer.seek(10, os.SEEK_SET)
self.assertFalse(writer.seekable())
with self.assertRaises(io.UnsupportedOperation):
writer.tell()
with self.assertRaises(io.UnsupportedOperation):
writer.truncate()
with self.assertRaises(io.UnsupportedOperation):
writer.truncate(42)
with self.assertRaises(io.UnsupportedOperation):
writer.truncate(size=42)
self.assertTrue(writer.writable())
with self.assertRaises(io.UnsupportedOperation):
writer.writelines([])
with self.assertRaises(io.UnsupportedOperation):
writer.read()
with self.assertRaises(io.UnsupportedOperation):
writer.read(42)
with self.assertRaises(io.UnsupportedOperation):
writer.read(size=42)
with self.assertRaises(io.UnsupportedOperation):
writer.readall()
with self.assertRaises(io.UnsupportedOperation):
writer.readinto(None)
with self.assertRaises(io.UnsupportedOperation):
writer.fileno()
def test_fileno_file(self):
with tempfile.TemporaryFile('wb') as tf:
dctx = zstd.ZstdDecompressor()
writer = dctx.stream_writer(tf)
self.assertEqual(writer.fileno(), tf.fileno())
def test_close(self):
foo = zstd.ZstdCompressor().compress(b'foo')
buffer = NonClosingBytesIO()
dctx = zstd.ZstdDecompressor()
writer = dctx.stream_writer(buffer)
writer.write(foo)
self.assertFalse(writer.closed)
self.assertFalse(buffer.closed)
writer.close()
self.assertTrue(writer.closed)
self.assertTrue(buffer.closed)
with self.assertRaisesRegexp(ValueError, 'stream is closed'):
writer.write(b'')
with self.assertRaisesRegexp(ValueError, 'stream is closed'):
writer.flush()
with self.assertRaisesRegexp(ValueError, 'stream is closed'):
with writer:
pass
self.assertEqual(buffer.getvalue(), b'foo')
# Context manager exit should close stream.
buffer = NonClosingBytesIO()
writer = dctx.stream_writer(buffer)
with writer:
writer.write(foo)
self.assertTrue(writer.closed)
self.assertEqual(buffer.getvalue(), b'foo')
def test_flush(self):
buffer = OpCountingBytesIO()
dctx = zstd.ZstdDecompressor()
writer = dctx.stream_writer(buffer)
writer.flush()
self.assertEqual(buffer._flush_count, 1)
writer.flush()
self.assertEqual(buffer._flush_count, 2)
def test_empty_roundtrip(self): def test_empty_roundtrip(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
empty = cctx.compress(b'') empty = cctx.compress(b'')
self.assertEqual(decompress_via_writer(empty), b'') self.assertEqual(decompress_via_writer(empty), b'')
def test_input_types(self): def test_input_types(self):
cctx = zstd.ZstdCompressor(level=1) cctx = zstd.ZstdCompressor(level=1)
compressed = cctx.compress(b'foo') compressed = cctx.compress(b'foo')
mutable_array = bytearray(len(compressed)) mutable_array = bytearray(len(compressed))
mutable_array[:] = compressed mutable_array[:] = compressed
sources = [ sources = [
memoryview(compressed), memoryview(compressed),
bytearray(compressed), bytearray(compressed),
mutable_array, mutable_array,
] ]
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
for source in sources: for source in sources:
buffer = io.BytesIO() buffer = io.BytesIO()
with dctx.stream_writer(buffer) as decompressor:
decompressor = dctx.stream_writer(buffer)
decompressor.write(source) decompressor.write(source)
self.assertEqual(buffer.getvalue(), b'foo')
buffer = NonClosingBytesIO()
with dctx.stream_writer(buffer) as decompressor:
self.assertEqual(decompressor.write(source), 3)
self.assertEqual(buffer.getvalue(), b'foo') self.assertEqual(buffer.getvalue(), b'foo')
buffer = io.BytesIO()
writer = dctx.stream_writer(buffer, write_return_read=True)
self.assertEqual(writer.write(source), len(source))
self.assertEqual(buffer.getvalue(), b'foo')
def test_large_roundtrip(self): def test_large_roundtrip(self):
chunks = [] chunks = []
for i in range(255): for i in range(255):
chunks.append(struct.Struct('>B').pack(i) * 16384) chunks.append(struct.Struct('>B').pack(i) * 16384)
orig = b''.join(chunks) orig = b''.join(chunks)
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
compressed = cctx.compress(orig) compressed = cctx.compress(orig)
self.assertEqual(decompress_via_writer(compressed), orig) self.assertEqual(decompress_via_writer(compressed), orig)
def test_multiple_calls(self): def test_multiple_calls(self):
chunks = [] chunks = []
for i in range(255): for i in range(255):
for j in range(255): for j in range(255):
chunks.append(struct.Struct('>B').pack(j) * i) chunks.append(struct.Struct('>B').pack(j) * i)
orig = b''.join(chunks) orig = b''.join(chunks)
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
compressed = cctx.compress(orig) compressed = cctx.compress(orig)
buffer = io.BytesIO() buffer = NonClosingBytesIO()
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
with dctx.stream_writer(buffer) as decompressor: with dctx.stream_writer(buffer) as decompressor:
pos = 0 pos = 0
while pos < len(compressed): while pos < len(compressed):
pos2 = pos + 8192 pos2 = pos + 8192
decompressor.write(compressed[pos:pos2]) decompressor.write(compressed[pos:pos2])
pos += 8192 pos += 8192
self.assertEqual(buffer.getvalue(), orig) self.assertEqual(buffer.getvalue(), orig)
# Again with write_return_read=True
buffer = io.BytesIO()
writer = dctx.stream_writer(buffer, write_return_read=True)
pos = 0
while pos < len(compressed):
pos2 = pos + 8192
chunk = compressed[pos:pos2]
self.assertEqual(writer.write(chunk), len(chunk))
pos += 8192
self.assertEqual(buffer.getvalue(), orig)
def test_dictionary(self): def test_dictionary(self):
samples = [] samples = []
for i in range(128): for i in range(128):
samples.append(b'foo' * 64) samples.append(b'foo' * 64)
samples.append(b'bar' * 64) samples.append(b'bar' * 64)
samples.append(b'foobar' * 64) samples.append(b'foobar' * 64)
d = zstd.train_dictionary(8192, samples) d = zstd.train_dictionary(8192, samples)
orig = b'foobar' * 16384 orig = b'foobar' * 16384
buffer = io.BytesIO() buffer = NonClosingBytesIO()
cctx = zstd.ZstdCompressor(dict_data=d) cctx = zstd.ZstdCompressor(dict_data=d)
with cctx.stream_writer(buffer) as compressor: with cctx.stream_writer(buffer) as compressor:
self.assertEqual(compressor.write(orig), 0) self.assertEqual(compressor.write(orig), 0)
compressed = buffer.getvalue() compressed = buffer.getvalue()
buffer = io.BytesIO() buffer = io.BytesIO()
dctx = zstd.ZstdDecompressor(dict_data=d) dctx = zstd.ZstdDecompressor(dict_data=d)
decompressor = dctx.stream_writer(buffer)
self.assertEqual(decompressor.write(compressed), len(orig))
self.assertEqual(buffer.getvalue(), orig)
buffer = NonClosingBytesIO()
with dctx.stream_writer(buffer) as decompressor: with dctx.stream_writer(buffer) as decompressor:
self.assertEqual(decompressor.write(compressed), len(orig)) self.assertEqual(decompressor.write(compressed), len(orig))
self.assertEqual(buffer.getvalue(), orig) self.assertEqual(buffer.getvalue(), orig)
def test_memory_size(self): def test_memory_size(self):
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
buffer = io.BytesIO() buffer = io.BytesIO()
decompressor = dctx.stream_writer(buffer)
size = decompressor.memory_size()
self.assertGreater(size, 100000)
with dctx.stream_writer(buffer) as decompressor: with dctx.stream_writer(buffer) as decompressor:
size = decompressor.memory_size() size = decompressor.memory_size()
self.assertGreater(size, 100000) self.assertGreater(size, 100000)
def test_write_size(self): def test_write_size(self):
source = zstd.ZstdCompressor().compress(b'foobarfoobar') source = zstd.ZstdCompressor().compress(b'foobarfoobar')
dest = OpCountingBytesIO() dest = OpCountingBytesIO()
next(it) next(it)
decompressed = b''.join(chunks) decompressed = b''.join(chunks)
self.assertEqual(decompressed, source.getvalue()) self.assertEqual(decompressed, source.getvalue())
@unittest.skipUnless('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set') @unittest.skipUnless('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
def test_large_input(self): def test_large_input(self):
bytes = list(struct.Struct('>B').pack(i) for i in range(256)) bytes = list(struct.Struct('>B').pack(i) for i in range(256))
compressed = io.BytesIO() compressed = NonClosingBytesIO()
input_size = 0 input_size = 0
cctx = zstd.ZstdCompressor(level=1) cctx = zstd.ZstdCompressor(level=1)
with cctx.stream_writer(compressed) as compressor: with cctx.stream_writer(compressed) as compressor:
while True: while True:
compressor.write(random.choice(bytes)) compressor.write(random.choice(bytes))
input_size += 1 input_size += 1
have_compressed = len(compressed.getvalue()) > zstd.DECOMPRESSION_RECOMMENDED_INPUT_SIZE have_compressed = len(compressed.getvalue()) > zstd.DECOMPRESSION_RECOMMENDED_INPUT_SIZE
have_raw = input_size > zstd.DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE * 2 have_raw = input_size > zstd.DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE * 2
if have_compressed and have_raw: if have_compressed and have_raw:
break break
compressed.seek(0) compressed = io.BytesIO(compressed.getvalue())
self.assertGreater(len(compressed.getvalue()), self.assertGreater(len(compressed.getvalue()),
zstd.DECOMPRESSION_RECOMMENDED_INPUT_SIZE) zstd.DECOMPRESSION_RECOMMENDED_INPUT_SIZE)
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
it = dctx.read_to_iter(compressed) it = dctx.read_to_iter(compressed)
chunks = [] chunks = []
chunks.append(next(it)) chunks.append(next(it))
self.assertEqual(len(decompressed), input_size) self.assertEqual(len(decompressed), input_size)
def test_interesting(self): def test_interesting(self):
# Found this edge case via fuzzing. # Found this edge case via fuzzing.
cctx = zstd.ZstdCompressor(level=1) cctx = zstd.ZstdCompressor(level=1)
source = io.BytesIO() source = io.BytesIO()
compressed = io.BytesIO() compressed = NonClosingBytesIO()
with cctx.stream_writer(compressed) as compressor: with cctx.stream_writer(compressed) as compressor:
for i in range(256): for i in range(256):
chunk = b'\0' * 1024 chunk = b'\0' * 1024
compressor.write(chunk) compressor.write(chunk)
source.write(chunk) source.write(chunk)
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
simple = dctx.decompress(compressed.getvalue(), simple = dctx.decompress(compressed.getvalue(),
max_output_size=len(source.getvalue())) max_output_size=len(source.getvalue()))
self.assertEqual(simple, source.getvalue()) self.assertEqual(simple, source.getvalue())
compressed.seek(0) compressed = io.BytesIO(compressed.getvalue())
streamed = b''.join(dctx.read_to_iter(compressed)) streamed = b''.join(dctx.read_to_iter(compressed))
self.assertEqual(streamed, source.getvalue()) self.assertEqual(streamed, source.getvalue())
def test_read_write_size(self): def test_read_write_size(self):
source = OpCountingBytesIO(zstd.ZstdCompressor().compress(b'foobarfoobar')) source = OpCountingBytesIO(zstd.ZstdCompressor().compress(b'foobarfoobar'))
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
for chunk in dctx.read_to_iter(source, read_size=1, write_size=1): for chunk in dctx.read_to_iter(source, read_size=1, write_size=1):
self.assertEqual(len(chunk), 1) self.assertEqual(len(chunk), 1)
self.assertEqual(decompressed, expected) self.assertEqual(decompressed, expected)
# TODO enable for CFFI # TODO enable for CFFI
class TestDecompressor_multi_decompress_to_buffer(unittest.TestCase): class TestDecompressor_multi_decompress_to_buffer(unittest.TestCase):
def test_invalid_inputs(self): def test_invalid_inputs(self):
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
if not hasattr(dctx, 'multi_decompress_to_buffer'):
self.skipTest('multi_decompress_to_buffer not available')
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
dctx.multi_decompress_to_buffer(True) dctx.multi_decompress_to_buffer(True)
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
dctx.multi_decompress_to_buffer((1, 2)) dctx.multi_decompress_to_buffer((1, 2))
with self.assertRaisesRegexp(TypeError, 'item 0 not a bytes like object'): with self.assertRaisesRegexp(TypeError, 'item 0 not a bytes like object'):
dctx.multi_decompress_to_buffer([u'foo']) dctx.multi_decompress_to_buffer([u'foo'])
with self.assertRaisesRegexp(ValueError, 'could not determine decompressed size of item 0'): with self.assertRaisesRegexp(ValueError, 'could not determine decompressed size of item 0'):
dctx.multi_decompress_to_buffer([b'foobarbaz']) dctx.multi_decompress_to_buffer([b'foobarbaz'])
def test_list_input(self): def test_list_input(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
original = [b'foo' * 4, b'bar' * 6] original = [b'foo' * 4, b'bar' * 6]
frames = [cctx.compress(d) for d in original] frames = [cctx.compress(d) for d in original]
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
if not hasattr(dctx, 'multi_decompress_to_buffer'):
self.skipTest('multi_decompress_to_buffer not available')
result = dctx.multi_decompress_to_buffer(frames) result = dctx.multi_decompress_to_buffer(frames)
self.assertEqual(len(result), len(frames)) self.assertEqual(len(result), len(frames))
self.assertEqual(result.size(), sum(map(len, original))) self.assertEqual(result.size(), sum(map(len, original)))
for i, data in enumerate(original): for i, data in enumerate(original):
self.assertEqual(result[i].tobytes(), data) self.assertEqual(result[i].tobytes(), data)
self.assertEqual(result[0].offset, 0) self.assertEqual(result[0].offset, 0)
self.assertEqual(len(result[0]), 12) self.assertEqual(len(result[0]), 12)
self.assertEqual(result[1].offset, 12) self.assertEqual(result[1].offset, 12)
self.assertEqual(len(result[1]), 18) self.assertEqual(len(result[1]), 18)
def test_list_input_frame_sizes(self): def test_list_input_frame_sizes(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
original = [b'foo' * 4, b'bar' * 6, b'baz' * 8] original = [b'foo' * 4, b'bar' * 6, b'baz' * 8]
frames = [cctx.compress(d) for d in original] frames = [cctx.compress(d) for d in original]
sizes = struct.pack('=' + 'Q' * len(original), *map(len, original)) sizes = struct.pack('=' + 'Q' * len(original), *map(len, original))
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
if not hasattr(dctx, 'multi_decompress_to_buffer'):
self.skipTest('multi_decompress_to_buffer not available')
result = dctx.multi_decompress_to_buffer(frames, decompressed_sizes=sizes) result = dctx.multi_decompress_to_buffer(frames, decompressed_sizes=sizes)
self.assertEqual(len(result), len(frames)) self.assertEqual(len(result), len(frames))
self.assertEqual(result.size(), sum(map(len, original))) self.assertEqual(result.size(), sum(map(len, original)))
for i, data in enumerate(original): for i, data in enumerate(original):
self.assertEqual(result[i].tobytes(), data) self.assertEqual(result[i].tobytes(), data)
def test_buffer_with_segments_input(self): def test_buffer_with_segments_input(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
original = [b'foo' * 4, b'bar' * 6] original = [b'foo' * 4, b'bar' * 6]
frames = [cctx.compress(d) for d in original] frames = [cctx.compress(d) for d in original]
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
if not hasattr(dctx, 'multi_decompress_to_buffer'):
self.skipTest('multi_decompress_to_buffer not available')
segments = struct.pack('=QQQQ', 0, len(frames[0]), len(frames[0]), len(frames[1])) segments = struct.pack('=QQQQ', 0, len(frames[0]), len(frames[0]), len(frames[1]))
b = zstd.BufferWithSegments(b''.join(frames), segments) b = zstd.BufferWithSegments(b''.join(frames), segments)
result = dctx.multi_decompress_to_buffer(b) result = dctx.multi_decompress_to_buffer(b)
self.assertEqual(len(result), len(frames)) self.assertEqual(len(result), len(frames))
self.assertEqual(result[0].offset, 0) self.assertEqual(result[0].offset, 0)
self.assertEqual(len(result[0]), 12) self.assertEqual(len(result[0]), 12)
self.assertEqual(result[1].offset, 12) self.assertEqual(result[1].offset, 12)
self.assertEqual(len(result[1]), 18) self.assertEqual(len(result[1]), 18)
def test_buffer_with_segments_sizes(self): def test_buffer_with_segments_sizes(self):
cctx = zstd.ZstdCompressor(write_content_size=False) cctx = zstd.ZstdCompressor(write_content_size=False)
original = [b'foo' * 4, b'bar' * 6, b'baz' * 8] original = [b'foo' * 4, b'bar' * 6, b'baz' * 8]
frames = [cctx.compress(d) for d in original] frames = [cctx.compress(d) for d in original]
sizes = struct.pack('=' + 'Q' * len(original), *map(len, original)) sizes = struct.pack('=' + 'Q' * len(original), *map(len, original))
dctx = zstd.ZstdDecompressor()
if not hasattr(dctx, 'multi_decompress_to_buffer'):
self.skipTest('multi_decompress_to_buffer not available')
segments = struct.pack('=QQQQQQ', 0, len(frames[0]), segments = struct.pack('=QQQQQQ', 0, len(frames[0]),
len(frames[0]), len(frames[1]), len(frames[0]), len(frames[1]),
len(frames[0]) + len(frames[1]), len(frames[2])) len(frames[0]) + len(frames[1]), len(frames[2]))
b = zstd.BufferWithSegments(b''.join(frames), segments) b = zstd.BufferWithSegments(b''.join(frames), segments)
dctx = zstd.ZstdDecompressor()
result = dctx.multi_decompress_to_buffer(b, decompressed_sizes=sizes) result = dctx.multi_decompress_to_buffer(b, decompressed_sizes=sizes)
self.assertEqual(len(result), len(frames)) self.assertEqual(len(result), len(frames))
self.assertEqual(result.size(), sum(map(len, original))) self.assertEqual(result.size(), sum(map(len, original)))
for i, data in enumerate(original): for i, data in enumerate(original):
self.assertEqual(result[i].tobytes(), data) self.assertEqual(result[i].tobytes(), data)
def test_buffer_with_segments_collection_input(self): def test_buffer_with_segments_collection_input(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
original = [ original = [
b'foo0' * 2, b'foo0' * 2,
b'foo1' * 3, b'foo1' * 3,
b'foo2' * 4, b'foo2' * 4,
b'foo3' * 5, b'foo3' * 5,
b'foo4' * 6, b'foo4' * 6,
] ]
if not hasattr(cctx, 'multi_compress_to_buffer'):
self.skipTest('multi_compress_to_buffer not available')
frames = cctx.multi_compress_to_buffer(original) frames = cctx.multi_compress_to_buffer(original)
# Check round trip. # Check round trip.
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
decompressed = dctx.multi_decompress_to_buffer(frames, threads=3) decompressed = dctx.multi_decompress_to_buffer(frames, threads=3)
self.assertEqual(len(decompressed), len(original)) self.assertEqual(len(decompressed), len(original))
for i, data in enumerate(original): for i, data in enumerate(original):
self.assertEqual(data, decompressed[i].tobytes()) self.assertEqual(data, decompressed[i].tobytes())
# And a manual mode. # And a manual mode.
def test_dict(self): def test_dict(self):
d = zstd.train_dictionary(16384, generate_samples(), k=64, d=16) d = zstd.train_dictionary(16384, generate_samples(), k=64, d=16)
cctx = zstd.ZstdCompressor(dict_data=d, level=1) cctx = zstd.ZstdCompressor(dict_data=d, level=1)
frames = [cctx.compress(s) for s in generate_samples()] frames = [cctx.compress(s) for s in generate_samples()]
dctx = zstd.ZstdDecompressor(dict_data=d) dctx = zstd.ZstdDecompressor(dict_data=d)
if not hasattr(dctx, 'multi_decompress_to_buffer'):
self.skipTest('multi_decompress_to_buffer not available')
result = dctx.multi_decompress_to_buffer(frames) result = dctx.multi_decompress_to_buffer(frames)
self.assertEqual([o.tobytes() for o in result], generate_samples()) self.assertEqual([o.tobytes() for o in result], generate_samples())
def test_multiple_threads(self): def test_multiple_threads(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
frames = [] frames = []
frames.extend(cctx.compress(b'x' * 64) for i in range(256)) frames.extend(cctx.compress(b'x' * 64) for i in range(256))
frames.extend(cctx.compress(b'y' * 64) for i in range(256)) frames.extend(cctx.compress(b'y' * 64) for i in range(256))
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
if not hasattr(dctx, 'multi_decompress_to_buffer'):
self.skipTest('multi_decompress_to_buffer not available')
result = dctx.multi_decompress_to_buffer(frames, threads=-1) result = dctx.multi_decompress_to_buffer(frames, threads=-1)
self.assertEqual(len(result), len(frames)) self.assertEqual(len(result), len(frames))
self.assertEqual(result.size(), 2 * 64 * 256) self.assertEqual(result.size(), 2 * 64 * 256)
self.assertEqual(result[0].tobytes(), b'x' * 64) self.assertEqual(result[0].tobytes(), b'x' * 64)
self.assertEqual(result[256].tobytes(), b'y' * 64) self.assertEqual(result[256].tobytes(), b'y' * 64)
def test_item_failure(self): def test_item_failure(self):
cctx = zstd.ZstdCompressor() cctx = zstd.ZstdCompressor()
frames = [cctx.compress(b'x' * 128), cctx.compress(b'y' * 128)] frames = [cctx.compress(b'x' * 128), cctx.compress(b'y' * 128)]
frames[1] = frames[1][0:15] + b'extra' + frames[1][15:] frames[1] = frames[1][0:15] + b'extra' + frames[1][15:]
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
if not hasattr(dctx, 'multi_decompress_to_buffer'):
self.skipTest('multi_decompress_to_buffer not available')
with self.assertRaisesRegexp(zstd.ZstdError, with self.assertRaisesRegexp(zstd.ZstdError,
'error decompressing item 1: (' 'error decompressing item 1: ('
'Corrupted block|' 'Corrupted block|'
'Destination buffer is too small)'): 'Destination buffer is too small)'):
dctx.multi_decompress_to_buffer(frames) dctx.multi_decompress_to_buffer(frames)
with self.assertRaisesRegexp(zstd.ZstdError, with self.assertRaisesRegexp(zstd.ZstdError,
'error decompressing item 1: (' 'error decompressing item 1: ('
'Corrupted block|' 'Corrupted block|'
'Destination buffer is too small)'): 'Destination buffer is too small)'):
dctx.multi_decompress_to_buffer(frames, threads=2) dctx.multi_decompress_to_buffer(frames, threads=2)

contrib/python-zstandard/tests/test_decompressor_fuzzing.py

import io import io
import os import os
import unittest import unittest
try: try:
import hypothesis import hypothesis
import hypothesis.strategies as strategies import hypothesis.strategies as strategies
except ImportError: except ImportError:
raise unittest.SkipTest('hypothesis not available') raise unittest.SkipTest('hypothesis not available')
import zstandard as zstd import zstandard as zstd
from . common import ( from . common import (
make_cffi, make_cffi,
NonClosingBytesIO,
random_input_data, random_input_data,
) )
@unittest.skipUnless('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set') @unittest.skipUnless('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
@make_cffi @make_cffi
class TestDecompressor_stream_reader_fuzzing(unittest.TestCase): class TestDecompressor_stream_reader_fuzzing(unittest.TestCase):
@hypothesis.settings( @hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example]) suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()), @hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5), level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384), streaming=strategies.booleans(),
source_read_size=strategies.integers(1, 1048576),
read_sizes=strategies.data()) read_sizes=strategies.data())
def test_stream_source_read_variance(self, original, level, source_read_size, def test_stream_source_read_variance(self, original, level, streaming,
read_sizes): source_read_size, read_sizes):
cctx = zstd.ZstdCompressor(level=level) cctx = zstd.ZstdCompressor(level=level)
if streaming:
source = io.BytesIO()
writer = cctx.stream_writer(source)
writer.write(original)
writer.flush(zstd.FLUSH_FRAME)
source.seek(0)
else:
frame = cctx.compress(original) frame = cctx.compress(original)
source = io.BytesIO(frame)
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
source = io.BytesIO(frame)
chunks = [] chunks = []
with dctx.stream_reader(source, read_size=source_read_size) as reader: with dctx.stream_reader(source, read_size=source_read_size) as reader:
while True: while True:
read_size = read_sizes.draw(strategies.integers(1, 16384)) read_size = read_sizes.draw(strategies.integers(-1, 131072))
chunk = reader.read(read_size) chunk = reader.read(read_size)
if not chunk: if not chunk and read_size:
break
chunks.append(chunk)
self.assertEqual(b''.join(chunks), original)
# Similar to above except we have a constant read() size.
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
streaming=strategies.booleans(),
source_read_size=strategies.integers(1, 1048576),
read_size=strategies.integers(-1, 131072))
def test_stream_source_read_size(self, original, level, streaming,
source_read_size, read_size):
if read_size == 0:
read_size = 1
cctx = zstd.ZstdCompressor(level=level)
if streaming:
source = io.BytesIO()
writer = cctx.stream_writer(source)
writer.write(original)
writer.flush(zstd.FLUSH_FRAME)
source.seek(0)
else:
frame = cctx.compress(original)
source = io.BytesIO(frame)
dctx = zstd.ZstdDecompressor()
chunks = []
reader = dctx.stream_reader(source, read_size=source_read_size)
while True:
chunk = reader.read(read_size)
if not chunk and read_size:
break break
chunks.append(chunk) chunks.append(chunk)
self.assertEqual(b''.join(chunks), original) self.assertEqual(b''.join(chunks), original)
@hypothesis.settings( @hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example]) suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()), @hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5), level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384), streaming=strategies.booleans(),
source_read_size=strategies.integers(1, 1048576),
read_sizes=strategies.data()) read_sizes=strategies.data())
def test_buffer_source_read_variance(self, original, level, source_read_size, def test_buffer_source_read_variance(self, original, level, streaming,
read_sizes): source_read_size, read_sizes):
cctx = zstd.ZstdCompressor(level=level) cctx = zstd.ZstdCompressor(level=level)
if streaming:
source = io.BytesIO()
writer = cctx.stream_writer(source)
writer.write(original)
writer.flush(zstd.FLUSH_FRAME)
frame = source.getvalue()
else:
frame = cctx.compress(original) frame = cctx.compress(original)
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
chunks = [] chunks = []
with dctx.stream_reader(frame, read_size=source_read_size) as reader: with dctx.stream_reader(frame, read_size=source_read_size) as reader:
while True: while True:
read_size = read_sizes.draw(strategies.integers(1, 16384)) read_size = read_sizes.draw(strategies.integers(-1, 131072))
chunk = reader.read(read_size) chunk = reader.read(read_size)
if not chunk: if not chunk and read_size:
break
chunks.append(chunk)
self.assertEqual(b''.join(chunks), original)
# Similar to above except we have a constant read() size.
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
streaming=strategies.booleans(),
source_read_size=strategies.integers(1, 1048576),
read_size=strategies.integers(-1, 131072))
def test_buffer_source_constant_read_size(self, original, level, streaming,
source_read_size, read_size):
if read_size == 0:
read_size = -1
cctx = zstd.ZstdCompressor(level=level)
if streaming:
source = io.BytesIO()
writer = cctx.stream_writer(source)
writer.write(original)
writer.flush(zstd.FLUSH_FRAME)
frame = source.getvalue()
else:
frame = cctx.compress(original)
dctx = zstd.ZstdDecompressor()
chunks = []
reader = dctx.stream_reader(frame, read_size=source_read_size)
while True:
chunk = reader.read(read_size)
if not chunk and read_size:
break
chunks.append(chunk)
self.assertEqual(b''.join(chunks), original)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
streaming=strategies.booleans(),
source_read_size=strategies.integers(1, 1048576))
def test_stream_source_readall(self, original, level, streaming,
source_read_size):
cctx = zstd.ZstdCompressor(level=level)
if streaming:
source = io.BytesIO()
writer = cctx.stream_writer(source)
writer.write(original)
writer.flush(zstd.FLUSH_FRAME)
source.seek(0)
else:
frame = cctx.compress(original)
source = io.BytesIO(frame)
dctx = zstd.ZstdDecompressor()
data = dctx.stream_reader(source, read_size=source_read_size).readall()
self.assertEqual(data, original)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
streaming=strategies.booleans(),
source_read_size=strategies.integers(1, 1048576),
read_sizes=strategies.data())
def test_stream_source_read1_variance(self, original, level, streaming,
source_read_size, read_sizes):
cctx = zstd.ZstdCompressor(level=level)
if streaming:
source = io.BytesIO()
writer = cctx.stream_writer(source)
writer.write(original)
writer.flush(zstd.FLUSH_FRAME)
source.seek(0)
else:
frame = cctx.compress(original)
source = io.BytesIO(frame)
dctx = zstd.ZstdDecompressor()
chunks = []
with dctx.stream_reader(source, read_size=source_read_size) as reader:
while True:
read_size = read_sizes.draw(strategies.integers(-1, 131072))
chunk = reader.read1(read_size)
if not chunk and read_size:
break break
chunks.append(chunk) chunks.append(chunk)
self.assertEqual(b''.join(chunks), original) self.assertEqual(b''.join(chunks), original)
@hypothesis.settings( @hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example]) suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5),
streaming=strategies.booleans(),
source_read_size=strategies.integers(1, 1048576),
read_sizes=strategies.data())
def test_stream_source_readinto1_variance(self, original, level, streaming,
source_read_size, read_sizes):
cctx = zstd.ZstdCompressor(level=level)
if streaming:
source = io.BytesIO()
writer = cctx.stream_writer(source)
writer.write(original)
writer.flush(zstd.FLUSH_FRAME)
source.seek(0)
else:
frame = cctx.compress(original)
source = io.BytesIO(frame)
dctx = zstd.ZstdDecompressor()
chunks = []
with dctx.stream_reader(source, read_size=source_read_size) as reader:
while True:
read_size = read_sizes.draw(strategies.integers(1, 131072))
b = bytearray(read_size)
count = reader.readinto1(b)
if not count:
break
chunks.append(bytes(b[0:count]))
self.assertEqual(b''.join(chunks), original)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given( @hypothesis.given(
original=strategies.sampled_from(random_input_data()), original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5), level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 16384), source_read_size=strategies.integers(1, 1048576),
seek_amounts=strategies.data(), seek_amounts=strategies.data(),
read_sizes=strategies.data()) read_sizes=strategies.data())
def test_relative_seeks(self, original, level, source_read_size, seek_amounts, def test_relative_seeks(self, original, level, source_read_size, seek_amounts,
read_sizes): read_sizes):
cctx = zstd.ZstdCompressor(level=level) cctx = zstd.ZstdCompressor(level=level)
frame = cctx.compress(original) frame = cctx.compress(original)
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
with dctx.stream_reader(frame, read_size=source_read_size) as reader: with dctx.stream_reader(frame, read_size=source_read_size) as reader:
while True: while True:
amount = seek_amounts.draw(strategies.integers(0, 16384)) amount = seek_amounts.draw(strategies.integers(0, 16384))
reader.seek(amount, os.SEEK_CUR) reader.seek(amount, os.SEEK_CUR)
offset = reader.tell() offset = reader.tell()
read_amount = read_sizes.draw(strategies.integers(1, 16384)) read_amount = read_sizes.draw(strategies.integers(1, 16384))
chunk = reader.read(read_amount) chunk = reader.read(read_amount)
if not chunk: if not chunk:
break break
self.assertEqual(original[offset:offset + len(chunk)], chunk) self.assertEqual(original[offset:offset + len(chunk)], chunk)
@hypothesis.settings(
suppress_health_check=[hypothesis.HealthCheck.large_base_example])
@hypothesis.given(
originals=strategies.data(),
frame_count=strategies.integers(min_value=2, max_value=10),
level=strategies.integers(min_value=1, max_value=5),
source_read_size=strategies.integers(1, 1048576),
read_sizes=strategies.data())
def test_multiple_frames(self, originals, frame_count, level,
source_read_size, read_sizes):
cctx = zstd.ZstdCompressor(level=level)
source = io.BytesIO()
buffer = io.BytesIO()
writer = cctx.stream_writer(buffer)
for i in range(frame_count):
data = originals.draw(strategies.sampled_from(random_input_data()))
source.write(data)
writer.write(data)
writer.flush(zstd.FLUSH_FRAME)
dctx = zstd.ZstdDecompressor()
buffer.seek(0)
reader = dctx.stream_reader(buffer, read_size=source_read_size,
read_across_frames=True)
chunks = []
while True:
read_amount = read_sizes.draw(strategies.integers(-1, 16384))
chunk = reader.read(read_amount)
if not chunk and read_amount:
break
chunks.append(chunk)
self.assertEqual(source.getvalue(), b''.join(chunks))
@unittest.skipUnless('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set') @unittest.skipUnless('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
@make_cffi @make_cffi
class TestDecompressor_stream_writer_fuzzing(unittest.TestCase): class TestDecompressor_stream_writer_fuzzing(unittest.TestCase):
@hypothesis.given(original=strategies.sampled_from(random_input_data()), @hypothesis.given(original=strategies.sampled_from(random_input_data()),
level=strategies.integers(min_value=1, max_value=5), level=strategies.integers(min_value=1, max_value=5),
write_size=strategies.integers(min_value=1, max_value=8192), write_size=strategies.integers(min_value=1, max_value=8192),
input_sizes=strategies.data()) input_sizes=strategies.data())
def test_write_size_variance(self, original, level, write_size, input_sizes): def test_write_size_variance(self, original, level, write_size, input_sizes):
cctx = zstd.ZstdCompressor(level=level) cctx = zstd.ZstdCompressor(level=level)
frame = cctx.compress(original) frame = cctx.compress(original)
dctx = zstd.ZstdDecompressor() dctx = zstd.ZstdDecompressor()
source = io.BytesIO(frame) source = io.BytesIO(frame)
dest = io.BytesIO() dest = NonClosingBytesIO()
with dctx.stream_writer(dest, write_size=write_size) as decompressor: with dctx.stream_writer(dest, write_size=write_size) as decompressor:
while True: while True:
input_size = input_sizes.draw(strategies.integers(1, 4096)) input_size = input_sizes.draw(strategies.integers(1, 4096))
chunk = source.read(input_size) chunk = source.read(input_size)
if not chunk: if not chunk:
break break
if use_dict: if use_dict:
kwargs['dict_data'] = zstd.ZstdCompressionDict(original[0]) kwargs['dict_data'] = zstd.ZstdCompressionDict(original[0])
cctx = zstd.ZstdCompressor(level=1, cctx = zstd.ZstdCompressor(level=1,
write_content_size=True, write_content_size=True,
write_checksum=True, write_checksum=True,
**kwargs) **kwargs)
if not hasattr(cctx, 'multi_compress_to_buffer'):
self.skipTest('multi_compress_to_buffer not available')
frames_buffer = cctx.multi_compress_to_buffer(original, threads=-1) frames_buffer = cctx.multi_compress_to_buffer(original, threads=-1)
dctx = zstd.ZstdDecompressor(**kwargs) dctx = zstd.ZstdDecompressor(**kwargs)
result = dctx.multi_decompress_to_buffer(frames_buffer) result = dctx.multi_decompress_to_buffer(frames_buffer)
self.assertEqual(len(result), len(original)) self.assertEqual(len(result), len(original))
for i, frame in enumerate(result): for i, frame in enumerate(result):
self.assertEqual(frame.tobytes(), original[i]) self.assertEqual(frame.tobytes(), original[i])
frames_list = [f.tobytes() for f in frames_buffer] frames_list = [f.tobytes() for f in frames_buffer]
result = dctx.multi_decompress_to_buffer(frames_list) result = dctx.multi_decompress_to_buffer(frames_list)
self.assertEqual(len(result), len(original)) self.assertEqual(len(result), len(original))
for i, frame in enumerate(result): for i, frame in enumerate(result):
self.assertEqual(frame.tobytes(), original[i]) self.assertEqual(frame.tobytes(), original[i])

contrib/python-zstandard/tests/test_module_attributes.py

from __future__ import unicode_literals from __future__ import unicode_literals
import unittest import unittest
import zstandard as zstd import zstandard as zstd
from . common import ( from . common import (
make_cffi, make_cffi,
) )
@make_cffi @make_cffi
class TestModuleAttributes(unittest.TestCase): class TestModuleAttributes(unittest.TestCase):
def test_version(self): def test_version(self):
self.assertEqual(zstd.ZSTD_VERSION, (1, 3, 6)) self.assertEqual(zstd.ZSTD_VERSION, (1, 3, 8))
self.assertEqual(zstd.__version__, '0.10.1') self.assertEqual(zstd.__version__, '0.11.0')
def test_constants(self): def test_constants(self):
self.assertEqual(zstd.MAX_COMPRESSION_LEVEL, 22) self.assertEqual(zstd.MAX_COMPRESSION_LEVEL, 22)
self.assertEqual(zstd.FRAME_HEADER, b'\x28\xb5\x2f\xfd') self.assertEqual(zstd.FRAME_HEADER, b'\x28\xb5\x2f\xfd')
def test_hasattr(self): def test_hasattr(self):
attrs = ( attrs = (
'CONTENTSIZE_UNKNOWN', 'CONTENTSIZE_UNKNOWN',
'CONTENTSIZE_ERROR', 'CONTENTSIZE_ERROR',
'COMPRESSION_RECOMMENDED_INPUT_SIZE', 'COMPRESSION_RECOMMENDED_INPUT_SIZE',
'COMPRESSION_RECOMMENDED_OUTPUT_SIZE', 'COMPRESSION_RECOMMENDED_OUTPUT_SIZE',
'DECOMPRESSION_RECOMMENDED_INPUT_SIZE', 'DECOMPRESSION_RECOMMENDED_INPUT_SIZE',
'DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE', 'DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE',
'MAGIC_NUMBER', 'MAGIC_NUMBER',
'FLUSH_BLOCK',
'FLUSH_FRAME',
'BLOCKSIZELOG_MAX', 'BLOCKSIZELOG_MAX',
'BLOCKSIZE_MAX', 'BLOCKSIZE_MAX',
'WINDOWLOG_MIN', 'WINDOWLOG_MIN',
'WINDOWLOG_MAX', 'WINDOWLOG_MAX',
'CHAINLOG_MIN', 'CHAINLOG_MIN',
'CHAINLOG_MAX', 'CHAINLOG_MAX',
'HASHLOG_MIN', 'HASHLOG_MIN',
'HASHLOG_MAX', 'HASHLOG_MAX',
'HASHLOG3_MAX', 'HASHLOG3_MAX',
'MINMATCH_MIN',
'MINMATCH_MAX',
'SEARCHLOG_MIN', 'SEARCHLOG_MIN',
'SEARCHLOG_MAX', 'SEARCHLOG_MAX',
'SEARCHLENGTH_MIN', 'SEARCHLENGTH_MIN',
'SEARCHLENGTH_MAX', 'SEARCHLENGTH_MAX',
'TARGETLENGTH_MIN', 'TARGETLENGTH_MIN',
'TARGETLENGTH_MAX', 'TARGETLENGTH_MAX',
'LDM_MINMATCH_MIN', 'LDM_MINMATCH_MIN',
'LDM_MINMATCH_MAX', 'LDM_MINMATCH_MAX',
'LDM_BUCKETSIZELOG_MAX', 'LDM_BUCKETSIZELOG_MAX',
'STRATEGY_FAST', 'STRATEGY_FAST',
'STRATEGY_DFAST', 'STRATEGY_DFAST',
'STRATEGY_GREEDY', 'STRATEGY_GREEDY',
'STRATEGY_LAZY', 'STRATEGY_LAZY',
'STRATEGY_LAZY2', 'STRATEGY_LAZY2',
'STRATEGY_BTLAZY2', 'STRATEGY_BTLAZY2',
'STRATEGY_BTOPT', 'STRATEGY_BTOPT',
'STRATEGY_BTULTRA', 'STRATEGY_BTULTRA',
'STRATEGY_BTULTRA2',
'DICT_TYPE_AUTO', 'DICT_TYPE_AUTO',
'DICT_TYPE_RAWCONTENT', 'DICT_TYPE_RAWCONTENT',
'DICT_TYPE_FULLDICT', 'DICT_TYPE_FULLDICT',
) )
for a in attrs: for a in attrs:
self.assertTrue(hasattr(zstd, a), a) self.assertTrue(hasattr(zstd, a), a)

contrib/python-zstandard/zstandard/__init__.py

# the hacky but simple environment variable approach. # the hacky but simple environment variable approach.
_module_policy = os.environ.get('PYTHON_ZSTANDARD_IMPORT_POLICY', 'default') _module_policy = os.environ.get('PYTHON_ZSTANDARD_IMPORT_POLICY', 'default')
if _module_policy == 'default': if _module_policy == 'default':
if platform.python_implementation() in ('CPython',): if platform.python_implementation() in ('CPython',):
from zstd import * from zstd import *
backend = 'cext' backend = 'cext'
elif platform.python_implementation() in ('PyPy',): elif platform.python_implementation() in ('PyPy',):
from zstd_cffi import * from .cffi import *
backend = 'cffi' backend = 'cffi'
else: else:
try: try:
from zstd import * from zstd import *
backend = 'cext' backend = 'cext'
except ImportError: except ImportError:
from zstd_cffi import * from .cffi import *
backend = 'cffi' backend = 'cffi'
elif _module_policy == 'cffi_fallback': elif _module_policy == 'cffi_fallback':
try: try:
from zstd import * from zstd import *
backend = 'cext' backend = 'cext'
except ImportError: except ImportError:
from zstd_cffi import * from .cffi import *
backend = 'cffi' backend = 'cffi'
elif _module_policy == 'cext': elif _module_policy == 'cext':
from zstd import * from zstd import *
backend = 'cext' backend = 'cext'
elif _module_policy == 'cffi': elif _module_policy == 'cffi':
from zstd_cffi import * from .cffi import *
backend = 'cffi' backend = 'cffi'
else: else:
raise ImportError('unknown module import policy: %s; use default, cffi_fallback, ' raise ImportError('unknown module import policy: %s; use default, cffi_fallback, '
'cext, or cffi' % _module_policy) 'cext, or cffi' % _module_policy)
# Keep this in sync with python-zstandard.h. # Keep this in sync with python-zstandard.h.
__version__ = '0.10.1' __version__ = '0.11.0'

contrib/python-zstandard/zstandard/cffi.py

  • This file was moved from contrib/python-zstandard/zstd_cffi.py.
'FrameParameters', 'FrameParameters',
'estimate_decompression_context_size', 'estimate_decompression_context_size',
'frame_content_size', 'frame_content_size',
'frame_header_size', 'frame_header_size',
'get_frame_parameters', 'get_frame_parameters',
'train_dictionary', 'train_dictionary',
# Constants. # Constants.
'FLUSH_BLOCK',
'FLUSH_FRAME',
'COMPRESSOBJ_FLUSH_FINISH', 'COMPRESSOBJ_FLUSH_FINISH',
'COMPRESSOBJ_FLUSH_BLOCK', 'COMPRESSOBJ_FLUSH_BLOCK',
'ZSTD_VERSION', 'ZSTD_VERSION',
'FRAME_HEADER', 'FRAME_HEADER',
'CONTENTSIZE_UNKNOWN', 'CONTENTSIZE_UNKNOWN',
'CONTENTSIZE_ERROR', 'CONTENTSIZE_ERROR',
'MAX_COMPRESSION_LEVEL', 'MAX_COMPRESSION_LEVEL',
'COMPRESSION_RECOMMENDED_INPUT_SIZE', 'COMPRESSION_RECOMMENDED_INPUT_SIZE',
'COMPRESSION_RECOMMENDED_OUTPUT_SIZE', 'COMPRESSION_RECOMMENDED_OUTPUT_SIZE',
'DECOMPRESSION_RECOMMENDED_INPUT_SIZE', 'DECOMPRESSION_RECOMMENDED_INPUT_SIZE',
'DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE', 'DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE',
'MAGIC_NUMBER', 'MAGIC_NUMBER',
'BLOCKSIZELOG_MAX', 'BLOCKSIZELOG_MAX',
'BLOCKSIZE_MAX', 'BLOCKSIZE_MAX',
'WINDOWLOG_MIN', 'WINDOWLOG_MIN',
'WINDOWLOG_MAX', 'WINDOWLOG_MAX',
'CHAINLOG_MIN', 'CHAINLOG_MIN',
'CHAINLOG_MAX', 'CHAINLOG_MAX',
'HASHLOG_MIN', 'HASHLOG_MIN',
'HASHLOG_MAX', 'HASHLOG_MAX',
'HASHLOG3_MAX', 'HASHLOG3_MAX',
'MINMATCH_MIN',
'MINMATCH_MAX',
'SEARCHLOG_MIN', 'SEARCHLOG_MIN',
'SEARCHLOG_MAX', 'SEARCHLOG_MAX',
'SEARCHLENGTH_MIN', 'SEARCHLENGTH_MIN',
'SEARCHLENGTH_MAX', 'SEARCHLENGTH_MAX',
'TARGETLENGTH_MIN', 'TARGETLENGTH_MIN',
'TARGETLENGTH_MAX', 'TARGETLENGTH_MAX',
'LDM_MINMATCH_MIN', 'LDM_MINMATCH_MIN',
'LDM_MINMATCH_MAX', 'LDM_MINMATCH_MAX',
'LDM_BUCKETSIZELOG_MAX', 'LDM_BUCKETSIZELOG_MAX',
'STRATEGY_FAST', 'STRATEGY_FAST',
'STRATEGY_DFAST', 'STRATEGY_DFAST',
'STRATEGY_GREEDY', 'STRATEGY_GREEDY',
'STRATEGY_LAZY', 'STRATEGY_LAZY',
'STRATEGY_LAZY2', 'STRATEGY_LAZY2',
'STRATEGY_BTLAZY2', 'STRATEGY_BTLAZY2',
'STRATEGY_BTOPT', 'STRATEGY_BTOPT',
'STRATEGY_BTULTRA', 'STRATEGY_BTULTRA',
'STRATEGY_BTULTRA2',
'DICT_TYPE_AUTO', 'DICT_TYPE_AUTO',
'DICT_TYPE_RAWCONTENT', 'DICT_TYPE_RAWCONTENT',
'DICT_TYPE_FULLDICT', 'DICT_TYPE_FULLDICT',
'FORMAT_ZSTD1', 'FORMAT_ZSTD1',
'FORMAT_ZSTD1_MAGICLESS', 'FORMAT_ZSTD1_MAGICLESS',
] ]
import io import io
BLOCKSIZE_MAX = lib.ZSTD_BLOCKSIZE_MAX BLOCKSIZE_MAX = lib.ZSTD_BLOCKSIZE_MAX
WINDOWLOG_MIN = lib.ZSTD_WINDOWLOG_MIN WINDOWLOG_MIN = lib.ZSTD_WINDOWLOG_MIN
WINDOWLOG_MAX = lib.ZSTD_WINDOWLOG_MAX WINDOWLOG_MAX = lib.ZSTD_WINDOWLOG_MAX
CHAINLOG_MIN = lib.ZSTD_CHAINLOG_MIN CHAINLOG_MIN = lib.ZSTD_CHAINLOG_MIN
CHAINLOG_MAX = lib.ZSTD_CHAINLOG_MAX CHAINLOG_MAX = lib.ZSTD_CHAINLOG_MAX
HASHLOG_MIN = lib.ZSTD_HASHLOG_MIN HASHLOG_MIN = lib.ZSTD_HASHLOG_MIN
HASHLOG_MAX = lib.ZSTD_HASHLOG_MAX HASHLOG_MAX = lib.ZSTD_HASHLOG_MAX
HASHLOG3_MAX = lib.ZSTD_HASHLOG3_MAX HASHLOG3_MAX = lib.ZSTD_HASHLOG3_MAX
MINMATCH_MIN = lib.ZSTD_MINMATCH_MIN
MINMATCH_MAX = lib.ZSTD_MINMATCH_MAX
SEARCHLOG_MIN = lib.ZSTD_SEARCHLOG_MIN SEARCHLOG_MIN = lib.ZSTD_SEARCHLOG_MIN
SEARCHLOG_MAX = lib.ZSTD_SEARCHLOG_MAX SEARCHLOG_MAX = lib.ZSTD_SEARCHLOG_MAX
SEARCHLENGTH_MIN = lib.ZSTD_SEARCHLENGTH_MIN SEARCHLENGTH_MIN = lib.ZSTD_MINMATCH_MIN
SEARCHLENGTH_MAX = lib.ZSTD_SEARCHLENGTH_MAX SEARCHLENGTH_MAX = lib.ZSTD_MINMATCH_MAX
TARGETLENGTH_MIN = lib.ZSTD_TARGETLENGTH_MIN TARGETLENGTH_MIN = lib.ZSTD_TARGETLENGTH_MIN
TARGETLENGTH_MAX = lib.ZSTD_TARGETLENGTH_MAX TARGETLENGTH_MAX = lib.ZSTD_TARGETLENGTH_MAX
LDM_MINMATCH_MIN = lib.ZSTD_LDM_MINMATCH_MIN LDM_MINMATCH_MIN = lib.ZSTD_LDM_MINMATCH_MIN
LDM_MINMATCH_MAX = lib.ZSTD_LDM_MINMATCH_MAX LDM_MINMATCH_MAX = lib.ZSTD_LDM_MINMATCH_MAX
LDM_BUCKETSIZELOG_MAX = lib.ZSTD_LDM_BUCKETSIZELOG_MAX LDM_BUCKETSIZELOG_MAX = lib.ZSTD_LDM_BUCKETSIZELOG_MAX
STRATEGY_FAST = lib.ZSTD_fast STRATEGY_FAST = lib.ZSTD_fast
STRATEGY_DFAST = lib.ZSTD_dfast STRATEGY_DFAST = lib.ZSTD_dfast
STRATEGY_GREEDY = lib.ZSTD_greedy STRATEGY_GREEDY = lib.ZSTD_greedy
STRATEGY_LAZY = lib.ZSTD_lazy STRATEGY_LAZY = lib.ZSTD_lazy
STRATEGY_LAZY2 = lib.ZSTD_lazy2 STRATEGY_LAZY2 = lib.ZSTD_lazy2
STRATEGY_BTLAZY2 = lib.ZSTD_btlazy2 STRATEGY_BTLAZY2 = lib.ZSTD_btlazy2
STRATEGY_BTOPT = lib.ZSTD_btopt STRATEGY_BTOPT = lib.ZSTD_btopt
STRATEGY_BTULTRA = lib.ZSTD_btultra STRATEGY_BTULTRA = lib.ZSTD_btultra
STRATEGY_BTULTRA2 = lib.ZSTD_btultra2
DICT_TYPE_AUTO = lib.ZSTD_dct_auto DICT_TYPE_AUTO = lib.ZSTD_dct_auto
DICT_TYPE_RAWCONTENT = lib.ZSTD_dct_rawContent DICT_TYPE_RAWCONTENT = lib.ZSTD_dct_rawContent
DICT_TYPE_FULLDICT = lib.ZSTD_dct_fullDict DICT_TYPE_FULLDICT = lib.ZSTD_dct_fullDict
FORMAT_ZSTD1 = lib.ZSTD_f_zstd1 FORMAT_ZSTD1 = lib.ZSTD_f_zstd1
FORMAT_ZSTD1_MAGICLESS = lib.ZSTD_f_zstd1_magicless FORMAT_ZSTD1_MAGICLESS = lib.ZSTD_f_zstd1_magicless
FLUSH_BLOCK = 0
FLUSH_FRAME = 1
COMPRESSOBJ_FLUSH_FINISH = 0 COMPRESSOBJ_FLUSH_FINISH = 0
COMPRESSOBJ_FLUSH_BLOCK = 1 COMPRESSOBJ_FLUSH_BLOCK = 1
def _cpu_count(): def _cpu_count():
# os.cpu_count() was introducd in Python 3.4. # os.cpu_count() was introducd in Python 3.4.
try: try:
return os.cpu_count() or 0 return os.cpu_count() or 0
def _make_cctx_params(params): def _make_cctx_params(params):
res = lib.ZSTD_createCCtxParams() res = lib.ZSTD_createCCtxParams()
if res == ffi.NULL: if res == ffi.NULL:
raise MemoryError() raise MemoryError()
res = ffi.gc(res, lib.ZSTD_freeCCtxParams) res = ffi.gc(res, lib.ZSTD_freeCCtxParams)
attrs = [ attrs = [
(lib.ZSTD_p_format, params.format), (lib.ZSTD_c_format, params.format),
(lib.ZSTD_p_compressionLevel, params.compression_level), (lib.ZSTD_c_compressionLevel, params.compression_level),
(lib.ZSTD_p_windowLog, params.window_log), (lib.ZSTD_c_windowLog, params.window_log),
(lib.ZSTD_p_hashLog, params.hash_log), (lib.ZSTD_c_hashLog, params.hash_log),
(lib.ZSTD_p_chainLog, params.chain_log), (lib.ZSTD_c_chainLog, params.chain_log),
(lib.ZSTD_p_searchLog, params.search_log), (lib.ZSTD_c_searchLog, params.search_log),
(lib.ZSTD_p_minMatch, params.min_match), (lib.ZSTD_c_minMatch, params.min_match),
(lib.ZSTD_p_targetLength, params.target_length), (lib.ZSTD_c_targetLength, params.target_length),
(lib.ZSTD_p_compressionStrategy, params.compression_strategy), (lib.ZSTD_c_strategy, params.compression_strategy),
(lib.ZSTD_p_contentSizeFlag, params.write_content_size), (lib.ZSTD_c_contentSizeFlag, params.write_content_size),
(lib.ZSTD_p_checksumFlag, params.write_checksum), (lib.ZSTD_c_checksumFlag, params.write_checksum),
(lib.ZSTD_p_dictIDFlag, params.write_dict_id), (lib.ZSTD_c_dictIDFlag, params.write_dict_id),
(lib.ZSTD_p_nbWorkers, params.threads), (lib.ZSTD_c_nbWorkers, params.threads),
(lib.ZSTD_p_jobSize, params.job_size), (lib.ZSTD_c_jobSize, params.job_size),
(lib.ZSTD_p_overlapSizeLog, params.overlap_size_log), (lib.ZSTD_c_overlapLog, params.overlap_log),
(lib.ZSTD_p_forceMaxWindow, params.force_max_window), (lib.ZSTD_c_forceMaxWindow, params.force_max_window),
(lib.ZSTD_p_enableLongDistanceMatching, params.enable_ldm), (lib.ZSTD_c_enableLongDistanceMatching, params.enable_ldm),
(lib.ZSTD_p_ldmHashLog, params.ldm_hash_log), (lib.ZSTD_c_ldmHashLog, params.ldm_hash_log),
(lib.ZSTD_p_ldmMinMatch, params.ldm_min_match), (lib.ZSTD_c_ldmMinMatch, params.ldm_min_match),
(lib.ZSTD_p_ldmBucketSizeLog, params.ldm_bucket_size_log), (lib.ZSTD_c_ldmBucketSizeLog, params.ldm_bucket_size_log),
(lib.ZSTD_p_ldmHashEveryLog, params.ldm_hash_every_log), (lib.ZSTD_c_ldmHashRateLog, params.ldm_hash_rate_log),
] ]
for param, value in attrs: for param, value in attrs:
_set_compression_parameter(res, param, value) _set_compression_parameter(res, param, value)
return res return res
class ZstdCompressionParameters(object): class ZstdCompressionParameters(object):
@staticmethod @staticmethod
def from_level(level, source_size=0, dict_size=0, **kwargs): def from_level(level, source_size=0, dict_size=0, **kwargs):
params = lib.ZSTD_getCParams(level, source_size, dict_size) params = lib.ZSTD_getCParams(level, source_size, dict_size)
args = { args = {
'window_log': 'windowLog', 'window_log': 'windowLog',
'chain_log': 'chainLog', 'chain_log': 'chainLog',
'hash_log': 'hashLog', 'hash_log': 'hashLog',
'search_log': 'searchLog', 'search_log': 'searchLog',
'min_match': 'searchLength', 'min_match': 'minMatch',
'target_length': 'targetLength', 'target_length': 'targetLength',
'compression_strategy': 'strategy', 'compression_strategy': 'strategy',
} }
for arg, attr in args.items(): for arg, attr in args.items():
if arg not in kwargs: if arg not in kwargs:
kwargs[arg] = getattr(params, attr) kwargs[arg] = getattr(params, attr)
return ZstdCompressionParameters(**kwargs) return ZstdCompressionParameters(**kwargs)
def __init__(self, format=0, compression_level=0, window_log=0, hash_log=0, def __init__(self, format=0, compression_level=0, window_log=0, hash_log=0,
chain_log=0, search_log=0, min_match=0, target_length=0, chain_log=0, search_log=0, min_match=0, target_length=0,
compression_strategy=0, write_content_size=1, write_checksum=0, strategy=-1, compression_strategy=-1,
write_dict_id=0, job_size=0, overlap_size_log=0, write_content_size=1, write_checksum=0,
force_max_window=0, enable_ldm=0, ldm_hash_log=0, write_dict_id=0, job_size=0, overlap_log=-1,
ldm_min_match=0, ldm_bucket_size_log=0, ldm_hash_every_log=0, overlap_size_log=-1, force_max_window=0, enable_ldm=0,
threads=0): ldm_hash_log=0, ldm_min_match=0, ldm_bucket_size_log=0,
ldm_hash_rate_log=-1, ldm_hash_every_log=-1, threads=0):
params = lib.ZSTD_createCCtxParams()
if params == ffi.NULL:
raise MemoryError()
params = ffi.gc(params, lib.ZSTD_freeCCtxParams)
self._params = params
if threads < 0: if threads < 0:
threads = _cpu_count() threads = _cpu_count()
self.format = format # We need to set ZSTD_c_nbWorkers before ZSTD_c_jobSize and ZSTD_c_overlapLog
self.compression_level = compression_level # because setting ZSTD_c_nbWorkers resets the other parameters.
self.window_log = window_log _set_compression_parameter(params, lib.ZSTD_c_nbWorkers, threads)
self.hash_log = hash_log
self.chain_log = chain_log _set_compression_parameter(params, lib.ZSTD_c_format, format)
self.search_log = search_log _set_compression_parameter(params, lib.ZSTD_c_compressionLevel, compression_level)
self.min_match = min_match _set_compression_parameter(params, lib.ZSTD_c_windowLog, window_log)
self.target_length = target_length _set_compression_parameter(params, lib.ZSTD_c_hashLog, hash_log)
self.compression_strategy = compression_strategy _set_compression_parameter(params, lib.ZSTD_c_chainLog, chain_log)
self.write_content_size = write_content_size _set_compression_parameter(params, lib.ZSTD_c_searchLog, search_log)
self.write_checksum = write_checksum _set_compression_parameter(params, lib.ZSTD_c_minMatch, min_match)
self.write_dict_id = write_dict_id _set_compression_parameter(params, lib.ZSTD_c_targetLength, target_length)
self.job_size = job_size
self.overlap_size_log = overlap_size_log if strategy != -1 and compression_strategy != -1:
self.force_max_window = force_max_window raise ValueError('cannot specify both compression_strategy and strategy')
self.enable_ldm = enable_ldm
self.ldm_hash_log = ldm_hash_log if compression_strategy != -1:
self.ldm_min_match = ldm_min_match strategy = compression_strategy
self.ldm_bucket_size_log = ldm_bucket_size_log elif strategy == -1:
self.ldm_hash_every_log = ldm_hash_every_log strategy = 0
self.threads = threads
_set_compression_parameter(params, lib.ZSTD_c_strategy, strategy)
_set_compression_parameter(params, lib.ZSTD_c_contentSizeFlag, write_content_size)
_set_compression_parameter(params, lib.ZSTD_c_checksumFlag, write_checksum)
_set_compression_parameter(params, lib.ZSTD_c_dictIDFlag, write_dict_id)
_set_compression_parameter(params, lib.ZSTD_c_jobSize, job_size)
if overlap_log != -1 and overlap_size_log != -1:
raise ValueError('cannot specify both overlap_log and overlap_size_log')
if overlap_size_log != -1:
overlap_log = overlap_size_log
elif overlap_log == -1:
overlap_log = 0
_set_compression_parameter(params, lib.ZSTD_c_overlapLog, overlap_log)
_set_compression_parameter(params, lib.ZSTD_c_forceMaxWindow, force_max_window)
_set_compression_parameter(params, lib.ZSTD_c_enableLongDistanceMatching, enable_ldm)
_set_compression_parameter(params, lib.ZSTD_c_ldmHashLog, ldm_hash_log)
_set_compression_parameter(params, lib.ZSTD_c_ldmMinMatch, ldm_min_match)
_set_compression_parameter(params, lib.ZSTD_c_ldmBucketSizeLog, ldm_bucket_size_log)
if ldm_hash_rate_log != -1 and ldm_hash_every_log != -1:
raise ValueError('cannot specify both ldm_hash_rate_log and ldm_hash_every_log')
if ldm_hash_every_log != -1:
ldm_hash_rate_log = ldm_hash_every_log
elif ldm_hash_rate_log == -1:
ldm_hash_rate_log = 0
_set_compression_parameter(params, lib.ZSTD_c_ldmHashRateLog, ldm_hash_rate_log)
@property
def format(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_format)
@property
def compression_level(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_compressionLevel)
@property
def window_log(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_windowLog)
@property
def hash_log(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_hashLog)
@property
def chain_log(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_chainLog)
@property
def search_log(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_searchLog)
@property
def min_match(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_minMatch)
@property
def target_length(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_targetLength)
@property
def compression_strategy(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_strategy)
@property
def write_content_size(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_contentSizeFlag)
@property
def write_checksum(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_checksumFlag)
@property
def write_dict_id(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_dictIDFlag)
@property
def job_size(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_jobSize)
@property
def overlap_log(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_overlapLog)
@property
def overlap_size_log(self):
return self.overlap_log
@property
def force_max_window(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_forceMaxWindow)
@property
def enable_ldm(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_enableLongDistanceMatching)
@property
def ldm_hash_log(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_ldmHashLog)
@property
def ldm_min_match(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_ldmMinMatch)
@property
def ldm_bucket_size_log(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_ldmBucketSizeLog)
@property
def ldm_hash_rate_log(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_ldmHashRateLog)
@property
def ldm_hash_every_log(self):
return self.ldm_hash_rate_log
self.params = _make_cctx_params(self) @property
def threads(self):
return _get_compression_parameter(self._params, lib.ZSTD_c_nbWorkers)
def estimated_compression_context_size(self): def estimated_compression_context_size(self):
return lib.ZSTD_estimateCCtxSize_usingCCtxParams(self.params) return lib.ZSTD_estimateCCtxSize_usingCCtxParams(self._params)
CompressionParameters = ZstdCompressionParameters CompressionParameters = ZstdCompressionParameters
def estimate_decompression_context_size(): def estimate_decompression_context_size():
return lib.ZSTD_estimateDCtxSize() return lib.ZSTD_estimateDCtxSize()
def _set_compression_parameter(params, param, value): def _set_compression_parameter(params, param, value):
zresult = lib.ZSTD_CCtxParam_setParameter(params, param, zresult = lib.ZSTD_CCtxParam_setParameter(params, param, value)
ffi.cast('unsigned', value))
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('unable to set compression context parameter: %s' % raise ZstdError('unable to set compression context parameter: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
def _get_compression_parameter(params, param):
result = ffi.new('int *')
zresult = lib.ZSTD_CCtxParam_getParameter(params, param, result)
if lib.ZSTD_isError(zresult):
raise ZstdError('unable to get compression context parameter: %s' %
_zstd_error(zresult))
return result[0]
class ZstdCompressionWriter(object): class ZstdCompressionWriter(object):
def __init__(self, compressor, writer, source_size, write_size): def __init__(self, compressor, writer, source_size, write_size,
write_return_read):
self._compressor = compressor self._compressor = compressor
self._writer = writer self._writer = writer
self._source_size = source_size
self._write_size = write_size self._write_size = write_size
self._write_return_read = bool(write_return_read)
self._entered = False self._entered = False
self._closed = False
self._bytes_compressed = 0 self._bytes_compressed = 0
def __enter__(self): self._dst_buffer = ffi.new('char[]', write_size)
if self._entered: self._out_buffer = ffi.new('ZSTD_outBuffer *')
raise ZstdError('cannot __enter__ multiple times') self._out_buffer.dst = self._dst_buffer
self._out_buffer.size = len(self._dst_buffer)
self._out_buffer.pos = 0
zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._compressor._cctx, zresult = lib.ZSTD_CCtx_setPledgedSrcSize(compressor._cctx,
self._source_size) source_size)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('error setting source size: %s' % raise ZstdError('error setting source size: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
def __enter__(self):
if self._closed:
raise ValueError('stream is closed')
if self._entered:
raise ZstdError('cannot __enter__ multiple times')
self._entered = True self._entered = True
return self return self
def __exit__(self, exc_type, exc_value, exc_tb): def __exit__(self, exc_type, exc_value, exc_tb):
self._entered = False self._entered = False
if not exc_type and not exc_value and not exc_tb: if not exc_type and not exc_value and not exc_tb:
dst_buffer = ffi.new('char[]', self._write_size) self.close()
out_buffer = ffi.new('ZSTD_outBuffer *') self._compressor = None
in_buffer = ffi.new('ZSTD_inBuffer *')
out_buffer.dst = dst_buffer return False
out_buffer.size = len(dst_buffer)
out_buffer.pos = 0
in_buffer.src = ffi.NULL def memory_size(self):
in_buffer.size = 0 return lib.ZSTD_sizeof_CCtx(self._compressor._cctx)
in_buffer.pos = 0
while True: def fileno(self):
zresult = lib.ZSTD_compress_generic(self._compressor._cctx, f = getattr(self._writer, 'fileno', None)
out_buffer, in_buffer, if f:
lib.ZSTD_e_end) return f()
else:
raise OSError('fileno not available on underlying writer')
if lib.ZSTD_isError(zresult): def close(self):
raise ZstdError('error ending compression stream: %s' % if self._closed:
_zstd_error(zresult)) return
if out_buffer.pos: try:
self._writer.write(ffi.buffer(out_buffer.dst, out_buffer.pos)[:]) self.flush(FLUSH_FRAME)
out_buffer.pos = 0 finally:
self._closed = True
if zresult == 0: # Call close() on underlying stream as well.
break f = getattr(self._writer, 'close', None)
if f:
f()
self._compressor = None @property
def closed(self):
return self._closed
def isatty(self):
return False return False
def memory_size(self): def readable(self):
if not self._entered: return False
raise ZstdError('cannot determine size of an inactive compressor; '
'call when a context manager is active')
return lib.ZSTD_sizeof_CCtx(self._compressor._cctx) def readline(self, size=-1):
raise io.UnsupportedOperation()
def readlines(self, hint=-1):
raise io.UnsupportedOperation()
def seek(self, offset, whence=None):
raise io.UnsupportedOperation()
def seekable(self):
return False
def truncate(self, size=None):
raise io.UnsupportedOperation()
def writable(self):
return True
def writelines(self, lines):
raise NotImplementedError('writelines() is not yet implemented')
def read(self, size=-1):
raise io.UnsupportedOperation()
def readall(self):
raise io.UnsupportedOperation()
def readinto(self, b):
raise io.UnsupportedOperation()
def write(self, data): def write(self, data):
if not self._entered: if self._closed:
raise ZstdError('write() must be called from an active context ' raise ValueError('stream is closed')
'manager')
total_write = 0 total_write = 0
data_buffer = ffi.from_buffer(data) data_buffer = ffi.from_buffer(data)
in_buffer = ffi.new('ZSTD_inBuffer *') in_buffer = ffi.new('ZSTD_inBuffer *')
in_buffer.src = data_buffer in_buffer.src = data_buffer
in_buffer.size = len(data_buffer) in_buffer.size = len(data_buffer)
in_buffer.pos = 0 in_buffer.pos = 0
out_buffer = ffi.new('ZSTD_outBuffer *') out_buffer = self._out_buffer
dst_buffer = ffi.new('char[]', self._write_size)
out_buffer.dst = dst_buffer
out_buffer.size = self._write_size
out_buffer.pos = 0 out_buffer.pos = 0
while in_buffer.pos < in_buffer.size: while in_buffer.pos < in_buffer.size:
zresult = lib.ZSTD_compress_generic(self._compressor._cctx, zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
out_buffer, in_buffer, out_buffer, in_buffer,
lib.ZSTD_e_continue) lib.ZSTD_e_continue)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('zstd compress error: %s' % raise ZstdError('zstd compress error: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
if out_buffer.pos: if out_buffer.pos:
self._writer.write(ffi.buffer(out_buffer.dst, out_buffer.pos)[:]) self._writer.write(ffi.buffer(out_buffer.dst, out_buffer.pos)[:])
total_write += out_buffer.pos total_write += out_buffer.pos
self._bytes_compressed += out_buffer.pos self._bytes_compressed += out_buffer.pos
out_buffer.pos = 0 out_buffer.pos = 0
if self._write_return_read:
return in_buffer.pos
else:
return total_write return total_write
def flush(self): def flush(self, flush_mode=FLUSH_BLOCK):
if not self._entered: if flush_mode == FLUSH_BLOCK:
raise ZstdError('flush must be called from an active context manager') flush = lib.ZSTD_e_flush
elif flush_mode == FLUSH_FRAME:
flush = lib.ZSTD_e_end
else:
raise ValueError('unknown flush_mode: %r' % flush_mode)
if self._closed:
raise ValueError('stream is closed')
total_write = 0 total_write = 0
out_buffer = ffi.new('ZSTD_outBuffer *') out_buffer = self._out_buffer
dst_buffer = ffi.new('char[]', self._write_size)
out_buffer.dst = dst_buffer
out_buffer.size = self._write_size
out_buffer.pos = 0 out_buffer.pos = 0
in_buffer = ffi.new('ZSTD_inBuffer *') in_buffer = ffi.new('ZSTD_inBuffer *')
in_buffer.src = ffi.NULL in_buffer.src = ffi.NULL
in_buffer.size = 0 in_buffer.size = 0
in_buffer.pos = 0 in_buffer.pos = 0
while True: while True:
zresult = lib.ZSTD_compress_generic(self._compressor._cctx, zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
out_buffer, in_buffer, out_buffer, in_buffer,
lib.ZSTD_e_flush) flush)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('zstd compress error: %s' % raise ZstdError('zstd compress error: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
if out_buffer.pos: if out_buffer.pos:
self._writer.write(ffi.buffer(out_buffer.dst, out_buffer.pos)[:]) self._writer.write(ffi.buffer(out_buffer.dst, out_buffer.pos)[:])
total_write += out_buffer.pos total_write += out_buffer.pos
self._bytes_compressed += out_buffer.pos self._bytes_compressed += out_buffer.pos
source = ffi.new('ZSTD_inBuffer *') source = ffi.new('ZSTD_inBuffer *')
source.src = data_buffer source.src = data_buffer
source.size = len(data_buffer) source.size = len(data_buffer)
source.pos = 0 source.pos = 0
chunks = [] chunks = []
while source.pos < len(data): while source.pos < len(data):
zresult = lib.ZSTD_compress_generic(self._compressor._cctx, zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
self._out, self._out,
source, source,
lib.ZSTD_e_continue) lib.ZSTD_e_continue)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('zstd compress error: %s' % raise ZstdError('zstd compress error: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
if self._out.pos: if self._out.pos:
chunks.append(ffi.buffer(self._out.dst, self._out.pos)[:]) chunks.append(ffi.buffer(self._out.dst, self._out.pos)[:])
self._out.pos = 0 self._out.pos = 0
in_buffer = ffi.new('ZSTD_inBuffer *') in_buffer = ffi.new('ZSTD_inBuffer *')
in_buffer.src = ffi.NULL in_buffer.src = ffi.NULL
in_buffer.size = 0 in_buffer.size = 0
in_buffer.pos = 0 in_buffer.pos = 0
chunks = [] chunks = []
while True: while True:
zresult = lib.ZSTD_compress_generic(self._compressor._cctx, zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
self._out, self._out,
in_buffer, in_buffer,
z_flush_mode) z_flush_mode)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('error ending compression stream: %s' % raise ZstdError('error ending compression stream: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
if self._out.pos: if self._out.pos:
chunks.append(ffi.buffer(self._out.dst, self._out.pos)[:]) chunks.append(ffi.buffer(self._out.dst, self._out.pos)[:])
self._out.pos = 0 self._out.pos = 0
if not len(data_buffer): if not len(data_buffer):
return return
self._in.src = data_buffer self._in.src = data_buffer
self._in.size = len(data_buffer) self._in.size = len(data_buffer)
self._in.pos = 0 self._in.pos = 0
while self._in.pos < self._in.size: while self._in.pos < self._in.size:
zresult = lib.ZSTD_compress_generic(self._compressor._cctx, zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
self._out, self._out,
self._in, self._in,
lib.ZSTD_e_continue) lib.ZSTD_e_continue)
if self._in.pos == self._in.size: if self._in.pos == self._in.size:
self._in.src = ffi.NULL self._in.src = ffi.NULL
self._in.size = 0 self._in.size = 0
self._in.pos = 0 self._in.pos = 0
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('zstd compress error: %s' % raise ZstdError('zstd compress error: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
if self._out.pos == self._out.size: if self._out.pos == self._out.size:
yield ffi.buffer(self._out.dst, self._out.pos)[:] yield ffi.buffer(self._out.dst, self._out.pos)[:]
self._out.pos = 0 self._out.pos = 0
def flush(self): def flush(self):
if self._finished: if self._finished:
raise ZstdError('cannot call flush() after compression finished') raise ZstdError('cannot call flush() after compression finished')
if self._in.src != ffi.NULL: if self._in.src != ffi.NULL:
raise ZstdError('cannot call flush() before consuming output from ' raise ZstdError('cannot call flush() before consuming output from '
'previous operation') 'previous operation')
while True: while True:
zresult = lib.ZSTD_compress_generic(self._compressor._cctx, zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
self._out, self._in, self._out, self._in,
lib.ZSTD_e_flush) lib.ZSTD_e_flush)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('zstd compress error: %s' % _zstd_error(zresult)) raise ZstdError('zstd compress error: %s' % _zstd_error(zresult))
if self._out.pos: if self._out.pos:
yield ffi.buffer(self._out.dst, self._out.pos)[:] yield ffi.buffer(self._out.dst, self._out.pos)[:]
self._out.pos = 0 self._out.pos = 0
if not zresult: if not zresult:
return return
def finish(self): def finish(self):
if self._finished: if self._finished:
raise ZstdError('cannot call finish() after compression finished') raise ZstdError('cannot call finish() after compression finished')
if self._in.src != ffi.NULL: if self._in.src != ffi.NULL:
raise ZstdError('cannot call finish() before consuming output from ' raise ZstdError('cannot call finish() before consuming output from '
'previous operation') 'previous operation')
while True: while True:
zresult = lib.ZSTD_compress_generic(self._compressor._cctx, zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
self._out, self._in, self._out, self._in,
lib.ZSTD_e_end) lib.ZSTD_e_end)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('zstd compress error: %s' % _zstd_error(zresult)) raise ZstdError('zstd compress error: %s' % _zstd_error(zresult))
if self._out.pos: if self._out.pos:
yield ffi.buffer(self._out.dst, self._out.pos)[:] yield ffi.buffer(self._out.dst, self._out.pos)[:]
self._out.pos = 0 self._out.pos = 0
if not zresult: if not zresult:
self._finished = True self._finished = True
return return
class CompressionReader(object): class ZstdCompressionReader(object):
def __init__(self, compressor, source, read_size): def __init__(self, compressor, source, read_size):
self._compressor = compressor self._compressor = compressor
self._source = source self._source = source
self._read_size = read_size self._read_size = read_size
self._entered = False self._entered = False
self._closed = False self._closed = False
self._bytes_compressed = 0 self._bytes_compressed = 0
self._finished_input = False self._finished_input = False
@property @property
def closed(self): def closed(self):
return self._closed return self._closed
def tell(self): def tell(self):
return self._bytes_compressed return self._bytes_compressed
def readall(self): def readall(self):
raise NotImplementedError() chunks = []
while True:
chunk = self.read(1048576)
if not chunk:
break
chunks.append(chunk)
return b''.join(chunks)
def __iter__(self): def __iter__(self):
raise io.UnsupportedOperation() raise io.UnsupportedOperation()
def __next__(self): def __next__(self):
raise io.UnsupportedOperation() raise io.UnsupportedOperation()
next = __next__ next = __next__
def read(self, size=-1): def _read_input(self):
if self._closed: if self._finished_input:
raise ValueError('stream is closed') return
if self._finished_output: if hasattr(self._source, 'read'):
return b'' data = self._source.read(self._read_size)
if size < 1: if not data:
raise ValueError('cannot read negative or size 0 amounts') self._finished_input = True
return
# Need a dedicated ref to dest buffer otherwise it gets collected. self._source_buffer = ffi.from_buffer(data)
dst_buffer = ffi.new('char[]', size) self._in_buffer.src = self._source_buffer
out_buffer = ffi.new('ZSTD_outBuffer *') self._in_buffer.size = len(self._source_buffer)
out_buffer.dst = dst_buffer self._in_buffer.pos = 0
out_buffer.size = size else:
out_buffer.pos = 0 self._source_buffer = ffi.from_buffer(self._source)
self._in_buffer.src = self._source_buffer
self._in_buffer.size = len(self._source_buffer)
self._in_buffer.pos = 0
def compress_input(): def _compress_into_buffer(self, out_buffer):
if self._in_buffer.pos >= self._in_buffer.size: if self._in_buffer.pos >= self._in_buffer.size:
return return
old_pos = out_buffer.pos old_pos = out_buffer.pos
zresult = lib.ZSTD_compress_generic(self._compressor._cctx, zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
out_buffer, self._in_buffer, out_buffer, self._in_buffer,
lib.ZSTD_e_continue) lib.ZSTD_e_continue)
self._bytes_compressed += out_buffer.pos - old_pos self._bytes_compressed += out_buffer.pos - old_pos
if self._in_buffer.pos == self._in_buffer.size: if self._in_buffer.pos == self._in_buffer.size:
self._in_buffer.src = ffi.NULL self._in_buffer.src = ffi.NULL
self._in_buffer.pos = 0 self._in_buffer.pos = 0
self._in_buffer.size = 0 self._in_buffer.size = 0
self._source_buffer = None self._source_buffer = None
if not hasattr(self._source, 'read'): if not hasattr(self._source, 'read'):
self._finished_input = True self._finished_input = True
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('zstd compress error: %s', raise ZstdError('zstd compress error: %s',
_zstd_error(zresult)) _zstd_error(zresult))
if out_buffer.pos and out_buffer.pos == out_buffer.size: return out_buffer.pos and out_buffer.pos == out_buffer.size
return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
def get_input(): def read(self, size=-1):
if self._finished_input: if self._closed:
return raise ValueError('stream is closed')
if hasattr(self._source, 'read'): if size < -1:
data = self._source.read(self._read_size) raise ValueError('cannot read negative amounts less than -1')
if not data: if size == -1:
self._finished_input = True return self.readall()
return
self._source_buffer = ffi.from_buffer(data) if self._finished_output or size == 0:
self._in_buffer.src = self._source_buffer return b''
self._in_buffer.size = len(self._source_buffer)
self._in_buffer.pos = 0 # Need a dedicated ref to dest buffer otherwise it gets collected.
else: dst_buffer = ffi.new('char[]', size)
self._source_buffer = ffi.from_buffer(self._source) out_buffer = ffi.new('ZSTD_outBuffer *')
self._in_buffer.src = self._source_buffer out_buffer.dst = dst_buffer
self._in_buffer.size = len(self._source_buffer) out_buffer.size = size
self._in_buffer.pos = 0 out_buffer.pos = 0
result = compress_input() if self._compress_into_buffer(out_buffer):
if result: return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
return result
while not self._finished_input: while not self._finished_input:
get_input() self._read_input()
result = compress_input()
if result: if self._compress_into_buffer(out_buffer):
return result return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
# EOF # EOF
old_pos = out_buffer.pos old_pos = out_buffer.pos
zresult = lib.ZSTD_compress_generic(self._compressor._cctx, zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
out_buffer, self._in_buffer, out_buffer, self._in_buffer,
lib.ZSTD_e_end) lib.ZSTD_e_end)
self._bytes_compressed += out_buffer.pos - old_pos self._bytes_compressed += out_buffer.pos - old_pos
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('error ending compression stream: %s', raise ZstdError('error ending compression stream: %s',
_zstd_error(zresult)) _zstd_error(zresult))
if zresult == 0: if zresult == 0:
self._finished_output = True self._finished_output = True
return ffi.buffer(out_buffer.dst, out_buffer.pos)[:] return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
def read1(self, size=-1):
if self._closed:
raise ValueError('stream is closed')
if size < -1:
raise ValueError('cannot read negative amounts less than -1')
if self._finished_output or size == 0:
return b''
# -1 returns arbitrary number of bytes.
if size == -1:
size = COMPRESSION_RECOMMENDED_OUTPUT_SIZE
dst_buffer = ffi.new('char[]', size)
out_buffer = ffi.new('ZSTD_outBuffer *')
out_buffer.dst = dst_buffer
out_buffer.size = size
out_buffer.pos = 0
# read1() dictates that we can perform at most 1 call to the
# underlying stream to get input. However, we can't satisfy this
# restriction with compression because not all input generates output.
# It is possible to perform a block flush in order to ensure output.
# But this may not be desirable behavior. So we allow multiple read()
# to the underlying stream. But unlike read(), we stop once we have
# any output.
self._compress_into_buffer(out_buffer)
if out_buffer.pos:
return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
while not self._finished_input:
self._read_input()
# If we've filled the output buffer, return immediately.
if self._compress_into_buffer(out_buffer):
return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
# If we've populated the output buffer and we're not at EOF,
# also return, as we've satisfied the read1() limits.
if out_buffer.pos and not self._finished_input:
return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
# Else if we're at EOS and we have room left in the buffer,
# fall through to below and try to add more data to the output.
# EOF.
old_pos = out_buffer.pos
zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
out_buffer, self._in_buffer,
lib.ZSTD_e_end)
self._bytes_compressed += out_buffer.pos - old_pos
if lib.ZSTD_isError(zresult):
raise ZstdError('error ending compression stream: %s' %
_zstd_error(zresult))
if zresult == 0:
self._finished_output = True
return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
def readinto(self, b):
if self._closed:
raise ValueError('stream is closed')
if self._finished_output:
return 0
# TODO use writable=True once we require CFFI >= 1.12.
dest_buffer = ffi.from_buffer(b)
ffi.memmove(b, b'', 0)
out_buffer = ffi.new('ZSTD_outBuffer *')
out_buffer.dst = dest_buffer
out_buffer.size = len(dest_buffer)
out_buffer.pos = 0
if self._compress_into_buffer(out_buffer):
return out_buffer.pos
while not self._finished_input:
self._read_input()
if self._compress_into_buffer(out_buffer):
return out_buffer.pos
# EOF.
old_pos = out_buffer.pos
zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
out_buffer, self._in_buffer,
lib.ZSTD_e_end)
self._bytes_compressed += out_buffer.pos - old_pos
if lib.ZSTD_isError(zresult):
raise ZstdError('error ending compression stream: %s',
_zstd_error(zresult))
if zresult == 0:
self._finished_output = True
return out_buffer.pos
def readinto1(self, b):
if self._closed:
raise ValueError('stream is closed')
if self._finished_output:
return 0
# TODO use writable=True once we require CFFI >= 1.12.
dest_buffer = ffi.from_buffer(b)
ffi.memmove(b, b'', 0)
out_buffer = ffi.new('ZSTD_outBuffer *')
out_buffer.dst = dest_buffer
out_buffer.size = len(dest_buffer)
out_buffer.pos = 0
self._compress_into_buffer(out_buffer)
if out_buffer.pos:
return out_buffer.pos
while not self._finished_input:
self._read_input()
if self._compress_into_buffer(out_buffer):
return out_buffer.pos
if out_buffer.pos and not self._finished_input:
return out_buffer.pos
# EOF.
old_pos = out_buffer.pos
zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
out_buffer, self._in_buffer,
lib.ZSTD_e_end)
self._bytes_compressed += out_buffer.pos - old_pos
if lib.ZSTD_isError(zresult):
raise ZstdError('error ending compression stream: %s' %
_zstd_error(zresult))
if zresult == 0:
self._finished_output = True
return out_buffer.pos
class ZstdCompressor(object): class ZstdCompressor(object):
def __init__(self, level=3, dict_data=None, compression_params=None, def __init__(self, level=3, dict_data=None, compression_params=None,
write_checksum=None, write_content_size=None, write_checksum=None, write_content_size=None,
write_dict_id=None, threads=0): write_dict_id=None, threads=0):
if level > lib.ZSTD_maxCLevel(): if level > lib.ZSTD_maxCLevel():
raise ValueError('level must be less than %d' % lib.ZSTD_maxCLevel()) raise ValueError('level must be less than %d' % lib.ZSTD_maxCLevel())
if threads < 0: if threads < 0:
params = lib.ZSTD_createCCtxParams() params = lib.ZSTD_createCCtxParams()
if params == ffi.NULL: if params == ffi.NULL:
raise MemoryError() raise MemoryError()
self._params = ffi.gc(params, lib.ZSTD_freeCCtxParams) self._params = ffi.gc(params, lib.ZSTD_freeCCtxParams)
_set_compression_parameter(self._params, _set_compression_parameter(self._params,
lib.ZSTD_p_compressionLevel, lib.ZSTD_c_compressionLevel,
level) level)
_set_compression_parameter( _set_compression_parameter(
self._params, self._params,
lib.ZSTD_p_contentSizeFlag, lib.ZSTD_c_contentSizeFlag,
write_content_size if write_content_size is not None else 1) write_content_size if write_content_size is not None else 1)
_set_compression_parameter(self._params, _set_compression_parameter(self._params,
lib.ZSTD_p_checksumFlag, lib.ZSTD_c_checksumFlag,
1 if write_checksum else 0) 1 if write_checksum else 0)
_set_compression_parameter(self._params, _set_compression_parameter(self._params,
lib.ZSTD_p_dictIDFlag, lib.ZSTD_c_dictIDFlag,
1 if write_dict_id else 0) 1 if write_dict_id else 0)
if threads: if threads:
_set_compression_parameter(self._params, _set_compression_parameter(self._params,
lib.ZSTD_p_nbWorkers, lib.ZSTD_c_nbWorkers,
threads) threads)
cctx = lib.ZSTD_createCCtx() cctx = lib.ZSTD_createCCtx()
if cctx == ffi.NULL: if cctx == ffi.NULL:
raise MemoryError() raise MemoryError()
self._cctx = cctx self._cctx = cctx
self._dict_data = dict_data self._dict_data = dict_data
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('could not load compression dictionary: %s' % raise ZstdError('could not load compression dictionary: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
def memory_size(self): def memory_size(self):
return lib.ZSTD_sizeof_CCtx(self._cctx) return lib.ZSTD_sizeof_CCtx(self._cctx)
def compress(self, data): def compress(self, data):
lib.ZSTD_CCtx_reset(self._cctx) lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only)
data_buffer = ffi.from_buffer(data) data_buffer = ffi.from_buffer(data)
dest_size = lib.ZSTD_compressBound(len(data_buffer)) dest_size = lib.ZSTD_compressBound(len(data_buffer))
out = new_nonzero('char[]', dest_size) out = new_nonzero('char[]', dest_size)
zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, len(data_buffer)) zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, len(data_buffer))
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('error setting source size: %s' % raise ZstdError('error setting source size: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
out_buffer = ffi.new('ZSTD_outBuffer *') out_buffer = ffi.new('ZSTD_outBuffer *')
in_buffer = ffi.new('ZSTD_inBuffer *') in_buffer = ffi.new('ZSTD_inBuffer *')
out_buffer.dst = out out_buffer.dst = out
out_buffer.size = dest_size out_buffer.size = dest_size
out_buffer.pos = 0 out_buffer.pos = 0
in_buffer.src = data_buffer in_buffer.src = data_buffer
in_buffer.size = len(data_buffer) in_buffer.size = len(data_buffer)
in_buffer.pos = 0 in_buffer.pos = 0
zresult = lib.ZSTD_compress_generic(self._cctx, zresult = lib.ZSTD_compressStream2(self._cctx,
out_buffer, out_buffer,
in_buffer, in_buffer,
lib.ZSTD_e_end) lib.ZSTD_e_end)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('cannot compress: %s' % raise ZstdError('cannot compress: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
elif zresult: elif zresult:
raise ZstdError('unexpected partial frame flush') raise ZstdError('unexpected partial frame flush')
return ffi.buffer(out, out_buffer.pos)[:] return ffi.buffer(out, out_buffer.pos)[:]
def compressobj(self, size=-1): def compressobj(self, size=-1):
lib.ZSTD_CCtx_reset(self._cctx) lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only)
if size < 0: if size < 0:
size = lib.ZSTD_CONTENTSIZE_UNKNOWN size = lib.ZSTD_CONTENTSIZE_UNKNOWN
zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size) zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('error setting source size: %s' % raise ZstdError('error setting source size: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
cobj = ZstdCompressionObj() cobj = ZstdCompressionObj()
cobj._out = ffi.new('ZSTD_outBuffer *') cobj._out = ffi.new('ZSTD_outBuffer *')
cobj._dst_buffer = ffi.new('char[]', COMPRESSION_RECOMMENDED_OUTPUT_SIZE) cobj._dst_buffer = ffi.new('char[]', COMPRESSION_RECOMMENDED_OUTPUT_SIZE)
cobj._out.dst = cobj._dst_buffer cobj._out.dst = cobj._dst_buffer
cobj._out.size = COMPRESSION_RECOMMENDED_OUTPUT_SIZE cobj._out.size = COMPRESSION_RECOMMENDED_OUTPUT_SIZE
cobj._out.pos = 0 cobj._out.pos = 0
cobj._compressor = self cobj._compressor = self
cobj._finished = False cobj._finished = False
return cobj return cobj
def chunker(self, size=-1, chunk_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE): def chunker(self, size=-1, chunk_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE):
lib.ZSTD_CCtx_reset(self._cctx) lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only)
if size < 0: if size < 0:
size = lib.ZSTD_CONTENTSIZE_UNKNOWN size = lib.ZSTD_CONTENTSIZE_UNKNOWN
zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size) zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('error setting source size: %s' % raise ZstdError('error setting source size: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
return ZstdCompressionChunker(self, chunk_size=chunk_size) return ZstdCompressionChunker(self, chunk_size=chunk_size)
def copy_stream(self, ifh, ofh, size=-1, def copy_stream(self, ifh, ofh, size=-1,
read_size=COMPRESSION_RECOMMENDED_INPUT_SIZE, read_size=COMPRESSION_RECOMMENDED_INPUT_SIZE,
write_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE): write_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE):
if not hasattr(ifh, 'read'): if not hasattr(ifh, 'read'):
raise ValueError('first argument must have a read() method') raise ValueError('first argument must have a read() method')
if not hasattr(ofh, 'write'): if not hasattr(ofh, 'write'):
raise ValueError('second argument must have a write() method') raise ValueError('second argument must have a write() method')
lib.ZSTD_CCtx_reset(self._cctx) lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only)
if size < 0: if size < 0:
size = lib.ZSTD_CONTENTSIZE_UNKNOWN size = lib.ZSTD_CONTENTSIZE_UNKNOWN
zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size) zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('error setting source size: %s' % raise ZstdError('error setting source size: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
data_buffer = ffi.from_buffer(data) data_buffer = ffi.from_buffer(data)
total_read += len(data_buffer) total_read += len(data_buffer)
in_buffer.src = data_buffer in_buffer.src = data_buffer
in_buffer.size = len(data_buffer) in_buffer.size = len(data_buffer)
in_buffer.pos = 0 in_buffer.pos = 0
while in_buffer.pos < in_buffer.size: while in_buffer.pos < in_buffer.size:
zresult = lib.ZSTD_compress_generic(self._cctx, zresult = lib.ZSTD_compressStream2(self._cctx,
out_buffer, out_buffer,
in_buffer, in_buffer,
lib.ZSTD_e_continue) lib.ZSTD_e_continue)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('zstd compress error: %s' % raise ZstdError('zstd compress error: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
if out_buffer.pos: if out_buffer.pos:
ofh.write(ffi.buffer(out_buffer.dst, out_buffer.pos)) ofh.write(ffi.buffer(out_buffer.dst, out_buffer.pos))
total_write += out_buffer.pos total_write += out_buffer.pos
out_buffer.pos = 0 out_buffer.pos = 0
# We've finished reading. Flush the compressor. # We've finished reading. Flush the compressor.
while True: while True:
zresult = lib.ZSTD_compress_generic(self._cctx, zresult = lib.ZSTD_compressStream2(self._cctx,
out_buffer, out_buffer,
in_buffer, in_buffer,
lib.ZSTD_e_end) lib.ZSTD_e_end)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('error ending compression stream: %s' % raise ZstdError('error ending compression stream: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
if out_buffer.pos: if out_buffer.pos:
ofh.write(ffi.buffer(out_buffer.dst, out_buffer.pos)) ofh.write(ffi.buffer(out_buffer.dst, out_buffer.pos))
total_write += out_buffer.pos total_write += out_buffer.pos
out_buffer.pos = 0 out_buffer.pos = 0
if zresult == 0: if zresult == 0:
break break
return total_read, total_write return total_read, total_write
def stream_reader(self, source, size=-1, def stream_reader(self, source, size=-1,
read_size=COMPRESSION_RECOMMENDED_INPUT_SIZE): read_size=COMPRESSION_RECOMMENDED_INPUT_SIZE):
lib.ZSTD_CCtx_reset(self._cctx) lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only)
try: try:
size = len(source) size = len(source)
except Exception: except Exception:
pass pass
if size < 0: if size < 0:
size = lib.ZSTD_CONTENTSIZE_UNKNOWN size = lib.ZSTD_CONTENTSIZE_UNKNOWN
zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size) zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('error setting source size: %s' % raise ZstdError('error setting source size: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
return CompressionReader(self, source, read_size) return ZstdCompressionReader(self, source, read_size)
def stream_writer(self, writer, size=-1, def stream_writer(self, writer, size=-1,
write_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE): write_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE,
write_return_read=False):
if not hasattr(writer, 'write'): if not hasattr(writer, 'write'):
raise ValueError('must pass an object with a write() method') raise ValueError('must pass an object with a write() method')
lib.ZSTD_CCtx_reset(self._cctx) lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only)
if size < 0: if size < 0:
size = lib.ZSTD_CONTENTSIZE_UNKNOWN size = lib.ZSTD_CONTENTSIZE_UNKNOWN
return ZstdCompressionWriter(self, writer, size, write_size) return ZstdCompressionWriter(self, writer, size, write_size,
write_return_read)
write_to = stream_writer write_to = stream_writer
def read_to_iter(self, reader, size=-1, def read_to_iter(self, reader, size=-1,
read_size=COMPRESSION_RECOMMENDED_INPUT_SIZE, read_size=COMPRESSION_RECOMMENDED_INPUT_SIZE,
write_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE): write_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE):
if hasattr(reader, 'read'): if hasattr(reader, 'read'):
have_read = True have_read = True
elif hasattr(reader, '__getitem__'): elif hasattr(reader, '__getitem__'):
have_read = False have_read = False
buffer_offset = 0 buffer_offset = 0
size = len(reader) size = len(reader)
else: else:
raise ValueError('must pass an object with a read() method or ' raise ValueError('must pass an object with a read() method or '
'conforms to buffer protocol') 'conforms to buffer protocol')
lib.ZSTD_CCtx_reset(self._cctx) lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only)
if size < 0: if size < 0:
size = lib.ZSTD_CONTENTSIZE_UNKNOWN size = lib.ZSTD_CONTENTSIZE_UNKNOWN
zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size) zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('error setting source size: %s' % raise ZstdError('error setting source size: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
# Feed all read data into the compressor and emit output until # Feed all read data into the compressor and emit output until
# exhausted. # exhausted.
read_buffer = ffi.from_buffer(read_result) read_buffer = ffi.from_buffer(read_result)
in_buffer.src = read_buffer in_buffer.src = read_buffer
in_buffer.size = len(read_buffer) in_buffer.size = len(read_buffer)
in_buffer.pos = 0 in_buffer.pos = 0
while in_buffer.pos < in_buffer.size: while in_buffer.pos < in_buffer.size:
zresult = lib.ZSTD_compress_generic(self._cctx, out_buffer, in_buffer, zresult = lib.ZSTD_compressStream2(self._cctx, out_buffer, in_buffer,
lib.ZSTD_e_continue) lib.ZSTD_e_continue)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('zstd compress error: %s' % raise ZstdError('zstd compress error: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
if out_buffer.pos: if out_buffer.pos:
data = ffi.buffer(out_buffer.dst, out_buffer.pos)[:] data = ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
out_buffer.pos = 0 out_buffer.pos = 0
yield data yield data
assert out_buffer.pos == 0 assert out_buffer.pos == 0
# And repeat the loop to collect more data. # And repeat the loop to collect more data.
continue continue
# If we get here, input is exhausted. End the stream and emit what # If we get here, input is exhausted. End the stream and emit what
# remains. # remains.
while True: while True:
assert out_buffer.pos == 0 assert out_buffer.pos == 0
zresult = lib.ZSTD_compress_generic(self._cctx, zresult = lib.ZSTD_compressStream2(self._cctx,
out_buffer, out_buffer,
in_buffer, in_buffer,
lib.ZSTD_e_end) lib.ZSTD_e_end)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('error ending compression stream: %s' % raise ZstdError('error ending compression stream: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
if out_buffer.pos: if out_buffer.pos:
data = ffi.buffer(out_buffer.dst, out_buffer.pos)[:] data = ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
out_buffer.pos = 0 out_buffer.pos = 0
yield data yield data
raise ValueError('must specify one of level or compression_params') raise ValueError('must specify one of level or compression_params')
if level: if level:
cparams = lib.ZSTD_getCParams(level, 0, len(self._data)) cparams = lib.ZSTD_getCParams(level, 0, len(self._data))
else: else:
cparams = ffi.new('ZSTD_compressionParameters') cparams = ffi.new('ZSTD_compressionParameters')
cparams.chainLog = compression_params.chain_log cparams.chainLog = compression_params.chain_log
cparams.hashLog = compression_params.hash_log cparams.hashLog = compression_params.hash_log
cparams.searchLength = compression_params.min_match cparams.minMatch = compression_params.min_match
cparams.searchLog = compression_params.search_log cparams.searchLog = compression_params.search_log
cparams.strategy = compression_params.compression_strategy cparams.strategy = compression_params.compression_strategy
cparams.targetLength = compression_params.target_length cparams.targetLength = compression_params.target_length
cparams.windowLog = compression_params.window_log cparams.windowLog = compression_params.window_log
cdict = lib.ZSTD_createCDict_advanced(self._data, len(self._data), cdict = lib.ZSTD_createCDict_advanced(self._data, len(self._data),
lib.ZSTD_dlm_byRef, lib.ZSTD_dlm_byRef,
self._dict_type, self._dict_type,
def decompress(self, data): def decompress(self, data):
if self._finished: if self._finished:
raise ZstdError('cannot use a decompressobj multiple times') raise ZstdError('cannot use a decompressobj multiple times')
in_buffer = ffi.new('ZSTD_inBuffer *') in_buffer = ffi.new('ZSTD_inBuffer *')
out_buffer = ffi.new('ZSTD_outBuffer *') out_buffer = ffi.new('ZSTD_outBuffer *')
data_buffer = ffi.from_buffer(data) data_buffer = ffi.from_buffer(data)
if len(data_buffer) == 0:
return b''
in_buffer.src = data_buffer in_buffer.src = data_buffer
in_buffer.size = len(data_buffer) in_buffer.size = len(data_buffer)
in_buffer.pos = 0 in_buffer.pos = 0
dst_buffer = ffi.new('char[]', self._write_size) dst_buffer = ffi.new('char[]', self._write_size)
out_buffer.dst = dst_buffer out_buffer.dst = dst_buffer
out_buffer.size = len(dst_buffer) out_buffer.size = len(dst_buffer)
out_buffer.pos = 0 out_buffer.pos = 0
chunks = [] chunks = []
while True: while True:
zresult = lib.ZSTD_decompress_generic(self._decompressor._dctx, zresult = lib.ZSTD_decompressStream(self._decompressor._dctx,
out_buffer, in_buffer) out_buffer, in_buffer)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('zstd decompressor error: %s' % raise ZstdError('zstd decompressor error: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
if zresult == 0: if zresult == 0:
self._finished = True self._finished = True
self._decompressor = None self._decompressor = None
if out_buffer.pos: if out_buffer.pos:
chunks.append(ffi.buffer(out_buffer.dst, out_buffer.pos)[:]) chunks.append(ffi.buffer(out_buffer.dst, out_buffer.pos)[:])
if (zresult == 0 or if (zresult == 0 or
(in_buffer.pos == in_buffer.size and out_buffer.pos == 0)): (in_buffer.pos == in_buffer.size and out_buffer.pos == 0)):
break break
out_buffer.pos = 0 out_buffer.pos = 0
return b''.join(chunks) return b''.join(chunks)
def flush(self, length=0):
pass
class DecompressionReader(object): class ZstdDecompressionReader(object):
def __init__(self, decompressor, source, read_size): def __init__(self, decompressor, source, read_size, read_across_frames):
self._decompressor = decompressor self._decompressor = decompressor
self._source = source self._source = source
self._read_size = read_size self._read_size = read_size
self._read_across_frames = bool(read_across_frames)
self._entered = False self._entered = False
self._closed = False self._closed = False
self._bytes_decompressed = 0 self._bytes_decompressed = 0
self._finished_input = False self._finished_input = False
self._finished_output = False self._finished_output = False
self._in_buffer = ffi.new('ZSTD_inBuffer *') self._in_buffer = ffi.new('ZSTD_inBuffer *')
# Holds a ref to self._in_buffer.src. # Holds a ref to self._in_buffer.src.
self._source_buffer = None self._source_buffer = None
def writable(self): def writable(self):
return False return False
def seekable(self): def seekable(self):
return True return True
def readline(self): def readline(self):
raise NotImplementedError() raise io.UnsupportedOperation()
def readlines(self): def readlines(self):
raise NotImplementedError() raise io.UnsupportedOperation()
def write(self, data): def write(self, data):
raise io.UnsupportedOperation() raise io.UnsupportedOperation()
def writelines(self, lines): def writelines(self, lines):
raise io.UnsupportedOperation() raise io.UnsupportedOperation()
def isatty(self): def isatty(self):
@property @property
def closed(self): def closed(self):
return self._closed return self._closed
def tell(self): def tell(self):
return self._bytes_decompressed return self._bytes_decompressed
def readall(self): def readall(self):
raise NotImplementedError() chunks = []
while True:
chunk = self.read(1048576)
if not chunk:
break
chunks.append(chunk)
return b''.join(chunks)
def __iter__(self): def __iter__(self):
raise NotImplementedError() raise io.UnsupportedOperation()
def __next__(self): def __next__(self):
raise NotImplementedError() raise io.UnsupportedOperation()
next = __next__ next = __next__
def read(self, size): def _read_input(self):
if self._closed: # We have data left over in the input buffer. Use it.
raise ValueError('stream is closed') if self._in_buffer.pos < self._in_buffer.size:
return
if self._finished_output: # All input data exhausted. Nothing to do.
return b'' if self._finished_input:
return
if size < 1: # Else populate the input buffer from our source.
raise ValueError('cannot read negative or size 0 amounts') if hasattr(self._source, 'read'):
data = self._source.read(self._read_size)
dst_buffer = ffi.new('char[]', size) if not data:
out_buffer = ffi.new('ZSTD_outBuffer *') self._finished_input = True
out_buffer.dst = dst_buffer return
out_buffer.size = size
out_buffer.pos = 0 self._source_buffer = ffi.from_buffer(data)
self._in_buffer.src = self._source_buffer
self._in_buffer.size = len(self._source_buffer)
self._in_buffer.pos = 0
else:
self._source_buffer = ffi.from_buffer(self._source)
self._in_buffer.src = self._source_buffer
self._in_buffer.size = len(self._source_buffer)
self._in_buffer.pos = 0
def decompress(): def _decompress_into_buffer(self, out_buffer):
zresult = lib.ZSTD_decompress_generic(self._decompressor._dctx, """Decompress available input into an output buffer.
Returns True if data in output buffer should be emitted.
"""
zresult = lib.ZSTD_decompressStream(self._decompressor._dctx,
out_buffer, self._in_buffer) out_buffer, self._in_buffer)
if self._in_buffer.pos == self._in_buffer.size: if self._in_buffer.pos == self._in_buffer.size:
self._in_buffer.src = ffi.NULL self._in_buffer.src = ffi.NULL
self._in_buffer.pos = 0 self._in_buffer.pos = 0
self._in_buffer.size = 0 self._in_buffer.size = 0
self._source_buffer = None self._source_buffer = None
if not hasattr(self._source, 'read'): if not hasattr(self._source, 'read'):
self._finished_input = True self._finished_input = True
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('zstd decompress error: %s', raise ZstdError('zstd decompress error: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
elif zresult == 0:
self._finished_output = True
if out_buffer.pos and out_buffer.pos == out_buffer.size: # Emit data if there is data AND either:
self._bytes_decompressed += out_buffer.size # a) output buffer is full (read amount is satisfied)
# b) we're at end of a frame and not in frame spanning mode
return (out_buffer.pos and
(out_buffer.pos == out_buffer.size or
zresult == 0 and not self._read_across_frames))
def read(self, size=-1):
if self._closed:
raise ValueError('stream is closed')
if size < -1:
raise ValueError('cannot read negative amounts less than -1')
if size == -1:
# This is recursive. But it gets the job done.
return self.readall()
if self._finished_output or size == 0:
return b''
# We /could/ call into readinto() here. But that introduces more
# overhead.
dst_buffer = ffi.new('char[]', size)
out_buffer = ffi.new('ZSTD_outBuffer *')
out_buffer.dst = dst_buffer
out_buffer.size = size
out_buffer.pos = 0
self._read_input()
if self._decompress_into_buffer(out_buffer):
self._bytes_decompressed += out_buffer.pos
return ffi.buffer(out_buffer.dst, out_buffer.pos)[:] return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
def get_input(): while not self._finished_input:
if self._finished_input: self._read_input()
return if self._decompress_into_buffer(out_buffer):
self._bytes_decompressed += out_buffer.pos
return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
if hasattr(self._source, 'read'): self._bytes_decompressed += out_buffer.pos
data = self._source.read(self._read_size) return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
if not data: def readinto(self, b):
self._finished_input = True if self._closed:
return raise ValueError('stream is closed')
self._source_buffer = ffi.from_buffer(data) if self._finished_output:
self._in_buffer.src = self._source_buffer return 0
self._in_buffer.size = len(self._source_buffer)
self._in_buffer.pos = 0 # TODO use writable=True once we require CFFI >= 1.12.
else: dest_buffer = ffi.from_buffer(b)
self._source_buffer = ffi.from_buffer(self._source) ffi.memmove(b, b'', 0)
self._in_buffer.src = self._source_buffer out_buffer = ffi.new('ZSTD_outBuffer *')
self._in_buffer.size = len(self._source_buffer) out_buffer.dst = dest_buffer
self._in_buffer.pos = 0 out_buffer.size = len(dest_buffer)
out_buffer.pos = 0
self._read_input()
if self._decompress_into_buffer(out_buffer):
self._bytes_decompressed += out_buffer.pos
return out_buffer.pos
while not self._finished_input:
self._read_input()
if self._decompress_into_buffer(out_buffer):
self._bytes_decompressed += out_buffer.pos
return out_buffer.pos
self._bytes_decompressed += out_buffer.pos
return out_buffer.pos
get_input() def read1(self, size=-1):
result = decompress() if self._closed:
if result: raise ValueError('stream is closed')
return result
if size < -1:
raise ValueError('cannot read negative amounts less than -1')
if self._finished_output or size == 0:
return b''
# -1 returns arbitrary number of bytes.
if size == -1:
size = DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE
dst_buffer = ffi.new('char[]', size)
out_buffer = ffi.new('ZSTD_outBuffer *')
out_buffer.dst = dst_buffer
out_buffer.size = size
out_buffer.pos = 0
# read1() dictates that we can perform at most 1 call to underlying
# stream to get input. However, we can't satisfy this restriction with
# decompression because not all input generates output. So we allow
# multiple read(). But unlike read(), we stop once we have any output.
while not self._finished_input: while not self._finished_input:
get_input() self._read_input()
result = decompress() self._decompress_into_buffer(out_buffer)
if result:
return result if out_buffer.pos:
break
self._bytes_decompressed += out_buffer.pos self._bytes_decompressed += out_buffer.pos
return ffi.buffer(out_buffer.dst, out_buffer.pos)[:] return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
def readinto1(self, b):
if self._closed:
raise ValueError('stream is closed')
if self._finished_output:
return 0
# TODO use writable=True once we require CFFI >= 1.12.
dest_buffer = ffi.from_buffer(b)
ffi.memmove(b, b'', 0)
out_buffer = ffi.new('ZSTD_outBuffer *')
out_buffer.dst = dest_buffer
out_buffer.size = len(dest_buffer)
out_buffer.pos = 0
while not self._finished_input and not self._finished_output:
self._read_input()
self._decompress_into_buffer(out_buffer)
if out_buffer.pos:
break
self._bytes_decompressed += out_buffer.pos
return out_buffer.pos
def seek(self, pos, whence=os.SEEK_SET): def seek(self, pos, whence=os.SEEK_SET):
if self._closed: if self._closed:
raise ValueError('stream is closed') raise ValueError('stream is closed')
read_amount = 0 read_amount = 0
if whence == os.SEEK_SET: if whence == os.SEEK_SET:
if pos < 0: if pos < 0:
if not result: if not result:
break break
read_amount -= len(result) read_amount -= len(result)
return self._bytes_decompressed return self._bytes_decompressed
class ZstdDecompressionWriter(object): class ZstdDecompressionWriter(object):
def __init__(self, decompressor, writer, write_size): def __init__(self, decompressor, writer, write_size, write_return_read):
decompressor._ensure_dctx()
self._decompressor = decompressor self._decompressor = decompressor
self._writer = writer self._writer = writer
self._write_size = write_size self._write_size = write_size
self._write_return_read = bool(write_return_read)
self._entered = False self._entered = False
self._closed = False
def __enter__(self): def __enter__(self):
if self._closed:
raise ValueError('stream is closed')
if self._entered: if self._entered:
raise ZstdError('cannot __enter__ multiple times') raise ZstdError('cannot __enter__ multiple times')
self._decompressor._ensure_dctx()
self._entered = True self._entered = True
return self return self
def __exit__(self, exc_type, exc_value, exc_tb): def __exit__(self, exc_type, exc_value, exc_tb):
self._entered = False self._entered = False
self.close()
def memory_size(self): def memory_size(self):
if not self._decompressor._dctx:
raise ZstdError('cannot determine size of inactive decompressor '
'call when context manager is active')
return lib.ZSTD_sizeof_DCtx(self._decompressor._dctx) return lib.ZSTD_sizeof_DCtx(self._decompressor._dctx)
def close(self):
if self._closed:
return
try:
self.flush()
finally:
self._closed = True
f = getattr(self._writer, 'close', None)
if f:
f()
@property
def closed(self):
return self._closed
def fileno(self):
f = getattr(self._writer, 'fileno', None)
if f:
return f()
else:
raise OSError('fileno not available on underlying writer')
def flush(self):
if self._closed:
raise ValueError('stream is closed')
f = getattr(self._writer, 'flush', None)
if f:
return f()
def isatty(self):
return False
def readable(self):
return False
def readline(self, size=-1):
raise io.UnsupportedOperation()
def readlines(self, hint=-1):
raise io.UnsupportedOperation()
def seek(self, offset, whence=None):
raise io.UnsupportedOperation()
def seekable(self):
return False
def tell(self):
raise io.UnsupportedOperation()
def truncate(self, size=None):
raise io.UnsupportedOperation()
def writable(self):
return True
def writelines(self, lines):
raise io.UnsupportedOperation()
def read(self, size=-1):
raise io.UnsupportedOperation()
def readall(self):
raise io.UnsupportedOperation()
def readinto(self, b):
raise io.UnsupportedOperation()
def write(self, data): def write(self, data):
if not self._entered: if self._closed:
raise ZstdError('write must be called from an active context manager') raise ValueError('stream is closed')
total_write = 0 total_write = 0
in_buffer = ffi.new('ZSTD_inBuffer *') in_buffer = ffi.new('ZSTD_inBuffer *')
out_buffer = ffi.new('ZSTD_outBuffer *') out_buffer = ffi.new('ZSTD_outBuffer *')
data_buffer = ffi.from_buffer(data) data_buffer = ffi.from_buffer(data)
in_buffer.src = data_buffer in_buffer.src = data_buffer
in_buffer.size = len(data_buffer) in_buffer.size = len(data_buffer)
in_buffer.pos = 0 in_buffer.pos = 0
dst_buffer = ffi.new('char[]', self._write_size) dst_buffer = ffi.new('char[]', self._write_size)
out_buffer.dst = dst_buffer out_buffer.dst = dst_buffer
out_buffer.size = len(dst_buffer) out_buffer.size = len(dst_buffer)
out_buffer.pos = 0 out_buffer.pos = 0
dctx = self._decompressor._dctx dctx = self._decompressor._dctx
while in_buffer.pos < in_buffer.size: while in_buffer.pos < in_buffer.size:
zresult = lib.ZSTD_decompress_generic(dctx, out_buffer, in_buffer) zresult = lib.ZSTD_decompressStream(dctx, out_buffer, in_buffer)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('zstd decompress error: %s' % raise ZstdError('zstd decompress error: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
if out_buffer.pos: if out_buffer.pos:
self._writer.write(ffi.buffer(out_buffer.dst, out_buffer.pos)[:]) self._writer.write(ffi.buffer(out_buffer.dst, out_buffer.pos)[:])
total_write += out_buffer.pos total_write += out_buffer.pos
out_buffer.pos = 0 out_buffer.pos = 0
if self._write_return_read:
return in_buffer.pos
else:
return total_write return total_write
class ZstdDecompressor(object): class ZstdDecompressor(object):
def __init__(self, dict_data=None, max_window_size=0, format=FORMAT_ZSTD1): def __init__(self, dict_data=None, max_window_size=0, format=FORMAT_ZSTD1):
self._dict_data = dict_data self._dict_data = dict_data
self._max_window_size = max_window_size self._max_window_size = max_window_size
self._format = format self._format = format
out_buffer.size = result_size out_buffer.size = result_size
out_buffer.pos = 0 out_buffer.pos = 0
in_buffer = ffi.new('ZSTD_inBuffer *') in_buffer = ffi.new('ZSTD_inBuffer *')
in_buffer.src = data_buffer in_buffer.src = data_buffer
in_buffer.size = len(data_buffer) in_buffer.size = len(data_buffer)
in_buffer.pos = 0 in_buffer.pos = 0
zresult = lib.ZSTD_decompress_generic(self._dctx, out_buffer, in_buffer) zresult = lib.ZSTD_decompressStream(self._dctx, out_buffer, in_buffer)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('decompression error: %s' % raise ZstdError('decompression error: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
elif zresult: elif zresult:
raise ZstdError('decompression error: did not decompress full frame') raise ZstdError('decompression error: did not decompress full frame')
elif output_size and out_buffer.pos != output_size: elif output_size and out_buffer.pos != output_size:
raise ZstdError('decompression error: decompressed %d bytes; expected %d' % raise ZstdError('decompression error: decompressed %d bytes; expected %d' %
(zresult, output_size)) (zresult, output_size))
return ffi.buffer(result_buffer, out_buffer.pos)[:] return ffi.buffer(result_buffer, out_buffer.pos)[:]
def stream_reader(self, source, read_size=DECOMPRESSION_RECOMMENDED_INPUT_SIZE): def stream_reader(self, source, read_size=DECOMPRESSION_RECOMMENDED_INPUT_SIZE,
read_across_frames=False):
self._ensure_dctx() self._ensure_dctx()
return DecompressionReader(self, source, read_size) return ZstdDecompressionReader(self, source, read_size, read_across_frames)
def decompressobj(self, write_size=DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE): def decompressobj(self, write_size=DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE):
if write_size < 1: if write_size < 1:
raise ValueError('write_size must be positive') raise ValueError('write_size must be positive')
self._ensure_dctx() self._ensure_dctx()
return ZstdDecompressionObj(self, write_size=write_size) return ZstdDecompressionObj(self, write_size=write_size)
read_buffer = ffi.from_buffer(read_result) read_buffer = ffi.from_buffer(read_result)
in_buffer.src = read_buffer in_buffer.src = read_buffer
in_buffer.size = len(read_buffer) in_buffer.size = len(read_buffer)
in_buffer.pos = 0 in_buffer.pos = 0
while in_buffer.pos < in_buffer.size: while in_buffer.pos < in_buffer.size:
assert out_buffer.pos == 0 assert out_buffer.pos == 0
zresult = lib.ZSTD_decompress_generic(self._dctx, out_buffer, in_buffer) zresult = lib.ZSTD_decompressStream(self._dctx, out_buffer, in_buffer)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('zstd decompress error: %s' % raise ZstdError('zstd decompress error: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
if out_buffer.pos: if out_buffer.pos:
data = ffi.buffer(out_buffer.dst, out_buffer.pos)[:] data = ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
out_buffer.pos = 0 out_buffer.pos = 0
yield data yield data
if zresult == 0: if zresult == 0:
return return
# Repeat loop to collect more input data. # Repeat loop to collect more input data.
continue continue
# If we get here, input is exhausted. # If we get here, input is exhausted.
read_from = read_to_iter read_from = read_to_iter
def stream_writer(self, writer, write_size=DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE): def stream_writer(self, writer, write_size=DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE,
write_return_read=False):
if not hasattr(writer, 'write'): if not hasattr(writer, 'write'):
raise ValueError('must pass an object with a write() method') raise ValueError('must pass an object with a write() method')
return ZstdDecompressionWriter(self, writer, write_size) return ZstdDecompressionWriter(self, writer, write_size,
write_return_read)
write_to = stream_writer write_to = stream_writer
def copy_stream(self, ifh, ofh, def copy_stream(self, ifh, ofh,
read_size=DECOMPRESSION_RECOMMENDED_INPUT_SIZE, read_size=DECOMPRESSION_RECOMMENDED_INPUT_SIZE,
write_size=DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE): write_size=DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE):
if not hasattr(ifh, 'read'): if not hasattr(ifh, 'read'):
raise ValueError('first argument must have a read() method') raise ValueError('first argument must have a read() method')
data_buffer = ffi.from_buffer(data) data_buffer = ffi.from_buffer(data)
total_read += len(data_buffer) total_read += len(data_buffer)
in_buffer.src = data_buffer in_buffer.src = data_buffer
in_buffer.size = len(data_buffer) in_buffer.size = len(data_buffer)
in_buffer.pos = 0 in_buffer.pos = 0
# Flush all read data to output. # Flush all read data to output.
while in_buffer.pos < in_buffer.size: while in_buffer.pos < in_buffer.size:
zresult = lib.ZSTD_decompress_generic(self._dctx, out_buffer, in_buffer) zresult = lib.ZSTD_decompressStream(self._dctx, out_buffer, in_buffer)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('zstd decompressor error: %s' % raise ZstdError('zstd decompressor error: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
if out_buffer.pos: if out_buffer.pos:
ofh.write(ffi.buffer(out_buffer.dst, out_buffer.pos)) ofh.write(ffi.buffer(out_buffer.dst, out_buffer.pos))
total_write += out_buffer.pos total_write += out_buffer.pos
out_buffer.pos = 0 out_buffer.pos = 0
out_buffer.size = len(last_buffer) out_buffer.size = len(last_buffer)
out_buffer.pos = 0 out_buffer.pos = 0
in_buffer = ffi.new('ZSTD_inBuffer *') in_buffer = ffi.new('ZSTD_inBuffer *')
in_buffer.src = chunk_buffer in_buffer.src = chunk_buffer
in_buffer.size = len(chunk_buffer) in_buffer.size = len(chunk_buffer)
in_buffer.pos = 0 in_buffer.pos = 0
zresult = lib.ZSTD_decompress_generic(self._dctx, out_buffer, in_buffer) zresult = lib.ZSTD_decompressStream(self._dctx, out_buffer, in_buffer)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('could not decompress chunk 0: %s' % raise ZstdError('could not decompress chunk 0: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
elif zresult: elif zresult:
raise ZstdError('chunk 0 did not decompress full frame') raise ZstdError('chunk 0 did not decompress full frame')
# Special case of chain length of 1 # Special case of chain length of 1
if len(frames) == 1: if len(frames) == 1:
out_buffer.dst = dest_buffer out_buffer.dst = dest_buffer
out_buffer.size = len(dest_buffer) out_buffer.size = len(dest_buffer)
out_buffer.pos = 0 out_buffer.pos = 0
in_buffer.src = chunk_buffer in_buffer.src = chunk_buffer
in_buffer.size = len(chunk_buffer) in_buffer.size = len(chunk_buffer)
in_buffer.pos = 0 in_buffer.pos = 0
zresult = lib.ZSTD_decompress_generic(self._dctx, out_buffer, in_buffer) zresult = lib.ZSTD_decompressStream(self._dctx, out_buffer, in_buffer)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('could not decompress chunk %d: %s' % raise ZstdError('could not decompress chunk %d: %s' %
_zstd_error(zresult)) _zstd_error(zresult))
elif zresult: elif zresult:
raise ZstdError('chunk %d did not decompress full frame' % i) raise ZstdError('chunk %d did not decompress full frame' % i)
last_buffer = dest_buffer last_buffer = dest_buffer
i += 1 i += 1
return ffi.buffer(last_buffer, len(last_buffer))[:] return ffi.buffer(last_buffer, len(last_buffer))[:]
def _ensure_dctx(self, load_dict=True): def _ensure_dctx(self, load_dict=True):
lib.ZSTD_DCtx_reset(self._dctx) lib.ZSTD_DCtx_reset(self._dctx, lib.ZSTD_reset_session_only)
if self._max_window_size: if self._max_window_size:
zresult = lib.ZSTD_DCtx_setMaxWindowSize(self._dctx, zresult = lib.ZSTD_DCtx_setMaxWindowSize(self._dctx,
self._max_window_size) self._max_window_size)
if lib.ZSTD_isError(zresult): if lib.ZSTD_isError(zresult):
raise ZstdError('unable to set max window size: %s' % raise ZstdError('unable to set max window size: %s' %
_zstd_error(zresult)) _zstd_error(zresult))

contrib/python-zstandard/zstd.c

However, downstream redistributors or packagers may unbundle zstd However, downstream redistributors or packagers may unbundle zstd
from python-zstandard. This can result in a mismatch between zstd from python-zstandard. This can result in a mismatch between zstd
versions and API semantics. This essentially "voids the warranty" versions and API semantics. This essentially "voids the warranty"
of python-zstandard and may cause undefined behavior. of python-zstandard and may cause undefined behavior.
We detect this mismatch here and refuse to load the module if this We detect this mismatch here and refuse to load the module if this
scenario is detected. scenario is detected.
*/ */
if (ZSTD_VERSION_NUMBER != 10306 || ZSTD_versionNumber() != 10306) { if (ZSTD_VERSION_NUMBER != 10308 || ZSTD_versionNumber() != 10308) {
PyErr_SetString(PyExc_ImportError, "zstd C API mismatch; Python bindings not compiled against expected zstd version"); PyErr_SetString(PyExc_ImportError, "zstd C API mismatch; Python bindings not compiled against expected zstd version");
return; return;
} }
bufferutil_module_init(m); bufferutil_module_init(m);
compressionparams_module_init(m); compressionparams_module_init(m);
compressiondict_module_init(m); compressiondict_module_init(m);
compressobj_module_init(m); compressobj_module_init(m);
memcpy(PyBytes_AS_STRING(tmp), PyBytes_AS_STRING(*obj), memcpy(PyBytes_AS_STRING(tmp), PyBytes_AS_STRING(*obj),
PyBytes_GET_SIZE(*obj)); PyBytes_GET_SIZE(*obj));
Py_DECREF(*obj); Py_DECREF(*obj);
*obj = tmp; *obj = tmp;
return 0; return 0;
} }
No newline at end of file No newline at end of file

contrib/python-zstandard/zstd/common/bitstream.h

MEM_STATIC size_t BIT_getUpperBits(size_t bitContainer, U32 const start) MEM_STATIC size_t BIT_getUpperBits(size_t bitContainer, U32 const start)
{ {
return bitContainer >> start; return bitContainer >> start;
} }
MEM_STATIC size_t BIT_getMiddleBits(size_t bitContainer, U32 const start, U32 const nbBits) MEM_STATIC size_t BIT_getMiddleBits(size_t bitContainer, U32 const start, U32 const nbBits)
{ {
#if defined(__BMI__) && defined(__GNUC__) && __GNUC__*1000+__GNUC_MINOR__ >= 4008 /* experimental */ U32 const regMask = sizeof(bitContainer)*8 - 1;
# if defined(__x86_64__) /* if start > regMask, bitstream is corrupted, and result is undefined */
if (sizeof(bitContainer)==8)
return _bextr_u64(bitContainer, start, nbBits);
else
# endif
return _bextr_u32(bitContainer, start, nbBits);
#else
assert(nbBits < BIT_MASK_SIZE); assert(nbBits < BIT_MASK_SIZE);
return (bitContainer >> start) & BIT_mask[nbBits]; return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
#endif
} }
MEM_STATIC size_t BIT_getLowerBits(size_t bitContainer, U32 const nbBits) MEM_STATIC size_t BIT_getLowerBits(size_t bitContainer, U32 const nbBits)
{ {
assert(nbBits < BIT_MASK_SIZE); assert(nbBits < BIT_MASK_SIZE);
return bitContainer & BIT_mask[nbBits]; return bitContainer & BIT_mask[nbBits];
} }
/*! BIT_lookBits() : /*! BIT_lookBits() :
* Provides next n bits from local register. * Provides next n bits from local register.
* local register is not modified. * local register is not modified.
* On 32-bits, maxNbBits==24. * On 32-bits, maxNbBits==24.
* On 64-bits, maxNbBits==56. * On 64-bits, maxNbBits==56.
* @return : value extracted */ * @return : value extracted */
MEM_STATIC size_t BIT_lookBits(const BIT_DStream_t* bitD, U32 nbBits) MEM_STATIC size_t BIT_lookBits(const BIT_DStream_t* bitD, U32 nbBits)
{ {
#if defined(__BMI__) && defined(__GNUC__) /* experimental; fails if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8 */ /* arbitrate between double-shift and shift+mask */
#if 1
/* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8,
* bitstream is likely corrupted, and result is undefined */
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
#else #else
/* this code path is slower on my os-x laptop */
U32 const regMask = sizeof(bitD->bitContainer)*8 - 1; U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMask); return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMask);
#endif #endif
} }
/*! BIT_lookBitsFast() : /*! BIT_lookBitsFast() :
* unsafe version; only works if nbBits >= 1 */ * unsafe version; only works if nbBits >= 1 */
MEM_STATIC size_t BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits) MEM_STATIC size_t BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits)
{ {
U32 const regMask = sizeof(bitD->bitContainer)*8 - 1; U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
assert(nbBits >= 1); assert(nbBits >= 1);
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
} }
MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits) MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
{ {
bitD->bitsConsumed += nbBits; bitD->bitsConsumed += nbBits;
} }
/*! BIT_readBits() : /*! BIT_readBits() :
* Read (consume) next n bits from local register and update. * Read (consume) next n bits from local register and update.
* Pay attention to not read more than nbBits contained into local register. * Pay attention to not read more than nbBits contained into local register.
* @return : extracted value. */ * @return : extracted value. */
MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits) MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits)
{ {
size_t const value = BIT_lookBits(bitD, nbBits); size_t const value = BIT_lookBits(bitD, nbBits);
BIT_skipBits(bitD, nbBits); BIT_skipBits(bitD, nbBits);
return value; return value;
} }
/*! BIT_readBitsFast() : /*! BIT_readBitsFast() :
* unsafe version; only works only if nbBits >= 1 */ * unsafe version; only works only if nbBits >= 1 */
MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits) MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits)
{ {
size_t const value = BIT_lookBitsFast(bitD, nbBits); size_t const value = BIT_lookBitsFast(bitD, nbBits);
assert(nbBits >= 1); assert(nbBits >= 1);
BIT_skipBits(bitD, nbBits); BIT_skipBits(bitD, nbBits);
return value; return value;
} }
/*! BIT_reloadDStream() : /*! BIT_reloadDStream() :

contrib/python-zstandard/zstd/common/compiler.h

#ifndef ZSTD_COMPILER_H #ifndef ZSTD_COMPILER_H
#define ZSTD_COMPILER_H #define ZSTD_COMPILER_H
/*-******************************************************* /*-*******************************************************
* Compiler specifics * Compiler specifics
*********************************************************/ *********************************************************/
/* force inlining */ /* force inlining */
#if !defined(ZSTD_NO_INLINE)
#if defined (__GNUC__) || defined(__cplusplus) || defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */ #if defined (__GNUC__) || defined(__cplusplus) || defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */
# define INLINE_KEYWORD inline # define INLINE_KEYWORD inline
#else #else
# define INLINE_KEYWORD # define INLINE_KEYWORD
#endif #endif
#if defined(__GNUC__) #if defined(__GNUC__)
# define FORCE_INLINE_ATTR __attribute__((always_inline)) # define FORCE_INLINE_ATTR __attribute__((always_inline))
#elif defined(_MSC_VER) #elif defined(_MSC_VER)
# define FORCE_INLINE_ATTR __forceinline # define FORCE_INLINE_ATTR __forceinline
#else #else
# define FORCE_INLINE_ATTR # define FORCE_INLINE_ATTR
#endif #endif
#else
#define INLINE_KEYWORD
#define FORCE_INLINE_ATTR
#endif
/** /**
* FORCE_INLINE_TEMPLATE is used to define C "templates", which take constant * FORCE_INLINE_TEMPLATE is used to define C "templates", which take constant
* parameters. They must be inlined for the compiler to elimininate the constant * parameters. They must be inlined for the compiler to elimininate the constant
* branches. * branches.
*/ */
#define FORCE_INLINE_TEMPLATE static INLINE_KEYWORD FORCE_INLINE_ATTR #define FORCE_INLINE_TEMPLATE static INLINE_KEYWORD FORCE_INLINE_ATTR
/** /**
* HINT_INLINE is used to help the compiler generate better code. It is *not* * HINT_INLINE is used to help the compiler generate better code. It is *not*
&& !defined(__BMI2__) && !defined(__BMI2__)
# define DYNAMIC_BMI2 1 # define DYNAMIC_BMI2 1
#else #else
# define DYNAMIC_BMI2 0 # define DYNAMIC_BMI2 0
#endif #endif
#endif #endif
/* prefetch /* prefetch
* can be disabled, by declaring NO_PREFETCH macro * can be disabled, by declaring NO_PREFETCH build macro */
* All prefetch invocations use a single default locality 2,
* generating instruction prefetcht1,
* which, according to Intel, means "load data into L2 cache".
* This is a good enough "middle ground" for the time being,
* though in theory, it would be better to specialize locality depending on data being prefetched.
* Tests could not determine any sensible difference based on locality value. */
#if defined(NO_PREFETCH) #if defined(NO_PREFETCH)
# define PREFETCH(ptr) (void)(ptr) /* disabled */ # define PREFETCH_L1(ptr) (void)(ptr) /* disabled */
# define PREFETCH_L2(ptr) (void)(ptr) /* disabled */
#else #else
# if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_I86)) /* _mm_prefetch() is not defined outside of x86/x64 */ # if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_I86)) /* _mm_prefetch() is not defined outside of x86/x64 */
# include <mmintrin.h> /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */ # include <mmintrin.h> /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */
# define PREFETCH(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T1) # define PREFETCH_L1(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T0)
# define PREFETCH_L2(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T1)
# elif defined(__GNUC__) && ( (__GNUC__ >= 4) || ( (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1) ) ) # elif defined(__GNUC__) && ( (__GNUC__ >= 4) || ( (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1) ) )
# define PREFETCH(ptr) __builtin_prefetch((ptr), 0 /* rw==read */, 2 /* locality */) # define PREFETCH_L1(ptr) __builtin_prefetch((ptr), 0 /* rw==read */, 3 /* locality */)
# define PREFETCH_L2(ptr) __builtin_prefetch((ptr), 0 /* rw==read */, 2 /* locality */)
# else # else
# define PREFETCH(ptr) (void)(ptr) /* disabled */ # define PREFETCH_L1(ptr) (void)(ptr) /* disabled */
# define PREFETCH_L2(ptr) (void)(ptr) /* disabled */
# endif # endif
#endif /* NO_PREFETCH */ #endif /* NO_PREFETCH */
#define CACHELINE_SIZE 64 #define CACHELINE_SIZE 64
#define PREFETCH_AREA(p, s) { \ #define PREFETCH_AREA(p, s) { \
const char* const _ptr = (const char*)(p); \ const char* const _ptr = (const char*)(p); \
size_t const _size = (size_t)(s); \ size_t const _size = (size_t)(s); \
size_t _pos; \ size_t _pos; \
for (_pos=0; _pos<_size; _pos+=CACHELINE_SIZE) { \ for (_pos=0; _pos<_size; _pos+=CACHELINE_SIZE) { \
PREFETCH(_ptr + _pos); \ PREFETCH_L2(_ptr + _pos); \
} \ } \
} }
/* disable warnings */ /* disable warnings */
#ifdef _MSC_VER /* Visual Studio */ #ifdef _MSC_VER /* Visual Studio */
# include <intrin.h> /* For Visual 2005 */ # include <intrin.h> /* For Visual 2005 */
# pragma warning(disable : 4100) /* disable: C4100: unreferenced formal parameter */ # pragma warning(disable : 4100) /* disable: C4100: unreferenced formal parameter */
# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ # pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */
# pragma warning(disable : 4204) /* disable: C4204: non-constant aggregate initializer */ # pragma warning(disable : 4204) /* disable: C4204: non-constant aggregate initializer */
# pragma warning(disable : 4214) /* disable: C4214: non-int bitfields */ # pragma warning(disable : 4214) /* disable: C4214: non-int bitfields */
# pragma warning(disable : 4324) /* disable: C4324: padded structure */ # pragma warning(disable : 4324) /* disable: C4324: padded structure */
#endif #endif
#endif /* ZSTD_COMPILER_H */ #endif /* ZSTD_COMPILER_H */

contrib/python-zstandard/zstd/common/cpu.h

"popl %%ebx\n\t" "popl %%ebx\n\t"
: "=a"(f1a), "=c"(f1c), "=d"(f1d) : "=a"(f1a), "=c"(f1c), "=d"(f1d)
: "a"(1)); : "a"(1));
} }
if (n >= 7) { if (n >= 7) {
__asm__( __asm__(
"pushl %%ebx\n\t" "pushl %%ebx\n\t"
"cpuid\n\t" "cpuid\n\t"
"movl %%ebx, %%eax\n\r" "movl %%ebx, %%eax\n\t"
"popl %%ebx" "popl %%ebx"
: "=a"(f7b), "=c"(f7c) : "=a"(f7b), "=c"(f7c)
: "a"(7), "c"(0) : "a"(7), "c"(0)
: "edx"); : "edx");
} }
#elif defined(__x86_64__) || defined(_M_X64) || defined(__i386__) #elif defined(__x86_64__) || defined(_M_X64) || defined(__i386__)
U32 n; U32 n;
__asm__("cpuid" : "=a"(n) : "a"(0) : "ebx", "ecx", "edx"); __asm__("cpuid" : "=a"(n) : "a"(0) : "ebx", "ecx", "edx");

contrib/python-zstandard/zstd/common/debug.h

#ifndef DEBUG_H_12987983217 #ifndef DEBUG_H_12987983217
#define DEBUG_H_12987983217 #define DEBUG_H_12987983217
#if defined (__cplusplus) #if defined (__cplusplus)
extern "C" { extern "C" {
#endif #endif
/* static assert is triggered at compile time, leaving no runtime artefact, /* static assert is triggered at compile time, leaving no runtime artefact.
* but can only work with compile-time constants. * static assert only works with compile-time constants.
* This variant can only be used inside a function. */ * Also, this variant can only be used inside a function. */
#define DEBUG_STATIC_ASSERT(c) (void)sizeof(char[(c) ? 1 : -1]) #define DEBUG_STATIC_ASSERT(c) (void)sizeof(char[(c) ? 1 : -1])
/* DEBUGLEVEL is expected to be defined externally, /* DEBUGLEVEL is expected to be defined externally,
* typically through compiler command line. * typically through compiler command line.
* Value must be a number. */ * Value must be a number. */
#ifndef DEBUGLEVEL #ifndef DEBUGLEVEL
# define DEBUGLEVEL 0 # define DEBUGLEVEL 0
#endif #endif
/* DEBUGFILE can be defined externally,
* typically through compiler command line.
* note : currently useless.
* Value must be stderr or stdout */
#ifndef DEBUGFILE
# define DEBUGFILE stderr
#endif
/* recommended values for DEBUGLEVEL : /* recommended values for DEBUGLEVEL :
* 0 : no debug, all run-time functions disabled * 0 : release mode, no debug, all run-time checks disabled
* 1 : no display, enables assert() only * 1 : enables assert() only, no display
* 2 : reserved, for currently active debug path * 2 : reserved, for currently active debug path
* 3 : events once per object lifetime (CCtx, CDict, etc.) * 3 : events once per object lifetime (CCtx, CDict, etc.)
* 4 : events once per frame * 4 : events once per frame
* 5 : events once per block * 5 : events once per block
* 6 : events once per sequence (verbose) * 6 : events once per sequence (verbose)
* 7+: events at every position (*very* verbose) * 7+: events at every position (*very* verbose)
* *
* It's generally inconvenient to output traces > 5. * It's generally inconvenient to output traces > 5.
* In which case, it's possible to selectively enable higher verbosity levels * In which case, it's possible to selectively trigger high verbosity levels
* by modifying g_debug_level. * by modifying g_debug_level.
*/ */
#if (DEBUGLEVEL>=1) #if (DEBUGLEVEL>=1)
# include <assert.h> # include <assert.h>
#else #else
# ifndef assert /* assert may be already defined, due to prior #include <assert.h> */ # ifndef assert /* assert may be already defined, due to prior #include <assert.h> */
# define assert(condition) ((void)0) /* disable assert (default) */ # define assert(condition) ((void)0) /* disable assert (default) */
# endif # endif
#endif #endif
#if (DEBUGLEVEL>=2) #if (DEBUGLEVEL>=2)
# include <stdio.h> # include <stdio.h>
extern int g_debuglevel; /* here, this variable is only declared, extern int g_debuglevel; /* the variable is only declared,
it actually lives in debug.c, it actually lives in debug.c,
and is shared by the whole process. and is shared by the whole process.
It's typically used to enable very verbose levels It's not thread-safe.
It's useful when enabling very verbose levels
on selective conditions (such as position in src) */ on selective conditions (such as position in src) */
# define RAWLOG(l, ...) { \ # define RAWLOG(l, ...) { \
if (l<=g_debuglevel) { \ if (l<=g_debuglevel) { \
fprintf(stderr, __VA_ARGS__); \ fprintf(stderr, __VA_ARGS__); \
} } } }
# define DEBUGLOG(l, ...) { \ # define DEBUGLOG(l, ...) { \
if (l<=g_debuglevel) { \ if (l<=g_debuglevel) { \
fprintf(stderr, __FILE__ ": " __VA_ARGS__); \ fprintf(stderr, __FILE__ ": " __VA_ARGS__); \

contrib/python-zstandard/zstd/common/error_private.c

/* /*
* Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
* All rights reserved. * All rights reserved.
* *
* This source code is licensed under both the BSD-style license (found in the * 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 * 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). * in the COPYING file in the root directory of this source tree).
* You may select, at your option, one of the above-listed licenses. * You may select, at your option, one of the above-listed licenses.
*/ */
/* The purpose of this file is to have a single list of error strings embedded in binary */ /* The purpose of this file is to have a single list of error strings embedded in binary */
#include "error_private.h" #include "error_private.h"
const char* ERR_getErrorString(ERR_enum code) const char* ERR_getErrorString(ERR_enum code)
{ {
#ifdef ZSTD_STRIP_ERROR_STRINGS
(void)code;
return "Error strings stripped";
#else
static const char* const notErrorCode = "Unspecified error code"; static const char* const notErrorCode = "Unspecified error code";
switch( code ) switch( code )
{ {
case PREFIX(no_error): return "No error detected"; case PREFIX(no_error): return "No error detected";
case PREFIX(GENERIC): return "Error (generic)"; case PREFIX(GENERIC): return "Error (generic)";
case PREFIX(prefix_unknown): return "Unknown frame descriptor"; case PREFIX(prefix_unknown): return "Unknown frame descriptor";
case PREFIX(version_unsupported): return "Version not supported"; case PREFIX(version_unsupported): return "Version not supported";
case PREFIX(frameParameter_unsupported): return "Unsupported frame parameter"; case PREFIX(frameParameter_unsupported): return "Unsupported frame parameter";
case PREFIX(tableLog_tooLarge): return "tableLog requires too much memory : unsupported"; case PREFIX(tableLog_tooLarge): return "tableLog requires too much memory : unsupported";
case PREFIX(maxSymbolValue_tooLarge): return "Unsupported max Symbol Value : too large"; case PREFIX(maxSymbolValue_tooLarge): return "Unsupported max Symbol Value : too large";
case PREFIX(maxSymbolValue_tooSmall): return "Specified maxSymbolValue is too small"; case PREFIX(maxSymbolValue_tooSmall): return "Specified maxSymbolValue is too small";
case PREFIX(dictionary_corrupted): return "Dictionary is corrupted"; case PREFIX(dictionary_corrupted): return "Dictionary is corrupted";
case PREFIX(dictionary_wrong): return "Dictionary mismatch"; case PREFIX(dictionary_wrong): return "Dictionary mismatch";
case PREFIX(dictionaryCreation_failed): return "Cannot create Dictionary from provided samples"; case PREFIX(dictionaryCreation_failed): return "Cannot create Dictionary from provided samples";
case PREFIX(dstSize_tooSmall): return "Destination buffer is too small"; case PREFIX(dstSize_tooSmall): return "Destination buffer is too small";
case PREFIX(srcSize_wrong): return "Src size is incorrect"; case PREFIX(srcSize_wrong): return "Src size is incorrect";
case PREFIX(dstBuffer_null): return "Operation on NULL destination buffer";
/* following error codes are not stable and may be removed or changed in a future version */ /* following error codes are not stable and may be removed or changed in a future version */
case PREFIX(frameIndex_tooLarge): return "Frame index is too large"; case PREFIX(frameIndex_tooLarge): return "Frame index is too large";
case PREFIX(seekableIO): return "An I/O error occurred when reading/seeking"; case PREFIX(seekableIO): return "An I/O error occurred when reading/seeking";
case PREFIX(maxCode): case PREFIX(maxCode):
default: return notErrorCode; default: return notErrorCode;
} }
#endif
} }

contrib/python-zstandard/zstd/common/fse.h

MEM_STATIC void FSE_initCState(FSE_CState_t* statePtr, const FSE_CTable* ct) MEM_STATIC void FSE_initCState(FSE_CState_t* statePtr, const FSE_CTable* ct)
{ {
const void* ptr = ct; const void* ptr = ct;
const U16* u16ptr = (const U16*) ptr; const U16* u16ptr = (const U16*) ptr;
const U32 tableLog = MEM_read16(ptr); const U32 tableLog = MEM_read16(ptr);
statePtr->value = (ptrdiff_t)1<<tableLog; statePtr->value = (ptrdiff_t)1<<tableLog;
statePtr->stateTable = u16ptr+2; statePtr->stateTable = u16ptr+2;
statePtr->symbolTT = ((const U32*)ct + 1 + (tableLog ? (1<<(tableLog-1)) : 1)); statePtr->symbolTT = ct + 1 + (tableLog ? (1<<(tableLog-1)) : 1);
statePtr->stateLog = tableLog; statePtr->stateLog = tableLog;
} }
/*! FSE_initCState2() : /*! FSE_initCState2() :
* Same as FSE_initCState(), but the first symbol to include (which will be the last to be read) * Same as FSE_initCState(), but the first symbol to include (which will be the last to be read)
* uses the smallest state value possible, saving the cost of this symbol */ * uses the smallest state value possible, saving the cost of this symbol */
MEM_STATIC void FSE_initCState2(FSE_CState_t* statePtr, const FSE_CTable* ct, U32 symbol) MEM_STATIC void FSE_initCState2(FSE_CState_t* statePtr, const FSE_CTable* ct, U32 symbol)
{ {
FSE_initCState(statePtr, ct); FSE_initCState(statePtr, ct);
{ const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol]; { const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
const U16* stateTable = (const U16*)(statePtr->stateTable); const U16* stateTable = (const U16*)(statePtr->stateTable);
U32 nbBitsOut = (U32)((symbolTT.deltaNbBits + (1<<15)) >> 16); U32 nbBitsOut = (U32)((symbolTT.deltaNbBits + (1<<15)) >> 16);
statePtr->value = (nbBitsOut << 16) - symbolTT.deltaNbBits; statePtr->value = (nbBitsOut << 16) - symbolTT.deltaNbBits;
statePtr->value = stateTable[(statePtr->value >> nbBitsOut) + symbolTT.deltaFindState]; statePtr->value = stateTable[(statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
} }
} }
MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, U32 symbol) MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, unsigned symbol)
{ {
FSE_symbolCompressionTransform const symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol]; FSE_symbolCompressionTransform const symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
const U16* const stateTable = (const U16*)(statePtr->stateTable); const U16* const stateTable = (const U16*)(statePtr->stateTable);
U32 const nbBitsOut = (U32)((statePtr->value + symbolTT.deltaNbBits) >> 16); U32 const nbBitsOut = (U32)((statePtr->value + symbolTT.deltaNbBits) >> 16);
BIT_addBits(bitC, statePtr->value, nbBitsOut); BIT_addBits(bitC, statePtr->value, nbBitsOut);
statePtr->value = stateTable[ (statePtr->value >> nbBitsOut) + symbolTT.deltaFindState]; statePtr->value = stateTable[ (statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
} }

contrib/python-zstandard/zstd/common/huf.h

#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \ #define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog) * 0x01000001) } HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog) * 0x01000001) }
/* **************************************** /* ****************************************
* Advanced decompression functions * Advanced decompression functions
******************************************/ ******************************************/
size_t HUF_decompress4X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */ size_t HUF_decompress4X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */
#ifndef HUF_FORCE_DECOMPRESS_X1
size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */ size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */
#endif
size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< decodes RLE and uncompressed */ size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< decodes RLE and uncompressed */
size_t HUF_decompress4X_hufOnly(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< considers RLE and uncompressed as errors */ size_t HUF_decompress4X_hufOnly(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< considers RLE and uncompressed as errors */
size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< considers RLE and uncompressed as errors */ size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< considers RLE and uncompressed as errors */
size_t HUF_decompress4X1_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */ size_t HUF_decompress4X1_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */
size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< single-symbol decoder */ size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< single-symbol decoder */
#ifndef HUF_FORCE_DECOMPRESS_X1
size_t HUF_decompress4X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */ size_t HUF_decompress4X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */
size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< double-symbols decoder */ size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< double-symbols decoder */
#endif
/* **************************************** /* ****************************************
* HUF detailed API * HUF detailed API
* ****************************************/ * ****************************************/
/*! HUF_compress() does the following: /*! HUF_compress() does the following:
* 1. count symbol occurrence from source[] into table count[] using FSE_count() (exposed within "fse.h") * 1. count symbol occurrence from source[] into table count[] using FSE_count() (exposed within "fse.h")
/** HUF_buildCTable_wksp() : /** HUF_buildCTable_wksp() :
* Same as HUF_buildCTable(), but using externally allocated scratch buffer. * Same as HUF_buildCTable(), but using externally allocated scratch buffer.
* `workSpace` must be aligned on 4-bytes boundaries, and its size must be >= HUF_CTABLE_WORKSPACE_SIZE. * `workSpace` must be aligned on 4-bytes boundaries, and its size must be >= HUF_CTABLE_WORKSPACE_SIZE.
*/ */
#define HUF_CTABLE_WORKSPACE_SIZE_U32 (2*HUF_SYMBOLVALUE_MAX +1 +1) #define HUF_CTABLE_WORKSPACE_SIZE_U32 (2*HUF_SYMBOLVALUE_MAX +1 +1)
#define HUF_CTABLE_WORKSPACE_SIZE (HUF_CTABLE_WORKSPACE_SIZE_U32 * sizeof(unsigned)) #define HUF_CTABLE_WORKSPACE_SIZE (HUF_CTABLE_WORKSPACE_SIZE_U32 * sizeof(unsigned))
size_t HUF_buildCTable_wksp (HUF_CElt* tree, size_t HUF_buildCTable_wksp (HUF_CElt* tree,
const U32* count, U32 maxSymbolValue, U32 maxNbBits, const unsigned* count, U32 maxSymbolValue, U32 maxNbBits,
void* workSpace, size_t wkspSize); void* workSpace, size_t wkspSize);
/*! HUF_readStats() : /*! HUF_readStats() :
* Read compact Huffman tree, saved by HUF_writeCTable(). * Read compact Huffman tree, saved by HUF_writeCTable().
* `huffWeight` is destination buffer. * `huffWeight` is destination buffer.
* @return : size read from `src` , or an error Code . * @return : size read from `src` , or an error Code .
* Note : Needed by HUF_readCTable() and HUF_readDTableXn() . */ * Note : Needed by HUF_readCTable() and HUF_readDTableXn() . */
size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, size_t HUF_readStats(BYTE* huffWeight, size_t hwSize,
* HUF_TABLE_LOG_MAX=12 to ~1850 bytes when HUF_TABLE_LOG_MAX=15. * HUF_TABLE_LOG_MAX=12 to ~1850 bytes when HUF_TABLE_LOG_MAX=15.
* Buffer overflow errors may potentially occur if code modifications result in * Buffer overflow errors may potentially occur if code modifications result in
* a required workspace size greater than that specified in the following * a required workspace size greater than that specified in the following
* macro. * macro.
*/ */
#define HUF_DECOMPRESS_WORKSPACE_SIZE (2 << 10) #define HUF_DECOMPRESS_WORKSPACE_SIZE (2 << 10)
#define HUF_DECOMPRESS_WORKSPACE_SIZE_U32 (HUF_DECOMPRESS_WORKSPACE_SIZE / sizeof(U32)) #define HUF_DECOMPRESS_WORKSPACE_SIZE_U32 (HUF_DECOMPRESS_WORKSPACE_SIZE / sizeof(U32))
#ifndef HUF_FORCE_DECOMPRESS_X2
size_t HUF_readDTableX1 (HUF_DTable* DTable, const void* src, size_t srcSize); size_t HUF_readDTableX1 (HUF_DTable* DTable, const void* src, size_t srcSize);
size_t HUF_readDTableX1_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize); size_t HUF_readDTableX1_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize);
#endif
#ifndef HUF_FORCE_DECOMPRESS_X1
size_t HUF_readDTableX2 (HUF_DTable* DTable, const void* src, size_t srcSize); size_t HUF_readDTableX2 (HUF_DTable* DTable, const void* src, size_t srcSize);
size_t HUF_readDTableX2_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize); size_t HUF_readDTableX2_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize);
#endif
size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
#ifndef HUF_FORCE_DECOMPRESS_X2
size_t HUF_decompress4X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); size_t HUF_decompress4X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
#endif
#ifndef HUF_FORCE_DECOMPRESS_X1
size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
#endif
/* ====================== */ /* ====================== */
/* single stream variants */ /* single stream variants */
/* ====================== */ /* ====================== */
size_t HUF_compress1X (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog); size_t HUF_compress1X (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog);
size_t HUF_compress1X_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize); /**< `workSpace` must be a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */ size_t HUF_compress1X_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize); /**< `workSpace` must be a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */
size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable); size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable);
/** HUF_compress1X_repeat() : /** HUF_compress1X_repeat() :
* Same as HUF_compress1X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none. * Same as HUF_compress1X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none.
* If it uses hufTable it does not modify hufTable or repeat. * If it uses hufTable it does not modify hufTable or repeat.
* If it doesn't, it sets *repeat = HUF_repeat_none, and it sets hufTable to the table used. * If it doesn't, it sets *repeat = HUF_repeat_none, and it sets hufTable to the table used.
* If preferRepeat then the old table will always be used if valid. */ * If preferRepeat then the old table will always be used if valid. */
size_t HUF_compress1X_repeat(void* dst, size_t dstSize, size_t HUF_compress1X_repeat(void* dst, size_t dstSize,
const void* src, size_t srcSize, const void* src, size_t srcSize,
unsigned maxSymbolValue, unsigned tableLog, unsigned maxSymbolValue, unsigned tableLog,
void* workSpace, size_t wkspSize, /**< `workSpace` must be aligned on 4-bytes boundaries, `wkspSize` must be >= HUF_WORKSPACE_SIZE */ void* workSpace, size_t wkspSize, /**< `workSpace` must be aligned on 4-bytes boundaries, `wkspSize` must be >= HUF_WORKSPACE_SIZE */
HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2); HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2);
size_t HUF_decompress1X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /* single-symbol decoder */ size_t HUF_decompress1X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /* single-symbol decoder */
#ifndef HUF_FORCE_DECOMPRESS_X1
size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /* double-symbol decoder */ size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /* double-symbol decoder */
#endif
size_t HUF_decompress1X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); size_t HUF_decompress1X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
size_t HUF_decompress1X_DCtx_wksp (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); size_t HUF_decompress1X_DCtx_wksp (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize);
#ifndef HUF_FORCE_DECOMPRESS_X2
size_t HUF_decompress1X1_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */ size_t HUF_decompress1X1_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */
size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< single-symbol decoder */ size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< single-symbol decoder */
#endif
#ifndef HUF_FORCE_DECOMPRESS_X1
size_t HUF_decompress1X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */ size_t HUF_decompress1X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */
size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< double-symbols decoder */ size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< double-symbols decoder */
#endif
size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); /**< automatic selection of sing or double symbol decoder, based on DTable */ size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); /**< automatic selection of sing or double symbol decoder, based on DTable */
#ifndef HUF_FORCE_DECOMPRESS_X2
size_t HUF_decompress1X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); size_t HUF_decompress1X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
#endif
#ifndef HUF_FORCE_DECOMPRESS_X1
size_t HUF_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); size_t HUF_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
#endif
/* BMI2 variants. /* BMI2 variants.
* If the CPU has BMI2 support, pass bmi2=1, otherwise pass bmi2=0. * If the CPU has BMI2 support, pass bmi2=1, otherwise pass bmi2=0.
*/ */
size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2); size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2);
#ifndef HUF_FORCE_DECOMPRESS_X2
size_t HUF_decompress1X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2); size_t HUF_decompress1X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2);
#endif
size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2); size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2);
size_t HUF_decompress4X_hufOnly_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2); size_t HUF_decompress4X_hufOnly_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2);
#endif /* HUF_STATIC_LINKING_ONLY */ #endif /* HUF_STATIC_LINKING_ONLY */
#if defined (__cplusplus) #if defined (__cplusplus)
} }
#endif #endif

contrib/python-zstandard/zstd/common/mem.h

#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) #elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
# define MEM_STATIC static inline # define MEM_STATIC static inline
#elif defined(_MSC_VER) #elif defined(_MSC_VER)
# define MEM_STATIC static __inline # define MEM_STATIC static __inline
#else #else
# define MEM_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */ # define MEM_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */
#endif #endif
#ifndef __has_builtin
# define __has_builtin(x) 0 /* compat. with non-clang compilers */
#endif
/* code only tested on 32 and 64 bits systems */ /* code only tested on 32 and 64 bits systems */
#define MEM_STATIC_ASSERT(c) { enum { MEM_static_assert = 1/(int)(!!(c)) }; } #define MEM_STATIC_ASSERT(c) { enum { MEM_static_assert = 1/(int)(!!(c)) }; }
MEM_STATIC void MEM_check(void) { MEM_STATIC_ASSERT((sizeof(size_t)==4) || (sizeof(size_t)==8)); } MEM_STATIC void MEM_check(void) { MEM_STATIC_ASSERT((sizeof(size_t)==4) || (sizeof(size_t)==8)); }
/*-************************************************************** /*-**************************************************************
* Basic Types * Basic Types
*****************************************************************/ *****************************************************************/
} }
#endif /* MEM_FORCE_MEMORY_ACCESS */ #endif /* MEM_FORCE_MEMORY_ACCESS */
MEM_STATIC U32 MEM_swap32(U32 in) MEM_STATIC U32 MEM_swap32(U32 in)
{ {
#if defined(_MSC_VER) /* Visual Studio */ #if defined(_MSC_VER) /* Visual Studio */
return _byteswap_ulong(in); return _byteswap_ulong(in);
#elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403) #elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
|| (defined(__clang__) && __has_builtin(__builtin_bswap32))
return __builtin_bswap32(in); return __builtin_bswap32(in);
#else #else
return ((in << 24) & 0xff000000 ) | return ((in << 24) & 0xff000000 ) |
((in << 8) & 0x00ff0000 ) | ((in << 8) & 0x00ff0000 ) |
((in >> 8) & 0x0000ff00 ) | ((in >> 8) & 0x0000ff00 ) |
((in >> 24) & 0x000000ff ); ((in >> 24) & 0x000000ff );
#endif #endif
} }
MEM_STATIC U64 MEM_swap64(U64 in) MEM_STATIC U64 MEM_swap64(U64 in)
{ {
#if defined(_MSC_VER) /* Visual Studio */ #if defined(_MSC_VER) /* Visual Studio */
return _byteswap_uint64(in); return _byteswap_uint64(in);
#elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403) #elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
|| (defined(__clang__) && __has_builtin(__builtin_bswap64))
return __builtin_bswap64(in); return __builtin_bswap64(in);
#else #else
return ((in << 56) & 0xff00000000000000ULL) | return ((in << 56) & 0xff00000000000000ULL) |
((in << 40) & 0x00ff000000000000ULL) | ((in << 40) & 0x00ff000000000000ULL) |
((in << 24) & 0x0000ff0000000000ULL) | ((in << 24) & 0x0000ff0000000000ULL) |
((in << 8) & 0x000000ff00000000ULL) | ((in << 8) & 0x000000ff00000000ULL) |
((in >> 8) & 0x00000000ff000000ULL) | ((in >> 8) & 0x00000000ff000000ULL) |
((in >> 24) & 0x0000000000ff0000ULL) | ((in >> 24) & 0x0000000000ff0000ULL) |

contrib/python-zstandard/zstd/common/pool.c

ZSTD_pthread_cond_wait(&ctx->queuePopCond, &ctx->queueMutex); ZSTD_pthread_cond_wait(&ctx->queuePopCond, &ctx->queueMutex);
} }
/* Pop a job off the queue */ /* Pop a job off the queue */
{ POOL_job const job = ctx->queue[ctx->queueHead]; { POOL_job const job = ctx->queue[ctx->queueHead];
ctx->queueHead = (ctx->queueHead + 1) % ctx->queueSize; ctx->queueHead = (ctx->queueHead + 1) % ctx->queueSize;
ctx->numThreadsBusy++; ctx->numThreadsBusy++;
ctx->queueEmpty = ctx->queueHead == ctx->queueTail; ctx->queueEmpty = ctx->queueHead == ctx->queueTail;
/* Unlock the mutex, signal a pusher, and run the job */ /* Unlock the mutex, signal a pusher, and run the job */
ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
ZSTD_pthread_cond_signal(&ctx->queuePushCond); ZSTD_pthread_cond_signal(&ctx->queuePushCond);
ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
job.function(job.opaque); job.function(job.opaque);
/* If the intended queue size was 0, signal after finishing job */ /* If the intended queue size was 0, signal after finishing job */
ZSTD_pthread_mutex_lock(&ctx->queueMutex); ZSTD_pthread_mutex_lock(&ctx->queueMutex);
ctx->numThreadsBusy--; ctx->numThreadsBusy--;
if (ctx->queueSize == 1) { if (ctx->queueSize == 1) {
ZSTD_pthread_cond_signal(&ctx->queuePushCond); ZSTD_pthread_cond_signal(&ctx->queuePushCond);

contrib/python-zstandard/zstd/common/zstd_common.c

unsigned ZSTD_versionNumber(void) { return ZSTD_VERSION_NUMBER; } unsigned ZSTD_versionNumber(void) { return ZSTD_VERSION_NUMBER; }
const char* ZSTD_versionString(void) { return ZSTD_VERSION_STRING; } const char* ZSTD_versionString(void) { return ZSTD_VERSION_STRING; }
/*-**************************************** /*-****************************************
* ZSTD Error Management * ZSTD Error Management
******************************************/ ******************************************/
#undef ZSTD_isError /* defined within zstd_internal.h */
/*! ZSTD_isError() : /*! ZSTD_isError() :
* tells if a return value is an error code */ * tells if a return value is an error code
* symbol is required for external callers */
unsigned ZSTD_isError(size_t code) { return ERR_isError(code); } unsigned ZSTD_isError(size_t code) { return ERR_isError(code); }
/*! ZSTD_getErrorName() : /*! ZSTD_getErrorName() :
* provides error code string from function result (useful for debugging) */ * provides error code string from function result (useful for debugging) */
const char* ZSTD_getErrorName(size_t code) { return ERR_getErrorName(code); } const char* ZSTD_getErrorName(size_t code) { return ERR_getErrorName(code); }
/*! ZSTD_getError() : /*! ZSTD_getError() :
* convert a `size_t` function result into a proper ZSTD_errorCode enum */ * convert a `size_t` function result into a proper ZSTD_errorCode enum */

contrib/python-zstandard/zstd/common/zstd_errors.h

ZSTD_error_maxSymbolValue_tooLarge = 46, ZSTD_error_maxSymbolValue_tooLarge = 46,
ZSTD_error_maxSymbolValue_tooSmall = 48, ZSTD_error_maxSymbolValue_tooSmall = 48,
ZSTD_error_stage_wrong = 60, ZSTD_error_stage_wrong = 60,
ZSTD_error_init_missing = 62, ZSTD_error_init_missing = 62,
ZSTD_error_memory_allocation = 64, ZSTD_error_memory_allocation = 64,
ZSTD_error_workSpace_tooSmall= 66, ZSTD_error_workSpace_tooSmall= 66,
ZSTD_error_dstSize_tooSmall = 70, ZSTD_error_dstSize_tooSmall = 70,
ZSTD_error_srcSize_wrong = 72, ZSTD_error_srcSize_wrong = 72,
ZSTD_error_dstBuffer_null = 74,
/* following error codes are __NOT STABLE__, they can be removed or changed in future versions */ /* following error codes are __NOT STABLE__, they can be removed or changed in future versions */
ZSTD_error_frameIndex_tooLarge = 100, ZSTD_error_frameIndex_tooLarge = 100,
ZSTD_error_seekableIO = 102, ZSTD_error_seekableIO = 102,
ZSTD_error_maxCode = 120 /* never EVER use this value directly, it can change in future versions! Use ZSTD_isError() instead */ ZSTD_error_maxCode = 120 /* never EVER use this value directly, it can change in future versions! Use ZSTD_isError() instead */
} ZSTD_ErrorCode; } ZSTD_ErrorCode;
/*! ZSTD_getErrorCode() : /*! ZSTD_getErrorCode() :
convert a `size_t` function result into a `ZSTD_ErrorCode` enum type, convert a `size_t` function result into a `ZSTD_ErrorCode` enum type,

contrib/python-zstandard/zstd/common/zstd_internal.h

#if defined (__cplusplus) #if defined (__cplusplus)
extern "C" { extern "C" {
#endif #endif
/* ---- static assert (debug) --- */ /* ---- static assert (debug) --- */
#define ZSTD_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c) #define ZSTD_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)
#define ZSTD_isError ERR_isError /* for inlining */
#define FSE_isError ERR_isError
#define HUF_isError ERR_isError
/*-************************************* /*-*************************************
* shared macros * shared macros
***************************************/ ***************************************/
#undef MIN #undef MIN
#undef MAX #undef MAX
#define MIN(a,b) ((a)<(b) ? (a) : (b)) #define MIN(a,b) ((a)<(b) ? (a) : (b))
#define BIT7 128 #define BIT7 128
#define BIT6 64 #define BIT6 64
#define BIT5 32 #define BIT5 32
#define BIT4 16 #define BIT4 16
#define BIT1 2 #define BIT1 2
#define BIT0 1 #define BIT0 1
#define ZSTD_WINDOWLOG_ABSOLUTEMIN 10 #define ZSTD_WINDOWLOG_ABSOLUTEMIN 10
#define ZSTD_WINDOWLOG_DEFAULTMAX 27 /* Default maximum allowed window log */
static const size_t ZSTD_fcs_fieldSize[4] = { 0, 2, 4, 8 }; static const size_t ZSTD_fcs_fieldSize[4] = { 0, 2, 4, 8 };
static const size_t ZSTD_did_fieldSize[4] = { 0, 1, 2, 4 }; static const size_t ZSTD_did_fieldSize[4] = { 0, 1, 2, 4 };
#define ZSTD_FRAMEIDSIZE 4 /* magic number size */ #define ZSTD_FRAMEIDSIZE 4 /* magic number size */
#define ZSTD_BLOCKHEADERSIZE 3 /* C standard doesn't allow `static const` variable to be init using another `static const` variable */ #define ZSTD_BLOCKHEADERSIZE 3 /* C standard doesn't allow `static const` variable to be init using another `static const` variable */
static const size_t ZSTD_blockHeaderSize = ZSTD_BLOCKHEADERSIZE; static const size_t ZSTD_blockHeaderSize = ZSTD_BLOCKHEADERSIZE;
typedef enum { bt_raw, bt_rle, bt_compressed, bt_reserved } blockType_e; typedef enum { bt_raw, bt_rle, bt_compressed, bt_reserved } blockType_e;
* do not use with extDict variant ! */ * do not use with extDict variant ! */
void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx); /* zstdmt, adaptive_compression (shouldn't get this definition from here) */ void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx); /* zstdmt, adaptive_compression (shouldn't get this definition from here) */
typedef struct { typedef struct {
blockType_e blockType; blockType_e blockType;
U32 lastBlock; U32 lastBlock;
U32 origSize; U32 origSize;
} blockProperties_t; } blockProperties_t; /* declared here for decompress and fullbench */
/*! ZSTD_getcBlockSize() : /*! ZSTD_getcBlockSize() :
* Provides the size of compressed block from block header `src` */ * Provides the size of compressed block from block header `src` */
/* Used by: decompress, fullbench (does not get its definition from here) */ /* Used by: decompress, fullbench (does not get its definition from here) */
size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, size_t ZSTD_getcBlockSize(const void* src, size_t srcSize,
blockProperties_t* bpPtr); blockProperties_t* bpPtr);
/*! ZSTD_decodeSeqHeaders() :
* decode sequence header from src */
/* Used by: decompress, fullbench (does not get its definition from here) */
size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,
const void* src, size_t srcSize);
#if defined (__cplusplus) #if defined (__cplusplus)
} }
#endif #endif
#endif /* ZSTD_CCOMMON_H_MODULE */ #endif /* ZSTD_CCOMMON_H_MODULE */

contrib/python-zstandard/zstd/compress/fse_compress.c

#ifdef __clang_analyzer__ #ifdef __clang_analyzer__
memset(tableSymbol, 0, sizeof(*tableSymbol) * tableSize); /* useless initialization, just to keep scan-build happy */ memset(tableSymbol, 0, sizeof(*tableSymbol) * tableSize); /* useless initialization, just to keep scan-build happy */
#endif #endif
/* symbol start positions */ /* symbol start positions */
{ U32 u; { U32 u;
cumul[0] = 0; cumul[0] = 0;
for (u=1; u<=maxSymbolValue+1; u++) { for (u=1; u <= maxSymbolValue+1; u++) {
if (normalizedCounter[u-1]==-1) { /* Low proba symbol */ if (normalizedCounter[u-1]==-1) { /* Low proba symbol */
cumul[u] = cumul[u-1] + 1; cumul[u] = cumul[u-1] + 1;
tableSymbol[highThreshold--] = (FSE_FUNCTION_TYPE)(u-1); tableSymbol[highThreshold--] = (FSE_FUNCTION_TYPE)(u-1);
} else { } else {
cumul[u] = cumul[u-1] + normalizedCounter[u-1]; cumul[u] = cumul[u-1] + normalizedCounter[u-1];
} } } }
cumul[maxSymbolValue+1] = tableSize+1; cumul[maxSymbolValue+1] = tableSize+1;
} }
* `wkspSize` size must be `(1<<tableLog)`. * `wkspSize` size must be `(1<<tableLog)`.
*/ */
size_t FSE_compress_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize) size_t FSE_compress_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize)
{ {
BYTE* const ostart = (BYTE*) dst; BYTE* const ostart = (BYTE*) dst;
BYTE* op = ostart; BYTE* op = ostart;
BYTE* const oend = ostart + dstSize; BYTE* const oend = ostart + dstSize;
U32 count[FSE_MAX_SYMBOL_VALUE+1]; unsigned count[FSE_MAX_SYMBOL_VALUE+1];
S16 norm[FSE_MAX_SYMBOL_VALUE+1]; S16 norm[FSE_MAX_SYMBOL_VALUE+1];
FSE_CTable* CTable = (FSE_CTable*)workSpace; FSE_CTable* CTable = (FSE_CTable*)workSpace;
size_t const CTableSize = FSE_CTABLE_SIZE_U32(tableLog, maxSymbolValue); size_t const CTableSize = FSE_CTABLE_SIZE_U32(tableLog, maxSymbolValue);
void* scratchBuffer = (void*)(CTable + CTableSize); void* scratchBuffer = (void*)(CTable + CTableSize);
size_t const scratchBufferSize = wkspSize - (CTableSize * sizeof(FSE_CTable)); size_t const scratchBufferSize = wkspSize - (CTableSize * sizeof(FSE_CTable));
/* init conditions */ /* init conditions */
if (wkspSize < FSE_WKSP_SIZE_U32(tableLog, maxSymbolValue)) return ERROR(tableLog_tooLarge); if (wkspSize < FSE_WKSP_SIZE_U32(tableLog, maxSymbolValue)) return ERROR(tableLog_tooLarge);
if (srcSize <= 1) return 0; /* Not compressible */ if (srcSize <= 1) return 0; /* Not compressible */
if (!maxSymbolValue) maxSymbolValue = FSE_MAX_SYMBOL_VALUE; if (!maxSymbolValue) maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
if (!tableLog) tableLog = FSE_DEFAULT_TABLELOG; if (!tableLog) tableLog = FSE_DEFAULT_TABLELOG;
/* Scan input and build symbol stats */ /* Scan input and build symbol stats */
{ CHECK_V_F(maxCount, HIST_count_wksp(count, &maxSymbolValue, src, srcSize, (unsigned*)scratchBuffer) ); { CHECK_V_F(maxCount, HIST_count_wksp(count, &maxSymbolValue, src, srcSize, scratchBuffer, scratchBufferSize) );
if (maxCount == srcSize) return 1; /* only a single symbol in src : rle */ if (maxCount == srcSize) return 1; /* only a single symbol in src : rle */
if (maxCount == 1) return 0; /* each symbol present maximum once => not compressible */ if (maxCount == 1) return 0; /* each symbol present maximum once => not compressible */
if (maxCount < (srcSize >> 7)) return 0; /* Heuristic : not compressible enough */ if (maxCount < (srcSize >> 7)) return 0; /* Heuristic : not compressible enough */
} }
tableLog = FSE_optimalTableLog(tableLog, srcSize, maxSymbolValue); tableLog = FSE_optimalTableLog(tableLog, srcSize, maxSymbolValue);
CHECK_F( FSE_normalizeCount(norm, tableLog, count, srcSize, maxSymbolValue) ); CHECK_F( FSE_normalizeCount(norm, tableLog, count, srcSize, maxSymbolValue) );

contrib/python-zstandard/zstd/compress/hist.h

/* --- dependencies --- */ /* --- dependencies --- */
#include <stddef.h> /* size_t */ #include <stddef.h> /* size_t */
/* --- simple histogram functions --- */ /* --- simple histogram functions --- */
/*! HIST_count(): /*! HIST_count():
* Provides the precise count of each byte within a table 'count'. * Provides the precise count of each byte within a table 'count'.
* 'count' is a table of unsigned int, of minimum size (*maxSymbolValuePtr+1). * 'count' is a table of unsigned int, of minimum size (*maxSymbolValuePtr+1).
* Updates *maxSymbolValuePtr with actual largest symbol value detected. * Updates *maxSymbolValuePtr with actual largest symbol value detected.
* @return : count of the most frequent symbol (which isn't identified). * @return : count of the most frequent symbol (which isn't identified).
* or an error code, which can be tested using HIST_isError(). * or an error code, which can be tested using HIST_isError().
* note : if return == srcSize, there is only one symbol. * note : if return == srcSize, there is only one symbol.
*/ */
size_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr, size_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr,
const void* src, size_t srcSize); const void* src, size_t srcSize);
unsigned HIST_isError(size_t code); /**< tells if a return value is an error code */ unsigned HIST_isError(size_t code); /**< tells if a return value is an error code */
/* --- advanced histogram functions --- */ /* --- advanced histogram functions --- */
#define HIST_WKSP_SIZE_U32 1024 #define HIST_WKSP_SIZE_U32 1024
#define HIST_WKSP_SIZE (HIST_WKSP_SIZE_U32 * sizeof(unsigned))
/** HIST_count_wksp() : /** HIST_count_wksp() :
* Same as HIST_count(), but using an externally provided scratch buffer. * Same as HIST_count(), but using an externally provided scratch buffer.
* Benefit is this function will use very little stack space. * Benefit is this function will use very little stack space.
* `workSpace` must be a table of unsigned of size >= HIST_WKSP_SIZE_U32 * `workSpace` is a writable buffer which must be 4-bytes aligned,
* `workSpaceSize` must be >= HIST_WKSP_SIZE
*/ */
size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr, size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
const void* src, size_t srcSize, const void* src, size_t srcSize,
unsigned* workSpace); void* workSpace, size_t workSpaceSize);
/** HIST_countFast() : /** HIST_countFast() :
* same as HIST_count(), but blindly trusts that all byte values within src are <= *maxSymbolValuePtr. * same as HIST_count(), but blindly trusts that all byte values within src are <= *maxSymbolValuePtr.
* This function is unsafe, and will segfault if any value within `src` is `> *maxSymbolValuePtr` * This function is unsafe, and will segfault if any value within `src` is `> *maxSymbolValuePtr`
*/ */
size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr, size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr,
const void* src, size_t srcSize); const void* src, size_t srcSize);
/** HIST_countFast_wksp() : /** HIST_countFast_wksp() :
* Same as HIST_countFast(), but using an externally provided scratch buffer. * Same as HIST_countFast(), but using an externally provided scratch buffer.
* `workSpace` must be a table of unsigned of size >= HIST_WKSP_SIZE_U32 * `workSpace` is a writable buffer which must be 4-bytes aligned,
* `workSpaceSize` must be >= HIST_WKSP_SIZE
*/ */
size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr, size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
const void* src, size_t srcSize, const void* src, size_t srcSize,
unsigned* workSpace); void* workSpace, size_t workSpaceSize);
/*! HIST_count_simple() : /*! HIST_count_simple() :
* Same as HIST_countFast(), this function is unsafe, * Same as HIST_countFast(), this function is unsafe,
* and will segfault if any value within `src` is `> *maxSymbolValuePtr`. * and will segfault if any value within `src` is `> *maxSymbolValuePtr`.
* It is also a bit slower for large inputs. * It is also a bit slower for large inputs.
* However, it does not need any additional memory (not even on stack). * However, it does not need any additional memory (not even on stack).
* @return : count of the most frequent symbol. * @return : count of the most frequent symbol.
* Note this function doesn't produce any error (i.e. it must succeed). * Note this function doesn't produce any error (i.e. it must succeed).
*/ */
unsigned HIST_count_simple(unsigned* count, unsigned* maxSymbolValuePtr, unsigned HIST_count_simple(unsigned* count, unsigned* maxSymbolValuePtr,
const void* src, size_t srcSize); const void* src, size_t srcSize);

contrib/python-zstandard/zstd/compress/hist.c

{ U32 s; { U32 s;
for (s=0; s<=maxSymbolValue; s++) for (s=0; s<=maxSymbolValue; s++)
if (count[s] > largestCount) largestCount = count[s]; if (count[s] > largestCount) largestCount = count[s];
} }
return largestCount; return largestCount;
} }
typedef enum { trustInput, checkMaxSymbolValue } HIST_checkInput_e;
/* HIST_count_parallel_wksp() : /* HIST_count_parallel_wksp() :
* store histogram into 4 intermediate tables, recombined at the end. * store histogram into 4 intermediate tables, recombined at the end.
* this design makes better use of OoO cpus, * this design makes better use of OoO cpus,
* and is noticeably faster when some values are heavily repeated. * and is noticeably faster when some values are heavily repeated.
* But it needs some additional workspace for intermediate tables. * But it needs some additional workspace for intermediate tables.
* `workSpace` size must be a table of size >= HIST_WKSP_SIZE_U32. * `workSpace` size must be a table of size >= HIST_WKSP_SIZE_U32.
* @return : largest histogram frequency, * @return : largest histogram frequency,
* or an error code (notably when histogram would be larger than *maxSymbolValuePtr). */ * or an error code (notably when histogram would be larger than *maxSymbolValuePtr). */
static size_t HIST_count_parallel_wksp( static size_t HIST_count_parallel_wksp(
unsigned* count, unsigned* maxSymbolValuePtr, unsigned* count, unsigned* maxSymbolValuePtr,
const void* source, size_t sourceSize, const void* source, size_t sourceSize,
unsigned checkMax, HIST_checkInput_e check,
unsigned* const workSpace) U32* const workSpace)
{ {
const BYTE* ip = (const BYTE*)source; const BYTE* ip = (const BYTE*)source;
const BYTE* const iend = ip+sourceSize; const BYTE* const iend = ip+sourceSize;
unsigned maxSymbolValue = *maxSymbolValuePtr; unsigned maxSymbolValue = *maxSymbolValuePtr;
unsigned max=0; unsigned max=0;
U32* const Counting1 = workSpace; U32* const Counting1 = workSpace;
U32* const Counting2 = Counting1 + 256; U32* const Counting2 = Counting1 + 256;
U32* const Counting3 = Counting2 + 256; U32* const Counting3 = Counting2 + 256;
Counting4[ c>>24 ]++; Counting4[ c>>24 ]++;
} }
ip-=4; ip-=4;
} }
/* finish last symbols */ /* finish last symbols */
while (ip<iend) Counting1[*ip++]++; while (ip<iend) Counting1[*ip++]++;
if (checkMax) { /* verify stats will fit into destination table */ if (check) { /* verify stats will fit into destination table */
U32 s; for (s=255; s>maxSymbolValue; s--) { U32 s; for (s=255; s>maxSymbolValue; s--) {
Counting1[s] += Counting2[s] + Counting3[s] + Counting4[s]; Counting1[s] += Counting2[s] + Counting3[s] + Counting4[s];
if (Counting1[s]) return ERROR(maxSymbolValue_tooSmall); if (Counting1[s]) return ERROR(maxSymbolValue_tooSmall);
} } } }
{ U32 s; { U32 s;
if (maxSymbolValue > 255) maxSymbolValue = 255; if (maxSymbolValue > 255) maxSymbolValue = 255;
for (s=0; s<=maxSymbolValue; s++) { for (s=0; s<=maxSymbolValue; s++) {
count[s] = Counting1[s] + Counting2[s] + Counting3[s] + Counting4[s]; count[s] = Counting1[s] + Counting2[s] + Counting3[s] + Counting4[s];
if (count[s] > max) max = count[s]; if (count[s] > max) max = count[s];
} } } }
while (!count[maxSymbolValue]) maxSymbolValue--; while (!count[maxSymbolValue]) maxSymbolValue--;
*maxSymbolValuePtr = maxSymbolValue; *maxSymbolValuePtr = maxSymbolValue;
return (size_t)max; return (size_t)max;
} }
/* HIST_countFast_wksp() : /* HIST_countFast_wksp() :
* Same as HIST_countFast(), but using an externally provided scratch buffer. * Same as HIST_countFast(), but using an externally provided scratch buffer.
* `workSpace` size must be table of >= HIST_WKSP_SIZE_U32 unsigned */ * `workSpace` is a writable buffer which must be 4-bytes aligned,
* `workSpaceSize` must be >= HIST_WKSP_SIZE
*/
size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr, size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
const void* source, size_t sourceSize, const void* source, size_t sourceSize,
unsigned* workSpace) void* workSpace, size_t workSpaceSize)
{ {
if (sourceSize < 1500) /* heuristic threshold */ if (sourceSize < 1500) /* heuristic threshold */
return HIST_count_simple(count, maxSymbolValuePtr, source, sourceSize); return HIST_count_simple(count, maxSymbolValuePtr, source, sourceSize);
return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, 0, workSpace); if ((size_t)workSpace & 3) return ERROR(GENERIC); /* must be aligned on 4-bytes boundaries */
if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall);
return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, trustInput, (U32*)workSpace);
} }
/* fast variant (unsafe : won't check if src contains values beyond count[] limit) */ /* fast variant (unsafe : won't check if src contains values beyond count[] limit) */
size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr, size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr,
const void* source, size_t sourceSize) const void* source, size_t sourceSize)
{ {
unsigned tmpCounters[HIST_WKSP_SIZE_U32]; unsigned tmpCounters[HIST_WKSP_SIZE_U32];
return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, tmpCounters); return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, tmpCounters, sizeof(tmpCounters));
} }
/* HIST_count_wksp() : /* HIST_count_wksp() :
* Same as HIST_count(), but using an externally provided scratch buffer. * Same as HIST_count(), but using an externally provided scratch buffer.
* `workSpace` size must be table of >= HIST_WKSP_SIZE_U32 unsigned */ * `workSpace` size must be table of >= HIST_WKSP_SIZE_U32 unsigned */
size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr, size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
const void* source, size_t sourceSize, unsigned* workSpace) const void* source, size_t sourceSize,
void* workSpace, size_t workSpaceSize)
{ {
if ((size_t)workSpace & 3) return ERROR(GENERIC); /* must be aligned on 4-bytes boundaries */
if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall);
if (*maxSymbolValuePtr < 255) if (*maxSymbolValuePtr < 255)
return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, 1, workSpace); return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, checkMaxSymbolValue, (U32*)workSpace);
*maxSymbolValuePtr = 255; *maxSymbolValuePtr = 255;
return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, workSpace); return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, workSpace, workSpaceSize);
} }
size_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr, size_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr,
const void* src, size_t srcSize) const void* src, size_t srcSize)
{ {
unsigned tmpCounters[HIST_WKSP_SIZE_U32]; unsigned tmpCounters[HIST_WKSP_SIZE_U32];
return HIST_count_wksp(count, maxSymbolValuePtr, src, srcSize, tmpCounters); return HIST_count_wksp(count, maxSymbolValuePtr, src, srcSize, tmpCounters, sizeof(tmpCounters));
} }

contrib/python-zstandard/zstd/compress/huf_compress.c

*/ */
#define MAX_FSE_TABLELOG_FOR_HUFF_HEADER 6 #define MAX_FSE_TABLELOG_FOR_HUFF_HEADER 6
static size_t HUF_compressWeights (void* dst, size_t dstSize, const void* weightTable, size_t wtSize) static size_t HUF_compressWeights (void* dst, size_t dstSize, const void* weightTable, size_t wtSize)
{ {
BYTE* const ostart = (BYTE*) dst; BYTE* const ostart = (BYTE*) dst;
BYTE* op = ostart; BYTE* op = ostart;
BYTE* const oend = ostart + dstSize; BYTE* const oend = ostart + dstSize;
U32 maxSymbolValue = HUF_TABLELOG_MAX; unsigned maxSymbolValue = HUF_TABLELOG_MAX;
U32 tableLog = MAX_FSE_TABLELOG_FOR_HUFF_HEADER; U32 tableLog = MAX_FSE_TABLELOG_FOR_HUFF_HEADER;
FSE_CTable CTable[FSE_CTABLE_SIZE_U32(MAX_FSE_TABLELOG_FOR_HUFF_HEADER, HUF_TABLELOG_MAX)]; FSE_CTable CTable[FSE_CTABLE_SIZE_U32(MAX_FSE_TABLELOG_FOR_HUFF_HEADER, HUF_TABLELOG_MAX)];
BYTE scratchBuffer[1<<MAX_FSE_TABLELOG_FOR_HUFF_HEADER]; BYTE scratchBuffer[1<<MAX_FSE_TABLELOG_FOR_HUFF_HEADER];
U32 count[HUF_TABLELOG_MAX+1]; unsigned count[HUF_TABLELOG_MAX+1];
S16 norm[HUF_TABLELOG_MAX+1]; S16 norm[HUF_TABLELOG_MAX+1];
/* init conditions */ /* init conditions */
if (wtSize <= 1) return 0; /* Not compressible */ if (wtSize <= 1) return 0; /* Not compressible */
/* Scan input and build symbol stats */ /* Scan input and build symbol stats */
{ unsigned const maxCount = HIST_count_simple(count, &maxSymbolValue, weightTable, wtSize); /* never fails */ { unsigned const maxCount = HIST_count_simple(count, &maxSymbolValue, weightTable, wtSize); /* never fails */
if (maxCount == wtSize) return 1; /* only a single symbol in src : rle */ if (maxCount == wtSize) return 1; /* only a single symbol in src : rle */
U16 val; U16 val;
BYTE nbBits; BYTE nbBits;
}; /* typedef'd to HUF_CElt within "huf.h" */ }; /* typedef'd to HUF_CElt within "huf.h" */
/*! HUF_writeCTable() : /*! HUF_writeCTable() :
`CTable` : Huffman tree to save, using huf representation. `CTable` : Huffman tree to save, using huf representation.
@return : size of saved CTable */ @return : size of saved CTable */
size_t HUF_writeCTable (void* dst, size_t maxDstSize, size_t HUF_writeCTable (void* dst, size_t maxDstSize,
const HUF_CElt* CTable, U32 maxSymbolValue, U32 huffLog) const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog)
{ {
BYTE bitsToWeight[HUF_TABLELOG_MAX + 1]; /* precomputed conversion table */ BYTE bitsToWeight[HUF_TABLELOG_MAX + 1]; /* precomputed conversion table */
BYTE huffWeight[HUF_SYMBOLVALUE_MAX]; BYTE huffWeight[HUF_SYMBOLVALUE_MAX];
BYTE* op = (BYTE*)dst; BYTE* op = (BYTE*)dst;
U32 n; U32 n;
/* check conditions */ /* check conditions */
if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge); if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge);
op[0] = (BYTE)(128 /*special case*/ + (maxSymbolValue-1)); op[0] = (BYTE)(128 /*special case*/ + (maxSymbolValue-1));
huffWeight[maxSymbolValue] = 0; /* to be sure it doesn't cause msan issue in final combination */ huffWeight[maxSymbolValue] = 0; /* to be sure it doesn't cause msan issue in final combination */
for (n=0; n<maxSymbolValue; n+=2) for (n=0; n<maxSymbolValue; n+=2)
op[(n/2)+1] = (BYTE)((huffWeight[n] << 4) + huffWeight[n+1]); op[(n/2)+1] = (BYTE)((huffWeight[n] << 4) + huffWeight[n+1]);
return ((maxSymbolValue+1)/2) + 1; return ((maxSymbolValue+1)/2) + 1;
} }
size_t HUF_readCTable (HUF_CElt* CTable, U32* maxSymbolValuePtr, const void* src, size_t srcSize) size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize)
{ {
BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1]; /* init not required, even though some static analyzer may complain */ BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1]; /* init not required, even though some static analyzer may complain */
U32 rankVal[HUF_TABLELOG_ABSOLUTEMAX + 1]; /* large enough for values from 0 to 16 */ U32 rankVal[HUF_TABLELOG_ABSOLUTEMAX + 1]; /* large enough for values from 0 to 16 */
U32 tableLog = 0; U32 tableLog = 0;
U32 nbSymbols = 0; U32 nbSymbols = 0;
/* get symbol weights */ /* get symbol weights */
CHECK_V_F(readSize, HUF_readStats(huffWeight, HUF_SYMBOLVALUE_MAX+1, rankVal, &nbSymbols, &tableLog, src, srcSize)); CHECK_V_F(readSize, HUF_readStats(huffWeight, HUF_SYMBOLVALUE_MAX+1, rankVal, &nbSymbols, &tableLog, src, srcSize));
} }
typedef struct { typedef struct {
U32 base; U32 base;
U32 current; U32 current;
} rankPos; } rankPos;
static void HUF_sort(nodeElt* huffNode, const U32* count, U32 maxSymbolValue) static void HUF_sort(nodeElt* huffNode, const unsigned* count, U32 maxSymbolValue)
{ {
rankPos rank[32]; rankPos rank[32];
U32 n; U32 n;
memset(rank, 0, sizeof(rank)); memset(rank, 0, sizeof(rank));
for (n=0; n<=maxSymbolValue; n++) { for (n=0; n<=maxSymbolValue; n++) {
U32 r = BIT_highbit32(count[n] + 1); U32 r = BIT_highbit32(count[n] + 1);
rank[r].base ++; rank[r].base ++;
/** HUF_buildCTable_wksp() : /** HUF_buildCTable_wksp() :
* Same as HUF_buildCTable(), but using externally allocated scratch buffer. * Same as HUF_buildCTable(), but using externally allocated scratch buffer.
* `workSpace` must be aligned on 4-bytes boundaries, and be at least as large as a table of HUF_CTABLE_WORKSPACE_SIZE_U32 unsigned. * `workSpace` must be aligned on 4-bytes boundaries, and be at least as large as a table of HUF_CTABLE_WORKSPACE_SIZE_U32 unsigned.
*/ */
#define STARTNODE (HUF_SYMBOLVALUE_MAX+1) #define STARTNODE (HUF_SYMBOLVALUE_MAX+1)
typedef nodeElt huffNodeTable[HUF_CTABLE_WORKSPACE_SIZE_U32]; typedef nodeElt huffNodeTable[HUF_CTABLE_WORKSPACE_SIZE_U32];
size_t HUF_buildCTable_wksp (HUF_CElt* tree, const U32* count, U32 maxSymbolValue, U32 maxNbBits, void* workSpace, size_t wkspSize) size_t HUF_buildCTable_wksp (HUF_CElt* tree, const unsigned* count, U32 maxSymbolValue, U32 maxNbBits, void* workSpace, size_t wkspSize)
{ {
nodeElt* const huffNode0 = (nodeElt*)workSpace; nodeElt* const huffNode0 = (nodeElt*)workSpace;
nodeElt* const huffNode = huffNode0+1; nodeElt* const huffNode = huffNode0+1;
U32 n, nonNullRank; U32 n, nonNullRank;
int lowS, lowN; int lowS, lowN;
U16 nodeNb = STARTNODE; U16 nodeNb = STARTNODE;
U32 nodeRoot; U32 nodeRoot;
return maxNbBits; return maxNbBits;
} }
/** HUF_buildCTable() : /** HUF_buildCTable() :
* @return : maxNbBits * @return : maxNbBits
* Note : count is used before tree is written, so they can safely overlap * Note : count is used before tree is written, so they can safely overlap
*/ */
size_t HUF_buildCTable (HUF_CElt* tree, const U32* count, U32 maxSymbolValue, U32 maxNbBits) size_t HUF_buildCTable (HUF_CElt* tree, const unsigned* count, unsigned maxSymbolValue, unsigned maxNbBits)
{ {
huffNodeTable nodeTable; huffNodeTable nodeTable;
return HUF_buildCTable_wksp(tree, count, maxSymbolValue, maxNbBits, nodeTable, sizeof(nodeTable)); return HUF_buildCTable_wksp(tree, count, maxSymbolValue, maxNbBits, nodeTable, sizeof(nodeTable));
} }
static size_t HUF_estimateCompressedSize(HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue) static size_t HUF_estimateCompressedSize(HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue)
{ {
size_t nbBits = 0; size_t nbBits = 0;
return op-ostart; return op-ostart;
} }
size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable) size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable)
{ {
return HUF_compress4X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, /* bmi2 */ 0); return HUF_compress4X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, /* bmi2 */ 0);
} }
typedef enum { HUF_singleStream, HUF_fourStreams } HUF_nbStreams_e;
static size_t HUF_compressCTable_internal( static size_t HUF_compressCTable_internal(
BYTE* const ostart, BYTE* op, BYTE* const oend, BYTE* const ostart, BYTE* op, BYTE* const oend,
const void* src, size_t srcSize, const void* src, size_t srcSize,
unsigned singleStream, const HUF_CElt* CTable, const int bmi2) HUF_nbStreams_e nbStreams, const HUF_CElt* CTable, const int bmi2)
{ {
size_t const cSize = singleStream ? size_t const cSize = (nbStreams==HUF_singleStream) ?
HUF_compress1X_usingCTable_internal(op, oend - op, src, srcSize, CTable, bmi2) : HUF_compress1X_usingCTable_internal(op, oend - op, src, srcSize, CTable, bmi2) :
HUF_compress4X_usingCTable_internal(op, oend - op, src, srcSize, CTable, bmi2); HUF_compress4X_usingCTable_internal(op, oend - op, src, srcSize, CTable, bmi2);
if (HUF_isError(cSize)) { return cSize; } if (HUF_isError(cSize)) { return cSize; }
if (cSize==0) { return 0; } /* uncompressible */ if (cSize==0) { return 0; } /* uncompressible */
op += cSize; op += cSize;
/* check compressibility */ /* check compressibility */
if ((size_t)(op-ostart) >= srcSize-1) { return 0; } if ((size_t)(op-ostart) >= srcSize-1) { return 0; }
return op-ostart; return op-ostart;
} }
typedef struct { typedef struct {
U32 count[HUF_SYMBOLVALUE_MAX + 1]; unsigned count[HUF_SYMBOLVALUE_MAX + 1];
HUF_CElt CTable[HUF_SYMBOLVALUE_MAX + 1]; HUF_CElt CTable[HUF_SYMBOLVALUE_MAX + 1];
huffNodeTable nodeTable; huffNodeTable nodeTable;
} HUF_compress_tables_t; } HUF_compress_tables_t;
/* HUF_compress_internal() : /* HUF_compress_internal() :
* `workSpace` must a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */ * `workSpace` must a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */
static size_t HUF_compress_internal ( static size_t
void* dst, size_t dstSize, HUF_compress_internal (void* dst, size_t dstSize,
const void* src, size_t srcSize, const void* src, size_t srcSize,
unsigned maxSymbolValue, unsigned huffLog, unsigned maxSymbolValue, unsigned huffLog,
unsigned singleStream, HUF_nbStreams_e nbStreams,
void* workSpace, size_t wkspSize, void* workSpace, size_t wkspSize,
HUF_CElt* oldHufTable, HUF_repeat* repeat, int preferRepeat, HUF_CElt* oldHufTable, HUF_repeat* repeat, int preferRepeat,
const int bmi2) const int bmi2)
{ {
HUF_compress_tables_t* const table = (HUF_compress_tables_t*)workSpace; HUF_compress_tables_t* const table = (HUF_compress_tables_t*)workSpace;
BYTE* const ostart = (BYTE*)dst; BYTE* const ostart = (BYTE*)dst;
BYTE* const oend = ostart + dstSize; BYTE* const oend = ostart + dstSize;
BYTE* op = ostart; BYTE* op = ostart;
/* checks & inits */ /* checks & inits */
if (((size_t)workSpace & 3) != 0) return ERROR(GENERIC); /* must be aligned on 4-bytes boundaries */ if (((size_t)workSpace & 3) != 0) return ERROR(GENERIC); /* must be aligned on 4-bytes boundaries */
if (wkspSize < sizeof(*table)) return ERROR(workSpace_tooSmall); if (wkspSize < HUF_WORKSPACE_SIZE) return ERROR(workSpace_tooSmall);
if (!srcSize) return 0; /* Uncompressed */ if (!srcSize) return 0; /* Uncompressed */
if (!dstSize) return 0; /* cannot fit anything within dst budget */ if (!dstSize) return 0; /* cannot fit anything within dst budget */
if (srcSize > HUF_BLOCKSIZE_MAX) return ERROR(srcSize_wrong); /* current block size limit */ if (srcSize > HUF_BLOCKSIZE_MAX) return ERROR(srcSize_wrong); /* current block size limit */
if (huffLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge); if (huffLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge); if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge);
if (!maxSymbolValue) maxSymbolValue = HUF_SYMBOLVALUE_MAX; if (!maxSymbolValue) maxSymbolValue = HUF_SYMBOLVALUE_MAX;
if (!huffLog) huffLog = HUF_TABLELOG_DEFAULT; if (!huffLog) huffLog = HUF_TABLELOG_DEFAULT;
/* Heuristic : If old table is valid, use it for small inputs */ /* Heuristic : If old table is valid, use it for small inputs */
if (preferRepeat && repeat && *repeat == HUF_repeat_valid) { if (preferRepeat && repeat && *repeat == HUF_repeat_valid) {
return HUF_compressCTable_internal(ostart, op, oend, return HUF_compressCTable_internal(ostart, op, oend,
src, srcSize, src, srcSize,
singleStream, oldHufTable, bmi2); nbStreams, oldHufTable, bmi2);
} }
/* Scan input and build symbol stats */ /* Scan input and build symbol stats */
{ CHECK_V_F(largest, HIST_count_wksp (table->count, &maxSymbolValue, (const BYTE*)src, srcSize, table->count) ); { CHECK_V_F(largest, HIST_count_wksp (table->count, &maxSymbolValue, (const BYTE*)src, srcSize, workSpace, wkspSize) );
if (largest == srcSize) { *ostart = ((const BYTE*)src)[0]; return 1; } /* single symbol, rle */ if (largest == srcSize) { *ostart = ((const BYTE*)src)[0]; return 1; } /* single symbol, rle */
if (largest <= (srcSize >> 7)+4) return 0; /* heuristic : probably not compressible enough */ if (largest <= (srcSize >> 7)+4) return 0; /* heuristic : probably not compressible enough */
} }
/* Check validity of previous table */ /* Check validity of previous table */
if ( repeat if ( repeat
&& *repeat == HUF_repeat_check && *repeat == HUF_repeat_check
&& !HUF_validateCTable(oldHufTable, table->count, maxSymbolValue)) { && !HUF_validateCTable(oldHufTable, table->count, maxSymbolValue)) {
*repeat = HUF_repeat_none; *repeat = HUF_repeat_none;
} }
/* Heuristic : use existing table for small inputs */ /* Heuristic : use existing table for small inputs */
if (preferRepeat && repeat && *repeat != HUF_repeat_none) { if (preferRepeat && repeat && *repeat != HUF_repeat_none) {
return HUF_compressCTable_internal(ostart, op, oend, return HUF_compressCTable_internal(ostart, op, oend,
src, srcSize, src, srcSize,
singleStream, oldHufTable, bmi2); nbStreams, oldHufTable, bmi2);
} }
/* Build Huffman Tree */ /* Build Huffman Tree */
huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue); huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue);
{ CHECK_V_F(maxBits, HUF_buildCTable_wksp(table->CTable, table->count, { size_t const maxBits = HUF_buildCTable_wksp(table->CTable, table->count,
maxSymbolValue, huffLog, maxSymbolValue, huffLog,
table->nodeTable, sizeof(table->nodeTable)) ); table->nodeTable, sizeof(table->nodeTable));
CHECK_F(maxBits);
huffLog = (U32)maxBits; huffLog = (U32)maxBits;
/* Zero unused symbols in CTable, so we can check it for validity */ /* Zero unused symbols in CTable, so we can check it for validity */
memset(table->CTable + (maxSymbolValue + 1), 0, memset(table->CTable + (maxSymbolValue + 1), 0,
sizeof(table->CTable) - ((maxSymbolValue + 1) * sizeof(HUF_CElt))); sizeof(table->CTable) - ((maxSymbolValue + 1) * sizeof(HUF_CElt)));
} }
/* Write table description header */ /* Write table description header */
{ CHECK_V_F(hSize, HUF_writeCTable (op, dstSize, table->CTable, maxSymbolValue, huffLog) ); { CHECK_V_F(hSize, HUF_writeCTable (op, dstSize, table->CTable, maxSymbolValue, huffLog) );
/* Check if using previous huffman table is beneficial */ /* Check if using previous huffman table is beneficial */
if (repeat && *repeat != HUF_repeat_none) { if (repeat && *repeat != HUF_repeat_none) {
size_t const oldSize = HUF_estimateCompressedSize(oldHufTable, table->count, maxSymbolValue); size_t const oldSize = HUF_estimateCompressedSize(oldHufTable, table->count, maxSymbolValue);
size_t const newSize = HUF_estimateCompressedSize(table->CTable, table->count, maxSymbolValue); size_t const newSize = HUF_estimateCompressedSize(table->CTable, table->count, maxSymbolValue);
if (oldSize <= hSize + newSize || hSize + 12 >= srcSize) { if (oldSize <= hSize + newSize || hSize + 12 >= srcSize) {
return HUF_compressCTable_internal(ostart, op, oend, return HUF_compressCTable_internal(ostart, op, oend,
src, srcSize, src, srcSize,
singleStream, oldHufTable, bmi2); nbStreams, oldHufTable, bmi2);
} } } }
/* Use the new huffman table */ /* Use the new huffman table */
if (hSize + 12ul >= srcSize) { return 0; } if (hSize + 12ul >= srcSize) { return 0; }
op += hSize; op += hSize;
if (repeat) { *repeat = HUF_repeat_none; } if (repeat) { *repeat = HUF_repeat_none; }
if (oldHufTable) if (oldHufTable)
memcpy(oldHufTable, table->CTable, sizeof(table->CTable)); /* Save new table */ memcpy(oldHufTable, table->CTable, sizeof(table->CTable)); /* Save new table */
} }
return HUF_compressCTable_internal(ostart, op, oend, return HUF_compressCTable_internal(ostart, op, oend,
src, srcSize, src, srcSize,
singleStream, table->CTable, bmi2); nbStreams, table->CTable, bmi2);
} }
size_t HUF_compress1X_wksp (void* dst, size_t dstSize, size_t HUF_compress1X_wksp (void* dst, size_t dstSize,
const void* src, size_t srcSize, const void* src, size_t srcSize,
unsigned maxSymbolValue, unsigned huffLog, unsigned maxSymbolValue, unsigned huffLog,
void* workSpace, size_t wkspSize) void* workSpace, size_t wkspSize)
{ {
return HUF_compress_internal(dst, dstSize, src, srcSize, return HUF_compress_internal(dst, dstSize, src, srcSize,
maxSymbolValue, huffLog, 1 /*single stream*/, maxSymbolValue, huffLog, HUF_singleStream,
workSpace, wkspSize, workSpace, wkspSize,
NULL, NULL, 0, 0 /*bmi2*/); NULL, NULL, 0, 0 /*bmi2*/);
} }
size_t HUF_compress1X_repeat (void* dst, size_t dstSize, size_t HUF_compress1X_repeat (void* dst, size_t dstSize,
const void* src, size_t srcSize, const void* src, size_t srcSize,
unsigned maxSymbolValue, unsigned huffLog, unsigned maxSymbolValue, unsigned huffLog,
void* workSpace, size_t wkspSize, void* workSpace, size_t wkspSize,
HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2) HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2)
{ {
return HUF_compress_internal(dst, dstSize, src, srcSize, return HUF_compress_internal(dst, dstSize, src, srcSize,
maxSymbolValue, huffLog, 1 /*single stream*/, maxSymbolValue, huffLog, HUF_singleStream,
workSpace, wkspSize, hufTable, workSpace, wkspSize, hufTable,
repeat, preferRepeat, bmi2); repeat, preferRepeat, bmi2);
} }
size_t HUF_compress1X (void* dst, size_t dstSize, size_t HUF_compress1X (void* dst, size_t dstSize,
const void* src, size_t srcSize, const void* src, size_t srcSize,
unsigned maxSymbolValue, unsigned huffLog) unsigned maxSymbolValue, unsigned huffLog)
{ {
unsigned workSpace[HUF_WORKSPACE_SIZE_U32]; unsigned workSpace[HUF_WORKSPACE_SIZE_U32];
return HUF_compress1X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace)); return HUF_compress1X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace));
} }
/* HUF_compress4X_repeat(): /* HUF_compress4X_repeat():
* compress input using 4 streams. * compress input using 4 streams.
* provide workspace to generate compression tables */ * provide workspace to generate compression tables */
size_t HUF_compress4X_wksp (void* dst, size_t dstSize, size_t HUF_compress4X_wksp (void* dst, size_t dstSize,
const void* src, size_t srcSize, const void* src, size_t srcSize,
unsigned maxSymbolValue, unsigned huffLog, unsigned maxSymbolValue, unsigned huffLog,
void* workSpace, size_t wkspSize) void* workSpace, size_t wkspSize)
{ {
return HUF_compress_internal(dst, dstSize, src, srcSize, return HUF_compress_internal(dst, dstSize, src, srcSize,
maxSymbolValue, huffLog, 0 /*4 streams*/, maxSymbolValue, huffLog, HUF_fourStreams,
workSpace, wkspSize, workSpace, wkspSize,
NULL, NULL, 0, 0 /*bmi2*/); NULL, NULL, 0, 0 /*bmi2*/);
} }
/* HUF_compress4X_repeat(): /* HUF_compress4X_repeat():
* compress input using 4 streams. * compress input using 4 streams.
* re-use an existing huffman compression table */ * re-use an existing huffman compression table */
size_t HUF_compress4X_repeat (void* dst, size_t dstSize, size_t HUF_compress4X_repeat (void* dst, size_t dstSize,
const void* src, size_t srcSize, const void* src, size_t srcSize,
unsigned maxSymbolValue, unsigned huffLog, unsigned maxSymbolValue, unsigned huffLog,
void* workSpace, size_t wkspSize, void* workSpace, size_t wkspSize,
HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2) HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2)
{ {
return HUF_compress_internal(dst, dstSize, src, srcSize, return HUF_compress_internal(dst, dstSize, src, srcSize,
maxSymbolValue, huffLog, 0 /* 4 streams */, maxSymbolValue, huffLog, HUF_fourStreams,
workSpace, wkspSize, workSpace, wkspSize,
hufTable, repeat, preferRepeat, bmi2); hufTable, repeat, preferRepeat, bmi2);
} }
size_t HUF_compress2 (void* dst, size_t dstSize, size_t HUF_compress2 (void* dst, size_t dstSize,
const void* src, size_t srcSize, const void* src, size_t srcSize,
unsigned maxSymbolValue, unsigned huffLog) unsigned maxSymbolValue, unsigned huffLog)
{ {
unsigned workSpace[HUF_WORKSPACE_SIZE_U32]; unsigned workSpace[HUF_WORKSPACE_SIZE_U32];
return HUF_compress4X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace)); return HUF_compress4X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace));
} }
size_t HUF_compress (void* dst, size_t maxDstSize, const void* src, size_t srcSize) size_t HUF_compress (void* dst, size_t maxDstSize, const void* src, size_t srcSize)
{ {
return HUF_compress2(dst, maxDstSize, src, srcSize, 255, HUF_TABLELOG_DEFAULT); return HUF_compress2(dst, maxDstSize, src, srcSize, 255, HUF_TABLELOG_DEFAULT);
} }

contrib/python-zstandard/zstd/compress/zstd_compress.c

/* /*
* Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
* All rights reserved. * All rights reserved.
* *
* This source code is licensed under both the BSD-style license (found in the * 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 * 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). * in the COPYING file in the root directory of this source tree).
* You may select, at your option, one of the above-listed licenses. * You may select, at your option, one of the above-listed licenses.
*/ */
/*-************************************* /*-*************************************
* Dependencies * Dependencies
***************************************/ ***************************************/
#include <limits.h> /* INT_MAX */
#include <string.h> /* memset */ #include <string.h> /* memset */
#include "cpu.h" #include "cpu.h"
#include "mem.h" #include "mem.h"
#include "hist.h" /* HIST_countFast_wksp */ #include "hist.h" /* HIST_countFast_wksp */
#define FSE_STATIC_LINKING_ONLY /* FSE_encodeSymbol */ #define FSE_STATIC_LINKING_ONLY /* FSE_encodeSymbol */
#include "fse.h" #include "fse.h"
#define HUF_STATIC_LINKING_ONLY #define HUF_STATIC_LINKING_ONLY
#include "huf.h" #include "huf.h"
} }
static void ZSTD_initCCtx(ZSTD_CCtx* cctx, ZSTD_customMem memManager) static void ZSTD_initCCtx(ZSTD_CCtx* cctx, ZSTD_customMem memManager)
{ {
assert(cctx != NULL); assert(cctx != NULL);
memset(cctx, 0, sizeof(*cctx)); memset(cctx, 0, sizeof(*cctx));
cctx->customMem = memManager; cctx->customMem = memManager;
cctx->bmi2 = ZSTD_cpuid_bmi2(ZSTD_cpuid()); cctx->bmi2 = ZSTD_cpuid_bmi2(ZSTD_cpuid());
{ size_t const err = ZSTD_CCtx_resetParameters(cctx); { size_t const err = ZSTD_CCtx_reset(cctx, ZSTD_reset_parameters);
assert(!ZSTD_isError(err)); assert(!ZSTD_isError(err));
(void)err; (void)err;
} }
} }
ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem) ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem)
{ {
ZSTD_STATIC_ASSERT(zcss_init==0); ZSTD_STATIC_ASSERT(zcss_init==0);
} }
static size_t ZSTD_sizeof_mtctx(const ZSTD_CCtx* cctx) static size_t ZSTD_sizeof_mtctx(const ZSTD_CCtx* cctx)
{ {
#ifdef ZSTD_MULTITHREAD #ifdef ZSTD_MULTITHREAD
return ZSTDMT_sizeof_CCtx(cctx->mtctx); return ZSTDMT_sizeof_CCtx(cctx->mtctx);
#else #else
(void) cctx; (void)cctx;
return 0; return 0;
#endif #endif
} }
size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx) size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx)
{ {
if (cctx==NULL) return 0; /* support sizeof on NULL */ if (cctx==NULL) return 0; /* support sizeof on NULL */
ZSTD_CCtx_params ret = cctxParams; ZSTD_CCtx_params ret = cctxParams;
ret.cParams = params.cParams; ret.cParams = params.cParams;
ret.fParams = params.fParams; ret.fParams = params.fParams;
ret.compressionLevel = ZSTD_CLEVEL_DEFAULT; /* should not matter, as all cParams are presumed properly defined */ ret.compressionLevel = ZSTD_CLEVEL_DEFAULT; /* should not matter, as all cParams are presumed properly defined */
assert(!ZSTD_checkCParams(params.cParams)); assert(!ZSTD_checkCParams(params.cParams));
return ret; return ret;
} }
#define CLAMPCHECK(val,min,max) { \ ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter param)
if (((val)<(min)) | ((val)>(max))) { \ {
ZSTD_bounds bounds = { 0, 0, 0 };
switch(param)
{
case ZSTD_c_compressionLevel:
bounds.lowerBound = ZSTD_minCLevel();
bounds.upperBound = ZSTD_maxCLevel();
return bounds;
case ZSTD_c_windowLog:
bounds.lowerBound = ZSTD_WINDOWLOG_MIN;
bounds.upperBound = ZSTD_WINDOWLOG_MAX;
return bounds;
case ZSTD_c_hashLog:
bounds.lowerBound = ZSTD_HASHLOG_MIN;
bounds.upperBound = ZSTD_HASHLOG_MAX;
return bounds;
case ZSTD_c_chainLog:
bounds.lowerBound = ZSTD_CHAINLOG_MIN;
bounds.upperBound = ZSTD_CHAINLOG_MAX;
return bounds;
case ZSTD_c_searchLog:
bounds.lowerBound = ZSTD_SEARCHLOG_MIN;
bounds.upperBound = ZSTD_SEARCHLOG_MAX;
return bounds;
case ZSTD_c_minMatch:
bounds.lowerBound = ZSTD_MINMATCH_MIN;
bounds.upperBound = ZSTD_MINMATCH_MAX;
return bounds;
case ZSTD_c_targetLength:
bounds.lowerBound = ZSTD_TARGETLENGTH_MIN;
bounds.upperBound = ZSTD_TARGETLENGTH_MAX;
return bounds;
case ZSTD_c_strategy:
bounds.lowerBound = ZSTD_STRATEGY_MIN;
bounds.upperBound = ZSTD_STRATEGY_MAX;
return bounds;
case ZSTD_c_contentSizeFlag:
bounds.lowerBound = 0;
bounds.upperBound = 1;
return bounds;
case ZSTD_c_checksumFlag:
bounds.lowerBound = 0;
bounds.upperBound = 1;
return bounds;
case ZSTD_c_dictIDFlag:
bounds.lowerBound = 0;
bounds.upperBound = 1;
return bounds;
case ZSTD_c_nbWorkers:
bounds.lowerBound = 0;
#ifdef ZSTD_MULTITHREAD
bounds.upperBound = ZSTDMT_NBWORKERS_MAX;
#else
bounds.upperBound = 0;
#endif
return bounds;
case ZSTD_c_jobSize:
bounds.lowerBound = 0;
#ifdef ZSTD_MULTITHREAD
bounds.upperBound = ZSTDMT_JOBSIZE_MAX;
#else
bounds.upperBound = 0;
#endif
return bounds;
case ZSTD_c_overlapLog:
bounds.lowerBound = ZSTD_OVERLAPLOG_MIN;
bounds.upperBound = ZSTD_OVERLAPLOG_MAX;
return bounds;
case ZSTD_c_enableLongDistanceMatching:
bounds.lowerBound = 0;
bounds.upperBound = 1;
return bounds;
case ZSTD_c_ldmHashLog:
bounds.lowerBound = ZSTD_LDM_HASHLOG_MIN;
bounds.upperBound = ZSTD_LDM_HASHLOG_MAX;
return bounds;
case ZSTD_c_ldmMinMatch:
bounds.lowerBound = ZSTD_LDM_MINMATCH_MIN;
bounds.upperBound = ZSTD_LDM_MINMATCH_MAX;
return bounds;
case ZSTD_c_ldmBucketSizeLog:
bounds.lowerBound = ZSTD_LDM_BUCKETSIZELOG_MIN;
bounds.upperBound = ZSTD_LDM_BUCKETSIZELOG_MAX;
return bounds;
case ZSTD_c_ldmHashRateLog:
bounds.lowerBound = ZSTD_LDM_HASHRATELOG_MIN;
bounds.upperBound = ZSTD_LDM_HASHRATELOG_MAX;
return bounds;
/* experimental parameters */
case ZSTD_c_rsyncable:
bounds.lowerBound = 0;
bounds.upperBound = 1;
return bounds;
case ZSTD_c_forceMaxWindow :
bounds.lowerBound = 0;
bounds.upperBound = 1;
return bounds;
case ZSTD_c_format:
ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless);
bounds.lowerBound = ZSTD_f_zstd1;
bounds.upperBound = ZSTD_f_zstd1_magicless; /* note : how to ensure at compile time that this is the highest value enum ? */
return bounds;
case ZSTD_c_forceAttachDict:
ZSTD_STATIC_ASSERT(ZSTD_dictDefaultAttach < ZSTD_dictForceCopy);
bounds.lowerBound = ZSTD_dictDefaultAttach;
bounds.upperBound = ZSTD_dictForceCopy; /* note : how to ensure at compile time that this is the highest value enum ? */
return bounds;
default:
{ ZSTD_bounds const boundError = { ERROR(parameter_unsupported), 0, 0 };
return boundError;
}
}
}
/* ZSTD_cParam_withinBounds:
* @return 1 if value is within cParam bounds,
* 0 otherwise */
static int ZSTD_cParam_withinBounds(ZSTD_cParameter cParam, int value)
{
ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);
if (ZSTD_isError(bounds.error)) return 0;
if (value < bounds.lowerBound) return 0;
if (value > bounds.upperBound) return 0;
return 1;
}
#define BOUNDCHECK(cParam, val) { \
if (!ZSTD_cParam_withinBounds(cParam,val)) { \
return ERROR(parameter_outOfBound); \ return ERROR(parameter_outOfBound); \
} } } }
static int ZSTD_isUpdateAuthorized(ZSTD_cParameter param) static int ZSTD_isUpdateAuthorized(ZSTD_cParameter param)
{ {
switch(param) switch(param)
{ {
case ZSTD_p_compressionLevel: case ZSTD_c_compressionLevel:
case ZSTD_p_hashLog: case ZSTD_c_hashLog:
case ZSTD_p_chainLog: case ZSTD_c_chainLog:
case ZSTD_p_searchLog: case ZSTD_c_searchLog:
case ZSTD_p_minMatch: case ZSTD_c_minMatch:
case ZSTD_p_targetLength: case ZSTD_c_targetLength:
case ZSTD_p_compressionStrategy: case ZSTD_c_strategy:
return 1; return 1;
case ZSTD_p_format: case ZSTD_c_format:
case ZSTD_p_windowLog: case ZSTD_c_windowLog:
case ZSTD_p_contentSizeFlag: case ZSTD_c_contentSizeFlag:
case ZSTD_p_checksumFlag: case ZSTD_c_checksumFlag:
case ZSTD_p_dictIDFlag: case ZSTD_c_dictIDFlag:
case ZSTD_p_forceMaxWindow : case ZSTD_c_forceMaxWindow :
case ZSTD_p_nbWorkers: case ZSTD_c_nbWorkers:
case ZSTD_p_jobSize: case ZSTD_c_jobSize:
case ZSTD_p_overlapSizeLog: case ZSTD_c_overlapLog:
case ZSTD_p_enableLongDistanceMatching: case ZSTD_c_rsyncable:
case ZSTD_p_ldmHashLog: case ZSTD_c_enableLongDistanceMatching:
case ZSTD_p_ldmMinMatch: case ZSTD_c_ldmHashLog:
case ZSTD_p_ldmBucketSizeLog: case ZSTD_c_ldmMinMatch:
case ZSTD_p_ldmHashEveryLog: case ZSTD_c_ldmBucketSizeLog:
case ZSTD_p_forceAttachDict: case ZSTD_c_ldmHashRateLog:
case ZSTD_c_forceAttachDict:
default: default:
return 0; return 0;
} }
} }
size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned value) size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value)
{ {
DEBUGLOG(4, "ZSTD_CCtx_setParameter (%u, %u)", (U32)param, value); DEBUGLOG(4, "ZSTD_CCtx_setParameter (%i, %i)", (int)param, value);
if (cctx->streamStage != zcss_init) { if (cctx->streamStage != zcss_init) {
if (ZSTD_isUpdateAuthorized(param)) { if (ZSTD_isUpdateAuthorized(param)) {
cctx->cParamsChanged = 1; cctx->cParamsChanged = 1;
} else { } else {
return ERROR(stage_wrong); return ERROR(stage_wrong);
} } } }
switch(param) switch(param)
{ {
case ZSTD_p_format : case ZSTD_c_format :
return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value); return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
case ZSTD_p_compressionLevel: case ZSTD_c_compressionLevel:
if (cctx->cdict) return ERROR(stage_wrong); if (cctx->cdict) return ERROR(stage_wrong);
return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value); return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
case ZSTD_p_windowLog: case ZSTD_c_windowLog:
case ZSTD_p_hashLog: case ZSTD_c_hashLog:
case ZSTD_p_chainLog: case ZSTD_c_chainLog:
case ZSTD_p_searchLog: case ZSTD_c_searchLog:
case ZSTD_p_minMatch: case ZSTD_c_minMatch:
case ZSTD_p_targetLength: case ZSTD_c_targetLength:
case ZSTD_p_compressionStrategy: case ZSTD_c_strategy:
if (cctx->cdict) return ERROR(stage_wrong); if (cctx->cdict) return ERROR(stage_wrong);
return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value); return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
case ZSTD_p_contentSizeFlag: case ZSTD_c_contentSizeFlag:
case ZSTD_p_checksumFlag: case ZSTD_c_checksumFlag:
case ZSTD_p_dictIDFlag: case ZSTD_c_dictIDFlag:
return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value); return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
case ZSTD_p_forceMaxWindow : /* Force back-references to remain < windowSize, case ZSTD_c_forceMaxWindow : /* Force back-references to remain < windowSize,
* even when referencing into Dictionary content. * even when referencing into Dictionary content.
* default : 0 when using a CDict, 1 when using a Prefix */ * default : 0 when using a CDict, 1 when using a Prefix */
return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value); return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
case ZSTD_p_forceAttachDict: case ZSTD_c_forceAttachDict:
return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value); return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
case ZSTD_p_nbWorkers: case ZSTD_c_nbWorkers:
if ((value>0) && cctx->staticSize) { if ((value!=0) && cctx->staticSize) {
return ERROR(parameter_unsupported); /* MT not compatible with static alloc */ return ERROR(parameter_unsupported); /* MT not compatible with static alloc */
} }
return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value); return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
case ZSTD_p_jobSize: case ZSTD_c_jobSize:
case ZSTD_p_overlapSizeLog: case ZSTD_c_overlapLog:
case ZSTD_c_rsyncable:
return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value); return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
case ZSTD_p_enableLongDistanceMatching: case ZSTD_c_enableLongDistanceMatching:
case ZSTD_p_ldmHashLog: case ZSTD_c_ldmHashLog:
case ZSTD_p_ldmMinMatch: case ZSTD_c_ldmMinMatch:
case ZSTD_p_ldmBucketSizeLog: case ZSTD_c_ldmBucketSizeLog:
case ZSTD_p_ldmHashEveryLog: case ZSTD_c_ldmHashRateLog:
if (cctx->cdict) return ERROR(stage_wrong); if (cctx->cdict) return ERROR(stage_wrong);
return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value); return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
default: return ERROR(parameter_unsupported); default: return ERROR(parameter_unsupported);
} }
} }
size_t ZSTD_CCtxParam_setParameter( size_t ZSTD_CCtxParam_setParameter(ZSTD_CCtx_params* CCtxParams,
ZSTD_CCtx_params* CCtxParams, ZSTD_cParameter param, unsigned value) ZSTD_cParameter param, int value)
{ {
DEBUGLOG(4, "ZSTD_CCtxParam_setParameter (%u, %u)", (U32)param, value); DEBUGLOG(4, "ZSTD_CCtxParam_setParameter (%i, %i)", (int)param, value);
switch(param) switch(param)
{ {
case ZSTD_p_format : case ZSTD_c_format :
if (value > (unsigned)ZSTD_f_zstd1_magicless) BOUNDCHECK(ZSTD_c_format, value);
return ERROR(parameter_unsupported);
CCtxParams->format = (ZSTD_format_e)value; CCtxParams->format = (ZSTD_format_e)value;
return (size_t)CCtxParams->format; return (size_t)CCtxParams->format;
case ZSTD_p_compressionLevel : { case ZSTD_c_compressionLevel : {
int cLevel = (int)value; /* cast expected to restore negative sign */ int cLevel = value;
if (cLevel > ZSTD_maxCLevel()) cLevel = ZSTD_maxCLevel(); if (cLevel > ZSTD_maxCLevel()) cLevel = ZSTD_maxCLevel();
if (cLevel < ZSTD_minCLevel()) cLevel = ZSTD_minCLevel();
if (cLevel) { /* 0 : does not change current level */ if (cLevel) { /* 0 : does not change current level */
CCtxParams->compressionLevel = cLevel; CCtxParams->compressionLevel = cLevel;
} }
if (CCtxParams->compressionLevel >= 0) return CCtxParams->compressionLevel; if (CCtxParams->compressionLevel >= 0) return CCtxParams->compressionLevel;
return 0; /* return type (size_t) cannot represent negative values */ return 0; /* return type (size_t) cannot represent negative values */
} }
case ZSTD_p_windowLog : case ZSTD_c_windowLog :
if (value>0) /* 0 => use default */ if (value!=0) /* 0 => use default */
CLAMPCHECK(value, ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX); BOUNDCHECK(ZSTD_c_windowLog, value);
CCtxParams->cParams.windowLog = value; CCtxParams->cParams.windowLog = value;
return CCtxParams->cParams.windowLog; return CCtxParams->cParams.windowLog;
case ZSTD_p_hashLog : case ZSTD_c_hashLog :
if (value>0) /* 0 => use default */ if (value!=0) /* 0 => use default */
CLAMPCHECK(value, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX); BOUNDCHECK(ZSTD_c_hashLog, value);
CCtxParams->cParams.hashLog = value; CCtxParams->cParams.hashLog = value;
return CCtxParams->cParams.hashLog; return CCtxParams->cParams.hashLog;
case ZSTD_p_chainLog : case ZSTD_c_chainLog :
if (value>0) /* 0 => use default */ if (value!=0) /* 0 => use default */
CLAMPCHECK(value, ZSTD_CHAINLOG_MIN, ZSTD_CHAINLOG_MAX); BOUNDCHECK(ZSTD_c_chainLog, value);
CCtxParams->cParams.chainLog = value; CCtxParams->cParams.chainLog = value;
return CCtxParams->cParams.chainLog; return CCtxParams->cParams.chainLog;
case ZSTD_p_searchLog : case ZSTD_c_searchLog :
if (value>0) /* 0 => use default */ if (value!=0) /* 0 => use default */
CLAMPCHECK(value, ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX); BOUNDCHECK(ZSTD_c_searchLog, value);
CCtxParams->cParams.searchLog = value; CCtxParams->cParams.searchLog = value;
return value; return value;
case ZSTD_p_minMatch : case ZSTD_c_minMatch :
if (value>0) /* 0 => use default */ if (value!=0) /* 0 => use default */
CLAMPCHECK(value, ZSTD_SEARCHLENGTH_MIN, ZSTD_SEARCHLENGTH_MAX); BOUNDCHECK(ZSTD_c_minMatch, value);
CCtxParams->cParams.searchLength = value; CCtxParams->cParams.minMatch = value;
return CCtxParams->cParams.searchLength; return CCtxParams->cParams.minMatch;
case ZSTD_p_targetLength : case ZSTD_c_targetLength :
/* all values are valid. 0 => use default */ BOUNDCHECK(ZSTD_c_targetLength, value);
CCtxParams->cParams.targetLength = value; CCtxParams->cParams.targetLength = value;
return CCtxParams->cParams.targetLength; return CCtxParams->cParams.targetLength;
case ZSTD_p_compressionStrategy : case ZSTD_c_strategy :
if (value>0) /* 0 => use default */ if (value!=0) /* 0 => use default */
CLAMPCHECK(value, (unsigned)ZSTD_fast, (unsigned)ZSTD_btultra); BOUNDCHECK(ZSTD_c_strategy, value);
CCtxParams->cParams.strategy = (ZSTD_strategy)value; CCtxParams->cParams.strategy = (ZSTD_strategy)value;
return (size_t)CCtxParams->cParams.strategy; return (size_t)CCtxParams->cParams.strategy;
case ZSTD_p_contentSizeFlag : case ZSTD_c_contentSizeFlag :
/* Content size written in frame header _when known_ (default:1) */ /* Content size written in frame header _when known_ (default:1) */
DEBUGLOG(4, "set content size flag = %u", (value>0)); DEBUGLOG(4, "set content size flag = %u", (value!=0));
CCtxParams->fParams.contentSizeFlag = value > 0; CCtxParams->fParams.contentSizeFlag = value != 0;
return CCtxParams->fParams.contentSizeFlag; return CCtxParams->fParams.contentSizeFlag;
case ZSTD_p_checksumFlag : case ZSTD_c_checksumFlag :
/* A 32-bits content checksum will be calculated and written at end of frame (default:0) */ /* A 32-bits content checksum will be calculated and written at end of frame (default:0) */
CCtxParams->fParams.checksumFlag = value > 0; CCtxParams->fParams.checksumFlag = value != 0;
return CCtxParams->fParams.checksumFlag; return CCtxParams->fParams.checksumFlag;
case ZSTD_p_dictIDFlag : /* When applicable, dictionary's dictID is provided in frame header (default:1) */ case ZSTD_c_dictIDFlag : /* When applicable, dictionary's dictID is provided in frame header (default:1) */
DEBUGLOG(4, "set dictIDFlag = %u", (value>0)); DEBUGLOG(4, "set dictIDFlag = %u", (value!=0));
CCtxParams->fParams.noDictIDFlag = !value; CCtxParams->fParams.noDictIDFlag = !value;
return !CCtxParams->fParams.noDictIDFlag; return !CCtxParams->fParams.noDictIDFlag;
case ZSTD_p_forceMaxWindow : case ZSTD_c_forceMaxWindow :
CCtxParams->forceWindow = (value > 0); CCtxParams->forceWindow = (value != 0);
return CCtxParams->forceWindow; return CCtxParams->forceWindow;
case ZSTD_p_forceAttachDict : case ZSTD_c_forceAttachDict : {
CCtxParams->attachDictPref = value ? const ZSTD_dictAttachPref_e pref = (ZSTD_dictAttachPref_e)value;
(value > 0 ? ZSTD_dictForceAttach : ZSTD_dictForceCopy) : BOUNDCHECK(ZSTD_c_forceAttachDict, pref);
ZSTD_dictDefaultAttach; CCtxParams->attachDictPref = pref;
return CCtxParams->attachDictPref; return CCtxParams->attachDictPref;
}
case ZSTD_p_nbWorkers : case ZSTD_c_nbWorkers :
#ifndef ZSTD_MULTITHREAD #ifndef ZSTD_MULTITHREAD
if (value>0) return ERROR(parameter_unsupported); if (value!=0) return ERROR(parameter_unsupported);
return 0; return 0;
#else #else
return ZSTDMT_CCtxParam_setNbWorkers(CCtxParams, value); return ZSTDMT_CCtxParam_setNbWorkers(CCtxParams, value);
#endif #endif
case ZSTD_p_jobSize : case ZSTD_c_jobSize :
#ifndef ZSTD_MULTITHREAD #ifndef ZSTD_MULTITHREAD
return ERROR(parameter_unsupported); return ERROR(parameter_unsupported);
#else #else
return ZSTDMT_CCtxParam_setMTCtxParameter(CCtxParams, ZSTDMT_p_jobSize, value); return ZSTDMT_CCtxParam_setMTCtxParameter(CCtxParams, ZSTDMT_p_jobSize, value);
#endif #endif
case ZSTD_p_overlapSizeLog : case ZSTD_c_overlapLog :
#ifndef ZSTD_MULTITHREAD
return ERROR(parameter_unsupported);
#else
return ZSTDMT_CCtxParam_setMTCtxParameter(CCtxParams, ZSTDMT_p_overlapLog, value);
#endif
case ZSTD_c_rsyncable :
#ifndef ZSTD_MULTITHREAD #ifndef ZSTD_MULTITHREAD
return ERROR(parameter_unsupported); return ERROR(parameter_unsupported);
#else #else
return ZSTDMT_CCtxParam_setMTCtxParameter(CCtxParams, ZSTDMT_p_overlapSectionLog, value); return ZSTDMT_CCtxParam_setMTCtxParameter(CCtxParams, ZSTDMT_p_rsyncable, value);
#endif #endif
case ZSTD_p_enableLongDistanceMatching : case ZSTD_c_enableLongDistanceMatching :
CCtxParams->ldmParams.enableLdm = (value>0); CCtxParams->ldmParams.enableLdm = (value!=0);
return CCtxParams->ldmParams.enableLdm; return CCtxParams->ldmParams.enableLdm;
case ZSTD_p_ldmHashLog : case ZSTD_c_ldmHashLog :
if (value>0) /* 0 ==> auto */ if (value!=0) /* 0 ==> auto */
CLAMPCHECK(value, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX); BOUNDCHECK(ZSTD_c_ldmHashLog, value);
CCtxParams->ldmParams.hashLog = value; CCtxParams->ldmParams.hashLog = value;
return CCtxParams->ldmParams.hashLog; return CCtxParams->ldmParams.hashLog;
case ZSTD_p_ldmMinMatch : case ZSTD_c_ldmMinMatch :
if (value>0) /* 0 ==> default */ if (value!=0) /* 0 ==> default */
CLAMPCHECK(value, ZSTD_LDM_MINMATCH_MIN, ZSTD_LDM_MINMATCH_MAX); BOUNDCHECK(ZSTD_c_ldmMinMatch, value);
CCtxParams->ldmParams.minMatchLength = value; CCtxParams->ldmParams.minMatchLength = value;
return CCtxParams->ldmParams.minMatchLength; return CCtxParams->ldmParams.minMatchLength;
case ZSTD_p_ldmBucketSizeLog : case ZSTD_c_ldmBucketSizeLog :
if (value > ZSTD_LDM_BUCKETSIZELOG_MAX) if (value!=0) /* 0 ==> default */
return ERROR(parameter_outOfBound); BOUNDCHECK(ZSTD_c_ldmBucketSizeLog, value);
CCtxParams->ldmParams.bucketSizeLog = value; CCtxParams->ldmParams.bucketSizeLog = value;
return CCtxParams->ldmParams.bucketSizeLog; return CCtxParams->ldmParams.bucketSizeLog;
case ZSTD_p_ldmHashEveryLog : case ZSTD_c_ldmHashRateLog :
if (value > ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN) if (value > ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN)
return ERROR(parameter_outOfBound); return ERROR(parameter_outOfBound);
CCtxParams->ldmParams.hashEveryLog = value; CCtxParams->ldmParams.hashRateLog = value;
return CCtxParams->ldmParams.hashEveryLog; return CCtxParams->ldmParams.hashRateLog;
default: return ERROR(parameter_unsupported); default: return ERROR(parameter_unsupported);
} }
} }
size_t ZSTD_CCtx_getParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned* value) size_t ZSTD_CCtx_getParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int* value)
{ {
return ZSTD_CCtxParam_getParameter(&cctx->requestedParams, param, value); return ZSTD_CCtxParam_getParameter(&cctx->requestedParams, param, value);
} }
size_t ZSTD_CCtxParam_getParameter( size_t ZSTD_CCtxParam_getParameter(
ZSTD_CCtx_params* CCtxParams, ZSTD_cParameter param, unsigned* value) ZSTD_CCtx_params* CCtxParams, ZSTD_cParameter param, int* value)
{ {
switch(param) switch(param)
{ {
case ZSTD_p_format : case ZSTD_c_format :
*value = CCtxParams->format; *value = CCtxParams->format;
break; break;
case ZSTD_p_compressionLevel : case ZSTD_c_compressionLevel :
*value = CCtxParams->compressionLevel; *value = CCtxParams->compressionLevel;
break; break;
case ZSTD_p_windowLog : case ZSTD_c_windowLog :
*value = CCtxParams->cParams.windowLog; *value = CCtxParams->cParams.windowLog;
break; break;
case ZSTD_p_hashLog : case ZSTD_c_hashLog :
*value = CCtxParams->cParams.hashLog; *value = CCtxParams->cParams.hashLog;
break; break;
case ZSTD_p_chainLog : case ZSTD_c_chainLog :
*value = CCtxParams->cParams.chainLog; *value = CCtxParams->cParams.chainLog;
break; break;
case ZSTD_p_searchLog : case ZSTD_c_searchLog :
*value = CCtxParams->cParams.searchLog; *value = CCtxParams->cParams.searchLog;
break; break;
case ZSTD_p_minMatch : case ZSTD_c_minMatch :
*value = CCtxParams->cParams.searchLength; *value = CCtxParams->cParams.minMatch;
break; break;
case ZSTD_p_targetLength : case ZSTD_c_targetLength :
*value = CCtxParams->cParams.targetLength; *value = CCtxParams->cParams.targetLength;
break; break;
case ZSTD_p_compressionStrategy : case ZSTD_c_strategy :
*value = (unsigned)CCtxParams->cParams.strategy; *value = (unsigned)CCtxParams->cParams.strategy;
break; break;
case ZSTD_p_contentSizeFlag : case ZSTD_c_contentSizeFlag :
*value = CCtxParams->fParams.contentSizeFlag; *value = CCtxParams->fParams.contentSizeFlag;
break; break;
case ZSTD_p_checksumFlag : case ZSTD_c_checksumFlag :
*value = CCtxParams->fParams.checksumFlag; *value = CCtxParams->fParams.checksumFlag;
break; break;
case ZSTD_p_dictIDFlag : case ZSTD_c_dictIDFlag :
*value = !CCtxParams->fParams.noDictIDFlag; *value = !CCtxParams->fParams.noDictIDFlag;
break; break;
case ZSTD_p_forceMaxWindow : case ZSTD_c_forceMaxWindow :
*value = CCtxParams->forceWindow; *value = CCtxParams->forceWindow;
break; break;
case ZSTD_p_forceAttachDict : case ZSTD_c_forceAttachDict :
*value = CCtxParams->attachDictPref; *value = CCtxParams->attachDictPref;
break; break;
case ZSTD_p_nbWorkers : case ZSTD_c_nbWorkers :
#ifndef ZSTD_MULTITHREAD #ifndef ZSTD_MULTITHREAD
assert(CCtxParams->nbWorkers == 0); assert(CCtxParams->nbWorkers == 0);
#endif #endif
*value = CCtxParams->nbWorkers; *value = CCtxParams->nbWorkers;
break; break;
case ZSTD_p_jobSize : case ZSTD_c_jobSize :
#ifndef ZSTD_MULTITHREAD #ifndef ZSTD_MULTITHREAD
return ERROR(parameter_unsupported); return ERROR(parameter_unsupported);
#else #else
*value = CCtxParams->jobSize; assert(CCtxParams->jobSize <= INT_MAX);
*value = (int)CCtxParams->jobSize;
break; break;
#endif #endif
case ZSTD_p_overlapSizeLog : case ZSTD_c_overlapLog :
#ifndef ZSTD_MULTITHREAD #ifndef ZSTD_MULTITHREAD
return ERROR(parameter_unsupported); return ERROR(parameter_unsupported);
#else #else
*value = CCtxParams->overlapSizeLog; *value = CCtxParams->overlapLog;
break; break;
#endif #endif
case ZSTD_p_enableLongDistanceMatching : case ZSTD_c_rsyncable :
#ifndef ZSTD_MULTITHREAD
return ERROR(parameter_unsupported);
#else
*value = CCtxParams->rsyncable;
break;
#endif
case ZSTD_c_enableLongDistanceMatching :
*value = CCtxParams->ldmParams.enableLdm; *value = CCtxParams->ldmParams.enableLdm;
break; break;
case ZSTD_p_ldmHashLog : case ZSTD_c_ldmHashLog :
*value = CCtxParams->ldmParams.hashLog; *value = CCtxParams->ldmParams.hashLog;
break; break;
case ZSTD_p_ldmMinMatch : case ZSTD_c_ldmMinMatch :
*value = CCtxParams->ldmParams.minMatchLength; *value = CCtxParams->ldmParams.minMatchLength;
break; break;
case ZSTD_p_ldmBucketSizeLog : case ZSTD_c_ldmBucketSizeLog :
*value = CCtxParams->ldmParams.bucketSizeLog; *value = CCtxParams->ldmParams.bucketSizeLog;
break; break;
case ZSTD_p_ldmHashEveryLog : case ZSTD_c_ldmHashRateLog :
*value = CCtxParams->ldmParams.hashEveryLog; *value = CCtxParams->ldmParams.hashRateLog;
break; break;
default: return ERROR(parameter_unsupported); default: return ERROR(parameter_unsupported);
} }
return 0; return 0;
} }
/** ZSTD_CCtx_setParametersUsingCCtxParams() : /** ZSTD_CCtx_setParametersUsingCCtxParams() :
* just applies `params` into `cctx` * just applies `params` into `cctx`
cctx->prefixDict.dict = prefix; cctx->prefixDict.dict = prefix;
cctx->prefixDict.dictSize = prefixSize; cctx->prefixDict.dictSize = prefixSize;
cctx->prefixDict.dictContentType = dictContentType; cctx->prefixDict.dictContentType = dictContentType;
return 0; return 0;
} }
/*! ZSTD_CCtx_reset() : /*! ZSTD_CCtx_reset() :
* Also dumps dictionary */ * Also dumps dictionary */
void ZSTD_CCtx_reset(ZSTD_CCtx* cctx) size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset)
{ {
if ( (reset == ZSTD_reset_session_only)
|| (reset == ZSTD_reset_session_and_parameters) ) {
cctx->streamStage = zcss_init; cctx->streamStage = zcss_init;
cctx->pledgedSrcSizePlusOne = 0; cctx->pledgedSrcSizePlusOne = 0;
} }
if ( (reset == ZSTD_reset_parameters)
size_t ZSTD_CCtx_resetParameters(ZSTD_CCtx* cctx) || (reset == ZSTD_reset_session_and_parameters) ) {
{
if (cctx->streamStage != zcss_init) return ERROR(stage_wrong); if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
cctx->cdict = NULL; cctx->cdict = NULL;
return ZSTD_CCtxParams_reset(&cctx->requestedParams); return ZSTD_CCtxParams_reset(&cctx->requestedParams);
} }
return 0;
}
/** ZSTD_checkCParams() : /** ZSTD_checkCParams() :
control CParam values remain within authorized range. control CParam values remain within authorized range.
@return : 0, or an error code if one value is beyond authorized range */ @return : 0, or an error code if one value is beyond authorized range */
size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams) size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
{ {
CLAMPCHECK(cParams.windowLog, ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX); BOUNDCHECK(ZSTD_c_windowLog, cParams.windowLog);
CLAMPCHECK(cParams.chainLog, ZSTD_CHAINLOG_MIN, ZSTD_CHAINLOG_MAX); BOUNDCHECK(ZSTD_c_chainLog, cParams.chainLog);
CLAMPCHECK(cParams.hashLog, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX); BOUNDCHECK(ZSTD_c_hashLog, cParams.hashLog);
CLAMPCHECK(cParams.searchLog, ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX); BOUNDCHECK(ZSTD_c_searchLog, cParams.searchLog);
CLAMPCHECK(cParams.searchLength, ZSTD_SEARCHLENGTH_MIN, ZSTD_SEARCHLENGTH_MAX); BOUNDCHECK(ZSTD_c_minMatch, cParams.minMatch);
ZSTD_STATIC_ASSERT(ZSTD_TARGETLENGTH_MIN == 0); BOUNDCHECK(ZSTD_c_targetLength,cParams.targetLength);
if (cParams.targetLength > ZSTD_TARGETLENGTH_MAX) BOUNDCHECK(ZSTD_c_strategy, cParams.strategy);
return ERROR(parameter_outOfBound);
if ((U32)(cParams.strategy) > (U32)ZSTD_btultra)
return ERROR(parameter_unsupported);
return 0; return 0;
} }
/** ZSTD_clampCParams() : /** ZSTD_clampCParams() :
* make CParam values within valid range. * make CParam values within valid range.
* @return : valid CParams */ * @return : valid CParams */
static ZSTD_compressionParameters static ZSTD_compressionParameters
ZSTD_clampCParams(ZSTD_compressionParameters cParams) ZSTD_clampCParams(ZSTD_compressionParameters cParams)
{ {
# define CLAMP(val,min,max) { \ # define CLAMP_TYPE(cParam, val, type) { \
if (val<min) val=min; \ ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam); \
else if (val>max) val=max; \ if ((int)val<bounds.lowerBound) val=(type)bounds.lowerBound; \
} else if ((int)val>bounds.upperBound) val=(type)bounds.upperBound; \
CLAMP(cParams.windowLog, ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX); }
CLAMP(cParams.chainLog, ZSTD_CHAINLOG_MIN, ZSTD_CHAINLOG_MAX); # define CLAMP(cParam, val) CLAMP_TYPE(cParam, val, int)
CLAMP(cParams.hashLog, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX); CLAMP(ZSTD_c_windowLog, cParams.windowLog);
CLAMP(cParams.searchLog, ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX); CLAMP(ZSTD_c_chainLog, cParams.chainLog);
CLAMP(cParams.searchLength, ZSTD_SEARCHLENGTH_MIN, ZSTD_SEARCHLENGTH_MAX); CLAMP(ZSTD_c_hashLog, cParams.hashLog);
ZSTD_STATIC_ASSERT(ZSTD_TARGETLENGTH_MIN == 0); CLAMP(ZSTD_c_searchLog, cParams.searchLog);
if (cParams.targetLength > ZSTD_TARGETLENGTH_MAX) CLAMP(ZSTD_c_minMatch, cParams.minMatch);
cParams.targetLength = ZSTD_TARGETLENGTH_MAX; CLAMP(ZSTD_c_targetLength,cParams.targetLength);
CLAMP(cParams.strategy, ZSTD_fast, ZSTD_btultra); CLAMP_TYPE(ZSTD_c_strategy,cParams.strategy, ZSTD_strategy);
return cParams; return cParams;
} }
/** ZSTD_cycleLog() : /** ZSTD_cycleLog() :
* condition for correct operation : hashLog > 1 */ * condition for correct operation : hashLog > 1 */
static U32 ZSTD_cycleLog(U32 hashLog, ZSTD_strategy strat) static U32 ZSTD_cycleLog(U32 hashLog, ZSTD_strategy strat)
{ {
U32 const btScale = ((U32)strat >= (U32)ZSTD_btlazy2); U32 const btScale = ((U32)strat >= (U32)ZSTD_btlazy2);
const ZSTD_CCtx_params* CCtxParams, U64 srcSizeHint, size_t dictSize) const ZSTD_CCtx_params* CCtxParams, U64 srcSizeHint, size_t dictSize)
{ {
ZSTD_compressionParameters cParams = ZSTD_getCParams(CCtxParams->compressionLevel, srcSizeHint, dictSize); ZSTD_compressionParameters cParams = ZSTD_getCParams(CCtxParams->compressionLevel, srcSizeHint, dictSize);
if (CCtxParams->ldmParams.enableLdm) cParams.windowLog = ZSTD_LDM_DEFAULT_WINDOW_LOG; if (CCtxParams->ldmParams.enableLdm) cParams.windowLog = ZSTD_LDM_DEFAULT_WINDOW_LOG;
if (CCtxParams->cParams.windowLog) cParams.windowLog = CCtxParams->cParams.windowLog; if (CCtxParams->cParams.windowLog) cParams.windowLog = CCtxParams->cParams.windowLog;
if (CCtxParams->cParams.hashLog) cParams.hashLog = CCtxParams->cParams.hashLog; if (CCtxParams->cParams.hashLog) cParams.hashLog = CCtxParams->cParams.hashLog;
if (CCtxParams->cParams.chainLog) cParams.chainLog = CCtxParams->cParams.chainLog; if (CCtxParams->cParams.chainLog) cParams.chainLog = CCtxParams->cParams.chainLog;
if (CCtxParams->cParams.searchLog) cParams.searchLog = CCtxParams->cParams.searchLog; if (CCtxParams->cParams.searchLog) cParams.searchLog = CCtxParams->cParams.searchLog;
if (CCtxParams->cParams.searchLength) cParams.searchLength = CCtxParams->cParams.searchLength; if (CCtxParams->cParams.minMatch) cParams.minMatch = CCtxParams->cParams.minMatch;
if (CCtxParams->cParams.targetLength) cParams.targetLength = CCtxParams->cParams.targetLength; if (CCtxParams->cParams.targetLength) cParams.targetLength = CCtxParams->cParams.targetLength;
if (CCtxParams->cParams.strategy) cParams.strategy = CCtxParams->cParams.strategy; if (CCtxParams->cParams.strategy) cParams.strategy = CCtxParams->cParams.strategy;
assert(!ZSTD_checkCParams(cParams)); assert(!ZSTD_checkCParams(cParams));
return ZSTD_adjustCParams_internal(cParams, srcSizeHint, dictSize); return ZSTD_adjustCParams_internal(cParams, srcSizeHint, dictSize);
} }
static size_t static size_t
ZSTD_sizeof_matchState(const ZSTD_compressionParameters* const cParams, ZSTD_sizeof_matchState(const ZSTD_compressionParameters* const cParams,
const U32 forCCtx) const U32 forCCtx)
{ {
size_t const chainSize = (cParams->strategy == ZSTD_fast) ? 0 : ((size_t)1 << cParams->chainLog); size_t const chainSize = (cParams->strategy == ZSTD_fast) ? 0 : ((size_t)1 << cParams->chainLog);
size_t const hSize = ((size_t)1) << cParams->hashLog; size_t const hSize = ((size_t)1) << cParams->hashLog;
U32 const hashLog3 = (forCCtx && cParams->searchLength==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0; U32 const hashLog3 = (forCCtx && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
size_t const h3Size = ((size_t)1) << hashLog3; size_t const h3Size = ((size_t)1) << hashLog3;
size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32); size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);
size_t const optPotentialSpace = ((MaxML+1) + (MaxLL+1) + (MaxOff+1) + (1<<Litbits)) * sizeof(U32) size_t const optPotentialSpace = ((MaxML+1) + (MaxLL+1) + (MaxOff+1) + (1<<Litbits)) * sizeof(U32)
+ (ZSTD_OPT_NUM+1) * (sizeof(ZSTD_match_t)+sizeof(ZSTD_optimal_t)); + (ZSTD_OPT_NUM+1) * (sizeof(ZSTD_match_t)+sizeof(ZSTD_optimal_t));
size_t const optSpace = (forCCtx && ((cParams->strategy == ZSTD_btopt) || size_t const optSpace = (forCCtx && (cParams->strategy >= ZSTD_btopt))
(cParams->strategy == ZSTD_btultra)))
? optPotentialSpace ? optPotentialSpace
: 0; : 0;
DEBUGLOG(4, "chainSize: %u - hSize: %u - h3Size: %u", DEBUGLOG(4, "chainSize: %u - hSize: %u - h3Size: %u",
(U32)chainSize, (U32)hSize, (U32)h3Size); (U32)chainSize, (U32)hSize, (U32)h3Size);
return tableSpace + optSpace; return tableSpace + optSpace;
} }
size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params) size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params)
{ {
/* Estimate CCtx size is supported for single-threaded compression only. */ /* Estimate CCtx size is supported for single-threaded compression only. */
if (params->nbWorkers > 0) { return ERROR(GENERIC); } if (params->nbWorkers > 0) { return ERROR(GENERIC); }
{ ZSTD_compressionParameters const cParams = { ZSTD_compressionParameters const cParams =
ZSTD_getCParamsFromCCtxParams(params, 0, 0); ZSTD_getCParamsFromCCtxParams(params, 0, 0);
size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, (size_t)1 << cParams.windowLog); size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, (size_t)1 << cParams.windowLog);
U32 const divider = (cParams.searchLength==3) ? 3 : 4; U32 const divider = (cParams.minMatch==3) ? 3 : 4;
size_t const maxNbSeq = blockSize / divider; size_t const maxNbSeq = blockSize / divider;
size_t const tokenSpace = WILDCOPY_OVERLENGTH + blockSize + 11*maxNbSeq; size_t const tokenSpace = WILDCOPY_OVERLENGTH + blockSize + 11*maxNbSeq;
size_t const entropySpace = HUF_WORKSPACE_SIZE; size_t const entropySpace = HUF_WORKSPACE_SIZE;
size_t const blockStateSpace = 2 * sizeof(ZSTD_compressedBlockState_t); size_t const blockStateSpace = 2 * sizeof(ZSTD_compressedBlockState_t);
size_t const matchStateSize = ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 1); size_t const matchStateSize = ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 1);
size_t const ldmSpace = ZSTD_ldm_getTableSize(params->ldmParams); size_t const ldmSpace = ZSTD_ldm_getTableSize(params->ldmParams);
size_t const ldmSeqSpace = ZSTD_ldm_getMaxNbSeq(params->ldmParams, blockSize) * sizeof(rawSeq); size_t const ldmSeqSpace = ZSTD_ldm_getMaxNbSeq(params->ldmParams, blockSize) * sizeof(rawSeq);
ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, 0, 0); ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, 0, 0);
return ZSTD_estimateCCtxSize_usingCParams(cParams); return ZSTD_estimateCCtxSize_usingCParams(cParams);
} }
size_t ZSTD_estimateCCtxSize(int compressionLevel) size_t ZSTD_estimateCCtxSize(int compressionLevel)
{ {
int level; int level;
size_t memBudget = 0; size_t memBudget = 0;
for (level=1; level<=compressionLevel; level++) { for (level=MIN(compressionLevel, 1); level<=compressionLevel; level++) {
size_t const newMB = ZSTD_estimateCCtxSize_internal(level); size_t const newMB = ZSTD_estimateCCtxSize_internal(level);
if (newMB > memBudget) memBudget = newMB; if (newMB > memBudget) memBudget = newMB;
} }
return memBudget; return memBudget;
} }
size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params) size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params)
{ {
ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, 0, 0); ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, 0, 0);
return ZSTD_estimateCStreamSize_usingCParams(cParams); return ZSTD_estimateCStreamSize_usingCParams(cParams);
} }
size_t ZSTD_estimateCStreamSize(int compressionLevel) size_t ZSTD_estimateCStreamSize(int compressionLevel)
{ {
int level; int level;
size_t memBudget = 0; size_t memBudget = 0;
for (level=1; level<=compressionLevel; level++) { for (level=MIN(compressionLevel, 1); level<=compressionLevel; level++) {
size_t const newMB = ZSTD_estimateCStreamSize_internal(level); size_t const newMB = ZSTD_estimateCStreamSize_internal(level);
if (newMB > memBudget) memBudget = newMB; if (newMB > memBudget) memBudget = newMB;
} }
return memBudget; return memBudget;
} }
/* ZSTD_getFrameProgression(): /* ZSTD_getFrameProgression():
* tells how much data has been consumed (input) and produced (output) for current frame. * tells how much data has been consumed (input) and produced (output) for current frame.
static U32 ZSTD_equivalentCParams(ZSTD_compressionParameters cParams1, static U32 ZSTD_equivalentCParams(ZSTD_compressionParameters cParams1,
ZSTD_compressionParameters cParams2) ZSTD_compressionParameters cParams2)
{ {
return (cParams1.hashLog == cParams2.hashLog) return (cParams1.hashLog == cParams2.hashLog)
& (cParams1.chainLog == cParams2.chainLog) & (cParams1.chainLog == cParams2.chainLog)
& (cParams1.strategy == cParams2.strategy) /* opt parser space */ & (cParams1.strategy == cParams2.strategy) /* opt parser space */
& ((cParams1.searchLength==3) == (cParams2.searchLength==3)); /* hashlog3 space */ & ((cParams1.minMatch==3) == (cParams2.minMatch==3)); /* hashlog3 space */
} }
static void ZSTD_assertEqualCParams(ZSTD_compressionParameters cParams1, static void ZSTD_assertEqualCParams(ZSTD_compressionParameters cParams1,
ZSTD_compressionParameters cParams2) ZSTD_compressionParameters cParams2)
{ {
(void)cParams1; (void)cParams1;
(void)cParams2; (void)cParams2;
assert(cParams1.windowLog == cParams2.windowLog); assert(cParams1.windowLog == cParams2.windowLog);
assert(cParams1.chainLog == cParams2.chainLog); assert(cParams1.chainLog == cParams2.chainLog);
assert(cParams1.hashLog == cParams2.hashLog); assert(cParams1.hashLog == cParams2.hashLog);
assert(cParams1.searchLog == cParams2.searchLog); assert(cParams1.searchLog == cParams2.searchLog);
assert(cParams1.searchLength == cParams2.searchLength); assert(cParams1.minMatch == cParams2.minMatch);
assert(cParams1.targetLength == cParams2.targetLength); assert(cParams1.targetLength == cParams2.targetLength);
assert(cParams1.strategy == cParams2.strategy); assert(cParams1.strategy == cParams2.strategy);
} }
/** The parameters are equivalent if ldm is not enabled in both sets or /** The parameters are equivalent if ldm is not enabled in both sets or
* all the parameters are equivalent. */ * all the parameters are equivalent. */
static U32 ZSTD_equivalentLdmParams(ldmParams_t ldmParams1, static U32 ZSTD_equivalentLdmParams(ldmParams_t ldmParams1,
ldmParams_t ldmParams2) ldmParams_t ldmParams2)
{ {
return (!ldmParams1.enableLdm && !ldmParams2.enableLdm) || return (!ldmParams1.enableLdm && !ldmParams2.enableLdm) ||
(ldmParams1.enableLdm == ldmParams2.enableLdm && (ldmParams1.enableLdm == ldmParams2.enableLdm &&
ldmParams1.hashLog == ldmParams2.hashLog && ldmParams1.hashLog == ldmParams2.hashLog &&
ldmParams1.bucketSizeLog == ldmParams2.bucketSizeLog && ldmParams1.bucketSizeLog == ldmParams2.bucketSizeLog &&
ldmParams1.minMatchLength == ldmParams2.minMatchLength && ldmParams1.minMatchLength == ldmParams2.minMatchLength &&
ldmParams1.hashEveryLog == ldmParams2.hashEveryLog); ldmParams1.hashRateLog == ldmParams2.hashRateLog);
} }
typedef enum { ZSTDb_not_buffered, ZSTDb_buffered } ZSTD_buffered_policy_e; typedef enum { ZSTDb_not_buffered, ZSTDb_buffered } ZSTD_buffered_policy_e;
/* ZSTD_sufficientBuff() : /* ZSTD_sufficientBuff() :
* check internal buffers exist for streaming if buffPol == ZSTDb_buffered . * check internal buffers exist for streaming if buffPol == ZSTDb_buffered .
* Note : they are assumed to be correctly sized if ZSTD_equivalentCParams()==1 */ * Note : they are assumed to be correctly sized if ZSTD_equivalentCParams()==1 */
static U32 ZSTD_sufficientBuff(size_t bufferSize1, size_t maxNbSeq1, static U32 ZSTD_sufficientBuff(size_t bufferSize1, size_t maxNbSeq1,
size_t maxNbLit1, size_t maxNbLit1,
ZSTD_buffered_policy_e buffPol2, ZSTD_buffered_policy_e buffPol2,
ZSTD_compressionParameters cParams2, ZSTD_compressionParameters cParams2,
U64 pledgedSrcSize) U64 pledgedSrcSize)
{ {
size_t const windowSize2 = MAX(1, (size_t)MIN(((U64)1 << cParams2.windowLog), pledgedSrcSize)); size_t const windowSize2 = MAX(1, (size_t)MIN(((U64)1 << cParams2.windowLog), pledgedSrcSize));
size_t const blockSize2 = MIN(ZSTD_BLOCKSIZE_MAX, windowSize2); size_t const blockSize2 = MIN(ZSTD_BLOCKSIZE_MAX, windowSize2);
size_t const maxNbSeq2 = blockSize2 / ((cParams2.searchLength == 3) ? 3 : 4); size_t const maxNbSeq2 = blockSize2 / ((cParams2.minMatch == 3) ? 3 : 4);
size_t const maxNbLit2 = blockSize2; size_t const maxNbLit2 = blockSize2;
size_t const neededBufferSize2 = (buffPol2==ZSTDb_buffered) ? windowSize2 + blockSize2 : 0; size_t const neededBufferSize2 = (buffPol2==ZSTDb_buffered) ? windowSize2 + blockSize2 : 0;
DEBUGLOG(4, "ZSTD_sufficientBuff: is neededBufferSize2=%u <= bufferSize1=%u", DEBUGLOG(4, "ZSTD_sufficientBuff: is neededBufferSize2=%u <= bufferSize1=%u",
(U32)neededBufferSize2, (U32)bufferSize1); (U32)neededBufferSize2, (U32)bufferSize1);
DEBUGLOG(4, "ZSTD_sufficientBuff: is maxNbSeq2=%u <= maxNbSeq1=%u", DEBUGLOG(4, "ZSTD_sufficientBuff: is maxNbSeq2=%u <= maxNbSeq1=%u",
(U32)maxNbSeq2, (U32)maxNbSeq1); (U32)maxNbSeq2, (U32)maxNbSeq1);
DEBUGLOG(4, "ZSTD_sufficientBuff: is maxNbLit2=%u <= maxNbLit1=%u", DEBUGLOG(4, "ZSTD_sufficientBuff: is maxNbLit2=%u <= maxNbLit1=%u",
(U32)maxNbLit2, (U32)maxNbLit1); (U32)maxNbLit2, (U32)maxNbLit1);
/*! ZSTD_invalidateMatchState() /*! ZSTD_invalidateMatchState()
* Invalidate all the matches in the match finder tables. * Invalidate all the matches in the match finder tables.
* Requires nextSrc and base to be set (can be NULL). * Requires nextSrc and base to be set (can be NULL).
*/ */
static void ZSTD_invalidateMatchState(ZSTD_matchState_t* ms) static void ZSTD_invalidateMatchState(ZSTD_matchState_t* ms)
{ {
ZSTD_window_clear(&ms->window); ZSTD_window_clear(&ms->window);
ms->nextToUpdate = ms->window.dictLimit + 1; ms->nextToUpdate = ms->window.dictLimit;
ms->nextToUpdate3 = ms->window.dictLimit + 1; ms->nextToUpdate3 = ms->window.dictLimit;
ms->loadedDictEnd = 0; ms->loadedDictEnd = 0;
ms->opt.litLengthSum = 0; /* force reset of btopt stats */ ms->opt.litLengthSum = 0; /* force reset of btopt stats */
ms->dictMatchState = NULL; ms->dictMatchState = NULL;
} }
/*! ZSTD_continueCCtx() : /*! ZSTD_continueCCtx() :
* reuse CCtx without reset (note : requires no dictionary) */ * reuse CCtx without reset (note : requires no dictionary) */
static size_t ZSTD_continueCCtx(ZSTD_CCtx* cctx, ZSTD_CCtx_params params, U64 pledgedSrcSize) static size_t ZSTD_continueCCtx(ZSTD_CCtx* cctx, ZSTD_CCtx_params params, U64 pledgedSrcSize)
static void* static void*
ZSTD_reset_matchState(ZSTD_matchState_t* ms, ZSTD_reset_matchState(ZSTD_matchState_t* ms,
void* ptr, void* ptr,
const ZSTD_compressionParameters* cParams, const ZSTD_compressionParameters* cParams,
ZSTD_compResetPolicy_e const crp, U32 const forCCtx) ZSTD_compResetPolicy_e const crp, U32 const forCCtx)
{ {
size_t const chainSize = (cParams->strategy == ZSTD_fast) ? 0 : ((size_t)1 << cParams->chainLog); size_t const chainSize = (cParams->strategy == ZSTD_fast) ? 0 : ((size_t)1 << cParams->chainLog);
size_t const hSize = ((size_t)1) << cParams->hashLog; size_t const hSize = ((size_t)1) << cParams->hashLog;
U32 const hashLog3 = (forCCtx && cParams->searchLength==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0; U32 const hashLog3 = (forCCtx && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
size_t const h3Size = ((size_t)1) << hashLog3; size_t const h3Size = ((size_t)1) << hashLog3;
size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32); size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);
assert(((size_t)ptr & 3) == 0); assert(((size_t)ptr & 3) == 0);
ms->hashLog3 = hashLog3; ms->hashLog3 = hashLog3;
memset(&ms->window, 0, sizeof(ms->window)); memset(&ms->window, 0, sizeof(ms->window));
ms->window.dictLimit = 1; /* start from 1, so that 1st position is valid */ ms->window.dictLimit = 1; /* start from 1, so that 1st position is valid */
ms->window.lowLimit = 1; /* it ensures first and later CCtx usages compress the same */ ms->window.lowLimit = 1; /* it ensures first and later CCtx usages compress the same */
ms->window.nextSrc = ms->window.base + 1; /* see issue #1241 */ ms->window.nextSrc = ms->window.base + 1; /* see issue #1241 */
ZSTD_invalidateMatchState(ms); ZSTD_invalidateMatchState(ms);
/* opt parser space */ /* opt parser space */
if (forCCtx && ((cParams->strategy == ZSTD_btopt) | (cParams->strategy == ZSTD_btultra))) { if (forCCtx && (cParams->strategy >= ZSTD_btopt)) {
DEBUGLOG(4, "reserving optimal parser space"); DEBUGLOG(4, "reserving optimal parser space");
ms->opt.litFreq = (U32*)ptr; ms->opt.litFreq = (unsigned*)ptr;
ms->opt.litLengthFreq = ms->opt.litFreq + (1<<Litbits); ms->opt.litLengthFreq = ms->opt.litFreq + (1<<Litbits);
ms->opt.matchLengthFreq = ms->opt.litLengthFreq + (MaxLL+1); ms->opt.matchLengthFreq = ms->opt.litLengthFreq + (MaxLL+1);
ms->opt.offCodeFreq = ms->opt.matchLengthFreq + (MaxML+1); ms->opt.offCodeFreq = ms->opt.matchLengthFreq + (MaxML+1);
ptr = ms->opt.offCodeFreq + (MaxOff+1); ptr = ms->opt.offCodeFreq + (MaxOff+1);
ms->opt.matchTable = (ZSTD_match_t*)ptr; ms->opt.matchTable = (ZSTD_match_t*)ptr;
ptr = ms->opt.matchTable + ZSTD_OPT_NUM+1; ptr = ms->opt.matchTable + ZSTD_OPT_NUM+1;
ms->opt.priceTable = (ZSTD_optimal_t*)ptr; ms->opt.priceTable = (ZSTD_optimal_t*)ptr;
ptr = ms->opt.priceTable + ZSTD_OPT_NUM+1; ptr = ms->opt.priceTable + ZSTD_OPT_NUM+1;
return ZSTD_continueCCtx(zc, params, pledgedSrcSize); return ZSTD_continueCCtx(zc, params, pledgedSrcSize);
} } } }
DEBUGLOG(4, "ZSTD_equivalentParams()==0 -> reset CCtx"); DEBUGLOG(4, "ZSTD_equivalentParams()==0 -> reset CCtx");
if (params.ldmParams.enableLdm) { if (params.ldmParams.enableLdm) {
/* Adjust long distance matching parameters */ /* Adjust long distance matching parameters */
ZSTD_ldm_adjustParameters(&params.ldmParams, &params.cParams); ZSTD_ldm_adjustParameters(&params.ldmParams, &params.cParams);
assert(params.ldmParams.hashLog >= params.ldmParams.bucketSizeLog); assert(params.ldmParams.hashLog >= params.ldmParams.bucketSizeLog);
assert(params.ldmParams.hashEveryLog < 32); assert(params.ldmParams.hashRateLog < 32);
zc->ldmState.hashPower = ZSTD_ldm_getHashPower(params.ldmParams.minMatchLength); zc->ldmState.hashPower = ZSTD_rollingHash_primePower(params.ldmParams.minMatchLength);
} }
{ size_t const windowSize = MAX(1, (size_t)MIN(((U64)1 << params.cParams.windowLog), pledgedSrcSize)); { size_t const windowSize = MAX(1, (size_t)MIN(((U64)1 << params.cParams.windowLog), pledgedSrcSize));
size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, windowSize); size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, windowSize);
U32 const divider = (params.cParams.searchLength==3) ? 3 : 4; U32 const divider = (params.cParams.minMatch==3) ? 3 : 4;
size_t const maxNbSeq = blockSize / divider; size_t const maxNbSeq = blockSize / divider;
size_t const tokenSpace = WILDCOPY_OVERLENGTH + blockSize + 11*maxNbSeq; size_t const tokenSpace = WILDCOPY_OVERLENGTH + blockSize + 11*maxNbSeq;
size_t const buffOutSize = (zbuff==ZSTDb_buffered) ? ZSTD_compressBound(blockSize)+1 : 0; size_t const buffOutSize = (zbuff==ZSTDb_buffered) ? ZSTD_compressBound(blockSize)+1 : 0;
size_t const buffInSize = (zbuff==ZSTDb_buffered) ? windowSize + blockSize : 0; size_t const buffInSize = (zbuff==ZSTDb_buffered) ? windowSize + blockSize : 0;
size_t const matchStateSize = ZSTD_sizeof_matchState(&params.cParams, /* forCCtx */ 1); size_t const matchStateSize = ZSTD_sizeof_matchState(&params.cParams, /* forCCtx */ 1);
size_t const maxNbLdmSeq = ZSTD_ldm_getMaxNbSeq(params.ldmParams, blockSize); size_t const maxNbLdmSeq = ZSTD_ldm_getMaxNbSeq(params.ldmParams, blockSize);
void* ptr; /* used to partition workSpace */ void* ptr; /* used to partition workSpace */
zc->appliedParams = params; zc->appliedParams = params;
zc->blockState.matchState.cParams = params.cParams; zc->blockState.matchState.cParams = params.cParams;
zc->pledgedSrcSizePlusOne = pledgedSrcSize+1; zc->pledgedSrcSizePlusOne = pledgedSrcSize+1;
zc->consumedSrcSize = 0; zc->consumedSrcSize = 0;
zc->producedCSize = 0; zc->producedCSize = 0;
if (pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN) if (pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN)
zc->appliedParams.fParams.contentSizeFlag = 0; zc->appliedParams.fParams.contentSizeFlag = 0;
DEBUGLOG(4, "pledged content size : %u ; flag : %u", DEBUGLOG(4, "pledged content size : %u ; flag : %u",
(U32)pledgedSrcSize, zc->appliedParams.fParams.contentSizeFlag); (unsigned)pledgedSrcSize, zc->appliedParams.fParams.contentSizeFlag);
zc->blockSize = blockSize; zc->blockSize = blockSize;
XXH64_reset(&zc->xxhState, 0); XXH64_reset(&zc->xxhState, 0);
zc->stage = ZSTDcs_init; zc->stage = ZSTDcs_init;
zc->dictID = 0; zc->dictID = 0;
ZSTD_reset_compressedBlockState(zc->blockState.prevCBlock); ZSTD_reset_compressedBlockState(zc->blockState.prevCBlock);
for (i=0; i<ZSTD_REP_NUM; i++) cctx->blockState.prevCBlock->rep[i] = 0; for (i=0; i<ZSTD_REP_NUM; i++) cctx->blockState.prevCBlock->rep[i] = 0;
assert(!ZSTD_window_hasExtDict(cctx->blockState.matchState.window)); assert(!ZSTD_window_hasExtDict(cctx->blockState.matchState.window));
} }
/* These are the approximate sizes for each strategy past which copying the /* These are the approximate sizes for each strategy past which copying the
* dictionary tables into the working context is faster than using them * dictionary tables into the working context is faster than using them
* in-place. * in-place.
*/ */
static const size_t attachDictSizeCutoffs[(unsigned)ZSTD_btultra+1] = { static const size_t attachDictSizeCutoffs[ZSTD_STRATEGY_MAX+1] = {
8 KB, /* unused */ 8 KB, /* unused */
8 KB, /* ZSTD_fast */ 8 KB, /* ZSTD_fast */
16 KB, /* ZSTD_dfast */ 16 KB, /* ZSTD_dfast */
32 KB, /* ZSTD_greedy */ 32 KB, /* ZSTD_greedy */
32 KB, /* ZSTD_lazy */ 32 KB, /* ZSTD_lazy */
32 KB, /* ZSTD_lazy2 */ 32 KB, /* ZSTD_lazy2 */
32 KB, /* ZSTD_btlazy2 */ 32 KB, /* ZSTD_btlazy2 */
32 KB, /* ZSTD_btopt */ 32 KB, /* ZSTD_btopt */
8 KB /* ZSTD_btultra */ 8 KB, /* ZSTD_btultra */
8 KB /* ZSTD_btultra2 */
}; };
static int ZSTD_shouldAttachDict(const ZSTD_CDict* cdict, static int ZSTD_shouldAttachDict(const ZSTD_CDict* cdict,
ZSTD_CCtx_params params, ZSTD_CCtx_params params,
U64 pledgedSrcSize) U64 pledgedSrcSize)
{ {
size_t cutoff = attachDictSizeCutoffs[cdict->matchState.cParams.strategy]; size_t cutoff = attachDictSizeCutoffs[cdict->matchState.cParams.strategy];
return ( pledgedSrcSize <= cutoff return ( pledgedSrcSize <= cutoff
* in-place. We decide here which strategy to use. */ * in-place. We decide here which strategy to use. */
static size_t ZSTD_resetCCtx_usingCDict(ZSTD_CCtx* cctx, static size_t ZSTD_resetCCtx_usingCDict(ZSTD_CCtx* cctx,
const ZSTD_CDict* cdict, const ZSTD_CDict* cdict,
ZSTD_CCtx_params params, ZSTD_CCtx_params params,
U64 pledgedSrcSize, U64 pledgedSrcSize,
ZSTD_buffered_policy_e zbuff) ZSTD_buffered_policy_e zbuff)
{ {
DEBUGLOG(4, "ZSTD_resetCCtx_usingCDict (pledgedSrcSize=%u)", (U32)pledgedSrcSize); DEBUGLOG(4, "ZSTD_resetCCtx_usingCDict (pledgedSrcSize=%u)",
(unsigned)pledgedSrcSize);
if (ZSTD_shouldAttachDict(cdict, params, pledgedSrcSize)) { if (ZSTD_shouldAttachDict(cdict, params, pledgedSrcSize)) {
return ZSTD_resetCCtx_byAttachingCDict( return ZSTD_resetCCtx_byAttachingCDict(
cctx, cdict, params, pledgedSrcSize, zbuff); cctx, cdict, params, pledgedSrcSize, zbuff);
} else { } else {
return ZSTD_resetCCtx_byCopyingCDict( return ZSTD_resetCCtx_byCopyingCDict(
cctx, cdict, params, pledgedSrcSize, zbuff); cctx, cdict, params, pledgedSrcSize, zbuff);
} }
/* ZSTD_minGain() : /* ZSTD_minGain() :
* minimum compression required * minimum compression required
* to generate a compress block or a compressed literals section. * to generate a compress block or a compressed literals section.
* note : use same formula for both situations */ * note : use same formula for both situations */
static size_t ZSTD_minGain(size_t srcSize, ZSTD_strategy strat) static size_t ZSTD_minGain(size_t srcSize, ZSTD_strategy strat)
{ {
U32 const minlog = (strat==ZSTD_btultra) ? 7 : 6; U32 const minlog = (strat>=ZSTD_btultra) ? (U32)(strat) - 1 : 6;
ZSTD_STATIC_ASSERT(ZSTD_btultra == 8);
assert(ZSTD_cParam_withinBounds(ZSTD_c_strategy, strat));
return (srcSize >> minlog) + 2; return (srcSize >> minlog) + 2;
} }
static size_t ZSTD_compressLiterals (ZSTD_hufCTables_t const* prevHuf, static size_t ZSTD_compressLiterals (ZSTD_hufCTables_t const* prevHuf,
ZSTD_hufCTables_t* nextHuf, ZSTD_hufCTables_t* nextHuf,
ZSTD_strategy strategy, int disableLiteralCompression, ZSTD_strategy strategy, int disableLiteralCompression,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const void* src, size_t srcSize,
U32* workspace, const int bmi2) void* workspace, size_t wkspSize,
const int bmi2)
{ {
size_t const minGain = ZSTD_minGain(srcSize, strategy); size_t const minGain = ZSTD_minGain(srcSize, strategy);
size_t const lhSize = 3 + (srcSize >= 1 KB) + (srcSize >= 16 KB); size_t const lhSize = 3 + (srcSize >= 1 KB) + (srcSize >= 16 KB);
BYTE* const ostart = (BYTE*)dst; BYTE* const ostart = (BYTE*)dst;
U32 singleStream = srcSize < 256; U32 singleStream = srcSize < 256;
symbolEncodingType_e hType = set_compressed; symbolEncodingType_e hType = set_compressed;
size_t cLitSize; size_t cLitSize;
if (srcSize <= minLitSize) return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize); if (srcSize <= minLitSize) return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
} }
if (dstCapacity < lhSize+1) return ERROR(dstSize_tooSmall); /* not enough space for compression */ if (dstCapacity < lhSize+1) return ERROR(dstSize_tooSmall); /* not enough space for compression */
{ HUF_repeat repeat = prevHuf->repeatMode; { HUF_repeat repeat = prevHuf->repeatMode;
int const preferRepeat = strategy < ZSTD_lazy ? srcSize <= 1024 : 0; int const preferRepeat = strategy < ZSTD_lazy ? srcSize <= 1024 : 0;
if (repeat == HUF_repeat_valid && lhSize == 3) singleStream = 1; if (repeat == HUF_repeat_valid && lhSize == 3) singleStream = 1;
cLitSize = singleStream ? HUF_compress1X_repeat(ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 11, cLitSize = singleStream ? HUF_compress1X_repeat(ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 11,
workspace, HUF_WORKSPACE_SIZE, (HUF_CElt*)nextHuf->CTable, &repeat, preferRepeat, bmi2) workspace, wkspSize, (HUF_CElt*)nextHuf->CTable, &repeat, preferRepeat, bmi2)
: HUF_compress4X_repeat(ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 11, : HUF_compress4X_repeat(ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 11,
workspace, HUF_WORKSPACE_SIZE, (HUF_CElt*)nextHuf->CTable, &repeat, preferRepeat, bmi2); workspace, wkspSize, (HUF_CElt*)nextHuf->CTable, &repeat, preferRepeat, bmi2);
if (repeat != HUF_repeat_none) { if (repeat != HUF_repeat_none) {
/* reused the existing table */ /* reused the existing table */
hType = set_repeat; hType = set_repeat;
} }
} }
if ((cLitSize==0) | (cLitSize >= srcSize - minGain) | ERR_isError(cLitSize)) { if ((cLitSize==0) | (cLitSize >= srcSize - minGain) | ERR_isError(cLitSize)) {
memcpy(nextHuf, prevHuf, sizeof(*prevHuf)); memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
if (isDefaultAllowed) { if (isDefaultAllowed) {
assert(!ZSTD_isError(basicCost)); assert(!ZSTD_isError(basicCost));
assert(!(*repeatMode == FSE_repeat_valid && ZSTD_isError(repeatCost))); assert(!(*repeatMode == FSE_repeat_valid && ZSTD_isError(repeatCost)));
} }
assert(!ZSTD_isError(NCountCost)); assert(!ZSTD_isError(NCountCost));
assert(compressedCost < ERROR(maxCode)); assert(compressedCost < ERROR(maxCode));
DEBUGLOG(5, "Estimated bit costs: basic=%u\trepeat=%u\tcompressed=%u", DEBUGLOG(5, "Estimated bit costs: basic=%u\trepeat=%u\tcompressed=%u",
(U32)basicCost, (U32)repeatCost, (U32)compressedCost); (unsigned)basicCost, (unsigned)repeatCost, (unsigned)compressedCost);
if (basicCost <= repeatCost && basicCost <= compressedCost) { if (basicCost <= repeatCost && basicCost <= compressedCost) {
DEBUGLOG(5, "Selected set_basic"); DEBUGLOG(5, "Selected set_basic");
assert(isDefaultAllowed); assert(isDefaultAllowed);
*repeatMode = FSE_repeat_none; *repeatMode = FSE_repeat_none;
return set_basic; return set_basic;
} }
if (repeatCost <= compressedCost) { if (repeatCost <= compressedCost) {
DEBUGLOG(5, "Selected set_repeat"); DEBUGLOG(5, "Selected set_repeat");
assert(!ZSTD_isError(repeatCost)); assert(!ZSTD_isError(repeatCost));
return set_repeat; return set_repeat;
} }
assert(compressedCost < basicCost && compressedCost < repeatCost); assert(compressedCost < basicCost && compressedCost < repeatCost);
} }
DEBUGLOG(5, "Selected set_compressed"); DEBUGLOG(5, "Selected set_compressed");
*repeatMode = FSE_repeat_check; *repeatMode = FSE_repeat_check;
return set_compressed; return set_compressed;
} }
MEM_STATIC size_t MEM_STATIC size_t
ZSTD_buildCTable(void* dst, size_t dstCapacity, ZSTD_buildCTable(void* dst, size_t dstCapacity,
FSE_CTable* nextCTable, U32 FSELog, symbolEncodingType_e type, FSE_CTable* nextCTable, U32 FSELog, symbolEncodingType_e type,
U32* count, U32 max, unsigned* count, U32 max,
const BYTE* codeTable, size_t nbSeq, const BYTE* codeTable, size_t nbSeq,
const S16* defaultNorm, U32 defaultNormLog, U32 defaultMax, const S16* defaultNorm, U32 defaultNormLog, U32 defaultMax,
const FSE_CTable* prevCTable, size_t prevCTableSize, const FSE_CTable* prevCTable, size_t prevCTableSize,
void* workspace, size_t workspaceSize) void* workspace, size_t workspaceSize)
{ {
BYTE* op = (BYTE*)dst; BYTE* op = (BYTE*)dst;
const BYTE* const oend = op + dstCapacity; const BYTE* const oend = op + dstCapacity;
DEBUGLOG(6, "ZSTD_buildCTable (dstCapacity=%u)", (unsigned)dstCapacity);
switch (type) { switch (type) {
case set_rle: case set_rle:
*op = codeTable[0];
CHECK_F(FSE_buildCTable_rle(nextCTable, (BYTE)max)); CHECK_F(FSE_buildCTable_rle(nextCTable, (BYTE)max));
if (dstCapacity==0) return ERROR(dstSize_tooSmall);
*op = codeTable[0];
return 1; return 1;
case set_repeat: case set_repeat:
memcpy(nextCTable, prevCTable, prevCTableSize); memcpy(nextCTable, prevCTable, prevCTableSize);
return 0; return 0;
case set_basic: case set_basic:
CHECK_F(FSE_buildCTable_wksp(nextCTable, defaultNorm, defaultMax, defaultNormLog, workspace, workspaceSize)); /* note : could be pre-calculated */ CHECK_F(FSE_buildCTable_wksp(nextCTable, defaultNorm, defaultMax, defaultNormLog, workspace, workspaceSize)); /* note : could be pre-calculated */
return 0; return 0;
case set_compressed: { case set_compressed: {
seqDef const* sequences, size_t nbSeq, int longOffsets) seqDef const* sequences, size_t nbSeq, int longOffsets)
{ {
BIT_CStream_t blockStream; BIT_CStream_t blockStream;
FSE_CState_t stateMatchLength; FSE_CState_t stateMatchLength;
FSE_CState_t stateOffsetBits; FSE_CState_t stateOffsetBits;
FSE_CState_t stateLitLength; FSE_CState_t stateLitLength;
CHECK_E(BIT_initCStream(&blockStream, dst, dstCapacity), dstSize_tooSmall); /* not enough space remaining */ CHECK_E(BIT_initCStream(&blockStream, dst, dstCapacity), dstSize_tooSmall); /* not enough space remaining */
DEBUGLOG(6, "available space for bitstream : %i (dstCapacity=%u)",
(int)(blockStream.endPtr - blockStream.startPtr),
(unsigned)dstCapacity);
/* first symbols */ /* first symbols */
FSE_initCState2(&stateMatchLength, CTable_MatchLength, mlCodeTable[nbSeq-1]); FSE_initCState2(&stateMatchLength, CTable_MatchLength, mlCodeTable[nbSeq-1]);
FSE_initCState2(&stateOffsetBits, CTable_OffsetBits, ofCodeTable[nbSeq-1]); FSE_initCState2(&stateOffsetBits, CTable_OffsetBits, ofCodeTable[nbSeq-1]);
FSE_initCState2(&stateLitLength, CTable_LitLength, llCodeTable[nbSeq-1]); FSE_initCState2(&stateLitLength, CTable_LitLength, llCodeTable[nbSeq-1]);
BIT_addBits(&blockStream, sequences[nbSeq-1].litLength, LL_bits[llCodeTable[nbSeq-1]]); BIT_addBits(&blockStream, sequences[nbSeq-1].litLength, LL_bits[llCodeTable[nbSeq-1]]);
if (MEM_32bits()) BIT_flushBits(&blockStream); if (MEM_32bits()) BIT_flushBits(&blockStream);
BIT_addBits(&blockStream, sequences[nbSeq-1].matchLength, ML_bits[mlCodeTable[nbSeq-1]]); BIT_addBits(&blockStream, sequences[nbSeq-1].matchLength, ML_bits[mlCodeTable[nbSeq-1]]);
for (n=nbSeq-2 ; n<nbSeq ; n--) { /* intentional underflow */ for (n=nbSeq-2 ; n<nbSeq ; n--) { /* intentional underflow */
BYTE const llCode = llCodeTable[n]; BYTE const llCode = llCodeTable[n];
BYTE const ofCode = ofCodeTable[n]; BYTE const ofCode = ofCodeTable[n];
BYTE const mlCode = mlCodeTable[n]; BYTE const mlCode = mlCodeTable[n];
U32 const llBits = LL_bits[llCode]; U32 const llBits = LL_bits[llCode];
U32 const ofBits = ofCode; U32 const ofBits = ofCode;
U32 const mlBits = ML_bits[mlCode]; U32 const mlBits = ML_bits[mlCode];
DEBUGLOG(6, "encoding: litlen:%2u - matchlen:%2u - offCode:%7u", DEBUGLOG(6, "encoding: litlen:%2u - matchlen:%2u - offCode:%7u",
sequences[n].litLength, (unsigned)sequences[n].litLength,
sequences[n].matchLength + MINMATCH, (unsigned)sequences[n].matchLength + MINMATCH,
sequences[n].offset); (unsigned)sequences[n].offset);
/* 32b*/ /* 64b*/ /* 32b*/ /* 64b*/
/* (7)*/ /* (7)*/ /* (7)*/ /* (7)*/
FSE_encodeSymbol(&blockStream, &stateOffsetBits, ofCode); /* 15 */ /* 15 */ FSE_encodeSymbol(&blockStream, &stateOffsetBits, ofCode); /* 15 */ /* 15 */
FSE_encodeSymbol(&blockStream, &stateMatchLength, mlCode); /* 24 */ /* 24 */ FSE_encodeSymbol(&blockStream, &stateMatchLength, mlCode); /* 24 */ /* 24 */
if (MEM_32bits()) BIT_flushBits(&blockStream); /* (7)*/ if (MEM_32bits()) BIT_flushBits(&blockStream); /* (7)*/
FSE_encodeSymbol(&blockStream, &stateLitLength, llCode); /* 16 */ /* 33 */ FSE_encodeSymbol(&blockStream, &stateLitLength, llCode); /* 16 */ /* 33 */
if (MEM_32bits() || (ofBits+mlBits+llBits >= 64-7-(LLFSELog+MLFSELog+OffFSELog))) if (MEM_32bits() || (ofBits+mlBits+llBits >= 64-7-(LLFSELog+MLFSELog+OffFSELog)))
BIT_flushBits(&blockStream); /* (7)*/ BIT_flushBits(&blockStream); /* (7)*/
BIT_addBits(&blockStream, sequences[n].litLength, llBits); BIT_addBits(&blockStream, sequences[n].litLength, llBits);
if (MEM_32bits() && ((llBits+mlBits)>24)) BIT_flushBits(&blockStream); if (MEM_32bits() && ((llBits+mlBits)>24)) BIT_flushBits(&blockStream);
BIT_addBits(&blockStream, sequences[n].matchLength, mlBits); BIT_addBits(&blockStream, sequences[n].matchLength, mlBits);
if (MEM_32bits() || (ofBits+mlBits+llBits > 56)) BIT_flushBits(&blockStream); if (MEM_32bits() || (ofBits+mlBits+llBits > 56)) BIT_flushBits(&blockStream);
if (longOffsets) { if (longOffsets) {
int const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1); int const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);
if (extraBits) { if (extraBits) {
BIT_addBits(&blockStream, sequences[n].offset, extraBits); BIT_addBits(&blockStream, sequences[n].offset, extraBits);
BIT_flushBits(&blockStream); /* (7)*/ BIT_flushBits(&blockStream); /* (7)*/
} }
BIT_addBits(&blockStream, sequences[n].offset >> extraBits, BIT_addBits(&blockStream, sequences[n].offset >> extraBits,
ofBits - extraBits); /* 31 */ ofBits - extraBits); /* 31 */
} else { } else {
BIT_addBits(&blockStream, sequences[n].offset, ofBits); /* 31 */ BIT_addBits(&blockStream, sequences[n].offset, ofBits); /* 31 */
} }
BIT_flushBits(&blockStream); /* (7)*/ BIT_flushBits(&blockStream); /* (7)*/
DEBUGLOG(7, "remaining space : %i", (int)(blockStream.endPtr - blockStream.ptr));
} } } }
DEBUGLOG(6, "ZSTD_encodeSequences: flushing ML state with %u bits", stateMatchLength.stateLog); DEBUGLOG(6, "ZSTD_encodeSequences: flushing ML state with %u bits", stateMatchLength.stateLog);
FSE_flushCState(&blockStream, &stateMatchLength); FSE_flushCState(&blockStream, &stateMatchLength);
DEBUGLOG(6, "ZSTD_encodeSequences: flushing Off state with %u bits", stateOffsetBits.stateLog); DEBUGLOG(6, "ZSTD_encodeSequences: flushing Off state with %u bits", stateOffsetBits.stateLog);
FSE_flushCState(&blockStream, &stateOffsetBits); FSE_flushCState(&blockStream, &stateOffsetBits);
DEBUGLOG(6, "ZSTD_encodeSequences: flushing LL state with %u bits", stateLitLength.stateLog); DEBUGLOG(6, "ZSTD_encodeSequences: flushing LL state with %u bits", stateLitLength.stateLog);
FSE_flushCState(&blockStream, &stateLitLength); FSE_flushCState(&blockStream, &stateLitLength);
static size_t ZSTD_encodeSequences( static size_t ZSTD_encodeSequences(
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable, FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable, FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable, FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
seqDef const* sequences, size_t nbSeq, int longOffsets, int bmi2) seqDef const* sequences, size_t nbSeq, int longOffsets, int bmi2)
{ {
DEBUGLOG(5, "ZSTD_encodeSequences: dstCapacity = %u", (unsigned)dstCapacity);
#if DYNAMIC_BMI2 #if DYNAMIC_BMI2
if (bmi2) { if (bmi2) {
return ZSTD_encodeSequences_bmi2(dst, dstCapacity, return ZSTD_encodeSequences_bmi2(dst, dstCapacity,
CTable_MatchLength, mlCodeTable, CTable_MatchLength, mlCodeTable,
CTable_OffsetBits, ofCodeTable, CTable_OffsetBits, ofCodeTable,
CTable_LitLength, llCodeTable, CTable_LitLength, llCodeTable,
sequences, nbSeq, longOffsets); sequences, nbSeq, longOffsets);
} }
#endif #endif
(void)bmi2; (void)bmi2;
return ZSTD_encodeSequences_default(dst, dstCapacity, return ZSTD_encodeSequences_default(dst, dstCapacity,
CTable_MatchLength, mlCodeTable, CTable_MatchLength, mlCodeTable,
CTable_OffsetBits, ofCodeTable, CTable_OffsetBits, ofCodeTable,
CTable_LitLength, llCodeTable, CTable_LitLength, llCodeTable,
sequences, nbSeq, longOffsets); sequences, nbSeq, longOffsets);
} }
MEM_STATIC size_t ZSTD_compressSequences_internal(seqStore_t* seqStorePtr, /* ZSTD_compressSequences_internal():
ZSTD_entropyCTables_t const* prevEntropy, * actually compresses both literals and sequences */
MEM_STATIC size_t
ZSTD_compressSequences_internal(seqStore_t* seqStorePtr,
const ZSTD_entropyCTables_t* prevEntropy,
ZSTD_entropyCTables_t* nextEntropy, ZSTD_entropyCTables_t* nextEntropy,
ZSTD_CCtx_params const* cctxParams, const ZSTD_CCtx_params* cctxParams,
void* dst, size_t dstCapacity, U32* workspace, void* dst, size_t dstCapacity,
void* workspace, size_t wkspSize,
const int bmi2) const int bmi2)
{ {
const int longOffsets = cctxParams->cParams.windowLog > STREAM_ACCUMULATOR_MIN; const int longOffsets = cctxParams->cParams.windowLog > STREAM_ACCUMULATOR_MIN;
ZSTD_strategy const strategy = cctxParams->cParams.strategy; ZSTD_strategy const strategy = cctxParams->cParams.strategy;
U32 count[MaxSeq+1]; unsigned count[MaxSeq+1];
FSE_CTable* CTable_LitLength = nextEntropy->fse.litlengthCTable; FSE_CTable* CTable_LitLength = nextEntropy->fse.litlengthCTable;
FSE_CTable* CTable_OffsetBits = nextEntropy->fse.offcodeCTable; FSE_CTable* CTable_OffsetBits = nextEntropy->fse.offcodeCTable;
FSE_CTable* CTable_MatchLength = nextEntropy->fse.matchlengthCTable; FSE_CTable* CTable_MatchLength = nextEntropy->fse.matchlengthCTable;
U32 LLtype, Offtype, MLtype; /* compressed, raw or rle */ U32 LLtype, Offtype, MLtype; /* compressed, raw or rle */
const seqDef* const sequences = seqStorePtr->sequencesStart; const seqDef* const sequences = seqStorePtr->sequencesStart;
const BYTE* const ofCodeTable = seqStorePtr->ofCode; const BYTE* const ofCodeTable = seqStorePtr->ofCode;
const BYTE* const llCodeTable = seqStorePtr->llCode; const BYTE* const llCodeTable = seqStorePtr->llCode;
const BYTE* const mlCodeTable = seqStorePtr->mlCode; const BYTE* const mlCodeTable = seqStorePtr->mlCode;
BYTE* const ostart = (BYTE*)dst; BYTE* const ostart = (BYTE*)dst;
BYTE* const oend = ostart + dstCapacity; BYTE* const oend = ostart + dstCapacity;
BYTE* op = ostart; BYTE* op = ostart;
size_t const nbSeq = seqStorePtr->sequences - seqStorePtr->sequencesStart; size_t const nbSeq = seqStorePtr->sequences - seqStorePtr->sequencesStart;
BYTE* seqHead; BYTE* seqHead;
BYTE* lastNCount = NULL; BYTE* lastNCount = NULL;
ZSTD_STATIC_ASSERT(HUF_WORKSPACE_SIZE >= (1<<MAX(MLFSELog,LLFSELog))); ZSTD_STATIC_ASSERT(HUF_WORKSPACE_SIZE >= (1<<MAX(MLFSELog,LLFSELog)));
DEBUGLOG(5, "ZSTD_compressSequences_internal");
/* Compress literals */ /* Compress literals */
{ const BYTE* const literals = seqStorePtr->litStart; { const BYTE* const literals = seqStorePtr->litStart;
size_t const litSize = seqStorePtr->lit - literals; size_t const litSize = seqStorePtr->lit - literals;
int const disableLiteralCompression = (cctxParams->cParams.strategy == ZSTD_fast) && (cctxParams->cParams.targetLength > 0); int const disableLiteralCompression = (cctxParams->cParams.strategy == ZSTD_fast) && (cctxParams->cParams.targetLength > 0);
size_t const cSize = ZSTD_compressLiterals( size_t const cSize = ZSTD_compressLiterals(
&prevEntropy->huf, &nextEntropy->huf, &prevEntropy->huf, &nextEntropy->huf,
cctxParams->cParams.strategy, disableLiteralCompression, cctxParams->cParams.strategy, disableLiteralCompression,
op, dstCapacity, op, dstCapacity,
literals, litSize, literals, litSize,
workspace, bmi2); workspace, wkspSize,
bmi2);
if (ZSTD_isError(cSize)) if (ZSTD_isError(cSize))
return cSize; return cSize;
assert(cSize <= dstCapacity); assert(cSize <= dstCapacity);
op += cSize; op += cSize;
} }
/* Sequences Header */ /* Sequences Header */
if ((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/) return ERROR(dstSize_tooSmall); if ((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/) return ERROR(dstSize_tooSmall);
} }
/* seqHead : flags for FSE encoding type */ /* seqHead : flags for FSE encoding type */
seqHead = op++; seqHead = op++;
/* convert length/distances into codes */ /* convert length/distances into codes */
ZSTD_seqToCodes(seqStorePtr); ZSTD_seqToCodes(seqStorePtr);
/* build CTable for Literal Lengths */ /* build CTable for Literal Lengths */
{ U32 max = MaxLL; { unsigned max = MaxLL;
size_t const mostFrequent = HIST_countFast_wksp(count, &max, llCodeTable, nbSeq, workspace); /* can't fail */ size_t const mostFrequent = HIST_countFast_wksp(count, &max, llCodeTable, nbSeq, workspace, wkspSize); /* can't fail */
DEBUGLOG(5, "Building LL table"); DEBUGLOG(5, "Building LL table");
nextEntropy->fse.litlength_repeatMode = prevEntropy->fse.litlength_repeatMode; nextEntropy->fse.litlength_repeatMode = prevEntropy->fse.litlength_repeatMode;
LLtype = ZSTD_selectEncodingType(&nextEntropy->fse.litlength_repeatMode, count, max, mostFrequent, nbSeq, LLFSELog, prevEntropy->fse.litlengthCTable, LL_defaultNorm, LL_defaultNormLog, ZSTD_defaultAllowed, strategy); LLtype = ZSTD_selectEncodingType(&nextEntropy->fse.litlength_repeatMode,
count, max, mostFrequent, nbSeq,
LLFSELog, prevEntropy->fse.litlengthCTable,
LL_defaultNorm, LL_defaultNormLog,
ZSTD_defaultAllowed, strategy);
assert(set_basic < set_compressed && set_rle < set_compressed); assert(set_basic < set_compressed && set_rle < set_compressed);
assert(!(LLtype < set_compressed && nextEntropy->fse.litlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */ assert(!(LLtype < set_compressed && nextEntropy->fse.litlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
{ size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_LitLength, LLFSELog, (symbolEncodingType_e)LLtype, { size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_LitLength, LLFSELog, (symbolEncodingType_e)LLtype,
count, max, llCodeTable, nbSeq, LL_defaultNorm, LL_defaultNormLog, MaxLL, count, max, llCodeTable, nbSeq, LL_defaultNorm, LL_defaultNormLog, MaxLL,
prevEntropy->fse.litlengthCTable, sizeof(prevEntropy->fse.litlengthCTable), prevEntropy->fse.litlengthCTable, sizeof(prevEntropy->fse.litlengthCTable),
workspace, HUF_WORKSPACE_SIZE); workspace, wkspSize);
if (ZSTD_isError(countSize)) return countSize; if (ZSTD_isError(countSize)) return countSize;
if (LLtype == set_compressed) if (LLtype == set_compressed)
lastNCount = op; lastNCount = op;
op += countSize; op += countSize;
} } } }
/* build CTable for Offsets */ /* build CTable for Offsets */
{ U32 max = MaxOff; { unsigned max = MaxOff;
size_t const mostFrequent = HIST_countFast_wksp(count, &max, ofCodeTable, nbSeq, workspace); /* can't fail */ size_t const mostFrequent = HIST_countFast_wksp(count, &max, ofCodeTable, nbSeq, workspace, wkspSize); /* can't fail */
/* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */ /* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */
ZSTD_defaultPolicy_e const defaultPolicy = (max <= DefaultMaxOff) ? ZSTD_defaultAllowed : ZSTD_defaultDisallowed; ZSTD_defaultPolicy_e const defaultPolicy = (max <= DefaultMaxOff) ? ZSTD_defaultAllowed : ZSTD_defaultDisallowed;
DEBUGLOG(5, "Building OF table"); DEBUGLOG(5, "Building OF table");
nextEntropy->fse.offcode_repeatMode = prevEntropy->fse.offcode_repeatMode; nextEntropy->fse.offcode_repeatMode = prevEntropy->fse.offcode_repeatMode;
Offtype = ZSTD_selectEncodingType(&nextEntropy->fse.offcode_repeatMode, count, max, mostFrequent, nbSeq, OffFSELog, prevEntropy->fse.offcodeCTable, OF_defaultNorm, OF_defaultNormLog, defaultPolicy, strategy); Offtype = ZSTD_selectEncodingType(&nextEntropy->fse.offcode_repeatMode,
count, max, mostFrequent, nbSeq,
OffFSELog, prevEntropy->fse.offcodeCTable,
OF_defaultNorm, OF_defaultNormLog,
defaultPolicy, strategy);
assert(!(Offtype < set_compressed && nextEntropy->fse.offcode_repeatMode != FSE_repeat_none)); /* We don't copy tables */ assert(!(Offtype < set_compressed && nextEntropy->fse.offcode_repeatMode != FSE_repeat_none)); /* We don't copy tables */
{ size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_OffsetBits, OffFSELog, (symbolEncodingType_e)Offtype, { size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_OffsetBits, OffFSELog, (symbolEncodingType_e)Offtype,
count, max, ofCodeTable, nbSeq, OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff, count, max, ofCodeTable, nbSeq, OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff,
prevEntropy->fse.offcodeCTable, sizeof(prevEntropy->fse.offcodeCTable), prevEntropy->fse.offcodeCTable, sizeof(prevEntropy->fse.offcodeCTable),
workspace, HUF_WORKSPACE_SIZE); workspace, wkspSize);
if (ZSTD_isError(countSize)) return countSize; if (ZSTD_isError(countSize)) return countSize;
if (Offtype == set_compressed) if (Offtype == set_compressed)
lastNCount = op; lastNCount = op;
op += countSize; op += countSize;
} } } }
/* build CTable for MatchLengths */ /* build CTable for MatchLengths */
{ U32 max = MaxML; { unsigned max = MaxML;
size_t const mostFrequent = HIST_countFast_wksp(count, &max, mlCodeTable, nbSeq, workspace); /* can't fail */ size_t const mostFrequent = HIST_countFast_wksp(count, &max, mlCodeTable, nbSeq, workspace, wkspSize); /* can't fail */
DEBUGLOG(5, "Building ML table"); DEBUGLOG(5, "Building ML table (remaining space : %i)", (int)(oend-op));
nextEntropy->fse.matchlength_repeatMode = prevEntropy->fse.matchlength_repeatMode; nextEntropy->fse.matchlength_repeatMode = prevEntropy->fse.matchlength_repeatMode;
MLtype = ZSTD_selectEncodingType(&nextEntropy->fse.matchlength_repeatMode, count, max, mostFrequent, nbSeq, MLFSELog, prevEntropy->fse.matchlengthCTable, ML_defaultNorm, ML_defaultNormLog, ZSTD_defaultAllowed, strategy); MLtype = ZSTD_selectEncodingType(&nextEntropy->fse.matchlength_repeatMode,
count, max, mostFrequent, nbSeq,
MLFSELog, prevEntropy->fse.matchlengthCTable,
ML_defaultNorm, ML_defaultNormLog,
ZSTD_defaultAllowed, strategy);
assert(!(MLtype < set_compressed && nextEntropy->fse.matchlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */ assert(!(MLtype < set_compressed && nextEntropy->fse.matchlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
{ size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_MatchLength, MLFSELog, (symbolEncodingType_e)MLtype, { size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_MatchLength, MLFSELog, (symbolEncodingType_e)MLtype,
count, max, mlCodeTable, nbSeq, ML_defaultNorm, ML_defaultNormLog, MaxML, count, max, mlCodeTable, nbSeq, ML_defaultNorm, ML_defaultNormLog, MaxML,
prevEntropy->fse.matchlengthCTable, sizeof(prevEntropy->fse.matchlengthCTable), prevEntropy->fse.matchlengthCTable, sizeof(prevEntropy->fse.matchlengthCTable),
workspace, HUF_WORKSPACE_SIZE); workspace, wkspSize);
if (ZSTD_isError(countSize)) return countSize; if (ZSTD_isError(countSize)) return countSize;
if (MLtype == set_compressed) if (MLtype == set_compressed)
lastNCount = op; lastNCount = op;
op += countSize; op += countSize;
} } } }
*seqHead = (BYTE)((LLtype<<6) + (Offtype<<4) + (MLtype<<2)); *seqHead = (BYTE)((LLtype<<6) + (Offtype<<4) + (MLtype<<2));
/* NCountSize >= 2 && bitstreamSize > 0 ==> lastCountSize == 3 */ /* NCountSize >= 2 && bitstreamSize > 0 ==> lastCountSize == 3 */
assert(op - lastNCount == 3); assert(op - lastNCount == 3);
DEBUGLOG(5, "Avoiding bug in zstd decoder in versions <= 1.3.4 by " DEBUGLOG(5, "Avoiding bug in zstd decoder in versions <= 1.3.4 by "
"emitting an uncompressed block."); "emitting an uncompressed block.");
return 0; return 0;
} }
} }
DEBUGLOG(5, "compressed block size : %u", (unsigned)(op - ostart));
return op - ostart; return op - ostart;
} }
MEM_STATIC size_t ZSTD_compressSequences(seqStore_t* seqStorePtr, MEM_STATIC size_t
ZSTD_compressSequences(seqStore_t* seqStorePtr,
const ZSTD_entropyCTables_t* prevEntropy, const ZSTD_entropyCTables_t* prevEntropy,
ZSTD_entropyCTables_t* nextEntropy, ZSTD_entropyCTables_t* nextEntropy,
const ZSTD_CCtx_params* cctxParams, const ZSTD_CCtx_params* cctxParams,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
size_t srcSize, U32* workspace, int bmi2) size_t srcSize,
void* workspace, size_t wkspSize,
int bmi2)
{ {
size_t const cSize = ZSTD_compressSequences_internal( size_t const cSize = ZSTD_compressSequences_internal(
seqStorePtr, prevEntropy, nextEntropy, cctxParams, dst, dstCapacity, seqStorePtr, prevEntropy, nextEntropy, cctxParams,
workspace, bmi2); dst, dstCapacity,
workspace, wkspSize, bmi2);
if (cSize == 0) return 0; if (cSize == 0) return 0;
/* When srcSize <= dstCapacity, there is enough space to write a raw uncompressed block. /* When srcSize <= dstCapacity, there is enough space to write a raw uncompressed block.
* Since we ran out of space, block must be not compressible, so fall back to raw uncompressed block. * Since we ran out of space, block must be not compressible, so fall back to raw uncompressed block.
*/ */
if ((cSize == ERROR(dstSize_tooSmall)) & (srcSize <= dstCapacity)) if ((cSize == ERROR(dstSize_tooSmall)) & (srcSize <= dstCapacity))
return 0; /* block not compressed */ return 0; /* block not compressed */
if (ZSTD_isError(cSize)) return cSize; if (ZSTD_isError(cSize)) return cSize;
/* Check compressibility */ /* Check compressibility */
{ size_t const maxCSize = srcSize - ZSTD_minGain(srcSize, cctxParams->cParams.strategy); { size_t const maxCSize = srcSize - ZSTD_minGain(srcSize, cctxParams->cParams.strategy);
if (cSize >= maxCSize) return 0; /* block not compressed */ if (cSize >= maxCSize) return 0; /* block not compressed */
} }
return cSize; return cSize;
} }
/* ZSTD_selectBlockCompressor() : /* ZSTD_selectBlockCompressor() :
* Not static, but internal use only (used by long distance matcher) * Not static, but internal use only (used by long distance matcher)
* assumption : strat is a valid strategy */ * assumption : strat is a valid strategy */
ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_dictMode_e dictMode) ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_dictMode_e dictMode)
{ {
static const ZSTD_blockCompressor blockCompressor[3][(unsigned)ZSTD_btultra+1] = { static const ZSTD_blockCompressor blockCompressor[3][ZSTD_STRATEGY_MAX+1] = {
{ ZSTD_compressBlock_fast /* default for 0 */, { ZSTD_compressBlock_fast /* default for 0 */,
ZSTD_compressBlock_fast, ZSTD_compressBlock_fast,
ZSTD_compressBlock_doubleFast, ZSTD_compressBlock_doubleFast,
ZSTD_compressBlock_greedy, ZSTD_compressBlock_greedy,
ZSTD_compressBlock_lazy, ZSTD_compressBlock_lazy,
ZSTD_compressBlock_lazy2, ZSTD_compressBlock_lazy2,
ZSTD_compressBlock_btlazy2, ZSTD_compressBlock_btlazy2,
ZSTD_compressBlock_btopt, ZSTD_compressBlock_btopt,
ZSTD_compressBlock_btultra }, ZSTD_compressBlock_btultra,
ZSTD_compressBlock_btultra2 },
{ ZSTD_compressBlock_fast_extDict /* default for 0 */, { ZSTD_compressBlock_fast_extDict /* default for 0 */,
ZSTD_compressBlock_fast_extDict, ZSTD_compressBlock_fast_extDict,
ZSTD_compressBlock_doubleFast_extDict, ZSTD_compressBlock_doubleFast_extDict,
ZSTD_compressBlock_greedy_extDict, ZSTD_compressBlock_greedy_extDict,
ZSTD_compressBlock_lazy_extDict, ZSTD_compressBlock_lazy_extDict,
ZSTD_compressBlock_lazy2_extDict, ZSTD_compressBlock_lazy2_extDict,
ZSTD_compressBlock_btlazy2_extDict, ZSTD_compressBlock_btlazy2_extDict,
ZSTD_compressBlock_btopt_extDict, ZSTD_compressBlock_btopt_extDict,
ZSTD_compressBlock_btultra_extDict,
ZSTD_compressBlock_btultra_extDict }, ZSTD_compressBlock_btultra_extDict },
{ ZSTD_compressBlock_fast_dictMatchState /* default for 0 */, { ZSTD_compressBlock_fast_dictMatchState /* default for 0 */,
ZSTD_compressBlock_fast_dictMatchState, ZSTD_compressBlock_fast_dictMatchState,
ZSTD_compressBlock_doubleFast_dictMatchState, ZSTD_compressBlock_doubleFast_dictMatchState,
ZSTD_compressBlock_greedy_dictMatchState, ZSTD_compressBlock_greedy_dictMatchState,
ZSTD_compressBlock_lazy_dictMatchState, ZSTD_compressBlock_lazy_dictMatchState,
ZSTD_compressBlock_lazy2_dictMatchState, ZSTD_compressBlock_lazy2_dictMatchState,
ZSTD_compressBlock_btlazy2_dictMatchState, ZSTD_compressBlock_btlazy2_dictMatchState,
ZSTD_compressBlock_btopt_dictMatchState, ZSTD_compressBlock_btopt_dictMatchState,
ZSTD_compressBlock_btultra_dictMatchState,
ZSTD_compressBlock_btultra_dictMatchState } ZSTD_compressBlock_btultra_dictMatchState }
}; };
ZSTD_blockCompressor selectedCompressor; ZSTD_blockCompressor selectedCompressor;
ZSTD_STATIC_ASSERT((unsigned)ZSTD_fast == 1); ZSTD_STATIC_ASSERT((unsigned)ZSTD_fast == 1);
assert((U32)strat >= (U32)ZSTD_fast); assert(ZSTD_cParam_withinBounds(ZSTD_c_strategy, strat));
assert((U32)strat <= (U32)ZSTD_btultra); selectedCompressor = blockCompressor[(int)dictMode][(int)strat];
selectedCompressor = blockCompressor[(int)dictMode][(U32)strat];
assert(selectedCompressor != NULL); assert(selectedCompressor != NULL);
return selectedCompressor; return selectedCompressor;
} }
static void ZSTD_storeLastLiterals(seqStore_t* seqStorePtr, static void ZSTD_storeLastLiterals(seqStore_t* seqStorePtr,
const BYTE* anchor, size_t lastLLSize) const BYTE* anchor, size_t lastLLSize)
{ {
memcpy(seqStorePtr->lit, anchor, lastLLSize); memcpy(seqStorePtr->lit, anchor, lastLLSize);
seqStorePtr->lit += lastLLSize; seqStorePtr->lit += lastLLSize;
} }
void ZSTD_resetSeqStore(seqStore_t* ssPtr) void ZSTD_resetSeqStore(seqStore_t* ssPtr)
{ {
ssPtr->lit = ssPtr->litStart; ssPtr->lit = ssPtr->litStart;
ssPtr->sequences = ssPtr->sequencesStart; ssPtr->sequences = ssPtr->sequencesStart;
ssPtr->longLengthID = 0; ssPtr->longLengthID = 0;
} }
static size_t ZSTD_compressBlock_internal(ZSTD_CCtx* zc, static size_t ZSTD_compressBlock_internal(ZSTD_CCtx* zc,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize) const void* src, size_t srcSize)
{ {
ZSTD_matchState_t* const ms = &zc->blockState.matchState; ZSTD_matchState_t* const ms = &zc->blockState.matchState;
size_t cSize; size_t cSize;
DEBUGLOG(5, "ZSTD_compressBlock_internal (dstCapacity=%zu, dictLimit=%u, nextToUpdate=%u)", DEBUGLOG(5, "ZSTD_compressBlock_internal (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u)",
dstCapacity, ms->window.dictLimit, ms->nextToUpdate); (unsigned)dstCapacity, (unsigned)ms->window.dictLimit, (unsigned)ms->nextToUpdate);
assert(srcSize <= ZSTD_BLOCKSIZE_MAX); assert(srcSize <= ZSTD_BLOCKSIZE_MAX);
/* Assert that we have correctly flushed the ctx params into the ms's copy */ /* Assert that we have correctly flushed the ctx params into the ms's copy */
ZSTD_assertEqualCParams(zc->appliedParams.cParams, ms->cParams); ZSTD_assertEqualCParams(zc->appliedParams.cParams, ms->cParams);
if (srcSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1) { if (srcSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1) {
ZSTD_ldm_skipSequences(&zc->externSeqStore, srcSize, zc->appliedParams.cParams.searchLength); ZSTD_ldm_skipSequences(&zc->externSeqStore, srcSize, zc->appliedParams.cParams.minMatch);
cSize = 0; cSize = 0;
goto out; /* don't even attempt compression below a certain srcSize */ goto out; /* don't even attempt compression below a certain srcSize */
} }
ZSTD_resetSeqStore(&(zc->seqStore)); ZSTD_resetSeqStore(&(zc->seqStore));
ms->opt.symbolCosts = &zc->blockState.prevCBlock->entropy; /* required for optimal parser to read stats from dictionary */ ms->opt.symbolCosts = &zc->blockState.prevCBlock->entropy; /* required for optimal parser to read stats from dictionary */
/* a gap between an attached dict and the current window is not safe, /* a gap between an attached dict and the current window is not safe,
* they must remain adjacent, and when that stops being the case, the dict * they must remain adjacent,
* must be unset */ * and when that stops being the case, the dict must be unset */
assert(ms->dictMatchState == NULL || ms->loadedDictEnd == ms->window.dictLimit); assert(ms->dictMatchState == NULL || ms->loadedDictEnd == ms->window.dictLimit);
/* limited update after a very long match */ /* limited update after a very long match */
{ const BYTE* const base = ms->window.base; { const BYTE* const base = ms->window.base;
const BYTE* const istart = (const BYTE*)src; const BYTE* const istart = (const BYTE*)src;
const U32 current = (U32)(istart-base); const U32 current = (U32)(istart-base);
if (sizeof(ptrdiff_t)==8) assert(istart - base < (ptrdiff_t)(U32)(-1)); /* ensure no overflow */ if (sizeof(ptrdiff_t)==8) assert(istart - base < (ptrdiff_t)(U32)(-1)); /* ensure no overflow */
if (current > ms->nextToUpdate + 384) if (current > ms->nextToUpdate + 384)
ZSTD_storeLastLiterals(&zc->seqStore, lastLiterals, lastLLSize); ZSTD_storeLastLiterals(&zc->seqStore, lastLiterals, lastLLSize);
} } } }
/* encode sequences and literals */ /* encode sequences and literals */
cSize = ZSTD_compressSequences(&zc->seqStore, cSize = ZSTD_compressSequences(&zc->seqStore,
&zc->blockState.prevCBlock->entropy, &zc->blockState.nextCBlock->entropy, &zc->blockState.prevCBlock->entropy, &zc->blockState.nextCBlock->entropy,
&zc->appliedParams, &zc->appliedParams,
dst, dstCapacity, dst, dstCapacity,
srcSize, zc->entropyWorkspace, zc->bmi2); srcSize,
zc->entropyWorkspace, HUF_WORKSPACE_SIZE /* statically allocated in resetCCtx */,
zc->bmi2);
out: out:
if (!ZSTD_isError(cSize) && cSize != 0) { if (!ZSTD_isError(cSize) && cSize != 0) {
/* confirm repcodes and entropy tables when emitting a compressed block */ /* confirm repcodes and entropy tables when emitting a compressed block */
ZSTD_compressedBlockState_t* const tmp = zc->blockState.prevCBlock; ZSTD_compressedBlockState_t* const tmp = zc->blockState.prevCBlock;
zc->blockState.prevCBlock = zc->blockState.nextCBlock; zc->blockState.prevCBlock = zc->blockState.nextCBlock;
zc->blockState.nextCBlock = tmp; zc->blockState.nextCBlock = tmp;
} }
size_t blockSize = cctx->blockSize; size_t blockSize = cctx->blockSize;
size_t remaining = srcSize; size_t remaining = srcSize;
const BYTE* ip = (const BYTE*)src; const BYTE* ip = (const BYTE*)src;
BYTE* const ostart = (BYTE*)dst; BYTE* const ostart = (BYTE*)dst;
BYTE* op = ostart; BYTE* op = ostart;
U32 const maxDist = (U32)1 << cctx->appliedParams.cParams.windowLog; U32 const maxDist = (U32)1 << cctx->appliedParams.cParams.windowLog;
assert(cctx->appliedParams.cParams.windowLog <= 31); assert(cctx->appliedParams.cParams.windowLog <= 31);
DEBUGLOG(5, "ZSTD_compress_frameChunk (blockSize=%u)", (U32)blockSize); DEBUGLOG(5, "ZSTD_compress_frameChunk (blockSize=%u)", (unsigned)blockSize);
if (cctx->appliedParams.fParams.checksumFlag && srcSize) if (cctx->appliedParams.fParams.checksumFlag && srcSize)
XXH64_update(&cctx->xxhState, src, srcSize); XXH64_update(&cctx->xxhState, src, srcSize);
while (remaining) { while (remaining) {
ZSTD_matchState_t* const ms = &cctx->blockState.matchState; ZSTD_matchState_t* const ms = &cctx->blockState.matchState;
U32 const lastBlock = lastFrameChunk & (blockSize >= remaining); U32 const lastBlock = lastFrameChunk & (blockSize >= remaining);
if (dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE) if (dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE)
ip += blockSize; ip += blockSize;
assert(remaining >= blockSize); assert(remaining >= blockSize);
remaining -= blockSize; remaining -= blockSize;
op += cSize; op += cSize;
assert(dstCapacity >= cSize); assert(dstCapacity >= cSize);
dstCapacity -= cSize; dstCapacity -= cSize;
DEBUGLOG(5, "ZSTD_compress_frameChunk: adding a block of size %u", DEBUGLOG(5, "ZSTD_compress_frameChunk: adding a block of size %u",
(U32)cSize); (unsigned)cSize);
} } } }
if (lastFrameChunk && (op>ostart)) cctx->stage = ZSTDcs_ending; if (lastFrameChunk && (op>ostart)) cctx->stage = ZSTDcs_ending;
return op-ostart; return op-ostart;
} }
static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity, static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity,
ZSTD_CCtx_params params, U64 pledgedSrcSize, U32 dictID) ZSTD_CCtx_params params, U64 pledgedSrcSize, U32 dictID)
{ BYTE* const op = (BYTE*)dst; { BYTE* const op = (BYTE*)dst;
U32 const dictIDSizeCodeLength = (dictID>0) + (dictID>=256) + (dictID>=65536); /* 0-3 */ U32 const dictIDSizeCodeLength = (dictID>0) + (dictID>=256) + (dictID>=65536); /* 0-3 */
U32 const dictIDSizeCode = params.fParams.noDictIDFlag ? 0 : dictIDSizeCodeLength; /* 0-3 */ U32 const dictIDSizeCode = params.fParams.noDictIDFlag ? 0 : dictIDSizeCodeLength; /* 0-3 */
U32 const checksumFlag = params.fParams.checksumFlag>0; U32 const checksumFlag = params.fParams.checksumFlag>0;
U32 const windowSize = (U32)1 << params.cParams.windowLog; U32 const windowSize = (U32)1 << params.cParams.windowLog;
U32 const singleSegment = params.fParams.contentSizeFlag && (windowSize >= pledgedSrcSize); U32 const singleSegment = params.fParams.contentSizeFlag && (windowSize >= pledgedSrcSize);
BYTE const windowLogByte = (BYTE)((params.cParams.windowLog - ZSTD_WINDOWLOG_ABSOLUTEMIN) << 3); BYTE const windowLogByte = (BYTE)((params.cParams.windowLog - ZSTD_WINDOWLOG_ABSOLUTEMIN) << 3);
U32 const fcsCode = params.fParams.contentSizeFlag ? U32 const fcsCode = params.fParams.contentSizeFlag ?
(pledgedSrcSize>=256) + (pledgedSrcSize>=65536+256) + (pledgedSrcSize>=0xFFFFFFFFU) : 0; /* 0-3 */ (pledgedSrcSize>=256) + (pledgedSrcSize>=65536+256) + (pledgedSrcSize>=0xFFFFFFFFU) : 0; /* 0-3 */
BYTE const frameHeaderDecriptionByte = (BYTE)(dictIDSizeCode + (checksumFlag<<2) + (singleSegment<<5) + (fcsCode<<6) ); BYTE const frameHeaderDecriptionByte = (BYTE)(dictIDSizeCode + (checksumFlag<<2) + (singleSegment<<5) + (fcsCode<<6) );
size_t pos=0; size_t pos=0;
assert(!(params.fParams.contentSizeFlag && pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN)); assert(!(params.fParams.contentSizeFlag && pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN));
if (dstCapacity < ZSTD_frameHeaderSize_max) return ERROR(dstSize_tooSmall); if (dstCapacity < ZSTD_FRAMEHEADERSIZE_MAX) return ERROR(dstSize_tooSmall);
DEBUGLOG(4, "ZSTD_writeFrameHeader : dictIDFlag : %u ; dictID : %u ; dictIDSizeCode : %u", DEBUGLOG(4, "ZSTD_writeFrameHeader : dictIDFlag : %u ; dictID : %u ; dictIDSizeCode : %u",
!params.fParams.noDictIDFlag, dictID, dictIDSizeCode); !params.fParams.noDictIDFlag, (unsigned)dictID, (unsigned)dictIDSizeCode);
if (params.format == ZSTD_f_zstd1) { if (params.format == ZSTD_f_zstd1) {
MEM_writeLE32(dst, ZSTD_MAGICNUMBER); MEM_writeLE32(dst, ZSTD_MAGICNUMBER);
pos = 4; pos = 4;
} }
op[pos++] = frameHeaderDecriptionByte; op[pos++] = frameHeaderDecriptionByte;
if (!singleSegment) op[pos++] = windowLogByte; if (!singleSegment) op[pos++] = windowLogByte;
switch(dictIDSizeCode) switch(dictIDSizeCode)
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const void* src, size_t srcSize,
U32 frame, U32 lastFrameChunk) U32 frame, U32 lastFrameChunk)
{ {
ZSTD_matchState_t* const ms = &cctx->blockState.matchState; ZSTD_matchState_t* const ms = &cctx->blockState.matchState;
size_t fhSize = 0; size_t fhSize = 0;
DEBUGLOG(5, "ZSTD_compressContinue_internal, stage: %u, srcSize: %u", DEBUGLOG(5, "ZSTD_compressContinue_internal, stage: %u, srcSize: %u",
cctx->stage, (U32)srcSize); cctx->stage, (unsigned)srcSize);
if (cctx->stage==ZSTDcs_created) return ERROR(stage_wrong); /* missing init (ZSTD_compressBegin) */ if (cctx->stage==ZSTDcs_created) return ERROR(stage_wrong); /* missing init (ZSTD_compressBegin) */
if (frame && (cctx->stage==ZSTDcs_init)) { if (frame && (cctx->stage==ZSTDcs_init)) {
fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, cctx->appliedParams, fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, cctx->appliedParams,
cctx->pledgedSrcSizePlusOne-1, cctx->dictID); cctx->pledgedSrcSizePlusOne-1, cctx->dictID);
if (ZSTD_isError(fhSize)) return fhSize; if (ZSTD_isError(fhSize)) return fhSize;
dstCapacity -= fhSize; dstCapacity -= fhSize;
dst = (char*)dst + fhSize; dst = (char*)dst + fhSize;
ZSTD_reduceIndex(cctx, correction); ZSTD_reduceIndex(cctx, correction);
if (ms->nextToUpdate < correction) ms->nextToUpdate = 0; if (ms->nextToUpdate < correction) ms->nextToUpdate = 0;
else ms->nextToUpdate -= correction; else ms->nextToUpdate -= correction;
ms->loadedDictEnd = 0; ms->loadedDictEnd = 0;
ms->dictMatchState = NULL; ms->dictMatchState = NULL;
} }
} }
DEBUGLOG(5, "ZSTD_compressContinue_internal (blockSize=%u)", (U32)cctx->blockSize); DEBUGLOG(5, "ZSTD_compressContinue_internal (blockSize=%u)", (unsigned)cctx->blockSize);
{ size_t const cSize = frame ? { size_t const cSize = frame ?
ZSTD_compress_frameChunk (cctx, dst, dstCapacity, src, srcSize, lastFrameChunk) : ZSTD_compress_frameChunk (cctx, dst, dstCapacity, src, srcSize, lastFrameChunk) :
ZSTD_compressBlock_internal (cctx, dst, dstCapacity, src, srcSize); ZSTD_compressBlock_internal (cctx, dst, dstCapacity, src, srcSize);
if (ZSTD_isError(cSize)) return cSize; if (ZSTD_isError(cSize)) return cSize;
cctx->consumedSrcSize += srcSize; cctx->consumedSrcSize += srcSize;
cctx->producedCSize += (cSize + fhSize); cctx->producedCSize += (cSize + fhSize);
assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0)); assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0));
if (cctx->pledgedSrcSizePlusOne != 0) { /* control src size */ if (cctx->pledgedSrcSizePlusOne != 0) { /* control src size */
ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1); ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1);
if (cctx->consumedSrcSize+1 > cctx->pledgedSrcSizePlusOne) { if (cctx->consumedSrcSize+1 > cctx->pledgedSrcSizePlusOne) {
DEBUGLOG(4, "error : pledgedSrcSize = %u, while realSrcSize >= %u", DEBUGLOG(4, "error : pledgedSrcSize = %u, while realSrcSize >= %u",
(U32)cctx->pledgedSrcSizePlusOne-1, (U32)cctx->consumedSrcSize); (unsigned)cctx->pledgedSrcSizePlusOne-1, (unsigned)cctx->consumedSrcSize);
return ERROR(srcSize_wrong); return ERROR(srcSize_wrong);
} }
} }
return cSize + fhSize; return cSize + fhSize;
} }
} }
size_t ZSTD_compressContinue (ZSTD_CCtx* cctx, size_t ZSTD_compressContinue (ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize) const void* src, size_t srcSize)
{ {
DEBUGLOG(5, "ZSTD_compressContinue (srcSize=%u)", (U32)srcSize); DEBUGLOG(5, "ZSTD_compressContinue (srcSize=%u)", (unsigned)srcSize);
return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1 /* frame mode */, 0 /* last chunk */); return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1 /* frame mode */, 0 /* last chunk */);
} }
size_t ZSTD_getBlockSize(const ZSTD_CCtx* cctx) size_t ZSTD_getBlockSize(const ZSTD_CCtx* cctx)
{ {
ZSTD_compressionParameters const cParams = cctx->appliedParams.cParams; ZSTD_compressionParameters const cParams = cctx->appliedParams.cParams;
assert(!ZSTD_checkCParams(cParams)); assert(!ZSTD_checkCParams(cParams));
case ZSTD_lazy2: case ZSTD_lazy2:
if (srcSize >= HASH_READ_SIZE) if (srcSize >= HASH_READ_SIZE)
ZSTD_insertAndFindFirstIndex(ms, iend-HASH_READ_SIZE); ZSTD_insertAndFindFirstIndex(ms, iend-HASH_READ_SIZE);
break; break;
case ZSTD_btlazy2: /* we want the dictionary table fully sorted */ case ZSTD_btlazy2: /* we want the dictionary table fully sorted */
case ZSTD_btopt: case ZSTD_btopt:
case ZSTD_btultra: case ZSTD_btultra:
case ZSTD_btultra2:
if (srcSize >= HASH_READ_SIZE) if (srcSize >= HASH_READ_SIZE)
ZSTD_updateTree(ms, iend-HASH_READ_SIZE, iend); ZSTD_updateTree(ms, iend-HASH_READ_SIZE, iend);
break; break;
default: default:
assert(0); /* not possible : not a valid strategy id */ assert(0); /* not possible : not a valid strategy id */
} }
} }
{ unsigned offcodeLog; { unsigned offcodeLog;
size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr); size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr);
if (FSE_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted); if (FSE_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted);
if (offcodeLog > OffFSELog) return ERROR(dictionary_corrupted); if (offcodeLog > OffFSELog) return ERROR(dictionary_corrupted);
/* Defer checking offcodeMaxValue because we need to know the size of the dictionary content */ /* Defer checking offcodeMaxValue because we need to know the size of the dictionary content */
/* fill all offset symbols to avoid garbage at end of table */ /* fill all offset symbols to avoid garbage at end of table */
CHECK_E( FSE_buildCTable_wksp(bs->entropy.fse.offcodeCTable, offcodeNCount, MaxOff, offcodeLog, workspace, HUF_WORKSPACE_SIZE), CHECK_E( FSE_buildCTable_wksp(bs->entropy.fse.offcodeCTable,
offcodeNCount, MaxOff, offcodeLog,
workspace, HUF_WORKSPACE_SIZE),
dictionary_corrupted); dictionary_corrupted);
dictPtr += offcodeHeaderSize; dictPtr += offcodeHeaderSize;
} }
{ short matchlengthNCount[MaxML+1]; { short matchlengthNCount[MaxML+1];
unsigned matchlengthMaxValue = MaxML, matchlengthLog; unsigned matchlengthMaxValue = MaxML, matchlengthLog;
size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr); size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr);
if (FSE_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted); if (FSE_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted);
if (matchlengthLog > MLFSELog) return ERROR(dictionary_corrupted); if (matchlengthLog > MLFSELog) return ERROR(dictionary_corrupted);
/* Every match length code must have non-zero probability */ /* Every match length code must have non-zero probability */
CHECK_F( ZSTD_checkDictNCount(matchlengthNCount, matchlengthMaxValue, MaxML)); CHECK_F( ZSTD_checkDictNCount(matchlengthNCount, matchlengthMaxValue, MaxML));
CHECK_E( FSE_buildCTable_wksp(bs->entropy.fse.matchlengthCTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog, workspace, HUF_WORKSPACE_SIZE), CHECK_E( FSE_buildCTable_wksp(bs->entropy.fse.matchlengthCTable,
matchlengthNCount, matchlengthMaxValue, matchlengthLog,
workspace, HUF_WORKSPACE_SIZE),
dictionary_corrupted); dictionary_corrupted);
dictPtr += matchlengthHeaderSize; dictPtr += matchlengthHeaderSize;
} }
{ short litlengthNCount[MaxLL+1]; { short litlengthNCount[MaxLL+1];
unsigned litlengthMaxValue = MaxLL, litlengthLog; unsigned litlengthMaxValue = MaxLL, litlengthLog;
size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr); size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr);
if (FSE_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted); if (FSE_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted);
if (litlengthLog > LLFSELog) return ERROR(dictionary_corrupted); if (litlengthLog > LLFSELog) return ERROR(dictionary_corrupted);
/* Every literal length code must have non-zero probability */ /* Every literal length code must have non-zero probability */
CHECK_F( ZSTD_checkDictNCount(litlengthNCount, litlengthMaxValue, MaxLL)); CHECK_F( ZSTD_checkDictNCount(litlengthNCount, litlengthMaxValue, MaxLL));
CHECK_E( FSE_buildCTable_wksp(bs->entropy.fse.litlengthCTable, litlengthNCount, litlengthMaxValue, litlengthLog, workspace, HUF_WORKSPACE_SIZE), CHECK_E( FSE_buildCTable_wksp(bs->entropy.fse.litlengthCTable,
litlengthNCount, litlengthMaxValue, litlengthLog,
workspace, HUF_WORKSPACE_SIZE),
dictionary_corrupted); dictionary_corrupted);
dictPtr += litlengthHeaderSize; dictPtr += litlengthHeaderSize;
} }
if (dictPtr+12 > dictEnd) return ERROR(dictionary_corrupted); if (dictPtr+12 > dictEnd) return ERROR(dictionary_corrupted);
bs->rep[0] = MEM_readLE32(dictPtr+0); bs->rep[0] = MEM_readLE32(dictPtr+0);
bs->rep[1] = MEM_readLE32(dictPtr+4); bs->rep[1] = MEM_readLE32(dictPtr+4);
bs->rep[2] = MEM_readLE32(dictPtr+8); bs->rep[2] = MEM_readLE32(dictPtr+8);
cctxParams, pledgedSrcSize); cctxParams, pledgedSrcSize);
} }
size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel) size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel)
{ {
ZSTD_parameters const params = ZSTD_getParams(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize); ZSTD_parameters const params = ZSTD_getParams(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize);
ZSTD_CCtx_params const cctxParams = ZSTD_CCtx_params const cctxParams =
ZSTD_assignParamsToCCtxParams(cctx->requestedParams, params); ZSTD_assignParamsToCCtxParams(cctx->requestedParams, params);
DEBUGLOG(4, "ZSTD_compressBegin_usingDict (dictSize=%u)", (U32)dictSize); DEBUGLOG(4, "ZSTD_compressBegin_usingDict (dictSize=%u)", (unsigned)dictSize);
return ZSTD_compressBegin_internal(cctx, dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL, return ZSTD_compressBegin_internal(cctx, dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,
cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, ZSTDb_not_buffered); cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, ZSTDb_not_buffered);
} }
size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel) size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel)
{ {
return ZSTD_compressBegin_usingDict(cctx, NULL, 0, compressionLevel); return ZSTD_compressBegin_usingDict(cctx, NULL, 0, compressionLevel);
} }
MEM_writeLE32(op, cBlockHeader24); MEM_writeLE32(op, cBlockHeader24);
op += ZSTD_blockHeaderSize; op += ZSTD_blockHeaderSize;
dstCapacity -= ZSTD_blockHeaderSize; dstCapacity -= ZSTD_blockHeaderSize;
} }
if (cctx->appliedParams.fParams.checksumFlag) { if (cctx->appliedParams.fParams.checksumFlag) {
U32 const checksum = (U32) XXH64_digest(&cctx->xxhState); U32 const checksum = (U32) XXH64_digest(&cctx->xxhState);
if (dstCapacity<4) return ERROR(dstSize_tooSmall); if (dstCapacity<4) return ERROR(dstSize_tooSmall);
DEBUGLOG(4, "ZSTD_writeEpilogue: write checksum : %08X", checksum); DEBUGLOG(4, "ZSTD_writeEpilogue: write checksum : %08X", (unsigned)checksum);
MEM_writeLE32(op, checksum); MEM_writeLE32(op, checksum);
op += 4; op += 4;
} }
cctx->stage = ZSTDcs_created; /* return to "created but no init" status */ cctx->stage = ZSTDcs_created; /* return to "created but no init" status */
return op-ostart; return op-ostart;
} }
endResult = ZSTD_writeEpilogue(cctx, (char*)dst + cSize, dstCapacity-cSize); endResult = ZSTD_writeEpilogue(cctx, (char*)dst + cSize, dstCapacity-cSize);
if (ZSTD_isError(endResult)) return endResult; if (ZSTD_isError(endResult)) return endResult;
assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0)); assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0));
if (cctx->pledgedSrcSizePlusOne != 0) { /* control src size */ if (cctx->pledgedSrcSizePlusOne != 0) { /* control src size */
ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1); ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1);
DEBUGLOG(4, "end of frame : controlling src size"); DEBUGLOG(4, "end of frame : controlling src size");
if (cctx->pledgedSrcSizePlusOne != cctx->consumedSrcSize+1) { if (cctx->pledgedSrcSizePlusOne != cctx->consumedSrcSize+1) {
DEBUGLOG(4, "error : pledgedSrcSize = %u, while realSrcSize = %u", DEBUGLOG(4, "error : pledgedSrcSize = %u, while realSrcSize = %u",
(U32)cctx->pledgedSrcSizePlusOne-1, (U32)cctx->consumedSrcSize); (unsigned)cctx->pledgedSrcSizePlusOne-1, (unsigned)cctx->consumedSrcSize);
return ERROR(srcSize_wrong); return ERROR(srcSize_wrong);
} } } }
return cSize + endResult; return cSize + endResult;
} }
static size_t ZSTD_compress_internal (ZSTD_CCtx* cctx, static size_t ZSTD_compress_internal (ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
/* Internal */ /* Internal */
size_t ZSTD_compress_advanced_internal( size_t ZSTD_compress_advanced_internal(
ZSTD_CCtx* cctx, ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const void* src, size_t srcSize,
const void* dict,size_t dictSize, const void* dict,size_t dictSize,
ZSTD_CCtx_params params) ZSTD_CCtx_params params)
{ {
DEBUGLOG(4, "ZSTD_compress_advanced_internal (srcSize:%u)", (U32)srcSize); DEBUGLOG(4, "ZSTD_compress_advanced_internal (srcSize:%u)", (unsigned)srcSize);
CHECK_F( ZSTD_compressBegin_internal(cctx, CHECK_F( ZSTD_compressBegin_internal(cctx,
dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL, dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,
params, srcSize, ZSTDb_not_buffered) ); params, srcSize, ZSTDb_not_buffered) );
return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize); return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
} }
size_t ZSTD_compress_usingDict(ZSTD_CCtx* cctx, size_t ZSTD_compress_usingDict(ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const void* src, size_t srcSize,
const void* dict, size_t dictSize, const void* dict, size_t dictSize,
int compressionLevel) int compressionLevel)
{ {
ZSTD_parameters const params = ZSTD_getParams(compressionLevel, srcSize + (!srcSize), dict ? dictSize : 0); ZSTD_parameters const params = ZSTD_getParams(compressionLevel, srcSize + (!srcSize), dict ? dictSize : 0);
ZSTD_CCtx_params cctxParams = ZSTD_assignParamsToCCtxParams(cctx->requestedParams, params); ZSTD_CCtx_params cctxParams = ZSTD_assignParamsToCCtxParams(cctx->requestedParams, params);
assert(params.fParams.contentSizeFlag == 1); assert(params.fParams.contentSizeFlag == 1);
return ZSTD_compress_advanced_internal(cctx, dst, dstCapacity, src, srcSize, dict, dictSize, cctxParams); return ZSTD_compress_advanced_internal(cctx, dst, dstCapacity, src, srcSize, dict, dictSize, cctxParams);
} }
size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx, size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const void* src, size_t srcSize,
int compressionLevel) int compressionLevel)
{ {
DEBUGLOG(4, "ZSTD_compressCCtx (srcSize=%u)", (U32)srcSize); DEBUGLOG(4, "ZSTD_compressCCtx (srcSize=%u)", (unsigned)srcSize);
assert(cctx != NULL); assert(cctx != NULL);
return ZSTD_compress_usingDict(cctx, dst, dstCapacity, src, srcSize, NULL, 0, compressionLevel); return ZSTD_compress_usingDict(cctx, dst, dstCapacity, src, srcSize, NULL, 0, compressionLevel);
} }
size_t ZSTD_compress(void* dst, size_t dstCapacity, size_t ZSTD_compress(void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const void* src, size_t srcSize,
int compressionLevel) int compressionLevel)
{ {
/* ===== Dictionary API ===== */ /* ===== Dictionary API ===== */
/*! ZSTD_estimateCDictSize_advanced() : /*! ZSTD_estimateCDictSize_advanced() :
* Estimate amount of memory that will be needed to create a dictionary with following arguments */ * Estimate amount of memory that will be needed to create a dictionary with following arguments */
size_t ZSTD_estimateCDictSize_advanced( size_t ZSTD_estimateCDictSize_advanced(
size_t dictSize, ZSTD_compressionParameters cParams, size_t dictSize, ZSTD_compressionParameters cParams,
ZSTD_dictLoadMethod_e dictLoadMethod) ZSTD_dictLoadMethod_e dictLoadMethod)
{ {
DEBUGLOG(5, "sizeof(ZSTD_CDict) : %u", (U32)sizeof(ZSTD_CDict)); DEBUGLOG(5, "sizeof(ZSTD_CDict) : %u", (unsigned)sizeof(ZSTD_CDict));
return sizeof(ZSTD_CDict) + HUF_WORKSPACE_SIZE + ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 0) return sizeof(ZSTD_CDict) + HUF_WORKSPACE_SIZE + ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 0)
+ (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize); + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);
} }
size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel) size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel)
{ {
ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, 0, dictSize); ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, 0, dictSize);
return ZSTD_estimateCDictSize_advanced(dictSize, cParams, ZSTD_dlm_byCopy); return ZSTD_estimateCDictSize_advanced(dictSize, cParams, ZSTD_dlm_byCopy);
} }
size_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict) size_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict)
{ {
if (cdict==NULL) return 0; /* support sizeof on NULL */ if (cdict==NULL) return 0; /* support sizeof on NULL */
DEBUGLOG(5, "sizeof(*cdict) : %u", (U32)sizeof(*cdict)); DEBUGLOG(5, "sizeof(*cdict) : %u", (unsigned)sizeof(*cdict));
return cdict->workspaceSize + (cdict->dictBuffer ? cdict->dictContentSize : 0) + sizeof(*cdict); return cdict->workspaceSize + (cdict->dictBuffer ? cdict->dictContentSize : 0) + sizeof(*cdict);
} }
static size_t ZSTD_initCDict_internal( static size_t ZSTD_initCDict_internal(
ZSTD_CDict* cdict, ZSTD_CDict* cdict,
const void* dictBuffer, size_t dictSize, const void* dictBuffer, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType, ZSTD_dictContentType_e dictContentType,
ZSTD_compressionParameters cParams) ZSTD_compressionParameters cParams)
{ {
DEBUGLOG(3, "ZSTD_initCDict_internal (dictContentType:%u)", (U32)dictContentType); DEBUGLOG(3, "ZSTD_initCDict_internal (dictContentType:%u)", (unsigned)dictContentType);
assert(!ZSTD_checkCParams(cParams)); assert(!ZSTD_checkCParams(cParams));
cdict->matchState.cParams = cParams; cdict->matchState.cParams = cParams;
if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dictBuffer) || (!dictSize)) { if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dictBuffer) || (!dictSize)) {
cdict->dictBuffer = NULL; cdict->dictBuffer = NULL;
cdict->dictContent = dictBuffer; cdict->dictContent = dictBuffer;
} else { } else {
void* const internalBuffer = ZSTD_malloc(dictSize, cdict->customMem); void* const internalBuffer = ZSTD_malloc(dictSize, cdict->customMem);
cdict->dictBuffer = internalBuffer; cdict->dictBuffer = internalBuffer;
return 0; return 0;
} }
ZSTD_CDict* ZSTD_createCDict_advanced(const void* dictBuffer, size_t dictSize, ZSTD_CDict* ZSTD_createCDict_advanced(const void* dictBuffer, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType, ZSTD_dictContentType_e dictContentType,
ZSTD_compressionParameters cParams, ZSTD_customMem customMem) ZSTD_compressionParameters cParams, ZSTD_customMem customMem)
{ {
DEBUGLOG(3, "ZSTD_createCDict_advanced, mode %u", (U32)dictContentType); DEBUGLOG(3, "ZSTD_createCDict_advanced, mode %u", (unsigned)dictContentType);
if (!customMem.customAlloc ^ !customMem.customFree) return NULL; if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
{ ZSTD_CDict* const cdict = (ZSTD_CDict*)ZSTD_malloc(sizeof(ZSTD_CDict), customMem); { ZSTD_CDict* const cdict = (ZSTD_CDict*)ZSTD_malloc(sizeof(ZSTD_CDict), customMem);
size_t const workspaceSize = HUF_WORKSPACE_SIZE + ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 0); size_t const workspaceSize = HUF_WORKSPACE_SIZE + ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 0);
void* const workspace = ZSTD_malloc(workspaceSize, customMem); void* const workspace = ZSTD_malloc(workspaceSize, customMem);
if (!cdict || !workspace) { if (!cdict || !workspace) {
ZSTD_free(cdict, customMem); ZSTD_free(cdict, customMem);
{ {
size_t const matchStateSize = ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 0); size_t const matchStateSize = ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 0);
size_t const neededSize = sizeof(ZSTD_CDict) + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize) size_t const neededSize = sizeof(ZSTD_CDict) + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize)
+ HUF_WORKSPACE_SIZE + matchStateSize; + HUF_WORKSPACE_SIZE + matchStateSize;
ZSTD_CDict* const cdict = (ZSTD_CDict*) workspace; ZSTD_CDict* const cdict = (ZSTD_CDict*) workspace;
void* ptr; void* ptr;
if ((size_t)workspace & 7) return NULL; /* 8-aligned */ if ((size_t)workspace & 7) return NULL; /* 8-aligned */
DEBUGLOG(4, "(workspaceSize < neededSize) : (%u < %u) => %u", DEBUGLOG(4, "(workspaceSize < neededSize) : (%u < %u) => %u",
(U32)workspaceSize, (U32)neededSize, (U32)(workspaceSize < neededSize)); (unsigned)workspaceSize, (unsigned)neededSize, (unsigned)(workspaceSize < neededSize));
if (workspaceSize < neededSize) return NULL; if (workspaceSize < neededSize) return NULL;
if (dictLoadMethod == ZSTD_dlm_byCopy) { if (dictLoadMethod == ZSTD_dlm_byCopy) {
memcpy(cdict+1, dict, dictSize); memcpy(cdict+1, dict, dictSize);
dict = cdict+1; dict = cdict+1;
ptr = (char*)workspace + sizeof(ZSTD_CDict) + dictSize; ptr = (char*)workspace + sizeof(ZSTD_CDict) + dictSize;
} else { } else {
ptr = cdict+1; ptr = cdict+1;
return 0; /* ready to go */ return 0; /* ready to go */
} }
/* ZSTD_resetCStream(): /* ZSTD_resetCStream():
* pledgedSrcSize == 0 means "unknown" */ * pledgedSrcSize == 0 means "unknown" */
size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize) size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize)
{ {
ZSTD_CCtx_params params = zcs->requestedParams; ZSTD_CCtx_params params = zcs->requestedParams;
DEBUGLOG(4, "ZSTD_resetCStream: pledgedSrcSize = %u", (U32)pledgedSrcSize); DEBUGLOG(4, "ZSTD_resetCStream: pledgedSrcSize = %u", (unsigned)pledgedSrcSize);
if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN; if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;
params.fParams.contentSizeFlag = 1; params.fParams.contentSizeFlag = 1;
return ZSTD_resetCStream_internal(zcs, NULL, 0, ZSTD_dct_auto, zcs->cdict, params, pledgedSrcSize); return ZSTD_resetCStream_internal(zcs, NULL, 0, ZSTD_dct_auto, zcs->cdict, params, pledgedSrcSize);
} }
/*! ZSTD_initCStream_internal() : /*! ZSTD_initCStream_internal() :
* Note : for lib/compress only. Used by zstdmt_compress.c. * Note : for lib/compress only. Used by zstdmt_compress.c.
* Assumption 1 : params are valid * Assumption 1 : params are valid
* Assumption 2 : either dict, or cdict, is defined, not both */ * Assumption 2 : either dict, or cdict, is defined, not both */
size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs, size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
const void* dict, size_t dictSize, const ZSTD_CDict* cdict, const void* dict, size_t dictSize, const ZSTD_CDict* cdict,
ZSTD_CCtx_params params, unsigned long long pledgedSrcSize) ZSTD_CCtx_params params, unsigned long long pledgedSrcSize)
{ {
DEBUGLOG(4, "ZSTD_initCStream_internal"); DEBUGLOG(4, "ZSTD_initCStream_internal");
params.cParams = ZSTD_getCParamsFromCCtxParams(&params, pledgedSrcSize, dictSize); params.cParams = ZSTD_getCParamsFromCCtxParams(&params, pledgedSrcSize, dictSize);
assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams))); assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
assert(!((dict) && (cdict))); /* either dict or cdict, not both */ assert(!((dict) && (cdict))); /* either dict or cdict, not both */
if (dict && dictSize >= 8) { if (dict && dictSize >= 8) {
DEBUGLOG(4, "loading dictionary of size %u", (U32)dictSize); DEBUGLOG(4, "loading dictionary of size %u", (unsigned)dictSize);
if (zcs->staticSize) { /* static CCtx : never uses malloc */ if (zcs->staticSize) { /* static CCtx : never uses malloc */
/* incompatible with internal cdict creation */ /* incompatible with internal cdict creation */
return ERROR(memory_allocation); return ERROR(memory_allocation);
} }
ZSTD_freeCDict(zcs->cdictLocal); ZSTD_freeCDict(zcs->cdictLocal);
zcs->cdictLocal = ZSTD_createCDict_advanced(dict, dictSize, zcs->cdictLocal = ZSTD_createCDict_advanced(dict, dictSize,
ZSTD_dlm_byCopy, ZSTD_dct_auto, ZSTD_dlm_byCopy, ZSTD_dct_auto,
params.cParams, zcs->customMem); params.cParams, zcs->customMem);
* pledgedSrcSize must be exact. * pledgedSrcSize must be exact.
* if srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. * if srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN.
* dict is loaded with default parameters ZSTD_dm_auto and ZSTD_dlm_byCopy. */ * dict is loaded with default parameters ZSTD_dm_auto and ZSTD_dlm_byCopy. */
size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs, size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
const void* dict, size_t dictSize, const void* dict, size_t dictSize,
ZSTD_parameters params, unsigned long long pledgedSrcSize) ZSTD_parameters params, unsigned long long pledgedSrcSize)
{ {
DEBUGLOG(4, "ZSTD_initCStream_advanced: pledgedSrcSize=%u, flag=%u", DEBUGLOG(4, "ZSTD_initCStream_advanced: pledgedSrcSize=%u, flag=%u",
(U32)pledgedSrcSize, params.fParams.contentSizeFlag); (unsigned)pledgedSrcSize, params.fParams.contentSizeFlag);
CHECK_F( ZSTD_checkCParams(params.cParams) ); CHECK_F( ZSTD_checkCParams(params.cParams) );
if ((pledgedSrcSize==0) && (params.fParams.contentSizeFlag==0)) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN; /* for compatibility with older programs relying on this behavior. Users should now specify ZSTD_CONTENTSIZE_UNKNOWN. This line will be removed in the future. */ if ((pledgedSrcSize==0) && (params.fParams.contentSizeFlag==0)) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN; /* for compatibility with older programs relying on this behavior. Users should now specify ZSTD_CONTENTSIZE_UNKNOWN. This line will be removed in the future. */
zcs->requestedParams = ZSTD_assignParamsToCCtxParams(zcs->requestedParams, params); zcs->requestedParams = ZSTD_assignParamsToCCtxParams(zcs->requestedParams, params);
return ZSTD_initCStream_internal(zcs, dict, dictSize, NULL /*cdict*/, zcs->requestedParams, pledgedSrcSize); return ZSTD_initCStream_internal(zcs, dict, dictSize, NULL /*cdict*/, zcs->requestedParams, pledgedSrcSize);
} }
size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel) size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel)
{ {
size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel) size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel)
{ {
DEBUGLOG(4, "ZSTD_initCStream"); DEBUGLOG(4, "ZSTD_initCStream");
return ZSTD_initCStream_srcSize(zcs, compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN); return ZSTD_initCStream_srcSize(zcs, compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN);
} }
/*====== Compression ======*/ /*====== Compression ======*/
MEM_STATIC size_t ZSTD_limitCopy(void* dst, size_t dstCapacity, static size_t ZSTD_nextInputSizeHint(const ZSTD_CCtx* cctx)
{
size_t hintInSize = cctx->inBuffTarget - cctx->inBuffPos;
if (hintInSize==0) hintInSize = cctx->blockSize;
return hintInSize;
}
static size_t ZSTD_limitCopy(void* dst, size_t dstCapacity,
const void* src, size_t srcSize) const void* src, size_t srcSize)
{ {
size_t const length = MIN(dstCapacity, srcSize); size_t const length = MIN(dstCapacity, srcSize);
if (length) memcpy(dst, src, length); if (length) memcpy(dst, src, length);
return length; return length;
} }
/** ZSTD_compressStream_generic(): /** ZSTD_compressStream_generic():
* internal function for all *compressStream*() variants and *compress_generic() * internal function for all *compressStream*() variants
* non-static, because can be called from zstdmt_compress.c * non-static, because can be called from zstdmt_compress.c
* @return : hint size for next input */ * @return : hint size for next input */
size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs, size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
ZSTD_outBuffer* output, ZSTD_outBuffer* output,
ZSTD_inBuffer* input, ZSTD_inBuffer* input,
ZSTD_EndDirective const flushMode) ZSTD_EndDirective const flushMode)
{ {
const char* const istart = (const char*)input->src; const char* const istart = (const char*)input->src;
const char* const iend = istart + input->size; const char* const iend = istart + input->size;
const char* ip = istart + input->pos; const char* ip = istart + input->pos;
char* const ostart = (char*)output->dst; char* const ostart = (char*)output->dst;
char* const oend = ostart + output->size; char* const oend = ostart + output->size;
char* op = ostart + output->pos; char* op = ostart + output->pos;
U32 someMoreWork = 1; U32 someMoreWork = 1;
/* check expectations */ /* check expectations */
DEBUGLOG(5, "ZSTD_compressStream_generic, flush=%u", (U32)flushMode); DEBUGLOG(5, "ZSTD_compressStream_generic, flush=%u", (unsigned)flushMode);
assert(zcs->inBuff != NULL); assert(zcs->inBuff != NULL);
assert(zcs->inBuffSize > 0); assert(zcs->inBuffSize > 0);
assert(zcs->outBuff != NULL); assert(zcs->outBuff != NULL);
assert(zcs->outBuffSize > 0); assert(zcs->outBuffSize > 0);
assert(output->pos <= output->size); assert(output->pos <= output->size);
assert(input->pos <= input->size); assert(input->pos <= input->size);
while (someMoreWork) { while (someMoreWork) {
switch(zcs->streamStage) switch(zcs->streamStage)
{ {
case zcss_init: case zcss_init:
/* call ZSTD_initCStream() first ! */ /* call ZSTD_initCStream() first ! */
return ERROR(init_missing); return ERROR(init_missing);
case zcss_load: case zcss_load:
if ( (flushMode == ZSTD_e_end) if ( (flushMode == ZSTD_e_end)
&& ((size_t)(oend-op) >= ZSTD_compressBound(iend-ip)) /* enough dstCapacity */ && ((size_t)(oend-op) >= ZSTD_compressBound(iend-ip)) /* enough dstCapacity */
&& (zcs->inBuffPos == 0) ) { && (zcs->inBuffPos == 0) ) {
/* shortcut to compression pass directly into output buffer */ /* shortcut to compression pass directly into output buffer */
size_t const cSize = ZSTD_compressEnd(zcs, size_t const cSize = ZSTD_compressEnd(zcs,
op, oend-op, ip, iend-ip); op, oend-op, ip, iend-ip);
DEBUGLOG(4, "ZSTD_compressEnd : %u", (U32)cSize); DEBUGLOG(4, "ZSTD_compressEnd : cSize=%u", (unsigned)cSize);
if (ZSTD_isError(cSize)) return cSize; if (ZSTD_isError(cSize)) return cSize;
ip = iend; ip = iend;
op += cSize; op += cSize;
zcs->frameEnded = 1; zcs->frameEnded = 1;
ZSTD_CCtx_reset(zcs); ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
someMoreWork = 0; break; someMoreWork = 0; break;
} }
/* complete loading into inBuffer */ /* complete loading into inBuffer */
{ size_t const toLoad = zcs->inBuffTarget - zcs->inBuffPos; { size_t const toLoad = zcs->inBuffTarget - zcs->inBuffPos;
size_t const loaded = ZSTD_limitCopy( size_t const loaded = ZSTD_limitCopy(
zcs->inBuff + zcs->inBuffPos, toLoad, zcs->inBuff + zcs->inBuffPos, toLoad,
ip, iend-ip); ip, iend-ip);
zcs->inBuffPos += loaded; zcs->inBuffPos += loaded;
zcs->inBuff + zcs->inToCompress, iSize); zcs->inBuff + zcs->inToCompress, iSize);
if (ZSTD_isError(cSize)) return cSize; if (ZSTD_isError(cSize)) return cSize;
zcs->frameEnded = lastBlock; zcs->frameEnded = lastBlock;
/* prepare next block */ /* prepare next block */
zcs->inBuffTarget = zcs->inBuffPos + zcs->blockSize; zcs->inBuffTarget = zcs->inBuffPos + zcs->blockSize;
if (zcs->inBuffTarget > zcs->inBuffSize) if (zcs->inBuffTarget > zcs->inBuffSize)
zcs->inBuffPos = 0, zcs->inBuffTarget = zcs->blockSize; zcs->inBuffPos = 0, zcs->inBuffTarget = zcs->blockSize;
DEBUGLOG(5, "inBuffTarget:%u / inBuffSize:%u", DEBUGLOG(5, "inBuffTarget:%u / inBuffSize:%u",
(U32)zcs->inBuffTarget, (U32)zcs->inBuffSize); (unsigned)zcs->inBuffTarget, (unsigned)zcs->inBuffSize);
if (!lastBlock) if (!lastBlock)
assert(zcs->inBuffTarget <= zcs->inBuffSize); assert(zcs->inBuffTarget <= zcs->inBuffSize);
zcs->inToCompress = zcs->inBuffPos; zcs->inToCompress = zcs->inBuffPos;
if (cDst == op) { /* no need to flush */ if (cDst == op) { /* no need to flush */
op += cSize; op += cSize;
if (zcs->frameEnded) { if (zcs->frameEnded) {
DEBUGLOG(5, "Frame completed directly in outBuffer"); DEBUGLOG(5, "Frame completed directly in outBuffer");
someMoreWork = 0; someMoreWork = 0;
ZSTD_CCtx_reset(zcs); ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
} }
break; break;
} }
zcs->outBuffContentSize = cSize; zcs->outBuffContentSize = cSize;
zcs->outBuffFlushedSize = 0; zcs->outBuffFlushedSize = 0;
zcs->streamStage = zcss_flush; /* pass-through to flush stage */ zcs->streamStage = zcss_flush; /* pass-through to flush stage */
} }
/* fall-through */ /* fall-through */
case zcss_flush: case zcss_flush:
DEBUGLOG(5, "flush stage"); DEBUGLOG(5, "flush stage");
{ size_t const toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize; { size_t const toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize;
size_t const flushed = ZSTD_limitCopy(op, oend-op, size_t const flushed = ZSTD_limitCopy(op, oend-op,
zcs->outBuff + zcs->outBuffFlushedSize, toFlush); zcs->outBuff + zcs->outBuffFlushedSize, toFlush);
DEBUGLOG(5, "toFlush: %u into %u ==> flushed: %u", DEBUGLOG(5, "toFlush: %u into %u ==> flushed: %u",
(U32)toFlush, (U32)(oend-op), (U32)flushed); (unsigned)toFlush, (unsigned)(oend-op), (unsigned)flushed);
op += flushed; op += flushed;
zcs->outBuffFlushedSize += flushed; zcs->outBuffFlushedSize += flushed;
if (toFlush!=flushed) { if (toFlush!=flushed) {
/* flush not fully completed, presumably because dst is too small */ /* flush not fully completed, presumably because dst is too small */
assert(op==oend); assert(op==oend);
someMoreWork = 0; someMoreWork = 0;
break; break;
} }
zcs->outBuffContentSize = zcs->outBuffFlushedSize = 0; zcs->outBuffContentSize = zcs->outBuffFlushedSize = 0;
if (zcs->frameEnded) { if (zcs->frameEnded) {
DEBUGLOG(5, "Frame completed on flush"); DEBUGLOG(5, "Frame completed on flush");
someMoreWork = 0; someMoreWork = 0;
ZSTD_CCtx_reset(zcs); ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
break; break;
} }
zcs->streamStage = zcss_load; zcs->streamStage = zcss_load;
break; break;
} }
default: /* impossible */ default: /* impossible */
assert(0); assert(0);
} }
} }
input->pos = ip - istart; input->pos = ip - istart;
output->pos = op - ostart; output->pos = op - ostart;
if (zcs->frameEnded) return 0; if (zcs->frameEnded) return 0;
{ size_t hintInSize = zcs->inBuffTarget - zcs->inBuffPos; return ZSTD_nextInputSizeHint(zcs);
if (hintInSize==0) hintInSize = zcs->blockSize;
return hintInSize;
} }
static size_t ZSTD_nextInputSizeHint_MTorST(const ZSTD_CCtx* cctx)
{
#ifdef ZSTD_MULTITHREAD
if (cctx->appliedParams.nbWorkers >= 1) {
assert(cctx->mtctx != NULL);
return ZSTDMT_nextInputSizeHint(cctx->mtctx);
}
#endif
return ZSTD_nextInputSizeHint(cctx);
} }
size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input) size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
{ {
/* check conditions */ CHECK_F( ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue) );
if (output->pos > output->size) return ERROR(GENERIC); return ZSTD_nextInputSizeHint_MTorST(zcs);
if (input->pos > input->size) return ERROR(GENERIC);
return ZSTD_compressStream_generic(zcs, output, input, ZSTD_e_continue);
} }
size_t ZSTD_compress_generic (ZSTD_CCtx* cctx, size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
ZSTD_outBuffer* output, ZSTD_outBuffer* output,
ZSTD_inBuffer* input, ZSTD_inBuffer* input,
ZSTD_EndDirective endOp) ZSTD_EndDirective endOp)
{ {
DEBUGLOG(5, "ZSTD_compress_generic, endOp=%u ", (U32)endOp); DEBUGLOG(5, "ZSTD_compressStream2, endOp=%u ", (unsigned)endOp);
/* check conditions */ /* check conditions */
if (output->pos > output->size) return ERROR(GENERIC); if (output->pos > output->size) return ERROR(GENERIC);
if (input->pos > input->size) return ERROR(GENERIC); if (input->pos > input->size) return ERROR(GENERIC);
assert(cctx!=NULL); assert(cctx!=NULL);
/* transparent initialization stage */ /* transparent initialization stage */
if (cctx->streamStage == zcss_init) { if (cctx->streamStage == zcss_init) {
ZSTD_CCtx_params params = cctx->requestedParams; ZSTD_CCtx_params params = cctx->requestedParams;
ZSTD_prefixDict const prefixDict = cctx->prefixDict; ZSTD_prefixDict const prefixDict = cctx->prefixDict;
memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict)); /* single usage */ memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict)); /* single usage */
assert(prefixDict.dict==NULL || cctx->cdict==NULL); /* only one can be set */ assert(prefixDict.dict==NULL || cctx->cdict==NULL); /* only one can be set */
DEBUGLOG(4, "ZSTD_compress_generic : transparent init stage"); DEBUGLOG(4, "ZSTD_compressStream2 : transparent init stage");
if (endOp == ZSTD_e_end) cctx->pledgedSrcSizePlusOne = input->size + 1; /* auto-fix pledgedSrcSize */ if (endOp == ZSTD_e_end) cctx->pledgedSrcSizePlusOne = input->size + 1; /* auto-fix pledgedSrcSize */
params.cParams = ZSTD_getCParamsFromCCtxParams( params.cParams = ZSTD_getCParamsFromCCtxParams(
&cctx->requestedParams, cctx->pledgedSrcSizePlusOne-1, 0 /*dictSize*/); &cctx->requestedParams, cctx->pledgedSrcSizePlusOne-1, 0 /*dictSize*/);
#ifdef ZSTD_MULTITHREAD #ifdef ZSTD_MULTITHREAD
if ((cctx->pledgedSrcSizePlusOne-1) <= ZSTDMT_JOBSIZE_MIN) { if ((cctx->pledgedSrcSizePlusOne-1) <= ZSTDMT_JOBSIZE_MIN) {
params.nbWorkers = 0; /* do not invoke multi-threading when src size is too small */ params.nbWorkers = 0; /* do not invoke multi-threading when src size is too small */
} }
if (params.nbWorkers > 0) { if (params.nbWorkers > 0) {
/* mt context creation */ /* mt context creation */
if (cctx->mtctx == NULL) { if (cctx->mtctx == NULL) {
DEBUGLOG(4, "ZSTD_compress_generic: creating new mtctx for nbWorkers=%u", DEBUGLOG(4, "ZSTD_compressStream2: creating new mtctx for nbWorkers=%u",
params.nbWorkers); params.nbWorkers);
cctx->mtctx = ZSTDMT_createCCtx_advanced(params.nbWorkers, cctx->customMem); cctx->mtctx = ZSTDMT_createCCtx_advanced(params.nbWorkers, cctx->customMem);
if (cctx->mtctx == NULL) return ERROR(memory_allocation); if (cctx->mtctx == NULL) return ERROR(memory_allocation);
} }
/* mt compression */ /* mt compression */
DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbWorkers=%u", params.nbWorkers); DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbWorkers=%u", params.nbWorkers);
CHECK_F( ZSTDMT_initCStream_internal( CHECK_F( ZSTDMT_initCStream_internal(
cctx->mtctx, cctx->mtctx,
prefixDict.dict, prefixDict.dictSize, ZSTD_dct_rawContent, prefixDict.dict, prefixDict.dictSize, ZSTD_dct_rawContent,
cctx->cdict, params, cctx->pledgedSrcSizePlusOne-1) ); cctx->cdict, params, cctx->pledgedSrcSizePlusOne-1) );
cctx->streamStage = zcss_load; cctx->streamStage = zcss_load;
cctx->appliedParams.nbWorkers = params.nbWorkers; cctx->appliedParams.nbWorkers = params.nbWorkers;
} else } else
#endif #endif
{ CHECK_F( ZSTD_resetCStream_internal(cctx, { CHECK_F( ZSTD_resetCStream_internal(cctx,
prefixDict.dict, prefixDict.dictSize, prefixDict.dictContentType, prefixDict.dict, prefixDict.dictSize, prefixDict.dictContentType,
cctx->cdict, cctx->cdict,
params, cctx->pledgedSrcSizePlusOne-1) ); params, cctx->pledgedSrcSizePlusOne-1) );
assert(cctx->streamStage == zcss_load); assert(cctx->streamStage == zcss_load);
assert(cctx->appliedParams.nbWorkers == 0); assert(cctx->appliedParams.nbWorkers == 0);
} } } }
/* end of transparent initialization stage */
/* compression stage */ /* compression stage */
#ifdef ZSTD_MULTITHREAD #ifdef ZSTD_MULTITHREAD
if (cctx->appliedParams.nbWorkers > 0) { if (cctx->appliedParams.nbWorkers > 0) {
if (cctx->cParamsChanged) { if (cctx->cParamsChanged) {
ZSTDMT_updateCParams_whileCompressing(cctx->mtctx, &cctx->requestedParams); ZSTDMT_updateCParams_whileCompressing(cctx->mtctx, &cctx->requestedParams);
cctx->cParamsChanged = 0; cctx->cParamsChanged = 0;
} }
{ size_t const flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp); { size_t const flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp);
if ( ZSTD_isError(flushMin) if ( ZSTD_isError(flushMin)
|| (endOp == ZSTD_e_end && flushMin == 0) ) { /* compression completed */ || (endOp == ZSTD_e_end && flushMin == 0) ) { /* compression completed */
ZSTD_CCtx_reset(cctx); ZSTD_CCtx_reset(cctx, ZSTD_reset_session_only);
} }
DEBUGLOG(5, "completed ZSTD_compress_generic delegating to ZSTDMT_compressStream_generic"); DEBUGLOG(5, "completed ZSTD_compressStream2 delegating to ZSTDMT_compressStream_generic");
return flushMin; return flushMin;
} } } }
#endif #endif
CHECK_F( ZSTD_compressStream_generic(cctx, output, input, endOp) ); CHECK_F( ZSTD_compressStream_generic(cctx, output, input, endOp) );
DEBUGLOG(5, "completed ZSTD_compress_generic"); DEBUGLOG(5, "completed ZSTD_compressStream2");
return cctx->outBuffContentSize - cctx->outBuffFlushedSize; /* remaining to flush */ return cctx->outBuffContentSize - cctx->outBuffFlushedSize; /* remaining to flush */
} }
size_t ZSTD_compress_generic_simpleArgs ( size_t ZSTD_compressStream2_simpleArgs (
ZSTD_CCtx* cctx, ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity, size_t* dstPos, void* dst, size_t dstCapacity, size_t* dstPos,
const void* src, size_t srcSize, size_t* srcPos, const void* src, size_t srcSize, size_t* srcPos,
ZSTD_EndDirective endOp) ZSTD_EndDirective endOp)
{ {
ZSTD_outBuffer output = { dst, dstCapacity, *dstPos }; ZSTD_outBuffer output = { dst, dstCapacity, *dstPos };
ZSTD_inBuffer input = { src, srcSize, *srcPos }; ZSTD_inBuffer input = { src, srcSize, *srcPos };
/* ZSTD_compress_generic() will check validity of dstPos and srcPos */ /* ZSTD_compressStream2() will check validity of dstPos and srcPos */
size_t const cErr = ZSTD_compress_generic(cctx, &output, &input, endOp); size_t const cErr = ZSTD_compressStream2(cctx, &output, &input, endOp);
*dstPos = output.pos; *dstPos = output.pos;
*srcPos = input.pos; *srcPos = input.pos;
return cErr; return cErr;
} }
size_t ZSTD_compress2(ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize)
{
ZSTD_CCtx_reset(cctx, ZSTD_reset_session_only);
{ size_t oPos = 0;
size_t iPos = 0;
size_t const result = ZSTD_compressStream2_simpleArgs(cctx,
dst, dstCapacity, &oPos,
src, srcSize, &iPos,
ZSTD_e_end);
if (ZSTD_isError(result)) return result;
if (result != 0) { /* compression not completed, due to lack of output space */
assert(oPos == dstCapacity);
return ERROR(dstSize_tooSmall);
}
assert(iPos == srcSize); /* all input is expected consumed */
return oPos;
}
}
/*====== Finalize ======*/ /*====== Finalize ======*/
/*! ZSTD_flushStream() : /*! ZSTD_flushStream() :
* @return : amount of data remaining to flush */ * @return : amount of data remaining to flush */
size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output) size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
{ {
ZSTD_inBuffer input = { NULL, 0, 0 }; ZSTD_inBuffer input = { NULL, 0, 0 };
if (output->pos > output->size) return ERROR(GENERIC); return ZSTD_compressStream2(zcs, output, &input, ZSTD_e_flush);
CHECK_F( ZSTD_compressStream_generic(zcs, output, &input, ZSTD_e_flush) );
return zcs->outBuffContentSize - zcs->outBuffFlushedSize; /* remaining to flush */
} }
size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output) size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
{ {
ZSTD_inBuffer input = { NULL, 0, 0 }; ZSTD_inBuffer input = { NULL, 0, 0 };
if (output->pos > output->size) return ERROR(GENERIC); size_t const remainingToFlush = ZSTD_compressStream2(zcs, output, &input, ZSTD_e_end);
CHECK_F( ZSTD_compressStream_generic(zcs, output, &input, ZSTD_e_end) ); CHECK_F( remainingToFlush );
if (zcs->appliedParams.nbWorkers > 0) return remainingToFlush; /* minimal estimation */
/* single thread mode : attempt to calculate remaining to flush more precisely */
{ size_t const lastBlockSize = zcs->frameEnded ? 0 : ZSTD_BLOCKHEADERSIZE; { size_t const lastBlockSize = zcs->frameEnded ? 0 : ZSTD_BLOCKHEADERSIZE;
size_t const checksumSize = zcs->frameEnded ? 0 : zcs->appliedParams.fParams.checksumFlag * 4; size_t const checksumSize = zcs->frameEnded ? 0 : zcs->appliedParams.fParams.checksumFlag * 4;
size_t const toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize + lastBlockSize + checksumSize; size_t const toFlush = remainingToFlush + lastBlockSize + checksumSize;
DEBUGLOG(4, "ZSTD_endStream : remaining to flush : %u", (U32)toFlush); DEBUGLOG(4, "ZSTD_endStream : remaining to flush : %u", (unsigned)toFlush);
return toFlush; return toFlush;
} }
} }
/*-===== Pre-defined compression levels =====-*/ /*-===== Pre-defined compression levels =====-*/
#define ZSTD_MAX_CLEVEL 22 #define ZSTD_MAX_CLEVEL 22
int ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; } int ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; }
int ZSTD_minCLevel(void) { return (int)-ZSTD_TARGETLENGTH_MAX; } int ZSTD_minCLevel(void) { return (int)-ZSTD_TARGETLENGTH_MAX; }
static const ZSTD_compressionParameters ZSTD_defaultCParameters[4][ZSTD_MAX_CLEVEL+1] = { static const ZSTD_compressionParameters ZSTD_defaultCParameters[4][ZSTD_MAX_CLEVEL+1] = {
{ /* "default" - guarantees a monotonically increasing memory budget */ { /* "default" - guarantees a monotonically increasing memory budget */
/* W, C, H, S, L, TL, strat */ /* W, C, H, S, L, TL, strat */
{ 19, 12, 13, 1, 6, 1, ZSTD_fast }, /* base for negative levels */ { 19, 12, 13, 1, 6, 1, ZSTD_fast }, /* base for negative levels */
{ 19, 13, 14, 1, 7, 0, ZSTD_fast }, /* level 1 */ { 19, 13, 14, 1, 7, 0, ZSTD_fast }, /* level 1 */
{ 19, 15, 16, 1, 6, 0, ZSTD_fast }, /* level 2 */ { 20, 15, 16, 1, 6, 0, ZSTD_fast }, /* level 2 */
{ 20, 16, 17, 1, 5, 1, ZSTD_dfast }, /* level 3 */ { 21, 16, 17, 1, 5, 1, ZSTD_dfast }, /* level 3 */
{ 20, 18, 18, 1, 5, 1, ZSTD_dfast }, /* level 4 */ { 21, 18, 18, 1, 5, 1, ZSTD_dfast }, /* level 4 */
{ 20, 18, 18, 2, 5, 2, ZSTD_greedy }, /* level 5 */ { 21, 18, 19, 2, 5, 2, ZSTD_greedy }, /* level 5 */
{ 21, 18, 19, 2, 5, 4, ZSTD_lazy }, /* level 6 */ { 21, 19, 19, 3, 5, 4, ZSTD_greedy }, /* level 6 */
{ 21, 18, 19, 3, 5, 8, ZSTD_lazy2 }, /* level 7 */ { 21, 19, 19, 3, 5, 8, ZSTD_lazy }, /* level 7 */
{ 21, 19, 19, 3, 5, 16, ZSTD_lazy2 }, /* level 8 */ { 21, 19, 19, 3, 5, 16, ZSTD_lazy2 }, /* level 8 */
{ 21, 19, 20, 4, 5, 16, ZSTD_lazy2 }, /* level 9 */ { 21, 19, 20, 4, 5, 16, ZSTD_lazy2 }, /* level 9 */
{ 21, 20, 21, 4, 5, 16, ZSTD_lazy2 }, /* level 10 */ { 22, 20, 21, 4, 5, 16, ZSTD_lazy2 }, /* level 10 */
{ 21, 21, 22, 4, 5, 16, ZSTD_lazy2 }, /* level 11 */ { 22, 21, 22, 4, 5, 16, ZSTD_lazy2 }, /* level 11 */
{ 22, 20, 22, 5, 5, 16, ZSTD_lazy2 }, /* level 12 */ { 22, 21, 22, 5, 5, 16, ZSTD_lazy2 }, /* level 12 */
{ 22, 21, 22, 4, 5, 32, ZSTD_btlazy2 }, /* level 13 */ { 22, 21, 22, 5, 5, 32, ZSTD_btlazy2 }, /* level 13 */
{ 22, 21, 22, 5, 5, 32, ZSTD_btlazy2 }, /* level 14 */ { 22, 22, 23, 5, 5, 32, ZSTD_btlazy2 }, /* level 14 */
{ 22, 22, 22, 6, 5, 32, ZSTD_btlazy2 }, /* level 15 */ { 22, 23, 23, 6, 5, 32, ZSTD_btlazy2 }, /* level 15 */
{ 22, 21, 22, 4, 5, 48, ZSTD_btopt }, /* level 16 */ { 22, 22, 22, 5, 5, 48, ZSTD_btopt }, /* level 16 */
{ 23, 22, 22, 4, 4, 64, ZSTD_btopt }, /* level 17 */ { 23, 23, 22, 5, 4, 64, ZSTD_btopt }, /* level 17 */
{ 23, 23, 22, 6, 3,256, ZSTD_btopt }, /* level 18 */ { 23, 23, 22, 6, 3, 64, ZSTD_btultra }, /* level 18 */
{ 23, 24, 22, 7, 3,256, ZSTD_btultra }, /* level 19 */ { 23, 24, 22, 7, 3,256, ZSTD_btultra2}, /* level 19 */
{ 25, 25, 23, 7, 3,256, ZSTD_btultra }, /* level 20 */ { 25, 25, 23, 7, 3,256, ZSTD_btultra2}, /* level 20 */
{ 26, 26, 24, 7, 3,512, ZSTD_btultra }, /* level 21 */ { 26, 26, 24, 7, 3,512, ZSTD_btultra2}, /* level 21 */
{ 27, 27, 25, 9, 3,999, ZSTD_btultra }, /* level 22 */ { 27, 27, 25, 9, 3,999, ZSTD_btultra2}, /* level 22 */
}, },
{ /* for srcSize <= 256 KB */ { /* for srcSize <= 256 KB */
/* W, C, H, S, L, T, strat */ /* W, C, H, S, L, T, strat */
{ 18, 12, 13, 1, 5, 1, ZSTD_fast }, /* base for negative levels */ { 18, 12, 13, 1, 5, 1, ZSTD_fast }, /* base for negative levels */
{ 18, 13, 14, 1, 6, 0, ZSTD_fast }, /* level 1 */ { 18, 13, 14, 1, 6, 0, ZSTD_fast }, /* level 1 */
{ 18, 14, 14, 1, 5, 1, ZSTD_dfast }, /* level 2 */ { 18, 14, 14, 1, 5, 1, ZSTD_dfast }, /* level 2 */
{ 18, 16, 16, 1, 4, 1, ZSTD_dfast }, /* level 3 */ { 18, 16, 16, 1, 4, 1, ZSTD_dfast }, /* level 3 */
{ 18, 16, 17, 2, 5, 2, ZSTD_greedy }, /* level 4.*/ { 18, 16, 17, 2, 5, 2, ZSTD_greedy }, /* level 4.*/
{ 18, 18, 18, 3, 5, 2, ZSTD_greedy }, /* level 5.*/ { 18, 18, 18, 3, 5, 2, ZSTD_greedy }, /* level 5.*/
{ 18, 18, 19, 3, 5, 4, ZSTD_lazy }, /* level 6.*/ { 18, 18, 19, 3, 5, 4, ZSTD_lazy }, /* level 6.*/
{ 18, 18, 19, 4, 4, 4, ZSTD_lazy }, /* level 7 */ { 18, 18, 19, 4, 4, 4, ZSTD_lazy }, /* level 7 */
{ 18, 18, 19, 4, 4, 8, ZSTD_lazy2 }, /* level 8 */ { 18, 18, 19, 4, 4, 8, ZSTD_lazy2 }, /* level 8 */
{ 18, 18, 19, 5, 4, 8, ZSTD_lazy2 }, /* level 9 */ { 18, 18, 19, 5, 4, 8, ZSTD_lazy2 }, /* level 9 */
{ 18, 18, 19, 6, 4, 8, ZSTD_lazy2 }, /* level 10 */ { 18, 18, 19, 6, 4, 8, ZSTD_lazy2 }, /* level 10 */
{ 18, 18, 19, 5, 4, 16, ZSTD_btlazy2 }, /* level 11.*/ { 18, 18, 19, 5, 4, 12, ZSTD_btlazy2 }, /* level 11.*/
{ 18, 19, 19, 6, 4, 16, ZSTD_btlazy2 }, /* level 12.*/ { 18, 19, 19, 7, 4, 12, ZSTD_btlazy2 }, /* level 12.*/
{ 18, 19, 19, 8, 4, 16, ZSTD_btlazy2 }, /* level 13 */ { 18, 18, 19, 4, 4, 16, ZSTD_btopt }, /* level 13 */
{ 18, 18, 19, 4, 4, 24, ZSTD_btopt }, /* level 14.*/ { 18, 18, 19, 4, 3, 32, ZSTD_btopt }, /* level 14.*/
{ 18, 18, 19, 4, 3, 24, ZSTD_btopt }, /* level 15.*/ { 18, 18, 19, 6, 3,128, ZSTD_btopt }, /* level 15.*/
{ 18, 19, 19, 6, 3, 64, ZSTD_btopt }, /* level 16.*/ { 18, 19, 19, 6, 3,128, ZSTD_btultra }, /* level 16.*/
{ 18, 19, 19, 8, 3,128, ZSTD_btopt }, /* level 17.*/ { 18, 19, 19, 8, 3,256, ZSTD_btultra }, /* level 17.*/
{ 18, 19, 19, 10, 3,256, ZSTD_btopt }, /* level 18.*/ { 18, 19, 19, 6, 3,128, ZSTD_btultra2}, /* level 18.*/
{ 18, 19, 19, 10, 3,256, ZSTD_btultra }, /* level 19.*/ { 18, 19, 19, 8, 3,256, ZSTD_btultra2}, /* level 19.*/
{ 18, 19, 19, 11, 3,512, ZSTD_btultra }, /* level 20.*/ { 18, 19, 19, 10, 3,512, ZSTD_btultra2}, /* level 20.*/
{ 18, 19, 19, 12, 3,512, ZSTD_btultra }, /* level 21.*/ { 18, 19, 19, 12, 3,512, ZSTD_btultra2}, /* level 21.*/
{ 18, 19, 19, 13, 3,999, ZSTD_btultra }, /* level 22.*/ { 18, 19, 19, 13, 3,999, ZSTD_btultra2}, /* level 22.*/
}, },
{ /* for srcSize <= 128 KB */ { /* for srcSize <= 128 KB */
/* W, C, H, S, L, T, strat */ /* W, C, H, S, L, T, strat */
{ 17, 12, 12, 1, 5, 1, ZSTD_fast }, /* base for negative levels */ { 17, 12, 12, 1, 5, 1, ZSTD_fast }, /* base for negative levels */
{ 17, 12, 13, 1, 6, 0, ZSTD_fast }, /* level 1 */ { 17, 12, 13, 1, 6, 0, ZSTD_fast }, /* level 1 */
{ 17, 13, 15, 1, 5, 0, ZSTD_fast }, /* level 2 */ { 17, 13, 15, 1, 5, 0, ZSTD_fast }, /* level 2 */
{ 17, 15, 16, 2, 5, 1, ZSTD_dfast }, /* level 3 */ { 17, 15, 16, 2, 5, 1, ZSTD_dfast }, /* level 3 */
{ 17, 17, 17, 2, 4, 1, ZSTD_dfast }, /* level 4 */ { 17, 17, 17, 2, 4, 1, ZSTD_dfast }, /* level 4 */
{ 17, 16, 17, 3, 4, 2, ZSTD_greedy }, /* level 5 */ { 17, 16, 17, 3, 4, 2, ZSTD_greedy }, /* level 5 */
{ 17, 17, 17, 3, 4, 4, ZSTD_lazy }, /* level 6 */ { 17, 17, 17, 3, 4, 4, ZSTD_lazy }, /* level 6 */
{ 17, 17, 17, 3, 4, 8, ZSTD_lazy2 }, /* level 7 */ { 17, 17, 17, 3, 4, 8, ZSTD_lazy2 }, /* level 7 */
{ 17, 17, 17, 4, 4, 8, ZSTD_lazy2 }, /* level 8 */ { 17, 17, 17, 4, 4, 8, ZSTD_lazy2 }, /* level 8 */
{ 17, 17, 17, 5, 4, 8, ZSTD_lazy2 }, /* level 9 */ { 17, 17, 17, 5, 4, 8, ZSTD_lazy2 }, /* level 9 */
{ 17, 17, 17, 6, 4, 8, ZSTD_lazy2 }, /* level 10 */ { 17, 17, 17, 6, 4, 8, ZSTD_lazy2 }, /* level 10 */
{ 17, 17, 17, 7, 4, 8, ZSTD_lazy2 }, /* level 11 */ { 17, 17, 17, 5, 4, 8, ZSTD_btlazy2 }, /* level 11 */
{ 17, 18, 17, 6, 4, 16, ZSTD_btlazy2 }, /* level 12 */ { 17, 18, 17, 7, 4, 12, ZSTD_btlazy2 }, /* level 12 */
{ 17, 18, 17, 8, 4, 16, ZSTD_btlazy2 }, /* level 13.*/ { 17, 18, 17, 3, 4, 12, ZSTD_btopt }, /* level 13.*/
{ 17, 18, 17, 4, 4, 32, ZSTD_btopt }, /* level 14.*/ { 17, 18, 17, 4, 3, 32, ZSTD_btopt }, /* level 14.*/
{ 17, 18, 17, 6, 3, 64, ZSTD_btopt }, /* level 15.*/ { 17, 18, 17, 6, 3,256, ZSTD_btopt }, /* level 15.*/
{ 17, 18, 17, 7, 3,128, ZSTD_btopt }, /* level 16.*/ { 17, 18, 17, 6, 3,128, ZSTD_btultra }, /* level 16.*/
{ 17, 18, 17, 7, 3,256, ZSTD_btopt }, /* level 17.*/ { 17, 18, 17, 8, 3,256, ZSTD_btultra }, /* level 17.*/
{ 17, 18, 17, 8, 3,256, ZSTD_btopt }, /* level 18.*/ { 17, 18, 17, 10, 3,512, ZSTD_btultra }, /* level 18.*/
{ 17, 18, 17, 8, 3,256, ZSTD_btultra }, /* level 19.*/ { 17, 18, 17, 5, 3,256, ZSTD_btultra2}, /* level 19.*/
{ 17, 18, 17, 9, 3,256, ZSTD_btultra }, /* level 20.*/ { 17, 18, 17, 7, 3,512, ZSTD_btultra2}, /* level 20.*/
{ 17, 18, 17, 10, 3,256, ZSTD_btultra }, /* level 21.*/ { 17, 18, 17, 9, 3,512, ZSTD_btultra2}, /* level 21.*/
{ 17, 18, 17, 11, 3,512, ZSTD_btultra }, /* level 22.*/ { 17, 18, 17, 11, 3,999, ZSTD_btultra2}, /* level 22.*/
}, },
{ /* for srcSize <= 16 KB */ { /* for srcSize <= 16 KB */
/* W, C, H, S, L, T, strat */ /* W, C, H, S, L, T, strat */
{ 14, 12, 13, 1, 5, 1, ZSTD_fast }, /* base for negative levels */ { 14, 12, 13, 1, 5, 1, ZSTD_fast }, /* base for negative levels */
{ 14, 14, 15, 1, 5, 0, ZSTD_fast }, /* level 1 */ { 14, 14, 15, 1, 5, 0, ZSTD_fast }, /* level 1 */
{ 14, 14, 15, 1, 4, 0, ZSTD_fast }, /* level 2 */ { 14, 14, 15, 1, 4, 0, ZSTD_fast }, /* level 2 */
{ 14, 14, 14, 2, 4, 1, ZSTD_dfast }, /* level 3.*/ { 14, 14, 15, 2, 4, 1, ZSTD_dfast }, /* level 3 */
{ 14, 14, 14, 4, 4, 2, ZSTD_greedy }, /* level 4.*/ { 14, 14, 14, 4, 4, 2, ZSTD_greedy }, /* level 4 */
{ 14, 14, 14, 3, 4, 4, ZSTD_lazy }, /* level 5.*/ { 14, 14, 14, 3, 4, 4, ZSTD_lazy }, /* level 5.*/
{ 14, 14, 14, 4, 4, 8, ZSTD_lazy2 }, /* level 6 */ { 14, 14, 14, 4, 4, 8, ZSTD_lazy2 }, /* level 6 */
{ 14, 14, 14, 6, 4, 8, ZSTD_lazy2 }, /* level 7 */ { 14, 14, 14, 6, 4, 8, ZSTD_lazy2 }, /* level 7 */
{ 14, 14, 14, 8, 4, 8, ZSTD_lazy2 }, /* level 8.*/ { 14, 14, 14, 8, 4, 8, ZSTD_lazy2 }, /* level 8.*/
{ 14, 15, 14, 5, 4, 8, ZSTD_btlazy2 }, /* level 9.*/ { 14, 15, 14, 5, 4, 8, ZSTD_btlazy2 }, /* level 9.*/
{ 14, 15, 14, 9, 4, 8, ZSTD_btlazy2 }, /* level 10.*/ { 14, 15, 14, 9, 4, 8, ZSTD_btlazy2 }, /* level 10.*/
{ 14, 15, 14, 3, 4, 12, ZSTD_btopt }, /* level 11.*/ { 14, 15, 14, 3, 4, 12, ZSTD_btopt }, /* level 11.*/
{ 14, 15, 14, 6, 3, 16, ZSTD_btopt }, /* level 12.*/ { 14, 15, 14, 4, 3, 24, ZSTD_btopt }, /* level 12.*/
{ 14, 15, 14, 6, 3, 24, ZSTD_btopt }, /* level 13.*/ { 14, 15, 14, 5, 3, 32, ZSTD_btultra }, /* level 13.*/
{ 14, 15, 15, 6, 3, 48, ZSTD_btopt }, /* level 14.*/ { 14, 15, 15, 6, 3, 64, ZSTD_btultra }, /* level 14.*/
{ 14, 15, 15, 6, 3, 64, ZSTD_btopt }, /* level 15.*/ { 14, 15, 15, 7, 3,256, ZSTD_btultra }, /* level 15.*/
{ 14, 15, 15, 6, 3, 96, ZSTD_btopt }, /* level 16.*/ { 14, 15, 15, 5, 3, 48, ZSTD_btultra2}, /* level 16.*/
{ 14, 15, 15, 6, 3,128, ZSTD_btopt }, /* level 17.*/ { 14, 15, 15, 6, 3,128, ZSTD_btultra2}, /* level 17.*/
{ 14, 15, 15, 8, 3,256, ZSTD_btopt }, /* level 18.*/ { 14, 15, 15, 7, 3,256, ZSTD_btultra2}, /* level 18.*/
{ 14, 15, 15, 6, 3,256, ZSTD_btultra }, /* level 19.*/ { 14, 15, 15, 8, 3,256, ZSTD_btultra2}, /* level 19.*/
{ 14, 15, 15, 8, 3,256, ZSTD_btultra }, /* level 20.*/ { 14, 15, 15, 8, 3,512, ZSTD_btultra2}, /* level 20.*/
{ 14, 15, 15, 9, 3,256, ZSTD_btultra }, /* level 21.*/ { 14, 15, 15, 9, 3,512, ZSTD_btultra2}, /* level 21.*/
{ 14, 15, 15, 10, 3,512, ZSTD_btultra }, /* level 22.*/ { 14, 15, 15, 10, 3,999, ZSTD_btultra2}, /* level 22.*/
}, },
}; };
/*! ZSTD_getCParams() : /*! ZSTD_getCParams() :
* @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize. * @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize.
* Size values are optional, provide 0 if not known or unused */ * Size values are optional, provide 0 if not known or unused */
ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize) ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize)
{ {
size_t const addedSize = srcSizeHint ? 0 : 500; size_t const addedSize = srcSizeHint ? 0 : 500;
U64 const rSize = srcSizeHint+dictSize ? srcSizeHint+dictSize+addedSize : (U64)-1; U64 const rSize = srcSizeHint+dictSize ? srcSizeHint+dictSize+addedSize : (U64)-1;
U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB); /* intentional underflow for srcSizeHint == 0 */ U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB); /* intentional underflow for srcSizeHint == 0 */
int row = compressionLevel; int row = compressionLevel;
DEBUGLOG(5, "ZSTD_getCParams (cLevel=%i)", compressionLevel); DEBUGLOG(5, "ZSTD_getCParams (cLevel=%i)", compressionLevel);
if (compressionLevel == 0) row = ZSTD_CLEVEL_DEFAULT; /* 0 == default */ if (compressionLevel == 0) row = ZSTD_CLEVEL_DEFAULT; /* 0 == default */
if (compressionLevel < 0) row = 0; /* entry 0 is baseline for fast mode */ if (compressionLevel < 0) row = 0; /* entry 0 is baseline for fast mode */
if (compressionLevel > ZSTD_MAX_CLEVEL) row = ZSTD_MAX_CLEVEL; if (compressionLevel > ZSTD_MAX_CLEVEL) row = ZSTD_MAX_CLEVEL;
{ ZSTD_compressionParameters cp = ZSTD_defaultCParameters[tableID][row]; { ZSTD_compressionParameters cp = ZSTD_defaultCParameters[tableID][row];
if (compressionLevel < 0) cp.targetLength = (unsigned)(-compressionLevel); /* acceleration factor */ if (compressionLevel < 0) cp.targetLength = (unsigned)(-compressionLevel); /* acceleration factor */
return ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize); } return ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize);
}
} }
/*! ZSTD_getParams() : /*! ZSTD_getParams() :
* same as ZSTD_getCParams(), but @return a `ZSTD_parameters` object (instead of `ZSTD_compressionParameters`). * same as ZSTD_getCParams(), but @return a `ZSTD_parameters` object (instead of `ZSTD_compressionParameters`).
* All fields of `ZSTD_frameParameters` are set to default (0) */ * All fields of `ZSTD_frameParameters` are set to default (0) */
ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize) { ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize) {
ZSTD_parameters params; ZSTD_parameters params;
ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, srcSizeHint, dictSize); ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, srcSizeHint, dictSize);
DEBUGLOG(5, "ZSTD_getParams (cLevel=%i)", compressionLevel); DEBUGLOG(5, "ZSTD_getParams (cLevel=%i)", compressionLevel);
memset(&params, 0, sizeof(params)); memset(&params, 0, sizeof(params));
params.cParams = cParams; params.cParams = cParams;
params.fParams.contentSizeFlag = 1; params.fParams.contentSizeFlag = 1;
return params; return params;
} }

contrib/python-zstandard/zstd/compress/zstd_compress_internal.h

/*-************************************* /*-*************************************
* Context memory management * Context memory management
***************************************/ ***************************************/
typedef enum { ZSTDcs_created=0, ZSTDcs_init, ZSTDcs_ongoing, ZSTDcs_ending } ZSTD_compressionStage_e; typedef enum { ZSTDcs_created=0, ZSTDcs_init, ZSTDcs_ongoing, ZSTDcs_ending } ZSTD_compressionStage_e;
typedef enum { zcss_init=0, zcss_load, zcss_flush } ZSTD_cStreamStage; typedef enum { zcss_init=0, zcss_load, zcss_flush } ZSTD_cStreamStage;
typedef enum {
ZSTD_dictDefaultAttach = 0,
ZSTD_dictForceAttach = 1,
ZSTD_dictForceCopy = -1,
} ZSTD_dictAttachPref_e;
typedef struct ZSTD_prefixDict_s { typedef struct ZSTD_prefixDict_s {
const void* dict; const void* dict;
size_t dictSize; size_t dictSize;
ZSTD_dictContentType_e dictContentType; ZSTD_dictContentType_e dictContentType;
} ZSTD_prefixDict; } ZSTD_prefixDict;
typedef struct { typedef struct {
U32 CTable[HUF_CTABLE_SIZE_U32(255)]; U32 CTable[HUF_CTABLE_SIZE_U32(255)];
U32 litlen; U32 litlen;
U32 rep[ZSTD_REP_NUM]; U32 rep[ZSTD_REP_NUM];
} ZSTD_optimal_t; } ZSTD_optimal_t;
typedef enum { zop_dynamic=0, zop_predef } ZSTD_OptPrice_e; typedef enum { zop_dynamic=0, zop_predef } ZSTD_OptPrice_e;
typedef struct { typedef struct {
/* All tables are allocated inside cctx->workspace by ZSTD_resetCCtx_internal() */ /* All tables are allocated inside cctx->workspace by ZSTD_resetCCtx_internal() */
U32* litFreq; /* table of literals statistics, of size 256 */ unsigned* litFreq; /* table of literals statistics, of size 256 */
U32* litLengthFreq; /* table of litLength statistics, of size (MaxLL+1) */ unsigned* litLengthFreq; /* table of litLength statistics, of size (MaxLL+1) */
U32* matchLengthFreq; /* table of matchLength statistics, of size (MaxML+1) */ unsigned* matchLengthFreq; /* table of matchLength statistics, of size (MaxML+1) */
U32* offCodeFreq; /* table of offCode statistics, of size (MaxOff+1) */ unsigned* offCodeFreq; /* table of offCode statistics, of size (MaxOff+1) */
ZSTD_match_t* matchTable; /* list of found matches, of size ZSTD_OPT_NUM+1 */ ZSTD_match_t* matchTable; /* list of found matches, of size ZSTD_OPT_NUM+1 */
ZSTD_optimal_t* priceTable; /* All positions tracked by optimal parser, of size ZSTD_OPT_NUM+1 */ ZSTD_optimal_t* priceTable; /* All positions tracked by optimal parser, of size ZSTD_OPT_NUM+1 */
U32 litSum; /* nb of literals */ U32 litSum; /* nb of literals */
U32 litLengthSum; /* nb of litLength codes */ U32 litLengthSum; /* nb of litLength codes */
U32 matchLengthSum; /* nb of matchLength codes */ U32 matchLengthSum; /* nb of matchLength codes */
U32 offCodeSum; /* nb of offset codes */ U32 offCodeSum; /* nb of offset codes */
U32 litSumBasePrice; /* to compare to log2(litfreq) */ U32 litSumBasePrice; /* to compare to log2(litfreq) */
U32 loadedDictEnd; /* index of end of dictionary */ U32 loadedDictEnd; /* index of end of dictionary */
U32 nextToUpdate; /* index from which to continue table update */ U32 nextToUpdate; /* index from which to continue table update */
U32 nextToUpdate3; /* index from which to continue table update */ U32 nextToUpdate3; /* index from which to continue table update */
U32 hashLog3; /* dispatch table : larger == faster, more memory */ U32 hashLog3; /* dispatch table : larger == faster, more memory */
U32* hashTable; U32* hashTable;
U32* hashTable3; U32* hashTable3;
U32* chainTable; U32* chainTable;
optState_t opt; /* optimal parser state */ optState_t opt; /* optimal parser state */
const ZSTD_matchState_t *dictMatchState; const ZSTD_matchState_t * dictMatchState;
ZSTD_compressionParameters cParams; ZSTD_compressionParameters cParams;
}; };
typedef struct { typedef struct {
ZSTD_compressedBlockState_t* prevCBlock; ZSTD_compressedBlockState_t* prevCBlock;
ZSTD_compressedBlockState_t* nextCBlock; ZSTD_compressedBlockState_t* nextCBlock;
ZSTD_matchState_t matchState; ZSTD_matchState_t matchState;
} ZSTD_blockState_t; } ZSTD_blockState_t;
* Depends on ldmParams.minMatchLength */ * Depends on ldmParams.minMatchLength */
} ldmState_t; } ldmState_t;
typedef struct { typedef struct {
U32 enableLdm; /* 1 if enable long distance matching */ U32 enableLdm; /* 1 if enable long distance matching */
U32 hashLog; /* Log size of hashTable */ U32 hashLog; /* Log size of hashTable */
U32 bucketSizeLog; /* Log bucket size for collision resolution, at most 8 */ U32 bucketSizeLog; /* Log bucket size for collision resolution, at most 8 */
U32 minMatchLength; /* Minimum match length */ U32 minMatchLength; /* Minimum match length */
U32 hashEveryLog; /* Log number of entries to skip */ U32 hashRateLog; /* Log number of entries to skip */
U32 windowLog; /* Window log for the LDM */ U32 windowLog; /* Window log for the LDM */
} ldmParams_t; } ldmParams_t;
typedef struct { typedef struct {
U32 offset; U32 offset;
U32 litLength; U32 litLength;
U32 matchLength; U32 matchLength;
} rawSeq; } rawSeq;
int compressionLevel; int compressionLevel;
int forceWindow; /* force back-references to respect limit of int forceWindow; /* force back-references to respect limit of
* 1<<wLog, even for dictionary */ * 1<<wLog, even for dictionary */
ZSTD_dictAttachPref_e attachDictPref; ZSTD_dictAttachPref_e attachDictPref;
/* Multithreading: used to pass parameters to mtctx */ /* Multithreading: used to pass parameters to mtctx */
unsigned nbWorkers; int nbWorkers;
unsigned jobSize; size_t jobSize;
unsigned overlapSizeLog; int overlapLog;
int rsyncable;
/* Long distance matching parameters */ /* Long distance matching parameters */
ldmParams_t ldmParams; ldmParams_t ldmParams;
/* Internal use, for createCCtxParams() and freeCCtxParams() only */ /* Internal use, for createCCtxParams() and freeCCtxParams() only */
ZSTD_customMem customMem; ZSTD_customMem customMem;
}; /* typedef'd to ZSTD_CCtx_params within "zstd.h" */ }; /* typedef'd to ZSTD_CCtx_params within "zstd.h" */
case 4: return ZSTD_hash4Ptr(p, hBits); case 4: return ZSTD_hash4Ptr(p, hBits);
case 5: return ZSTD_hash5Ptr(p, hBits); case 5: return ZSTD_hash5Ptr(p, hBits);
case 6: return ZSTD_hash6Ptr(p, hBits); case 6: return ZSTD_hash6Ptr(p, hBits);
case 7: return ZSTD_hash7Ptr(p, hBits); case 7: return ZSTD_hash7Ptr(p, hBits);
case 8: return ZSTD_hash8Ptr(p, hBits); case 8: return ZSTD_hash8Ptr(p, hBits);
} }
} }
/** ZSTD_ipow() :
* Return base^exponent.
*/
static U64 ZSTD_ipow(U64 base, U64 exponent)
{
U64 power = 1;
while (exponent) {
if (exponent & 1) power *= base;
exponent >>= 1;
base *= base;
}
return power;
}
#define ZSTD_ROLL_HASH_CHAR_OFFSET 10
/** ZSTD_rollingHash_append() :
* Add the buffer to the hash value.
*/
static U64 ZSTD_rollingHash_append(U64 hash, void const* buf, size_t size)
{
BYTE const* istart = (BYTE const*)buf;
size_t pos;
for (pos = 0; pos < size; ++pos) {
hash *= prime8bytes;
hash += istart[pos] + ZSTD_ROLL_HASH_CHAR_OFFSET;
}
return hash;
}
/** ZSTD_rollingHash_compute() :
* Compute the rolling hash value of the buffer.
*/
MEM_STATIC U64 ZSTD_rollingHash_compute(void const* buf, size_t size)
{
return ZSTD_rollingHash_append(0, buf, size);
}
/** ZSTD_rollingHash_primePower() :
* Compute the primePower to be passed to ZSTD_rollingHash_rotate() for a hash
* over a window of length bytes.
*/
MEM_STATIC U64 ZSTD_rollingHash_primePower(U32 length)
{
return ZSTD_ipow(prime8bytes, length - 1);
}
/** ZSTD_rollingHash_rotate() :
* Rotate the rolling hash by one byte.
*/
MEM_STATIC U64 ZSTD_rollingHash_rotate(U64 hash, BYTE toRemove, BYTE toAdd, U64 primePower)
{
hash -= (toRemove + ZSTD_ROLL_HASH_CHAR_OFFSET) * primePower;
hash *= prime8bytes;
hash += toAdd + ZSTD_ROLL_HASH_CHAR_OFFSET;
return hash;
}
/*-************************************* /*-*************************************
* Round buffer management * Round buffer management
***************************************/ ***************************************/
/* Max current allowed */ /* Max current allowed */
#define ZSTD_CURRENT_MAX ((3U << 29) + (1U << ZSTD_WINDOWLOG_MAX)) #define ZSTD_CURRENT_MAX ((3U << 29) + (1U << ZSTD_WINDOWLOG_MAX))
/* Maximum chunk size before overflow correction needs to be called again */ /* Maximum chunk size before overflow correction needs to be called again */
#define ZSTD_CHUNKSIZE_MAX \ #define ZSTD_CHUNKSIZE_MAX \
( ((U32)-1) /* Maximum ending current index */ \ ( ((U32)-1) /* Maximum ending current index */ \
* byte of the dictionary is in the window, but once they are out of range, * byte of the dictionary is in the window, but once they are out of range,
* they cannot be referenced. If loadedDictEndPtr is NULL, we use * they cannot be referenced. If loadedDictEndPtr is NULL, we use
* loadedDictEnd == 0. * loadedDictEnd == 0.
* *
* In normal dict mode, the dict is between lowLimit and dictLimit. In * In normal dict mode, the dict is between lowLimit and dictLimit. In
* dictMatchState mode, lowLimit and dictLimit are the same, and the dictionary * dictMatchState mode, lowLimit and dictLimit are the same, and the dictionary
* is below them. forceWindow and dictMatchState are therefore incompatible. * is below them. forceWindow and dictMatchState are therefore incompatible.
*/ */
MEM_STATIC void ZSTD_window_enforceMaxDist(ZSTD_window_t* window, MEM_STATIC void
void const* srcEnd, U32 maxDist, ZSTD_window_enforceMaxDist(ZSTD_window_t* window,
void const* srcEnd,
U32 maxDist,
U32* loadedDictEndPtr, U32* loadedDictEndPtr,
const ZSTD_matchState_t** dictMatchStatePtr) const ZSTD_matchState_t** dictMatchStatePtr)
{ {
U32 const current = (U32)((BYTE const*)srcEnd - window->base); U32 const blockEndIdx = (U32)((BYTE const*)srcEnd - window->base);
U32 loadedDictEnd = loadedDictEndPtr != NULL ? *loadedDictEndPtr : 0; U32 loadedDictEnd = (loadedDictEndPtr != NULL) ? *loadedDictEndPtr : 0;
DEBUGLOG(5, "ZSTD_window_enforceMaxDist: current=%u, maxDist=%u", current, maxDist); DEBUGLOG(5, "ZSTD_window_enforceMaxDist: blockEndIdx=%u, maxDist=%u",
if (current > maxDist + loadedDictEnd) { (unsigned)blockEndIdx, (unsigned)maxDist);
U32 const newLowLimit = current - maxDist; if (blockEndIdx > maxDist + loadedDictEnd) {
U32 const newLowLimit = blockEndIdx - maxDist;
if (window->lowLimit < newLowLimit) window->lowLimit = newLowLimit; if (window->lowLimit < newLowLimit) window->lowLimit = newLowLimit;
if (window->dictLimit < window->lowLimit) { if (window->dictLimit < window->lowLimit) {
DEBUGLOG(5, "Update dictLimit to match lowLimit, from %u to %u", DEBUGLOG(5, "Update dictLimit to match lowLimit, from %u to %u",
window->dictLimit, window->lowLimit); (unsigned)window->dictLimit, (unsigned)window->lowLimit);
window->dictLimit = window->lowLimit; window->dictLimit = window->lowLimit;
} }
if (loadedDictEndPtr) if (loadedDictEndPtr)
*loadedDictEndPtr = 0; *loadedDictEndPtr = 0;
if (dictMatchStatePtr) if (dictMatchStatePtr)
*dictMatchStatePtr = NULL; *dictMatchStatePtr = NULL;
} }
} }
window->lowLimit = lowLimitMax; window->lowLimit = lowLimitMax;
DEBUGLOG(5, "Overlapping extDict and input : new lowLimit = %u", window->lowLimit); DEBUGLOG(5, "Overlapping extDict and input : new lowLimit = %u", window->lowLimit);
} }
return contiguous; return contiguous;
} }
/* debug functions */ /* debug functions */
#if (DEBUGLEVEL>=2)
MEM_STATIC double ZSTD_fWeight(U32 rawStat) MEM_STATIC double ZSTD_fWeight(U32 rawStat)
{ {
U32 const fp_accuracy = 8; U32 const fp_accuracy = 8;
U32 const fp_multiplier = (1 << fp_accuracy); U32 const fp_multiplier = (1 << fp_accuracy);
U32 const stat = rawStat + 1; U32 const newStat = rawStat + 1;
U32 const hb = ZSTD_highbit32(stat); U32 const hb = ZSTD_highbit32(newStat);
U32 const BWeight = hb * fp_multiplier; U32 const BWeight = hb * fp_multiplier;
U32 const FWeight = (stat << fp_accuracy) >> hb; U32 const FWeight = (newStat << fp_accuracy) >> hb;
U32 const weight = BWeight + FWeight; U32 const weight = BWeight + FWeight;
assert(hb + fp_accuracy < 31); assert(hb + fp_accuracy < 31);
return (double)weight / fp_multiplier; return (double)weight / fp_multiplier;
} }
/* display a table content,
* listing each element, its frequency, and its predicted bit cost */
MEM_STATIC void ZSTD_debugTable(const U32* table, U32 max) MEM_STATIC void ZSTD_debugTable(const U32* table, U32 max)
{ {
unsigned u, sum; unsigned u, sum;
for (u=0, sum=0; u<=max; u++) sum += table[u]; for (u=0, sum=0; u<=max; u++) sum += table[u];
DEBUGLOG(2, "total nb elts: %u", sum); DEBUGLOG(2, "total nb elts: %u", sum);
for (u=0; u<=max; u++) { for (u=0; u<=max; u++) {
DEBUGLOG(2, "%2u: %5u (%.2f)", DEBUGLOG(2, "%2u: %5u (%.2f)",
u, table[u], ZSTD_fWeight(sum) - ZSTD_fWeight(table[u]) ); u, table[u], ZSTD_fWeight(sum) - ZSTD_fWeight(table[u]) );
} }
} }
#endif
#if defined (__cplusplus) #if defined (__cplusplus)
} }
#endif #endif
/* ============================================================== /* ==============================================================
* Private declarations * Private declarations
* These prototypes shall only be called from within lib/compress * These prototypes shall only be called from within lib/compress

contrib/python-zstandard/zstd/compress/zstd_double_fast.c

void ZSTD_fillDoubleHashTable(ZSTD_matchState_t* ms, void ZSTD_fillDoubleHashTable(ZSTD_matchState_t* ms,
void const* end, ZSTD_dictTableLoadMethod_e dtlm) void const* end, ZSTD_dictTableLoadMethod_e dtlm)
{ {
const ZSTD_compressionParameters* const cParams = &ms->cParams; const ZSTD_compressionParameters* const cParams = &ms->cParams;
U32* const hashLarge = ms->hashTable; U32* const hashLarge = ms->hashTable;
U32 const hBitsL = cParams->hashLog; U32 const hBitsL = cParams->hashLog;
U32 const mls = cParams->searchLength; U32 const mls = cParams->minMatch;
U32* const hashSmall = ms->chainTable; U32* const hashSmall = ms->chainTable;
U32 const hBitsS = cParams->chainLog; U32 const hBitsS = cParams->chainLog;
const BYTE* const base = ms->window.base; const BYTE* const base = ms->window.base;
const BYTE* ip = base + ms->nextToUpdate; const BYTE* ip = base + ms->nextToUpdate;
const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE; const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE;
const U32 fastHashFillStep = 3; const U32 fastHashFillStep = 3;
/* Always insert every fastHashFillStep position into the hash tables. /* Always insert every fastHashFillStep position into the hash tables.
return iend - anchor; return iend - anchor;
} }
size_t ZSTD_compressBlock_doubleFast( size_t ZSTD_compressBlock_doubleFast(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize) void const* src, size_t srcSize)
{ {
const U32 mls = ms->cParams.searchLength; const U32 mls = ms->cParams.minMatch;
switch(mls) switch(mls)
{ {
default: /* includes case 3 */ default: /* includes case 3 */
case 4 : case 4 :
return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 4, ZSTD_noDict); return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 4, ZSTD_noDict);
case 5 : case 5 :
return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 5, ZSTD_noDict); return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 5, ZSTD_noDict);
case 6 : case 6 :
return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 6, ZSTD_noDict); return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 6, ZSTD_noDict);
case 7 : case 7 :
return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 7, ZSTD_noDict); return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 7, ZSTD_noDict);
} }
} }
size_t ZSTD_compressBlock_doubleFast_dictMatchState( size_t ZSTD_compressBlock_doubleFast_dictMatchState(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize) void const* src, size_t srcSize)
{ {
const U32 mls = ms->cParams.searchLength; const U32 mls = ms->cParams.minMatch;
switch(mls) switch(mls)
{ {
default: /* includes case 3 */ default: /* includes case 3 */
case 4 : case 4 :
return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 4, ZSTD_dictMatchState); return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 4, ZSTD_dictMatchState);
case 5 : case 5 :
return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 5, ZSTD_dictMatchState); return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 5, ZSTD_dictMatchState);
case 6 : case 6 :
return iend - anchor; return iend - anchor;
} }
size_t ZSTD_compressBlock_doubleFast_extDict( size_t ZSTD_compressBlock_doubleFast_extDict(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize) void const* src, size_t srcSize)
{ {
U32 const mls = ms->cParams.searchLength; U32 const mls = ms->cParams.minMatch;
switch(mls) switch(mls)
{ {
default: /* includes case 3 */ default: /* includes case 3 */
case 4 : case 4 :
return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 4); return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 4);
case 5 : case 5 :
return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 5); return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 5);
case 6 : case 6 :
return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 6); return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 6);
case 7 : case 7 :
return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 7); return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 7);
} }
} }

contrib/python-zstandard/zstd/compress/zstd_fast.c

void ZSTD_fillHashTable(ZSTD_matchState_t* ms, void ZSTD_fillHashTable(ZSTD_matchState_t* ms,
void const* end, ZSTD_dictTableLoadMethod_e dtlm) void const* end, ZSTD_dictTableLoadMethod_e dtlm)
{ {
const ZSTD_compressionParameters* const cParams = &ms->cParams; const ZSTD_compressionParameters* const cParams = &ms->cParams;
U32* const hashTable = ms->hashTable; U32* const hashTable = ms->hashTable;
U32 const hBits = cParams->hashLog; U32 const hBits = cParams->hashLog;
U32 const mls = cParams->searchLength; U32 const mls = cParams->minMatch;
const BYTE* const base = ms->window.base; const BYTE* const base = ms->window.base;
const BYTE* ip = base + ms->nextToUpdate; const BYTE* ip = base + ms->nextToUpdate;
const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE; const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE;
const U32 fastHashFillStep = 3; const U32 fastHashFillStep = 3;
/* Always insert every fastHashFillStep position into the hash table. /* Always insert every fastHashFillStep position into the hash table.
* Insert the other positions if their hash entry is empty. * Insert the other positions if their hash entry is empty.
*/ */
for (; ip + fastHashFillStep - 1 <= iend; ip += fastHashFillStep) { for ( ; ip + fastHashFillStep < iend + 2; ip += fastHashFillStep) {
U32 const current = (U32)(ip - base); U32 const current = (U32)(ip - base);
U32 i; size_t const hash0 = ZSTD_hashPtr(ip, hBits, mls);
for (i = 0; i < fastHashFillStep; ++i) { hashTable[hash0] = current;
size_t const hash = ZSTD_hashPtr(ip + i, hBits, mls); if (dtlm == ZSTD_dtlm_fast) continue;
if (i == 0 || hashTable[hash] == 0)
hashTable[hash] = current + i;
/* Only load extra positions for ZSTD_dtlm_full */ /* Only load extra positions for ZSTD_dtlm_full */
if (dtlm == ZSTD_dtlm_fast) { U32 p;
break; for (p = 1; p < fastHashFillStep; ++p) {
} size_t const hash = ZSTD_hashPtr(ip + p, hBits, mls);
} if (hashTable[hash] == 0) { /* not yet filled */
hashTable[hash] = current + p;
} } } }
} }
FORCE_INLINE_TEMPLATE FORCE_INLINE_TEMPLATE
size_t ZSTD_compressBlock_fast_generic( size_t ZSTD_compressBlock_fast_generic(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize, void const* src, size_t srcSize,
U32 const mls, ZSTD_dictMode_e const dictMode) U32 const mls, ZSTD_dictMode_e const dictMode)
{ {
} }
size_t ZSTD_compressBlock_fast( size_t ZSTD_compressBlock_fast(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize) void const* src, size_t srcSize)
{ {
ZSTD_compressionParameters const* cParams = &ms->cParams; ZSTD_compressionParameters const* cParams = &ms->cParams;
U32 const mls = cParams->searchLength; U32 const mls = cParams->minMatch;
assert(ms->dictMatchState == NULL); assert(ms->dictMatchState == NULL);
switch(mls) switch(mls)
{ {
default: /* includes case 3 */ default: /* includes case 3 */
case 4 : case 4 :
return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 4, ZSTD_noDict); return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 4, ZSTD_noDict);
case 5 : case 5 :
return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 5, ZSTD_noDict); return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 5, ZSTD_noDict);
case 6 : case 6 :
return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 6, ZSTD_noDict); return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 6, ZSTD_noDict);
case 7 : case 7 :
return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 7, ZSTD_noDict); return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 7, ZSTD_noDict);
} }
} }
size_t ZSTD_compressBlock_fast_dictMatchState( size_t ZSTD_compressBlock_fast_dictMatchState(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize) void const* src, size_t srcSize)
{ {
ZSTD_compressionParameters const* cParams = &ms->cParams; ZSTD_compressionParameters const* cParams = &ms->cParams;
U32 const mls = cParams->searchLength; U32 const mls = cParams->minMatch;
assert(ms->dictMatchState != NULL); assert(ms->dictMatchState != NULL);
switch(mls) switch(mls)
{ {
default: /* includes case 3 */ default: /* includes case 3 */
case 4 : case 4 :
return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 4, ZSTD_dictMatchState); return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 4, ZSTD_dictMatchState);
case 5 : case 5 :
return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 5, ZSTD_dictMatchState); return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 5, ZSTD_dictMatchState);
} }
size_t ZSTD_compressBlock_fast_extDict( size_t ZSTD_compressBlock_fast_extDict(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize) void const* src, size_t srcSize)
{ {
ZSTD_compressionParameters const* cParams = &ms->cParams; ZSTD_compressionParameters const* cParams = &ms->cParams;
U32 const mls = cParams->searchLength; U32 const mls = cParams->minMatch;
switch(mls) switch(mls)
{ {
default: /* includes case 3 */ default: /* includes case 3 */
case 4 : case 4 :
return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 4); return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 4);
case 5 : case 5 :
return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 5); return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 5);
case 6 : case 6 :
return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 6); return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 6);
case 7 : case 7 :
return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 7); return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 7);
} }
} }

contrib/python-zstandard/zstd/compress/zstd_lazy.c

/** ZSTD_insertDUBT1() : /** ZSTD_insertDUBT1() :
* sort one already inserted but unsorted position * sort one already inserted but unsorted position
* assumption : current >= btlow == (current - btmask) * assumption : current >= btlow == (current - btmask)
* doesn't fail */ * doesn't fail */
static void static void
ZSTD_insertDUBT1(ZSTD_matchState_t* ms, ZSTD_insertDUBT1(ZSTD_matchState_t* ms,
U32 current, const BYTE* inputEnd, U32 current, const BYTE* inputEnd,
U32 nbCompares, U32 btLow, const ZSTD_dictMode_e dictMode) U32 nbCompares, U32 btLow,
const ZSTD_dictMode_e dictMode)
{ {
const ZSTD_compressionParameters* const cParams = &ms->cParams; const ZSTD_compressionParameters* const cParams = &ms->cParams;
U32* const bt = ms->chainTable; U32* const bt = ms->chainTable;
U32 const btLog = cParams->chainLog - 1; U32 const btLog = cParams->chainLog - 1;
U32 const btMask = (1 << btLog) - 1; U32 const btMask = (1 << btLog) - 1;
size_t commonLengthSmaller=0, commonLengthLarger=0; size_t commonLengthSmaller=0, commonLengthLarger=0;
const BYTE* const base = ms->window.base; const BYTE* const base = ms->window.base;
const BYTE* const dictBase = ms->window.dictBase; const BYTE* const dictBase = ms->window.dictBase;
const U32 dictLimit = ms->window.dictLimit; const U32 dictLimit = ms->window.dictLimit;
const BYTE* const ip = (current>=dictLimit) ? base + current : dictBase + current; const BYTE* const ip = (current>=dictLimit) ? base + current : dictBase + current;
const BYTE* const iend = (current>=dictLimit) ? inputEnd : dictBase + dictLimit; const BYTE* const iend = (current>=dictLimit) ? inputEnd : dictBase + dictLimit;
const BYTE* const dictEnd = dictBase + dictLimit; const BYTE* const dictEnd = dictBase + dictLimit;
const BYTE* const prefixStart = base + dictLimit; const BYTE* const prefixStart = base + dictLimit;
const BYTE* match; const BYTE* match;
U32* smallerPtr = bt + 2*(current&btMask); U32* smallerPtr = bt + 2*(current&btMask);
U32* largerPtr = smallerPtr + 1; U32* largerPtr = smallerPtr + 1;
U32 matchIndex = *smallerPtr; U32 matchIndex = *smallerPtr; /* this candidate is unsorted : next sorted candidate is reached through *smallerPtr, while *largerPtr contains previous unsorted candidate (which is already saved and can be overwritten) */
U32 dummy32; /* to be nullified at the end */ U32 dummy32; /* to be nullified at the end */
U32 const windowLow = ms->window.lowLimit; U32 const windowLow = ms->window.lowLimit;
DEBUGLOG(8, "ZSTD_insertDUBT1(%u) (dictLimit=%u, lowLimit=%u)", DEBUGLOG(8, "ZSTD_insertDUBT1(%u) (dictLimit=%u, lowLimit=%u)",
current, dictLimit, windowLow); current, dictLimit, windowLow);
assert(current >= btLow); assert(current >= btLow);
assert(ip < iend); /* condition for ZSTD_count */ assert(ip < iend); /* condition for ZSTD_count */
while (nbCompares-- && (matchIndex > windowLow)) { while (nbCompares-- && (matchIndex > windowLow)) {
U32* const nextPtr = bt + 2*(matchIndex & btMask); U32* const nextPtr = bt + 2*(matchIndex & btMask);
size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */ size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */
assert(matchIndex < current); assert(matchIndex < current);
/* note : all candidates are now supposed sorted,
* but it's still possible to have nextPtr[1] == ZSTD_DUBT_UNSORTED_MARK
* when a real index has the same value as ZSTD_DUBT_UNSORTED_MARK */
if ( (dictMode != ZSTD_extDict) if ( (dictMode != ZSTD_extDict)
|| (matchIndex+matchLength >= dictLimit) /* both in current segment*/ || (matchIndex+matchLength >= dictLimit) /* both in current segment*/
|| (current < dictLimit) /* both in extDict */) { || (current < dictLimit) /* both in extDict */) {
const BYTE* const mBase = ( (dictMode != ZSTD_extDict) const BYTE* const mBase = ( (dictMode != ZSTD_extDict)
|| (matchIndex+matchLength >= dictLimit)) ? || (matchIndex+matchLength >= dictLimit)) ?
base : dictBase; base : dictBase;
assert( (matchIndex+matchLength >= dictLimit) /* might be wrong if extDict is incorrectly set to 0 */ assert( (matchIndex+matchLength >= dictLimit) /* might be wrong if extDict is incorrectly set to 0 */
|| (current < dictLimit) ); || (current < dictLimit) );
match = mBase + matchIndex; match = mBase + matchIndex;
matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend); matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
} else { } else {
match = dictBase + matchIndex; match = dictBase + matchIndex;
matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart); matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
if (matchIndex+matchLength >= dictLimit) if (matchIndex+matchLength >= dictLimit)
match = base + matchIndex; /* to prepare for next usage of match[matchLength] */ match = base + matchIndex; /* preparation for next read of match[matchLength] */
} }
DEBUGLOG(8, "ZSTD_insertDUBT1: comparing %u with %u : found %u common bytes ", DEBUGLOG(8, "ZSTD_insertDUBT1: comparing %u with %u : found %u common bytes ",
current, matchIndex, (U32)matchLength); current, matchIndex, (U32)matchLength);
if (ip+matchLength == iend) { /* equal : no way to know if inf or sup */ if (ip+matchLength == iend) { /* equal : no way to know if inf or sup */
break; /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */ break; /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */
} }
} }
static size_t static size_t
ZSTD_DUBT_findBetterDictMatch ( ZSTD_DUBT_findBetterDictMatch (
ZSTD_matchState_t* ms, ZSTD_matchState_t* ms,
const BYTE* const ip, const BYTE* const iend, const BYTE* const ip, const BYTE* const iend,
size_t* offsetPtr, size_t* offsetPtr,
size_t bestLength,
U32 nbCompares, U32 nbCompares,
U32 const mls, U32 const mls,
const ZSTD_dictMode_e dictMode) const ZSTD_dictMode_e dictMode)
{ {
const ZSTD_matchState_t * const dms = ms->dictMatchState; const ZSTD_matchState_t * const dms = ms->dictMatchState;
const ZSTD_compressionParameters* const dmsCParams = &dms->cParams; const ZSTD_compressionParameters* const dmsCParams = &dms->cParams;
const U32 * const dictHashTable = dms->hashTable; const U32 * const dictHashTable = dms->hashTable;
U32 const hashLog = dmsCParams->hashLog; U32 const hashLog = dmsCParams->hashLog;
U32 const dictLowLimit = dms->window.lowLimit; U32 const dictLowLimit = dms->window.lowLimit;
U32 const dictIndexDelta = ms->window.lowLimit - dictHighLimit; U32 const dictIndexDelta = ms->window.lowLimit - dictHighLimit;
U32* const dictBt = dms->chainTable; U32* const dictBt = dms->chainTable;
U32 const btLog = dmsCParams->chainLog - 1; U32 const btLog = dmsCParams->chainLog - 1;
U32 const btMask = (1 << btLog) - 1; U32 const btMask = (1 << btLog) - 1;
U32 const btLow = (btMask >= dictHighLimit - dictLowLimit) ? dictLowLimit : dictHighLimit - btMask; U32 const btLow = (btMask >= dictHighLimit - dictLowLimit) ? dictLowLimit : dictHighLimit - btMask;
size_t commonLengthSmaller=0, commonLengthLarger=0, bestLength=0; size_t commonLengthSmaller=0, commonLengthLarger=0;
U32 matchEndIdx = current+8+1;
(void)dictMode; (void)dictMode;
assert(dictMode == ZSTD_dictMatchState); assert(dictMode == ZSTD_dictMatchState);
while (nbCompares-- && (dictMatchIndex > dictLowLimit)) { while (nbCompares-- && (dictMatchIndex > dictLowLimit)) {
U32* const nextPtr = dictBt + 2*(dictMatchIndex & btMask); U32* const nextPtr = dictBt + 2*(dictMatchIndex & btMask);
size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */ size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */
const BYTE* match = dictBase + dictMatchIndex; const BYTE* match = dictBase + dictMatchIndex;
matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart); matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
if (dictMatchIndex+matchLength >= dictHighLimit) if (dictMatchIndex+matchLength >= dictHighLimit)
match = base + dictMatchIndex + dictIndexDelta; /* to prepare for next usage of match[matchLength] */ match = base + dictMatchIndex + dictIndexDelta; /* to prepare for next usage of match[matchLength] */
if (matchLength > bestLength) { if (matchLength > bestLength) {
U32 matchIndex = dictMatchIndex + dictIndexDelta; U32 matchIndex = dictMatchIndex + dictIndexDelta;
if (matchLength > matchEndIdx - matchIndex)
matchEndIdx = matchIndex + (U32)matchLength;
if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(current-matchIndex+1) - ZSTD_highbit32((U32)offsetPtr[0]+1)) ) { if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(current-matchIndex+1) - ZSTD_highbit32((U32)offsetPtr[0]+1)) ) {
DEBUGLOG(2, "ZSTD_DUBT_findBestDictMatch(%u) : found better match length %u -> %u and offsetCode %u -> %u (dictMatchIndex %u, matchIndex %u)", DEBUGLOG(9, "ZSTD_DUBT_findBetterDictMatch(%u) : found better match length %u -> %u and offsetCode %u -> %u (dictMatchIndex %u, matchIndex %u)",
current, (U32)bestLength, (U32)matchLength, (U32)*offsetPtr, ZSTD_REP_MOVE + current - matchIndex, dictMatchIndex, matchIndex); current, (U32)bestLength, (U32)matchLength, (U32)*offsetPtr, ZSTD_REP_MOVE + current - matchIndex, dictMatchIndex, matchIndex);
bestLength = matchLength, *offsetPtr = ZSTD_REP_MOVE + current - matchIndex; bestLength = matchLength, *offsetPtr = ZSTD_REP_MOVE + current - matchIndex;
} }
if (ip+matchLength == iend) { /* reached end of input : ip[matchLength] is not valid, no way to know if it's larger or smaller than match */ if (ip+matchLength == iend) { /* reached end of input : ip[matchLength] is not valid, no way to know if it's larger or smaller than match */
break; /* drop, to guarantee consistency (miss a little bit of compression) */ break; /* drop, to guarantee consistency (miss a little bit of compression) */
} }
} }
DEBUGLOG(2, "matchLength:%6zu, match:%p, prefixStart:%p, ip:%p", matchLength, match, prefixStart, ip);
if (match[matchLength] < ip[matchLength]) { if (match[matchLength] < ip[matchLength]) {
if (dictMatchIndex <= btLow) { break; } /* beyond tree size, stop the search */ if (dictMatchIndex <= btLow) { break; } /* beyond tree size, stop the search */
commonLengthSmaller = matchLength; /* all smaller will now have at least this guaranteed common length */ commonLengthSmaller = matchLength; /* all smaller will now have at least this guaranteed common length */
dictMatchIndex = nextPtr[1]; /* new matchIndex larger than previous (closer to current) */ dictMatchIndex = nextPtr[1]; /* new matchIndex larger than previous (closer to current) */
} else { } else {
/* match is larger than current */ /* match is larger than current */
if (dictMatchIndex <= btLow) { break; } /* beyond tree size, stop the search */ if (dictMatchIndex <= btLow) { break; } /* beyond tree size, stop the search */
commonLengthLarger = matchLength; commonLengthLarger = matchLength;
dictMatchIndex = nextPtr[0]; dictMatchIndex = nextPtr[0];
} }
} }
if (bestLength >= MINMATCH) { if (bestLength >= MINMATCH) {
U32 const mIndex = current - ((U32)*offsetPtr - ZSTD_REP_MOVE); (void)mIndex; U32 const mIndex = current - ((U32)*offsetPtr - ZSTD_REP_MOVE); (void)mIndex;
DEBUGLOG(2, "ZSTD_DUBT_findBestDictMatch(%u) : found match of length %u and offsetCode %u (pos %u)", DEBUGLOG(8, "ZSTD_DUBT_findBetterDictMatch(%u) : found match of length %u and offsetCode %u (pos %u)",
current, (U32)bestLength, (U32)*offsetPtr, mIndex); current, (U32)bestLength, (U32)*offsetPtr, mIndex);
} }
return bestLength; return bestLength;
} }
static size_t static size_t
assert(ip <= iend-8); /* required for h calculation */ assert(ip <= iend-8); /* required for h calculation */
/* reach end of unsorted candidates list */ /* reach end of unsorted candidates list */
while ( (matchIndex > unsortLimit) while ( (matchIndex > unsortLimit)
&& (*unsortedMark == ZSTD_DUBT_UNSORTED_MARK) && (*unsortedMark == ZSTD_DUBT_UNSORTED_MARK)
&& (nbCandidates > 1) ) { && (nbCandidates > 1) ) {
DEBUGLOG(8, "ZSTD_DUBT_findBestMatch: candidate %u is unsorted", DEBUGLOG(8, "ZSTD_DUBT_findBestMatch: candidate %u is unsorted",
matchIndex); matchIndex);
*unsortedMark = previousCandidate; *unsortedMark = previousCandidate; /* the unsortedMark becomes a reversed chain, to move up back to original position */
previousCandidate = matchIndex; previousCandidate = matchIndex;
matchIndex = *nextCandidate; matchIndex = *nextCandidate;
nextCandidate = bt + 2*(matchIndex&btMask); nextCandidate = bt + 2*(matchIndex&btMask);
unsortedMark = bt + 2*(matchIndex&btMask) + 1; unsortedMark = bt + 2*(matchIndex&btMask) + 1;
nbCandidates --; nbCandidates --;
} }
/* nullify last candidate if it's still unsorted
* simplification, detrimental to compression ratio, beneficial for speed */
if ( (matchIndex > unsortLimit) if ( (matchIndex > unsortLimit)
&& (*unsortedMark==ZSTD_DUBT_UNSORTED_MARK) ) { && (*unsortedMark==ZSTD_DUBT_UNSORTED_MARK) ) {
DEBUGLOG(7, "ZSTD_DUBT_findBestMatch: nullify last unsorted candidate %u", DEBUGLOG(7, "ZSTD_DUBT_findBestMatch: nullify last unsorted candidate %u",
matchIndex); matchIndex);
*nextCandidate = *unsortedMark = 0; /* nullify next candidate if it's still unsorted (note : simplification, detrimental to compression ratio, beneficial for speed) */ *nextCandidate = *unsortedMark = 0;
} }
/* batch sort stacked candidates */ /* batch sort stacked candidates */
matchIndex = previousCandidate; matchIndex = previousCandidate;
while (matchIndex) { /* will end on matchIndex == 0 */ while (matchIndex) { /* will end on matchIndex == 0 */
U32* const nextCandidateIdxPtr = bt + 2*(matchIndex&btMask) + 1; U32* const nextCandidateIdxPtr = bt + 2*(matchIndex&btMask) + 1;
U32 const nextCandidateIdx = *nextCandidateIdxPtr; U32 const nextCandidateIdx = *nextCandidateIdxPtr;
ZSTD_insertDUBT1(ms, matchIndex, iend, ZSTD_insertDUBT1(ms, matchIndex, iend,
nbCandidates, unsortLimit, dictMode); nbCandidates, unsortLimit, dictMode);
matchIndex = nextCandidateIdx; matchIndex = nextCandidateIdx;
nbCandidates++; nbCandidates++;
} }
/* find longest match */ /* find longest match */
{ size_t commonLengthSmaller=0, commonLengthLarger=0; { size_t commonLengthSmaller = 0, commonLengthLarger = 0;
const BYTE* const dictBase = ms->window.dictBase; const BYTE* const dictBase = ms->window.dictBase;
const U32 dictLimit = ms->window.dictLimit; const U32 dictLimit = ms->window.dictLimit;
const BYTE* const dictEnd = dictBase + dictLimit; const BYTE* const dictEnd = dictBase + dictLimit;
const BYTE* const prefixStart = base + dictLimit; const BYTE* const prefixStart = base + dictLimit;
U32* smallerPtr = bt + 2*(current&btMask); U32* smallerPtr = bt + 2*(current&btMask);
U32* largerPtr = bt + 2*(current&btMask) + 1; U32* largerPtr = bt + 2*(current&btMask) + 1;
U32 matchEndIdx = current+8+1; U32 matchEndIdx = current + 8 + 1;
U32 dummy32; /* to be nullified at the end */ U32 dummy32; /* to be nullified at the end */
size_t bestLength = 0; size_t bestLength = 0;
matchIndex = hashTable[h]; matchIndex = hashTable[h];
hashTable[h] = current; /* Update Hash Table */ hashTable[h] = current; /* Update Hash Table */
while (nbCompares-- && (matchIndex > windowLow)) { while (nbCompares-- && (matchIndex > windowLow)) {
U32* const nextPtr = bt + 2*(matchIndex & btMask); U32* const nextPtr = bt + 2*(matchIndex & btMask);
} }
if (matchLength > bestLength) { if (matchLength > bestLength) {
if (matchLength > matchEndIdx - matchIndex) if (matchLength > matchEndIdx - matchIndex)
matchEndIdx = matchIndex + (U32)matchLength; matchEndIdx = matchIndex + (U32)matchLength;
if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(current-matchIndex+1) - ZSTD_highbit32((U32)offsetPtr[0]+1)) ) if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(current-matchIndex+1) - ZSTD_highbit32((U32)offsetPtr[0]+1)) )
bestLength = matchLength, *offsetPtr = ZSTD_REP_MOVE + current - matchIndex; bestLength = matchLength, *offsetPtr = ZSTD_REP_MOVE + current - matchIndex;
if (ip+matchLength == iend) { /* equal : no way to know if inf or sup */ if (ip+matchLength == iend) { /* equal : no way to know if inf or sup */
if (dictMode == ZSTD_dictMatchState) {
nbCompares = 0; /* in addition to avoiding checking any
* further in this loop, make sure we
* skip checking in the dictionary. */
}
break; /* drop, to guarantee consistency (miss a little bit of compression) */ break; /* drop, to guarantee consistency (miss a little bit of compression) */
} }
} }
if (match[matchLength] < ip[matchLength]) { if (match[matchLength] < ip[matchLength]) {
/* match is smaller than current */ /* match is smaller than current */
*smallerPtr = matchIndex; /* update smaller idx */ *smallerPtr = matchIndex; /* update smaller idx */
commonLengthSmaller = matchLength; /* all smaller will now have at least this guaranteed common length */ commonLengthSmaller = matchLength; /* all smaller will now have at least this guaranteed common length */
if (matchIndex <= btLow) { smallerPtr=&dummy32; break; } /* beyond tree size, stop the search */ if (matchIndex <= btLow) { smallerPtr=&dummy32; break; } /* beyond tree size, stop the search */
smallerPtr = nextPtr+1; /* new "smaller" => larger of match */ smallerPtr = nextPtr+1; /* new "smaller" => larger of match */
matchIndex = nextPtr[1]; /* new matchIndex larger than previous (closer to current) */ matchIndex = nextPtr[1]; /* new matchIndex larger than previous (closer to current) */
} else { } else {
/* match is larger than current */ /* match is larger than current */
*largerPtr = matchIndex; *largerPtr = matchIndex;
commonLengthLarger = matchLength; commonLengthLarger = matchLength;
if (matchIndex <= btLow) { largerPtr=&dummy32; break; } /* beyond tree size, stop the search */ if (matchIndex <= btLow) { largerPtr=&dummy32; break; } /* beyond tree size, stop the search */
largerPtr = nextPtr; largerPtr = nextPtr;
matchIndex = nextPtr[0]; matchIndex = nextPtr[0];
} } } }
*smallerPtr = *largerPtr = 0; *smallerPtr = *largerPtr = 0;
if (dictMode == ZSTD_dictMatchState && nbCompares) { if (dictMode == ZSTD_dictMatchState && nbCompares) {
bestLength = ZSTD_DUBT_findBetterDictMatch(ms, ip, iend, offsetPtr, nbCompares, mls, dictMode); bestLength = ZSTD_DUBT_findBetterDictMatch(
ms, ip, iend,
offsetPtr, bestLength, nbCompares,
mls, dictMode);
} }
assert(matchEndIdx > current+8); /* ensure nextToUpdate is increased */ assert(matchEndIdx > current+8); /* ensure nextToUpdate is increased */
ms->nextToUpdate = matchEndIdx - 8; /* skip repetitive patterns */ ms->nextToUpdate = matchEndIdx - 8; /* skip repetitive patterns */
if (bestLength >= MINMATCH) { if (bestLength >= MINMATCH) {
U32 const mIndex = current - ((U32)*offsetPtr - ZSTD_REP_MOVE); (void)mIndex; U32 const mIndex = current - ((U32)*offsetPtr - ZSTD_REP_MOVE); (void)mIndex;
DEBUGLOG(8, "ZSTD_DUBT_findBestMatch(%u) : found match of length %u and offsetCode %u (pos %u)", DEBUGLOG(8, "ZSTD_DUBT_findBestMatch(%u) : found match of length %u and offsetCode %u (pos %u)",
current, (U32)bestLength, (U32)*offsetPtr, mIndex); current, (U32)bestLength, (U32)*offsetPtr, mIndex);
} }
static size_t static size_t
ZSTD_BtFindBestMatch_selectMLS ( ZSTD_matchState_t* ms, ZSTD_BtFindBestMatch_selectMLS ( ZSTD_matchState_t* ms,
const BYTE* ip, const BYTE* const iLimit, const BYTE* ip, const BYTE* const iLimit,
size_t* offsetPtr) size_t* offsetPtr)
{ {
switch(ms->cParams.searchLength) switch(ms->cParams.minMatch)
{ {
default : /* includes case 3 */ default : /* includes case 3 */
case 4 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_noDict); case 4 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_noDict);
case 5 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_noDict); case 5 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_noDict);
case 7 : case 7 :
case 6 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_noDict); case 6 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_noDict);
} }
} }
static size_t ZSTD_BtFindBestMatch_dictMatchState_selectMLS ( static size_t ZSTD_BtFindBestMatch_dictMatchState_selectMLS (
ZSTD_matchState_t* ms, ZSTD_matchState_t* ms,
const BYTE* ip, const BYTE* const iLimit, const BYTE* ip, const BYTE* const iLimit,
size_t* offsetPtr) size_t* offsetPtr)
{ {
switch(ms->cParams.searchLength) switch(ms->cParams.minMatch)
{ {
default : /* includes case 3 */ default : /* includes case 3 */
case 4 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_dictMatchState); case 4 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_dictMatchState);
case 5 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_dictMatchState); case 5 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_dictMatchState);
case 7 : case 7 :
case 6 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_dictMatchState); case 6 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_dictMatchState);
} }
} }
static size_t ZSTD_BtFindBestMatch_extDict_selectMLS ( static size_t ZSTD_BtFindBestMatch_extDict_selectMLS (
ZSTD_matchState_t* ms, ZSTD_matchState_t* ms,
const BYTE* ip, const BYTE* const iLimit, const BYTE* ip, const BYTE* const iLimit,
size_t* offsetPtr) size_t* offsetPtr)
{ {
switch(ms->cParams.searchLength) switch(ms->cParams.minMatch)
{ {
default : /* includes case 3 */ default : /* includes case 3 */
case 4 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_extDict); case 4 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_extDict);
case 5 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_extDict); case 5 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_extDict);
case 7 : case 7 :
case 6 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_extDict); case 6 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_extDict);
} }
} }
/* ********************************* /* *********************************
* Hash Chain * Hash Chain
***********************************/ ***********************************/
#define NEXT_IN_CHAIN(d, mask) chainTable[(d) & mask] #define NEXT_IN_CHAIN(d, mask) chainTable[(d) & (mask)]
/* Update chains up to ip (excluded) /* Update chains up to ip (excluded)
Assumption : always within prefix (i.e. not within extDict) */ Assumption : always within prefix (i.e. not within extDict) */
static U32 ZSTD_insertAndFindFirstIndex_internal( static U32 ZSTD_insertAndFindFirstIndex_internal(
ZSTD_matchState_t* ms, ZSTD_matchState_t* ms,
const ZSTD_compressionParameters* const cParams, const ZSTD_compressionParameters* const cParams,
const BYTE* ip, U32 const mls) const BYTE* ip, U32 const mls)
{ {
} }
ms->nextToUpdate = target; ms->nextToUpdate = target;
return hashTable[ZSTD_hashPtr(ip, hashLog, mls)]; return hashTable[ZSTD_hashPtr(ip, hashLog, mls)];
} }
U32 ZSTD_insertAndFindFirstIndex(ZSTD_matchState_t* ms, const BYTE* ip) { U32 ZSTD_insertAndFindFirstIndex(ZSTD_matchState_t* ms, const BYTE* ip) {
const ZSTD_compressionParameters* const cParams = &ms->cParams; const ZSTD_compressionParameters* const cParams = &ms->cParams;
return ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, ms->cParams.searchLength); return ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, ms->cParams.minMatch);
} }
/* inlining is important to hardwire a hot branch (template emulation) */ /* inlining is important to hardwire a hot branch (template emulation) */
FORCE_INLINE_TEMPLATE FORCE_INLINE_TEMPLATE
size_t ZSTD_HcFindBestMatch_generic ( size_t ZSTD_HcFindBestMatch_generic (
ZSTD_matchState_t* ms, ZSTD_matchState_t* ms,
const BYTE* const ip, const BYTE* const iLimit, const BYTE* const ip, const BYTE* const iLimit,
/* HC4 match finder */ /* HC4 match finder */
U32 matchIndex = ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, mls); U32 matchIndex = ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, mls);
for ( ; (matchIndex>lowLimit) & (nbAttempts>0) ; nbAttempts--) { for ( ; (matchIndex>lowLimit) & (nbAttempts>0) ; nbAttempts--) {
size_t currentMl=0; size_t currentMl=0;
if ((dictMode != ZSTD_extDict) || matchIndex >= dictLimit) { if ((dictMode != ZSTD_extDict) || matchIndex >= dictLimit) {
const BYTE* const match = base + matchIndex; const BYTE* const match = base + matchIndex;
assert(matchIndex >= dictLimit); /* ensures this is true if dictMode != ZSTD_extDict */
if (match[ml] == ip[ml]) /* potentially better */ if (match[ml] == ip[ml]) /* potentially better */
currentMl = ZSTD_count(ip, match, iLimit); currentMl = ZSTD_count(ip, match, iLimit);
} else { } else {
const BYTE* const match = dictBase + matchIndex; const BYTE* const match = dictBase + matchIndex;
assert(match+4 <= dictEnd); assert(match+4 <= dictEnd);
if (MEM_read32(match) == MEM_read32(ip)) /* assumption : matchIndex <= dictLimit-4 (by table construction) */ if (MEM_read32(match) == MEM_read32(ip)) /* assumption : matchIndex <= dictLimit-4 (by table construction) */
currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dictEnd, prefixStart) + 4; currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dictEnd, prefixStart) + 4;
} }
} }
FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_selectMLS ( FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_selectMLS (
ZSTD_matchState_t* ms, ZSTD_matchState_t* ms,
const BYTE* ip, const BYTE* const iLimit, const BYTE* ip, const BYTE* const iLimit,
size_t* offsetPtr) size_t* offsetPtr)
{ {
switch(ms->cParams.searchLength) switch(ms->cParams.minMatch)
{ {
default : /* includes case 3 */ default : /* includes case 3 */
case 4 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 4, ZSTD_noDict); case 4 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 4, ZSTD_noDict);
case 5 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 5, ZSTD_noDict); case 5 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 5, ZSTD_noDict);
case 7 : case 7 :
case 6 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 6, ZSTD_noDict); case 6 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 6, ZSTD_noDict);
} }
} }
static size_t ZSTD_HcFindBestMatch_dictMatchState_selectMLS ( static size_t ZSTD_HcFindBestMatch_dictMatchState_selectMLS (
ZSTD_matchState_t* ms, ZSTD_matchState_t* ms,
const BYTE* ip, const BYTE* const iLimit, const BYTE* ip, const BYTE* const iLimit,
size_t* offsetPtr) size_t* offsetPtr)
{ {
switch(ms->cParams.searchLength) switch(ms->cParams.minMatch)
{ {
default : /* includes case 3 */ default : /* includes case 3 */
case 4 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 4, ZSTD_dictMatchState); case 4 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 4, ZSTD_dictMatchState);
case 5 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 5, ZSTD_dictMatchState); case 5 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 5, ZSTD_dictMatchState);
case 7 : case 7 :
case 6 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 6, ZSTD_dictMatchState); case 6 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 6, ZSTD_dictMatchState);
} }
} }
FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_extDict_selectMLS ( FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_extDict_selectMLS (
ZSTD_matchState_t* ms, ZSTD_matchState_t* ms,
const BYTE* ip, const BYTE* const iLimit, const BYTE* ip, const BYTE* const iLimit,
size_t* offsetPtr) size_t* offsetPtr)
{ {
switch(ms->cParams.searchLength) switch(ms->cParams.minMatch)
{ {
default : /* includes case 3 */ default : /* includes case 3 */
case 4 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 4, ZSTD_extDict); case 4 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 4, ZSTD_extDict);
case 5 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 5, ZSTD_extDict); case 5 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 5, ZSTD_extDict);
case 7 : case 7 :
case 6 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 6, ZSTD_extDict); case 6 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 6, ZSTD_extDict);
} }
} }

contrib/python-zstandard/zstd/compress/zstd_ldm.h

#include "zstd_compress_internal.h" /* ldmParams_t, U32 */ #include "zstd_compress_internal.h" /* ldmParams_t, U32 */
#include "zstd.h" /* ZSTD_CCtx, size_t */ #include "zstd.h" /* ZSTD_CCtx, size_t */
/*-************************************* /*-*************************************
* Long distance matching * Long distance matching
***************************************/ ***************************************/
#define ZSTD_LDM_DEFAULT_WINDOW_LOG ZSTD_WINDOWLOG_DEFAULTMAX #define ZSTD_LDM_DEFAULT_WINDOW_LOG ZSTD_WINDOWLOG_LIMIT_DEFAULT
/** /**
* ZSTD_ldm_generateSequences(): * ZSTD_ldm_generateSequences():
* *
* Generates the sequences using the long distance match finder. * Generates the sequences using the long distance match finder.
* Generates long range matching sequences in `sequences`, which parse a prefix * Generates long range matching sequences in `sequences`, which parse a prefix
* of the source. `sequences` must be large enough to store every sequence, * of the source. `sequences` must be large enough to store every sequence,
* which can be checked with `ZSTD_ldm_getMaxNbSeq()`. * which can be checked with `ZSTD_ldm_getMaxNbSeq()`.
size_t ZSTD_ldm_getTableSize(ldmParams_t params); size_t ZSTD_ldm_getTableSize(ldmParams_t params);
/** ZSTD_ldm_getSeqSpace() : /** ZSTD_ldm_getSeqSpace() :
* Return an upper bound on the number of sequences that can be produced by * Return an upper bound on the number of sequences that can be produced by
* the long distance matcher, or 0 if LDM is disabled. * the long distance matcher, or 0 if LDM is disabled.
*/ */
size_t ZSTD_ldm_getMaxNbSeq(ldmParams_t params, size_t maxChunkSize); size_t ZSTD_ldm_getMaxNbSeq(ldmParams_t params, size_t maxChunkSize);
/** ZSTD_ldm_getTableSize() :
* Return prime8bytes^(minMatchLength-1) */
U64 ZSTD_ldm_getHashPower(U32 minMatchLength);
/** ZSTD_ldm_adjustParameters() : /** ZSTD_ldm_adjustParameters() :
* If the params->hashEveryLog is not set, set it to its default value based on * If the params->hashRateLog is not set, set it to its default value based on
* windowLog and params->hashLog. * windowLog and params->hashLog.
* *
* Ensures that params->bucketSizeLog is <= params->hashLog (setting it to * Ensures that params->bucketSizeLog is <= params->hashLog (setting it to
* params->hashLog if it is not). * params->hashLog if it is not).
* *
* Ensures that the minMatchLength >= targetLength during optimal parsing. * Ensures that the minMatchLength >= targetLength during optimal parsing.
*/ */
void ZSTD_ldm_adjustParameters(ldmParams_t* params, void ZSTD_ldm_adjustParameters(ldmParams_t* params,
ZSTD_compressionParameters const* cParams); ZSTD_compressionParameters const* cParams);
#if defined (__cplusplus) #if defined (__cplusplus)
} }
#endif #endif
#endif /* ZSTD_FAST_H */ #endif /* ZSTD_FAST_H */

contrib/python-zstandard/zstd/compress/zstd_ldm.c

assert(minMatch >= ZSTD_LDM_MINMATCH_MIN); assert(minMatch >= ZSTD_LDM_MINMATCH_MIN);
assert(minMatch <= ZSTD_LDM_MINMATCH_MAX); assert(minMatch <= ZSTD_LDM_MINMATCH_MAX);
params->minMatchLength = minMatch; params->minMatchLength = minMatch;
} }
if (params->hashLog == 0) { if (params->hashLog == 0) {
params->hashLog = MAX(ZSTD_HASHLOG_MIN, params->windowLog - LDM_HASH_RLOG); params->hashLog = MAX(ZSTD_HASHLOG_MIN, params->windowLog - LDM_HASH_RLOG);
assert(params->hashLog <= ZSTD_HASHLOG_MAX); assert(params->hashLog <= ZSTD_HASHLOG_MAX);
} }
if (params->hashEveryLog == 0) { if (params->hashRateLog == 0) {
params->hashEveryLog = params->windowLog < params->hashLog params->hashRateLog = params->windowLog < params->hashLog
? 0 ? 0
: params->windowLog - params->hashLog; : params->windowLog - params->hashLog;
} }
params->bucketSizeLog = MIN(params->bucketSizeLog, params->hashLog); params->bucketSizeLog = MIN(params->bucketSizeLog, params->hashLog);
} }
size_t ZSTD_ldm_getTableSize(ldmParams_t params) size_t ZSTD_ldm_getTableSize(ldmParams_t params)
{ {
bucketOffsets[hash]++; bucketOffsets[hash]++;
bucketOffsets[hash] &= ((U32)1 << ldmParams.bucketSizeLog) - 1; bucketOffsets[hash] &= ((U32)1 << ldmParams.bucketSizeLog) - 1;
} }
/** ZSTD_ldm_makeEntryAndInsertByTag() : /** ZSTD_ldm_makeEntryAndInsertByTag() :
* *
* Gets the small hash, checksum, and tag from the rollingHash. * Gets the small hash, checksum, and tag from the rollingHash.
* *
* If the tag matches (1 << ldmParams.hashEveryLog)-1, then * If the tag matches (1 << ldmParams.hashRateLog)-1, then
* creates an ldmEntry from the offset, and inserts it into the hash table. * creates an ldmEntry from the offset, and inserts it into the hash table.
* *
* hBits is the length of the small hash, which is the most significant hBits * hBits is the length of the small hash, which is the most significant hBits
* of rollingHash. The checksum is the next 32 most significant bits, followed * of rollingHash. The checksum is the next 32 most significant bits, followed
* by ldmParams.hashEveryLog bits that make up the tag. */ * by ldmParams.hashRateLog bits that make up the tag. */
static void ZSTD_ldm_makeEntryAndInsertByTag(ldmState_t* ldmState, static void ZSTD_ldm_makeEntryAndInsertByTag(ldmState_t* ldmState,
U64 const rollingHash, U64 const rollingHash,
U32 const hBits, U32 const hBits,
U32 const offset, U32 const offset,
ldmParams_t const ldmParams) ldmParams_t const ldmParams)
{ {
U32 const tag = ZSTD_ldm_getTag(rollingHash, hBits, ldmParams.hashEveryLog); U32 const tag = ZSTD_ldm_getTag(rollingHash, hBits, ldmParams.hashRateLog);
U32 const tagMask = ((U32)1 << ldmParams.hashEveryLog) - 1; U32 const tagMask = ((U32)1 << ldmParams.hashRateLog) - 1;
if (tag == tagMask) { if (tag == tagMask) {
U32 const hash = ZSTD_ldm_getSmallHash(rollingHash, hBits); U32 const hash = ZSTD_ldm_getSmallHash(rollingHash, hBits);
U32 const checksum = ZSTD_ldm_getChecksum(rollingHash, hBits); U32 const checksum = ZSTD_ldm_getChecksum(rollingHash, hBits);
ldmEntry_t entry; ldmEntry_t entry;
entry.offset = offset; entry.offset = offset;
entry.checksum = checksum; entry.checksum = checksum;
ZSTD_ldm_insertEntry(ldmState, hash, entry, ldmParams); ZSTD_ldm_insertEntry(ldmState, hash, entry, ldmParams);
} }
} }
/** ZSTD_ldm_getRollingHash() :
* Get a 64-bit hash using the first len bytes from buf.
*
* Giving bytes s = s_1, s_2, ... s_k, the hash is defined to be
* H(s) = s_1*(a^(k-1)) + s_2*(a^(k-2)) + ... + s_k*(a^0)
*
* where the constant a is defined to be prime8bytes.
*
* The implementation adds an offset to each byte, so
* H(s) = (s_1 + HASH_CHAR_OFFSET)*(a^(k-1)) + ... */
static U64 ZSTD_ldm_getRollingHash(const BYTE* buf, U32 len)
{
U64 ret = 0;
U32 i;
for (i = 0; i < len; i++) {
ret *= prime8bytes;
ret += buf[i] + LDM_HASH_CHAR_OFFSET;
}
return ret;
}
/** ZSTD_ldm_ipow() :
* Return base^exp. */
static U64 ZSTD_ldm_ipow(U64 base, U64 exp)
{
U64 ret = 1;
while (exp) {
if (exp & 1) { ret *= base; }
exp >>= 1;
base *= base;
}
return ret;
}
U64 ZSTD_ldm_getHashPower(U32 minMatchLength) {
DEBUGLOG(4, "ZSTD_ldm_getHashPower: mml=%u", minMatchLength);
assert(minMatchLength >= ZSTD_LDM_MINMATCH_MIN);
return ZSTD_ldm_ipow(prime8bytes, minMatchLength - 1);
}
/** ZSTD_ldm_updateHash() :
* Updates hash by removing toRemove and adding toAdd. */
static U64 ZSTD_ldm_updateHash(U64 hash, BYTE toRemove, BYTE toAdd, U64 hashPower)
{
hash -= ((toRemove + LDM_HASH_CHAR_OFFSET) * hashPower);
hash *= prime8bytes;
hash += toAdd + LDM_HASH_CHAR_OFFSET;
return hash;
}
/** ZSTD_ldm_countBackwardsMatch() : /** ZSTD_ldm_countBackwardsMatch() :
* Returns the number of bytes that match backwards before pIn and pMatch. * Returns the number of bytes that match backwards before pIn and pMatch.
* *
* We count only bytes where pMatch >= pBase and pIn >= pAnchor. */ * We count only bytes where pMatch >= pBase and pIn >= pAnchor. */
static size_t ZSTD_ldm_countBackwardsMatch( static size_t ZSTD_ldm_countBackwardsMatch(
const BYTE* pIn, const BYTE* pAnchor, const BYTE* pIn, const BYTE* pAnchor,
const BYTE* pMatch, const BYTE* pBase) const BYTE* pMatch, const BYTE* pBase)
{ {
break; break;
case ZSTD_greedy: case ZSTD_greedy:
case ZSTD_lazy: case ZSTD_lazy:
case ZSTD_lazy2: case ZSTD_lazy2:
case ZSTD_btlazy2: case ZSTD_btlazy2:
case ZSTD_btopt: case ZSTD_btopt:
case ZSTD_btultra: case ZSTD_btultra:
case ZSTD_btultra2:
break; break;
default: default:
assert(0); /* not possible : not a valid strategy id */ assert(0); /* not possible : not a valid strategy id */
} }
return 0; return 0;
} }
/** ZSTD_ldm_fillLdmHashTable() : /** ZSTD_ldm_fillLdmHashTable() :
* *
* Fills hashTable from (lastHashed + 1) to iend (non-inclusive). * Fills hashTable from (lastHashed + 1) to iend (non-inclusive).
* lastHash is the rolling hash that corresponds to lastHashed. * lastHash is the rolling hash that corresponds to lastHashed.
* *
* Returns the rolling hash corresponding to position iend-1. */ * Returns the rolling hash corresponding to position iend-1. */
static U64 ZSTD_ldm_fillLdmHashTable(ldmState_t* state, static U64 ZSTD_ldm_fillLdmHashTable(ldmState_t* state,
U64 lastHash, const BYTE* lastHashed, U64 lastHash, const BYTE* lastHashed,
const BYTE* iend, const BYTE* base, const BYTE* iend, const BYTE* base,
U32 hBits, ldmParams_t const ldmParams) U32 hBits, ldmParams_t const ldmParams)
{ {
U64 rollingHash = lastHash; U64 rollingHash = lastHash;
const BYTE* cur = lastHashed + 1; const BYTE* cur = lastHashed + 1;
while (cur < iend) { while (cur < iend) {
rollingHash = ZSTD_ldm_updateHash(rollingHash, cur[-1], rollingHash = ZSTD_rollingHash_rotate(rollingHash, cur[-1],
cur[ldmParams.minMatchLength-1], cur[ldmParams.minMatchLength-1],
state->hashPower); state->hashPower);
ZSTD_ldm_makeEntryAndInsertByTag(state, ZSTD_ldm_makeEntryAndInsertByTag(state,
rollingHash, hBits, rollingHash, hBits,
(U32)(cur - base), ldmParams); (U32)(cur - base), ldmParams);
++cur; ++cur;
} }
return rollingHash; return rollingHash;
} }
ldmParams_t const* params, void const* src, size_t srcSize) ldmParams_t const* params, void const* src, size_t srcSize)
{ {
/* LDM parameters */ /* LDM parameters */
int const extDict = ZSTD_window_hasExtDict(ldmState->window); int const extDict = ZSTD_window_hasExtDict(ldmState->window);
U32 const minMatchLength = params->minMatchLength; U32 const minMatchLength = params->minMatchLength;
U64 const hashPower = ldmState->hashPower; U64 const hashPower = ldmState->hashPower;
U32 const hBits = params->hashLog - params->bucketSizeLog; U32 const hBits = params->hashLog - params->bucketSizeLog;
U32 const ldmBucketSize = 1U << params->bucketSizeLog; U32 const ldmBucketSize = 1U << params->bucketSizeLog;
U32 const hashEveryLog = params->hashEveryLog; U32 const hashRateLog = params->hashRateLog;
U32 const ldmTagMask = (1U << params->hashEveryLog) - 1; U32 const ldmTagMask = (1U << params->hashRateLog) - 1;
/* Prefix and extDict parameters */ /* Prefix and extDict parameters */
U32 const dictLimit = ldmState->window.dictLimit; U32 const dictLimit = ldmState->window.dictLimit;
U32 const lowestIndex = extDict ? ldmState->window.lowLimit : dictLimit; U32 const lowestIndex = extDict ? ldmState->window.lowLimit : dictLimit;
BYTE const* const base = ldmState->window.base; BYTE const* const base = ldmState->window.base;
BYTE const* const dictBase = extDict ? ldmState->window.dictBase : NULL; BYTE const* const dictBase = extDict ? ldmState->window.dictBase : NULL;
BYTE const* const dictStart = extDict ? dictBase + lowestIndex : NULL; BYTE const* const dictStart = extDict ? dictBase + lowestIndex : NULL;
BYTE const* const dictEnd = extDict ? dictBase + dictLimit : NULL; BYTE const* const dictEnd = extDict ? dictBase + dictLimit : NULL;
BYTE const* const lowPrefixPtr = base + dictLimit; BYTE const* const lowPrefixPtr = base + dictLimit;
U64 rollingHash = 0; U64 rollingHash = 0;
while (ip <= ilimit) { while (ip <= ilimit) {
size_t mLength; size_t mLength;
U32 const current = (U32)(ip - base); U32 const current = (U32)(ip - base);
size_t forwardMatchLength = 0, backwardMatchLength = 0; size_t forwardMatchLength = 0, backwardMatchLength = 0;
ldmEntry_t* bestEntry = NULL; ldmEntry_t* bestEntry = NULL;
if (ip != istart) { if (ip != istart) {
rollingHash = ZSTD_ldm_updateHash(rollingHash, lastHashed[0], rollingHash = ZSTD_rollingHash_rotate(rollingHash, lastHashed[0],
lastHashed[minMatchLength], lastHashed[minMatchLength],
hashPower); hashPower);
} else { } else {
rollingHash = ZSTD_ldm_getRollingHash(ip, minMatchLength); rollingHash = ZSTD_rollingHash_compute(ip, minMatchLength);
} }
lastHashed = ip; lastHashed = ip;
/* Do not insert and do not look for a match */ /* Do not insert and do not look for a match */
if (ZSTD_ldm_getTag(rollingHash, hBits, hashEveryLog) != ldmTagMask) { if (ZSTD_ldm_getTag(rollingHash, hBits, hashRateLog) != ldmTagMask) {
ip++; ip++;
continue; continue;
} }
/* Get the best entry and compute the match lengths */ /* Get the best entry and compute the match lengths */
{ {
ldmEntry_t* const bucket = ldmEntry_t* const bucket =
ZSTD_ldm_getBucket(ldmState, ZSTD_ldm_getBucket(ldmState,
return sequence; return sequence;
} }
size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore, size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore,
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize) void const* src, size_t srcSize)
{ {
const ZSTD_compressionParameters* const cParams = &ms->cParams; const ZSTD_compressionParameters* const cParams = &ms->cParams;
unsigned const minMatch = cParams->searchLength; unsigned const minMatch = cParams->minMatch;
ZSTD_blockCompressor const blockCompressor = ZSTD_blockCompressor const blockCompressor =
ZSTD_selectBlockCompressor(cParams->strategy, ZSTD_matchState_dictMode(ms)); ZSTD_selectBlockCompressor(cParams->strategy, ZSTD_matchState_dictMode(ms));
/* Input bounds */ /* Input bounds */
BYTE const* const istart = (BYTE const*)src; BYTE const* const istart = (BYTE const*)src;
BYTE const* const iend = istart + srcSize; BYTE const* const iend = istart + srcSize;
/* Input positions */ /* Input positions */
BYTE const* ip = istart; BYTE const* ip = istart;

contrib/python-zstandard/zstd/compress/zstd_opt.h

void ZSTD_updateTree(ZSTD_matchState_t* ms, const BYTE* ip, const BYTE* iend); void ZSTD_updateTree(ZSTD_matchState_t* ms, const BYTE* ip, const BYTE* iend);
size_t ZSTD_compressBlock_btopt( size_t ZSTD_compressBlock_btopt(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize); void const* src, size_t srcSize);
size_t ZSTD_compressBlock_btultra( size_t ZSTD_compressBlock_btultra(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize); void const* src, size_t srcSize);
size_t ZSTD_compressBlock_btultra2(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize);
size_t ZSTD_compressBlock_btopt_dictMatchState( size_t ZSTD_compressBlock_btopt_dictMatchState(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize); void const* src, size_t srcSize);
size_t ZSTD_compressBlock_btultra_dictMatchState( size_t ZSTD_compressBlock_btultra_dictMatchState(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize); void const* src, size_t srcSize);
size_t ZSTD_compressBlock_btopt_extDict( size_t ZSTD_compressBlock_btopt_extDict(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize); void const* src, size_t srcSize);
size_t ZSTD_compressBlock_btultra_extDict( size_t ZSTD_compressBlock_btultra_extDict(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize); void const* src, size_t srcSize);
/* note : no btultra2 variant for extDict nor dictMatchState,
* because btultra2 is not meant to work with dictionaries
* and is only specific for the first block (no prefix) */
#if defined (__cplusplus) #if defined (__cplusplus)
} }
#endif #endif
#endif /* ZSTD_OPT_H */ #endif /* ZSTD_OPT_H */

contrib/python-zstandard/zstd/compress/zstd_opt.c

#include "hist.h" #include "hist.h"
#include "zstd_opt.h" #include "zstd_opt.h"
#define ZSTD_LITFREQ_ADD 2 /* scaling factor for litFreq, so that frequencies adapt faster to new stats */ #define ZSTD_LITFREQ_ADD 2 /* scaling factor for litFreq, so that frequencies adapt faster to new stats */
#define ZSTD_FREQ_DIV 4 /* log factor when using previous stats to init next stats */ #define ZSTD_FREQ_DIV 4 /* log factor when using previous stats to init next stats */
#define ZSTD_MAX_PRICE (1<<30) #define ZSTD_MAX_PRICE (1<<30)
#define ZSTD_PREDEF_THRESHOLD 1024 /* if srcSize < ZSTD_PREDEF_THRESHOLD, symbols' cost is assumed static, directly determined by pre-defined distributions */
/*-************************************* /*-*************************************
* Price functions for optimal parser * Price functions for optimal parser
***************************************/ ***************************************/
#if 0 /* approximation at bit level */ #if 0 /* approximation at bit level */
# define BITCOST_ACCURACY 0 # define BITCOST_ACCURACY 0
# define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY) # define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY)
U32 const hb = ZSTD_highbit32(stat); U32 const hb = ZSTD_highbit32(stat);
U32 const BWeight = hb * BITCOST_MULTIPLIER; U32 const BWeight = hb * BITCOST_MULTIPLIER;
U32 const FWeight = (stat << BITCOST_ACCURACY) >> hb; U32 const FWeight = (stat << BITCOST_ACCURACY) >> hb;
U32 const weight = BWeight + FWeight; U32 const weight = BWeight + FWeight;
assert(hb + BITCOST_ACCURACY < 31); assert(hb + BITCOST_ACCURACY < 31);
return weight; return weight;
} }
/* debugging function, @return price in bytes */ #if (DEBUGLEVEL>=2)
/* debugging function,
* @return price in bytes as fractional value
* for debug messages only */
MEM_STATIC double ZSTD_fCost(U32 price) MEM_STATIC double ZSTD_fCost(U32 price)
{ {
return (double)price / (BITCOST_MULTIPLIER*8); return (double)price / (BITCOST_MULTIPLIER*8);
} }
#endif
static void ZSTD_setBasePrices(optState_t* optPtr, int optLevel) static void ZSTD_setBasePrices(optState_t* optPtr, int optLevel)
{ {
optPtr->litSumBasePrice = WEIGHT(optPtr->litSum, optLevel); optPtr->litSumBasePrice = WEIGHT(optPtr->litSum, optLevel);
optPtr->litLengthSumBasePrice = WEIGHT(optPtr->litLengthSum, optLevel); optPtr->litLengthSumBasePrice = WEIGHT(optPtr->litLengthSum, optLevel);
optPtr->matchLengthSumBasePrice = WEIGHT(optPtr->matchLengthSum, optLevel); optPtr->matchLengthSumBasePrice = WEIGHT(optPtr->matchLengthSum, optLevel);
optPtr->offCodeSumBasePrice = WEIGHT(optPtr->offCodeSum, optLevel); optPtr->offCodeSumBasePrice = WEIGHT(optPtr->offCodeSum, optLevel);
} }
static U32 ZSTD_downscaleStat(U32* table, U32 lastEltIndex, int malus) /* ZSTD_downscaleStat() :
* reduce all elements in table by a factor 2^(ZSTD_FREQ_DIV+malus)
* return the resulting sum of elements */
static U32 ZSTD_downscaleStat(unsigned* table, U32 lastEltIndex, int malus)
{ {
U32 s, sum=0; U32 s, sum=0;
DEBUGLOG(5, "ZSTD_downscaleStat (nbElts=%u)", (unsigned)lastEltIndex+1);
assert(ZSTD_FREQ_DIV+malus > 0 && ZSTD_FREQ_DIV+malus < 31); assert(ZSTD_FREQ_DIV+malus > 0 && ZSTD_FREQ_DIV+malus < 31);
for (s=0; s<=lastEltIndex; s++) { for (s=0; s<lastEltIndex+1; s++) {
table[s] = 1 + (table[s] >> (ZSTD_FREQ_DIV+malus)); table[s] = 1 + (table[s] >> (ZSTD_FREQ_DIV+malus));
sum += table[s]; sum += table[s];
} }
return sum; return sum;
} }
static void ZSTD_rescaleFreqs(optState_t* const optPtr, /* ZSTD_rescaleFreqs() :
* if first block (detected by optPtr->litLengthSum == 0) : init statistics
* take hints from dictionary if there is one
* or init from zero, using src for literals stats, or flat 1 for match symbols
* otherwise downscale existing stats, to be used as seed for next block.
*/
static void
ZSTD_rescaleFreqs(optState_t* const optPtr,
const BYTE* const src, size_t const srcSize, const BYTE* const src, size_t const srcSize,
int optLevel) int const optLevel)
{ {
DEBUGLOG(5, "ZSTD_rescaleFreqs (srcSize=%u)", (unsigned)srcSize);
optPtr->priceType = zop_dynamic; optPtr->priceType = zop_dynamic;
if (optPtr->litLengthSum == 0) { /* first block : init */ if (optPtr->litLengthSum == 0) { /* first block : init */
if (srcSize <= 1024) /* heuristic */ if (srcSize <= ZSTD_PREDEF_THRESHOLD) { /* heuristic */
DEBUGLOG(5, "(srcSize <= ZSTD_PREDEF_THRESHOLD) => zop_predef");
optPtr->priceType = zop_predef; optPtr->priceType = zop_predef;
}
assert(optPtr->symbolCosts != NULL); assert(optPtr->symbolCosts != NULL);
if (optPtr->symbolCosts->huf.repeatMode == HUF_repeat_valid) { /* huffman table presumed generated by dictionary */ if (optPtr->symbolCosts->huf.repeatMode == HUF_repeat_valid) {
/* huffman table presumed generated by dictionary */
optPtr->priceType = zop_dynamic; optPtr->priceType = zop_dynamic;
assert(optPtr->litFreq != NULL); assert(optPtr->litFreq != NULL);
optPtr->litSum = 0; optPtr->litSum = 0;
{ unsigned lit; { unsigned lit;
for (lit=0; lit<=MaxLit; lit++) { for (lit=0; lit<=MaxLit; lit++) {
U32 const scaleLog = 11; /* scale to 2K */ U32 const scaleLog = 11; /* scale to 2K */
U32 const bitCost = HUF_getNbBits(optPtr->symbolCosts->huf.CTable, lit); U32 const bitCost = HUF_getNbBits(optPtr->symbolCosts->huf.CTable, lit);
/* ZSTD_litLengthPrice() : /* ZSTD_litLengthPrice() :
* cost of literalLength symbol */ * cost of literalLength symbol */
static U32 ZSTD_litLengthPrice(U32 const litLength, const optState_t* const optPtr, int optLevel) static U32 ZSTD_litLengthPrice(U32 const litLength, const optState_t* const optPtr, int optLevel)
{ {
if (optPtr->priceType == zop_predef) return WEIGHT(litLength, optLevel); if (optPtr->priceType == zop_predef) return WEIGHT(litLength, optLevel);
/* dynamic statistics */ /* dynamic statistics */
{ U32 const llCode = ZSTD_LLcode(litLength); { U32 const llCode = ZSTD_LLcode(litLength);
return (LL_bits[llCode] * BITCOST_MULTIPLIER) + (optPtr->litLengthSumBasePrice - WEIGHT(optPtr->litLengthFreq[llCode], optLevel)); return (LL_bits[llCode] * BITCOST_MULTIPLIER)
+ optPtr->litLengthSumBasePrice
- WEIGHT(optPtr->litLengthFreq[llCode], optLevel);
} }
} }
/* ZSTD_litLengthContribution() : /* ZSTD_litLengthContribution() :
* @return ( cost(litlength) - cost(0) ) * @return ( cost(litlength) - cost(0) )
* this value can then be added to rawLiteralsCost() * this value can then be added to rawLiteralsCost()
* to provide a cost which is directly comparable to a match ending at same position */ * to provide a cost which is directly comparable to a match ending at same position */
static int ZSTD_litLengthContribution(U32 const litLength, const optState_t* const optPtr, int optLevel) static int ZSTD_litLengthContribution(U32 const litLength, const optState_t* const optPtr, int optLevel)
/* ZSTD_getMatchPrice() : /* ZSTD_getMatchPrice() :
* Provides the cost of the match part (offset + matchLength) of a sequence * Provides the cost of the match part (offset + matchLength) of a sequence
* Must be combined with ZSTD_fullLiteralsCost() to get the full cost of a sequence. * Must be combined with ZSTD_fullLiteralsCost() to get the full cost of a sequence.
* optLevel: when <2, favors small offset for decompression speed (improved cache efficiency) */ * optLevel: when <2, favors small offset for decompression speed (improved cache efficiency) */
FORCE_INLINE_TEMPLATE U32 FORCE_INLINE_TEMPLATE U32
ZSTD_getMatchPrice(U32 const offset, ZSTD_getMatchPrice(U32 const offset,
U32 const matchLength, U32 const matchLength,
const optState_t* const optPtr, const optState_t* const optPtr,
int const optLevel) int const optLevel)
{ {
U32 price; U32 price;
U32 const offCode = ZSTD_highbit32(offset+1); U32 const offCode = ZSTD_highbit32(offset+1);
U32 const mlBase = matchLength - MINMATCH; U32 const mlBase = matchLength - MINMATCH;
assert(matchLength >= MINMATCH); assert(matchLength >= MINMATCH);
if (optPtr->priceType == zop_predef) /* fixed scheme, do not use statistics */ if (optPtr->priceType == zop_predef) /* fixed scheme, do not use statistics */
const BYTE* const prefixStart = base + dictLimit; const BYTE* const prefixStart = base + dictLimit;
const BYTE* match; const BYTE* match;
const U32 current = (U32)(ip-base); const U32 current = (U32)(ip-base);
const U32 btLow = btMask >= current ? 0 : current - btMask; const U32 btLow = btMask >= current ? 0 : current - btMask;
U32* smallerPtr = bt + 2*(current&btMask); U32* smallerPtr = bt + 2*(current&btMask);
U32* largerPtr = smallerPtr + 1; U32* largerPtr = smallerPtr + 1;
U32 dummy32; /* to be nullified at the end */ U32 dummy32; /* to be nullified at the end */
U32 const windowLow = ms->window.lowLimit; U32 const windowLow = ms->window.lowLimit;
U32 const matchLow = windowLow ? windowLow : 1;
U32 matchEndIdx = current+8+1; U32 matchEndIdx = current+8+1;
size_t bestLength = 8; size_t bestLength = 8;
U32 nbCompares = 1U << cParams->searchLog; U32 nbCompares = 1U << cParams->searchLog;
#ifdef ZSTD_C_PREDICT #ifdef ZSTD_C_PREDICT
U32 predictedSmall = *(bt + 2*((current-1)&btMask) + 0); U32 predictedSmall = *(bt + 2*((current-1)&btMask) + 0);
U32 predictedLarge = *(bt + 2*((current-1)&btMask) + 1); U32 predictedLarge = *(bt + 2*((current-1)&btMask) + 1);
predictedSmall += (predictedSmall>0); predictedSmall += (predictedSmall>0);
predictedLarge += (predictedLarge>0); predictedLarge += (predictedLarge>0);
#endif /* ZSTD_C_PREDICT */ #endif /* ZSTD_C_PREDICT */
DEBUGLOG(8, "ZSTD_insertBt1 (%u)", current); DEBUGLOG(8, "ZSTD_insertBt1 (%u)", current);
assert(ip <= iend-8); /* required for h calculation */ assert(ip <= iend-8); /* required for h calculation */
hashTable[h] = current; /* Update Hash Table */ hashTable[h] = current; /* Update Hash Table */
while (nbCompares-- && (matchIndex >= matchLow)) { assert(windowLow > 0);
while (nbCompares-- && (matchIndex >= windowLow)) {
U32* const nextPtr = bt + 2*(matchIndex & btMask); U32* const nextPtr = bt + 2*(matchIndex & btMask);
size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */ size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */
assert(matchIndex < current); assert(matchIndex < current);
#ifdef ZSTD_C_PREDICT /* note : can create issues when hlog small <= 11 */ #ifdef ZSTD_C_PREDICT /* note : can create issues when hlog small <= 11 */
const U32* predictPtr = bt + 2*((matchIndex-1) & btMask); /* written this way, as bt is a roll buffer */ const U32* predictPtr = bt + 2*((matchIndex-1) & btMask); /* written this way, as bt is a roll buffer */
if (matchIndex == predictedSmall) { if (matchIndex == predictedSmall) {
/* no need to check length, result known */ /* no need to check length, result known */
void ZSTD_updateTree_internal( void ZSTD_updateTree_internal(
ZSTD_matchState_t* ms, ZSTD_matchState_t* ms,
const BYTE* const ip, const BYTE* const iend, const BYTE* const ip, const BYTE* const iend,
const U32 mls, const ZSTD_dictMode_e dictMode) const U32 mls, const ZSTD_dictMode_e dictMode)
{ {
const BYTE* const base = ms->window.base; const BYTE* const base = ms->window.base;
U32 const target = (U32)(ip - base); U32 const target = (U32)(ip - base);
U32 idx = ms->nextToUpdate; U32 idx = ms->nextToUpdate;
DEBUGLOG(5, "ZSTD_updateTree_internal, from %u to %u (dictMode:%u)", DEBUGLOG(6, "ZSTD_updateTree_internal, from %u to %u (dictMode:%u)",
idx, target, dictMode); idx, target, dictMode);
while(idx < target) while(idx < target)
idx += ZSTD_insertBt1(ms, base+idx, iend, mls, dictMode == ZSTD_extDict); idx += ZSTD_insertBt1(ms, base+idx, iend, mls, dictMode == ZSTD_extDict);
ms->nextToUpdate = target; ms->nextToUpdate = target;
} }
void ZSTD_updateTree(ZSTD_matchState_t* ms, const BYTE* ip, const BYTE* iend) { void ZSTD_updateTree(ZSTD_matchState_t* ms, const BYTE* ip, const BYTE* iend) {
ZSTD_updateTree_internal(ms, ip, iend, ms->cParams.searchLength, ZSTD_noDict); ZSTD_updateTree_internal(ms, ip, iend, ms->cParams.minMatch, ZSTD_noDict);
} }
FORCE_INLINE_TEMPLATE FORCE_INLINE_TEMPLATE
U32 ZSTD_insertBtAndGetAllMatches ( U32 ZSTD_insertBtAndGetAllMatches (
ZSTD_matchState_t* ms, ZSTD_matchState_t* ms,
const BYTE* const ip, const BYTE* const iLimit, const ZSTD_dictMode_e dictMode, const BYTE* const ip, const BYTE* const iLimit, const ZSTD_dictMode_e dictMode,
U32 rep[ZSTD_REP_NUM], U32 const ll0, U32 rep[ZSTD_REP_NUM],
ZSTD_match_t* matches, const U32 lengthToBeat, U32 const mls /* template */) U32 const ll0, /* tells if associated literal length is 0 or not. This value must be 0 or 1 */
ZSTD_match_t* matches,
const U32 lengthToBeat,
U32 const mls /* template */)
{ {
const ZSTD_compressionParameters* const cParams = &ms->cParams; const ZSTD_compressionParameters* const cParams = &ms->cParams;
U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1); U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1);
const BYTE* const base = ms->window.base; const BYTE* const base = ms->window.base;
U32 const current = (U32)(ip-base); U32 const current = (U32)(ip-base);
U32 const hashLog = cParams->hashLog; U32 const hashLog = cParams->hashLog;
U32 const minMatch = (mls==3) ? 3 : 4; U32 const minMatch = (mls==3) ? 3 : 4;
U32* const hashTable = ms->hashTable; U32* const hashTable = ms->hashTable;
U32 const dmsBtLog = dictMode == ZSTD_dictMatchState ? dmsCParams->chainLog - 1 : btLog; U32 const dmsBtLog = dictMode == ZSTD_dictMatchState ? dmsCParams->chainLog - 1 : btLog;
U32 const dmsBtMask = dictMode == ZSTD_dictMatchState ? (1U << dmsBtLog) - 1 : 0; U32 const dmsBtMask = dictMode == ZSTD_dictMatchState ? (1U << dmsBtLog) - 1 : 0;
U32 const dmsBtLow = dictMode == ZSTD_dictMatchState && dmsBtMask < dmsHighLimit - dmsLowLimit ? dmsHighLimit - dmsBtMask : dmsLowLimit; U32 const dmsBtLow = dictMode == ZSTD_dictMatchState && dmsBtMask < dmsHighLimit - dmsLowLimit ? dmsHighLimit - dmsBtMask : dmsLowLimit;
size_t bestLength = lengthToBeat-1; size_t bestLength = lengthToBeat-1;
DEBUGLOG(8, "ZSTD_insertBtAndGetAllMatches: current=%u", current); DEBUGLOG(8, "ZSTD_insertBtAndGetAllMatches: current=%u", current);
/* check repCode */ /* check repCode */
assert(ll0 <= 1); /* necessarily 1 or 0 */
{ U32 const lastR = ZSTD_REP_NUM + ll0; { U32 const lastR = ZSTD_REP_NUM + ll0;
U32 repCode; U32 repCode;
for (repCode = ll0; repCode < lastR; repCode++) { for (repCode = ll0; repCode < lastR; repCode++) {
U32 const repOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode]; U32 const repOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
U32 const repIndex = current - repOffset; U32 const repIndex = current - repOffset;
U32 repLen = 0; U32 repLen = 0;
assert(current >= dictLimit); assert(current >= dictLimit);
if (repOffset-1 /* intentional overflow, discards 0 and -1 */ < current-dictLimit) { /* equivalent to `current > repIndex >= dictLimit` */ if (repOffset-1 /* intentional overflow, discards 0 and -1 */ < current-dictLimit) { /* equivalent to `current > repIndex >= dictLimit` */
FORCE_INLINE_TEMPLATE U32 ZSTD_BtGetAllMatches ( FORCE_INLINE_TEMPLATE U32 ZSTD_BtGetAllMatches (
ZSTD_matchState_t* ms, ZSTD_matchState_t* ms,
const BYTE* ip, const BYTE* const iHighLimit, const ZSTD_dictMode_e dictMode, const BYTE* ip, const BYTE* const iHighLimit, const ZSTD_dictMode_e dictMode,
U32 rep[ZSTD_REP_NUM], U32 const ll0, U32 rep[ZSTD_REP_NUM], U32 const ll0,
ZSTD_match_t* matches, U32 const lengthToBeat) ZSTD_match_t* matches, U32 const lengthToBeat)
{ {
const ZSTD_compressionParameters* const cParams = &ms->cParams; const ZSTD_compressionParameters* const cParams = &ms->cParams;
U32 const matchLengthSearch = cParams->searchLength; U32 const matchLengthSearch = cParams->minMatch;
DEBUGLOG(8, "ZSTD_BtGetAllMatches"); DEBUGLOG(8, "ZSTD_BtGetAllMatches");
if (ip < ms->window.base + ms->nextToUpdate) return 0; /* skipped area */ if (ip < ms->window.base + ms->nextToUpdate) return 0; /* skipped area */
ZSTD_updateTree_internal(ms, ip, iHighLimit, matchLengthSearch, dictMode); ZSTD_updateTree_internal(ms, ip, iHighLimit, matchLengthSearch, dictMode);
switch(matchLengthSearch) switch(matchLengthSearch)
{ {
case 3 : return ZSTD_insertBtAndGetAllMatches(ms, ip, iHighLimit, dictMode, rep, ll0, matches, lengthToBeat, 3); case 3 : return ZSTD_insertBtAndGetAllMatches(ms, ip, iHighLimit, dictMode, rep, ll0, matches, lengthToBeat, 3);
default : default :
case 4 : return ZSTD_insertBtAndGetAllMatches(ms, ip, iHighLimit, dictMode, rep, ll0, matches, lengthToBeat, 4); case 4 : return ZSTD_insertBtAndGetAllMatches(ms, ip, iHighLimit, dictMode, rep, ll0, matches, lengthToBeat, 4);
} }
static U32 ZSTD_totalLen(ZSTD_optimal_t sol) static U32 ZSTD_totalLen(ZSTD_optimal_t sol)
{ {
return sol.litlen + sol.mlen; return sol.litlen + sol.mlen;
} }
#if 0 /* debug */
static void
listStats(const U32* table, int lastEltID)
{
int const nbElts = lastEltID + 1;
int enb;
for (enb=0; enb < nbElts; enb++) {
(void)table;
//RAWLOG(2, "%3i:%3i, ", enb, table[enb]);
RAWLOG(2, "%4i,", table[enb]);
}
RAWLOG(2, " \n");
}
#endif
FORCE_INLINE_TEMPLATE size_t FORCE_INLINE_TEMPLATE size_t
ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms, ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms,
seqStore_t* seqStore, seqStore_t* seqStore,
U32 rep[ZSTD_REP_NUM], U32 rep[ZSTD_REP_NUM],
const void* src, size_t srcSize, const void* src, size_t srcSize,
const int optLevel, const ZSTD_dictMode_e dictMode) const int optLevel,
const ZSTD_dictMode_e dictMode)
{ {
optState_t* const optStatePtr = &ms->opt; optState_t* const optStatePtr = &ms->opt;
const BYTE* const istart = (const BYTE*)src; const BYTE* const istart = (const BYTE*)src;
const BYTE* ip = istart; const BYTE* ip = istart;
const BYTE* anchor = istart; const BYTE* anchor = istart;
const BYTE* const iend = istart + srcSize; const BYTE* const iend = istart + srcSize;
const BYTE* const ilimit = iend - 8; const BYTE* const ilimit = iend - 8;
const BYTE* const base = ms->window.base; const BYTE* const base = ms->window.base;
const BYTE* const prefixStart = base + ms->window.dictLimit; const BYTE* const prefixStart = base + ms->window.dictLimit;
const ZSTD_compressionParameters* const cParams = &ms->cParams; const ZSTD_compressionParameters* const cParams = &ms->cParams;
U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1); U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1);
U32 const minMatch = (cParams->searchLength == 3) ? 3 : 4; U32 const minMatch = (cParams->minMatch == 3) ? 3 : 4;
ZSTD_optimal_t* const opt = optStatePtr->priceTable; ZSTD_optimal_t* const opt = optStatePtr->priceTable;
ZSTD_match_t* const matches = optStatePtr->matchTable; ZSTD_match_t* const matches = optStatePtr->matchTable;
ZSTD_optimal_t lastSequence; ZSTD_optimal_t lastSequence;
/* init */ /* init */
DEBUGLOG(5, "ZSTD_compressBlock_opt_generic"); DEBUGLOG(5, "ZSTD_compressBlock_opt_generic: current=%u, prefix=%u, nextToUpdate=%u",
(U32)(ip - base), ms->window.dictLimit, ms->nextToUpdate);
assert(optLevel <= 2); assert(optLevel <= 2);
ms->nextToUpdate3 = ms->nextToUpdate; ms->nextToUpdate3 = ms->nextToUpdate;
ZSTD_rescaleFreqs(optStatePtr, (const BYTE*)src, srcSize, optLevel); ZSTD_rescaleFreqs(optStatePtr, (const BYTE*)src, srcSize, optLevel);
ip += (ip==prefixStart); ip += (ip==prefixStart);
/* Match Loop */ /* Match Loop */
while (ip < ilimit) { while (ip < ilimit) {
U32 cur, last_pos = 0; U32 cur, last_pos = 0;
DEBUGLOG(6, "sending selected sequences into seqStore") DEBUGLOG(6, "sending selected sequences into seqStore")
{ U32 storePos; { U32 storePos;
for (storePos=storeStart; storePos <= storeEnd; storePos++) { for (storePos=storeStart; storePos <= storeEnd; storePos++) {
U32 const llen = opt[storePos].litlen; U32 const llen = opt[storePos].litlen;
U32 const mlen = opt[storePos].mlen; U32 const mlen = opt[storePos].mlen;
U32 const offCode = opt[storePos].off; U32 const offCode = opt[storePos].off;
U32 const advance = llen + mlen; U32 const advance = llen + mlen;
DEBUGLOG(6, "considering seq starting at %zi, llen=%u, mlen=%u", DEBUGLOG(6, "considering seq starting at %zi, llen=%u, mlen=%u",
anchor - istart, llen, mlen); anchor - istart, (unsigned)llen, (unsigned)mlen);
if (mlen==0) { /* only literals => must be last "sequence", actually starting a new stream of sequences */ if (mlen==0) { /* only literals => must be last "sequence", actually starting a new stream of sequences */
assert(storePos == storeEnd); /* must be last sequence */ assert(storePos == storeEnd); /* must be last sequence */
ip = anchor + llen; /* last "sequence" is a bunch of literals => don't progress anchor */ ip = anchor + llen; /* last "sequence" is a bunch of literals => don't progress anchor */
continue; /* will finish */ continue; /* will finish */
} }
/* repcodes update : like ZSTD_updateRep(), but update in place */ /* repcodes update : like ZSTD_updateRep(), but update in place */
const void* src, size_t srcSize) const void* src, size_t srcSize)
{ {
DEBUGLOG(5, "ZSTD_compressBlock_btopt"); DEBUGLOG(5, "ZSTD_compressBlock_btopt");
return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 0 /*optLevel*/, ZSTD_noDict); return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 0 /*optLevel*/, ZSTD_noDict);
} }
/* used in 2-pass strategy */ /* used in 2-pass strategy */
static U32 ZSTD_upscaleStat(U32* table, U32 lastEltIndex, int bonus) static U32 ZSTD_upscaleStat(unsigned* table, U32 lastEltIndex, int bonus)
{ {
U32 s, sum=0; U32 s, sum=0;
assert(ZSTD_FREQ_DIV+bonus > 0); assert(ZSTD_FREQ_DIV+bonus >= 0);
for (s=0; s<=lastEltIndex; s++) { for (s=0; s<lastEltIndex+1; s++) {
table[s] <<= ZSTD_FREQ_DIV+bonus; table[s] <<= ZSTD_FREQ_DIV+bonus;
table[s]--; table[s]--;
sum += table[s]; sum += table[s];
} }
return sum; return sum;
} }
/* used in 2-pass strategy */ /* used in 2-pass strategy */
MEM_STATIC void ZSTD_upscaleStats(optState_t* optPtr) MEM_STATIC void ZSTD_upscaleStats(optState_t* optPtr)
{ {
optPtr->litSum = ZSTD_upscaleStat(optPtr->litFreq, MaxLit, 0); optPtr->litSum = ZSTD_upscaleStat(optPtr->litFreq, MaxLit, 0);
optPtr->litLengthSum = ZSTD_upscaleStat(optPtr->litLengthFreq, MaxLL, 1); optPtr->litLengthSum = ZSTD_upscaleStat(optPtr->litLengthFreq, MaxLL, 0);
optPtr->matchLengthSum = ZSTD_upscaleStat(optPtr->matchLengthFreq, MaxML, 1); optPtr->matchLengthSum = ZSTD_upscaleStat(optPtr->matchLengthFreq, MaxML, 0);
optPtr->offCodeSum = ZSTD_upscaleStat(optPtr->offCodeFreq, MaxOff, 1); optPtr->offCodeSum = ZSTD_upscaleStat(optPtr->offCodeFreq, MaxOff, 0);
} }
size_t ZSTD_compressBlock_btultra( /* ZSTD_initStats_ultra():
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], * make a first compression pass, just to seed stats with more accurate starting values.
* only works on first block, with no dictionary and no ldm.
* this function cannot error, hence its constract must be respected.
*/
static void
ZSTD_initStats_ultra(ZSTD_matchState_t* ms,
seqStore_t* seqStore,
U32 rep[ZSTD_REP_NUM],
const void* src, size_t srcSize) const void* src, size_t srcSize)
{ {
DEBUGLOG(5, "ZSTD_compressBlock_btultra (srcSize=%zu)", srcSize); U32 tmpRep[ZSTD_REP_NUM]; /* updated rep codes will sink here */
#if 0
/* 2-pass strategy (disabled)
* this strategy makes a first pass over first block to collect statistics
* and seed next round's statistics with it.
* The compression ratio gain is generally small (~0.5% on first block),
* the cost is 2x cpu time on first block. */
assert(srcSize <= ZSTD_BLOCKSIZE_MAX);
if ( (ms->opt.litLengthSum==0) /* first block */
&& (seqStore->sequences == seqStore->sequencesStart) /* no ldm */
&& (ms->window.dictLimit == ms->window.lowLimit) ) { /* no dictionary */
U32 tmpRep[ZSTD_REP_NUM];
DEBUGLOG(5, "ZSTD_compressBlock_btultra: first block: collecting statistics");
assert(ms->nextToUpdate >= ms->window.dictLimit
&& ms->nextToUpdate <= ms->window.dictLimit + 1);
memcpy(tmpRep, rep, sizeof(tmpRep)); memcpy(tmpRep, rep, sizeof(tmpRep));
DEBUGLOG(4, "ZSTD_initStats_ultra (srcSize=%zu)", srcSize);
assert(ms->opt.litLengthSum == 0); /* first block */
assert(seqStore->sequences == seqStore->sequencesStart); /* no ldm */
assert(ms->window.dictLimit == ms->window.lowLimit); /* no dictionary */
assert(ms->window.dictLimit - ms->nextToUpdate <= 1); /* no prefix (note: intentional overflow, defined as 2-complement) */
ZSTD_compressBlock_opt_generic(ms, seqStore, tmpRep, src, srcSize, 2 /*optLevel*/, ZSTD_noDict); /* generate stats into ms->opt*/ ZSTD_compressBlock_opt_generic(ms, seqStore, tmpRep, src, srcSize, 2 /*optLevel*/, ZSTD_noDict); /* generate stats into ms->opt*/
ZSTD_resetSeqStore(seqStore);
/* invalidate first scan from history */ /* invalidate first scan from history */
ZSTD_resetSeqStore(seqStore);
ms->window.base -= srcSize; ms->window.base -= srcSize;
ms->window.dictLimit += (U32)srcSize; ms->window.dictLimit += (U32)srcSize;
ms->window.lowLimit = ms->window.dictLimit; ms->window.lowLimit = ms->window.dictLimit;
ms->nextToUpdate = ms->window.dictLimit; ms->nextToUpdate = ms->window.dictLimit;
ms->nextToUpdate3 = ms->window.dictLimit; ms->nextToUpdate3 = ms->window.dictLimit;
/* re-inforce weight of collected statistics */ /* re-inforce weight of collected statistics */
ZSTD_upscaleStats(&ms->opt); ZSTD_upscaleStats(&ms->opt);
} }
#endif
size_t ZSTD_compressBlock_btultra(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
const void* src, size_t srcSize)
{
DEBUGLOG(5, "ZSTD_compressBlock_btultra (srcSize=%zu)", srcSize);
return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 2 /*optLevel*/, ZSTD_noDict);
}
size_t ZSTD_compressBlock_btultra2(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
const void* src, size_t srcSize)
{
U32 const current = (U32)((const BYTE*)src - ms->window.base);
DEBUGLOG(5, "ZSTD_compressBlock_btultra2 (srcSize=%zu)", srcSize);
/* 2-pass strategy:
* this strategy makes a first pass over first block to collect statistics
* and seed next round's statistics with it.
* After 1st pass, function forgets everything, and starts a new block.
* Consequently, this can only work if no data has been previously loaded in tables,
* aka, no dictionary, no prefix, no ldm preprocessing.
* The compression ratio gain is generally small (~0.5% on first block),
* the cost is 2x cpu time on first block. */
assert(srcSize <= ZSTD_BLOCKSIZE_MAX);
if ( (ms->opt.litLengthSum==0) /* first block */
&& (seqStore->sequences == seqStore->sequencesStart) /* no ldm */
&& (ms->window.dictLimit == ms->window.lowLimit) /* no dictionary */
&& (current == ms->window.dictLimit) /* start of frame, nothing already loaded nor skipped */
&& (srcSize > ZSTD_PREDEF_THRESHOLD)
) {
ZSTD_initStats_ultra(ms, seqStore, rep, src, srcSize);
}
return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 2 /*optLevel*/, ZSTD_noDict); return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 2 /*optLevel*/, ZSTD_noDict);
} }
size_t ZSTD_compressBlock_btopt_dictMatchState( size_t ZSTD_compressBlock_btopt_dictMatchState(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
const void* src, size_t srcSize) const void* src, size_t srcSize)
{ {
return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 0 /*optLevel*/, ZSTD_dictMatchState); return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 0 /*optLevel*/, ZSTD_dictMatchState);
} }
size_t ZSTD_compressBlock_btultra_extDict( size_t ZSTD_compressBlock_btultra_extDict(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
const void* src, size_t srcSize) const void* src, size_t srcSize)
{ {
return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 2 /*optLevel*/, ZSTD_extDict); return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 2 /*optLevel*/, ZSTD_extDict);
} }
/* note : no btultra2 variant for extDict nor dictMatchState,
* because btultra2 is not meant to work with dictionaries
* and is only specific for the first block (no prefix) */

contrib/python-zstandard/zstd/compress/zstdmt_compress.h

* These methods will stop being exposed in a future version */ * These methods will stop being exposed in a future version */
/* === Dependencies === */ /* === Dependencies === */
#include <stddef.h> /* size_t */ #include <stddef.h> /* size_t */
#define ZSTD_STATIC_LINKING_ONLY /* ZSTD_parameters */ #define ZSTD_STATIC_LINKING_ONLY /* ZSTD_parameters */
#include "zstd.h" /* ZSTD_inBuffer, ZSTD_outBuffer, ZSTDLIB_API */ #include "zstd.h" /* ZSTD_inBuffer, ZSTD_outBuffer, ZSTDLIB_API */
/* === Constants === */
#ifndef ZSTDMT_NBWORKERS_MAX
# define ZSTDMT_NBWORKERS_MAX 200
#endif
#ifndef ZSTDMT_JOBSIZE_MIN
# define ZSTDMT_JOBSIZE_MIN (1 MB)
#endif
#define ZSTDMT_JOBSIZE_MAX (MEM_32bits() ? (512 MB) : (1024 MB))
/* === Memory management === */ /* === Memory management === */
typedef struct ZSTDMT_CCtx_s ZSTDMT_CCtx; typedef struct ZSTDMT_CCtx_s ZSTDMT_CCtx;
ZSTDLIB_API ZSTDMT_CCtx* ZSTDMT_createCCtx(unsigned nbWorkers); ZSTDLIB_API ZSTDMT_CCtx* ZSTDMT_createCCtx(unsigned nbWorkers);
ZSTDLIB_API ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbWorkers, ZSTDLIB_API ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbWorkers,
ZSTD_customMem cMem); ZSTD_customMem cMem);
ZSTDLIB_API size_t ZSTDMT_freeCCtx(ZSTDMT_CCtx* mtctx); ZSTDLIB_API size_t ZSTDMT_freeCCtx(ZSTDMT_CCtx* mtctx);
ZSTDLIB_API size_t ZSTDMT_sizeof_CCtx(ZSTDMT_CCtx* mtctx); ZSTDLIB_API size_t ZSTDMT_sizeof_CCtx(ZSTDMT_CCtx* mtctx);
/* === Simple one-pass compression function === */ /* === Simple one-pass compression function === */
ZSTDLIB_API size_t ZSTDMT_compressCCtx(ZSTDMT_CCtx* mtctx, ZSTDLIB_API size_t ZSTDMT_compressCCtx(ZSTDMT_CCtx* mtctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const void* src, size_t srcSize,
int compressionLevel); int compressionLevel);
/* === Streaming functions === */ /* === Streaming functions === */
ZSTDLIB_API size_t ZSTDMT_initCStream(ZSTDMT_CCtx* mtctx, int compressionLevel); ZSTDLIB_API size_t ZSTDMT_initCStream(ZSTDMT_CCtx* mtctx, int compressionLevel);
ZSTDLIB_API size_t ZSTDMT_resetCStream(ZSTDMT_CCtx* mtctx, unsigned long long pledgedSrcSize); /**< if srcSize is not known at reset time, use ZSTD_CONTENTSIZE_UNKNOWN. Note: for compatibility with older programs, 0 means the same as ZSTD_CONTENTSIZE_UNKNOWN, but it will change in the future to mean "empty" */ ZSTDLIB_API size_t ZSTDMT_resetCStream(ZSTDMT_CCtx* mtctx, unsigned long long pledgedSrcSize); /**< if srcSize is not known at reset time, use ZSTD_CONTENTSIZE_UNKNOWN. Note: for compatibility with older programs, 0 means the same as ZSTD_CONTENTSIZE_UNKNOWN, but it will change in the future to mean "empty" */
ZSTDLIB_API size_t ZSTDMT_nextInputSizeHint(const ZSTDMT_CCtx* mtctx);
ZSTDLIB_API size_t ZSTDMT_compressStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output, ZSTD_inBuffer* input); ZSTDLIB_API size_t ZSTDMT_compressStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
ZSTDLIB_API size_t ZSTDMT_flushStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output); /**< @return : 0 == all flushed; >0 : still some data to be flushed; or an error code (ZSTD_isError()) */ ZSTDLIB_API size_t ZSTDMT_flushStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output); /**< @return : 0 == all flushed; >0 : still some data to be flushed; or an error code (ZSTD_isError()) */
ZSTDLIB_API size_t ZSTDMT_endStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output); /**< @return : 0 == all flushed; >0 : still some data to be flushed; or an error code (ZSTD_isError()) */ ZSTDLIB_API size_t ZSTDMT_endStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output); /**< @return : 0 == all flushed; >0 : still some data to be flushed; or an error code (ZSTD_isError()) */
/* === Advanced functions and parameters === */ /* === Advanced functions and parameters === */
#ifndef ZSTDMT_JOBSIZE_MIN
# define ZSTDMT_JOBSIZE_MIN (1U << 20) /* 1 MB - Minimum size of each compression job */
#endif
ZSTDLIB_API size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx, ZSTDLIB_API size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const void* src, size_t srcSize,
const ZSTD_CDict* cdict, const ZSTD_CDict* cdict,
ZSTD_parameters params, ZSTD_parameters params,
unsigned overlapLog); int overlapLog);
ZSTDLIB_API size_t ZSTDMT_initCStream_advanced(ZSTDMT_CCtx* mtctx, ZSTDLIB_API size_t ZSTDMT_initCStream_advanced(ZSTDMT_CCtx* mtctx,
const void* dict, size_t dictSize, /* dict can be released after init, a local copy is preserved within zcs */ const void* dict, size_t dictSize, /* dict can be released after init, a local copy is preserved within zcs */
ZSTD_parameters params, ZSTD_parameters params,
unsigned long long pledgedSrcSize); /* pledgedSrcSize is optional and can be zero == unknown */ unsigned long long pledgedSrcSize); /* pledgedSrcSize is optional and can be zero == unknown */
ZSTDLIB_API size_t ZSTDMT_initCStream_usingCDict(ZSTDMT_CCtx* mtctx, ZSTDLIB_API size_t ZSTDMT_initCStream_usingCDict(ZSTDMT_CCtx* mtctx,
const ZSTD_CDict* cdict, const ZSTD_CDict* cdict,
ZSTD_frameParameters fparams, ZSTD_frameParameters fparams,
unsigned long long pledgedSrcSize); /* note : zero means empty */ unsigned long long pledgedSrcSize); /* note : zero means empty */
/* ZSTDMT_parameter : /* ZSTDMT_parameter :
* List of parameters that can be set using ZSTDMT_setMTCtxParameter() */ * List of parameters that can be set using ZSTDMT_setMTCtxParameter() */
typedef enum { typedef enum {
ZSTDMT_p_jobSize, /* Each job is compressed in parallel. By default, this value is dynamically determined depending on compression parameters. Can be set explicitly here. */ ZSTDMT_p_jobSize, /* Each job is compressed in parallel. By default, this value is dynamically determined depending on compression parameters. Can be set explicitly here. */
ZSTDMT_p_overlapSectionLog /* Each job may reload a part of previous job to enhance compressionr ratio; 0 == no overlap, 6(default) == use 1/8th of window, >=9 == use full window. This is a "sticky" parameter : its value will be re-used on next compression job */ ZSTDMT_p_overlapLog, /* Each job may reload a part of previous job to enhance compressionr ratio; 0 == no overlap, 6(default) == use 1/8th of window, >=9 == use full window. This is a "sticky" parameter : its value will be re-used on next compression job */
ZSTDMT_p_rsyncable /* Enables rsyncable mode. */
} ZSTDMT_parameter; } ZSTDMT_parameter;
/* ZSTDMT_setMTCtxParameter() : /* ZSTDMT_setMTCtxParameter() :
* allow setting individual parameters, one at a time, among a list of enums defined in ZSTDMT_parameter. * allow setting individual parameters, one at a time, among a list of enums defined in ZSTDMT_parameter.
* The function must be called typically after ZSTD_createCCtx() but __before ZSTDMT_init*() !__ * The function must be called typically after ZSTD_createCCtx() but __before ZSTDMT_init*() !__
* Parameters not explicitly reset by ZSTDMT_init*() remain the same in consecutive compression sessions. * Parameters not explicitly reset by ZSTDMT_init*() remain the same in consecutive compression sessions.
* @return : 0, or an error code (which can be tested using ZSTD_isError()) */ * @return : 0, or an error code (which can be tested using ZSTD_isError()) */
ZSTDLIB_API size_t ZSTDMT_setMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSTDMT_parameter parameter, unsigned value); ZSTDLIB_API size_t ZSTDMT_setMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSTDMT_parameter parameter, int value);
/* ZSTDMT_getMTCtxParameter() : /* ZSTDMT_getMTCtxParameter() :
* Query the ZSTDMT_CCtx for a parameter value. * Query the ZSTDMT_CCtx for a parameter value.
* @return : 0, or an error code (which can be tested using ZSTD_isError()) */ * @return : 0, or an error code (which can be tested using ZSTD_isError()) */
ZSTDLIB_API size_t ZSTDMT_getMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSTDMT_parameter parameter, unsigned* value); ZSTDLIB_API size_t ZSTDMT_getMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSTDMT_parameter parameter, int* value);
/*! ZSTDMT_compressStream_generic() : /*! ZSTDMT_compressStream_generic() :
* Combines ZSTDMT_compressStream() with optional ZSTDMT_flushStream() or ZSTDMT_endStream() * Combines ZSTDMT_compressStream() with optional ZSTDMT_flushStream() or ZSTDMT_endStream()
* depending on flush directive. * depending on flush directive.
* @return : minimum amount of data still to be flushed * @return : minimum amount of data still to be flushed
* 0 if fully flushed * 0 if fully flushed
* or an error code * or an error code
* Probe the oldest active job (not yet entirely flushed) and check its output buffer. * Probe the oldest active job (not yet entirely flushed) and check its output buffer.
* If return 0, it means there is no active job, * If return 0, it means there is no active job,
* or, it means oldest job is still active, but everything produced has been flushed so far, * or, it means oldest job is still active, but everything produced has been flushed so far,
* therefore flushing is limited by speed of oldest job. */ * therefore flushing is limited by speed of oldest job. */
size_t ZSTDMT_toFlushNow(ZSTDMT_CCtx* mtctx); size_t ZSTDMT_toFlushNow(ZSTDMT_CCtx* mtctx);
/*! ZSTDMT_CCtxParam_setMTCtxParameter() /*! ZSTDMT_CCtxParam_setMTCtxParameter()
* like ZSTDMT_setMTCtxParameter(), but into a ZSTD_CCtx_Params */ * like ZSTDMT_setMTCtxParameter(), but into a ZSTD_CCtx_Params */
size_t ZSTDMT_CCtxParam_setMTCtxParameter(ZSTD_CCtx_params* params, ZSTDMT_parameter parameter, unsigned value); size_t ZSTDMT_CCtxParam_setMTCtxParameter(ZSTD_CCtx_params* params, ZSTDMT_parameter parameter, int value);
/*! ZSTDMT_CCtxParam_setNbWorkers() /*! ZSTDMT_CCtxParam_setNbWorkers()
* Set nbWorkers, and clamp it. * Set nbWorkers, and clamp it.
* Also reset jobSize and overlapLog */ * Also reset jobSize and overlapLog */
size_t ZSTDMT_CCtxParam_setNbWorkers(ZSTD_CCtx_params* params, unsigned nbWorkers); size_t ZSTDMT_CCtxParam_setNbWorkers(ZSTD_CCtx_params* params, unsigned nbWorkers);
/*! ZSTDMT_updateCParams_whileCompressing() : /*! ZSTDMT_updateCParams_whileCompressing() :
* Updates only a selected set of compression parameters, to remain compatible with current frame. * Updates only a selected set of compression parameters, to remain compatible with current frame.

contrib/python-zstandard/zstd/compress/zstdmt_compress.c

/* /*
* Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
* All rights reserved. * All rights reserved.
* *
* This source code is licensed under both the BSD-style license (found in the * 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 * 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). * in the COPYING file in the root directory of this source tree).
* You may select, at your option, one of the above-listed licenses. * You may select, at your option, one of the above-listed licenses.
*/ */
/* ====== Tuning parameters ====== */
#define ZSTDMT_NBWORKERS_MAX 200
#define ZSTDMT_JOBSIZE_MAX (MEM_32bits() ? (512 MB) : (2 GB)) /* note : limited by `jobSize` type, which is `unsigned` */
#define ZSTDMT_OVERLAPLOG_DEFAULT 6
/* ====== Compiler specifics ====== */ /* ====== Compiler specifics ====== */
#if defined(_MSC_VER) #if defined(_MSC_VER)
# pragma warning(disable : 4204) /* disable: C4204: non-constant aggregate initializer */ # pragma warning(disable : 4204) /* disable: C4204: non-constant aggregate initializer */
#endif #endif
/* ====== Constants ====== */
#define ZSTDMT_OVERLAPLOG_DEFAULT 0
/* ====== Dependencies ====== */ /* ====== Dependencies ====== */
#include <string.h> /* memcpy, memset */ #include <string.h> /* memcpy, memset */
#include <limits.h> /* INT_MAX */ #include <limits.h> /* INT_MAX, UINT_MAX */
#include "pool.h" /* threadpool */ #include "pool.h" /* threadpool */
#include "threading.h" /* mutex */ #include "threading.h" /* mutex */
#include "zstd_compress_internal.h" /* MIN, ERROR, ZSTD_*, ZSTD_highbit32 */ #include "zstd_compress_internal.h" /* MIN, ERROR, ZSTD_*, ZSTD_highbit32 */
#include "zstd_ldm.h" #include "zstd_ldm.h"
#include "zstdmt_compress.h" #include "zstdmt_compress.h"
/* Guards code to support resizing the SeqPool. /* Guards code to support resizing the SeqPool.
* We will want to resize the SeqPool to save memory in the future. * We will want to resize the SeqPool to save memory in the future.
RAWLOG(l, " \n"); \ RAWLOG(l, " \n"); \
} }
static unsigned long long GetCurrentClockTimeMicroseconds(void) static unsigned long long GetCurrentClockTimeMicroseconds(void)
{ {
static clock_t _ticksPerSecond = 0; static clock_t _ticksPerSecond = 0;
if (_ticksPerSecond <= 0) _ticksPerSecond = sysconf(_SC_CLK_TCK); if (_ticksPerSecond <= 0) _ticksPerSecond = sysconf(_SC_CLK_TCK);
{ struct tms junk; clock_t newTicks = (clock_t) times(&junk); { struct tms junk; clock_t newTicks = (clock_t) times(&junk);
return ((((unsigned long long)newTicks)*(1000000))/_ticksPerSecond); } return ((((unsigned long long)newTicks)*(1000000))/_ticksPerSecond);
} } }
#define MUTEX_WAIT_TIME_DLEVEL 6 #define MUTEX_WAIT_TIME_DLEVEL 6
#define ZSTD_PTHREAD_MUTEX_LOCK(mutex) { \ #define ZSTD_PTHREAD_MUTEX_LOCK(mutex) { \
if (DEBUGLEVEL >= MUTEX_WAIT_TIME_DLEVEL) { \ if (DEBUGLEVEL >= MUTEX_WAIT_TIME_DLEVEL) { \
unsigned long long const beforeTime = GetCurrentClockTimeMicroseconds(); \ unsigned long long const beforeTime = GetCurrentClockTimeMicroseconds(); \
ZSTD_pthread_mutex_lock(mutex); \ ZSTD_pthread_mutex_lock(mutex); \
{ unsigned long long const afterTime = GetCurrentClockTimeMicroseconds(); \ { unsigned long long const afterTime = GetCurrentClockTimeMicroseconds(); \
unsigned long long const elapsedTime = (afterTime-beforeTime); \ unsigned long long const elapsedTime = (afterTime-beforeTime); \
} }
/* ===== CCtx Pool ===== */ /* ===== CCtx Pool ===== */
/* a single CCtx Pool can be invoked from multiple threads in parallel */ /* a single CCtx Pool can be invoked from multiple threads in parallel */
typedef struct { typedef struct {
ZSTD_pthread_mutex_t poolMutex; ZSTD_pthread_mutex_t poolMutex;
unsigned totalCCtx; int totalCCtx;
unsigned availCCtx; int availCCtx;
ZSTD_customMem cMem; ZSTD_customMem cMem;
ZSTD_CCtx* cctx[1]; /* variable size */ ZSTD_CCtx* cctx[1]; /* variable size */
} ZSTDMT_CCtxPool; } ZSTDMT_CCtxPool;
/* note : all CCtx borrowed from the pool should be released back to the pool _before_ freeing the pool */ /* note : all CCtx borrowed from the pool should be released back to the pool _before_ freeing the pool */
static void ZSTDMT_freeCCtxPool(ZSTDMT_CCtxPool* pool) static void ZSTDMT_freeCCtxPool(ZSTDMT_CCtxPool* pool)
{ {
unsigned u; int cid;
for (u=0; u<pool->totalCCtx; u++) for (cid=0; cid<pool->totalCCtx; cid++)
ZSTD_freeCCtx(pool->cctx[u]); /* note : compatible with free on NULL */ ZSTD_freeCCtx(pool->cctx[cid]); /* note : compatible with free on NULL */
ZSTD_pthread_mutex_destroy(&pool->poolMutex); ZSTD_pthread_mutex_destroy(&pool->poolMutex);
ZSTD_free(pool, pool->cMem); ZSTD_free(pool, pool->cMem);
} }
/* ZSTDMT_createCCtxPool() : /* ZSTDMT_createCCtxPool() :
* implies nbWorkers >= 1 , checked by caller ZSTDMT_createCCtx() */ * implies nbWorkers >= 1 , checked by caller ZSTDMT_createCCtx() */
static ZSTDMT_CCtxPool* ZSTDMT_createCCtxPool(unsigned nbWorkers, static ZSTDMT_CCtxPool* ZSTDMT_createCCtxPool(int nbWorkers,
ZSTD_customMem cMem) ZSTD_customMem cMem)
{ {
ZSTDMT_CCtxPool* const cctxPool = (ZSTDMT_CCtxPool*) ZSTD_calloc( ZSTDMT_CCtxPool* const cctxPool = (ZSTDMT_CCtxPool*) ZSTD_calloc(
sizeof(ZSTDMT_CCtxPool) + (nbWorkers-1)*sizeof(ZSTD_CCtx*), cMem); sizeof(ZSTDMT_CCtxPool) + (nbWorkers-1)*sizeof(ZSTD_CCtx*), cMem);
assert(nbWorkers > 0); assert(nbWorkers > 0);
if (!cctxPool) return NULL; if (!cctxPool) return NULL;
if (ZSTD_pthread_mutex_init(&cctxPool->poolMutex, NULL)) { if (ZSTD_pthread_mutex_init(&cctxPool->poolMutex, NULL)) {
ZSTD_free(cctxPool, cMem); ZSTD_free(cctxPool, cMem);
return NULL; return NULL;
} }
cctxPool->cMem = cMem; cctxPool->cMem = cMem;
cctxPool->totalCCtx = nbWorkers; cctxPool->totalCCtx = nbWorkers;
cctxPool->availCCtx = 1; /* at least one cctx for single-thread mode */ cctxPool->availCCtx = 1; /* at least one cctx for single-thread mode */
cctxPool->cctx[0] = ZSTD_createCCtx_advanced(cMem); cctxPool->cctx[0] = ZSTD_createCCtx_advanced(cMem);
if (!cctxPool->cctx[0]) { ZSTDMT_freeCCtxPool(cctxPool); return NULL; } if (!cctxPool->cctx[0]) { ZSTDMT_freeCCtxPool(cctxPool); return NULL; }
DEBUGLOG(3, "cctxPool created, with %u workers", nbWorkers); DEBUGLOG(3, "cctxPool created, with %u workers", nbWorkers);
return cctxPool; return cctxPool;
} }
static ZSTDMT_CCtxPool* ZSTDMT_expandCCtxPool(ZSTDMT_CCtxPool* srcPool, static ZSTDMT_CCtxPool* ZSTDMT_expandCCtxPool(ZSTDMT_CCtxPool* srcPool,
unsigned nbWorkers) int nbWorkers)
{ {
if (srcPool==NULL) return NULL; if (srcPool==NULL) return NULL;
if (nbWorkers <= srcPool->totalCCtx) return srcPool; /* good enough */ if (nbWorkers <= srcPool->totalCCtx) return srcPool; /* good enough */
/* need a larger cctx pool */ /* need a larger cctx pool */
{ ZSTD_customMem const cMem = srcPool->cMem; { ZSTD_customMem const cMem = srcPool->cMem;
ZSTDMT_freeCCtxPool(srcPool); ZSTDMT_freeCCtxPool(srcPool);
return ZSTDMT_createCCtxPool(nbWorkers, cMem); return ZSTDMT_createCCtxPool(nbWorkers, cMem);
} }
static int ZSTDMT_serialState_reset(serialState_t* serialState, ZSTDMT_seqPool* seqPool, ZSTD_CCtx_params params, size_t jobSize) static int ZSTDMT_serialState_reset(serialState_t* serialState, ZSTDMT_seqPool* seqPool, ZSTD_CCtx_params params, size_t jobSize)
{ {
/* Adjust parameters */ /* Adjust parameters */
if (params.ldmParams.enableLdm) { if (params.ldmParams.enableLdm) {
DEBUGLOG(4, "LDM window size = %u KB", (1U << params.cParams.windowLog) >> 10); DEBUGLOG(4, "LDM window size = %u KB", (1U << params.cParams.windowLog) >> 10);
ZSTD_ldm_adjustParameters(&params.ldmParams, &params.cParams); ZSTD_ldm_adjustParameters(&params.ldmParams, &params.cParams);
assert(params.ldmParams.hashLog >= params.ldmParams.bucketSizeLog); assert(params.ldmParams.hashLog >= params.ldmParams.bucketSizeLog);
assert(params.ldmParams.hashEveryLog < 32); assert(params.ldmParams.hashRateLog < 32);
serialState->ldmState.hashPower = serialState->ldmState.hashPower =
ZSTD_ldm_getHashPower(params.ldmParams.minMatchLength); ZSTD_rollingHash_primePower(params.ldmParams.minMatchLength);
} else { } else {
memset(&params.ldmParams, 0, sizeof(params.ldmParams)); memset(&params.ldmParams, 0, sizeof(params.ldmParams));
} }
serialState->nextJobID = 0; serialState->nextJobID = 0;
if (params.fParams.checksumFlag) if (params.fParams.checksumFlag)
XXH64_reset(&serialState->xxhState, 0); XXH64_reset(&serialState->xxhState, 0);
if (params.ldmParams.enableLdm) { if (params.ldmParams.enableLdm) {
ZSTD_customMem cMem = params.customMem; ZSTD_customMem cMem = params.customMem;
/* init */ /* init */
if (job->cdict) { if (job->cdict) {
size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, NULL, 0, ZSTD_dct_auto, ZSTD_dtlm_fast, job->cdict, jobParams, job->fullFrameSize); size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, NULL, 0, ZSTD_dct_auto, ZSTD_dtlm_fast, job->cdict, jobParams, job->fullFrameSize);
assert(job->firstJob); /* only allowed for first job */ assert(job->firstJob); /* only allowed for first job */
if (ZSTD_isError(initError)) JOB_ERROR(initError); if (ZSTD_isError(initError)) JOB_ERROR(initError);
} else { /* srcStart points at reloaded section */ } else { /* srcStart points at reloaded section */
U64 const pledgedSrcSize = job->firstJob ? job->fullFrameSize : job->src.size; U64 const pledgedSrcSize = job->firstJob ? job->fullFrameSize : job->src.size;
{ size_t const forceWindowError = ZSTD_CCtxParam_setParameter(&jobParams, ZSTD_p_forceMaxWindow, !job->firstJob); { size_t const forceWindowError = ZSTD_CCtxParam_setParameter(&jobParams, ZSTD_c_forceMaxWindow, !job->firstJob);
if (ZSTD_isError(forceWindowError)) JOB_ERROR(forceWindowError); if (ZSTD_isError(forceWindowError)) JOB_ERROR(forceWindowError);
} }
{ size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, { size_t const initError = ZSTD_compressBegin_advanced_internal(cctx,
job->prefix.start, job->prefix.size, ZSTD_dct_rawContent, /* load dictionary in "content-only" mode (no header analysis) */ job->prefix.start, job->prefix.size, ZSTD_dct_rawContent, /* load dictionary in "content-only" mode (no header analysis) */
ZSTD_dtlm_fast, ZSTD_dtlm_fast,
NULL, /*cdict*/ NULL, /*cdict*/
jobParams, pledgedSrcSize); jobParams, pledgedSrcSize);
if (ZSTD_isError(initError)) JOB_ERROR(initError); if (ZSTD_isError(initError)) JOB_ERROR(initError);
* buffer. Updated past the end if the inBuff once * buffer. Updated past the end if the inBuff once
* the inBuff is sent to the worker thread. * the inBuff is sent to the worker thread.
* pos <= capacity. * pos <= capacity.
*/ */
} roundBuff_t; } roundBuff_t;
static const roundBuff_t kNullRoundBuff = {NULL, 0, 0}; static const roundBuff_t kNullRoundBuff = {NULL, 0, 0};
#define RSYNC_LENGTH 32
typedef struct {
U64 hash;
U64 hitMask;
U64 primePower;
} rsyncState_t;
struct ZSTDMT_CCtx_s { struct ZSTDMT_CCtx_s {
POOL_ctx* factory; POOL_ctx* factory;
ZSTDMT_jobDescription* jobs; ZSTDMT_jobDescription* jobs;
ZSTDMT_bufferPool* bufPool; ZSTDMT_bufferPool* bufPool;
ZSTDMT_CCtxPool* cctxPool; ZSTDMT_CCtxPool* cctxPool;
ZSTDMT_seqPool* seqPool; ZSTDMT_seqPool* seqPool;
ZSTD_CCtx_params params; ZSTD_CCtx_params params;
size_t targetSectionSize; size_t targetSectionSize;
size_t targetPrefixSize; size_t targetPrefixSize;
int jobReady; /* 1 => one job is already prepared, but pool has shortage of workers. Don't create a new job. */ int jobReady; /* 1 => one job is already prepared, but pool has shortage of workers. Don't create a new job. */
inBuff_t inBuff; inBuff_t inBuff;
roundBuff_t roundBuff; roundBuff_t roundBuff;
serialState_t serial; serialState_t serial;
rsyncState_t rsync;
unsigned singleBlockingThread; unsigned singleBlockingThread;
unsigned jobIDMask; unsigned jobIDMask;
unsigned doneJobID; unsigned doneJobID;
unsigned nextJobID; unsigned nextJobID;
unsigned frameEnded; unsigned frameEnded;
unsigned allJobsCompleted; unsigned allJobsCompleted;
unsigned long long frameContentSize; unsigned long long frameContentSize;
unsigned long long consumed; unsigned long long consumed;
/* ZSTDMT_CCtxParam_setNbWorkers(): /* ZSTDMT_CCtxParam_setNbWorkers():
* Internal use only */ * Internal use only */
size_t ZSTDMT_CCtxParam_setNbWorkers(ZSTD_CCtx_params* params, unsigned nbWorkers) size_t ZSTDMT_CCtxParam_setNbWorkers(ZSTD_CCtx_params* params, unsigned nbWorkers)
{ {
if (nbWorkers > ZSTDMT_NBWORKERS_MAX) nbWorkers = ZSTDMT_NBWORKERS_MAX; if (nbWorkers > ZSTDMT_NBWORKERS_MAX) nbWorkers = ZSTDMT_NBWORKERS_MAX;
params->nbWorkers = nbWorkers; params->nbWorkers = nbWorkers;
params->overlapSizeLog = ZSTDMT_OVERLAPLOG_DEFAULT; params->overlapLog = ZSTDMT_OVERLAPLOG_DEFAULT;
params->jobSize = 0; params->jobSize = 0;
return nbWorkers; return nbWorkers;
} }
ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbWorkers, ZSTD_customMem cMem) ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbWorkers, ZSTD_customMem cMem)
{ {
ZSTDMT_CCtx* mtctx; ZSTDMT_CCtx* mtctx;
U32 nbJobs = nbWorkers + 2; U32 nbJobs = nbWorkers + 2;
+ (mtctx->jobIDMask+1) * sizeof(ZSTDMT_jobDescription) + (mtctx->jobIDMask+1) * sizeof(ZSTDMT_jobDescription)
+ ZSTDMT_sizeof_CCtxPool(mtctx->cctxPool) + ZSTDMT_sizeof_CCtxPool(mtctx->cctxPool)
+ ZSTDMT_sizeof_seqPool(mtctx->seqPool) + ZSTDMT_sizeof_seqPool(mtctx->seqPool)
+ ZSTD_sizeof_CDict(mtctx->cdictLocal) + ZSTD_sizeof_CDict(mtctx->cdictLocal)
+ mtctx->roundBuff.capacity; + mtctx->roundBuff.capacity;
} }
/* Internal only */ /* Internal only */
size_t ZSTDMT_CCtxParam_setMTCtxParameter(ZSTD_CCtx_params* params, size_t
ZSTDMT_parameter parameter, unsigned value) { ZSTDMT_CCtxParam_setMTCtxParameter(ZSTD_CCtx_params* params,
ZSTDMT_parameter parameter,
int value)
{
DEBUGLOG(4, "ZSTDMT_CCtxParam_setMTCtxParameter"); DEBUGLOG(4, "ZSTDMT_CCtxParam_setMTCtxParameter");
switch(parameter) switch(parameter)
{ {
case ZSTDMT_p_jobSize : case ZSTDMT_p_jobSize :
DEBUGLOG(4, "ZSTDMT_CCtxParam_setMTCtxParameter : set jobSize to %u", value); DEBUGLOG(4, "ZSTDMT_CCtxParam_setMTCtxParameter : set jobSize to %i", value);
if ( (value > 0) /* value==0 => automatic job size */ if ( value != 0 /* default */
& (value < ZSTDMT_JOBSIZE_MIN) ) && value < ZSTDMT_JOBSIZE_MIN)
value = ZSTDMT_JOBSIZE_MIN; value = ZSTDMT_JOBSIZE_MIN;
if (value > ZSTDMT_JOBSIZE_MAX) assert(value >= 0);
value = ZSTDMT_JOBSIZE_MAX; if (value > ZSTDMT_JOBSIZE_MAX) value = ZSTDMT_JOBSIZE_MAX;
params->jobSize = value; params->jobSize = value;
return value; return value;
case ZSTDMT_p_overlapSectionLog :
if (value > 9) value = 9; case ZSTDMT_p_overlapLog :
DEBUGLOG(4, "ZSTDMT_p_overlapSectionLog : %u", value); DEBUGLOG(4, "ZSTDMT_p_overlapLog : %i", value);
params->overlapSizeLog = (value >= 9) ? 9 : value; if (value < ZSTD_OVERLAPLOG_MIN) value = ZSTD_OVERLAPLOG_MIN;
if (value > ZSTD_OVERLAPLOG_MAX) value = ZSTD_OVERLAPLOG_MAX;
params->overlapLog = value;
return value;
case ZSTDMT_p_rsyncable :
value = (value != 0);
params->rsyncable = value;
return value; return value;
default : default :
return ERROR(parameter_unsupported); return ERROR(parameter_unsupported);
} }
} }
size_t ZSTDMT_setMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSTDMT_parameter parameter, unsigned value) size_t ZSTDMT_setMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSTDMT_parameter parameter, int value)
{ {
DEBUGLOG(4, "ZSTDMT_setMTCtxParameter"); DEBUGLOG(4, "ZSTDMT_setMTCtxParameter");
switch(parameter)
{
case ZSTDMT_p_jobSize :
return ZSTDMT_CCtxParam_setMTCtxParameter(&mtctx->params, parameter, value); return ZSTDMT_CCtxParam_setMTCtxParameter(&mtctx->params, parameter, value);
case ZSTDMT_p_overlapSectionLog :
return ZSTDMT_CCtxParam_setMTCtxParameter(&mtctx->params, parameter, value);
default :
return ERROR(parameter_unsupported);
}
} }
size_t ZSTDMT_getMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSTDMT_parameter parameter, unsigned* value) size_t ZSTDMT_getMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSTDMT_parameter parameter, int* value)
{ {
switch (parameter) { switch (parameter) {
case ZSTDMT_p_jobSize: case ZSTDMT_p_jobSize:
*value = mtctx->params.jobSize; assert(mtctx->params.jobSize <= INT_MAX);
*value = (int)(mtctx->params.jobSize);
break;
case ZSTDMT_p_overlapLog:
*value = mtctx->params.overlapLog;
break; break;
case ZSTDMT_p_overlapSectionLog: case ZSTDMT_p_rsyncable:
*value = mtctx->params.overlapSizeLog; *value = mtctx->params.rsyncable;
break; break;
default: default:
return ERROR(parameter_unsupported); return ERROR(parameter_unsupported);
} }
return 0; return 0;
} }
/* Sets parameters relevant to the compression job, /* Sets parameters relevant to the compression job,
return toFlush; return toFlush;
} }
/* ------------------------------------------ */ /* ------------------------------------------ */
/* ===== Multi-threaded compression ===== */ /* ===== Multi-threaded compression ===== */
/* ------------------------------------------ */ /* ------------------------------------------ */
static size_t ZSTDMT_computeTargetJobLog(ZSTD_CCtx_params const params) static unsigned ZSTDMT_computeTargetJobLog(ZSTD_CCtx_params const params)
{ {
if (params.ldmParams.enableLdm) if (params.ldmParams.enableLdm)
/* In Long Range Mode, the windowLog is typically oversized.
* In which case, it's preferable to determine the jobSize
* based on chainLog instead. */
return MAX(21, params.cParams.chainLog + 4); return MAX(21, params.cParams.chainLog + 4);
return MAX(20, params.cParams.windowLog + 2); return MAX(20, params.cParams.windowLog + 2);
} }
static size_t ZSTDMT_computeOverlapLog(ZSTD_CCtx_params const params) static int ZSTDMT_overlapLog_default(ZSTD_strategy strat)
{ {
unsigned const overlapRLog = (params.overlapSizeLog>9) ? 0 : 9-params.overlapSizeLog; switch(strat)
if (params.ldmParams.enableLdm) {
return (MIN(params.cParams.windowLog, ZSTDMT_computeTargetJobLog(params) - 2) - overlapRLog); case ZSTD_btultra2:
return overlapRLog >= 9 ? 0 : (params.cParams.windowLog - overlapRLog); return 9;
case ZSTD_btultra:
case ZSTD_btopt:
return 8;
case ZSTD_btlazy2:
case ZSTD_lazy2:
return 7;
case ZSTD_lazy:
case ZSTD_greedy:
case ZSTD_dfast:
case ZSTD_fast:
default:;
}
return 6;
} }
static unsigned ZSTDMT_computeNbJobs(ZSTD_CCtx_params params, size_t srcSize, unsigned nbWorkers) { static int ZSTDMT_overlapLog(int ovlog, ZSTD_strategy strat)
{
assert(0 <= ovlog && ovlog <= 9);
if (ovlog == 0) return ZSTDMT_overlapLog_default(strat);
return ovlog;
}
static size_t ZSTDMT_computeOverlapSize(ZSTD_CCtx_params const params)
{
int const overlapRLog = 9 - ZSTDMT_overlapLog(params.overlapLog, params.cParams.strategy);
int ovLog = (overlapRLog >= 8) ? 0 : (params.cParams.windowLog - overlapRLog);
assert(0 <= overlapRLog && overlapRLog <= 8);
if (params.ldmParams.enableLdm) {
/* In Long Range Mode, the windowLog is typically oversized.
* In which case, it's preferable to determine the jobSize
* based on chainLog instead.
* Then, ovLog becomes a fraction of the jobSize, rather than windowSize */
ovLog = MIN(params.cParams.windowLog, ZSTDMT_computeTargetJobLog(params) - 2)
- overlapRLog;
}
assert(0 <= ovLog && ovLog <= 30);
DEBUGLOG(4, "overlapLog : %i", params.overlapLog);
DEBUGLOG(4, "overlap size : %i", 1 << ovLog);
return (ovLog==0) ? 0 : (size_t)1 << ovLog;
}
static unsigned
ZSTDMT_computeNbJobs(ZSTD_CCtx_params params, size_t srcSize, unsigned nbWorkers)
{
assert(nbWorkers>0); assert(nbWorkers>0);
{ size_t const jobSizeTarget = (size_t)1 << ZSTDMT_computeTargetJobLog(params); { size_t const jobSizeTarget = (size_t)1 << ZSTDMT_computeTargetJobLog(params);
size_t const jobMaxSize = jobSizeTarget << 2; size_t const jobMaxSize = jobSizeTarget << 2;
size_t const passSizeMax = jobMaxSize * nbWorkers; size_t const passSizeMax = jobMaxSize * nbWorkers;
unsigned const multiplier = (unsigned)(srcSize / passSizeMax) + 1; unsigned const multiplier = (unsigned)(srcSize / passSizeMax) + 1;
unsigned const nbJobsLarge = multiplier * nbWorkers; unsigned const nbJobsLarge = multiplier * nbWorkers;
unsigned const nbJobsMax = (unsigned)(srcSize / jobSizeTarget) + 1; unsigned const nbJobsMax = (unsigned)(srcSize / jobSizeTarget) + 1;
unsigned const nbJobsSmall = MIN(nbJobsMax, nbWorkers); unsigned const nbJobsSmall = MIN(nbJobsMax, nbWorkers);
return (multiplier>1) ? nbJobsLarge : nbJobsSmall; return (multiplier>1) ? nbJobsLarge : nbJobsSmall;
} } } }
/* ZSTDMT_compress_advanced_internal() : /* ZSTDMT_compress_advanced_internal() :
* This is a blocking function : it will only give back control to caller after finishing its compression job. * This is a blocking function : it will only give back control to caller after finishing its compression job.
*/ */
static size_t ZSTDMT_compress_advanced_internal( static size_t ZSTDMT_compress_advanced_internal(
ZSTDMT_CCtx* mtctx, ZSTDMT_CCtx* mtctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const void* src, size_t srcSize,
const ZSTD_CDict* cdict, const ZSTD_CDict* cdict,
ZSTD_CCtx_params params) ZSTD_CCtx_params params)
{ {
ZSTD_CCtx_params const jobParams = ZSTDMT_initJobCCtxParams(params); ZSTD_CCtx_params const jobParams = ZSTDMT_initJobCCtxParams(params);
size_t const overlapSize = (size_t)1 << ZSTDMT_computeOverlapLog(params); size_t const overlapSize = ZSTDMT_computeOverlapSize(params);
unsigned const nbJobs = ZSTDMT_computeNbJobs(params, srcSize, params.nbWorkers); unsigned const nbJobs = ZSTDMT_computeNbJobs(params, srcSize, params.nbWorkers);
size_t const proposedJobSize = (srcSize + (nbJobs-1)) / nbJobs; size_t const proposedJobSize = (srcSize + (nbJobs-1)) / nbJobs;
size_t const avgJobSize = (((proposedJobSize-1) & 0x1FFFF) < 0x7FFF) ? proposedJobSize + 0xFFFF : proposedJobSize; /* avoid too small last block */ size_t const avgJobSize = (((proposedJobSize-1) & 0x1FFFF) < 0x7FFF) ? proposedJobSize + 0xFFFF : proposedJobSize; /* avoid too small last block */
const char* const srcStart = (const char*)src; const char* const srcStart = (const char*)src;
size_t remainingSrcSize = srcSize; size_t remainingSrcSize = srcSize;
unsigned const compressWithinDst = (dstCapacity >= ZSTD_compressBound(srcSize)) ? nbJobs : (unsigned)(dstCapacity / ZSTD_compressBound(avgJobSize)); /* presumes avgJobSize >= 256 KB, which should be the case */ unsigned const compressWithinDst = (dstCapacity >= ZSTD_compressBound(srcSize)) ? nbJobs : (unsigned)(dstCapacity / ZSTD_compressBound(avgJobSize)); /* presumes avgJobSize >= 256 KB, which should be the case */
size_t frameStartPos = 0, dstBufferPos = 0; size_t frameStartPos = 0, dstBufferPos = 0;
assert(jobParams.nbWorkers == 0); assert(jobParams.nbWorkers == 0);
} } } }
if (!error) DEBUGLOG(4, "compressed size : %u ", (U32)dstPos); if (!error) DEBUGLOG(4, "compressed size : %u ", (U32)dstPos);
return error ? error : dstPos; return error ? error : dstPos;
} }
} }
size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx, size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const void* src, size_t srcSize,
const ZSTD_CDict* cdict, const ZSTD_CDict* cdict,
ZSTD_parameters params, ZSTD_parameters params,
unsigned overlapLog) int overlapLog)
{ {
ZSTD_CCtx_params cctxParams = mtctx->params; ZSTD_CCtx_params cctxParams = mtctx->params;
cctxParams.cParams = params.cParams; cctxParams.cParams = params.cParams;
cctxParams.fParams = params.fParams; cctxParams.fParams = params.fParams;
cctxParams.overlapSizeLog = overlapLog; assert(ZSTD_OVERLAPLOG_MIN <= overlapLog && overlapLog <= ZSTD_OVERLAPLOG_MAX);
cctxParams.overlapLog = overlapLog;
return ZSTDMT_compress_advanced_internal(mtctx, return ZSTDMT_compress_advanced_internal(mtctx,
dst, dstCapacity, dst, dstCapacity,
src, srcSize, src, srcSize,
cdict, cctxParams); cdict, cctxParams);
} }
size_t ZSTDMT_compressCCtx(ZSTDMT_CCtx* mtctx, size_t ZSTDMT_compressCCtx(ZSTDMT_CCtx* mtctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const void* src, size_t srcSize,
int compressionLevel) int compressionLevel)
{ {
U32 const overlapLog = (compressionLevel >= ZSTD_maxCLevel()) ? 9 : ZSTDMT_OVERLAPLOG_DEFAULT;
ZSTD_parameters params = ZSTD_getParams(compressionLevel, srcSize, 0); ZSTD_parameters params = ZSTD_getParams(compressionLevel, srcSize, 0);
int const overlapLog = ZSTDMT_overlapLog_default(params.cParams.strategy);
params.fParams.contentSizeFlag = 1; params.fParams.contentSizeFlag = 1;
return ZSTDMT_compress_advanced(mtctx, dst, dstCapacity, src, srcSize, NULL, params, overlapLog); return ZSTDMT_compress_advanced(mtctx, dst, dstCapacity, src, srcSize, NULL, params, overlapLog);
} }
/* ====================================== */ /* ====================================== */
/* ======= Streaming API ======= */ /* ======= Streaming API ======= */
/* ====================================== */ /* ====================================== */
/* params supposed partially fully validated at this point */ /* params supposed partially fully validated at this point */
assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams))); assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
assert(!((dict) && (cdict))); /* either dict or cdict, not both */ assert(!((dict) && (cdict))); /* either dict or cdict, not both */
/* init */ /* init */
if (params.nbWorkers != mtctx->params.nbWorkers) if (params.nbWorkers != mtctx->params.nbWorkers)
CHECK_F( ZSTDMT_resize(mtctx, params.nbWorkers) ); CHECK_F( ZSTDMT_resize(mtctx, params.nbWorkers) );
if (params.jobSize > 0 && params.jobSize < ZSTDMT_JOBSIZE_MIN) params.jobSize = ZSTDMT_JOBSIZE_MIN; if (params.jobSize != 0 && params.jobSize < ZSTDMT_JOBSIZE_MIN) params.jobSize = ZSTDMT_JOBSIZE_MIN;
if (params.jobSize > ZSTDMT_JOBSIZE_MAX) params.jobSize = ZSTDMT_JOBSIZE_MAX; if (params.jobSize > (size_t)ZSTDMT_JOBSIZE_MAX) params.jobSize = ZSTDMT_JOBSIZE_MAX;
mtctx->singleBlockingThread = (pledgedSrcSize <= ZSTDMT_JOBSIZE_MIN); /* do not trigger multi-threading when srcSize is too small */ mtctx->singleBlockingThread = (pledgedSrcSize <= ZSTDMT_JOBSIZE_MIN); /* do not trigger multi-threading when srcSize is too small */
if (mtctx->singleBlockingThread) { if (mtctx->singleBlockingThread) {
ZSTD_CCtx_params const singleThreadParams = ZSTDMT_initJobCCtxParams(params); ZSTD_CCtx_params const singleThreadParams = ZSTDMT_initJobCCtxParams(params);
DEBUGLOG(5, "ZSTDMT_initCStream_internal: switch to single blocking thread mode"); DEBUGLOG(5, "ZSTDMT_initCStream_internal: switch to single blocking thread mode");
assert(singleThreadParams.nbWorkers == 0); assert(singleThreadParams.nbWorkers == 0);
return ZSTD_initCStream_internal(mtctx->cctxPool->cctx[0], return ZSTD_initCStream_internal(mtctx->cctxPool->cctx[0],
dict, dictSize, cdict, dict, dictSize, cdict,
mtctx->cdict = mtctx->cdictLocal; mtctx->cdict = mtctx->cdictLocal;
if (mtctx->cdictLocal == NULL) return ERROR(memory_allocation); if (mtctx->cdictLocal == NULL) return ERROR(memory_allocation);
} else { } else {
ZSTD_freeCDict(mtctx->cdictLocal); ZSTD_freeCDict(mtctx->cdictLocal);
mtctx->cdictLocal = NULL; mtctx->cdictLocal = NULL;
mtctx->cdict = cdict; mtctx->cdict = cdict;
} }
mtctx->targetPrefixSize = (size_t)1 << ZSTDMT_computeOverlapLog(params); mtctx->targetPrefixSize = ZSTDMT_computeOverlapSize(params);
DEBUGLOG(4, "overlapLog=%u => %u KB", params.overlapSizeLog, (U32)(mtctx->targetPrefixSize>>10)); DEBUGLOG(4, "overlapLog=%i => %u KB", params.overlapLog, (U32)(mtctx->targetPrefixSize>>10));
mtctx->targetSectionSize = params.jobSize; mtctx->targetSectionSize = params.jobSize;
if (mtctx->targetSectionSize == 0) { if (mtctx->targetSectionSize == 0) {
mtctx->targetSectionSize = 1ULL << ZSTDMT_computeTargetJobLog(params); mtctx->targetSectionSize = 1ULL << ZSTDMT_computeTargetJobLog(params);
} }
if (params.rsyncable) {
/* Aim for the targetsectionSize as the average job size. */
U32 const jobSizeMB = (U32)(mtctx->targetSectionSize >> 20);
U32 const rsyncBits = ZSTD_highbit32(jobSizeMB) + 20;
assert(jobSizeMB >= 1);
DEBUGLOG(4, "rsyncLog = %u", rsyncBits);
mtctx->rsync.hash = 0;
mtctx->rsync.hitMask = (1ULL << rsyncBits) - 1;
mtctx->rsync.primePower = ZSTD_rollingHash_primePower(RSYNC_LENGTH);
}
if (mtctx->targetSectionSize < mtctx->targetPrefixSize) mtctx->targetSectionSize = mtctx->targetPrefixSize; /* job size must be >= overlap size */ if (mtctx->targetSectionSize < mtctx->targetPrefixSize) mtctx->targetSectionSize = mtctx->targetPrefixSize; /* job size must be >= overlap size */
DEBUGLOG(4, "Job Size : %u KB (note : set to %u)", (U32)(mtctx->targetSectionSize>>10), params.jobSize); DEBUGLOG(4, "Job Size : %u KB (note : set to %u)", (U32)(mtctx->targetSectionSize>>10), (U32)params.jobSize);
DEBUGLOG(4, "inBuff Size : %u KB", (U32)(mtctx->targetSectionSize>>10)); DEBUGLOG(4, "inBuff Size : %u KB", (U32)(mtctx->targetSectionSize>>10));
ZSTDMT_setBufferSize(mtctx->bufPool, ZSTD_compressBound(mtctx->targetSectionSize)); ZSTDMT_setBufferSize(mtctx->bufPool, ZSTD_compressBound(mtctx->targetSectionSize));
{ {
/* If ldm is enabled we need windowSize space. */ /* If ldm is enabled we need windowSize space. */
size_t const windowSize = mtctx->params.ldmParams.enableLdm ? (1U << mtctx->params.cParams.windowLog) : 0; size_t const windowSize = mtctx->params.ldmParams.enableLdm ? (1U << mtctx->params.cParams.windowLog) : 0;
/* Two buffers of slack, plus extra space for the overlap /* Two buffers of slack, plus extra space for the overlap
* This is the minimum slack that LDM works with. One extra because * This is the minimum slack that LDM works with. One extra because
* flush might waste up to targetSectionSize-1 bytes. Another extra * flush might waste up to targetSectionSize-1 bytes. Another extra
mtctx->inBuff.buffer = buffer; mtctx->inBuff.buffer = buffer;
mtctx->inBuff.filled = 0; mtctx->inBuff.filled = 0;
assert(mtctx->roundBuff.pos + buffer.capacity <= mtctx->roundBuff.capacity); assert(mtctx->roundBuff.pos + buffer.capacity <= mtctx->roundBuff.capacity);
return 1; return 1;
} }
typedef struct {
size_t toLoad; /* The number of bytes to load from the input. */
int flush; /* Boolean declaring if we must flush because we found a synchronization point. */
} syncPoint_t;
/**
* Searches through the input for a synchronization point. If one is found, we
* will instruct the caller to flush, and return the number of bytes to load.
* Otherwise, we will load as many bytes as possible and instruct the caller
* to continue as normal.
*/
static syncPoint_t
findSynchronizationPoint(ZSTDMT_CCtx const* mtctx, ZSTD_inBuffer const input)
{
BYTE const* const istart = (BYTE const*)input.src + input.pos;
U64 const primePower = mtctx->rsync.primePower;
U64 const hitMask = mtctx->rsync.hitMask;
syncPoint_t syncPoint;
U64 hash;
BYTE const* prev;
size_t pos;
syncPoint.toLoad = MIN(input.size - input.pos, mtctx->targetSectionSize - mtctx->inBuff.filled);
syncPoint.flush = 0;
if (!mtctx->params.rsyncable)
/* Rsync is disabled. */
return syncPoint;
if (mtctx->inBuff.filled + syncPoint.toLoad < RSYNC_LENGTH)
/* Not enough to compute the hash.
* We will miss any synchronization points in this RSYNC_LENGTH byte
* window. However, since it depends only in the internal buffers, if the
* state is already synchronized, we will remain synchronized.
* Additionally, the probability that we miss a synchronization point is
* low: RSYNC_LENGTH / targetSectionSize.
*/
return syncPoint;
/* Initialize the loop variables. */
if (mtctx->inBuff.filled >= RSYNC_LENGTH) {
/* We have enough bytes buffered to initialize the hash.
* Start scanning at the beginning of the input.
*/
pos = 0;
prev = (BYTE const*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled - RSYNC_LENGTH;
hash = ZSTD_rollingHash_compute(prev, RSYNC_LENGTH);
} else {
/* We don't have enough bytes buffered to initialize the hash, but
* we know we have at least RSYNC_LENGTH bytes total.
* Start scanning after the first RSYNC_LENGTH bytes less the bytes
* already buffered.
*/
pos = RSYNC_LENGTH - mtctx->inBuff.filled;
prev = (BYTE const*)mtctx->inBuff.buffer.start - pos;
hash = ZSTD_rollingHash_compute(mtctx->inBuff.buffer.start, mtctx->inBuff.filled);
hash = ZSTD_rollingHash_append(hash, istart, pos);
}
/* Starting with the hash of the previous RSYNC_LENGTH bytes, roll
* through the input. If we hit a synchronization point, then cut the
* job off, and tell the compressor to flush the job. Otherwise, load
* all the bytes and continue as normal.
* If we go too long without a synchronization point (targetSectionSize)
* then a block will be emitted anyways, but this is okay, since if we
* are already synchronized we will remain synchronized.
*/
for (; pos < syncPoint.toLoad; ++pos) {
BYTE const toRemove = pos < RSYNC_LENGTH ? prev[pos] : istart[pos - RSYNC_LENGTH];
/* if (pos >= RSYNC_LENGTH) assert(ZSTD_rollingHash_compute(istart + pos - RSYNC_LENGTH, RSYNC_LENGTH) == hash); */
hash = ZSTD_rollingHash_rotate(hash, toRemove, istart[pos], primePower);
if ((hash & hitMask) == hitMask) {
syncPoint.toLoad = pos + 1;
syncPoint.flush = 1;
break;
}
}
return syncPoint;
}
size_t ZSTDMT_nextInputSizeHint(const ZSTDMT_CCtx* mtctx)
{
size_t hintInSize = mtctx->targetSectionSize - mtctx->inBuff.filled;
if (hintInSize==0) hintInSize = mtctx->targetSectionSize;
return hintInSize;
}
/** ZSTDMT_compressStream_generic() : /** ZSTDMT_compressStream_generic() :
* internal use only - exposed to be invoked from zstd_compress.c * internal use only - exposed to be invoked from zstd_compress.c
* assumption : output and input are valid (pos <= size) * assumption : output and input are valid (pos <= size)
* @return : minimum amount of data remaining to flush, 0 if none */ * @return : minimum amount of data remaining to flush, 0 if none */
size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx, size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
ZSTD_outBuffer* output, ZSTD_outBuffer* output,
ZSTD_inBuffer* input, ZSTD_inBuffer* input,
} }
if ((mtctx->frameEnded) && (endOp==ZSTD_e_continue)) { if ((mtctx->frameEnded) && (endOp==ZSTD_e_continue)) {
/* current frame being ended. Only flush/end are allowed */ /* current frame being ended. Only flush/end are allowed */
return ERROR(stage_wrong); return ERROR(stage_wrong);
} }
/* single-pass shortcut (note : synchronous-mode) */ /* single-pass shortcut (note : synchronous-mode) */
if ( (mtctx->nextJobID == 0) /* just started */ if ( (!mtctx->params.rsyncable) /* rsyncable mode is disabled */
&& (mtctx->nextJobID == 0) /* just started */
&& (mtctx->inBuff.filled == 0) /* nothing buffered */ && (mtctx->inBuff.filled == 0) /* nothing buffered */
&& (!mtctx->jobReady) /* no job already created */ && (!mtctx->jobReady) /* no job already created */
&& (endOp == ZSTD_e_end) /* end order */ && (endOp == ZSTD_e_end) /* end order */
&& (output->size - output->pos >= ZSTD_compressBound(input->size - input->pos)) ) { /* enough space in dst */ && (output->size - output->pos >= ZSTD_compressBound(input->size - input->pos)) ) { /* enough space in dst */
size_t const cSize = ZSTDMT_compress_advanced_internal(mtctx, size_t const cSize = ZSTDMT_compress_advanced_internal(mtctx,
(char*)output->dst + output->pos, output->size - output->pos, (char*)output->dst + output->pos, output->size - output->pos,
(const char*)input->src + input->pos, input->size - input->pos, (const char*)input->src + input->pos, input->size - input->pos,
mtctx->cdict, mtctx->params); mtctx->cdict, mtctx->params);
* still compression jobs ongoing. * still compression jobs ongoing.
*/ */
DEBUGLOG(5, "ZSTDMT_tryGetInputRange failed"); DEBUGLOG(5, "ZSTDMT_tryGetInputRange failed");
assert(mtctx->doneJobID != mtctx->nextJobID); assert(mtctx->doneJobID != mtctx->nextJobID);
} else } else
DEBUGLOG(5, "ZSTDMT_tryGetInputRange completed successfully : mtctx->inBuff.buffer.start = %p", mtctx->inBuff.buffer.start); DEBUGLOG(5, "ZSTDMT_tryGetInputRange completed successfully : mtctx->inBuff.buffer.start = %p", mtctx->inBuff.buffer.start);
} }
if (mtctx->inBuff.buffer.start != NULL) { if (mtctx->inBuff.buffer.start != NULL) {
size_t const toLoad = MIN(input->size - input->pos, mtctx->targetSectionSize - mtctx->inBuff.filled); syncPoint_t const syncPoint = findSynchronizationPoint(mtctx, *input);
if (syncPoint.flush && endOp == ZSTD_e_continue) {
endOp = ZSTD_e_flush;
}
assert(mtctx->inBuff.buffer.capacity >= mtctx->targetSectionSize); assert(mtctx->inBuff.buffer.capacity >= mtctx->targetSectionSize);
DEBUGLOG(5, "ZSTDMT_compressStream_generic: adding %u bytes on top of %u to buffer of size %u", DEBUGLOG(5, "ZSTDMT_compressStream_generic: adding %u bytes on top of %u to buffer of size %u",
(U32)toLoad, (U32)mtctx->inBuff.filled, (U32)mtctx->targetSectionSize); (U32)syncPoint.toLoad, (U32)mtctx->inBuff.filled, (U32)mtctx->targetSectionSize);
memcpy((char*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled, (const char*)input->src + input->pos, toLoad); memcpy((char*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled, (const char*)input->src + input->pos, syncPoint.toLoad);
input->pos += toLoad; input->pos += syncPoint.toLoad;
mtctx->inBuff.filled += toLoad; mtctx->inBuff.filled += syncPoint.toLoad;
forwardInputProgress = toLoad>0; forwardInputProgress = syncPoint.toLoad>0;
} }
if ((input->pos < input->size) && (endOp == ZSTD_e_end)) if ((input->pos < input->size) && (endOp == ZSTD_e_end))
endOp = ZSTD_e_flush; /* can't end now : not all input consumed */ endOp = ZSTD_e_flush; /* can't end now : not all input consumed */
} }
if ( (mtctx->jobReady) if ( (mtctx->jobReady)
|| (mtctx->inBuff.filled >= mtctx->targetSectionSize) /* filled enough : let's compress */ || (mtctx->inBuff.filled >= mtctx->targetSectionSize) /* filled enough : let's compress */
|| ((endOp != ZSTD_e_continue) && (mtctx->inBuff.filled > 0)) /* something to flush : let's go */ || ((endOp != ZSTD_e_continue) && (mtctx->inBuff.filled > 0)) /* something to flush : let's go */

contrib/python-zstandard/zstd/decompress/huf_decompress.c

#include <string.h> /* memcpy, memset */ #include <string.h> /* memcpy, memset */
#include "compiler.h" #include "compiler.h"
#include "bitstream.h" /* BIT_* */ #include "bitstream.h" /* BIT_* */
#include "fse.h" /* to compress headers */ #include "fse.h" /* to compress headers */
#define HUF_STATIC_LINKING_ONLY #define HUF_STATIC_LINKING_ONLY
#include "huf.h" #include "huf.h"
#include "error_private.h" #include "error_private.h"
/* **************************************************************
* Macros
****************************************************************/
/* These two optional macros force the use one way or another of the two
* Huffman decompression implementations. You can't force in both directions
* at the same time.
*/
#if defined(HUF_FORCE_DECOMPRESS_X1) && \
defined(HUF_FORCE_DECOMPRESS_X2)
#error "Cannot force the use of the X1 and X2 decoders at the same time!"
#endif
/* ************************************************************** /* **************************************************************
* Error Management * Error Management
****************************************************************/ ****************************************************************/
#define HUF_isError ERR_isError #define HUF_isError ERR_isError
#define CHECK_F(f) { size_t const err_ = (f); if (HUF_isError(err_)) return err_; } #define CHECK_F(f) { size_t const err_ = (f); if (HUF_isError(err_)) return err_; }
/* ************************************************************** /* **************************************************************
* Byte alignment for workSpace management * Byte alignment for workSpace management
****************************************************************/ ****************************************************************/
#define HUF_ALIGN(x, a) HUF_ALIGN_MASK((x), (a) - 1) #define HUF_ALIGN(x, a) HUF_ALIGN_MASK((x), (a) - 1)
#define HUF_ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask)) #define HUF_ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask))
/* **************************************************************
* BMI2 Variant Wrappers
****************************************************************/
#if DYNAMIC_BMI2
#define HUF_DGEN(fn) \
\
static size_t fn##_default( \
void* dst, size_t dstSize, \
const void* cSrc, size_t cSrcSize, \
const HUF_DTable* DTable) \
{ \
return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \
} \
\
static TARGET_ATTRIBUTE("bmi2") size_t fn##_bmi2( \
void* dst, size_t dstSize, \
const void* cSrc, size_t cSrcSize, \
const HUF_DTable* DTable) \
{ \
return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \
} \
\
static size_t fn(void* dst, size_t dstSize, void const* cSrc, \
size_t cSrcSize, HUF_DTable const* DTable, int bmi2) \
{ \
if (bmi2) { \
return fn##_bmi2(dst, dstSize, cSrc, cSrcSize, DTable); \
} \
return fn##_default(dst, dstSize, cSrc, cSrcSize, DTable); \
}
#else
#define HUF_DGEN(fn) \
static size_t fn(void* dst, size_t dstSize, void const* cSrc, \
size_t cSrcSize, HUF_DTable const* DTable, int bmi2) \
{ \
(void)bmi2; \
return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \
}
#endif
/*-***************************/ /*-***************************/
/* generic DTableDesc */ /* generic DTableDesc */
/*-***************************/ /*-***************************/
typedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc; typedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc;
static DTableDesc HUF_getDTableDesc(const HUF_DTable* table) static DTableDesc HUF_getDTableDesc(const HUF_DTable* table)
{ {
DTableDesc dtd; DTableDesc dtd;
memcpy(&dtd, table, sizeof(dtd)); memcpy(&dtd, table, sizeof(dtd));
return dtd; return dtd;
} }
#ifndef HUF_FORCE_DECOMPRESS_X2
/*-***************************/ /*-***************************/
/* single-symbol decoding */ /* single-symbol decoding */
/*-***************************/ /*-***************************/
typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX1; /* single-symbol decoding */ typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX1; /* single-symbol decoding */
size_t HUF_readDTableX1_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize) size_t HUF_readDTableX1_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize)
{ {
U32 tableLog = 0; U32 tableLog = 0;
} }
} }
typedef size_t (*HUF_decompress_usingDTable_t)(void *dst, size_t dstSize, typedef size_t (*HUF_decompress_usingDTable_t)(void *dst, size_t dstSize,
const void *cSrc, const void *cSrc,
size_t cSrcSize, size_t cSrcSize,
const HUF_DTable *DTable); const HUF_DTable *DTable);
#if DYNAMIC_BMI2
#define HUF_DGEN(fn) \
\
static size_t fn##_default( \
void* dst, size_t dstSize, \
const void* cSrc, size_t cSrcSize, \
const HUF_DTable* DTable) \
{ \
return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \
} \
\
static TARGET_ATTRIBUTE("bmi2") size_t fn##_bmi2( \
void* dst, size_t dstSize, \
const void* cSrc, size_t cSrcSize, \
const HUF_DTable* DTable) \
{ \
return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \
} \
\
static size_t fn(void* dst, size_t dstSize, void const* cSrc, \
size_t cSrcSize, HUF_DTable const* DTable, int bmi2) \
{ \
if (bmi2) { \
return fn##_bmi2(dst, dstSize, cSrc, cSrcSize, DTable); \
} \
return fn##_default(dst, dstSize, cSrc, cSrcSize, DTable); \
}
#else
#define HUF_DGEN(fn) \
static size_t fn(void* dst, size_t dstSize, void const* cSrc, \
size_t cSrcSize, HUF_DTable const* DTable, int bmi2) \
{ \
(void)bmi2; \
return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \
}
#endif
HUF_DGEN(HUF_decompress1X1_usingDTable_internal) HUF_DGEN(HUF_decompress1X1_usingDTable_internal)
HUF_DGEN(HUF_decompress4X1_usingDTable_internal) HUF_DGEN(HUF_decompress4X1_usingDTable_internal)
size_t HUF_decompress1X1_usingDTable( size_t HUF_decompress1X1_usingDTable(
void* dst, size_t dstSize, void* dst, size_t dstSize,
workSpace, sizeof(workSpace)); workSpace, sizeof(workSpace));
} }
size_t HUF_decompress4X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) size_t HUF_decompress4X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
{ {
HUF_CREATE_STATIC_DTABLEX1(DTable, HUF_TABLELOG_MAX); HUF_CREATE_STATIC_DTABLEX1(DTable, HUF_TABLELOG_MAX);
return HUF_decompress4X1_DCtx(DTable, dst, dstSize, cSrc, cSrcSize); return HUF_decompress4X1_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
} }
#endif /* HUF_FORCE_DECOMPRESS_X2 */
#ifndef HUF_FORCE_DECOMPRESS_X1
/* *************************/ /* *************************/
/* double-symbols decoding */ /* double-symbols decoding */
/* *************************/ /* *************************/
typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX2; /* double-symbols decoding */ typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX2; /* double-symbols decoding */
typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t; typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;
typedef U32 rankValCol_t[HUF_TABLELOG_MAX + 1]; typedef U32 rankValCol_t[HUF_TABLELOG_MAX + 1];
} }
size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
{ {
HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_TABLELOG_MAX); HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_TABLELOG_MAX);
return HUF_decompress4X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize); return HUF_decompress4X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
} }
#endif /* HUF_FORCE_DECOMPRESS_X1 */
/* ***********************************/ /* ***********************************/
/* Universal decompression selectors */ /* Universal decompression selectors */
/* ***********************************/ /* ***********************************/
size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize,
const void* cSrc, size_t cSrcSize, const void* cSrc, size_t cSrcSize,
const HUF_DTable* DTable) const HUF_DTable* DTable)
{ {
DTableDesc const dtd = HUF_getDTableDesc(DTable); DTableDesc const dtd = HUF_getDTableDesc(DTable);
#if defined(HUF_FORCE_DECOMPRESS_X1)
(void)dtd;
assert(dtd.tableType == 0);
return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
(void)dtd;
assert(dtd.tableType == 1);
return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
#else
return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) : return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) :
HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
#endif
} }
size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize,
const void* cSrc, size_t cSrcSize, const void* cSrc, size_t cSrcSize,
const HUF_DTable* DTable) const HUF_DTable* DTable)
{ {
DTableDesc const dtd = HUF_getDTableDesc(DTable); DTableDesc const dtd = HUF_getDTableDesc(DTable);
#if defined(HUF_FORCE_DECOMPRESS_X1)
(void)dtd;
assert(dtd.tableType == 0);
return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
(void)dtd;
assert(dtd.tableType == 1);
return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
#else
return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) : return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) :
HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
#endif
} }
#if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2)
typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t; typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] = static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] =
{ {
/* single, double, quad */ /* single, double, quad */
{{0,0}, {1,1}, {2,2}}, /* Q==0 : impossible */ {{0,0}, {1,1}, {2,2}}, /* Q==0 : impossible */
{{0,0}, {1,1}, {2,2}}, /* Q==1 : impossible */ {{0,0}, {1,1}, {2,2}}, /* Q==1 : impossible */
{{ 38,130}, {1313, 74}, {2151, 38}}, /* Q == 2 : 12-18% */ {{ 38,130}, {1313, 74}, {2151, 38}}, /* Q == 2 : 12-18% */
{{ 448,128}, {1353, 74}, {2238, 41}}, /* Q == 3 : 18-25% */ {{ 448,128}, {1353, 74}, {2238, 41}}, /* Q == 3 : 18-25% */
{{ 556,128}, {1353, 74}, {2238, 47}}, /* Q == 4 : 25-32% */ {{ 556,128}, {1353, 74}, {2238, 47}}, /* Q == 4 : 25-32% */
{{ 714,128}, {1418, 74}, {2436, 53}}, /* Q == 5 : 32-38% */ {{ 714,128}, {1418, 74}, {2436, 53}}, /* Q == 5 : 32-38% */
{{ 883,128}, {1437, 74}, {2464, 61}}, /* Q == 6 : 38-44% */ {{ 883,128}, {1437, 74}, {2464, 61}}, /* Q == 6 : 38-44% */
{{ 897,128}, {1515, 75}, {2622, 68}}, /* Q == 7 : 44-50% */ {{ 897,128}, {1515, 75}, {2622, 68}}, /* Q == 7 : 44-50% */
{{ 926,128}, {1613, 75}, {2730, 75}}, /* Q == 8 : 50-56% */ {{ 926,128}, {1613, 75}, {2730, 75}}, /* Q == 8 : 50-56% */
{{ 947,128}, {1729, 77}, {3359, 77}}, /* Q == 9 : 56-62% */ {{ 947,128}, {1729, 77}, {3359, 77}}, /* Q == 9 : 56-62% */
{{1107,128}, {2083, 81}, {4006, 84}}, /* Q ==10 : 62-69% */ {{1107,128}, {2083, 81}, {4006, 84}}, /* Q ==10 : 62-69% */
{{1177,128}, {2379, 87}, {4785, 88}}, /* Q ==11 : 69-75% */ {{1177,128}, {2379, 87}, {4785, 88}}, /* Q ==11 : 69-75% */
{{1242,128}, {2415, 93}, {5155, 84}}, /* Q ==12 : 75-81% */ {{1242,128}, {2415, 93}, {5155, 84}}, /* Q ==12 : 75-81% */
{{1349,128}, {2644,106}, {5260,106}}, /* Q ==13 : 81-87% */ {{1349,128}, {2644,106}, {5260,106}}, /* Q ==13 : 81-87% */
{{1455,128}, {2422,124}, {4174,124}}, /* Q ==14 : 87-93% */ {{1455,128}, {2422,124}, {4174,124}}, /* Q ==14 : 87-93% */
{{ 722,128}, {1891,145}, {1936,146}}, /* Q ==15 : 93-99% */ {{ 722,128}, {1891,145}, {1936,146}}, /* Q ==15 : 93-99% */
}; };
#endif
/** HUF_selectDecoder() : /** HUF_selectDecoder() :
* Tells which decoder is likely to decode faster, * Tells which decoder is likely to decode faster,
* based on a set of pre-computed metrics. * based on a set of pre-computed metrics.
* @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 . * @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 .
* Assumption : 0 < dstSize <= 128 KB */ * Assumption : 0 < dstSize <= 128 KB */
U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize) U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize)
{ {
assert(dstSize > 0); assert(dstSize > 0);
assert(dstSize <= 128*1024); assert(dstSize <= 128*1024);
#if defined(HUF_FORCE_DECOMPRESS_X1)
(void)dstSize;
(void)cSrcSize;
return 0;
#elif defined(HUF_FORCE_DECOMPRESS_X2)
(void)dstSize;
(void)cSrcSize;
return 1;
#else
/* decoder timing evaluation */ /* decoder timing evaluation */
{ U32 const Q = (cSrcSize >= dstSize) ? 15 : (U32)(cSrcSize * 16 / dstSize); /* Q < 16 */ { U32 const Q = (cSrcSize >= dstSize) ? 15 : (U32)(cSrcSize * 16 / dstSize); /* Q < 16 */
U32 const D256 = (U32)(dstSize >> 8); U32 const D256 = (U32)(dstSize >> 8);
U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256); U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256);
U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256); U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256);
DTime1 += DTime1 >> 3; /* advantage to algorithm using less memory, to reduce cache eviction */ DTime1 += DTime1 >> 3; /* advantage to algorithm using less memory, to reduce cache eviction */
return DTime1 < DTime0; return DTime1 < DTime0;
} } }
#endif
}
typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
{ {
#if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2)
static const decompressionAlgo decompress[2] = { HUF_decompress4X1, HUF_decompress4X2 }; static const decompressionAlgo decompress[2] = { HUF_decompress4X1, HUF_decompress4X2 };
#endif
/* validation checks */ /* validation checks */
if (dstSize == 0) return ERROR(dstSize_tooSmall); if (dstSize == 0) return ERROR(dstSize_tooSmall);
if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */ if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */
if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */ if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */
if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */ if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */
{ U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize); { U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
#if defined(HUF_FORCE_DECOMPRESS_X1)
(void)algoNb;
assert(algoNb == 0);
return HUF_decompress4X1(dst, dstSize, cSrc, cSrcSize);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
(void)algoNb;
assert(algoNb == 1);
return HUF_decompress4X2(dst, dstSize, cSrc, cSrcSize);
#else
return decompress[algoNb](dst, dstSize, cSrc, cSrcSize); return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);
#endif
} }
} }
size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
{ {
/* validation checks */ /* validation checks */
if (dstSize == 0) return ERROR(dstSize_tooSmall); if (dstSize == 0) return ERROR(dstSize_tooSmall);
if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */ if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */
if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */ if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */
if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */ if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */
{ U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize); { U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
#if defined(HUF_FORCE_DECOMPRESS_X1)
(void)algoNb;
assert(algoNb == 0);
return HUF_decompress4X1_DCtx(dctx, dst, dstSize, cSrc, cSrcSize);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
(void)algoNb;
assert(algoNb == 1);
return HUF_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize);
#else
return algoNb ? HUF_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) : return algoNb ? HUF_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :
HUF_decompress4X1_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ; HUF_decompress4X1_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;
#endif
} }
} }
size_t HUF_decompress4X_hufOnly(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) size_t HUF_decompress4X_hufOnly(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
{ {
U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32]; U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
return HUF_decompress4X_hufOnly_wksp(dctx, dst, dstSize, cSrc, cSrcSize, return HUF_decompress4X_hufOnly_wksp(dctx, dst, dstSize, cSrc, cSrcSize,
workSpace, sizeof(workSpace)); workSpace, sizeof(workSpace));
} }
size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst, size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst,
size_t dstSize, const void* cSrc, size_t dstSize, const void* cSrc,
size_t cSrcSize, void* workSpace, size_t cSrcSize, void* workSpace,
size_t wkspSize) size_t wkspSize)
{ {
/* validation checks */ /* validation checks */
if (dstSize == 0) return ERROR(dstSize_tooSmall); if (dstSize == 0) return ERROR(dstSize_tooSmall);
if (cSrcSize == 0) return ERROR(corruption_detected); if (cSrcSize == 0) return ERROR(corruption_detected);
{ U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize); { U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
return algoNb ? HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize): #if defined(HUF_FORCE_DECOMPRESS_X1)
(void)algoNb;
assert(algoNb == 0);
return HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
(void)algoNb;
assert(algoNb == 1);
return HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
#else
return algoNb ? HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
cSrcSize, workSpace, wkspSize):
HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize); HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
#endif
} }
} }
size_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, size_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
const void* cSrc, size_t cSrcSize, const void* cSrc, size_t cSrcSize,
void* workSpace, size_t wkspSize) void* workSpace, size_t wkspSize)
{ {
/* validation checks */ /* validation checks */
if (dstSize == 0) return ERROR(dstSize_tooSmall); if (dstSize == 0) return ERROR(dstSize_tooSmall);
if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */ if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */
if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */ if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */
if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */ if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */
{ U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize); { U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
#if defined(HUF_FORCE_DECOMPRESS_X1)
(void)algoNb;
assert(algoNb == 0);
return HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,
cSrcSize, workSpace, wkspSize);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
(void)algoNb;
assert(algoNb == 1);
return HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
cSrcSize, workSpace, wkspSize);
#else
return algoNb ? HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc, return algoNb ? HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
cSrcSize, workSpace, wkspSize): cSrcSize, workSpace, wkspSize):
HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc, HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,
cSrcSize, workSpace, wkspSize); cSrcSize, workSpace, wkspSize);
#endif
} }
} }
size_t HUF_decompress1X_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, size_t HUF_decompress1X_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize,
const void* cSrc, size_t cSrcSize) const void* cSrc, size_t cSrcSize)
{ {
U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32]; U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
return HUF_decompress1X_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, return HUF_decompress1X_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize,
workSpace, sizeof(workSpace)); workSpace, sizeof(workSpace));
} }
size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2) size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
{ {
DTableDesc const dtd = HUF_getDTableDesc(DTable); DTableDesc const dtd = HUF_getDTableDesc(DTable);
#if defined(HUF_FORCE_DECOMPRESS_X1)
(void)dtd;
assert(dtd.tableType == 0);
return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
(void)dtd;
assert(dtd.tableType == 1);
return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
#else
return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) : return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) :
HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2); HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
#endif
} }
#ifndef HUF_FORCE_DECOMPRESS_X2
size_t HUF_decompress1X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2) size_t HUF_decompress1X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2)
{ {
const BYTE* ip = (const BYTE*) cSrc; const BYTE* ip = (const BYTE*) cSrc;
size_t const hSize = HUF_readDTableX1_wksp(dctx, cSrc, cSrcSize, workSpace, wkspSize); size_t const hSize = HUF_readDTableX1_wksp(dctx, cSrc, cSrcSize, workSpace, wkspSize);
if (HUF_isError(hSize)) return hSize; if (HUF_isError(hSize)) return hSize;
if (hSize >= cSrcSize) return ERROR(srcSize_wrong); if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
ip += hSize; cSrcSize -= hSize; ip += hSize; cSrcSize -= hSize;
return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2); return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
} }
#endif
size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2) size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
{ {
DTableDesc const dtd = HUF_getDTableDesc(DTable); DTableDesc const dtd = HUF_getDTableDesc(DTable);
#if defined(HUF_FORCE_DECOMPRESS_X1)
(void)dtd;
assert(dtd.tableType == 0);
return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
(void)dtd;
assert(dtd.tableType == 1);
return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
#else
return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) : return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) :
HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2); HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
#endif
} }
size_t HUF_decompress4X_hufOnly_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2) size_t HUF_decompress4X_hufOnly_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2)
{ {
/* validation checks */ /* validation checks */
if (dstSize == 0) return ERROR(dstSize_tooSmall); if (dstSize == 0) return ERROR(dstSize_tooSmall);
if (cSrcSize == 0) return ERROR(corruption_detected); if (cSrcSize == 0) return ERROR(corruption_detected);
{ U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize); { U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
#if defined(HUF_FORCE_DECOMPRESS_X1)
(void)algoNb;
assert(algoNb == 0);
return HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
(void)algoNb;
assert(algoNb == 1);
return HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
#else
return algoNb ? HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2) : return algoNb ? HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2) :
HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2); HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
#endif
} }
} }

contrib/python-zstandard/zstd/decompress/zstd_ddict.h

  • This file was added.
/*
* Copyright (c) 2016-present, Yann Collet, 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).
* You may select, at your option, one of the above-listed licenses.
*/
#ifndef ZSTD_DDICT_H
#define ZSTD_DDICT_H
/*-*******************************************************
* Dependencies
*********************************************************/
#include <stddef.h> /* size_t */
#include "zstd.h" /* ZSTD_DDict, and several public functions */
/*-*******************************************************
* Interface
*********************************************************/
/* note: several prototypes are already published in `zstd.h` :
* ZSTD_createDDict()
* ZSTD_createDDict_byReference()
* ZSTD_createDDict_advanced()
* ZSTD_freeDDict()
* ZSTD_initStaticDDict()
* ZSTD_sizeof_DDict()
* ZSTD_estimateDDictSize()
* ZSTD_getDictID_fromDict()
*/
const void* ZSTD_DDict_dictContent(const ZSTD_DDict* ddict);
size_t ZSTD_DDict_dictSize(const ZSTD_DDict* ddict);
void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);
#endif /* ZSTD_DDICT_H */

contrib/python-zstandard/zstd/decompress/zstd_ddict.c

  • This file was added.
/*
* Copyright (c) 2016-present, Yann Collet, 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).
* You may select, at your option, one of the above-listed licenses.
*/
/* zstd_ddict.c :
* concentrates all logic that needs to know the internals of ZSTD_DDict object */
/*-*******************************************************
* Dependencies
*********************************************************/
#include <string.h> /* memcpy, memmove, memset */
#include "cpu.h" /* bmi2 */
#include "mem.h" /* low level memory routines */
#define FSE_STATIC_LINKING_ONLY
#include "fse.h"
#define HUF_STATIC_LINKING_ONLY
#include "huf.h"
#include "zstd_decompress_internal.h"
#include "zstd_ddict.h"
#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
# include "zstd_legacy.h"
#endif
/*-*******************************************************
* Types
*********************************************************/
struct ZSTD_DDict_s {
void* dictBuffer;
const void* dictContent;
size_t dictSize;
ZSTD_entropyDTables_t entropy;
U32 dictID;
U32 entropyPresent;
ZSTD_customMem cMem;
}; /* typedef'd to ZSTD_DDict within "zstd.h" */
const void* ZSTD_DDict_dictContent(const ZSTD_DDict* ddict)
{
assert(ddict != NULL);
return ddict->dictContent;
}
size_t ZSTD_DDict_dictSize(const ZSTD_DDict* ddict)
{
assert(ddict != NULL);
return ddict->dictSize;
}
void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
{
DEBUGLOG(4, "ZSTD_copyDDictParameters");
assert(dctx != NULL);
assert(ddict != NULL);
dctx->dictID = ddict->dictID;
dctx->prefixStart = ddict->dictContent;
dctx->virtualStart = ddict->dictContent;
dctx->dictEnd = (const BYTE*)ddict->dictContent + ddict->dictSize;
dctx->previousDstEnd = dctx->dictEnd;
if (ddict->entropyPresent) {
dctx->litEntropy = 1;
dctx->fseEntropy = 1;
dctx->LLTptr = ddict->entropy.LLTable;
dctx->MLTptr = ddict->entropy.MLTable;
dctx->OFTptr = ddict->entropy.OFTable;
dctx->HUFptr = ddict->entropy.hufTable;
dctx->entropy.rep[0] = ddict->entropy.rep[0];
dctx->entropy.rep[1] = ddict->entropy.rep[1];
dctx->entropy.rep[2] = ddict->entropy.rep[2];
} else {
dctx->litEntropy = 0;
dctx->fseEntropy = 0;
}
}
static size_t
ZSTD_loadEntropy_intoDDict(ZSTD_DDict* ddict,
ZSTD_dictContentType_e dictContentType)
{
ddict->dictID = 0;
ddict->entropyPresent = 0;
if (dictContentType == ZSTD_dct_rawContent) return 0;
if (ddict->dictSize < 8) {
if (dictContentType == ZSTD_dct_fullDict)
return ERROR(dictionary_corrupted); /* only accept specified dictionaries */
return 0; /* pure content mode */
}
{ U32 const magic = MEM_readLE32(ddict->dictContent);
if (magic != ZSTD_MAGIC_DICTIONARY) {
if (dictContentType == ZSTD_dct_fullDict)
return ERROR(dictionary_corrupted); /* only accept specified dictionaries */
return 0; /* pure content mode */
}
}
ddict->dictID = MEM_readLE32((const char*)ddict->dictContent + ZSTD_FRAMEIDSIZE);
/* load entropy tables */
CHECK_E( ZSTD_loadDEntropy(&ddict->entropy,
ddict->dictContent, ddict->dictSize),
dictionary_corrupted );
ddict->entropyPresent = 1;
return 0;
}
static size_t ZSTD_initDDict_internal(ZSTD_DDict* ddict,
const void* dict, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType)
{
if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dict) || (!dictSize)) {
ddict->dictBuffer = NULL;
ddict->dictContent = dict;
if (!dict) dictSize = 0;
} else {
void* const internalBuffer = ZSTD_malloc(dictSize, ddict->cMem);
ddict->dictBuffer = internalBuffer;
ddict->dictContent = internalBuffer;
if (!internalBuffer) return ERROR(memory_allocation);
memcpy(internalBuffer, dict, dictSize);
}
ddict->dictSize = dictSize;
ddict->entropy.hufTable[0] = (HUF_DTable)((HufLog)*0x1000001); /* cover both little and big endian */
/* parse dictionary content */
CHECK_F( ZSTD_loadEntropy_intoDDict(ddict, dictContentType) );
return 0;
}
ZSTD_DDict* ZSTD_createDDict_advanced(const void* dict, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType,
ZSTD_customMem customMem)
{
if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
{ ZSTD_DDict* const ddict = (ZSTD_DDict*) ZSTD_malloc(sizeof(ZSTD_DDict), customMem);
if (ddict == NULL) return NULL;
ddict->cMem = customMem;
{ size_t const initResult = ZSTD_initDDict_internal(ddict,
dict, dictSize,
dictLoadMethod, dictContentType);
if (ZSTD_isError(initResult)) {
ZSTD_freeDDict(ddict);
return NULL;
} }
return ddict;
}
}
/*! ZSTD_createDDict() :
* Create a digested dictionary, to start decompression without startup delay.
* `dict` content is copied inside DDict.
* Consequently, `dict` can be released after `ZSTD_DDict` creation */
ZSTD_DDict* ZSTD_createDDict(const void* dict, size_t dictSize)
{
ZSTD_customMem const allocator = { NULL, NULL, NULL };
return ZSTD_createDDict_advanced(dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto, allocator);
}
/*! ZSTD_createDDict_byReference() :
* Create a digested dictionary, to start decompression without startup delay.
* Dictionary content is simply referenced, it will be accessed during decompression.
* Warning : dictBuffer must outlive DDict (DDict must be freed before dictBuffer) */
ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize)
{
ZSTD_customMem const allocator = { NULL, NULL, NULL };
return ZSTD_createDDict_advanced(dictBuffer, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto, allocator);
}
const ZSTD_DDict* ZSTD_initStaticDDict(
void* sBuffer, size_t sBufferSize,
const void* dict, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType)
{
size_t const neededSpace = sizeof(ZSTD_DDict)
+ (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);
ZSTD_DDict* const ddict = (ZSTD_DDict*)sBuffer;
assert(sBuffer != NULL);
assert(dict != NULL);
if ((size_t)sBuffer & 7) return NULL; /* 8-aligned */
if (sBufferSize < neededSpace) return NULL;
if (dictLoadMethod == ZSTD_dlm_byCopy) {
memcpy(ddict+1, dict, dictSize); /* local copy */
dict = ddict+1;
}
if (ZSTD_isError( ZSTD_initDDict_internal(ddict,
dict, dictSize,
ZSTD_dlm_byRef, dictContentType) ))
return NULL;
return ddict;
}
size_t ZSTD_freeDDict(ZSTD_DDict* ddict)
{
if (ddict==NULL) return 0; /* support free on NULL */
{ ZSTD_customMem const cMem = ddict->cMem;
ZSTD_free(ddict->dictBuffer, cMem);
ZSTD_free(ddict, cMem);
return 0;
}
}
/*! ZSTD_estimateDDictSize() :
* Estimate amount of memory that will be needed to create a dictionary for decompression.
* Note : dictionary created by reference using ZSTD_dlm_byRef are smaller */
size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod)
{
return sizeof(ZSTD_DDict) + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);
}
size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict)
{
if (ddict==NULL) return 0; /* support sizeof on NULL */
return sizeof(*ddict) + (ddict->dictBuffer ? ddict->dictSize : 0) ;
}
/*! ZSTD_getDictID_fromDDict() :
* Provides the dictID of the dictionary loaded into `ddict`.
* If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.
* Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */
unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict)
{
if (ddict==NULL) return 0;
return ZSTD_getDictID_fromDict(ddict->dictContent, ddict->dictSize);
}

contrib/python-zstandard/zstd/decompress/zstd_decompress.c

/*! /*!
* MAXWINDOWSIZE_DEFAULT : * MAXWINDOWSIZE_DEFAULT :
* maximum window size accepted by DStream __by default__. * maximum window size accepted by DStream __by default__.
* Frames requiring more memory will be rejected. * Frames requiring more memory will be rejected.
* It's possible to set a different limit using ZSTD_DCtx_setMaxWindowSize(). * It's possible to set a different limit using ZSTD_DCtx_setMaxWindowSize().
*/ */
#ifndef ZSTD_MAXWINDOWSIZE_DEFAULT #ifndef ZSTD_MAXWINDOWSIZE_DEFAULT
# define ZSTD_MAXWINDOWSIZE_DEFAULT (((U32)1 << ZSTD_WINDOWLOG_DEFAULTMAX) + 1) # define ZSTD_MAXWINDOWSIZE_DEFAULT (((U32)1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT) + 1)
#endif #endif
/*! /*!
* NO_FORWARD_PROGRESS_MAX : * NO_FORWARD_PROGRESS_MAX :
* maximum allowed nb of calls to ZSTD_decompressStream() and ZSTD_decompress_generic() * maximum allowed nb of calls to ZSTD_decompressStream()
* without any forward progress * without any forward progress
* (defined as: no byte read from input, and no byte flushed to output) * (defined as: no byte read from input, and no byte flushed to output)
* before triggering an error. * before triggering an error.
*/ */
#ifndef ZSTD_NO_FORWARD_PROGRESS_MAX #ifndef ZSTD_NO_FORWARD_PROGRESS_MAX
# define ZSTD_NO_FORWARD_PROGRESS_MAX 16 # define ZSTD_NO_FORWARD_PROGRESS_MAX 16
#endif #endif
/*-******************************************************* /*-*******************************************************
* Dependencies * Dependencies
*********************************************************/ *********************************************************/
#include <string.h> /* memcpy, memmove, memset */ #include <string.h> /* memcpy, memmove, memset */
#include "compiler.h" /* prefetch */
#include "cpu.h" /* bmi2 */ #include "cpu.h" /* bmi2 */
#include "mem.h" /* low level memory routines */ #include "mem.h" /* low level memory routines */
#define FSE_STATIC_LINKING_ONLY #define FSE_STATIC_LINKING_ONLY
#include "fse.h" #include "fse.h"
#define HUF_STATIC_LINKING_ONLY #define HUF_STATIC_LINKING_ONLY
#include "huf.h" #include "huf.h"
#include "zstd_internal.h" #include "zstd_internal.h" /* blockProperties_t */
#include "zstd_decompress_internal.h" /* ZSTD_DCtx */
#include "zstd_ddict.h" /* ZSTD_DDictDictContent */
#include "zstd_decompress_block.h" /* ZSTD_decompressBlock_internal */
#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1) #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
# include "zstd_legacy.h" # include "zstd_legacy.h"
#endif #endif
static const void* ZSTD_DDictDictContent(const ZSTD_DDict* ddict);
static size_t ZSTD_DDictDictSize(const ZSTD_DDict* ddict);
/*-*************************************
* Errors
***************************************/
#define ZSTD_isError ERR_isError /* for inlining */
#define FSE_isError ERR_isError
#define HUF_isError ERR_isError
/*_*******************************************************
* Memory operations
**********************************************************/
static void ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
/*-************************************************************* /*-*************************************************************
* Context management * Context management
***************************************************************/ ***************************************************************/
typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,
ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock,
ZSTDds_decompressLastBlock, ZSTDds_checkChecksum,
ZSTDds_decodeSkippableHeader, ZSTDds_skipFrame } ZSTD_dStage;
typedef enum { zdss_init=0, zdss_loadHeader,
zdss_read, zdss_load, zdss_flush } ZSTD_dStreamStage;
typedef struct {
U32 fastMode;
U32 tableLog;
} ZSTD_seqSymbol_header;
typedef struct {
U16 nextState;
BYTE nbAdditionalBits;
BYTE nbBits;
U32 baseValue;
} ZSTD_seqSymbol;
#define SEQSYMBOL_TABLE_SIZE(log) (1 + (1 << (log)))
typedef struct {
ZSTD_seqSymbol LLTable[SEQSYMBOL_TABLE_SIZE(LLFSELog)]; /* Note : Space reserved for FSE Tables */
ZSTD_seqSymbol OFTable[SEQSYMBOL_TABLE_SIZE(OffFSELog)]; /* is also used as temporary workspace while building hufTable during DDict creation */
ZSTD_seqSymbol MLTable[SEQSYMBOL_TABLE_SIZE(MLFSELog)]; /* and therefore must be at least HUF_DECOMPRESS_WORKSPACE_SIZE large */
HUF_DTable hufTable[HUF_DTABLE_SIZE(HufLog)]; /* can accommodate HUF_decompress4X */
U32 rep[ZSTD_REP_NUM];
} ZSTD_entropyDTables_t;
struct ZSTD_DCtx_s
{
const ZSTD_seqSymbol* LLTptr;
const ZSTD_seqSymbol* MLTptr;
const ZSTD_seqSymbol* OFTptr;
const HUF_DTable* HUFptr;
ZSTD_entropyDTables_t entropy;
U32 workspace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32]; /* space needed when building huffman tables */
const void* previousDstEnd; /* detect continuity */
const void* prefixStart; /* start of current segment */
const void* virtualStart; /* virtual start of previous segment if it was just before current one */
const void* dictEnd; /* end of previous segment */
size_t expected;
ZSTD_frameHeader fParams;
U64 decodedSize;
blockType_e bType; /* used in ZSTD_decompressContinue(), store blockType between block header decoding and block decompression stages */
ZSTD_dStage stage;
U32 litEntropy;
U32 fseEntropy;
XXH64_state_t xxhState;
size_t headerSize;
ZSTD_format_e format;
const BYTE* litPtr;
ZSTD_customMem customMem;
size_t litSize;
size_t rleSize;
size_t staticSize;
int bmi2; /* == 1 if the CPU supports BMI2 and 0 otherwise. CPU support is determined dynamically once per context lifetime. */
/* dictionary */
ZSTD_DDict* ddictLocal;
const ZSTD_DDict* ddict; /* set by ZSTD_initDStream_usingDDict(), or ZSTD_DCtx_refDDict() */
U32 dictID;
int ddictIsCold; /* if == 1 : dictionary is "new" for working context, and presumed "cold" (not in cpu cache) */
/* streaming */
ZSTD_dStreamStage streamStage;
char* inBuff;
size_t inBuffSize;
size_t inPos;
size_t maxWindowSize;
char* outBuff;
size_t outBuffSize;
size_t outStart;
size_t outEnd;
size_t lhSize;
void* legacyContext;
U32 previousLegacyVersion;
U32 legacyVersion;
U32 hostageByte;
int noForwardProgress;
/* workspace */
BYTE litBuffer[ZSTD_BLOCKSIZE_MAX + WILDCOPY_OVERLENGTH];
BYTE headerBuffer[ZSTD_FRAMEHEADERSIZE_MAX];
}; /* typedef'd to ZSTD_DCtx within "zstd.h" */
size_t ZSTD_sizeof_DCtx (const ZSTD_DCtx* dctx) size_t ZSTD_sizeof_DCtx (const ZSTD_DCtx* dctx)
{ {
if (dctx==NULL) return 0; /* support sizeof NULL */ if (dctx==NULL) return 0; /* support sizeof NULL */
return sizeof(*dctx) return sizeof(*dctx)
+ ZSTD_sizeof_DDict(dctx->ddictLocal) + ZSTD_sizeof_DDict(dctx->ddictLocal)
+ dctx->inBuffSize + dctx->outBuffSize; + dctx->inBuffSize + dctx->outBuffSize;
} }
size_t ZSTD_estimateDCtxSize(void) { return sizeof(ZSTD_DCtx); } size_t ZSTD_estimateDCtxSize(void) { return sizeof(ZSTD_DCtx); }
static size_t ZSTD_startingInputLength(ZSTD_format_e format) static size_t ZSTD_startingInputLength(ZSTD_format_e format)
{ {
size_t const startingInputLength = (format==ZSTD_f_zstd1_magicless) ? size_t const startingInputLength = (format==ZSTD_f_zstd1_magicless) ?
ZSTD_frameHeaderSize_prefix - ZSTD_FRAMEIDSIZE : ZSTD_FRAMEHEADERSIZE_PREFIX - ZSTD_FRAMEIDSIZE :
ZSTD_frameHeaderSize_prefix; ZSTD_FRAMEHEADERSIZE_PREFIX;
ZSTD_STATIC_ASSERT(ZSTD_FRAMEHEADERSIZE_PREFIX >= ZSTD_FRAMEIDSIZE); ZSTD_STATIC_ASSERT(ZSTD_FRAMEHEADERSIZE_PREFIX >= ZSTD_FRAMEIDSIZE);
/* only supports formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless */ /* only supports formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless */
assert( (format == ZSTD_f_zstd1) || (format == ZSTD_f_zstd1_magicless) ); assert( (format == ZSTD_f_zstd1) || (format == ZSTD_f_zstd1_magicless) );
return startingInputLength; return startingInputLength;
} }
static void ZSTD_initDCtx_internal(ZSTD_DCtx* dctx) static void ZSTD_initDCtx_internal(ZSTD_DCtx* dctx)
{ {
* Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0. * Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
* Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled. * Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled.
* Note 3 : Skippable Frame Identifiers are considered valid. */ * Note 3 : Skippable Frame Identifiers are considered valid. */
unsigned ZSTD_isFrame(const void* buffer, size_t size) unsigned ZSTD_isFrame(const void* buffer, size_t size)
{ {
if (size < ZSTD_FRAMEIDSIZE) return 0; if (size < ZSTD_FRAMEIDSIZE) return 0;
{ U32 const magic = MEM_readLE32(buffer); { U32 const magic = MEM_readLE32(buffer);
if (magic == ZSTD_MAGICNUMBER) return 1; if (magic == ZSTD_MAGICNUMBER) return 1;
if ((magic & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) return 1; if ((magic & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) return 1;
} }
#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1) #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
if (ZSTD_isLegacy(buffer, size)) return 1; if (ZSTD_isLegacy(buffer, size)) return 1;
#endif #endif
return 0; return 0;
} }
/** ZSTD_frameHeaderSize_internal() : /** ZSTD_frameHeaderSize_internal() :
size_t const minInputSize = ZSTD_startingInputLength(format); size_t const minInputSize = ZSTD_startingInputLength(format);
memset(zfhPtr, 0, sizeof(*zfhPtr)); /* not strictly necessary, but static analyzer do not understand that zfhPtr is only going to be read only if return value is zero, since they are 2 different signals */ memset(zfhPtr, 0, sizeof(*zfhPtr)); /* not strictly necessary, but static analyzer do not understand that zfhPtr is only going to be read only if return value is zero, since they are 2 different signals */
if (srcSize < minInputSize) return minInputSize; if (srcSize < minInputSize) return minInputSize;
if (src==NULL) return ERROR(GENERIC); /* invalid parameter */ if (src==NULL) return ERROR(GENERIC); /* invalid parameter */
if ( (format != ZSTD_f_zstd1_magicless) if ( (format != ZSTD_f_zstd1_magicless)
&& (MEM_readLE32(src) != ZSTD_MAGICNUMBER) ) { && (MEM_readLE32(src) != ZSTD_MAGICNUMBER) ) {
if ((MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) { if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
/* skippable frame */ /* skippable frame */
if (srcSize < ZSTD_skippableHeaderSize) if (srcSize < ZSTD_SKIPPABLEHEADERSIZE)
return ZSTD_skippableHeaderSize; /* magic number + frame length */ return ZSTD_SKIPPABLEHEADERSIZE; /* magic number + frame length */
memset(zfhPtr, 0, sizeof(*zfhPtr)); memset(zfhPtr, 0, sizeof(*zfhPtr));
zfhPtr->frameContentSize = MEM_readLE32((const char *)src + ZSTD_FRAMEIDSIZE); zfhPtr->frameContentSize = MEM_readLE32((const char *)src + ZSTD_FRAMEIDSIZE);
zfhPtr->frameType = ZSTD_skippableFrame; zfhPtr->frameType = ZSTD_skippableFrame;
return 0; return 0;
} }
return ERROR(prefix_unknown); return ERROR(prefix_unknown);
} }
return ZSTD_CONTENTSIZE_ERROR; return ZSTD_CONTENTSIZE_ERROR;
if (zfh.frameType == ZSTD_skippableFrame) { if (zfh.frameType == ZSTD_skippableFrame) {
return 0; return 0;
} else { } else {
return zfh.frameContentSize; return zfh.frameContentSize;
} } } }
} }
static size_t readSkippableFrameSize(void const* src, size_t srcSize)
{
size_t const skippableHeaderSize = ZSTD_SKIPPABLEHEADERSIZE;
U32 sizeU32;
if (srcSize < ZSTD_SKIPPABLEHEADERSIZE)
return ERROR(srcSize_wrong);
sizeU32 = MEM_readLE32((BYTE const*)src + ZSTD_FRAMEIDSIZE);
if ((U32)(sizeU32 + ZSTD_SKIPPABLEHEADERSIZE) < sizeU32)
return ERROR(frameParameter_unsupported);
return skippableHeaderSize + sizeU32;
}
/** ZSTD_findDecompressedSize() : /** ZSTD_findDecompressedSize() :
* compatible with legacy mode * compatible with legacy mode
* `srcSize` must be the exact length of some number of ZSTD compressed and/or * `srcSize` must be the exact length of some number of ZSTD compressed and/or
* skippable frames * skippable frames
* @return : decompressed size of the frames contained */ * @return : decompressed size of the frames contained */
unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize) unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize)
{ {
unsigned long long totalDstSize = 0; unsigned long long totalDstSize = 0;
while (srcSize >= ZSTD_frameHeaderSize_prefix) { while (srcSize >= ZSTD_FRAMEHEADERSIZE_PREFIX) {
U32 const magicNumber = MEM_readLE32(src); U32 const magicNumber = MEM_readLE32(src);
if ((magicNumber & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) { if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
size_t skippableSize; size_t const skippableSize = readSkippableFrameSize(src, srcSize);
if (srcSize < ZSTD_skippableHeaderSize) if (ZSTD_isError(skippableSize))
return ERROR(srcSize_wrong); return skippableSize;
skippableSize = MEM_readLE32((const BYTE *)src + ZSTD_FRAMEIDSIZE)
+ ZSTD_skippableHeaderSize;
if (srcSize < skippableSize) { if (srcSize < skippableSize) {
return ZSTD_CONTENTSIZE_ERROR; return ZSTD_CONTENTSIZE_ERROR;
} }
src = (const BYTE *)src + skippableSize; src = (const BYTE *)src + skippableSize;
srcSize -= skippableSize; srcSize -= skippableSize;
continue; continue;
} }
} /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */ } /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */
if (srcSize) return ZSTD_CONTENTSIZE_ERROR; if (srcSize) return ZSTD_CONTENTSIZE_ERROR;
return totalDstSize; return totalDstSize;
} }
/** ZSTD_getDecompressedSize() : /** ZSTD_getDecompressedSize() :
* compatible with legacy mode * compatible with legacy mode
* @return : decompressed size if known, 0 otherwise * @return : decompressed size if known, 0 otherwise
note : 0 can mean any of the following : note : 0 can mean any of the following :
- frame content is empty - frame content is empty
- decompressed size field is not present in frame header - decompressed size field is not present in frame header
- frame header unknown / not supported - frame header unknown / not supported
- frame header not complete (`srcSize` too small) */ - frame header not complete (`srcSize` too small) */
unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize) unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize)
{ {
unsigned long long const ret = ZSTD_getFrameContentSize(src, srcSize); unsigned long long const ret = ZSTD_getFrameContentSize(src, srcSize);
ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_ERROR < ZSTD_CONTENTSIZE_UNKNOWN); ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_ERROR < ZSTD_CONTENTSIZE_UNKNOWN);
return (ret >= ZSTD_CONTENTSIZE_ERROR) ? 0 : ret; return (ret >= ZSTD_CONTENTSIZE_ERROR) ? 0 : ret;
} }
/** ZSTD_decodeFrameHeader() : /** ZSTD_decodeFrameHeader() :
* `headerSize` must be the size provided by ZSTD_frameHeaderSize(). * `headerSize` must be the size provided by ZSTD_frameHeaderSize().
* @return : 0 if success, or an error code, which can be tested using ZSTD_isError() */ * @return : 0 if success, or an error code, which can be tested using ZSTD_isError() */
static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* dctx, const void* src, size_t headerSize) static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* dctx, const void* src, size_t headerSize)
{ {
size_t const result = ZSTD_getFrameHeader_advanced(&(dctx->fParams), src, headerSize, dctx->format); size_t const result = ZSTD_getFrameHeader_advanced(&(dctx->fParams), src, headerSize, dctx->format);
if (ZSTD_isError(result)) return result; /* invalid header */ if (ZSTD_isError(result)) return result; /* invalid header */
if (result>0) return ERROR(srcSize_wrong); /* headerSize too small */ if (result>0) return ERROR(srcSize_wrong); /* headerSize too small */
if (dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID)) if (dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID))
return ERROR(dictionary_wrong); return ERROR(dictionary_wrong);
if (dctx->fParams.checksumFlag) XXH64_reset(&dctx->xxhState, 0); if (dctx->fParams.checksumFlag) XXH64_reset(&dctx->xxhState, 0);
return 0; return 0;
} }
/*-*************************************************************
* Block decoding
***************************************************************/
/*! ZSTD_getcBlockSize() :
* Provides the size of compressed block from block header `src` */
size_t ZSTD_getcBlockSize(const void* src, size_t srcSize,
blockProperties_t* bpPtr)
{
if (srcSize < ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
{ U32 const cBlockHeader = MEM_readLE24(src);
U32 const cSize = cBlockHeader >> 3;
bpPtr->lastBlock = cBlockHeader & 1;
bpPtr->blockType = (blockType_e)((cBlockHeader >> 1) & 3);
bpPtr->origSize = cSize; /* only useful for RLE */
if (bpPtr->blockType == bt_rle) return 1;
if (bpPtr->blockType == bt_reserved) return ERROR(corruption_detected);
return cSize;
}
}
static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity,
const void* src, size_t srcSize)
{
if (dst==NULL) return ERROR(dstSize_tooSmall);
if (srcSize > dstCapacity) return ERROR(dstSize_tooSmall);
memcpy(dst, src, srcSize);
return srcSize;
}
static size_t ZSTD_setRleBlock(void* dst, size_t dstCapacity,
const void* src, size_t srcSize,
size_t regenSize)
{
if (srcSize != 1) return ERROR(srcSize_wrong);
if (regenSize > dstCapacity) return ERROR(dstSize_tooSmall);
memset(dst, *(const BYTE*)src, regenSize);
return regenSize;
}
/* Hidden declaration for fullbench */
size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
const void* src, size_t srcSize);
/*! ZSTD_decodeLiteralsBlock() :
* @return : nb of bytes read from src (< srcSize )
* note : symbol not declared but exposed for fullbench */
size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
const void* src, size_t srcSize) /* note : srcSize < BLOCKSIZE */
{
if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);
{ const BYTE* const istart = (const BYTE*) src;
symbolEncodingType_e const litEncType = (symbolEncodingType_e)(istart[0] & 3);
switch(litEncType)
{
case set_repeat:
if (dctx->litEntropy==0) return ERROR(dictionary_corrupted);
/* fall-through */
case set_compressed:
if (srcSize < 5) return ERROR(corruption_detected); /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for case 3 */
{ size_t lhSize, litSize, litCSize;
U32 singleStream=0;
U32 const lhlCode = (istart[0] >> 2) & 3;
U32 const lhc = MEM_readLE32(istart);
switch(lhlCode)
{
case 0: case 1: default: /* note : default is impossible, since lhlCode into [0..3] */
/* 2 - 2 - 10 - 10 */
singleStream = !lhlCode;
lhSize = 3;
litSize = (lhc >> 4) & 0x3FF;
litCSize = (lhc >> 14) & 0x3FF;
break;
case 2:
/* 2 - 2 - 14 - 14 */
lhSize = 4;
litSize = (lhc >> 4) & 0x3FFF;
litCSize = lhc >> 18;
break;
case 3:
/* 2 - 2 - 18 - 18 */
lhSize = 5;
litSize = (lhc >> 4) & 0x3FFFF;
litCSize = (lhc >> 22) + (istart[4] << 10);
break;
}
if (litSize > ZSTD_BLOCKSIZE_MAX) return ERROR(corruption_detected);
if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);
/* prefetch huffman table if cold */
if (dctx->ddictIsCold && (litSize > 768 /* heuristic */)) {
PREFETCH_AREA(dctx->HUFptr, sizeof(dctx->entropy.hufTable));
}
if (HUF_isError((litEncType==set_repeat) ?
( singleStream ?
HUF_decompress1X_usingDTable_bmi2(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->HUFptr, dctx->bmi2) :
HUF_decompress4X_usingDTable_bmi2(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->HUFptr, dctx->bmi2) ) :
( singleStream ?
HUF_decompress1X1_DCtx_wksp_bmi2(dctx->entropy.hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize,
dctx->workspace, sizeof(dctx->workspace), dctx->bmi2) :
HUF_decompress4X_hufOnly_wksp_bmi2(dctx->entropy.hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize,
dctx->workspace, sizeof(dctx->workspace), dctx->bmi2))))
return ERROR(corruption_detected);
dctx->litPtr = dctx->litBuffer;
dctx->litSize = litSize;
dctx->litEntropy = 1;
if (litEncType==set_compressed) dctx->HUFptr = dctx->entropy.hufTable;
memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
return litCSize + lhSize;
}
case set_basic:
{ size_t litSize, lhSize;
U32 const lhlCode = ((istart[0]) >> 2) & 3;
switch(lhlCode)
{
case 0: case 2: default: /* note : default is impossible, since lhlCode into [0..3] */
lhSize = 1;
litSize = istart[0] >> 3;
break;
case 1:
lhSize = 2;
litSize = MEM_readLE16(istart) >> 4;
break;
case 3:
lhSize = 3;
litSize = MEM_readLE24(istart) >> 4;
break;
}
if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) { /* risk reading beyond src buffer with wildcopy */
if (litSize+lhSize > srcSize) return ERROR(corruption_detected);
memcpy(dctx->litBuffer, istart+lhSize, litSize);
dctx->litPtr = dctx->litBuffer;
dctx->litSize = litSize;
memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
return lhSize+litSize;
}
/* direct reference into compressed stream */
dctx->litPtr = istart+lhSize;
dctx->litSize = litSize;
return lhSize+litSize;
}
case set_rle:
{ U32 const lhlCode = ((istart[0]) >> 2) & 3;
size_t litSize, lhSize;
switch(lhlCode)
{
case 0: case 2: default: /* note : default is impossible, since lhlCode into [0..3] */
lhSize = 1;
litSize = istart[0] >> 3;
break;
case 1:
lhSize = 2;
litSize = MEM_readLE16(istart) >> 4;
break;
case 3:
lhSize = 3;
litSize = MEM_readLE24(istart) >> 4;
if (srcSize<4) return ERROR(corruption_detected); /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4 */
break;
}
if (litSize > ZSTD_BLOCKSIZE_MAX) return ERROR(corruption_detected);
memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH);
dctx->litPtr = dctx->litBuffer;
dctx->litSize = litSize;
return lhSize+1;
}
default:
return ERROR(corruption_detected); /* impossible */
}
}
}
/* Default FSE distribution tables.
* These are pre-calculated FSE decoding tables using default distributions as defined in specification :
* https://github.com/facebook/zstd/blob/master/doc/zstd_compression_format.md#default-distributions
* They were generated programmatically with following method :
* - start from default distributions, present in /lib/common/zstd_internal.h
* - generate tables normally, using ZSTD_buildFSETable()
* - printout the content of tables
* - pretify output, report below, test with fuzzer to ensure it's correct */
/* Default FSE distribution table for Literal Lengths */
static const ZSTD_seqSymbol LL_defaultDTable[(1<<LL_DEFAULTNORMLOG)+1] = {
{ 1, 1, 1, LL_DEFAULTNORMLOG}, /* header : fastMode, tableLog */
/* nextState, nbAddBits, nbBits, baseVal */
{ 0, 0, 4, 0}, { 16, 0, 4, 0},
{ 32, 0, 5, 1}, { 0, 0, 5, 3},
{ 0, 0, 5, 4}, { 0, 0, 5, 6},
{ 0, 0, 5, 7}, { 0, 0, 5, 9},
{ 0, 0, 5, 10}, { 0, 0, 5, 12},
{ 0, 0, 6, 14}, { 0, 1, 5, 16},
{ 0, 1, 5, 20}, { 0, 1, 5, 22},
{ 0, 2, 5, 28}, { 0, 3, 5, 32},
{ 0, 4, 5, 48}, { 32, 6, 5, 64},
{ 0, 7, 5, 128}, { 0, 8, 6, 256},
{ 0, 10, 6, 1024}, { 0, 12, 6, 4096},
{ 32, 0, 4, 0}, { 0, 0, 4, 1},
{ 0, 0, 5, 2}, { 32, 0, 5, 4},
{ 0, 0, 5, 5}, { 32, 0, 5, 7},
{ 0, 0, 5, 8}, { 32, 0, 5, 10},
{ 0, 0, 5, 11}, { 0, 0, 6, 13},
{ 32, 1, 5, 16}, { 0, 1, 5, 18},
{ 32, 1, 5, 22}, { 0, 2, 5, 24},
{ 32, 3, 5, 32}, { 0, 3, 5, 40},
{ 0, 6, 4, 64}, { 16, 6, 4, 64},
{ 32, 7, 5, 128}, { 0, 9, 6, 512},
{ 0, 11, 6, 2048}, { 48, 0, 4, 0},
{ 16, 0, 4, 1}, { 32, 0, 5, 2},
{ 32, 0, 5, 3}, { 32, 0, 5, 5},
{ 32, 0, 5, 6}, { 32, 0, 5, 8},
{ 32, 0, 5, 9}, { 32, 0, 5, 11},
{ 32, 0, 5, 12}, { 0, 0, 6, 15},
{ 32, 1, 5, 18}, { 32, 1, 5, 20},
{ 32, 2, 5, 24}, { 32, 2, 5, 28},
{ 32, 3, 5, 40}, { 32, 4, 5, 48},
{ 0, 16, 6,65536}, { 0, 15, 6,32768},
{ 0, 14, 6,16384}, { 0, 13, 6, 8192},
}; /* LL_defaultDTable */
/* Default FSE distribution table for Offset Codes */
static const ZSTD_seqSymbol OF_defaultDTable[(1<<OF_DEFAULTNORMLOG)+1] = {
{ 1, 1, 1, OF_DEFAULTNORMLOG}, /* header : fastMode, tableLog */
/* nextState, nbAddBits, nbBits, baseVal */
{ 0, 0, 5, 0}, { 0, 6, 4, 61},
{ 0, 9, 5, 509}, { 0, 15, 5,32765},
{ 0, 21, 5,2097149}, { 0, 3, 5, 5},
{ 0, 7, 4, 125}, { 0, 12, 5, 4093},
{ 0, 18, 5,262141}, { 0, 23, 5,8388605},
{ 0, 5, 5, 29}, { 0, 8, 4, 253},
{ 0, 14, 5,16381}, { 0, 20, 5,1048573},
{ 0, 2, 5, 1}, { 16, 7, 4, 125},
{ 0, 11, 5, 2045}, { 0, 17, 5,131069},
{ 0, 22, 5,4194301}, { 0, 4, 5, 13},
{ 16, 8, 4, 253}, { 0, 13, 5, 8189},
{ 0, 19, 5,524285}, { 0, 1, 5, 1},
{ 16, 6, 4, 61}, { 0, 10, 5, 1021},
{ 0, 16, 5,65533}, { 0, 28, 5,268435453},
{ 0, 27, 5,134217725}, { 0, 26, 5,67108861},
{ 0, 25, 5,33554429}, { 0, 24, 5,16777213},
}; /* OF_defaultDTable */
/* Default FSE distribution table for Match Lengths */
static const ZSTD_seqSymbol ML_defaultDTable[(1<<ML_DEFAULTNORMLOG)+1] = {
{ 1, 1, 1, ML_DEFAULTNORMLOG}, /* header : fastMode, tableLog */
/* nextState, nbAddBits, nbBits, baseVal */
{ 0, 0, 6, 3}, { 0, 0, 4, 4},
{ 32, 0, 5, 5}, { 0, 0, 5, 6},
{ 0, 0, 5, 8}, { 0, 0, 5, 9},
{ 0, 0, 5, 11}, { 0, 0, 6, 13},
{ 0, 0, 6, 16}, { 0, 0, 6, 19},
{ 0, 0, 6, 22}, { 0, 0, 6, 25},
{ 0, 0, 6, 28}, { 0, 0, 6, 31},
{ 0, 0, 6, 34}, { 0, 1, 6, 37},
{ 0, 1, 6, 41}, { 0, 2, 6, 47},
{ 0, 3, 6, 59}, { 0, 4, 6, 83},
{ 0, 7, 6, 131}, { 0, 9, 6, 515},
{ 16, 0, 4, 4}, { 0, 0, 4, 5},
{ 32, 0, 5, 6}, { 0, 0, 5, 7},
{ 32, 0, 5, 9}, { 0, 0, 5, 10},
{ 0, 0, 6, 12}, { 0, 0, 6, 15},
{ 0, 0, 6, 18}, { 0, 0, 6, 21},
{ 0, 0, 6, 24}, { 0, 0, 6, 27},
{ 0, 0, 6, 30}, { 0, 0, 6, 33},
{ 0, 1, 6, 35}, { 0, 1, 6, 39},
{ 0, 2, 6, 43}, { 0, 3, 6, 51},
{ 0, 4, 6, 67}, { 0, 5, 6, 99},
{ 0, 8, 6, 259}, { 32, 0, 4, 4},
{ 48, 0, 4, 4}, { 16, 0, 4, 5},
{ 32, 0, 5, 7}, { 32, 0, 5, 8},
{ 32, 0, 5, 10}, { 32, 0, 5, 11},
{ 0, 0, 6, 14}, { 0, 0, 6, 17},
{ 0, 0, 6, 20}, { 0, 0, 6, 23},
{ 0, 0, 6, 26}, { 0, 0, 6, 29},
{ 0, 0, 6, 32}, { 0, 16, 6,65539},
{ 0, 15, 6,32771}, { 0, 14, 6,16387},
{ 0, 13, 6, 8195}, { 0, 12, 6, 4099},
{ 0, 11, 6, 2051}, { 0, 10, 6, 1027},
}; /* ML_defaultDTable */
static void ZSTD_buildSeqTable_rle(ZSTD_seqSymbol* dt, U32 baseValue, U32 nbAddBits)
{
void* ptr = dt;
ZSTD_seqSymbol_header* const DTableH = (ZSTD_seqSymbol_header*)ptr;
ZSTD_seqSymbol* const cell = dt + 1;
DTableH->tableLog = 0;
DTableH->fastMode = 0;
cell->nbBits = 0;
cell->nextState = 0;
assert(nbAddBits < 255);
cell->nbAdditionalBits = (BYTE)nbAddBits;
cell->baseValue = baseValue;
}
/* ZSTD_buildFSETable() :
* generate FSE decoding table for one symbol (ll, ml or off) */
static void
ZSTD_buildFSETable(ZSTD_seqSymbol* dt,
const short* normalizedCounter, unsigned maxSymbolValue,
const U32* baseValue, const U32* nbAdditionalBits,
unsigned tableLog)
{
ZSTD_seqSymbol* const tableDecode = dt+1;
U16 symbolNext[MaxSeq+1];
U32 const maxSV1 = maxSymbolValue + 1;
U32 const tableSize = 1 << tableLog;
U32 highThreshold = tableSize-1;
/* Sanity Checks */
assert(maxSymbolValue <= MaxSeq);
assert(tableLog <= MaxFSELog);
/* Init, lay down lowprob symbols */
{ ZSTD_seqSymbol_header DTableH;
DTableH.tableLog = tableLog;
DTableH.fastMode = 1;
{ S16 const largeLimit= (S16)(1 << (tableLog-1));
U32 s;
for (s=0; s<maxSV1; s++) {
if (normalizedCounter[s]==-1) {
tableDecode[highThreshold--].baseValue = s;
symbolNext[s] = 1;
} else {
if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
symbolNext[s] = normalizedCounter[s];
} } }
memcpy(dt, &DTableH, sizeof(DTableH));
}
/* Spread symbols */
{ U32 const tableMask = tableSize-1;
U32 const step = FSE_TABLESTEP(tableSize);
U32 s, position = 0;
for (s=0; s<maxSV1; s++) {
int i;
for (i=0; i<normalizedCounter[s]; i++) {
tableDecode[position].baseValue = s;
position = (position + step) & tableMask;
while (position > highThreshold) position = (position + step) & tableMask; /* lowprob area */
} }
assert(position == 0); /* position must reach all cells once, otherwise normalizedCounter is incorrect */
}
/* Build Decoding table */
{ U32 u;
for (u=0; u<tableSize; u++) {
U32 const symbol = tableDecode[u].baseValue;
U32 const nextState = symbolNext[symbol]++;
tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) );
tableDecode[u].nextState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
assert(nbAdditionalBits[symbol] < 255);
tableDecode[u].nbAdditionalBits = (BYTE)nbAdditionalBits[symbol];
tableDecode[u].baseValue = baseValue[symbol];
} }
}
/*! ZSTD_buildSeqTable() :
* @return : nb bytes read from src,
* or an error code if it fails */
static size_t ZSTD_buildSeqTable(ZSTD_seqSymbol* DTableSpace, const ZSTD_seqSymbol** DTablePtr,
symbolEncodingType_e type, U32 max, U32 maxLog,
const void* src, size_t srcSize,
const U32* baseValue, const U32* nbAdditionalBits,
const ZSTD_seqSymbol* defaultTable, U32 flagRepeatTable,
int ddictIsCold, int nbSeq)
{
switch(type)
{
case set_rle :
if (!srcSize) return ERROR(srcSize_wrong);
if ( (*(const BYTE*)src) > max) return ERROR(corruption_detected);
{ U32 const symbol = *(const BYTE*)src;
U32 const baseline = baseValue[symbol];
U32 const nbBits = nbAdditionalBits[symbol];
ZSTD_buildSeqTable_rle(DTableSpace, baseline, nbBits);
}
*DTablePtr = DTableSpace;
return 1;
case set_basic :
*DTablePtr = defaultTable;
return 0;
case set_repeat:
if (!flagRepeatTable) return ERROR(corruption_detected);
/* prefetch FSE table if used */
if (ddictIsCold && (nbSeq > 24 /* heuristic */)) {
const void* const pStart = *DTablePtr;
size_t const pSize = sizeof(ZSTD_seqSymbol) * (SEQSYMBOL_TABLE_SIZE(maxLog));
PREFETCH_AREA(pStart, pSize);
}
return 0;
case set_compressed :
{ U32 tableLog;
S16 norm[MaxSeq+1];
size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize);
if (FSE_isError(headerSize)) return ERROR(corruption_detected);
if (tableLog > maxLog) return ERROR(corruption_detected);
ZSTD_buildFSETable(DTableSpace, norm, max, baseValue, nbAdditionalBits, tableLog);
*DTablePtr = DTableSpace;
return headerSize;
}
default : /* impossible */
assert(0);
return ERROR(GENERIC);
}
}
static const U32 LL_base[MaxLL+1] = {
0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15,
16, 18, 20, 22, 24, 28, 32, 40,
48, 64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000,
0x2000, 0x4000, 0x8000, 0x10000 };
static const U32 OF_base[MaxOff+1] = {
0, 1, 1, 5, 0xD, 0x1D, 0x3D, 0x7D,
0xFD, 0x1FD, 0x3FD, 0x7FD, 0xFFD, 0x1FFD, 0x3FFD, 0x7FFD,
0xFFFD, 0x1FFFD, 0x3FFFD, 0x7FFFD, 0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD,
0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD, 0x1FFFFFFD, 0x3FFFFFFD, 0x7FFFFFFD };
static const U32 OF_bits[MaxOff+1] = {
0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31 };
static const U32 ML_base[MaxML+1] = {
3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25, 26,
27, 28, 29, 30, 31, 32, 33, 34,
35, 37, 39, 41, 43, 47, 51, 59,
67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803,
0x1003, 0x2003, 0x4003, 0x8003, 0x10003 };
/* Hidden delcaration for fullbench */
size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,
const void* src, size_t srcSize);
size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,
const void* src, size_t srcSize)
{
const BYTE* const istart = (const BYTE* const)src;
const BYTE* const iend = istart + srcSize;
const BYTE* ip = istart;
int nbSeq;
DEBUGLOG(5, "ZSTD_decodeSeqHeaders");
/* check */
if (srcSize < MIN_SEQUENCES_SIZE) return ERROR(srcSize_wrong);
/* SeqHead */
nbSeq = *ip++;
if (!nbSeq) { *nbSeqPtr=0; return 1; }
if (nbSeq > 0x7F) {
if (nbSeq == 0xFF) {
if (ip+2 > iend) return ERROR(srcSize_wrong);
nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2;
} else {
if (ip >= iend) return ERROR(srcSize_wrong);
nbSeq = ((nbSeq-0x80)<<8) + *ip++;
}
}
*nbSeqPtr = nbSeq;
/* FSE table descriptors */
if (ip+4 > iend) return ERROR(srcSize_wrong); /* minimum possible size */
{ symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6);
symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3);
symbolEncodingType_e const MLtype = (symbolEncodingType_e)((*ip >> 2) & 3);
ip++;
/* Build DTables */
{ size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr,
LLtype, MaxLL, LLFSELog,
ip, iend-ip,
LL_base, LL_bits,
LL_defaultDTable, dctx->fseEntropy,
dctx->ddictIsCold, nbSeq);
if (ZSTD_isError(llhSize)) return ERROR(corruption_detected);
ip += llhSize;
}
{ size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr,
OFtype, MaxOff, OffFSELog,
ip, iend-ip,
OF_base, OF_bits,
OF_defaultDTable, dctx->fseEntropy,
dctx->ddictIsCold, nbSeq);
if (ZSTD_isError(ofhSize)) return ERROR(corruption_detected);
ip += ofhSize;
}
{ size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr,
MLtype, MaxML, MLFSELog,
ip, iend-ip,
ML_base, ML_bits,
ML_defaultDTable, dctx->fseEntropy,
dctx->ddictIsCold, nbSeq);
if (ZSTD_isError(mlhSize)) return ERROR(corruption_detected);
ip += mlhSize;
}
}
/* prefetch dictionary content */
if (dctx->ddictIsCold) {
size_t const dictSize = (const char*)dctx->prefixStart - (const char*)dctx->virtualStart;
size_t const psmin = MIN(dictSize, (size_t)(64*nbSeq) /* heuristic */ );
size_t const pSize = MIN(psmin, 128 KB /* protection */ );
const void* const pStart = (const char*)dctx->dictEnd - pSize;
PREFETCH_AREA(pStart, pSize);
dctx->ddictIsCold = 0;
}
return ip-istart;
}
typedef struct {
size_t litLength;
size_t matchLength;
size_t offset;
const BYTE* match;
} seq_t;
typedef struct {
size_t state;
const ZSTD_seqSymbol* table;
} ZSTD_fseState;
typedef struct {
BIT_DStream_t DStream;
ZSTD_fseState stateLL;
ZSTD_fseState stateOffb;
ZSTD_fseState stateML;
size_t prevOffset[ZSTD_REP_NUM];
const BYTE* prefixStart;
const BYTE* dictEnd;
size_t pos;
} seqState_t;
FORCE_NOINLINE
size_t ZSTD_execSequenceLast7(BYTE* op,
BYTE* const oend, seq_t sequence,
const BYTE** litPtr, const BYTE* const litLimit,
const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)
{
BYTE* const oLitEnd = op + sequence.litLength;
size_t const sequenceLength = sequence.litLength + sequence.matchLength;
BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH;
const BYTE* const iLitEnd = *litPtr + sequence.litLength;
const BYTE* match = oLitEnd - sequence.offset;
/* check */
if (oMatchEnd>oend) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */
if (iLitEnd > litLimit) return ERROR(corruption_detected); /* over-read beyond lit buffer */
if (oLitEnd <= oend_w) return ERROR(GENERIC); /* Precondition */
/* copy literals */
if (op < oend_w) {
ZSTD_wildcopy(op, *litPtr, oend_w - op);
*litPtr += oend_w - op;
op = oend_w;
}
while (op < oLitEnd) *op++ = *(*litPtr)++;
/* copy Match */
if (sequence.offset > (size_t)(oLitEnd - base)) {
/* offset beyond prefix */
if (sequence.offset > (size_t)(oLitEnd - vBase)) return ERROR(corruption_detected);
match = dictEnd - (base-match);
if (match + sequence.matchLength <= dictEnd) {
memmove(oLitEnd, match, sequence.matchLength);
return sequenceLength;
}
/* span extDict & currentPrefixSegment */
{ size_t const length1 = dictEnd - match;
memmove(oLitEnd, match, length1);
op = oLitEnd + length1;
sequence.matchLength -= length1;
match = base;
} }
while (op < oMatchEnd) *op++ = *match++;
return sequenceLength;
}
HINT_INLINE
size_t ZSTD_execSequence(BYTE* op,
BYTE* const oend, seq_t sequence,
const BYTE** litPtr, const BYTE* const litLimit,
const BYTE* const prefixStart, const BYTE* const virtualStart, const BYTE* const dictEnd)
{
BYTE* const oLitEnd = op + sequence.litLength;
size_t const sequenceLength = sequence.litLength + sequence.matchLength;
BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH;
const BYTE* const iLitEnd = *litPtr + sequence.litLength;
const BYTE* match = oLitEnd - sequence.offset;
/* check */
if (oMatchEnd>oend) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */
if (iLitEnd > litLimit) return ERROR(corruption_detected); /* over-read beyond lit buffer */
if (oLitEnd>oend_w) return ZSTD_execSequenceLast7(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd);
/* copy Literals */
ZSTD_copy8(op, *litPtr);
if (sequence.litLength > 8)
ZSTD_wildcopy(op+8, (*litPtr)+8, sequence.litLength - 8); /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, no risk of overwrite beyond oend */
op = oLitEnd;
*litPtr = iLitEnd; /* update for next sequence */
/* copy Match */
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
/* offset beyond prefix -> go into extDict */
if (sequence.offset > (size_t)(oLitEnd - virtualStart))
return ERROR(corruption_detected);
match = dictEnd + (match - prefixStart);
if (match + sequence.matchLength <= dictEnd) {
memmove(oLitEnd, match, sequence.matchLength);
return sequenceLength;
}
/* span extDict & currentPrefixSegment */
{ size_t const length1 = dictEnd - match;
memmove(oLitEnd, match, length1);
op = oLitEnd + length1;
sequence.matchLength -= length1;
match = prefixStart;
if (op > oend_w || sequence.matchLength < MINMATCH) {
U32 i;
for (i = 0; i < sequence.matchLength; ++i) op[i] = match[i];
return sequenceLength;
}
} }
/* Requirement: op <= oend_w && sequence.matchLength >= MINMATCH */
/* match within prefix */
if (sequence.offset < 8) {
/* close range match, overlap */
static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 }; /* added */
static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 }; /* subtracted */
int const sub2 = dec64table[sequence.offset];
op[0] = match[0];
op[1] = match[1];
op[2] = match[2];
op[3] = match[3];
match += dec32table[sequence.offset];
ZSTD_copy4(op+4, match);
match -= sub2;
} else {
ZSTD_copy8(op, match);
}
op += 8; match += 8;
if (oMatchEnd > oend-(16-MINMATCH)) {
if (op < oend_w) {
ZSTD_wildcopy(op, match, oend_w - op);
match += oend_w - op;
op = oend_w;
}
while (op < oMatchEnd) *op++ = *match++;
} else {
ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8); /* works even if matchLength < 8 */
}
return sequenceLength;
}
HINT_INLINE
size_t ZSTD_execSequenceLong(BYTE* op,
BYTE* const oend, seq_t sequence,
const BYTE** litPtr, const BYTE* const litLimit,
const BYTE* const prefixStart, const BYTE* const dictStart, const BYTE* const dictEnd)
{
BYTE* const oLitEnd = op + sequence.litLength;
size_t const sequenceLength = sequence.litLength + sequence.matchLength;
BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH;
const BYTE* const iLitEnd = *litPtr + sequence.litLength;
const BYTE* match = sequence.match;
/* check */
if (oMatchEnd > oend) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */
if (iLitEnd > litLimit) return ERROR(corruption_detected); /* over-read beyond lit buffer */
if (oLitEnd > oend_w) return ZSTD_execSequenceLast7(op, oend, sequence, litPtr, litLimit, prefixStart, dictStart, dictEnd);
/* copy Literals */
ZSTD_copy8(op, *litPtr); /* note : op <= oLitEnd <= oend_w == oend - 8 */
if (sequence.litLength > 8)
ZSTD_wildcopy(op+8, (*litPtr)+8, sequence.litLength - 8); /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, no risk of overwrite beyond oend */
op = oLitEnd;
*litPtr = iLitEnd; /* update for next sequence */
/* copy Match */
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
/* offset beyond prefix */
if (sequence.offset > (size_t)(oLitEnd - dictStart)) return ERROR(corruption_detected);
if (match + sequence.matchLength <= dictEnd) {
memmove(oLitEnd, match, sequence.matchLength);
return sequenceLength;
}
/* span extDict & currentPrefixSegment */
{ size_t const length1 = dictEnd - match;
memmove(oLitEnd, match, length1);
op = oLitEnd + length1;
sequence.matchLength -= length1;
match = prefixStart;
if (op > oend_w || sequence.matchLength < MINMATCH) {
U32 i;
for (i = 0; i < sequence.matchLength; ++i) op[i] = match[i];
return sequenceLength;
}
} }
assert(op <= oend_w);
assert(sequence.matchLength >= MINMATCH);
/* match within prefix */
if (sequence.offset < 8) {
/* close range match, overlap */
static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 }; /* added */
static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 }; /* subtracted */
int const sub2 = dec64table[sequence.offset];
op[0] = match[0];
op[1] = match[1];
op[2] = match[2];
op[3] = match[3];
match += dec32table[sequence.offset];
ZSTD_copy4(op+4, match);
match -= sub2;
} else {
ZSTD_copy8(op, match);
}
op += 8; match += 8;
if (oMatchEnd > oend-(16-MINMATCH)) {
if (op < oend_w) {
ZSTD_wildcopy(op, match, oend_w - op);
match += oend_w - op;
op = oend_w;
}
while (op < oMatchEnd) *op++ = *match++;
} else {
ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8); /* works even if matchLength < 8 */
}
return sequenceLength;
}
static void
ZSTD_initFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, const ZSTD_seqSymbol* dt)
{
const void* ptr = dt;
const ZSTD_seqSymbol_header* const DTableH = (const ZSTD_seqSymbol_header*)ptr;
DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
DEBUGLOG(6, "ZSTD_initFseState : val=%u using %u bits",
(U32)DStatePtr->state, DTableH->tableLog);
BIT_reloadDStream(bitD);
DStatePtr->table = dt + 1;
}
FORCE_INLINE_TEMPLATE void
ZSTD_updateFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD)
{
ZSTD_seqSymbol const DInfo = DStatePtr->table[DStatePtr->state];
U32 const nbBits = DInfo.nbBits;
size_t const lowBits = BIT_readBits(bitD, nbBits);
DStatePtr->state = DInfo.nextState + lowBits;
}
/* We need to add at most (ZSTD_WINDOWLOG_MAX_32 - 1) bits to read the maximum
* offset bits. But we can only read at most (STREAM_ACCUMULATOR_MIN_32 - 1)
* bits before reloading. This value is the maximum number of bytes we read
* after reloading when we are decoding long offets.
*/
#define LONG_OFFSETS_MAX_EXTRA_BITS_32 \
(ZSTD_WINDOWLOG_MAX_32 > STREAM_ACCUMULATOR_MIN_32 \
? ZSTD_WINDOWLOG_MAX_32 - STREAM_ACCUMULATOR_MIN_32 \
: 0)
typedef enum { ZSTD_lo_isRegularOffset, ZSTD_lo_isLongOffset=1 } ZSTD_longOffset_e;
FORCE_INLINE_TEMPLATE seq_t
ZSTD_decodeSequence(seqState_t* seqState, const ZSTD_longOffset_e longOffsets)
{
seq_t seq;
U32 const llBits = seqState->stateLL.table[seqState->stateLL.state].nbAdditionalBits;
U32 const mlBits = seqState->stateML.table[seqState->stateML.state].nbAdditionalBits;
U32 const ofBits = seqState->stateOffb.table[seqState->stateOffb.state].nbAdditionalBits;
U32 const totalBits = llBits+mlBits+ofBits;
U32 const llBase = seqState->stateLL.table[seqState->stateLL.state].baseValue;
U32 const mlBase = seqState->stateML.table[seqState->stateML.state].baseValue;
U32 const ofBase = seqState->stateOffb.table[seqState->stateOffb.state].baseValue;
/* sequence */
{ size_t offset;
if (!ofBits)
offset = 0;
else {
ZSTD_STATIC_ASSERT(ZSTD_lo_isLongOffset == 1);
ZSTD_STATIC_ASSERT(LONG_OFFSETS_MAX_EXTRA_BITS_32 == 5);
assert(ofBits <= MaxOff);
if (MEM_32bits() && longOffsets && (ofBits >= STREAM_ACCUMULATOR_MIN_32)) {
U32 const extraBits = ofBits - MIN(ofBits, 32 - seqState->DStream.bitsConsumed);
offset = ofBase + (BIT_readBitsFast(&seqState->DStream, ofBits - extraBits) << extraBits);
BIT_reloadDStream(&seqState->DStream);
if (extraBits) offset += BIT_readBitsFast(&seqState->DStream, extraBits);
assert(extraBits <= LONG_OFFSETS_MAX_EXTRA_BITS_32); /* to avoid another reload */
} else {
offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */
if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);
}
}
if (ofBits <= 1) {
offset += (llBase==0);
if (offset) {
size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];
seqState->prevOffset[1] = seqState->prevOffset[0];
seqState->prevOffset[0] = offset = temp;
} else { /* offset == 0 */
offset = seqState->prevOffset[0];
}
} else {
seqState->prevOffset[2] = seqState->prevOffset[1];
seqState->prevOffset[1] = seqState->prevOffset[0];
seqState->prevOffset[0] = offset;
}
seq.offset = offset;
}
seq.matchLength = mlBase
+ ((mlBits>0) ? BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/) : 0); /* <= 16 bits */
if (MEM_32bits() && (mlBits+llBits >= STREAM_ACCUMULATOR_MIN_32-LONG_OFFSETS_MAX_EXTRA_BITS_32))
BIT_reloadDStream(&seqState->DStream);
if (MEM_64bits() && (totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog)))
BIT_reloadDStream(&seqState->DStream);
/* Ensure there are enough bits to read the rest of data in 64-bit mode. */
ZSTD_STATIC_ASSERT(16+LLFSELog+MLFSELog+OffFSELog < STREAM_ACCUMULATOR_MIN_64);
seq.litLength = llBase
+ ((llBits>0) ? BIT_readBitsFast(&seqState->DStream, llBits/*>0*/) : 0); /* <= 16 bits */
if (MEM_32bits())
BIT_reloadDStream(&seqState->DStream);
DEBUGLOG(6, "seq: litL=%u, matchL=%u, offset=%u",
(U32)seq.litLength, (U32)seq.matchLength, (U32)seq.offset);
/* ANS state update */
ZSTD_updateFseState(&seqState->stateLL, &seqState->DStream); /* <= 9 bits */
ZSTD_updateFseState(&seqState->stateML, &seqState->DStream); /* <= 9 bits */
if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream); /* <= 18 bits */
ZSTD_updateFseState(&seqState->stateOffb, &seqState->DStream); /* <= 8 bits */
return seq;
}
FORCE_INLINE_TEMPLATE size_t
ZSTD_decompressSequences_body( ZSTD_DCtx* dctx,
void* dst, size_t maxDstSize,
const void* seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset)
{
const BYTE* ip = (const BYTE*)seqStart;
const BYTE* const iend = ip + seqSize;
BYTE* const ostart = (BYTE* const)dst;
BYTE* const oend = ostart + maxDstSize;
BYTE* op = ostart;
const BYTE* litPtr = dctx->litPtr;
const BYTE* const litEnd = litPtr + dctx->litSize;
const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart);
const BYTE* const vBase = (const BYTE*) (dctx->virtualStart);
const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
DEBUGLOG(5, "ZSTD_decompressSequences_body");
/* Regen sequences */
if (nbSeq) {
seqState_t seqState;
dctx->fseEntropy = 1;
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
CHECK_E(BIT_initDStream(&seqState.DStream, ip, iend-ip), corruption_detected);
ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && nbSeq ; ) {
nbSeq--;
{ seq_t const sequence = ZSTD_decodeSequence(&seqState, isLongOffset);
size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litEnd, prefixStart, vBase, dictEnd);
DEBUGLOG(6, "regenerated sequence size : %u", (U32)oneSeqSize);
if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
op += oneSeqSize;
} }
/* check if reached exact end */
DEBUGLOG(5, "ZSTD_decompressSequences_body: after decode loop, remaining nbSeq : %i", nbSeq);
if (nbSeq) return ERROR(corruption_detected);
/* save reps for next block */
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
}
/* last literal segment */
{ size_t const lastLLSize = litEnd - litPtr;
if (lastLLSize > (size_t)(oend-op)) return ERROR(dstSize_tooSmall);
memcpy(op, litPtr, lastLLSize);
op += lastLLSize;
}
return op-ostart;
}
static size_t
ZSTD_decompressSequences_default(ZSTD_DCtx* dctx,
void* dst, size_t maxDstSize,
const void* seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset)
{
return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
}
FORCE_INLINE_TEMPLATE seq_t
ZSTD_decodeSequenceLong(seqState_t* seqState, ZSTD_longOffset_e const longOffsets)
{
seq_t seq;
U32 const llBits = seqState->stateLL.table[seqState->stateLL.state].nbAdditionalBits;
U32 const mlBits = seqState->stateML.table[seqState->stateML.state].nbAdditionalBits;
U32 const ofBits = seqState->stateOffb.table[seqState->stateOffb.state].nbAdditionalBits;
U32 const totalBits = llBits+mlBits+ofBits;
U32 const llBase = seqState->stateLL.table[seqState->stateLL.state].baseValue;
U32 const mlBase = seqState->stateML.table[seqState->stateML.state].baseValue;
U32 const ofBase = seqState->stateOffb.table[seqState->stateOffb.state].baseValue;
/* sequence */
{ size_t offset;
if (!ofBits)
offset = 0;
else {
ZSTD_STATIC_ASSERT(ZSTD_lo_isLongOffset == 1);
ZSTD_STATIC_ASSERT(LONG_OFFSETS_MAX_EXTRA_BITS_32 == 5);
assert(ofBits <= MaxOff);
if (MEM_32bits() && longOffsets) {
U32 const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN_32-1);
offset = ofBase + (BIT_readBitsFast(&seqState->DStream, ofBits - extraBits) << extraBits);
if (MEM_32bits() || extraBits) BIT_reloadDStream(&seqState->DStream);
if (extraBits) offset += BIT_readBitsFast(&seqState->DStream, extraBits);
} else {
offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */
if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);
}
}
if (ofBits <= 1) {
offset += (llBase==0);
if (offset) {
size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];
seqState->prevOffset[1] = seqState->prevOffset[0];
seqState->prevOffset[0] = offset = temp;
} else {
offset = seqState->prevOffset[0];
}
} else {
seqState->prevOffset[2] = seqState->prevOffset[1];
seqState->prevOffset[1] = seqState->prevOffset[0];
seqState->prevOffset[0] = offset;
}
seq.offset = offset;
}
seq.matchLength = mlBase + ((mlBits>0) ? BIT_readBitsFast(&seqState->DStream, mlBits) : 0); /* <= 16 bits */
if (MEM_32bits() && (mlBits+llBits >= STREAM_ACCUMULATOR_MIN_32-LONG_OFFSETS_MAX_EXTRA_BITS_32))
BIT_reloadDStream(&seqState->DStream);
if (MEM_64bits() && (totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog)))
BIT_reloadDStream(&seqState->DStream);
/* Verify that there is enough bits to read the rest of the data in 64-bit mode. */
ZSTD_STATIC_ASSERT(16+LLFSELog+MLFSELog+OffFSELog < STREAM_ACCUMULATOR_MIN_64);
seq.litLength = llBase + ((llBits>0) ? BIT_readBitsFast(&seqState->DStream, llBits) : 0); /* <= 16 bits */
if (MEM_32bits())
BIT_reloadDStream(&seqState->DStream);
{ size_t const pos = seqState->pos + seq.litLength;
const BYTE* const matchBase = (seq.offset > pos) ? seqState->dictEnd : seqState->prefixStart;
seq.match = matchBase + pos - seq.offset; /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted.
* No consequence though : no memory access will occur, overly large offset will be detected in ZSTD_execSequenceLong() */
seqState->pos = pos + seq.matchLength;
}
/* ANS state update */
ZSTD_updateFseState(&seqState->stateLL, &seqState->DStream); /* <= 9 bits */
ZSTD_updateFseState(&seqState->stateML, &seqState->DStream); /* <= 9 bits */
if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream); /* <= 18 bits */
ZSTD_updateFseState(&seqState->stateOffb, &seqState->DStream); /* <= 8 bits */
return seq;
}
FORCE_INLINE_TEMPLATE size_t
ZSTD_decompressSequencesLong_body(
ZSTD_DCtx* dctx,
void* dst, size_t maxDstSize,
const void* seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset)
{
const BYTE* ip = (const BYTE*)seqStart;
const BYTE* const iend = ip + seqSize;
BYTE* const ostart = (BYTE* const)dst;
BYTE* const oend = ostart + maxDstSize;
BYTE* op = ostart;
const BYTE* litPtr = dctx->litPtr;
const BYTE* const litEnd = litPtr + dctx->litSize;
const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart);
const BYTE* const dictStart = (const BYTE*) (dctx->virtualStart);
const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
/* Regen sequences */
if (nbSeq) {
#define STORED_SEQS 4
#define STOSEQ_MASK (STORED_SEQS-1)
#define ADVANCED_SEQS 4
seq_t sequences[STORED_SEQS];
int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS);
seqState_t seqState;
int seqNb;
dctx->fseEntropy = 1;
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
seqState.prefixStart = prefixStart;
seqState.pos = (size_t)(op-prefixStart);
seqState.dictEnd = dictEnd;
CHECK_E(BIT_initDStream(&seqState.DStream, ip, iend-ip), corruption_detected);
ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
/* prepare in advance */
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) {
sequences[seqNb] = ZSTD_decodeSequenceLong(&seqState, isLongOffset);
}
if (seqNb<seqAdvance) return ERROR(corruption_detected);
/* decode and decompress */
for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (seqNb<nbSeq) ; seqNb++) {
seq_t const sequence = ZSTD_decodeSequenceLong(&seqState, isLongOffset);
size_t const oneSeqSize = ZSTD_execSequenceLong(op, oend, sequences[(seqNb-ADVANCED_SEQS) & STOSEQ_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd);
if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
PREFETCH(sequence.match); /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */
sequences[seqNb&STOSEQ_MASK] = sequence;
op += oneSeqSize;
}
if (seqNb<nbSeq) return ERROR(corruption_detected);
/* finish queue */
seqNb -= seqAdvance;
for ( ; seqNb<nbSeq ; seqNb++) {
size_t const oneSeqSize = ZSTD_execSequenceLong(op, oend, sequences[seqNb&STOSEQ_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd);
if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
op += oneSeqSize;
}
/* save reps for next block */
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
#undef STORED_SEQS
#undef STOSEQ_MASK
#undef ADVANCED_SEQS
}
/* last literal segment */
{ size_t const lastLLSize = litEnd - litPtr;
if (lastLLSize > (size_t)(oend-op)) return ERROR(dstSize_tooSmall);
memcpy(op, litPtr, lastLLSize);
op += lastLLSize;
}
return op-ostart;
}
static size_t
ZSTD_decompressSequencesLong_default(ZSTD_DCtx* dctx,
void* dst, size_t maxDstSize,
const void* seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset)
{
return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
}
#if DYNAMIC_BMI2
static TARGET_ATTRIBUTE("bmi2") size_t
ZSTD_decompressSequences_bmi2(ZSTD_DCtx* dctx,
void* dst, size_t maxDstSize,
const void* seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset)
{
return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
}
static TARGET_ATTRIBUTE("bmi2") size_t
ZSTD_decompressSequencesLong_bmi2(ZSTD_DCtx* dctx,
void* dst, size_t maxDstSize,
const void* seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset)
{
return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
}
#endif
typedef size_t (*ZSTD_decompressSequences_t)(
ZSTD_DCtx *dctx, void *dst, size_t maxDstSize,
const void *seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset);
static size_t ZSTD_decompressSequences(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize,
const void* seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset)
{
DEBUGLOG(5, "ZSTD_decompressSequences");
#if DYNAMIC_BMI2
if (dctx->bmi2) {
return ZSTD_decompressSequences_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
}
#endif
return ZSTD_decompressSequences_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
}
static size_t ZSTD_decompressSequencesLong(ZSTD_DCtx* dctx,
void* dst, size_t maxDstSize,
const void* seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset)
{
DEBUGLOG(5, "ZSTD_decompressSequencesLong");
#if DYNAMIC_BMI2
if (dctx->bmi2) {
return ZSTD_decompressSequencesLong_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
}
#endif
return ZSTD_decompressSequencesLong_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
}
/* ZSTD_getLongOffsetsShare() :
* condition : offTable must be valid
* @return : "share" of long offsets (arbitrarily defined as > (1<<23))
* compared to maximum possible of (1<<OffFSELog) */
static unsigned
ZSTD_getLongOffsetsShare(const ZSTD_seqSymbol* offTable)
{
const void* ptr = offTable;
U32 const tableLog = ((const ZSTD_seqSymbol_header*)ptr)[0].tableLog;
const ZSTD_seqSymbol* table = offTable + 1;
U32 const max = 1 << tableLog;
U32 u, total = 0;
DEBUGLOG(5, "ZSTD_getLongOffsetsShare: (tableLog=%u)", tableLog);
assert(max <= (1 << OffFSELog)); /* max not too large */
for (u=0; u<max; u++) {
if (table[u].nbAdditionalBits > 22) total += 1;
}
assert(tableLog <= OffFSELog);
total <<= (OffFSELog - tableLog); /* scale to OffFSELog */
return total;
}
static size_t ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const int frame)
{ /* blockType == blockCompressed */
const BYTE* ip = (const BYTE*)src;
/* isLongOffset must be true if there are long offsets.
* Offsets are long if they are larger than 2^STREAM_ACCUMULATOR_MIN.
* We don't expect that to be the case in 64-bit mode.
* In block mode, window size is not known, so we have to be conservative.
* (note: but it could be evaluated from current-lowLimit)
*/
ZSTD_longOffset_e const isLongOffset = (ZSTD_longOffset_e)(MEM_32bits() && (!frame || dctx->fParams.windowSize > (1ULL << STREAM_ACCUMULATOR_MIN)));
DEBUGLOG(5, "ZSTD_decompressBlock_internal (size : %u)", (U32)srcSize);
if (srcSize >= ZSTD_BLOCKSIZE_MAX) return ERROR(srcSize_wrong);
/* Decode literals section */
{ size_t const litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize);
DEBUGLOG(5, "ZSTD_decodeLiteralsBlock : %u", (U32)litCSize);
if (ZSTD_isError(litCSize)) return litCSize;
ip += litCSize;
srcSize -= litCSize;
}
/* Build Decoding Tables */
{ int nbSeq;
size_t const seqHSize = ZSTD_decodeSeqHeaders(dctx, &nbSeq, ip, srcSize);
if (ZSTD_isError(seqHSize)) return seqHSize;
ip += seqHSize;
srcSize -= seqHSize;
if ( (!frame || dctx->fParams.windowSize > (1<<24))
&& (nbSeq>0) ) { /* could probably use a larger nbSeq limit */
U32 const shareLongOffsets = ZSTD_getLongOffsetsShare(dctx->OFTptr);
U32 const minShare = MEM_64bits() ? 7 : 20; /* heuristic values, correspond to 2.73% and 7.81% */
if (shareLongOffsets >= minShare)
return ZSTD_decompressSequencesLong(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset);
}
return ZSTD_decompressSequences(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset);
}
}
static void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst)
{
if (dst != dctx->previousDstEnd) { /* not contiguous */
dctx->dictEnd = dctx->previousDstEnd;
dctx->virtualStart = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));
dctx->prefixStart = dst;
dctx->previousDstEnd = dst;
}
}
size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize)
{
size_t dSize;
ZSTD_checkContinuity(dctx, dst);
dSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 0);
dctx->previousDstEnd = (char*)dst + dSize;
return dSize;
}
/** ZSTD_insertBlock() :
insert `src` block into `dctx` history. Useful to track uncompressed blocks. */
ZSTDLIB_API size_t ZSTD_insertBlock(ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize)
{
ZSTD_checkContinuity(dctx, blockStart);
dctx->previousDstEnd = (const char*)blockStart + blockSize;
return blockSize;
}
static size_t ZSTD_generateNxBytes(void* dst, size_t dstCapacity, BYTE value, size_t length)
{
if (length > dstCapacity) return ERROR(dstSize_tooSmall);
memset(dst, value, length);
return length;
}
/** ZSTD_findFrameCompressedSize() : /** ZSTD_findFrameCompressedSize() :
* compatible with legacy mode * compatible with legacy mode
* `src` must point to the start of a ZSTD frame, ZSTD legacy frame, or skippable frame * `src` must point to the start of a ZSTD frame, ZSTD legacy frame, or skippable frame
* `srcSize` must be at least as large as the frame contained * `srcSize` must be at least as large as the frame contained
* @return : the compressed size of the frame starting at `src` */ * @return : the compressed size of the frame starting at `src` */
size_t ZSTD_findFrameCompressedSize(const void *src, size_t srcSize) size_t ZSTD_findFrameCompressedSize(const void *src, size_t srcSize)
{ {
#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1) #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
if (ZSTD_isLegacy(src, srcSize)) if (ZSTD_isLegacy(src, srcSize))
return ZSTD_findFrameCompressedSizeLegacy(src, srcSize); return ZSTD_findFrameCompressedSizeLegacy(src, srcSize);
#endif #endif
if ( (srcSize >= ZSTD_skippableHeaderSize) if ( (srcSize >= ZSTD_SKIPPABLEHEADERSIZE)
&& (MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START ) { && (MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START ) {
return ZSTD_skippableHeaderSize + MEM_readLE32((const BYTE*)src + ZSTD_FRAMEIDSIZE); return readSkippableFrameSize(src, srcSize);
} else { } else {
const BYTE* ip = (const BYTE*)src; const BYTE* ip = (const BYTE*)src;
const BYTE* const ipstart = ip; const BYTE* const ipstart = ip;
size_t remainingSize = srcSize; size_t remainingSize = srcSize;
ZSTD_frameHeader zfh; ZSTD_frameHeader zfh;
/* Extract Frame Header */ /* Extract Frame Header */
{ size_t const ret = ZSTD_getFrameHeader(&zfh, src, srcSize); { size_t const ret = ZSTD_getFrameHeader(&zfh, src, srcSize);
if (remainingSize < 4) return ERROR(srcSize_wrong); if (remainingSize < 4) return ERROR(srcSize_wrong);
ip += 4; ip += 4;
} }
return ip - ipstart; return ip - ipstart;
} }
} }
/*-*************************************************************
* Frame decoding
***************************************************************/
void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst)
{
if (dst != dctx->previousDstEnd) { /* not contiguous */
dctx->dictEnd = dctx->previousDstEnd;
dctx->virtualStart = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));
dctx->prefixStart = dst;
dctx->previousDstEnd = dst;
}
}
/** ZSTD_insertBlock() :
insert `src` block into `dctx` history. Useful to track uncompressed blocks. */
size_t ZSTD_insertBlock(ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize)
{
ZSTD_checkContinuity(dctx, blockStart);
dctx->previousDstEnd = (const char*)blockStart + blockSize;
return blockSize;
}
static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity,
const void* src, size_t srcSize)
{
DEBUGLOG(5, "ZSTD_copyRawBlock");
if (dst == NULL) {
if (srcSize == 0) return 0;
return ERROR(dstBuffer_null);
}
if (srcSize > dstCapacity) return ERROR(dstSize_tooSmall);
memcpy(dst, src, srcSize);
return srcSize;
}
static size_t ZSTD_setRleBlock(void* dst, size_t dstCapacity,
BYTE b,
size_t regenSize)
{
if (dst == NULL) {
if (regenSize == 0) return 0;
return ERROR(dstBuffer_null);
}
if (regenSize > dstCapacity) return ERROR(dstSize_tooSmall);
memset(dst, b, regenSize);
return regenSize;
}
/*! ZSTD_decompressFrame() : /*! ZSTD_decompressFrame() :
* @dctx must be properly initialized */ * @dctx must be properly initialized
* will update *srcPtr and *srcSizePtr,
* to make *srcPtr progress by one frame. */
static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx, static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void** srcPtr, size_t *srcSizePtr) const void** srcPtr, size_t *srcSizePtr)
{ {
const BYTE* ip = (const BYTE*)(*srcPtr); const BYTE* ip = (const BYTE*)(*srcPtr);
BYTE* const ostart = (BYTE* const)dst; BYTE* const ostart = (BYTE* const)dst;
BYTE* const oend = ostart + dstCapacity; BYTE* const oend = ostart + dstCapacity;
BYTE* op = ostart; BYTE* op = ostart;
size_t remainingSize = *srcSizePtr; size_t remainingSrcSize = *srcSizePtr;
DEBUGLOG(4, "ZSTD_decompressFrame (srcSize:%i)", (int)*srcSizePtr);
/* check */ /* check */
if (remainingSize < ZSTD_frameHeaderSize_min+ZSTD_blockHeaderSize) if (remainingSrcSize < ZSTD_FRAMEHEADERSIZE_MIN+ZSTD_blockHeaderSize)
return ERROR(srcSize_wrong); return ERROR(srcSize_wrong);
/* Frame Header */ /* Frame Header */
{ size_t const frameHeaderSize = ZSTD_frameHeaderSize(ip, ZSTD_frameHeaderSize_prefix); { size_t const frameHeaderSize = ZSTD_frameHeaderSize(ip, ZSTD_FRAMEHEADERSIZE_PREFIX);
if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize; if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize;
if (remainingSize < frameHeaderSize+ZSTD_blockHeaderSize) if (remainingSrcSize < frameHeaderSize+ZSTD_blockHeaderSize)
return ERROR(srcSize_wrong); return ERROR(srcSize_wrong);
CHECK_F( ZSTD_decodeFrameHeader(dctx, ip, frameHeaderSize) ); CHECK_F( ZSTD_decodeFrameHeader(dctx, ip, frameHeaderSize) );
ip += frameHeaderSize; remainingSize -= frameHeaderSize; ip += frameHeaderSize; remainingSrcSize -= frameHeaderSize;
} }
/* Loop on each block */ /* Loop on each block */
while (1) { while (1) {
size_t decodedSize; size_t decodedSize;
blockProperties_t blockProperties; blockProperties_t blockProperties;
size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties); size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSrcSize, &blockProperties);
if (ZSTD_isError(cBlockSize)) return cBlockSize; if (ZSTD_isError(cBlockSize)) return cBlockSize;
ip += ZSTD_blockHeaderSize; ip += ZSTD_blockHeaderSize;
remainingSize -= ZSTD_blockHeaderSize; remainingSrcSize -= ZSTD_blockHeaderSize;
if (cBlockSize > remainingSize) return ERROR(srcSize_wrong); if (cBlockSize > remainingSrcSize) return ERROR(srcSize_wrong);
switch(blockProperties.blockType) switch(blockProperties.blockType)
{ {
case bt_compressed: case bt_compressed:
decodedSize = ZSTD_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize, /* frame */ 1); decodedSize = ZSTD_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize, /* frame */ 1);
break; break;
case bt_raw : case bt_raw :
decodedSize = ZSTD_copyRawBlock(op, oend-op, ip, cBlockSize); decodedSize = ZSTD_copyRawBlock(op, oend-op, ip, cBlockSize);
break; break;
case bt_rle : case bt_rle :
decodedSize = ZSTD_generateNxBytes(op, oend-op, *ip, blockProperties.origSize); decodedSize = ZSTD_setRleBlock(op, oend-op, *ip, blockProperties.origSize);
break; break;
case bt_reserved : case bt_reserved :
default: default:
return ERROR(corruption_detected); return ERROR(corruption_detected);
} }
if (ZSTD_isError(decodedSize)) return decodedSize; if (ZSTD_isError(decodedSize)) return decodedSize;
if (dctx->fParams.checksumFlag) if (dctx->fParams.checksumFlag)
XXH64_update(&dctx->xxhState, op, decodedSize); XXH64_update(&dctx->xxhState, op, decodedSize);
op += decodedSize; op += decodedSize;
ip += cBlockSize; ip += cBlockSize;
remainingSize -= cBlockSize; remainingSrcSize -= cBlockSize;
if (blockProperties.lastBlock) break; if (blockProperties.lastBlock) break;
} }
if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) { if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) {
if ((U64)(op-ostart) != dctx->fParams.frameContentSize) { if ((U64)(op-ostart) != dctx->fParams.frameContentSize) {
return ERROR(corruption_detected); return ERROR(corruption_detected);
} } } }
if (dctx->fParams.checksumFlag) { /* Frame content checksum verification */ if (dctx->fParams.checksumFlag) { /* Frame content checksum verification */
U32 const checkCalc = (U32)XXH64_digest(&dctx->xxhState); U32 const checkCalc = (U32)XXH64_digest(&dctx->xxhState);
U32 checkRead; U32 checkRead;
if (remainingSize<4) return ERROR(checksum_wrong); if (remainingSrcSize<4) return ERROR(checksum_wrong);
checkRead = MEM_readLE32(ip); checkRead = MEM_readLE32(ip);
if (checkRead != checkCalc) return ERROR(checksum_wrong); if (checkRead != checkCalc) return ERROR(checksum_wrong);
ip += 4; ip += 4;
remainingSize -= 4; remainingSrcSize -= 4;
} }
/* Allow caller to get size read */ /* Allow caller to get size read */
*srcPtr = ip; *srcPtr = ip;
*srcSizePtr = remainingSize; *srcSizePtr = remainingSrcSize;
return op-ostart; return op-ostart;
} }
static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx, static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const void* src, size_t srcSize,
const void* dict, size_t dictSize, const void* dict, size_t dictSize,
const ZSTD_DDict* ddict) const ZSTD_DDict* ddict)
{ {
void* const dststart = dst; void* const dststart = dst;
int moreThan1Frame = 0; int moreThan1Frame = 0;
DEBUGLOG(5, "ZSTD_decompressMultiFrame"); DEBUGLOG(5, "ZSTD_decompressMultiFrame");
assert(dict==NULL || ddict==NULL); /* either dict or ddict set, not both */ assert(dict==NULL || ddict==NULL); /* either dict or ddict set, not both */
if (ddict) { if (ddict) {
dict = ZSTD_DDictDictContent(ddict); dict = ZSTD_DDict_dictContent(ddict);
dictSize = ZSTD_DDictDictSize(ddict); dictSize = ZSTD_DDict_dictSize(ddict);
} }
while (srcSize >= ZSTD_frameHeaderSize_prefix) { while (srcSize >= ZSTD_FRAMEHEADERSIZE_PREFIX) {
#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1) #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
if (ZSTD_isLegacy(src, srcSize)) { if (ZSTD_isLegacy(src, srcSize)) {
size_t decodedSize; size_t decodedSize;
size_t const frameSize = ZSTD_findFrameCompressedSizeLegacy(src, srcSize); size_t const frameSize = ZSTD_findFrameCompressedSizeLegacy(src, srcSize);
if (ZSTD_isError(frameSize)) return frameSize; if (ZSTD_isError(frameSize)) return frameSize;
/* legacy support is not compatible with static dctx */ /* legacy support is not compatible with static dctx */
if (dctx->staticSize) return ERROR(memory_allocation); if (dctx->staticSize) return ERROR(memory_allocation);
decodedSize = ZSTD_decompressLegacy(dst, dstCapacity, src, frameSize, dict, dictSize); decodedSize = ZSTD_decompressLegacy(dst, dstCapacity, src, frameSize, dict, dictSize);
if (ZSTD_isError(decodedSize)) return decodedSize;
assert(decodedSize <=- dstCapacity);
dst = (BYTE*)dst + decodedSize; dst = (BYTE*)dst + decodedSize;
dstCapacity -= decodedSize; dstCapacity -= decodedSize;
src = (const BYTE*)src + frameSize; src = (const BYTE*)src + frameSize;
srcSize -= frameSize; srcSize -= frameSize;
continue; continue;
} }
#endif #endif
{ U32 const magicNumber = MEM_readLE32(src); { U32 const magicNumber = MEM_readLE32(src);
DEBUGLOG(4, "reading magic number %08X (expecting %08X)", DEBUGLOG(4, "reading magic number %08X (expecting %08X)",
(U32)magicNumber, (U32)ZSTD_MAGICNUMBER); (unsigned)magicNumber, ZSTD_MAGICNUMBER);
if ((magicNumber & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) { if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
size_t skippableSize; size_t const skippableSize = readSkippableFrameSize(src, srcSize);
if (srcSize < ZSTD_skippableHeaderSize) if (ZSTD_isError(skippableSize))
return ERROR(srcSize_wrong); return skippableSize;
skippableSize = MEM_readLE32((const BYTE*)src + ZSTD_FRAMEIDSIZE)
+ ZSTD_skippableHeaderSize;
if (srcSize < skippableSize) return ERROR(srcSize_wrong); if (srcSize < skippableSize) return ERROR(srcSize_wrong);
src = (const BYTE *)src + skippableSize; src = (const BYTE *)src + skippableSize;
srcSize -= skippableSize; srcSize -= skippableSize;
continue; continue;
} } } }
if (ddict) { if (ddict) {
* This error message replaces ERROR(prefix_unknown), * This error message replaces ERROR(prefix_unknown),
* which would be confusing, as the first header is actually correct. * which would be confusing, as the first header is actually correct.
* Note that one could be unlucky, it might be a corruption error instead, * Note that one could be unlucky, it might be a corruption error instead,
* happening right at the place where we expect zstd magic bytes. * happening right at the place where we expect zstd magic bytes.
* But this is _much_ less likely than a srcSize field error. */ * But this is _much_ less likely than a srcSize field error. */
return ERROR(srcSize_wrong); return ERROR(srcSize_wrong);
} }
if (ZSTD_isError(res)) return res; if (ZSTD_isError(res)) return res;
/* no need to bound check, ZSTD_decompressFrame already has */ assert(res <= dstCapacity);
dst = (BYTE*)dst + res; dst = (BYTE*)dst + res;
dstCapacity -= res; dstCapacity -= res;
} }
moreThan1Frame = 1; moreThan1Frame = 1;
} /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */ } /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */
if (srcSize) return ERROR(srcSize_wrong); /* input not entirely consumed */ if (srcSize) return ERROR(srcSize_wrong); /* input not entirely consumed */
static int ZSTD_isSkipFrame(ZSTD_DCtx* dctx) { return dctx->stage == ZSTDds_skipFrame; } static int ZSTD_isSkipFrame(ZSTD_DCtx* dctx) { return dctx->stage == ZSTDds_skipFrame; }
/** ZSTD_decompressContinue() : /** ZSTD_decompressContinue() :
* srcSize : must be the exact nb of bytes expected (see ZSTD_nextSrcSizeToDecompress()) * srcSize : must be the exact nb of bytes expected (see ZSTD_nextSrcSizeToDecompress())
* @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity) * @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity)
* or an error code, which can be tested using ZSTD_isError() */ * or an error code, which can be tested using ZSTD_isError() */
size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
{ {
DEBUGLOG(5, "ZSTD_decompressContinue (srcSize:%u)", (U32)srcSize); DEBUGLOG(5, "ZSTD_decompressContinue (srcSize:%u)", (unsigned)srcSize);
/* Sanity check */ /* Sanity check */
if (srcSize != dctx->expected) return ERROR(srcSize_wrong); /* not allowed */ if (srcSize != dctx->expected)
return ERROR(srcSize_wrong); /* not allowed */
if (dstCapacity) ZSTD_checkContinuity(dctx, dst); if (dstCapacity) ZSTD_checkContinuity(dctx, dst);
switch (dctx->stage) switch (dctx->stage)
{ {
case ZSTDds_getFrameHeaderSize : case ZSTDds_getFrameHeaderSize :
assert(src != NULL); assert(src != NULL);
if (dctx->format == ZSTD_f_zstd1) { /* allows header */ if (dctx->format == ZSTD_f_zstd1) { /* allows header */
assert(srcSize >= ZSTD_FRAMEIDSIZE); /* to read skippable magic number */ assert(srcSize >= ZSTD_FRAMEIDSIZE); /* to read skippable magic number */
if ((MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */ if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */
memcpy(dctx->headerBuffer, src, srcSize); memcpy(dctx->headerBuffer, src, srcSize);
dctx->expected = ZSTD_skippableHeaderSize - srcSize; /* remaining to load to get full skippable frame header */ dctx->expected = ZSTD_SKIPPABLEHEADERSIZE - srcSize; /* remaining to load to get full skippable frame header */
dctx->stage = ZSTDds_decodeSkippableHeader; dctx->stage = ZSTDds_decodeSkippableHeader;
return 0; return 0;
} } } }
dctx->headerSize = ZSTD_frameHeaderSize_internal(src, srcSize, dctx->format); dctx->headerSize = ZSTD_frameHeaderSize_internal(src, srcSize, dctx->format);
if (ZSTD_isError(dctx->headerSize)) return dctx->headerSize; if (ZSTD_isError(dctx->headerSize)) return dctx->headerSize;
memcpy(dctx->headerBuffer, src, srcSize); memcpy(dctx->headerBuffer, src, srcSize);
dctx->expected = dctx->headerSize - srcSize; dctx->expected = dctx->headerSize - srcSize;
dctx->stage = ZSTDds_decodeFrameHeader; dctx->stage = ZSTDds_decodeFrameHeader;
case bt_compressed: case bt_compressed:
DEBUGLOG(5, "ZSTD_decompressContinue: case bt_compressed"); DEBUGLOG(5, "ZSTD_decompressContinue: case bt_compressed");
rSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 1); rSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 1);
break; break;
case bt_raw : case bt_raw :
rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize); rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize);
break; break;
case bt_rle : case bt_rle :
rSize = ZSTD_setRleBlock(dst, dstCapacity, src, srcSize, dctx->rleSize); rSize = ZSTD_setRleBlock(dst, dstCapacity, *(const BYTE*)src, dctx->rleSize);
break; break;
case bt_reserved : /* should never happen */ case bt_reserved : /* should never happen */
default: default:
return ERROR(corruption_detected); return ERROR(corruption_detected);
} }
if (ZSTD_isError(rSize)) return rSize; if (ZSTD_isError(rSize)) return rSize;
DEBUGLOG(5, "ZSTD_decompressContinue: decoded size from block : %u", (U32)rSize); DEBUGLOG(5, "ZSTD_decompressContinue: decoded size from block : %u", (unsigned)rSize);
dctx->decodedSize += rSize; dctx->decodedSize += rSize;
if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, dst, rSize); if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, dst, rSize);
if (dctx->stage == ZSTDds_decompressLastBlock) { /* end of frame */ if (dctx->stage == ZSTDds_decompressLastBlock) { /* end of frame */
DEBUGLOG(4, "ZSTD_decompressContinue: decoded size from frame : %u", (U32)dctx->decodedSize); DEBUGLOG(4, "ZSTD_decompressContinue: decoded size from frame : %u", (unsigned)dctx->decodedSize);
if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) { if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) {
if (dctx->decodedSize != dctx->fParams.frameContentSize) { if (dctx->decodedSize != dctx->fParams.frameContentSize) {
return ERROR(corruption_detected); return ERROR(corruption_detected);
} } } }
if (dctx->fParams.checksumFlag) { /* another round for frame checksum */ if (dctx->fParams.checksumFlag) { /* another round for frame checksum */
dctx->expected = 4; dctx->expected = 4;
dctx->stage = ZSTDds_checkChecksum; dctx->stage = ZSTDds_checkChecksum;
} else { } else {
dctx->expected = 0; /* ends here */ dctx->expected = 0; /* ends here */
dctx->stage = ZSTDds_getFrameHeaderSize; dctx->stage = ZSTDds_getFrameHeaderSize;
} }
} else { } else {
dctx->stage = ZSTDds_decodeBlockHeader; dctx->stage = ZSTDds_decodeBlockHeader;
dctx->expected = ZSTD_blockHeaderSize; dctx->expected = ZSTD_blockHeaderSize;
dctx->previousDstEnd = (char*)dst + rSize; dctx->previousDstEnd = (char*)dst + rSize;
} }
return rSize; return rSize;
} }
case ZSTDds_checkChecksum: case ZSTDds_checkChecksum:
assert(srcSize == 4); /* guaranteed by dctx->expected */ assert(srcSize == 4); /* guaranteed by dctx->expected */
{ U32 const h32 = (U32)XXH64_digest(&dctx->xxhState); { U32 const h32 = (U32)XXH64_digest(&dctx->xxhState);
U32 const check32 = MEM_readLE32(src); U32 const check32 = MEM_readLE32(src);
DEBUGLOG(4, "ZSTD_decompressContinue: checksum : calculated %08X :: %08X read", h32, check32); DEBUGLOG(4, "ZSTD_decompressContinue: checksum : calculated %08X :: %08X read", (unsigned)h32, (unsigned)check32);
if (check32 != h32) return ERROR(checksum_wrong); if (check32 != h32) return ERROR(checksum_wrong);
dctx->expected = 0; dctx->expected = 0;
dctx->stage = ZSTDds_getFrameHeaderSize; dctx->stage = ZSTDds_getFrameHeaderSize;
return 0; return 0;
} }
case ZSTDds_decodeSkippableHeader: case ZSTDds_decodeSkippableHeader:
assert(src != NULL); assert(src != NULL);
assert(srcSize <= ZSTD_skippableHeaderSize); assert(srcSize <= ZSTD_SKIPPABLEHEADERSIZE);
memcpy(dctx->headerBuffer + (ZSTD_skippableHeaderSize - srcSize), src, srcSize); /* complete skippable header */ memcpy(dctx->headerBuffer + (ZSTD_SKIPPABLEHEADERSIZE - srcSize), src, srcSize); /* complete skippable header */
dctx->expected = MEM_readLE32(dctx->headerBuffer + ZSTD_FRAMEIDSIZE); /* note : dctx->expected can grow seriously large, beyond local buffer size */ dctx->expected = MEM_readLE32(dctx->headerBuffer + ZSTD_FRAMEIDSIZE); /* note : dctx->expected can grow seriously large, beyond local buffer size */
dctx->stage = ZSTDds_skipFrame; dctx->stage = ZSTDds_skipFrame;
return 0; return 0;
case ZSTDds_skipFrame: case ZSTDds_skipFrame:
dctx->expected = 0; dctx->expected = 0;
dctx->stage = ZSTDds_getFrameHeaderSize; dctx->stage = ZSTDds_getFrameHeaderSize;
return 0; return 0;
default: default:
return ERROR(GENERIC); /* impossible */ assert(0); /* impossible */
return ERROR(GENERIC); /* some compiler require default to do something */
} }
} }
static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
{ {
dctx->dictEnd = dctx->previousDstEnd; dctx->dictEnd = dctx->previousDstEnd;
dctx->virtualStart = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart)); dctx->virtualStart = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));
dctx->prefixStart = dict; dctx->prefixStart = dict;
dctx->previousDstEnd = (const char*)dict + dictSize; dctx->previousDstEnd = (const char*)dict + dictSize;
return 0; return 0;
} }
/*! ZSTD_loadEntropy() : /*! ZSTD_loadDEntropy() :
* dict : must point at beginning of a valid zstd dictionary. * dict : must point at beginning of a valid zstd dictionary.
* @return : size of entropy tables read */ * @return : size of entropy tables read */
static size_t ZSTD_loadEntropy(ZSTD_entropyDTables_t* entropy, size_t
ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
const void* const dict, size_t const dictSize) const void* const dict, size_t const dictSize)
{ {
const BYTE* dictPtr = (const BYTE*)dict; const BYTE* dictPtr = (const BYTE*)dict;
const BYTE* const dictEnd = dictPtr + dictSize; const BYTE* const dictEnd = dictPtr + dictSize;
if (dictSize <= 8) return ERROR(dictionary_corrupted); if (dictSize <= 8) return ERROR(dictionary_corrupted);
assert(MEM_readLE32(dict) == ZSTD_MAGIC_DICTIONARY); /* dict must be valid */ assert(MEM_readLE32(dict) == ZSTD_MAGIC_DICTIONARY); /* dict must be valid */
dictPtr += 8; /* skip header = magic + dictID */ dictPtr += 8; /* skip header = magic + dictID */
ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, OFTable) == offsetof(ZSTD_entropyDTables_t, LLTable) + sizeof(entropy->LLTable)); ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, OFTable) == offsetof(ZSTD_entropyDTables_t, LLTable) + sizeof(entropy->LLTable));
ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, MLTable) == offsetof(ZSTD_entropyDTables_t, OFTable) + sizeof(entropy->OFTable)); ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, MLTable) == offsetof(ZSTD_entropyDTables_t, OFTable) + sizeof(entropy->OFTable));
ZSTD_STATIC_ASSERT(sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable) >= HUF_DECOMPRESS_WORKSPACE_SIZE); ZSTD_STATIC_ASSERT(sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable) >= HUF_DECOMPRESS_WORKSPACE_SIZE);
{ void* const workspace = &entropy->LLTable; /* use fse tables as temporary workspace; implies fse tables are grouped together */ { void* const workspace = &entropy->LLTable; /* use fse tables as temporary workspace; implies fse tables are grouped together */
size_t const workspaceSize = sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable); size_t const workspaceSize = sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable);
#ifdef HUF_FORCE_DECOMPRESS_X1
/* in minimal huffman, we always use X1 variants */
size_t const hSize = HUF_readDTableX1_wksp(entropy->hufTable,
dictPtr, dictEnd - dictPtr,
workspace, workspaceSize);
#else
size_t const hSize = HUF_readDTableX2_wksp(entropy->hufTable, size_t const hSize = HUF_readDTableX2_wksp(entropy->hufTable,
dictPtr, dictEnd - dictPtr, dictPtr, dictEnd - dictPtr,
workspace, workspaceSize); workspace, workspaceSize);
#endif
if (HUF_isError(hSize)) return ERROR(dictionary_corrupted); if (HUF_isError(hSize)) return ERROR(dictionary_corrupted);
dictPtr += hSize; dictPtr += hSize;
} }
{ short offcodeNCount[MaxOff+1]; { short offcodeNCount[MaxOff+1];
U32 offcodeMaxValue = MaxOff, offcodeLog; unsigned offcodeMaxValue = MaxOff, offcodeLog;
size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr); size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr);
if (FSE_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted); if (FSE_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted);
if (offcodeMaxValue > MaxOff) return ERROR(dictionary_corrupted); if (offcodeMaxValue > MaxOff) return ERROR(dictionary_corrupted);
if (offcodeLog > OffFSELog) return ERROR(dictionary_corrupted); if (offcodeLog > OffFSELog) return ERROR(dictionary_corrupted);
ZSTD_buildFSETable( entropy->OFTable, ZSTD_buildFSETable( entropy->OFTable,
offcodeNCount, offcodeMaxValue, offcodeNCount, offcodeMaxValue,
OF_base, OF_bits, OF_base, OF_bits,
offcodeLog); offcodeLog);
if (dictSize < 8) return ZSTD_refDictContent(dctx, dict, dictSize); if (dictSize < 8) return ZSTD_refDictContent(dctx, dict, dictSize);
{ U32 const magic = MEM_readLE32(dict); { U32 const magic = MEM_readLE32(dict);
if (magic != ZSTD_MAGIC_DICTIONARY) { if (magic != ZSTD_MAGIC_DICTIONARY) {
return ZSTD_refDictContent(dctx, dict, dictSize); /* pure content mode */ return ZSTD_refDictContent(dctx, dict, dictSize); /* pure content mode */
} } } }
dctx->dictID = MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE); dctx->dictID = MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);
/* load entropy tables */ /* load entropy tables */
{ size_t const eSize = ZSTD_loadEntropy(&dctx->entropy, dict, dictSize); { size_t const eSize = ZSTD_loadDEntropy(&dctx->entropy, dict, dictSize);
if (ZSTD_isError(eSize)) return ERROR(dictionary_corrupted); if (ZSTD_isError(eSize)) return ERROR(dictionary_corrupted);
dict = (const char*)dict + eSize; dict = (const char*)dict + eSize;
dictSize -= eSize; dictSize -= eSize;
} }
dctx->litEntropy = dctx->fseEntropy = 1; dctx->litEntropy = dctx->fseEntropy = 1;
/* reference dictionary content */ /* reference dictionary content */
return ZSTD_refDictContent(dctx, dict, dictSize); return ZSTD_refDictContent(dctx, dict, dictSize);
if (dict && dictSize) if (dict && dictSize)
CHECK_E(ZSTD_decompress_insertDictionary(dctx, dict, dictSize), dictionary_corrupted); CHECK_E(ZSTD_decompress_insertDictionary(dctx, dict, dictSize), dictionary_corrupted);
return 0; return 0;
} }
/* ====== ZSTD_DDict ====== */ /* ====== ZSTD_DDict ====== */
struct ZSTD_DDict_s {
void* dictBuffer;
const void* dictContent;
size_t dictSize;
ZSTD_entropyDTables_t entropy;
U32 dictID;
U32 entropyPresent;
ZSTD_customMem cMem;
}; /* typedef'd to ZSTD_DDict within "zstd.h" */
static const void* ZSTD_DDictDictContent(const ZSTD_DDict* ddict)
{
assert(ddict != NULL);
return ddict->dictContent;
}
static size_t ZSTD_DDictDictSize(const ZSTD_DDict* ddict)
{
assert(ddict != NULL);
return ddict->dictSize;
}
size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict) size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
{ {
DEBUGLOG(4, "ZSTD_decompressBegin_usingDDict"); DEBUGLOG(4, "ZSTD_decompressBegin_usingDDict");
assert(dctx != NULL); assert(dctx != NULL);
if (ddict) { if (ddict) {
dctx->ddictIsCold = (dctx->dictEnd != (const char*)ddict->dictContent + ddict->dictSize); const char* const dictStart = (const char*)ZSTD_DDict_dictContent(ddict);
size_t const dictSize = ZSTD_DDict_dictSize(ddict);
const void* const dictEnd = dictStart + dictSize;
dctx->ddictIsCold = (dctx->dictEnd != dictEnd);
DEBUGLOG(4, "DDict is %s", DEBUGLOG(4, "DDict is %s",
dctx->ddictIsCold ? "~cold~" : "hot!"); dctx->ddictIsCold ? "~cold~" : "hot!");
} }
CHECK_F( ZSTD_decompressBegin(dctx) ); CHECK_F( ZSTD_decompressBegin(dctx) );
if (ddict) { /* NULL ddict is equivalent to no dictionary */ if (ddict) { /* NULL ddict is equivalent to no dictionary */
dctx->dictID = ddict->dictID; ZSTD_copyDDictParameters(dctx, ddict);
dctx->prefixStart = ddict->dictContent;
dctx->virtualStart = ddict->dictContent;
dctx->dictEnd = (const BYTE*)ddict->dictContent + ddict->dictSize;
dctx->previousDstEnd = dctx->dictEnd;
if (ddict->entropyPresent) {
dctx->litEntropy = 1;
dctx->fseEntropy = 1;
dctx->LLTptr = ddict->entropy.LLTable;
dctx->MLTptr = ddict->entropy.MLTable;
dctx->OFTptr = ddict->entropy.OFTable;
dctx->HUFptr = ddict->entropy.hufTable;
dctx->entropy.rep[0] = ddict->entropy.rep[0];
dctx->entropy.rep[1] = ddict->entropy.rep[1];
dctx->entropy.rep[2] = ddict->entropy.rep[2];
} else {
dctx->litEntropy = 0;
dctx->fseEntropy = 0;
}
}
return 0;
}
static size_t
ZSTD_loadEntropy_inDDict(ZSTD_DDict* ddict,
ZSTD_dictContentType_e dictContentType)
{
ddict->dictID = 0;
ddict->entropyPresent = 0;
if (dictContentType == ZSTD_dct_rawContent) return 0;
if (ddict->dictSize < 8) {
if (dictContentType == ZSTD_dct_fullDict)
return ERROR(dictionary_corrupted); /* only accept specified dictionaries */
return 0; /* pure content mode */
}
{ U32 const magic = MEM_readLE32(ddict->dictContent);
if (magic != ZSTD_MAGIC_DICTIONARY) {
if (dictContentType == ZSTD_dct_fullDict)
return ERROR(dictionary_corrupted); /* only accept specified dictionaries */
return 0; /* pure content mode */
}
}
ddict->dictID = MEM_readLE32((const char*)ddict->dictContent + ZSTD_FRAMEIDSIZE);
/* load entropy tables */
CHECK_E( ZSTD_loadEntropy(&ddict->entropy,
ddict->dictContent, ddict->dictSize),
dictionary_corrupted );
ddict->entropyPresent = 1;
return 0;
}
static size_t ZSTD_initDDict_internal(ZSTD_DDict* ddict,
const void* dict, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType)
{
if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dict) || (!dictSize)) {
ddict->dictBuffer = NULL;
ddict->dictContent = dict;
if (!dict) dictSize = 0;
} else {
void* const internalBuffer = ZSTD_malloc(dictSize, ddict->cMem);
ddict->dictBuffer = internalBuffer;
ddict->dictContent = internalBuffer;
if (!internalBuffer) return ERROR(memory_allocation);
memcpy(internalBuffer, dict, dictSize);
}
ddict->dictSize = dictSize;
ddict->entropy.hufTable[0] = (HUF_DTable)((HufLog)*0x1000001); /* cover both little and big endian */
/* parse dictionary content */
CHECK_F( ZSTD_loadEntropy_inDDict(ddict, dictContentType) );
return 0;
}
ZSTD_DDict* ZSTD_createDDict_advanced(const void* dict, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType,
ZSTD_customMem customMem)
{
if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
{ ZSTD_DDict* const ddict = (ZSTD_DDict*) ZSTD_malloc(sizeof(ZSTD_DDict), customMem);
if (ddict == NULL) return NULL;
ddict->cMem = customMem;
{ size_t const initResult = ZSTD_initDDict_internal(ddict,
dict, dictSize,
dictLoadMethod, dictContentType);
if (ZSTD_isError(initResult)) {
ZSTD_freeDDict(ddict);
return NULL;
} }
return ddict;
}
}
/*! ZSTD_createDDict() :
* Create a digested dictionary, to start decompression without startup delay.
* `dict` content is copied inside DDict.
* Consequently, `dict` can be released after `ZSTD_DDict` creation */
ZSTD_DDict* ZSTD_createDDict(const void* dict, size_t dictSize)
{
ZSTD_customMem const allocator = { NULL, NULL, NULL };
return ZSTD_createDDict_advanced(dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto, allocator);
}
/*! ZSTD_createDDict_byReference() :
* Create a digested dictionary, to start decompression without startup delay.
* Dictionary content is simply referenced, it will be accessed during decompression.
* Warning : dictBuffer must outlive DDict (DDict must be freed before dictBuffer) */
ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize)
{
ZSTD_customMem const allocator = { NULL, NULL, NULL };
return ZSTD_createDDict_advanced(dictBuffer, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto, allocator);
}
const ZSTD_DDict* ZSTD_initStaticDDict(
void* sBuffer, size_t sBufferSize,
const void* dict, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType)
{
size_t const neededSpace = sizeof(ZSTD_DDict)
+ (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);
ZSTD_DDict* const ddict = (ZSTD_DDict*)sBuffer;
assert(sBuffer != NULL);
assert(dict != NULL);
if ((size_t)sBuffer & 7) return NULL; /* 8-aligned */
if (sBufferSize < neededSpace) return NULL;
if (dictLoadMethod == ZSTD_dlm_byCopy) {
memcpy(ddict+1, dict, dictSize); /* local copy */
dict = ddict+1;
}
if (ZSTD_isError( ZSTD_initDDict_internal(ddict,
dict, dictSize,
ZSTD_dlm_byRef, dictContentType) ))
return NULL;
return ddict;
} }
size_t ZSTD_freeDDict(ZSTD_DDict* ddict)
{
if (ddict==NULL) return 0; /* support free on NULL */
{ ZSTD_customMem const cMem = ddict->cMem;
ZSTD_free(ddict->dictBuffer, cMem);
ZSTD_free(ddict, cMem);
return 0; return 0;
} }
}
/*! ZSTD_estimateDDictSize() :
* Estimate amount of memory that will be needed to create a dictionary for decompression.
* Note : dictionary created by reference using ZSTD_dlm_byRef are smaller */
size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod)
{
return sizeof(ZSTD_DDict) + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);
}
size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict)
{
if (ddict==NULL) return 0; /* support sizeof on NULL */
return sizeof(*ddict) + (ddict->dictBuffer ? ddict->dictSize : 0) ;
}
/*! ZSTD_getDictID_fromDict() : /*! ZSTD_getDictID_fromDict() :
* Provides the dictID stored within dictionary. * Provides the dictID stored within dictionary.
* if @return == 0, the dictionary is not conformant with Zstandard specification. * if @return == 0, the dictionary is not conformant with Zstandard specification.
* It can still be loaded, but as a content-only dictionary. */ * It can still be loaded, but as a content-only dictionary. */
unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize) unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize)
{ {
if (dictSize < 8) return 0; if (dictSize < 8) return 0;
if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) return 0; if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) return 0;
return MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE); return MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);
} }
/*! ZSTD_getDictID_fromDDict() :
* Provides the dictID of the dictionary loaded into `ddict`.
* If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.
* Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */
unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict)
{
if (ddict==NULL) return 0;
return ZSTD_getDictID_fromDict(ddict->dictContent, ddict->dictSize);
}
/*! ZSTD_getDictID_fromFrame() : /*! ZSTD_getDictID_fromFrame() :
* Provides the dictID required to decompresse frame stored within `src`. * Provides the dictID required to decompresse frame stored within `src`.
* If @return == 0, the dictID could not be decoded. * If @return == 0, the dictID could not be decoded.
* This could for one of the following reasons : * This could for one of the following reasons :
* - The frame does not require a dictionary (most common case). * - The frame does not require a dictionary (most common case).
* - The frame was built with dictID intentionally removed. * - The frame was built with dictID intentionally removed.
* Needed dictionary is a hidden information. * Needed dictionary is a hidden information.
* Note : this use case also happens when using a non-conformant dictionary. * Note : this use case also happens when using a non-conformant dictionary.
size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize) size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize)
{ {
return ZSTD_DCtx_refPrefix_advanced(dctx, prefix, prefixSize, ZSTD_dct_rawContent); return ZSTD_DCtx_refPrefix_advanced(dctx, prefix, prefixSize, ZSTD_dct_rawContent);
} }
/* ZSTD_initDStream_usingDict() : /* ZSTD_initDStream_usingDict() :
* return : expected size, aka ZSTD_frameHeaderSize_prefix. * return : expected size, aka ZSTD_FRAMEHEADERSIZE_PREFIX.
* this function cannot fail */ * this function cannot fail */
size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize) size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize)
{ {
DEBUGLOG(4, "ZSTD_initDStream_usingDict"); DEBUGLOG(4, "ZSTD_initDStream_usingDict");
zds->streamStage = zdss_init; zds->streamStage = zdss_init;
zds->noForwardProgress = 0; zds->noForwardProgress = 0;
CHECK_F( ZSTD_DCtx_loadDictionary(zds, dict, dictSize) ); CHECK_F( ZSTD_DCtx_loadDictionary(zds, dict, dictSize) );
return ZSTD_frameHeaderSize_prefix; return ZSTD_FRAMEHEADERSIZE_PREFIX;
} }
/* note : this variant can't fail */ /* note : this variant can't fail */
size_t ZSTD_initDStream(ZSTD_DStream* zds) size_t ZSTD_initDStream(ZSTD_DStream* zds)
{ {
DEBUGLOG(4, "ZSTD_initDStream"); DEBUGLOG(4, "ZSTD_initDStream");
return ZSTD_initDStream_usingDict(zds, NULL, 0); return ZSTD_initDStream_usingDict(zds, NULL, 0);
} }
/* ZSTD_initDStream_usingDDict() : /* ZSTD_initDStream_usingDDict() :
* ddict will just be referenced, and must outlive decompression session * ddict will just be referenced, and must outlive decompression session
* this function cannot fail */ * this function cannot fail */
size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* dctx, const ZSTD_DDict* ddict) size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* dctx, const ZSTD_DDict* ddict)
{ {
size_t const initResult = ZSTD_initDStream(dctx); size_t const initResult = ZSTD_initDStream(dctx);
dctx->ddict = ddict; dctx->ddict = ddict;
return initResult; return initResult;
} }
/* ZSTD_resetDStream() : /* ZSTD_resetDStream() :
* return : expected size, aka ZSTD_frameHeaderSize_prefix. * return : expected size, aka ZSTD_FRAMEHEADERSIZE_PREFIX.
* this function cannot fail */ * this function cannot fail */
size_t ZSTD_resetDStream(ZSTD_DStream* dctx) size_t ZSTD_resetDStream(ZSTD_DStream* dctx)
{ {
DEBUGLOG(4, "ZSTD_resetDStream"); DEBUGLOG(4, "ZSTD_resetDStream");
dctx->streamStage = zdss_loadHeader; dctx->streamStage = zdss_loadHeader;
dctx->lhSize = dctx->inPos = dctx->outStart = dctx->outEnd = 0; dctx->lhSize = dctx->inPos = dctx->outStart = dctx->outEnd = 0;
dctx->legacyVersion = 0; dctx->legacyVersion = 0;
dctx->hostageByte = 0; dctx->hostageByte = 0;
return ZSTD_frameHeaderSize_prefix; return ZSTD_FRAMEHEADERSIZE_PREFIX;
} }
size_t ZSTD_setDStreamParameter(ZSTD_DStream* dctx,
ZSTD_DStreamParameter_e paramType, unsigned paramValue)
{
if (dctx->streamStage != zdss_init) return ERROR(stage_wrong);
switch(paramType)
{
default : return ERROR(parameter_unsupported);
case DStream_p_maxWindowSize :
DEBUGLOG(4, "setting maxWindowSize = %u KB", paramValue >> 10);
dctx->maxWindowSize = paramValue ? paramValue : (U32)(-1);
break;
}
return 0;
}
size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict) size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
{ {
if (dctx->streamStage != zdss_init) return ERROR(stage_wrong); if (dctx->streamStage != zdss_init) return ERROR(stage_wrong);
dctx->ddict = ddict; dctx->ddict = ddict;
return 0; return 0;
} }
/* ZSTD_DCtx_setMaxWindowSize() :
* note : no direct equivalence in ZSTD_DCtx_setParameter,
* since this version sets windowSize, and the other sets windowLog */
size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize) size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize)
{ {
ZSTD_bounds const bounds = ZSTD_dParam_getBounds(ZSTD_d_windowLogMax);
size_t const min = (size_t)1 << bounds.lowerBound;
size_t const max = (size_t)1 << bounds.upperBound;
if (dctx->streamStage != zdss_init) return ERROR(stage_wrong); if (dctx->streamStage != zdss_init) return ERROR(stage_wrong);
if (maxWindowSize < min) return ERROR(parameter_outOfBound);
if (maxWindowSize > max) return ERROR(parameter_outOfBound);
dctx->maxWindowSize = maxWindowSize; dctx->maxWindowSize = maxWindowSize;
return 0; return 0;
} }
size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format) size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format)
{ {
DEBUGLOG(4, "ZSTD_DCtx_setFormat : %u", (unsigned)format); return ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, format);
}
ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam)
{
ZSTD_bounds bounds = { 0, 0, 0 };
switch(dParam) {
case ZSTD_d_windowLogMax:
bounds.lowerBound = ZSTD_WINDOWLOG_ABSOLUTEMIN;
bounds.upperBound = ZSTD_WINDOWLOG_MAX;
return bounds;
case ZSTD_d_format:
bounds.lowerBound = (int)ZSTD_f_zstd1;
bounds.upperBound = (int)ZSTD_f_zstd1_magicless;
ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless);
return bounds;
default:;
}
bounds.error = ERROR(parameter_unsupported);
return bounds;
}
/* ZSTD_dParam_withinBounds:
* @return 1 if value is within dParam bounds,
* 0 otherwise */
static int ZSTD_dParam_withinBounds(ZSTD_dParameter dParam, int value)
{
ZSTD_bounds const bounds = ZSTD_dParam_getBounds(dParam);
if (ZSTD_isError(bounds.error)) return 0;
if (value < bounds.lowerBound) return 0;
if (value > bounds.upperBound) return 0;
return 1;
}
#define CHECK_DBOUNDS(p,v) { \
if (!ZSTD_dParam_withinBounds(p, v)) \
return ERROR(parameter_outOfBound); \
}
size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter dParam, int value)
{
if (dctx->streamStage != zdss_init) return ERROR(stage_wrong); if (dctx->streamStage != zdss_init) return ERROR(stage_wrong);
dctx->format = format; switch(dParam) {
case ZSTD_d_windowLogMax:
CHECK_DBOUNDS(ZSTD_d_windowLogMax, value);
dctx->maxWindowSize = ((size_t)1) << value;
return 0;
case ZSTD_d_format:
CHECK_DBOUNDS(ZSTD_d_format, value);
dctx->format = (ZSTD_format_e)value;
return 0;
default:;
}
return ERROR(parameter_unsupported);
}
size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset)
{
if ( (reset == ZSTD_reset_session_only)
|| (reset == ZSTD_reset_session_and_parameters) ) {
(void)ZSTD_initDStream(dctx);
}
if ( (reset == ZSTD_reset_parameters)
|| (reset == ZSTD_reset_session_and_parameters) ) {
if (dctx->streamStage != zdss_init)
return ERROR(stage_wrong);
dctx->format = ZSTD_f_zstd1;
dctx->maxWindowSize = ZSTD_MAXWINDOWSIZE_DEFAULT;
}
return 0; return 0;
} }
size_t ZSTD_sizeof_DStream(const ZSTD_DStream* dctx) size_t ZSTD_sizeof_DStream(const ZSTD_DStream* dctx)
{ {
return ZSTD_sizeof_DCtx(dctx); return ZSTD_sizeof_DCtx(dctx);
} }
size_t const blockSize = MIN(windowSize, ZSTD_BLOCKSIZE_MAX); size_t const blockSize = MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
size_t const inBuffSize = blockSize; /* no block can be larger */ size_t const inBuffSize = blockSize; /* no block can be larger */
size_t const outBuffSize = ZSTD_decodingBufferSize_min(windowSize, ZSTD_CONTENTSIZE_UNKNOWN); size_t const outBuffSize = ZSTD_decodingBufferSize_min(windowSize, ZSTD_CONTENTSIZE_UNKNOWN);
return ZSTD_estimateDCtxSize() + inBuffSize + outBuffSize; return ZSTD_estimateDCtxSize() + inBuffSize + outBuffSize;
} }
size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize) size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize)
{ {
U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX; /* note : should be user-selectable */ U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX; /* note : should be user-selectable, but requires an additional parameter (or a dctx) */
ZSTD_frameHeader zfh; ZSTD_frameHeader zfh;
size_t const err = ZSTD_getFrameHeader(&zfh, src, srcSize); size_t const err = ZSTD_getFrameHeader(&zfh, src, srcSize);
if (ZSTD_isError(err)) return err; if (ZSTD_isError(err)) return err;
if (err>0) return ERROR(srcSize_wrong); if (err>0) return ERROR(srcSize_wrong);
if (zfh.windowSize > windowSizeMax) if (zfh.windowSize > windowSizeMax)
return ERROR(frameParameter_windowTooLarge); return ERROR(frameParameter_windowTooLarge);
return ZSTD_estimateDStreamSize((size_t)zfh.windowSize); return ZSTD_estimateDStreamSize((size_t)zfh.windowSize);
} }
} } } }
#endif #endif
{ size_t const hSize = ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format); { size_t const hSize = ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format);
DEBUGLOG(5, "header size : %u", (U32)hSize); DEBUGLOG(5, "header size : %u", (U32)hSize);
if (ZSTD_isError(hSize)) { if (ZSTD_isError(hSize)) {
#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1) #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
U32 const legacyVersion = ZSTD_isLegacy(istart, iend-istart); U32 const legacyVersion = ZSTD_isLegacy(istart, iend-istart);
if (legacyVersion) { if (legacyVersion) {
const void* const dict = zds->ddict ? zds->ddict->dictContent : NULL; const void* const dict = zds->ddict ? ZSTD_DDict_dictContent(zds->ddict) : NULL;
size_t const dictSize = zds->ddict ? zds->ddict->dictSize : 0; size_t const dictSize = zds->ddict ? ZSTD_DDict_dictSize(zds->ddict) : 0;
DEBUGLOG(5, "ZSTD_decompressStream: detected legacy version v0.%u", legacyVersion); DEBUGLOG(5, "ZSTD_decompressStream: detected legacy version v0.%u", legacyVersion);
/* legacy support is incompatible with static dctx */ /* legacy support is incompatible with static dctx */
if (zds->staticSize) return ERROR(memory_allocation); if (zds->staticSize) return ERROR(memory_allocation);
CHECK_F(ZSTD_initLegacyStream(&zds->legacyContext, CHECK_F(ZSTD_initLegacyStream(&zds->legacyContext,
zds->previousLegacyVersion, legacyVersion, zds->previousLegacyVersion, legacyVersion,
dict, dictSize)); dict, dictSize));
zds->legacyVersion = zds->previousLegacyVersion = legacyVersion; zds->legacyVersion = zds->previousLegacyVersion = legacyVersion;
{ size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, legacyVersion, output, input); { size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, legacyVersion, output, input);
if (hint==0) zds->streamStage = zdss_init; /* or stay in stage zdss_loadHeader */ if (hint==0) zds->streamStage = zdss_init; /* or stay in stage zdss_loadHeader */
return hint; return hint;
} } } }
#endif #endif
return hSize; /* error */ return hSize; /* error */
} }
if (hSize != 0) { /* need more input */ if (hSize != 0) { /* need more input */
size_t const toLoad = hSize - zds->lhSize; /* if hSize!=0, hSize > zds->lhSize */ size_t const toLoad = hSize - zds->lhSize; /* if hSize!=0, hSize > zds->lhSize */
size_t const remainingInput = (size_t)(iend-ip); size_t const remainingInput = (size_t)(iend-ip);
assert(iend >= ip); assert(iend >= ip);
if (toLoad > remainingInput) { /* not enough input to load full header */ if (toLoad > remainingInput) { /* not enough input to load full header */
if (remainingInput > 0) { if (remainingInput > 0) {
memcpy(zds->headerBuffer + zds->lhSize, ip, remainingInput); memcpy(zds->headerBuffer + zds->lhSize, ip, remainingInput);
zds->lhSize += remainingInput; zds->lhSize += remainingInput;
} }
input->pos = input->size; input->pos = input->size;
return (MAX(ZSTD_frameHeaderSize_min, hSize) - zds->lhSize) + ZSTD_blockHeaderSize; /* remaining header bytes + next block header */ return (MAX(ZSTD_FRAMEHEADERSIZE_MIN, hSize) - zds->lhSize) + ZSTD_blockHeaderSize; /* remaining header bytes + next block header */
} }
assert(ip != NULL); assert(ip != NULL);
memcpy(zds->headerBuffer + zds->lhSize, ip, toLoad); zds->lhSize = hSize; ip += toLoad; memcpy(zds->headerBuffer + zds->lhSize, ip, toLoad); zds->lhSize = hSize; ip += toLoad;
break; break;
} } } }
/* check for single-pass mode opportunity */ /* check for single-pass mode opportunity */
if (zds->fParams.frameContentSize && zds->fParams.windowSize /* skippable frame if == 0 */ if (zds->fParams.frameContentSize && zds->fParams.windowSize /* skippable frame if == 0 */
someMoreWork = 0; someMoreWork = 0;
break; break;
} } } }
/* Consume header (see ZSTDds_decodeFrameHeader) */ /* Consume header (see ZSTDds_decodeFrameHeader) */
DEBUGLOG(4, "Consume header"); DEBUGLOG(4, "Consume header");
CHECK_F(ZSTD_decompressBegin_usingDDict(zds, zds->ddict)); CHECK_F(ZSTD_decompressBegin_usingDDict(zds, zds->ddict));
if ((MEM_readLE32(zds->headerBuffer) & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */ if ((MEM_readLE32(zds->headerBuffer) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */
zds->expected = MEM_readLE32(zds->headerBuffer + ZSTD_FRAMEIDSIZE); zds->expected = MEM_readLE32(zds->headerBuffer + ZSTD_FRAMEIDSIZE);
zds->stage = ZSTDds_skipFrame; zds->stage = ZSTDds_skipFrame;
} else { } else {
CHECK_F(ZSTD_decodeFrameHeader(zds, zds->headerBuffer, zds->lhSize)); CHECK_F(ZSTD_decodeFrameHeader(zds, zds->headerBuffer, zds->lhSize));
zds->expected = ZSTD_blockHeaderSize; zds->expected = ZSTD_blockHeaderSize;
zds->stage = ZSTDds_decodeBlockHeader; zds->stage = ZSTDds_decodeBlockHeader;
} }
zds->outStart = zds->outEnd = 0; zds->outStart = zds->outEnd = 0;
} }
break; break;
} } } }
/* cannot complete flush */ /* cannot complete flush */
someMoreWork = 0; someMoreWork = 0;
break; break;
default: return ERROR(GENERIC); /* impossible */ default:
assert(0); /* impossible */
return ERROR(GENERIC); /* some compiler require default to do something */
} } } }
/* result */ /* result */
input->pos = (size_t)(ip - (const char*)(input->src)); input->pos = (size_t)(ip - (const char*)(input->src));
output->pos = (size_t)(op - (char*)(output->dst)); output->pos = (size_t)(op - (char*)(output->dst));
if ((ip==istart) && (op==ostart)) { /* no forward progress */ if ((ip==istart) && (op==ostart)) { /* no forward progress */
zds->noForwardProgress ++; zds->noForwardProgress ++;
if (zds->noForwardProgress >= ZSTD_NO_FORWARD_PROGRESS_MAX) { if (zds->noForwardProgress >= ZSTD_NO_FORWARD_PROGRESS_MAX) {
} /* nextSrcSizeHint==0 */ } /* nextSrcSizeHint==0 */
nextSrcSizeHint += ZSTD_blockHeaderSize * (ZSTD_nextInputType(zds) == ZSTDnit_block); /* preload header of next block */ nextSrcSizeHint += ZSTD_blockHeaderSize * (ZSTD_nextInputType(zds) == ZSTDnit_block); /* preload header of next block */
assert(zds->inPos <= nextSrcSizeHint); assert(zds->inPos <= nextSrcSizeHint);
nextSrcSizeHint -= zds->inPos; /* part already loaded*/ nextSrcSizeHint -= zds->inPos; /* part already loaded*/
return nextSrcSizeHint; return nextSrcSizeHint;
} }
} }
size_t ZSTD_decompressStream_simpleArgs (
size_t ZSTD_decompress_generic(ZSTD_DCtx* dctx, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
{
return ZSTD_decompressStream(dctx, output, input);
}
size_t ZSTD_decompress_generic_simpleArgs (
ZSTD_DCtx* dctx, ZSTD_DCtx* dctx,
void* dst, size_t dstCapacity, size_t* dstPos, void* dst, size_t dstCapacity, size_t* dstPos,
const void* src, size_t srcSize, size_t* srcPos) const void* src, size_t srcSize, size_t* srcPos)
{ {
ZSTD_outBuffer output = { dst, dstCapacity, *dstPos }; ZSTD_outBuffer output = { dst, dstCapacity, *dstPos };
ZSTD_inBuffer input = { src, srcSize, *srcPos }; ZSTD_inBuffer input = { src, srcSize, *srcPos };
/* ZSTD_compress_generic() will check validity of dstPos and srcPos */ /* ZSTD_compress_generic() will check validity of dstPos and srcPos */
size_t const cErr = ZSTD_decompress_generic(dctx, &output, &input); size_t const cErr = ZSTD_decompressStream(dctx, &output, &input);
*dstPos = output.pos; *dstPos = output.pos;
*srcPos = input.pos; *srcPos = input.pos;
return cErr; return cErr;
} }
void ZSTD_DCtx_reset(ZSTD_DCtx* dctx)
{
(void)ZSTD_initDStream(dctx);
dctx->format = ZSTD_f_zstd1;
dctx->maxWindowSize = ZSTD_MAXWINDOWSIZE_DEFAULT;
}

contrib/python-zstandard/zstd/decompress/zstd_decompress_block.h

  • This file was added.
/*
* Copyright (c) 2016-present, Yann Collet, 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).
* You may select, at your option, one of the above-listed licenses.
*/
#ifndef ZSTD_DEC_BLOCK_H
#define ZSTD_DEC_BLOCK_H
/*-*******************************************************
* Dependencies
*********************************************************/
#include <stddef.h> /* size_t */
#include "zstd.h" /* DCtx, and some public functions */
#include "zstd_internal.h" /* blockProperties_t, and some public functions */
#include "zstd_decompress_internal.h" /* ZSTD_seqSymbol */
/* === Prototypes === */
/* note: prototypes already published within `zstd.h` :
* ZSTD_decompressBlock()
*/
/* note: prototypes already published within `zstd_internal.h` :
* ZSTD_getcBlockSize()
* ZSTD_decodeSeqHeaders()
*/
/* ZSTD_decompressBlock_internal() :
* decompress block, starting at `src`,
* into destination buffer `dst`.
* @return : decompressed block size,
* or an error code (which can be tested using ZSTD_isError())
*/
size_t ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const int frame);
/* ZSTD_buildFSETable() :
* generate FSE decoding table for one symbol (ll, ml or off)
* this function must be called with valid parameters only
* (dt is large enough, normalizedCounter distribution total is a power of 2, max is within range, etc.)
* in which case it cannot fail.
* Internal use only.
*/
void ZSTD_buildFSETable(ZSTD_seqSymbol* dt,
const short* normalizedCounter, unsigned maxSymbolValue,
const U32* baseValue, const U32* nbAdditionalBits,
unsigned tableLog);
#endif /* ZSTD_DEC_BLOCK_H */

contrib/python-zstandard/zstd/decompress/zstd_decompress_block.c

  • This file was added.
/*
* Copyright (c) 2016-present, Yann Collet, 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).
* You may select, at your option, one of the above-listed licenses.
*/
/* zstd_decompress_block :
* this module takes care of decompressing _compressed_ block */
/*-*******************************************************
* Dependencies
*********************************************************/
#include <string.h> /* memcpy, memmove, memset */
#include "compiler.h" /* prefetch */
#include "cpu.h" /* bmi2 */
#include "mem.h" /* low level memory routines */
#define FSE_STATIC_LINKING_ONLY
#include "fse.h"
#define HUF_STATIC_LINKING_ONLY
#include "huf.h"
#include "zstd_internal.h"
#include "zstd_decompress_internal.h" /* ZSTD_DCtx */
#include "zstd_ddict.h" /* ZSTD_DDictDictContent */
#include "zstd_decompress_block.h"
/*_*******************************************************
* Macros
**********************************************************/
/* These two optional macros force the use one way or another of the two
* ZSTD_decompressSequences implementations. You can't force in both directions
* at the same time.
*/
#if defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
#error "Cannot force the use of the short and the long ZSTD_decompressSequences variants!"
#endif
/*_*******************************************************
* Memory operations
**********************************************************/
static void ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
/*-*************************************************************
* Block decoding
***************************************************************/
/*! ZSTD_getcBlockSize() :
* Provides the size of compressed block from block header `src` */
size_t ZSTD_getcBlockSize(const void* src, size_t srcSize,
blockProperties_t* bpPtr)
{
if (srcSize < ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
{ U32 const cBlockHeader = MEM_readLE24(src);
U32 const cSize = cBlockHeader >> 3;
bpPtr->lastBlock = cBlockHeader & 1;
bpPtr->blockType = (blockType_e)((cBlockHeader >> 1) & 3);
bpPtr->origSize = cSize; /* only useful for RLE */
if (bpPtr->blockType == bt_rle) return 1;
if (bpPtr->blockType == bt_reserved) return ERROR(corruption_detected);
return cSize;
}
}
/* Hidden declaration for fullbench */
size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
const void* src, size_t srcSize);
/*! ZSTD_decodeLiteralsBlock() :
* @return : nb of bytes read from src (< srcSize )
* note : symbol not declared but exposed for fullbench */
size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
const void* src, size_t srcSize) /* note : srcSize < BLOCKSIZE */
{
if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);
{ const BYTE* const istart = (const BYTE*) src;
symbolEncodingType_e const litEncType = (symbolEncodingType_e)(istart[0] & 3);
switch(litEncType)
{
case set_repeat:
if (dctx->litEntropy==0) return ERROR(dictionary_corrupted);
/* fall-through */
case set_compressed:
if (srcSize < 5) return ERROR(corruption_detected); /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for case 3 */
{ size_t lhSize, litSize, litCSize;
U32 singleStream=0;
U32 const lhlCode = (istart[0] >> 2) & 3;
U32 const lhc = MEM_readLE32(istart);
size_t hufSuccess;
switch(lhlCode)
{
case 0: case 1: default: /* note : default is impossible, since lhlCode into [0..3] */
/* 2 - 2 - 10 - 10 */
singleStream = !lhlCode;
lhSize = 3;
litSize = (lhc >> 4) & 0x3FF;
litCSize = (lhc >> 14) & 0x3FF;
break;
case 2:
/* 2 - 2 - 14 - 14 */
lhSize = 4;
litSize = (lhc >> 4) & 0x3FFF;
litCSize = lhc >> 18;
break;
case 3:
/* 2 - 2 - 18 - 18 */
lhSize = 5;
litSize = (lhc >> 4) & 0x3FFFF;
litCSize = (lhc >> 22) + (istart[4] << 10);
break;
}
if (litSize > ZSTD_BLOCKSIZE_MAX) return ERROR(corruption_detected);
if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);
/* prefetch huffman table if cold */
if (dctx->ddictIsCold && (litSize > 768 /* heuristic */)) {
PREFETCH_AREA(dctx->HUFptr, sizeof(dctx->entropy.hufTable));
}
if (litEncType==set_repeat) {
if (singleStream) {
hufSuccess = HUF_decompress1X_usingDTable_bmi2(
dctx->litBuffer, litSize, istart+lhSize, litCSize,
dctx->HUFptr, dctx->bmi2);
} else {
hufSuccess = HUF_decompress4X_usingDTable_bmi2(
dctx->litBuffer, litSize, istart+lhSize, litCSize,
dctx->HUFptr, dctx->bmi2);
}
} else {
if (singleStream) {
#if defined(HUF_FORCE_DECOMPRESS_X2)
hufSuccess = HUF_decompress1X_DCtx_wksp(
dctx->entropy.hufTable, dctx->litBuffer, litSize,
istart+lhSize, litCSize, dctx->workspace,
sizeof(dctx->workspace));
#else
hufSuccess = HUF_decompress1X1_DCtx_wksp_bmi2(
dctx->entropy.hufTable, dctx->litBuffer, litSize,
istart+lhSize, litCSize, dctx->workspace,
sizeof(dctx->workspace), dctx->bmi2);
#endif
} else {
hufSuccess = HUF_decompress4X_hufOnly_wksp_bmi2(
dctx->entropy.hufTable, dctx->litBuffer, litSize,
istart+lhSize, litCSize, dctx->workspace,
sizeof(dctx->workspace), dctx->bmi2);
}
}
if (HUF_isError(hufSuccess)) return ERROR(corruption_detected);
dctx->litPtr = dctx->litBuffer;
dctx->litSize = litSize;
dctx->litEntropy = 1;
if (litEncType==set_compressed) dctx->HUFptr = dctx->entropy.hufTable;
memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
return litCSize + lhSize;
}
case set_basic:
{ size_t litSize, lhSize;
U32 const lhlCode = ((istart[0]) >> 2) & 3;
switch(lhlCode)
{
case 0: case 2: default: /* note : default is impossible, since lhlCode into [0..3] */
lhSize = 1;
litSize = istart[0] >> 3;
break;
case 1:
lhSize = 2;
litSize = MEM_readLE16(istart) >> 4;
break;
case 3:
lhSize = 3;
litSize = MEM_readLE24(istart) >> 4;
break;
}
if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) { /* risk reading beyond src buffer with wildcopy */
if (litSize+lhSize > srcSize) return ERROR(corruption_detected);
memcpy(dctx->litBuffer, istart+lhSize, litSize);
dctx->litPtr = dctx->litBuffer;
dctx->litSize = litSize;
memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
return lhSize+litSize;
}
/* direct reference into compressed stream */
dctx->litPtr = istart+lhSize;
dctx->litSize = litSize;
return lhSize+litSize;
}
case set_rle:
{ U32 const lhlCode = ((istart[0]) >> 2) & 3;
size_t litSize, lhSize;
switch(lhlCode)
{
case 0: case 2: default: /* note : default is impossible, since lhlCode into [0..3] */
lhSize = 1;
litSize = istart[0] >> 3;
break;
case 1:
lhSize = 2;
litSize = MEM_readLE16(istart) >> 4;
break;
case 3:
lhSize = 3;
litSize = MEM_readLE24(istart) >> 4;
if (srcSize<4) return ERROR(corruption_detected); /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4 */
break;
}
if (litSize > ZSTD_BLOCKSIZE_MAX) return ERROR(corruption_detected);
memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH);
dctx->litPtr = dctx->litBuffer;
dctx->litSize = litSize;
return lhSize+1;
}
default:
return ERROR(corruption_detected); /* impossible */
}
}
}
/* Default FSE distribution tables.
* These are pre-calculated FSE decoding tables using default distributions as defined in specification :
* https://github.com/facebook/zstd/blob/master/doc/zstd_compression_format.md#default-distributions
* They were generated programmatically with following method :
* - start from default distributions, present in /lib/common/zstd_internal.h
* - generate tables normally, using ZSTD_buildFSETable()
* - printout the content of tables
* - pretify output, report below, test with fuzzer to ensure it's correct */
/* Default FSE distribution table for Literal Lengths */
static const ZSTD_seqSymbol LL_defaultDTable[(1<<LL_DEFAULTNORMLOG)+1] = {
{ 1, 1, 1, LL_DEFAULTNORMLOG}, /* header : fastMode, tableLog */
/* nextState, nbAddBits, nbBits, baseVal */
{ 0, 0, 4, 0}, { 16, 0, 4, 0},
{ 32, 0, 5, 1}, { 0, 0, 5, 3},
{ 0, 0, 5, 4}, { 0, 0, 5, 6},
{ 0, 0, 5, 7}, { 0, 0, 5, 9},
{ 0, 0, 5, 10}, { 0, 0, 5, 12},
{ 0, 0, 6, 14}, { 0, 1, 5, 16},
{ 0, 1, 5, 20}, { 0, 1, 5, 22},
{ 0, 2, 5, 28}, { 0, 3, 5, 32},
{ 0, 4, 5, 48}, { 32, 6, 5, 64},
{ 0, 7, 5, 128}, { 0, 8, 6, 256},
{ 0, 10, 6, 1024}, { 0, 12, 6, 4096},
{ 32, 0, 4, 0}, { 0, 0, 4, 1},
{ 0, 0, 5, 2}, { 32, 0, 5, 4},
{ 0, 0, 5, 5}, { 32, 0, 5, 7},
{ 0, 0, 5, 8}, { 32, 0, 5, 10},
{ 0, 0, 5, 11}, { 0, 0, 6, 13},
{ 32, 1, 5, 16}, { 0, 1, 5, 18},
{ 32, 1, 5, 22}, { 0, 2, 5, 24},
{ 32, 3, 5, 32}, { 0, 3, 5, 40},
{ 0, 6, 4, 64}, { 16, 6, 4, 64},
{ 32, 7, 5, 128}, { 0, 9, 6, 512},
{ 0, 11, 6, 2048}, { 48, 0, 4, 0},
{ 16, 0, 4, 1}, { 32, 0, 5, 2},
{ 32, 0, 5, 3}, { 32, 0, 5, 5},
{ 32, 0, 5, 6}, { 32, 0, 5, 8},
{ 32, 0, 5, 9}, { 32, 0, 5, 11},
{ 32, 0, 5, 12}, { 0, 0, 6, 15},
{ 32, 1, 5, 18}, { 32, 1, 5, 20},
{ 32, 2, 5, 24}, { 32, 2, 5, 28},
{ 32, 3, 5, 40}, { 32, 4, 5, 48},
{ 0, 16, 6,65536}, { 0, 15, 6,32768},
{ 0, 14, 6,16384}, { 0, 13, 6, 8192},
}; /* LL_defaultDTable */
/* Default FSE distribution table for Offset Codes */
static const ZSTD_seqSymbol OF_defaultDTable[(1<<OF_DEFAULTNORMLOG)+1] = {
{ 1, 1, 1, OF_DEFAULTNORMLOG}, /* header : fastMode, tableLog */
/* nextState, nbAddBits, nbBits, baseVal */
{ 0, 0, 5, 0}, { 0, 6, 4, 61},
{ 0, 9, 5, 509}, { 0, 15, 5,32765},
{ 0, 21, 5,2097149}, { 0, 3, 5, 5},
{ 0, 7, 4, 125}, { 0, 12, 5, 4093},
{ 0, 18, 5,262141}, { 0, 23, 5,8388605},
{ 0, 5, 5, 29}, { 0, 8, 4, 253},
{ 0, 14, 5,16381}, { 0, 20, 5,1048573},
{ 0, 2, 5, 1}, { 16, 7, 4, 125},
{ 0, 11, 5, 2045}, { 0, 17, 5,131069},
{ 0, 22, 5,4194301}, { 0, 4, 5, 13},
{ 16, 8, 4, 253}, { 0, 13, 5, 8189},
{ 0, 19, 5,524285}, { 0, 1, 5, 1},
{ 16, 6, 4, 61}, { 0, 10, 5, 1021},
{ 0, 16, 5,65533}, { 0, 28, 5,268435453},
{ 0, 27, 5,134217725}, { 0, 26, 5,67108861},
{ 0, 25, 5,33554429}, { 0, 24, 5,16777213},
}; /* OF_defaultDTable */
/* Default FSE distribution table for Match Lengths */
static const ZSTD_seqSymbol ML_defaultDTable[(1<<ML_DEFAULTNORMLOG)+1] = {
{ 1, 1, 1, ML_DEFAULTNORMLOG}, /* header : fastMode, tableLog */
/* nextState, nbAddBits, nbBits, baseVal */
{ 0, 0, 6, 3}, { 0, 0, 4, 4},
{ 32, 0, 5, 5}, { 0, 0, 5, 6},
{ 0, 0, 5, 8}, { 0, 0, 5, 9},
{ 0, 0, 5, 11}, { 0, 0, 6, 13},
{ 0, 0, 6, 16}, { 0, 0, 6, 19},
{ 0, 0, 6, 22}, { 0, 0, 6, 25},
{ 0, 0, 6, 28}, { 0, 0, 6, 31},
{ 0, 0, 6, 34}, { 0, 1, 6, 37},
{ 0, 1, 6, 41}, { 0, 2, 6, 47},
{ 0, 3, 6, 59}, { 0, 4, 6, 83},
{ 0, 7, 6, 131}, { 0, 9, 6, 515},
{ 16, 0, 4, 4}, { 0, 0, 4, 5},
{ 32, 0, 5, 6}, { 0, 0, 5, 7},
{ 32, 0, 5, 9}, { 0, 0, 5, 10},
{ 0, 0, 6, 12}, { 0, 0, 6, 15},
{ 0, 0, 6, 18}, { 0, 0, 6, 21},
{ 0, 0, 6, 24}, { 0, 0, 6, 27},
{ 0, 0, 6, 30}, { 0, 0, 6, 33},
{ 0, 1, 6, 35}, { 0, 1, 6, 39},
{ 0, 2, 6, 43}, { 0, 3, 6, 51},
{ 0, 4, 6, 67}, { 0, 5, 6, 99},
{ 0, 8, 6, 259}, { 32, 0, 4, 4},
{ 48, 0, 4, 4}, { 16, 0, 4, 5},
{ 32, 0, 5, 7}, { 32, 0, 5, 8},
{ 32, 0, 5, 10}, { 32, 0, 5, 11},
{ 0, 0, 6, 14}, { 0, 0, 6, 17},
{ 0, 0, 6, 20}, { 0, 0, 6, 23},
{ 0, 0, 6, 26}, { 0, 0, 6, 29},
{ 0, 0, 6, 32}, { 0, 16, 6,65539},
{ 0, 15, 6,32771}, { 0, 14, 6,16387},
{ 0, 13, 6, 8195}, { 0, 12, 6, 4099},
{ 0, 11, 6, 2051}, { 0, 10, 6, 1027},
}; /* ML_defaultDTable */
static void ZSTD_buildSeqTable_rle(ZSTD_seqSymbol* dt, U32 baseValue, U32 nbAddBits)
{
void* ptr = dt;
ZSTD_seqSymbol_header* const DTableH = (ZSTD_seqSymbol_header*)ptr;
ZSTD_seqSymbol* const cell = dt + 1;
DTableH->tableLog = 0;
DTableH->fastMode = 0;
cell->nbBits = 0;
cell->nextState = 0;
assert(nbAddBits < 255);
cell->nbAdditionalBits = (BYTE)nbAddBits;
cell->baseValue = baseValue;
}
/* ZSTD_buildFSETable() :
* generate FSE decoding table for one symbol (ll, ml or off)
* cannot fail if input is valid =>
* all inputs are presumed validated at this stage */
void
ZSTD_buildFSETable(ZSTD_seqSymbol* dt,
const short* normalizedCounter, unsigned maxSymbolValue,
const U32* baseValue, const U32* nbAdditionalBits,
unsigned tableLog)
{
ZSTD_seqSymbol* const tableDecode = dt+1;
U16 symbolNext[MaxSeq+1];
U32 const maxSV1 = maxSymbolValue + 1;
U32 const tableSize = 1 << tableLog;
U32 highThreshold = tableSize-1;
/* Sanity Checks */
assert(maxSymbolValue <= MaxSeq);
assert(tableLog <= MaxFSELog);
/* Init, lay down lowprob symbols */
{ ZSTD_seqSymbol_header DTableH;
DTableH.tableLog = tableLog;
DTableH.fastMode = 1;
{ S16 const largeLimit= (S16)(1 << (tableLog-1));
U32 s;
for (s=0; s<maxSV1; s++) {
if (normalizedCounter[s]==-1) {
tableDecode[highThreshold--].baseValue = s;
symbolNext[s] = 1;
} else {
if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
symbolNext[s] = normalizedCounter[s];
} } }
memcpy(dt, &DTableH, sizeof(DTableH));
}
/* Spread symbols */
{ U32 const tableMask = tableSize-1;
U32 const step = FSE_TABLESTEP(tableSize);
U32 s, position = 0;
for (s=0; s<maxSV1; s++) {
int i;
for (i=0; i<normalizedCounter[s]; i++) {
tableDecode[position].baseValue = s;
position = (position + step) & tableMask;
while (position > highThreshold) position = (position + step) & tableMask; /* lowprob area */
} }
assert(position == 0); /* position must reach all cells once, otherwise normalizedCounter is incorrect */
}
/* Build Decoding table */
{ U32 u;
for (u=0; u<tableSize; u++) {
U32 const symbol = tableDecode[u].baseValue;
U32 const nextState = symbolNext[symbol]++;
tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) );
tableDecode[u].nextState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
assert(nbAdditionalBits[symbol] < 255);
tableDecode[u].nbAdditionalBits = (BYTE)nbAdditionalBits[symbol];
tableDecode[u].baseValue = baseValue[symbol];
} }
}
/*! ZSTD_buildSeqTable() :
* @return : nb bytes read from src,
* or an error code if it fails */
static size_t ZSTD_buildSeqTable(ZSTD_seqSymbol* DTableSpace, const ZSTD_seqSymbol** DTablePtr,
symbolEncodingType_e type, unsigned max, U32 maxLog,
const void* src, size_t srcSize,
const U32* baseValue, const U32* nbAdditionalBits,
const ZSTD_seqSymbol* defaultTable, U32 flagRepeatTable,
int ddictIsCold, int nbSeq)
{
switch(type)
{
case set_rle :
if (!srcSize) return ERROR(srcSize_wrong);
if ( (*(const BYTE*)src) > max) return ERROR(corruption_detected);
{ U32 const symbol = *(const BYTE*)src;
U32 const baseline = baseValue[symbol];
U32 const nbBits = nbAdditionalBits[symbol];
ZSTD_buildSeqTable_rle(DTableSpace, baseline, nbBits);
}
*DTablePtr = DTableSpace;
return 1;
case set_basic :
*DTablePtr = defaultTable;
return 0;
case set_repeat:
if (!flagRepeatTable) return ERROR(corruption_detected);
/* prefetch FSE table if used */
if (ddictIsCold && (nbSeq > 24 /* heuristic */)) {
const void* const pStart = *DTablePtr;
size_t const pSize = sizeof(ZSTD_seqSymbol) * (SEQSYMBOL_TABLE_SIZE(maxLog));
PREFETCH_AREA(pStart, pSize);
}
return 0;
case set_compressed :
{ unsigned tableLog;
S16 norm[MaxSeq+1];
size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize);
if (FSE_isError(headerSize)) return ERROR(corruption_detected);
if (tableLog > maxLog) return ERROR(corruption_detected);
ZSTD_buildFSETable(DTableSpace, norm, max, baseValue, nbAdditionalBits, tableLog);
*DTablePtr = DTableSpace;
return headerSize;
}
default : /* impossible */
assert(0);
return ERROR(GENERIC);
}
}
size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,
const void* src, size_t srcSize)
{
const BYTE* const istart = (const BYTE* const)src;
const BYTE* const iend = istart + srcSize;
const BYTE* ip = istart;
int nbSeq;
DEBUGLOG(5, "ZSTD_decodeSeqHeaders");
/* check */
if (srcSize < MIN_SEQUENCES_SIZE) return ERROR(srcSize_wrong);
/* SeqHead */
nbSeq = *ip++;
if (!nbSeq) {
*nbSeqPtr=0;
if (srcSize != 1) return ERROR(srcSize_wrong);
return 1;
}
if (nbSeq > 0x7F) {
if (nbSeq == 0xFF) {
if (ip+2 > iend) return ERROR(srcSize_wrong);
nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2;
} else {
if (ip >= iend) return ERROR(srcSize_wrong);
nbSeq = ((nbSeq-0x80)<<8) + *ip++;
}
}
*nbSeqPtr = nbSeq;
/* FSE table descriptors */
if (ip+4 > iend) return ERROR(srcSize_wrong); /* minimum possible size */
{ symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6);
symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3);
symbolEncodingType_e const MLtype = (symbolEncodingType_e)((*ip >> 2) & 3);
ip++;
/* Build DTables */
{ size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr,
LLtype, MaxLL, LLFSELog,
ip, iend-ip,
LL_base, LL_bits,
LL_defaultDTable, dctx->fseEntropy,
dctx->ddictIsCold, nbSeq);
if (ZSTD_isError(llhSize)) return ERROR(corruption_detected);
ip += llhSize;
}
{ size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr,
OFtype, MaxOff, OffFSELog,
ip, iend-ip,
OF_base, OF_bits,
OF_defaultDTable, dctx->fseEntropy,
dctx->ddictIsCold, nbSeq);
if (ZSTD_isError(ofhSize)) return ERROR(corruption_detected);
ip += ofhSize;
}
{ size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr,
MLtype, MaxML, MLFSELog,
ip, iend-ip,
ML_base, ML_bits,
ML_defaultDTable, dctx->fseEntropy,
dctx->ddictIsCold, nbSeq);
if (ZSTD_isError(mlhSize)) return ERROR(corruption_detected);
ip += mlhSize;
}
}
return ip-istart;
}
typedef struct {
size_t litLength;
size_t matchLength;
size_t offset;
const BYTE* match;
} seq_t;
typedef struct {
size_t state;
const ZSTD_seqSymbol* table;
} ZSTD_fseState;
typedef struct {
BIT_DStream_t DStream;
ZSTD_fseState stateLL;
ZSTD_fseState stateOffb;
ZSTD_fseState stateML;
size_t prevOffset[ZSTD_REP_NUM];
const BYTE* prefixStart;
const BYTE* dictEnd;
size_t pos;
} seqState_t;
/* ZSTD_execSequenceLast7():
* exceptional case : decompress a match starting within last 7 bytes of output buffer.
* requires more careful checks, to ensure there is no overflow.
* performance does not matter though.
* note : this case is supposed to be never generated "naturally" by reference encoder,
* since in most cases it needs at least 8 bytes to look for a match.
* but it's allowed by the specification. */
FORCE_NOINLINE
size_t ZSTD_execSequenceLast7(BYTE* op,
BYTE* const oend, seq_t sequence,
const BYTE** litPtr, const BYTE* const litLimit,
const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)
{
BYTE* const oLitEnd = op + sequence.litLength;
size_t const sequenceLength = sequence.litLength + sequence.matchLength;
BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */
const BYTE* const iLitEnd = *litPtr + sequence.litLength;
const BYTE* match = oLitEnd - sequence.offset;
/* check */
if (oMatchEnd>oend) return ERROR(dstSize_tooSmall); /* last match must fit within dstBuffer */
if (iLitEnd > litLimit) return ERROR(corruption_detected); /* try to read beyond literal buffer */
/* copy literals */
while (op < oLitEnd) *op++ = *(*litPtr)++;
/* copy Match */
if (sequence.offset > (size_t)(oLitEnd - base)) {
/* offset beyond prefix */
if (sequence.offset > (size_t)(oLitEnd - vBase)) return ERROR(corruption_detected);
match = dictEnd - (base-match);
if (match + sequence.matchLength <= dictEnd) {
memmove(oLitEnd, match, sequence.matchLength);
return sequenceLength;
}
/* span extDict & currentPrefixSegment */
{ size_t const length1 = dictEnd - match;
memmove(oLitEnd, match, length1);
op = oLitEnd + length1;
sequence.matchLength -= length1;
match = base;
} }
while (op < oMatchEnd) *op++ = *match++;
return sequenceLength;
}
HINT_INLINE
size_t ZSTD_execSequence(BYTE* op,
BYTE* const oend, seq_t sequence,
const BYTE** litPtr, const BYTE* const litLimit,
const BYTE* const prefixStart, const BYTE* const virtualStart, const BYTE* const dictEnd)
{
BYTE* const oLitEnd = op + sequence.litLength;
size_t const sequenceLength = sequence.litLength + sequence.matchLength;
BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH;
const BYTE* const iLitEnd = *litPtr + sequence.litLength;
const BYTE* match = oLitEnd - sequence.offset;
/* check */
if (oMatchEnd>oend) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */
if (iLitEnd > litLimit) return ERROR(corruption_detected); /* over-read beyond lit buffer */
if (oLitEnd>oend_w) return ZSTD_execSequenceLast7(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd);
/* copy Literals */
ZSTD_copy8(op, *litPtr);
if (sequence.litLength > 8)
ZSTD_wildcopy(op+8, (*litPtr)+8, sequence.litLength - 8); /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, no risk of overwrite beyond oend */
op = oLitEnd;
*litPtr = iLitEnd; /* update for next sequence */
/* copy Match */
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
/* offset beyond prefix -> go into extDict */
if (sequence.offset > (size_t)(oLitEnd - virtualStart))
return ERROR(corruption_detected);
match = dictEnd + (match - prefixStart);
if (match + sequence.matchLength <= dictEnd) {
memmove(oLitEnd, match, sequence.matchLength);
return sequenceLength;
}
/* span extDict & currentPrefixSegment */
{ size_t const length1 = dictEnd - match;
memmove(oLitEnd, match, length1);
op = oLitEnd + length1;
sequence.matchLength -= length1;
match = prefixStart;
if (op > oend_w || sequence.matchLength < MINMATCH) {
U32 i;
for (i = 0; i < sequence.matchLength; ++i) op[i] = match[i];
return sequenceLength;
}
} }
/* Requirement: op <= oend_w && sequence.matchLength >= MINMATCH */
/* match within prefix */
if (sequence.offset < 8) {
/* close range match, overlap */
static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 }; /* added */
static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 }; /* subtracted */
int const sub2 = dec64table[sequence.offset];
op[0] = match[0];
op[1] = match[1];
op[2] = match[2];
op[3] = match[3];
match += dec32table[sequence.offset];
ZSTD_copy4(op+4, match);
match -= sub2;
} else {
ZSTD_copy8(op, match);
}
op += 8; match += 8;
if (oMatchEnd > oend-(16-MINMATCH)) {
if (op < oend_w) {
ZSTD_wildcopy(op, match, oend_w - op);
match += oend_w - op;
op = oend_w;
}
while (op < oMatchEnd) *op++ = *match++;
} else {
ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8); /* works even if matchLength < 8 */
}
return sequenceLength;
}
HINT_INLINE
size_t ZSTD_execSequenceLong(BYTE* op,
BYTE* const oend, seq_t sequence,
const BYTE** litPtr, const BYTE* const litLimit,
const BYTE* const prefixStart, const BYTE* const dictStart, const BYTE* const dictEnd)
{
BYTE* const oLitEnd = op + sequence.litLength;
size_t const sequenceLength = sequence.litLength + sequence.matchLength;
BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH;
const BYTE* const iLitEnd = *litPtr + sequence.litLength;
const BYTE* match = sequence.match;
/* check */
if (oMatchEnd > oend) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */
if (iLitEnd > litLimit) return ERROR(corruption_detected); /* over-read beyond lit buffer */
if (oLitEnd > oend_w) return ZSTD_execSequenceLast7(op, oend, sequence, litPtr, litLimit, prefixStart, dictStart, dictEnd);
/* copy Literals */
ZSTD_copy8(op, *litPtr); /* note : op <= oLitEnd <= oend_w == oend - 8 */
if (sequence.litLength > 8)
ZSTD_wildcopy(op+8, (*litPtr)+8, sequence.litLength - 8); /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, no risk of overwrite beyond oend */
op = oLitEnd;
*litPtr = iLitEnd; /* update for next sequence */
/* copy Match */
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
/* offset beyond prefix */
if (sequence.offset > (size_t)(oLitEnd - dictStart)) return ERROR(corruption_detected);
if (match + sequence.matchLength <= dictEnd) {
memmove(oLitEnd, match, sequence.matchLength);
return sequenceLength;
}
/* span extDict & currentPrefixSegment */
{ size_t const length1 = dictEnd - match;
memmove(oLitEnd, match, length1);
op = oLitEnd + length1;
sequence.matchLength -= length1;
match = prefixStart;
if (op > oend_w || sequence.matchLength < MINMATCH) {
U32 i;
for (i = 0; i < sequence.matchLength; ++i) op[i] = match[i];
return sequenceLength;
}
} }
assert(op <= oend_w);
assert(sequence.matchLength >= MINMATCH);
/* match within prefix */
if (sequence.offset < 8) {
/* close range match, overlap */
static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 }; /* added */
static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 }; /* subtracted */
int const sub2 = dec64table[sequence.offset];
op[0] = match[0];
op[1] = match[1];
op[2] = match[2];
op[3] = match[3];
match += dec32table[sequence.offset];
ZSTD_copy4(op+4, match);
match -= sub2;
} else {
ZSTD_copy8(op, match);
}
op += 8; match += 8;
if (oMatchEnd > oend-(16-MINMATCH)) {
if (op < oend_w) {
ZSTD_wildcopy(op, match, oend_w - op);
match += oend_w - op;
op = oend_w;
}
while (op < oMatchEnd) *op++ = *match++;
} else {
ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8); /* works even if matchLength < 8 */
}
return sequenceLength;
}
static void
ZSTD_initFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, const ZSTD_seqSymbol* dt)
{
const void* ptr = dt;
const ZSTD_seqSymbol_header* const DTableH = (const ZSTD_seqSymbol_header*)ptr;
DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
DEBUGLOG(6, "ZSTD_initFseState : val=%u using %u bits",
(U32)DStatePtr->state, DTableH->tableLog);
BIT_reloadDStream(bitD);
DStatePtr->table = dt + 1;
}
FORCE_INLINE_TEMPLATE void
ZSTD_updateFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD)
{
ZSTD_seqSymbol const DInfo = DStatePtr->table[DStatePtr->state];
U32 const nbBits = DInfo.nbBits;
size_t const lowBits = BIT_readBits(bitD, nbBits);
DStatePtr->state = DInfo.nextState + lowBits;
}
/* We need to add at most (ZSTD_WINDOWLOG_MAX_32 - 1) bits to read the maximum
* offset bits. But we can only read at most (STREAM_ACCUMULATOR_MIN_32 - 1)
* bits before reloading. This value is the maximum number of bytes we read
* after reloading when we are decoding long offets.
*/
#define LONG_OFFSETS_MAX_EXTRA_BITS_32 \
(ZSTD_WINDOWLOG_MAX_32 > STREAM_ACCUMULATOR_MIN_32 \
? ZSTD_WINDOWLOG_MAX_32 - STREAM_ACCUMULATOR_MIN_32 \
: 0)
typedef enum { ZSTD_lo_isRegularOffset, ZSTD_lo_isLongOffset=1 } ZSTD_longOffset_e;
#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
FORCE_INLINE_TEMPLATE seq_t
ZSTD_decodeSequence(seqState_t* seqState, const ZSTD_longOffset_e longOffsets)
{
seq_t seq;
U32 const llBits = seqState->stateLL.table[seqState->stateLL.state].nbAdditionalBits;
U32 const mlBits = seqState->stateML.table[seqState->stateML.state].nbAdditionalBits;
U32 const ofBits = seqState->stateOffb.table[seqState->stateOffb.state].nbAdditionalBits;
U32 const totalBits = llBits+mlBits+ofBits;
U32 const llBase = seqState->stateLL.table[seqState->stateLL.state].baseValue;
U32 const mlBase = seqState->stateML.table[seqState->stateML.state].baseValue;
U32 const ofBase = seqState->stateOffb.table[seqState->stateOffb.state].baseValue;
/* sequence */
{ size_t offset;
if (!ofBits)
offset = 0;
else {
ZSTD_STATIC_ASSERT(ZSTD_lo_isLongOffset == 1);
ZSTD_STATIC_ASSERT(LONG_OFFSETS_MAX_EXTRA_BITS_32 == 5);
assert(ofBits <= MaxOff);
if (MEM_32bits() && longOffsets && (ofBits >= STREAM_ACCUMULATOR_MIN_32)) {
U32 const extraBits = ofBits - MIN(ofBits, 32 - seqState->DStream.bitsConsumed);
offset = ofBase + (BIT_readBitsFast(&seqState->DStream, ofBits - extraBits) << extraBits);
BIT_reloadDStream(&seqState->DStream);
if (extraBits) offset += BIT_readBitsFast(&seqState->DStream, extraBits);
assert(extraBits <= LONG_OFFSETS_MAX_EXTRA_BITS_32); /* to avoid another reload */
} else {
offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */
if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);
}
}
if (ofBits <= 1) {
offset += (llBase==0);
if (offset) {
size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];
seqState->prevOffset[1] = seqState->prevOffset[0];
seqState->prevOffset[0] = offset = temp;
} else { /* offset == 0 */
offset = seqState->prevOffset[0];
}
} else {
seqState->prevOffset[2] = seqState->prevOffset[1];
seqState->prevOffset[1] = seqState->prevOffset[0];
seqState->prevOffset[0] = offset;
}
seq.offset = offset;
}
seq.matchLength = mlBase
+ ((mlBits>0) ? BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/) : 0); /* <= 16 bits */
if (MEM_32bits() && (mlBits+llBits >= STREAM_ACCUMULATOR_MIN_32-LONG_OFFSETS_MAX_EXTRA_BITS_32))
BIT_reloadDStream(&seqState->DStream);
if (MEM_64bits() && (totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog)))
BIT_reloadDStream(&seqState->DStream);
/* Ensure there are enough bits to read the rest of data in 64-bit mode. */
ZSTD_STATIC_ASSERT(16+LLFSELog+MLFSELog+OffFSELog < STREAM_ACCUMULATOR_MIN_64);
seq.litLength = llBase
+ ((llBits>0) ? BIT_readBitsFast(&seqState->DStream, llBits/*>0*/) : 0); /* <= 16 bits */
if (MEM_32bits())
BIT_reloadDStream(&seqState->DStream);
DEBUGLOG(6, "seq: litL=%u, matchL=%u, offset=%u",
(U32)seq.litLength, (U32)seq.matchLength, (U32)seq.offset);
/* ANS state update */
ZSTD_updateFseState(&seqState->stateLL, &seqState->DStream); /* <= 9 bits */
ZSTD_updateFseState(&seqState->stateML, &seqState->DStream); /* <= 9 bits */
if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream); /* <= 18 bits */
ZSTD_updateFseState(&seqState->stateOffb, &seqState->DStream); /* <= 8 bits */
return seq;
}
FORCE_INLINE_TEMPLATE size_t
ZSTD_decompressSequences_body( ZSTD_DCtx* dctx,
void* dst, size_t maxDstSize,
const void* seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset)
{
const BYTE* ip = (const BYTE*)seqStart;
const BYTE* const iend = ip + seqSize;
BYTE* const ostart = (BYTE* const)dst;
BYTE* const oend = ostart + maxDstSize;
BYTE* op = ostart;
const BYTE* litPtr = dctx->litPtr;
const BYTE* const litEnd = litPtr + dctx->litSize;
const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart);
const BYTE* const vBase = (const BYTE*) (dctx->virtualStart);
const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
DEBUGLOG(5, "ZSTD_decompressSequences_body");
/* Regen sequences */
if (nbSeq) {
seqState_t seqState;
dctx->fseEntropy = 1;
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
CHECK_E(BIT_initDStream(&seqState.DStream, ip, iend-ip), corruption_detected);
ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && nbSeq ; ) {
nbSeq--;
{ seq_t const sequence = ZSTD_decodeSequence(&seqState, isLongOffset);
size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litEnd, prefixStart, vBase, dictEnd);
DEBUGLOG(6, "regenerated sequence size : %u", (U32)oneSeqSize);
if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
op += oneSeqSize;
} }
/* check if reached exact end */
DEBUGLOG(5, "ZSTD_decompressSequences_body: after decode loop, remaining nbSeq : %i", nbSeq);
if (nbSeq) return ERROR(corruption_detected);
/* save reps for next block */
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
}
/* last literal segment */
{ size_t const lastLLSize = litEnd - litPtr;
if (lastLLSize > (size_t)(oend-op)) return ERROR(dstSize_tooSmall);
memcpy(op, litPtr, lastLLSize);
op += lastLLSize;
}
return op-ostart;
}
static size_t
ZSTD_decompressSequences_default(ZSTD_DCtx* dctx,
void* dst, size_t maxDstSize,
const void* seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset)
{
return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
}
#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */
#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
FORCE_INLINE_TEMPLATE seq_t
ZSTD_decodeSequenceLong(seqState_t* seqState, ZSTD_longOffset_e const longOffsets)
{
seq_t seq;
U32 const llBits = seqState->stateLL.table[seqState->stateLL.state].nbAdditionalBits;
U32 const mlBits = seqState->stateML.table[seqState->stateML.state].nbAdditionalBits;
U32 const ofBits = seqState->stateOffb.table[seqState->stateOffb.state].nbAdditionalBits;
U32 const totalBits = llBits+mlBits+ofBits;
U32 const llBase = seqState->stateLL.table[seqState->stateLL.state].baseValue;
U32 const mlBase = seqState->stateML.table[seqState->stateML.state].baseValue;
U32 const ofBase = seqState->stateOffb.table[seqState->stateOffb.state].baseValue;
/* sequence */
{ size_t offset;
if (!ofBits)
offset = 0;
else {
ZSTD_STATIC_ASSERT(ZSTD_lo_isLongOffset == 1);
ZSTD_STATIC_ASSERT(LONG_OFFSETS_MAX_EXTRA_BITS_32 == 5);
assert(ofBits <= MaxOff);
if (MEM_32bits() && longOffsets) {
U32 const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN_32-1);
offset = ofBase + (BIT_readBitsFast(&seqState->DStream, ofBits - extraBits) << extraBits);
if (MEM_32bits() || extraBits) BIT_reloadDStream(&seqState->DStream);
if (extraBits) offset += BIT_readBitsFast(&seqState->DStream, extraBits);
} else {
offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */
if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);
}
}
if (ofBits <= 1) {
offset += (llBase==0);
if (offset) {
size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];
seqState->prevOffset[1] = seqState->prevOffset[0];
seqState->prevOffset[0] = offset = temp;
} else {
offset = seqState->prevOffset[0];
}
} else {
seqState->prevOffset[2] = seqState->prevOffset[1];
seqState->prevOffset[1] = seqState->prevOffset[0];
seqState->prevOffset[0] = offset;
}
seq.offset = offset;
}
seq.matchLength = mlBase + ((mlBits>0) ? BIT_readBitsFast(&seqState->DStream, mlBits) : 0); /* <= 16 bits */
if (MEM_32bits() && (mlBits+llBits >= STREAM_ACCUMULATOR_MIN_32-LONG_OFFSETS_MAX_EXTRA_BITS_32))
BIT_reloadDStream(&seqState->DStream);
if (MEM_64bits() && (totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog)))
BIT_reloadDStream(&seqState->DStream);
/* Verify that there is enough bits to read the rest of the data in 64-bit mode. */
ZSTD_STATIC_ASSERT(16+LLFSELog+MLFSELog+OffFSELog < STREAM_ACCUMULATOR_MIN_64);
seq.litLength = llBase + ((llBits>0) ? BIT_readBitsFast(&seqState->DStream, llBits) : 0); /* <= 16 bits */
if (MEM_32bits())
BIT_reloadDStream(&seqState->DStream);
{ size_t const pos = seqState->pos + seq.litLength;
const BYTE* const matchBase = (seq.offset > pos) ? seqState->dictEnd : seqState->prefixStart;
seq.match = matchBase + pos - seq.offset; /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted.
* No consequence though : no memory access will occur, overly large offset will be detected in ZSTD_execSequenceLong() */
seqState->pos = pos + seq.matchLength;
}
/* ANS state update */
ZSTD_updateFseState(&seqState->stateLL, &seqState->DStream); /* <= 9 bits */
ZSTD_updateFseState(&seqState->stateML, &seqState->DStream); /* <= 9 bits */
if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream); /* <= 18 bits */
ZSTD_updateFseState(&seqState->stateOffb, &seqState->DStream); /* <= 8 bits */
return seq;
}
FORCE_INLINE_TEMPLATE size_t
ZSTD_decompressSequencesLong_body(
ZSTD_DCtx* dctx,
void* dst, size_t maxDstSize,
const void* seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset)
{
const BYTE* ip = (const BYTE*)seqStart;
const BYTE* const iend = ip + seqSize;
BYTE* const ostart = (BYTE* const)dst;
BYTE* const oend = ostart + maxDstSize;
BYTE* op = ostart;
const BYTE* litPtr = dctx->litPtr;
const BYTE* const litEnd = litPtr + dctx->litSize;
const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart);
const BYTE* const dictStart = (const BYTE*) (dctx->virtualStart);
const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
/* Regen sequences */
if (nbSeq) {
#define STORED_SEQS 4
#define STORED_SEQS_MASK (STORED_SEQS-1)
#define ADVANCED_SEQS 4
seq_t sequences[STORED_SEQS];
int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS);
seqState_t seqState;
int seqNb;
dctx->fseEntropy = 1;
{ int i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
seqState.prefixStart = prefixStart;
seqState.pos = (size_t)(op-prefixStart);
seqState.dictEnd = dictEnd;
assert(iend >= ip);
CHECK_E(BIT_initDStream(&seqState.DStream, ip, iend-ip), corruption_detected);
ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
/* prepare in advance */
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) {
sequences[seqNb] = ZSTD_decodeSequenceLong(&seqState, isLongOffset);
PREFETCH_L1(sequences[seqNb].match); PREFETCH_L1(sequences[seqNb].match + sequences[seqNb].matchLength - 1); /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */
}
if (seqNb<seqAdvance) return ERROR(corruption_detected);
/* decode and decompress */
for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (seqNb<nbSeq) ; seqNb++) {
seq_t const sequence = ZSTD_decodeSequenceLong(&seqState, isLongOffset);
size_t const oneSeqSize = ZSTD_execSequenceLong(op, oend, sequences[(seqNb-ADVANCED_SEQS) & STORED_SEQS_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd);
if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
PREFETCH_L1(sequence.match); PREFETCH_L1(sequence.match + sequence.matchLength - 1); /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */
sequences[seqNb & STORED_SEQS_MASK] = sequence;
op += oneSeqSize;
}
if (seqNb<nbSeq) return ERROR(corruption_detected);
/* finish queue */
seqNb -= seqAdvance;
for ( ; seqNb<nbSeq ; seqNb++) {
size_t const oneSeqSize = ZSTD_execSequenceLong(op, oend, sequences[seqNb&STORED_SEQS_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd);
if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
op += oneSeqSize;
}
/* save reps for next block */
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
}
/* last literal segment */
{ size_t const lastLLSize = litEnd - litPtr;
if (lastLLSize > (size_t)(oend-op)) return ERROR(dstSize_tooSmall);
memcpy(op, litPtr, lastLLSize);
op += lastLLSize;
}
return op-ostart;
}
static size_t
ZSTD_decompressSequencesLong_default(ZSTD_DCtx* dctx,
void* dst, size_t maxDstSize,
const void* seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset)
{
return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
}
#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */
#if DYNAMIC_BMI2
#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
static TARGET_ATTRIBUTE("bmi2") size_t
ZSTD_decompressSequences_bmi2(ZSTD_DCtx* dctx,
void* dst, size_t maxDstSize,
const void* seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset)
{
return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
}
#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */
#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
static TARGET_ATTRIBUTE("bmi2") size_t
ZSTD_decompressSequencesLong_bmi2(ZSTD_DCtx* dctx,
void* dst, size_t maxDstSize,
const void* seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset)
{
return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
}
#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */
#endif /* DYNAMIC_BMI2 */
typedef size_t (*ZSTD_decompressSequences_t)(
ZSTD_DCtx* dctx,
void* dst, size_t maxDstSize,
const void* seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset);
#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
static size_t
ZSTD_decompressSequences(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize,
const void* seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset)
{
DEBUGLOG(5, "ZSTD_decompressSequences");
#if DYNAMIC_BMI2
if (dctx->bmi2) {
return ZSTD_decompressSequences_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
}
#endif
return ZSTD_decompressSequences_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
}
#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */
#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
/* ZSTD_decompressSequencesLong() :
* decompression function triggered when a minimum share of offsets is considered "long",
* aka out of cache.
* note : "long" definition seems overloaded here, sometimes meaning "wider than bitstream register", and sometimes mearning "farther than memory cache distance".
* This function will try to mitigate main memory latency through the use of prefetching */
static size_t
ZSTD_decompressSequencesLong(ZSTD_DCtx* dctx,
void* dst, size_t maxDstSize,
const void* seqStart, size_t seqSize, int nbSeq,
const ZSTD_longOffset_e isLongOffset)
{
DEBUGLOG(5, "ZSTD_decompressSequencesLong");
#if DYNAMIC_BMI2
if (dctx->bmi2) {
return ZSTD_decompressSequencesLong_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
}
#endif
return ZSTD_decompressSequencesLong_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
}
#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */
#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
!defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
/* ZSTD_getLongOffsetsShare() :
* condition : offTable must be valid
* @return : "share" of long offsets (arbitrarily defined as > (1<<23))
* compared to maximum possible of (1<<OffFSELog) */
static unsigned
ZSTD_getLongOffsetsShare(const ZSTD_seqSymbol* offTable)
{
const void* ptr = offTable;
U32 const tableLog = ((const ZSTD_seqSymbol_header*)ptr)[0].tableLog;
const ZSTD_seqSymbol* table = offTable + 1;
U32 const max = 1 << tableLog;
U32 u, total = 0;
DEBUGLOG(5, "ZSTD_getLongOffsetsShare: (tableLog=%u)", tableLog);
assert(max <= (1 << OffFSELog)); /* max not too large */
for (u=0; u<max; u++) {
if (table[u].nbAdditionalBits > 22) total += 1;
}
assert(tableLog <= OffFSELog);
total <<= (OffFSELog - tableLog); /* scale to OffFSELog */
return total;
}
#endif
size_t
ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const int frame)
{ /* blockType == blockCompressed */
const BYTE* ip = (const BYTE*)src;
/* isLongOffset must be true if there are long offsets.
* Offsets are long if they are larger than 2^STREAM_ACCUMULATOR_MIN.
* We don't expect that to be the case in 64-bit mode.
* In block mode, window size is not known, so we have to be conservative.
* (note: but it could be evaluated from current-lowLimit)
*/
ZSTD_longOffset_e const isLongOffset = (ZSTD_longOffset_e)(MEM_32bits() && (!frame || (dctx->fParams.windowSize > (1ULL << STREAM_ACCUMULATOR_MIN))));
DEBUGLOG(5, "ZSTD_decompressBlock_internal (size : %u)", (U32)srcSize);
if (srcSize >= ZSTD_BLOCKSIZE_MAX) return ERROR(srcSize_wrong);
/* Decode literals section */
{ size_t const litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize);
DEBUGLOG(5, "ZSTD_decodeLiteralsBlock : %u", (U32)litCSize);
if (ZSTD_isError(litCSize)) return litCSize;
ip += litCSize;
srcSize -= litCSize;
}
/* Build Decoding Tables */
{
/* These macros control at build-time which decompressor implementation
* we use. If neither is defined, we do some inspection and dispatch at
* runtime.
*/
#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
!defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
int usePrefetchDecoder = dctx->ddictIsCold;
#endif
int nbSeq;
size_t const seqHSize = ZSTD_decodeSeqHeaders(dctx, &nbSeq, ip, srcSize);
if (ZSTD_isError(seqHSize)) return seqHSize;
ip += seqHSize;
srcSize -= seqHSize;
#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
!defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
if ( !usePrefetchDecoder
&& (!frame || (dctx->fParams.windowSize > (1<<24)))
&& (nbSeq>ADVANCED_SEQS) ) { /* could probably use a larger nbSeq limit */
U32 const shareLongOffsets = ZSTD_getLongOffsetsShare(dctx->OFTptr);
U32 const minShare = MEM_64bits() ? 7 : 20; /* heuristic values, correspond to 2.73% and 7.81% */
usePrefetchDecoder = (shareLongOffsets >= minShare);
}
#endif
dctx->ddictIsCold = 0;
#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
!defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
if (usePrefetchDecoder)
#endif
#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
return ZSTD_decompressSequencesLong(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset);
#endif
#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
/* else */
return ZSTD_decompressSequences(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset);
#endif
}
}
size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize)
{
size_t dSize;
ZSTD_checkContinuity(dctx, dst);
dSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 0);
dctx->previousDstEnd = (char*)dst + dSize;
return dSize;
}

contrib/python-zstandard/zstd/decompress/zstd_decompress_internal.h

  • This file was added.
/*
* Copyright (c) 2016-present, Yann Collet, 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).
* You may select, at your option, one of the above-listed licenses.
*/
/* zstd_decompress_internal:
* objects and definitions shared within lib/decompress modules */
#ifndef ZSTD_DECOMPRESS_INTERNAL_H
#define ZSTD_DECOMPRESS_INTERNAL_H
/*-*******************************************************
* Dependencies
*********************************************************/
#include "mem.h" /* BYTE, U16, U32 */
#include "zstd_internal.h" /* ZSTD_seqSymbol */
/*-*******************************************************
* Constants
*********************************************************/
static const U32 LL_base[MaxLL+1] = {
0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15,
16, 18, 20, 22, 24, 28, 32, 40,
48, 64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000,
0x2000, 0x4000, 0x8000, 0x10000 };
static const U32 OF_base[MaxOff+1] = {
0, 1, 1, 5, 0xD, 0x1D, 0x3D, 0x7D,
0xFD, 0x1FD, 0x3FD, 0x7FD, 0xFFD, 0x1FFD, 0x3FFD, 0x7FFD,
0xFFFD, 0x1FFFD, 0x3FFFD, 0x7FFFD, 0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD,
0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD, 0x1FFFFFFD, 0x3FFFFFFD, 0x7FFFFFFD };
static const U32 OF_bits[MaxOff+1] = {
0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31 };
static const U32 ML_base[MaxML+1] = {
3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25, 26,
27, 28, 29, 30, 31, 32, 33, 34,
35, 37, 39, 41, 43, 47, 51, 59,
67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803,
0x1003, 0x2003, 0x4003, 0x8003, 0x10003 };
/*-*******************************************************
* Decompression types
*********************************************************/
typedef struct {
U32 fastMode;
U32 tableLog;
} ZSTD_seqSymbol_header;
typedef struct {
U16 nextState;
BYTE nbAdditionalBits;
BYTE nbBits;
U32 baseValue;
} ZSTD_seqSymbol;
#define SEQSYMBOL_TABLE_SIZE(log) (1 + (1 << (log)))
typedef struct {
ZSTD_seqSymbol LLTable[SEQSYMBOL_TABLE_SIZE(LLFSELog)]; /* Note : Space reserved for FSE Tables */
ZSTD_seqSymbol OFTable[SEQSYMBOL_TABLE_SIZE(OffFSELog)]; /* is also used as temporary workspace while building hufTable during DDict creation */
ZSTD_seqSymbol MLTable[SEQSYMBOL_TABLE_SIZE(MLFSELog)]; /* and therefore must be at least HUF_DECOMPRESS_WORKSPACE_SIZE large */
HUF_DTable hufTable[HUF_DTABLE_SIZE(HufLog)]; /* can accommodate HUF_decompress4X */
U32 rep[ZSTD_REP_NUM];
} ZSTD_entropyDTables_t;
typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,
ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock,
ZSTDds_decompressLastBlock, ZSTDds_checkChecksum,
ZSTDds_decodeSkippableHeader, ZSTDds_skipFrame } ZSTD_dStage;
typedef enum { zdss_init=0, zdss_loadHeader,
zdss_read, zdss_load, zdss_flush } ZSTD_dStreamStage;
struct ZSTD_DCtx_s
{
const ZSTD_seqSymbol* LLTptr;
const ZSTD_seqSymbol* MLTptr;
const ZSTD_seqSymbol* OFTptr;
const HUF_DTable* HUFptr;
ZSTD_entropyDTables_t entropy;
U32 workspace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32]; /* space needed when building huffman tables */
const void* previousDstEnd; /* detect continuity */
const void* prefixStart; /* start of current segment */
const void* virtualStart; /* virtual start of previous segment if it was just before current one */
const void* dictEnd; /* end of previous segment */
size_t expected;
ZSTD_frameHeader fParams;
U64 decodedSize;
blockType_e bType; /* used in ZSTD_decompressContinue(), store blockType between block header decoding and block decompression stages */
ZSTD_dStage stage;
U32 litEntropy;
U32 fseEntropy;
XXH64_state_t xxhState;
size_t headerSize;
ZSTD_format_e format;
const BYTE* litPtr;
ZSTD_customMem customMem;
size_t litSize;
size_t rleSize;
size_t staticSize;
int bmi2; /* == 1 if the CPU supports BMI2 and 0 otherwise. CPU support is determined dynamically once per context lifetime. */
/* dictionary */
ZSTD_DDict* ddictLocal;
const ZSTD_DDict* ddict; /* set by ZSTD_initDStream_usingDDict(), or ZSTD_DCtx_refDDict() */
U32 dictID;
int ddictIsCold; /* if == 1 : dictionary is "new" for working context, and presumed "cold" (not in cpu cache) */
/* streaming */
ZSTD_dStreamStage streamStage;
char* inBuff;
size_t inBuffSize;
size_t inPos;
size_t maxWindowSize;
char* outBuff;
size_t outBuffSize;
size_t outStart;
size_t outEnd;
size_t lhSize;
void* legacyContext;
U32 previousLegacyVersion;
U32 legacyVersion;
U32 hostageByte;
int noForwardProgress;
/* workspace */
BYTE litBuffer[ZSTD_BLOCKSIZE_MAX + WILDCOPY_OVERLENGTH];
BYTE headerBuffer[ZSTD_FRAMEHEADERSIZE_MAX];
}; /* typedef'd to ZSTD_DCtx within "zstd.h" */
/*-*******************************************************
* Shared internal functions
*********************************************************/
/*! ZSTD_loadDEntropy() :
* dict : must point at beginning of a valid zstd dictionary.
* @return : size of entropy tables read */
size_t ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
const void* const dict, size_t const dictSize);
/*! ZSTD_checkContinuity() :
* check if next `dst` follows previous position, where decompression ended.
* If yes, do nothing (continue on current segment).
* If not, classify previous segment as "external dictionary", and start a new segment.
* This function cannot fail. */
void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst);
#endif /* ZSTD_DECOMPRESS_INTERNAL_H */

contrib/python-zstandard/zstd/dictBuilder/cover.c

#ifndef ZDICT_STATIC_LINKING_ONLY #ifndef ZDICT_STATIC_LINKING_ONLY
#define ZDICT_STATIC_LINKING_ONLY #define ZDICT_STATIC_LINKING_ONLY
#endif #endif
#include "zdict.h" #include "zdict.h"
/*-************************************* /*-*************************************
* Constants * Constants
***************************************/ ***************************************/
#define COVER_MAX_SAMPLES_SIZE (sizeof(size_t) == 8 ? ((U32)-1) : ((U32)1 GB)) #define COVER_MAX_SAMPLES_SIZE (sizeof(size_t) == 8 ? ((unsigned)-1) : ((unsigned)1 GB))
#define DEFAULT_SPLITPOINT 1.0 #define DEFAULT_SPLITPOINT 1.0
/*-************************************* /*-*************************************
* Console display * Console display
***************************************/ ***************************************/
static int g_displayLevel = 2; static int g_displayLevel = 2;
#define DISPLAY(...) \ #define DISPLAY(...) \
{ \ { \
const unsigned nbTrainSamples = splitPoint < 1.0 ? (unsigned)((double)nbSamples * splitPoint) : nbSamples; const unsigned nbTrainSamples = splitPoint < 1.0 ? (unsigned)((double)nbSamples * splitPoint) : nbSamples;
const unsigned nbTestSamples = splitPoint < 1.0 ? nbSamples - nbTrainSamples : nbSamples; const unsigned nbTestSamples = splitPoint < 1.0 ? nbSamples - nbTrainSamples : nbSamples;
const size_t trainingSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes, nbTrainSamples) : totalSamplesSize; const size_t trainingSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes, nbTrainSamples) : totalSamplesSize;
const size_t testSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes + nbTrainSamples, nbTestSamples) : totalSamplesSize; const size_t testSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes + nbTrainSamples, nbTestSamples) : totalSamplesSize;
/* Checks */ /* Checks */
if (totalSamplesSize < MAX(d, sizeof(U64)) || if (totalSamplesSize < MAX(d, sizeof(U64)) ||
totalSamplesSize >= (size_t)COVER_MAX_SAMPLES_SIZE) { totalSamplesSize >= (size_t)COVER_MAX_SAMPLES_SIZE) {
DISPLAYLEVEL(1, "Total samples size is too large (%u MB), maximum size is %u MB\n", DISPLAYLEVEL(1, "Total samples size is too large (%u MB), maximum size is %u MB\n",
(U32)(totalSamplesSize>>20), (COVER_MAX_SAMPLES_SIZE >> 20)); (unsigned)(totalSamplesSize>>20), (COVER_MAX_SAMPLES_SIZE >> 20));
return 0; return 0;
} }
/* Check if there are at least 5 training samples */ /* Check if there are at least 5 training samples */
if (nbTrainSamples < 5) { if (nbTrainSamples < 5) {
DISPLAYLEVEL(1, "Total number of training samples is %u and is invalid.", nbTrainSamples); DISPLAYLEVEL(1, "Total number of training samples is %u and is invalid.", nbTrainSamples);
return 0; return 0;
} }
/* Check if there's testing sample */ /* Check if there's testing sample */
if (nbTestSamples < 1) { if (nbTestSamples < 1) {
DISPLAYLEVEL(1, "Total number of testing samples is %u and is invalid.", nbTestSamples); DISPLAYLEVEL(1, "Total number of testing samples is %u and is invalid.", nbTestSamples);
return 0; return 0;
} }
/* Zero the context */ /* Zero the context */
memset(ctx, 0, sizeof(*ctx)); memset(ctx, 0, sizeof(*ctx));
DISPLAYLEVEL(2, "Training on %u samples of total size %u\n", nbTrainSamples, DISPLAYLEVEL(2, "Training on %u samples of total size %u\n", nbTrainSamples,
(U32)trainingSamplesSize); (unsigned)trainingSamplesSize);
DISPLAYLEVEL(2, "Testing on %u samples of total size %u\n", nbTestSamples, DISPLAYLEVEL(2, "Testing on %u samples of total size %u\n", nbTestSamples,
(U32)testSamplesSize); (unsigned)testSamplesSize);
ctx->samples = samples; ctx->samples = samples;
ctx->samplesSizes = samplesSizes; ctx->samplesSizes = samplesSizes;
ctx->nbSamples = nbSamples; ctx->nbSamples = nbSamples;
ctx->nbTrainSamples = nbTrainSamples; ctx->nbTrainSamples = nbTrainSamples;
ctx->nbTestSamples = nbTestSamples; ctx->nbTestSamples = nbTestSamples;
/* Partial suffix array */ /* Partial suffix array */
ctx->suffixSize = trainingSamplesSize - MAX(d, sizeof(U64)) + 1; ctx->suffixSize = trainingSamplesSize - MAX(d, sizeof(U64)) + 1;
ctx->suffix = (U32 *)malloc(ctx->suffixSize * sizeof(U32)); ctx->suffix = (U32 *)malloc(ctx->suffixSize * sizeof(U32));
COVER_map_t *activeDmers, void *dictBuffer, COVER_map_t *activeDmers, void *dictBuffer,
size_t dictBufferCapacity, size_t dictBufferCapacity,
ZDICT_cover_params_t parameters) { ZDICT_cover_params_t parameters) {
BYTE *const dict = (BYTE *)dictBuffer; BYTE *const dict = (BYTE *)dictBuffer;
size_t tail = dictBufferCapacity; size_t tail = dictBufferCapacity;
/* Divide the data up into epochs of equal size. /* Divide the data up into epochs of equal size.
* We will select at least one segment from each epoch. * We will select at least one segment from each epoch.
*/ */
const U32 epochs = MAX(1, (U32)(dictBufferCapacity / parameters.k / 4)); const unsigned epochs = MAX(1, (U32)(dictBufferCapacity / parameters.k / 4));
const U32 epochSize = (U32)(ctx->suffixSize / epochs); const unsigned epochSize = (U32)(ctx->suffixSize / epochs);
size_t epoch; size_t epoch;
DISPLAYLEVEL(2, "Breaking content into %u epochs of size %u\n", epochs, DISPLAYLEVEL(2, "Breaking content into %u epochs of size %u\n",
epochSize); epochs, epochSize);
/* Loop through the epochs until there are no more segments or the dictionary /* Loop through the epochs until there are no more segments or the dictionary
* is full. * is full.
*/ */
for (epoch = 0; tail > 0; epoch = (epoch + 1) % epochs) { for (epoch = 0; tail > 0; epoch = (epoch + 1) % epochs) {
const U32 epochBegin = (U32)(epoch * epochSize); const U32 epochBegin = (U32)(epoch * epochSize);
const U32 epochEnd = epochBegin + epochSize; const U32 epochEnd = epochBegin + epochSize;
size_t segmentSize; size_t segmentSize;
/* Select a segment */ /* Select a segment */
} }
/* We fill the dictionary from the back to allow the best segments to be /* We fill the dictionary from the back to allow the best segments to be
* referenced with the smallest offsets. * referenced with the smallest offsets.
*/ */
tail -= segmentSize; tail -= segmentSize;
memcpy(dict + tail, ctx->samples + segment.begin, segmentSize); memcpy(dict + tail, ctx->samples + segment.begin, segmentSize);
DISPLAYUPDATE( DISPLAYUPDATE(
2, "\r%u%% ", 2, "\r%u%% ",
(U32)(((dictBufferCapacity - tail) * 100) / dictBufferCapacity)); (unsigned)(((dictBufferCapacity - tail) * 100) / dictBufferCapacity));
} }
DISPLAYLEVEL(2, "\r%79s\r", ""); DISPLAYLEVEL(2, "\r%79s\r", "");
return tail; return tail;
} }
ZDICTLIB_API size_t ZDICT_trainFromBuffer_cover( ZDICTLIB_API size_t ZDICT_trainFromBuffer_cover(
void *dictBuffer, size_t dictBufferCapacity, void *dictBuffer, size_t dictBufferCapacity,
const void *samplesBuffer, const size_t *samplesSizes, unsigned nbSamples, const void *samplesBuffer, const size_t *samplesSizes, unsigned nbSamples,
const size_t tail = const size_t tail =
COVER_buildDictionary(&ctx, ctx.freqs, &activeDmers, dictBuffer, COVER_buildDictionary(&ctx, ctx.freqs, &activeDmers, dictBuffer,
dictBufferCapacity, parameters); dictBufferCapacity, parameters);
const size_t dictionarySize = ZDICT_finalizeDictionary( const size_t dictionarySize = ZDICT_finalizeDictionary(
dict, dictBufferCapacity, dict + tail, dictBufferCapacity - tail, dict, dictBufferCapacity, dict + tail, dictBufferCapacity - tail,
samplesBuffer, samplesSizes, nbSamples, parameters.zParams); samplesBuffer, samplesSizes, nbSamples, parameters.zParams);
if (!ZSTD_isError(dictionarySize)) { if (!ZSTD_isError(dictionarySize)) {
DISPLAYLEVEL(2, "Constructed dictionary of size %u\n", DISPLAYLEVEL(2, "Constructed dictionary of size %u\n",
(U32)dictionarySize); (unsigned)dictionarySize);
} }
COVER_ctx_destroy(&ctx); COVER_ctx_destroy(&ctx);
COVER_map_destroy(&activeDmers); COVER_map_destroy(&activeDmers);
return dictionarySize; return dictionarySize;
} }
} }
if (!best->dict || best->dictSize < dictSize) { if (!best->dict || best->dictSize < dictSize) {
if (best->dict) { if (best->dict) {
free(best->dict); free(best->dict);
} }
best->dict = malloc(dictSize); best->dict = malloc(dictSize);
if (!best->dict) { if (!best->dict) {
best->compressedSize = ERROR(GENERIC); best->compressedSize = ERROR(GENERIC);
best->dictSize = 0; best->dictSize = 0;
ZSTD_pthread_cond_signal(&best->cond);
ZSTD_pthread_mutex_unlock(&best->mutex);
return; return;
} }
} }
/* Save the dictionary, parameters, and size */ /* Save the dictionary, parameters, and size */
memcpy(best->dict, dict, dictSize); memcpy(best->dict, dict, dictSize);
best->dictSize = dictSize; best->dictSize = dictSize;
best->parameters = parameters; best->parameters = parameters;
best->compressedSize = compressedSize; best->compressedSize = compressedSize;
COVER_best_start(&best); COVER_best_start(&best);
if (pool) { if (pool) {
POOL_add(pool, &COVER_tryParameters, data); POOL_add(pool, &COVER_tryParameters, data);
} else { } else {
COVER_tryParameters(data); COVER_tryParameters(data);
} }
/* Print status */ /* Print status */
LOCALDISPLAYUPDATE(displayLevel, 2, "\r%u%% ", LOCALDISPLAYUPDATE(displayLevel, 2, "\r%u%% ",
(U32)((iteration * 100) / kIterations)); (unsigned)((iteration * 100) / kIterations));
++iteration; ++iteration;
} }
COVER_best_wait(&best); COVER_best_wait(&best);
COVER_ctx_destroy(&ctx); COVER_ctx_destroy(&ctx);
} }
LOCALDISPLAYLEVEL(displayLevel, 2, "\r%79s\r", ""); LOCALDISPLAYLEVEL(displayLevel, 2, "\r%79s\r", "");
/* Fill the output buffer and parameters with output of the best parameters */ /* Fill the output buffer and parameters with output of the best parameters */
{ {

contrib/python-zstandard/zstd/dictBuilder/fastcover.c

#define ZDICT_STATIC_LINKING_ONLY #define ZDICT_STATIC_LINKING_ONLY
#endif #endif
#include "zdict.h" #include "zdict.h"
/*-************************************* /*-*************************************
* Constants * Constants
***************************************/ ***************************************/
#define FASTCOVER_MAX_SAMPLES_SIZE (sizeof(size_t) == 8 ? ((U32)-1) : ((U32)1 GB)) #define FASTCOVER_MAX_SAMPLES_SIZE (sizeof(size_t) == 8 ? ((unsigned)-1) : ((unsigned)1 GB))
#define FASTCOVER_MAX_F 31 #define FASTCOVER_MAX_F 31
#define FASTCOVER_MAX_ACCEL 10 #define FASTCOVER_MAX_ACCEL 10
#define DEFAULT_SPLITPOINT 0.75 #define DEFAULT_SPLITPOINT 0.75
#define DEFAULT_F 20 #define DEFAULT_F 20
#define DEFAULT_ACCEL 1 #define DEFAULT_ACCEL 1
/*-************************************* /*-*************************************
activeSegment.end = begin; activeSegment.end = begin;
activeSegment.score = 0; activeSegment.score = 0;
/* Slide the activeSegment through the whole epoch. /* Slide the activeSegment through the whole epoch.
* Save the best segment in bestSegment. * Save the best segment in bestSegment.
*/ */
while (activeSegment.end < end) { while (activeSegment.end < end) {
/* Get hash value of current dmer */ /* Get hash value of current dmer */
const size_t index = FASTCOVER_hashPtrToIndex(ctx->samples + activeSegment.end, f, d); const size_t idx = FASTCOVER_hashPtrToIndex(ctx->samples + activeSegment.end, f, d);
/* Add frequency of this index to score if this is the first occurence of index in active segment */ /* Add frequency of this index to score if this is the first occurence of index in active segment */
if (segmentFreqs[index] == 0) { if (segmentFreqs[idx] == 0) {
activeSegment.score += freqs[index]; activeSegment.score += freqs[idx];
} }
/* Increment end of segment and segmentFreqs*/ /* Increment end of segment and segmentFreqs*/
activeSegment.end += 1; activeSegment.end += 1;
segmentFreqs[index] += 1; segmentFreqs[idx] += 1;
/* If the window is now too large, drop the first position */ /* If the window is now too large, drop the first position */
if (activeSegment.end - activeSegment.begin == dmersInK + 1) { if (activeSegment.end - activeSegment.begin == dmersInK + 1) {
/* Get hash value of the dmer to be eliminated from active segment */ /* Get hash value of the dmer to be eliminated from active segment */
const size_t delIndex = FASTCOVER_hashPtrToIndex(ctx->samples + activeSegment.begin, f, d); const size_t delIndex = FASTCOVER_hashPtrToIndex(ctx->samples + activeSegment.begin, f, d);
segmentFreqs[delIndex] -= 1; segmentFreqs[delIndex] -= 1;
/* Subtract frequency of this index from score if this is the last occurrence of this index in active segment */ /* Subtract frequency of this index from score if this is the last occurrence of this index in active segment */
if (segmentFreqs[delIndex] == 0) { if (segmentFreqs[delIndex] == 0) {
activeSegment.score -= freqs[delIndex]; activeSegment.score -= freqs[delIndex];
const unsigned nbTestSamples = splitPoint < 1.0 ? nbSamples - nbTrainSamples : nbSamples; const unsigned nbTestSamples = splitPoint < 1.0 ? nbSamples - nbTrainSamples : nbSamples;
const size_t trainingSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes, nbTrainSamples) : totalSamplesSize; const size_t trainingSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes, nbTrainSamples) : totalSamplesSize;
const size_t testSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes + nbTrainSamples, nbTestSamples) : totalSamplesSize; const size_t testSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes + nbTrainSamples, nbTestSamples) : totalSamplesSize;
/* Checks */ /* Checks */
if (totalSamplesSize < MAX(d, sizeof(U64)) || if (totalSamplesSize < MAX(d, sizeof(U64)) ||
totalSamplesSize >= (size_t)FASTCOVER_MAX_SAMPLES_SIZE) { totalSamplesSize >= (size_t)FASTCOVER_MAX_SAMPLES_SIZE) {
DISPLAYLEVEL(1, "Total samples size is too large (%u MB), maximum size is %u MB\n", DISPLAYLEVEL(1, "Total samples size is too large (%u MB), maximum size is %u MB\n",
(U32)(totalSamplesSize >> 20), (FASTCOVER_MAX_SAMPLES_SIZE >> 20)); (unsigned)(totalSamplesSize >> 20), (FASTCOVER_MAX_SAMPLES_SIZE >> 20));
return 0; return 0;
} }
/* Check if there are at least 5 training samples */ /* Check if there are at least 5 training samples */
if (nbTrainSamples < 5) { if (nbTrainSamples < 5) {
DISPLAYLEVEL(1, "Total number of training samples is %u and is invalid\n", nbTrainSamples); DISPLAYLEVEL(1, "Total number of training samples is %u and is invalid\n", nbTrainSamples);
return 0; return 0;
} }
/* Check if there's testing sample */ /* Check if there's testing sample */
if (nbTestSamples < 1) { if (nbTestSamples < 1) {
DISPLAYLEVEL(1, "Total number of testing samples is %u and is invalid.\n", nbTestSamples); DISPLAYLEVEL(1, "Total number of testing samples is %u and is invalid.\n", nbTestSamples);
return 0; return 0;
} }
/* Zero the context */ /* Zero the context */
memset(ctx, 0, sizeof(*ctx)); memset(ctx, 0, sizeof(*ctx));
DISPLAYLEVEL(2, "Training on %u samples of total size %u\n", nbTrainSamples, DISPLAYLEVEL(2, "Training on %u samples of total size %u\n", nbTrainSamples,
(U32)trainingSamplesSize); (unsigned)trainingSamplesSize);
DISPLAYLEVEL(2, "Testing on %u samples of total size %u\n", nbTestSamples, DISPLAYLEVEL(2, "Testing on %u samples of total size %u\n", nbTestSamples,
(U32)testSamplesSize); (unsigned)testSamplesSize);
ctx->samples = samples; ctx->samples = samples;
ctx->samplesSizes = samplesSizes; ctx->samplesSizes = samplesSizes;
ctx->nbSamples = nbSamples; ctx->nbSamples = nbSamples;
ctx->nbTrainSamples = nbTrainSamples; ctx->nbTrainSamples = nbTrainSamples;
ctx->nbTestSamples = nbTestSamples; ctx->nbTestSamples = nbTestSamples;
ctx->nbDmers = trainingSamplesSize - MAX(d, sizeof(U64)) + 1; ctx->nbDmers = trainingSamplesSize - MAX(d, sizeof(U64)) + 1;
ctx->d = d; ctx->d = d;
ZDICT_cover_params_t parameters, ZDICT_cover_params_t parameters,
U16* segmentFreqs) U16* segmentFreqs)
{ {
BYTE *const dict = (BYTE *)dictBuffer; BYTE *const dict = (BYTE *)dictBuffer;
size_t tail = dictBufferCapacity; size_t tail = dictBufferCapacity;
/* Divide the data up into epochs of equal size. /* Divide the data up into epochs of equal size.
* We will select at least one segment from each epoch. * We will select at least one segment from each epoch.
*/ */
const U32 epochs = MAX(1, (U32)(dictBufferCapacity / parameters.k)); const unsigned epochs = MAX(1, (U32)(dictBufferCapacity / parameters.k));
const U32 epochSize = (U32)(ctx->nbDmers / epochs); const unsigned epochSize = (U32)(ctx->nbDmers / epochs);
size_t epoch; size_t epoch;
DISPLAYLEVEL(2, "Breaking content into %u epochs of size %u\n", epochs, DISPLAYLEVEL(2, "Breaking content into %u epochs of size %u\n",
epochSize); epochs, epochSize);
/* Loop through the epochs until there are no more segments or the dictionary /* Loop through the epochs until there are no more segments or the dictionary
* is full. * is full.
*/ */
for (epoch = 0; tail > 0; epoch = (epoch + 1) % epochs) { for (epoch = 0; tail > 0; epoch = (epoch + 1) % epochs) {
const U32 epochBegin = (U32)(epoch * epochSize); const U32 epochBegin = (U32)(epoch * epochSize);
const U32 epochEnd = epochBegin + epochSize; const U32 epochEnd = epochBegin + epochSize;
size_t segmentSize; size_t segmentSize;
/* Select a segment */ /* Select a segment */
/* We fill the dictionary from the back to allow the best segments to be /* We fill the dictionary from the back to allow the best segments to be
* referenced with the smallest offsets. * referenced with the smallest offsets.
*/ */
tail -= segmentSize; tail -= segmentSize;
memcpy(dict + tail, ctx->samples + segment.begin, segmentSize); memcpy(dict + tail, ctx->samples + segment.begin, segmentSize);
DISPLAYUPDATE( DISPLAYUPDATE(
2, "\r%u%% ", 2, "\r%u%% ",
(U32)(((dictBufferCapacity - tail) * 100) / dictBufferCapacity)); (unsigned)(((dictBufferCapacity - tail) * 100) / dictBufferCapacity));
} }
DISPLAYLEVEL(2, "\r%79s\r", ""); DISPLAYLEVEL(2, "\r%79s\r", "");
return tail; return tail;
} }
/** /**
* Parameters for FASTCOVER_tryParameters(). * Parameters for FASTCOVER_tryParameters().
const size_t tail = FASTCOVER_buildDictionary(&ctx, ctx.freqs, dictBuffer, const size_t tail = FASTCOVER_buildDictionary(&ctx, ctx.freqs, dictBuffer,
dictBufferCapacity, coverParams, segmentFreqs); dictBufferCapacity, coverParams, segmentFreqs);
const unsigned nbFinalizeSamples = (unsigned)(ctx.nbTrainSamples * ctx.accelParams.finalize / 100); const unsigned nbFinalizeSamples = (unsigned)(ctx.nbTrainSamples * ctx.accelParams.finalize / 100);
const size_t dictionarySize = ZDICT_finalizeDictionary( const size_t dictionarySize = ZDICT_finalizeDictionary(
dict, dictBufferCapacity, dict + tail, dictBufferCapacity - tail, dict, dictBufferCapacity, dict + tail, dictBufferCapacity - tail,
samplesBuffer, samplesSizes, nbFinalizeSamples, coverParams.zParams); samplesBuffer, samplesSizes, nbFinalizeSamples, coverParams.zParams);
if (!ZSTD_isError(dictionarySize)) { if (!ZSTD_isError(dictionarySize)) {
DISPLAYLEVEL(2, "Constructed dictionary of size %u\n", DISPLAYLEVEL(2, "Constructed dictionary of size %u\n",
(U32)dictionarySize); (unsigned)dictionarySize);
} }
FASTCOVER_ctx_destroy(&ctx); FASTCOVER_ctx_destroy(&ctx);
free(segmentFreqs); free(segmentFreqs);
return dictionarySize; return dictionarySize;
} }
} }
COVER_best_start(&best); COVER_best_start(&best);
if (pool) { if (pool) {
POOL_add(pool, &FASTCOVER_tryParameters, data); POOL_add(pool, &FASTCOVER_tryParameters, data);
} else { } else {
FASTCOVER_tryParameters(data); FASTCOVER_tryParameters(data);
} }
/* Print status */ /* Print status */
LOCALDISPLAYUPDATE(displayLevel, 2, "\r%u%% ", LOCALDISPLAYUPDATE(displayLevel, 2, "\r%u%% ",
(U32)((iteration * 100) / kIterations)); (unsigned)((iteration * 100) / kIterations));
++iteration; ++iteration;
} }
COVER_best_wait(&best); COVER_best_wait(&best);
FASTCOVER_ctx_destroy(&ctx); FASTCOVER_ctx_destroy(&ctx);
} }
LOCALDISPLAYLEVEL(displayLevel, 2, "\r%79s\r", ""); LOCALDISPLAYLEVEL(displayLevel, 2, "\r%79s\r", "");
/* Fill the output buffer and parameters with output of the best parameters */ /* Fill the output buffer and parameters with output of the best parameters */
{ {

contrib/python-zstandard/zstd/dictBuilder/zdict.c

if (end-start < minRatio) { if (end-start < minRatio) {
U32 idx; U32 idx;
for(idx=start; idx<end; idx++) for(idx=start; idx<end; idx++)
doneMarks[suffix[idx]] = 1; doneMarks[suffix[idx]] = 1;
return solution; return solution;
} }
{ int i; { int i;
U32 searchLength; U32 mml;
U32 refinedStart = start; U32 refinedStart = start;
U32 refinedEnd = end; U32 refinedEnd = end;
DISPLAYLEVEL(4, "\n"); DISPLAYLEVEL(4, "\n");
DISPLAYLEVEL(4, "found %3u matches of length >= %i at pos %7u ", (U32)(end-start), MINMATCHLENGTH, (U32)pos); DISPLAYLEVEL(4, "found %3u matches of length >= %i at pos %7u ", (unsigned)(end-start), MINMATCHLENGTH, (unsigned)pos);
DISPLAYLEVEL(4, "\n"); DISPLAYLEVEL(4, "\n");
for (searchLength = MINMATCHLENGTH ; ; searchLength++) { for (mml = MINMATCHLENGTH ; ; mml++) {
BYTE currentChar = 0; BYTE currentChar = 0;
U32 currentCount = 0; U32 currentCount = 0;
U32 currentID = refinedStart; U32 currentID = refinedStart;
U32 id; U32 id;
U32 selectedCount = 0; U32 selectedCount = 0;
U32 selectedID = currentID; U32 selectedID = currentID;
for (id =refinedStart; id < refinedEnd; id++) { for (id =refinedStart; id < refinedEnd; id++) {
if (b[suffix[id] + searchLength] != currentChar) { if (b[suffix[id] + mml] != currentChar) {
if (currentCount > selectedCount) { if (currentCount > selectedCount) {
selectedCount = currentCount; selectedCount = currentCount;
selectedID = currentID; selectedID = currentID;
} }
currentID = id; currentID = id;
currentChar = b[ suffix[id] + searchLength]; currentChar = b[ suffix[id] + mml];
currentCount = 0; currentCount = 0;
} }
currentCount ++; currentCount ++;
} }
if (currentCount > selectedCount) { /* for last */ if (currentCount > selectedCount) { /* for last */
selectedCount = currentCount; selectedCount = currentCount;
selectedID = currentID; selectedID = currentID;
} }
if (maxLength < MINMATCHLENGTH) return solution; /* skip : no long-enough solution */ if (maxLength < MINMATCHLENGTH) return solution; /* skip : no long-enough solution */
/* calculate savings */ /* calculate savings */
savings[5] = 0; savings[5] = 0;
for (i=MINMATCHLENGTH; i<=(int)maxLength; i++) for (i=MINMATCHLENGTH; i<=(int)maxLength; i++)
savings[i] = savings[i-1] + (lengthList[i] * (i-3)); savings[i] = savings[i-1] + (lengthList[i] * (i-3));
DISPLAYLEVEL(4, "Selected dict at position %u, of length %u : saves %u (ratio: %.2f) \n", DISPLAYLEVEL(4, "Selected dict at position %u, of length %u : saves %u (ratio: %.2f) \n",
(U32)pos, (U32)maxLength, savings[maxLength], (double)savings[maxLength] / maxLength); (unsigned)pos, (unsigned)maxLength, (unsigned)savings[maxLength], (double)savings[maxLength] / maxLength);
solution.pos = (U32)pos; solution.pos = (U32)pos;
solution.length = (U32)maxLength; solution.length = (U32)maxLength;
solution.savings = savings[maxLength]; solution.savings = savings[maxLength];
/* mark positions done */ /* mark positions done */
{ U32 id; { U32 id;
for (id=start; id<end; id++) { for (id=start; id<end; id++) {
dictSize += dictList[u].length; dictSize += dictList[u].length;
return dictSize; return dictSize;
} }
static size_t ZDICT_trainBuffer_legacy(dictItem* dictList, U32 dictListSize, static size_t ZDICT_trainBuffer_legacy(dictItem* dictList, U32 dictListSize,
const void* const buffer, size_t bufferSize, /* buffer must end with noisy guard band */ const void* const buffer, size_t bufferSize, /* buffer must end with noisy guard band */
const size_t* fileSizes, unsigned nbFiles, const size_t* fileSizes, unsigned nbFiles,
U32 minRatio, U32 notificationLevel) unsigned minRatio, U32 notificationLevel)
{ {
int* const suffix0 = (int*)malloc((bufferSize+2)*sizeof(*suffix0)); int* const suffix0 = (int*)malloc((bufferSize+2)*sizeof(*suffix0));
int* const suffix = suffix0+1; int* const suffix = suffix0+1;
U32* reverseSuffix = (U32*)malloc((bufferSize)*sizeof(*reverseSuffix)); U32* reverseSuffix = (U32*)malloc((bufferSize)*sizeof(*reverseSuffix));
BYTE* doneMarks = (BYTE*)malloc((bufferSize+16)*sizeof(*doneMarks)); /* +16 for overflow security */ BYTE* doneMarks = (BYTE*)malloc((bufferSize+16)*sizeof(*doneMarks)); /* +16 for overflow security */
U32* filePos = (U32*)malloc(nbFiles * sizeof(*filePos)); U32* filePos = (U32*)malloc(nbFiles * sizeof(*filePos));
size_t result = 0; size_t result = 0;
clock_t displayClock = 0; clock_t displayClock = 0;
if (!suffix0 || !reverseSuffix || !doneMarks || !filePos) { if (!suffix0 || !reverseSuffix || !doneMarks || !filePos) {
result = ERROR(memory_allocation); result = ERROR(memory_allocation);
goto _cleanup; goto _cleanup;
} }
if (minRatio < MINRATIO) minRatio = MINRATIO; if (minRatio < MINRATIO) minRatio = MINRATIO;
memset(doneMarks, 0, bufferSize+16); memset(doneMarks, 0, bufferSize+16);
/* limit sample set size (divsufsort limitation)*/ /* limit sample set size (divsufsort limitation)*/
if (bufferSize > ZDICT_MAX_SAMPLES_SIZE) DISPLAYLEVEL(3, "sample set too large : reduced to %u MB ...\n", (U32)(ZDICT_MAX_SAMPLES_SIZE>>20)); if (bufferSize > ZDICT_MAX_SAMPLES_SIZE) DISPLAYLEVEL(3, "sample set too large : reduced to %u MB ...\n", (unsigned)(ZDICT_MAX_SAMPLES_SIZE>>20));
while (bufferSize > ZDICT_MAX_SAMPLES_SIZE) bufferSize -= fileSizes[--nbFiles]; while (bufferSize > ZDICT_MAX_SAMPLES_SIZE) bufferSize -= fileSizes[--nbFiles];
/* sort */ /* sort */
DISPLAYLEVEL(2, "sorting %u files of total size %u MB ...\n", nbFiles, (U32)(bufferSize>>20)); DISPLAYLEVEL(2, "sorting %u files of total size %u MB ...\n", nbFiles, (unsigned)(bufferSize>>20));
{ int const divSuftSortResult = divsufsort((const unsigned char*)buffer, suffix, (int)bufferSize, 0); { int const divSuftSortResult = divsufsort((const unsigned char*)buffer, suffix, (int)bufferSize, 0);
if (divSuftSortResult != 0) { result = ERROR(GENERIC); goto _cleanup; } if (divSuftSortResult != 0) { result = ERROR(GENERIC); goto _cleanup; }
} }
suffix[bufferSize] = (int)bufferSize; /* leads into noise */ suffix[bufferSize] = (int)bufferSize; /* leads into noise */
suffix0[0] = (int)bufferSize; /* leads into noise */ suffix0[0] = (int)bufferSize; /* leads into noise */
/* build reverse suffix sort */ /* build reverse suffix sort */
{ size_t pos; { size_t pos;
for (pos=0; pos < bufferSize; pos++) for (pos=0; pos < bufferSize; pos++)
ZSTD_CDict* dict; /* dictionary */ ZSTD_CDict* dict; /* dictionary */
ZSTD_CCtx* zc; /* working context */ ZSTD_CCtx* zc; /* working context */
void* workPlace; /* must be ZSTD_BLOCKSIZE_MAX allocated */ void* workPlace; /* must be ZSTD_BLOCKSIZE_MAX allocated */
} EStats_ress_t; } EStats_ress_t;
#define MAXREPOFFSET 1024 #define MAXREPOFFSET 1024
static void ZDICT_countEStats(EStats_ress_t esr, ZSTD_parameters params, static void ZDICT_countEStats(EStats_ress_t esr, ZSTD_parameters params,
U32* countLit, U32* offsetcodeCount, U32* matchlengthCount, U32* litlengthCount, U32* repOffsets, unsigned* countLit, unsigned* offsetcodeCount, unsigned* matchlengthCount, unsigned* litlengthCount, U32* repOffsets,
const void* src, size_t srcSize, const void* src, size_t srcSize,
U32 notificationLevel) U32 notificationLevel)
{ {
size_t const blockSizeMax = MIN (ZSTD_BLOCKSIZE_MAX, 1 << params.cParams.windowLog); size_t const blockSizeMax = MIN (ZSTD_BLOCKSIZE_MAX, 1 << params.cParams.windowLog);
size_t cSize; size_t cSize;
if (srcSize > blockSizeMax) srcSize = blockSizeMax; /* protection vs large samples */ if (srcSize > blockSizeMax) srcSize = blockSizeMax; /* protection vs large samples */
{ size_t const errorCode = ZSTD_compressBegin_usingCDict(esr.zc, esr.dict); { size_t const errorCode = ZSTD_compressBegin_usingCDict(esr.zc, esr.dict);
if (ZSTD_isError(errorCode)) { DISPLAYLEVEL(1, "warning : ZSTD_compressBegin_usingCDict failed \n"); return; } if (ZSTD_isError(errorCode)) { DISPLAYLEVEL(1, "warning : ZSTD_compressBegin_usingCDict failed \n"); return; }
} }
cSize = ZSTD_compressBlock(esr.zc, esr.workPlace, ZSTD_BLOCKSIZE_MAX, src, srcSize); cSize = ZSTD_compressBlock(esr.zc, esr.workPlace, ZSTD_BLOCKSIZE_MAX, src, srcSize);
if (ZSTD_isError(cSize)) { DISPLAYLEVEL(3, "warning : could not compress sample size %u \n", (U32)srcSize); return; } if (ZSTD_isError(cSize)) { DISPLAYLEVEL(3, "warning : could not compress sample size %u \n", (unsigned)srcSize); return; }
if (cSize) { /* if == 0; block is not compressible */ if (cSize) { /* if == 0; block is not compressible */
const seqStore_t* const seqStorePtr = ZSTD_getSeqStore(esr.zc); const seqStore_t* const seqStorePtr = ZSTD_getSeqStore(esr.zc);
/* literals stats */ /* literals stats */
{ const BYTE* bytePtr; { const BYTE* bytePtr;
for(bytePtr = seqStorePtr->litStart; bytePtr < seqStorePtr->lit; bytePtr++) for(bytePtr = seqStorePtr->litStart; bytePtr < seqStorePtr->lit; bytePtr++)
countLit[*bytePtr]++; countLit[*bytePtr]++;
table[u] = tmp; table[u] = tmp;
} }
} }
/* ZDICT_flatLit() : /* ZDICT_flatLit() :
* rewrite `countLit` to contain a mostly flat but still compressible distribution of literals. * rewrite `countLit` to contain a mostly flat but still compressible distribution of literals.
* necessary to avoid generating a non-compressible distribution that HUF_writeCTable() cannot encode. * necessary to avoid generating a non-compressible distribution that HUF_writeCTable() cannot encode.
*/ */
static void ZDICT_flatLit(U32* countLit) static void ZDICT_flatLit(unsigned* countLit)
{ {
int u; int u;
for (u=1; u<256; u++) countLit[u] = 2; for (u=1; u<256; u++) countLit[u] = 2;
countLit[0] = 4; countLit[0] = 4;
countLit[253] = 1; countLit[253] = 1;
countLit[254] = 1; countLit[254] = 1;
} }
#define OFFCODE_MAX 30 /* only applicable to first block */ #define OFFCODE_MAX 30 /* only applicable to first block */
static size_t ZDICT_analyzeEntropy(void* dstBuffer, size_t maxDstSize, static size_t ZDICT_analyzeEntropy(void* dstBuffer, size_t maxDstSize,
unsigned compressionLevel, unsigned compressionLevel,
const void* srcBuffer, const size_t* fileSizes, unsigned nbFiles, const void* srcBuffer, const size_t* fileSizes, unsigned nbFiles,
const void* dictBuffer, size_t dictBufferSize, const void* dictBuffer, size_t dictBufferSize,
unsigned notificationLevel) unsigned notificationLevel)
{ {
U32 countLit[256]; unsigned countLit[256];
HUF_CREATE_STATIC_CTABLE(hufTable, 255); HUF_CREATE_STATIC_CTABLE(hufTable, 255);
U32 offcodeCount[OFFCODE_MAX+1]; unsigned offcodeCount[OFFCODE_MAX+1];
short offcodeNCount[OFFCODE_MAX+1]; short offcodeNCount[OFFCODE_MAX+1];
U32 offcodeMax = ZSTD_highbit32((U32)(dictBufferSize + 128 KB)); U32 offcodeMax = ZSTD_highbit32((U32)(dictBufferSize + 128 KB));
U32 matchLengthCount[MaxML+1]; unsigned matchLengthCount[MaxML+1];
short matchLengthNCount[MaxML+1]; short matchLengthNCount[MaxML+1];
U32 litLengthCount[MaxLL+1]; unsigned litLengthCount[MaxLL+1];
short litLengthNCount[MaxLL+1]; short litLengthNCount[MaxLL+1];
U32 repOffset[MAXREPOFFSET]; U32 repOffset[MAXREPOFFSET];
offsetCount_t bestRepOffset[ZSTD_REP_NUM+1]; offsetCount_t bestRepOffset[ZSTD_REP_NUM+1];
EStats_ress_t esr = { NULL, NULL, NULL }; EStats_ress_t esr = { NULL, NULL, NULL };
ZSTD_parameters params; ZSTD_parameters params;
U32 u, huffLog = 11, Offlog = OffFSELog, mlLog = MLFSELog, llLog = LLFSELog, total; U32 u, huffLog = 11, Offlog = OffFSELog, mlLog = MLFSELog, llLog = LLFSELog, total;
size_t pos = 0, errorCode; size_t pos = 0, errorCode;
size_t eSize = 0; size_t eSize = 0;
/* build dictionary */ /* build dictionary */
ZDICT_trainBuffer_legacy(dictList, dictListSize, ZDICT_trainBuffer_legacy(dictList, dictListSize,
samplesBuffer, samplesBuffSize, samplesBuffer, samplesBuffSize,
samplesSizes, nbSamples, samplesSizes, nbSamples,
minRep, notificationLevel); minRep, notificationLevel);
/* display best matches */ /* display best matches */
if (params.zParams.notificationLevel>= 3) { if (params.zParams.notificationLevel>= 3) {
U32 const nb = MIN(25, dictList[0].pos); unsigned const nb = MIN(25, dictList[0].pos);
U32 const dictContentSize = ZDICT_dictSize(dictList); unsigned const dictContentSize = ZDICT_dictSize(dictList);
U32 u; unsigned u;
DISPLAYLEVEL(3, "\n %u segments found, of total size %u \n", dictList[0].pos-1, dictContentSize); DISPLAYLEVEL(3, "\n %u segments found, of total size %u \n", (unsigned)dictList[0].pos-1, dictContentSize);
DISPLAYLEVEL(3, "list %u best segments \n", nb-1); DISPLAYLEVEL(3, "list %u best segments \n", nb-1);
for (u=1; u<nb; u++) { for (u=1; u<nb; u++) {
U32 const pos = dictList[u].pos; unsigned const pos = dictList[u].pos;
U32 const length = dictList[u].length; unsigned const length = dictList[u].length;
U32 const printedLength = MIN(40, length); U32 const printedLength = MIN(40, length);
if ((pos > samplesBuffSize) || ((pos + length) > samplesBuffSize)) { if ((pos > samplesBuffSize) || ((pos + length) > samplesBuffSize)) {
free(dictList); free(dictList);
return ERROR(GENERIC); /* should never happen */ return ERROR(GENERIC); /* should never happen */
} }
DISPLAYLEVEL(3, "%3u:%3u bytes at pos %8u, savings %7u bytes |", DISPLAYLEVEL(3, "%3u:%3u bytes at pos %8u, savings %7u bytes |",
u, length, pos, dictList[u].savings); u, length, pos, (unsigned)dictList[u].savings);
ZDICT_printHex((const char*)samplesBuffer+pos, printedLength); ZDICT_printHex((const char*)samplesBuffer+pos, printedLength);
DISPLAYLEVEL(3, "| \n"); DISPLAYLEVEL(3, "| \n");
} } } }
/* create dictionary */ /* create dictionary */
{ U32 dictContentSize = ZDICT_dictSize(dictList); { unsigned dictContentSize = ZDICT_dictSize(dictList);
if (dictContentSize < ZDICT_CONTENTSIZE_MIN) { free(dictList); return ERROR(dictionaryCreation_failed); } /* dictionary content too small */ if (dictContentSize < ZDICT_CONTENTSIZE_MIN) { free(dictList); return ERROR(dictionaryCreation_failed); } /* dictionary content too small */
if (dictContentSize < targetDictSize/4) { if (dictContentSize < targetDictSize/4) {
DISPLAYLEVEL(2, "! warning : selected content significantly smaller than requested (%u < %u) \n", dictContentSize, (U32)maxDictSize); DISPLAYLEVEL(2, "! warning : selected content significantly smaller than requested (%u < %u) \n", dictContentSize, (unsigned)maxDictSize);
if (samplesBuffSize < 10 * targetDictSize) if (samplesBuffSize < 10 * targetDictSize)
DISPLAYLEVEL(2, "! consider increasing the number of samples (total size : %u MB)\n", (U32)(samplesBuffSize>>20)); DISPLAYLEVEL(2, "! consider increasing the number of samples (total size : %u MB)\n", (unsigned)(samplesBuffSize>>20));
if (minRep > MINRATIO) { if (minRep > MINRATIO) {
DISPLAYLEVEL(2, "! consider increasing selectivity to produce larger dictionary (-s%u) \n", selectivity+1); DISPLAYLEVEL(2, "! consider increasing selectivity to produce larger dictionary (-s%u) \n", selectivity+1);
DISPLAYLEVEL(2, "! note : larger dictionaries are not necessarily better, test its efficiency on samples \n"); DISPLAYLEVEL(2, "! note : larger dictionaries are not necessarily better, test its efficiency on samples \n");
} }
} }
if ((dictContentSize > targetDictSize*3) && (nbSamples > 2*MINRATIO) && (selectivity>1)) { if ((dictContentSize > targetDictSize*3) && (nbSamples > 2*MINRATIO) && (selectivity>1)) {
U32 proposedSelectivity = selectivity-1; unsigned proposedSelectivity = selectivity-1;
while ((nbSamples >> proposedSelectivity) <= MINRATIO) { proposedSelectivity--; } while ((nbSamples >> proposedSelectivity) <= MINRATIO) { proposedSelectivity--; }
DISPLAYLEVEL(2, "! note : calculated dictionary significantly larger than requested (%u > %u) \n", dictContentSize, (U32)maxDictSize); DISPLAYLEVEL(2, "! note : calculated dictionary significantly larger than requested (%u > %u) \n", dictContentSize, (unsigned)maxDictSize);
DISPLAYLEVEL(2, "! consider increasing dictionary size, or produce denser dictionary (-s%u) \n", proposedSelectivity); DISPLAYLEVEL(2, "! consider increasing dictionary size, or produce denser dictionary (-s%u) \n", proposedSelectivity);
DISPLAYLEVEL(2, "! always test dictionary efficiency on real samples \n"); DISPLAYLEVEL(2, "! always test dictionary efficiency on real samples \n");
} }
/* limit dictionary size */ /* limit dictionary size */
{ U32 const max = dictList->pos; /* convention : nb of useful elts within dictList */ { U32 const max = dictList->pos; /* convention : nb of useful elts within dictList */
U32 currentSize = 0; U32 currentSize = 0;
U32 n; for (n=1; n<max; n++) { U32 n; for (n=1; n<max; n++) {

contrib/python-zstandard/zstd/zstd.h

Advanced experimental APIs should never be used with a dynamically-linked Advanced experimental APIs should never be used with a dynamically-linked
library. They are not "stable"; their definitions or signatures may change in library. They are not "stable"; their definitions or signatures may change in
the future. Only static linking is allowed. the future. Only static linking is allowed.
*******************************************************************************/ *******************************************************************************/
/*------ Version ------*/ /*------ Version ------*/
#define ZSTD_VERSION_MAJOR 1 #define ZSTD_VERSION_MAJOR 1
#define ZSTD_VERSION_MINOR 3 #define ZSTD_VERSION_MINOR 3
#define ZSTD_VERSION_RELEASE 6 #define ZSTD_VERSION_RELEASE 8
#define ZSTD_VERSION_NUMBER (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE) #define ZSTD_VERSION_NUMBER (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
ZSTDLIB_API unsigned ZSTD_versionNumber(void); /**< useful to check dll version */ ZSTDLIB_API unsigned ZSTD_versionNumber(void); /**< to check runtime library version */
#define ZSTD_LIB_VERSION ZSTD_VERSION_MAJOR.ZSTD_VERSION_MINOR.ZSTD_VERSION_RELEASE #define ZSTD_LIB_VERSION ZSTD_VERSION_MAJOR.ZSTD_VERSION_MINOR.ZSTD_VERSION_RELEASE
#define ZSTD_QUOTE(str) #str #define ZSTD_QUOTE(str) #str
#define ZSTD_EXPAND_AND_QUOTE(str) ZSTD_QUOTE(str) #define ZSTD_EXPAND_AND_QUOTE(str) ZSTD_QUOTE(str)
#define ZSTD_VERSION_STRING ZSTD_EXPAND_AND_QUOTE(ZSTD_LIB_VERSION) #define ZSTD_VERSION_STRING ZSTD_EXPAND_AND_QUOTE(ZSTD_LIB_VERSION)
ZSTDLIB_API const char* ZSTD_versionString(void); /* v1.3.0+ */ ZSTDLIB_API const char* ZSTD_versionString(void); /* requires v1.3.0+ */
/*************************************** /***************************************
* Default constant * Default constant
***************************************/ ***************************************/
#ifndef ZSTD_CLEVEL_DEFAULT #ifndef ZSTD_CLEVEL_DEFAULT
# define ZSTD_CLEVEL_DEFAULT 3 # define ZSTD_CLEVEL_DEFAULT 3
#endif #endif
* `compressedSize` : must be the _exact_ size of some number of compressed and/or skippable frames. * `compressedSize` : must be the _exact_ size of some number of compressed and/or skippable frames.
* `dstCapacity` is an upper bound of originalSize to regenerate. * `dstCapacity` is an upper bound of originalSize to regenerate.
* If user cannot imply a maximum upper bound, it's better to use streaming mode to decompress data. * If user cannot imply a maximum upper bound, it's better to use streaming mode to decompress data.
* @return : the number of bytes decompressed into `dst` (<= `dstCapacity`), * @return : the number of bytes decompressed into `dst` (<= `dstCapacity`),
* or an errorCode if it fails (which can be tested using ZSTD_isError()). */ * or an errorCode if it fails (which can be tested using ZSTD_isError()). */
ZSTDLIB_API size_t ZSTD_decompress( void* dst, size_t dstCapacity, ZSTDLIB_API size_t ZSTD_decompress( void* dst, size_t dstCapacity,
const void* src, size_t compressedSize); const void* src, size_t compressedSize);
/*! ZSTD_getFrameContentSize() : added in v1.3.0 /*! ZSTD_getFrameContentSize() : requires v1.3.0+
* `src` should point to the start of a ZSTD encoded frame. * `src` should point to the start of a ZSTD encoded frame.
* `srcSize` must be at least as large as the frame header. * `srcSize` must be at least as large as the frame header.
* hint : any size >= `ZSTD_frameHeaderSize_max` is large enough. * hint : any size >= `ZSTD_frameHeaderSize_max` is large enough.
* @return : - decompressed size of `src` frame content, if known * @return : - decompressed size of `src` frame content, if known
* - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined * - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined
* - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small) * - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small)
* note 1 : a 0 return value means the frame is valid but "empty". * note 1 : a 0 return value means the frame is valid but "empty".
* note 2 : decompressed size is an optional field, it may not be present, typically in streaming mode. * note 2 : decompressed size is an optional field, it may not be present, typically in streaming mode.
* it is recommended to allocate a context just once, and re-use it for each successive compression operation. * it is recommended to allocate a context just once, and re-use it for each successive compression operation.
* This will make workload friendlier for system's memory. * This will make workload friendlier for system's memory.
* Use one context per thread for parallel execution in multi-threaded environments. */ * Use one context per thread for parallel execution in multi-threaded environments. */
typedef struct ZSTD_CCtx_s ZSTD_CCtx; typedef struct ZSTD_CCtx_s ZSTD_CCtx;
ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx(void); ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx(void);
ZSTDLIB_API size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx); ZSTDLIB_API size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx);
/*! ZSTD_compressCCtx() : /*! ZSTD_compressCCtx() :
* Same as ZSTD_compress(), requires an allocated ZSTD_CCtx (see ZSTD_createCCtx()). */ * Same as ZSTD_compress(), using an explicit ZSTD_CCtx
ZSTDLIB_API size_t ZSTD_compressCCtx(ZSTD_CCtx* ctx, * The function will compress at requested compression level,
* ignoring any other parameter */
ZSTDLIB_API size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const void* src, size_t srcSize,
int compressionLevel); int compressionLevel);
/*= Decompression context /*= Decompression context
* When decompressing many times, * When decompressing many times,
* it is recommended to allocate a context only once, * it is recommended to allocate a context only once,
* and re-use it for each successive compression operation. * and re-use it for each successive compression operation.
* This will make workload friendlier for system's memory. * This will make workload friendlier for system's memory.
* Use one context per thread for parallel execution. */ * Use one context per thread for parallel execution. */
typedef struct ZSTD_DCtx_s ZSTD_DCtx; typedef struct ZSTD_DCtx_s ZSTD_DCtx;
ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx(void); ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx(void);
ZSTDLIB_API size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx); ZSTDLIB_API size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx);
/*! ZSTD_decompressDCtx() : /*! ZSTD_decompressDCtx() :
* Same as ZSTD_decompress(), requires an allocated ZSTD_DCtx (see ZSTD_createDCtx()) */ * Same as ZSTD_decompress(),
ZSTDLIB_API size_t ZSTD_decompressDCtx(ZSTD_DCtx* ctx, * requires an allocated ZSTD_DCtx.
* Compatible with sticky parameters.
*/
ZSTDLIB_API size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize); const void* src, size_t srcSize);
/************************** /**************************
* Simple dictionary API * Simple dictionary API
***************************/ ***************************/
/*! ZSTD_compress_usingDict() : /*! ZSTD_compress_usingDict() :
* Compression using a predefined Dictionary (see dictBuilder/zdict.h). * Compression at an explicit compression level using a Dictionary.
* A dictionary can be any arbitrary data segment (also called a prefix),
* or a buffer with specified information (see dictBuilder/zdict.h).
* Note : This function loads the dictionary, resulting in significant startup delay. * Note : This function loads the dictionary, resulting in significant startup delay.
* Note : When `dict == NULL || dictSize < 8` no dictionary is used. */ * It's intended for a dictionary used only once.
* Note 2 : When `dict == NULL || dictSize < 8` no dictionary is used. */
ZSTDLIB_API size_t ZSTD_compress_usingDict(ZSTD_CCtx* ctx, ZSTDLIB_API size_t ZSTD_compress_usingDict(ZSTD_CCtx* ctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const void* src, size_t srcSize,
const void* dict,size_t dictSize, const void* dict,size_t dictSize,
int compressionLevel); int compressionLevel);
/*! ZSTD_decompress_usingDict() : /*! ZSTD_decompress_usingDict() :
* Decompression using a predefined Dictionary (see dictBuilder/zdict.h). * Decompression using a known Dictionary.
* Dictionary must be identical to the one used during compression. * Dictionary must be identical to the one used during compression.
* Note : This function loads the dictionary, resulting in significant startup delay. * Note : This function loads the dictionary, resulting in significant startup delay.
* It's intended for a dictionary used only once.
* Note : When `dict == NULL || dictSize < 8` no dictionary is used. */ * Note : When `dict == NULL || dictSize < 8` no dictionary is used. */
ZSTDLIB_API size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx, ZSTDLIB_API size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const void* src, size_t srcSize,
const void* dict,size_t dictSize); const void* dict,size_t dictSize);
/********************************** /***********************************
* Bulk processing dictionary API * Bulk processing dictionary API
*********************************/ **********************************/
typedef struct ZSTD_CDict_s ZSTD_CDict; typedef struct ZSTD_CDict_s ZSTD_CDict;
/*! ZSTD_createCDict() : /*! ZSTD_createCDict() :
* When compressing multiple messages / blocks with the same dictionary, it's recommended to load it just once. * When compressing multiple messages / blocks using the same dictionary, it's recommended to load it only once.
* ZSTD_createCDict() will create a digested dictionary, ready to start future compression operations without startup delay. * ZSTD_createCDict() will create a digested dictionary, ready to start future compression operations without startup cost.
* ZSTD_CDict can be created once and shared by multiple threads concurrently, since its usage is read-only. * ZSTD_CDict can be created once and shared by multiple threads concurrently, since its usage is read-only.
* `dictBuffer` can be released after ZSTD_CDict creation, since its content is copied within CDict * `dictBuffer` can be released after ZSTD_CDict creation, because its content is copied within CDict.
* Note : A ZSTD_CDict can be created with an empty dictionary, but it is inefficient for small data. */ * Consider experimental function `ZSTD_createCDict_byReference()` if you prefer to not duplicate `dictBuffer` content.
* Note : A ZSTD_CDict can be created from an empty dictBuffer, but it is inefficient when used to compress small data. */
ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict(const void* dictBuffer, size_t dictSize, ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict(const void* dictBuffer, size_t dictSize,
int compressionLevel); int compressionLevel);
/*! ZSTD_freeCDict() : /*! ZSTD_freeCDict() :
* Function frees memory allocated by ZSTD_createCDict(). */ * Function frees memory allocated by ZSTD_createCDict(). */
ZSTDLIB_API size_t ZSTD_freeCDict(ZSTD_CDict* CDict); ZSTDLIB_API size_t ZSTD_freeCDict(ZSTD_CDict* CDict);
/*! ZSTD_compress_usingCDict() : /*! ZSTD_compress_usingCDict() :
* Compression using a digested Dictionary. * Compression using a digested Dictionary.
* Faster startup than ZSTD_compress_usingDict(), recommended when same dictionary is used multiple times. * Recommended when same dictionary is used multiple times.
* Note that compression level is decided during dictionary creation. * Note : compression level is _decided at dictionary creation time_,
* Frame parameters are hardcoded (dictID=yes, contentSize=yes, checksum=no) * and frame parameters are hardcoded (dictID=yes, contentSize=yes, checksum=no) */
* Note : ZSTD_compress_usingCDict() can be used with a ZSTD_CDict created from an empty dictionary.
* But it is inefficient for small data, and it is recommended to use ZSTD_compressCCtx(). */
ZSTDLIB_API size_t ZSTD_compress_usingCDict(ZSTD_CCtx* cctx, ZSTDLIB_API size_t ZSTD_compress_usingCDict(ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const void* src, size_t srcSize,
const ZSTD_CDict* cdict); const ZSTD_CDict* cdict);
typedef struct ZSTD_DDict_s ZSTD_DDict; typedef struct ZSTD_DDict_s ZSTD_DDict;
/*! ZSTD_createDDict() : /*! ZSTD_createDDict() :
* Create a digested dictionary, ready to start decompression operation without startup delay. * Create a digested dictionary, ready to start decompression operation without startup delay.
* dictBuffer can be released after DDict creation, as its content is copied inside DDict */ * dictBuffer can be released after DDict creation, as its content is copied inside DDict. */
ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict(const void* dictBuffer, size_t dictSize); ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict(const void* dictBuffer, size_t dictSize);
/*! ZSTD_freeDDict() : /*! ZSTD_freeDDict() :
* Function frees memory allocated with ZSTD_createDDict() */ * Function frees memory allocated with ZSTD_createDDict() */
ZSTDLIB_API size_t ZSTD_freeDDict(ZSTD_DDict* ddict); ZSTDLIB_API size_t ZSTD_freeDDict(ZSTD_DDict* ddict);
/*! ZSTD_decompress_usingDDict() : /*! ZSTD_decompress_usingDDict() :
* Decompression using a digested Dictionary. * Decompression using a digested Dictionary.
* Faster startup than ZSTD_decompress_usingDict(), recommended when same dictionary is used multiple times. */ * Recommended when same dictionary is used multiple times. */
ZSTDLIB_API size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx, ZSTDLIB_API size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize, const void* src, size_t srcSize,
const ZSTD_DDict* ddict); const ZSTD_DDict* ddict);
/**************************** /****************************
* Streaming * Streaming
/*-*********************************************************************** /*-***********************************************************************
* Streaming compression - HowTo * Streaming compression - HowTo
* *
* A ZSTD_CStream object is required to track streaming operation. * A ZSTD_CStream object is required to track streaming operation.
* Use ZSTD_createCStream() and ZSTD_freeCStream() to create/release resources. * Use ZSTD_createCStream() and ZSTD_freeCStream() to create/release resources.
* ZSTD_CStream objects can be reused multiple times on consecutive compression operations. * ZSTD_CStream objects can be reused multiple times on consecutive compression operations.
* It is recommended to re-use ZSTD_CStream in situations where many streaming operations will be achieved consecutively, * It is recommended to re-use ZSTD_CStream since it will play nicer with system's memory, by re-using already allocated memory.
* since it will play nicer with system's memory, by re-using already allocated memory. *
* Use one separate ZSTD_CStream per thread for parallel execution. * For parallel execution, use one separate ZSTD_CStream per thread.
* *
* Start a new compression by initializing ZSTD_CStream context. * note : since v1.3.0, ZSTD_CStream and ZSTD_CCtx are the same thing.
* Use ZSTD_initCStream() to start a new compression operation. *
* Use variants ZSTD_initCStream_usingDict() or ZSTD_initCStream_usingCDict() for streaming with dictionary (experimental section) * Parameters are sticky : when starting a new compression on the same context,
* it will re-use the same sticky parameters as previous compression session.
* When in doubt, it's recommended to fully initialize the context before usage.
* Use ZSTD_initCStream() to set the parameter to a selected compression level.
* Use advanced API (ZSTD_CCtx_setParameter(), etc.) to set more specific parameters.
* *
* Use ZSTD_compressStream() as many times as necessary to consume input stream. * Use ZSTD_compressStream() as many times as necessary to consume input stream.
* The function will automatically update both `pos` fields within `input` and `output`. * The function will automatically update both `pos` fields within `input` and `output`.
* Note that the function may not consume the entire input, * Note that the function may not consume the entire input,
* for example, because the output buffer is already full, * for example, because the output buffer is already full,
* in which case `input.pos < input.size`. * in which case `input.pos < input.size`.
* The caller must check if input has been entirely consumed. * The caller must check if input has been entirely consumed.
* If not, the caller must make some room to receive more compressed data, * If not, the caller must make some room to receive more compressed data,
* typically by emptying output buffer, or allocating a new output buffer,
* and then present again remaining input data. * and then present again remaining input data.
* @return : a size hint, preferred nb of bytes to use as input for next function call * @return : a size hint, preferred nb of bytes to use as input for next function call
* or an error code, which can be tested using ZSTD_isError(). * or an error code, which can be tested using ZSTD_isError().
* Note 1 : it's just a hint, to help latency a little, any other value will work fine. * Note 1 : it's just a hint, to help latency a little, any value will work fine.
* Note 2 : size hint is guaranteed to be <= ZSTD_CStreamInSize() * Note 2 : size hint is guaranteed to be <= ZSTD_CStreamInSize()
* *
* At any moment, it's possible to flush whatever data might remain stuck within internal buffer, * At any moment, it's possible to flush whatever data might remain stuck within internal buffer,
* using ZSTD_flushStream(). `output->pos` will be updated. * using ZSTD_flushStream(). `output->pos` will be updated.
* Note that, if `output->size` is too small, a single invocation of ZSTD_flushStream() might not be enough (return code > 0). * Note that, if `output->size` is too small, a single invocation of ZSTD_flushStream() might not be enough (return code > 0).
* In which case, make some room to receive more compressed data, and call again ZSTD_flushStream(). * In which case, make some room to receive more compressed data, and call again ZSTD_flushStream().
* @return : 0 if internal buffers are entirely flushed, * @return : 0 if internal buffers are entirely flushed,
* >0 if some data still present within internal buffer (the value is minimal estimation of remaining size), * >0 if some data still present within internal buffer (the value is minimal estimation of remaining size),
* or an error code, which can be tested using ZSTD_isError(). * or an error code, which can be tested using ZSTD_isError().
/*-*************************************************************************** /*-***************************************************************************
* Streaming decompression - HowTo * Streaming decompression - HowTo
* *
* A ZSTD_DStream object is required to track streaming operations. * A ZSTD_DStream object is required to track streaming operations.
* Use ZSTD_createDStream() and ZSTD_freeDStream() to create/release resources. * Use ZSTD_createDStream() and ZSTD_freeDStream() to create/release resources.
* ZSTD_DStream objects can be re-used multiple times. * ZSTD_DStream objects can be re-used multiple times.
* *
* Use ZSTD_initDStream() to start a new decompression operation, * Use ZSTD_initDStream() to start a new decompression operation.
* or ZSTD_initDStream_usingDict() if decompression requires a dictionary.
* @return : recommended first input size * @return : recommended first input size
* Alternatively, use advanced API to set specific properties.
* *
* Use ZSTD_decompressStream() repetitively to consume your input. * Use ZSTD_decompressStream() repetitively to consume your input.
* The function will update both `pos` fields. * The function will update both `pos` fields.
* If `input.pos < input.size`, some input has not been consumed. * If `input.pos < input.size`, some input has not been consumed.
* It's up to the caller to present again remaining data. * It's up to the caller to present again remaining data.
* The function tries to flush all data decoded immediately, respecting output buffer size.
* If `output.pos < output.size`, decoder has flushed everything it could. * If `output.pos < output.size`, decoder has flushed everything it could.
* But if `output.pos == output.size`, there might be some data left within internal buffers.,
* In which case, call ZSTD_decompressStream() again to flush whatever remains in the buffer.
* Note : with no additional input provided, amount of data flushed is necessarily <= ZSTD_BLOCKSIZE_MAX.
* @return : 0 when a frame is completely decoded and fully flushed, * @return : 0 when a frame is completely decoded and fully flushed,
* an error code, which can be tested using ZSTD_isError(), * or an error code, which can be tested using ZSTD_isError(),
* any other value > 0, which means there is still some decoding to do to complete current frame. * or any other value > 0, which means there is still some decoding or flushing to do to complete current frame :
* The return value is a suggested next input size (a hint to improve latency) that will never load more than the current frame. * the return value is a suggested next input size (just a hint for better latency)
* that will never request more than the remaining frame size.
* *******************************************************************************/ * *******************************************************************************/
typedef ZSTD_DCtx ZSTD_DStream; /**< DCtx and DStream are now effectively same object (>= v1.3.0) */ typedef ZSTD_DCtx ZSTD_DStream; /**< DCtx and DStream are now effectively same object (>= v1.3.0) */
/* For compatibility with versions <= v1.2.0, continue to consider them separated. */ /* For compatibility with versions <= v1.2.0, prefer differentiating them. */
/*===== ZSTD_DStream management functions =====*/ /*===== ZSTD_DStream management functions =====*/
ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream(void); ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream(void);
ZSTDLIB_API size_t ZSTD_freeDStream(ZSTD_DStream* zds); ZSTDLIB_API size_t ZSTD_freeDStream(ZSTD_DStream* zds);
/*===== Streaming decompression functions =====*/ /*===== Streaming decompression functions =====*/
ZSTDLIB_API size_t ZSTD_initDStream(ZSTD_DStream* zds); ZSTDLIB_API size_t ZSTD_initDStream(ZSTD_DStream* zds);
ZSTDLIB_API size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input); ZSTDLIB_API size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
ZSTDLIB_API size_t ZSTD_DStreamInSize(void); /*!< recommended size for input buffer */ ZSTDLIB_API size_t ZSTD_DStreamInSize(void); /*!< recommended size for input buffer */
ZSTDLIB_API size_t ZSTD_DStreamOutSize(void); /*!< recommended size for output buffer. Guarantee to successfully flush at least one complete block in all circumstances. */ ZSTDLIB_API size_t ZSTD_DStreamOutSize(void); /*!< recommended size for output buffer. Guarantee to successfully flush at least one complete block in all circumstances. */
#endif /* ZSTD_H_235446 */ #endif /* ZSTD_H_235446 */
#if defined(ZSTD_STATIC_LINKING_ONLY) && !defined(ZSTD_H_ZSTD_STATIC_LINKING_ONLY)
#define ZSTD_H_ZSTD_STATIC_LINKING_ONLY
/**************************************************************************************** /****************************************************************************************
* ADVANCED AND EXPERIMENTAL FUNCTIONS * ADVANCED AND EXPERIMENTAL FUNCTIONS
**************************************************************************************** ****************************************************************************************
* The definitions in this section are considered experimental. * The definitions in the following section are considered experimental.
* They should never be used with a dynamic library, as prototypes may change in the future.
* They are provided for advanced scenarios. * They are provided for advanced scenarios.
* They should never be used with a dynamic library, as prototypes may change in the future.
* Use them only in association with static linking. * Use them only in association with static linking.
* ***************************************************************************************/ * ***************************************************************************************/
ZSTDLIB_API int ZSTD_minCLevel(void); /*!< minimum negative compression level allowed */ #if defined(ZSTD_STATIC_LINKING_ONLY) && !defined(ZSTD_H_ZSTD_STATIC_LINKING_ONLY)
#define ZSTD_H_ZSTD_STATIC_LINKING_ONLY
/* --- Constants ---*/
#define ZSTD_MAGICNUMBER 0xFD2FB528 /* v0.8+ */
#define ZSTD_MAGIC_DICTIONARY 0xEC30A437 /* v0.7+ */
#define ZSTD_MAGIC_SKIPPABLE_START 0x184D2A50U
#define ZSTD_BLOCKSIZELOG_MAX 17
#define ZSTD_BLOCKSIZE_MAX (1<<ZSTD_BLOCKSIZELOG_MAX) /* define, for static allocation */
#define ZSTD_WINDOWLOG_MAX_32 30
#define ZSTD_WINDOWLOG_MAX_64 31
#define ZSTD_WINDOWLOG_MAX ((unsigned)(sizeof(size_t) == 4 ? ZSTD_WINDOWLOG_MAX_32 : ZSTD_WINDOWLOG_MAX_64))
#define ZSTD_WINDOWLOG_MIN 10
#define ZSTD_HASHLOG_MAX ((ZSTD_WINDOWLOG_MAX < 30) ? ZSTD_WINDOWLOG_MAX : 30)
#define ZSTD_HASHLOG_MIN 6
#define ZSTD_CHAINLOG_MAX_32 29
#define ZSTD_CHAINLOG_MAX_64 30
#define ZSTD_CHAINLOG_MAX ((unsigned)(sizeof(size_t) == 4 ? ZSTD_CHAINLOG_MAX_32 : ZSTD_CHAINLOG_MAX_64))
#define ZSTD_CHAINLOG_MIN ZSTD_HASHLOG_MIN
#define ZSTD_HASHLOG3_MAX 17
#define ZSTD_SEARCHLOG_MAX (ZSTD_WINDOWLOG_MAX-1)
#define ZSTD_SEARCHLOG_MIN 1
#define ZSTD_SEARCHLENGTH_MAX 7 /* only for ZSTD_fast, other strategies are limited to 6 */
#define ZSTD_SEARCHLENGTH_MIN 3 /* only for ZSTD_btopt, other strategies are limited to 4 */
#define ZSTD_TARGETLENGTH_MAX ZSTD_BLOCKSIZE_MAX
#define ZSTD_TARGETLENGTH_MIN 0 /* note : comparing this constant to an unsigned results in a tautological test */
#define ZSTD_LDM_MINMATCH_MAX 4096
#define ZSTD_LDM_MINMATCH_MIN 4
#define ZSTD_LDM_BUCKETSIZELOG_MAX 8
#define ZSTD_FRAMEHEADERSIZE_PREFIX 5 /* minimum input size to know frame header size */
#define ZSTD_FRAMEHEADERSIZE_MIN 6
#define ZSTD_FRAMEHEADERSIZE_MAX 18 /* for static allocation */
static const size_t ZSTD_frameHeaderSize_prefix = ZSTD_FRAMEHEADERSIZE_PREFIX;
static const size_t ZSTD_frameHeaderSize_min = ZSTD_FRAMEHEADERSIZE_MIN;
static const size_t ZSTD_frameHeaderSize_max = ZSTD_FRAMEHEADERSIZE_MAX;
static const size_t ZSTD_skippableHeaderSize = 8; /* magic number + skippable frame length */
/* --- Advanced types --- */ /****************************************************************************************
typedef enum { ZSTD_fast=1, ZSTD_dfast, ZSTD_greedy, ZSTD_lazy, ZSTD_lazy2, * Candidate API for promotion to stable status
ZSTD_btlazy2, ZSTD_btopt, ZSTD_btultra } ZSTD_strategy; /* from faster to stronger */ ****************************************************************************************
* The following symbols and constants form the "staging area" :
* they are considered to join "stable API" by v1.4.0.
* The proposal is written so that it can be made stable "as is",
* though it's still possible to suggest improvements.
* Staging is in fact last chance for changes,
* the API is locked once reaching "stable" status.
* ***************************************************************************************/
typedef struct {
unsigned windowLog; /**< largest match distance : larger == more compression, more memory needed during decompression */
unsigned chainLog; /**< fully searched segment : larger == more compression, slower, more memory (useless for fast) */
unsigned hashLog; /**< dispatch table : larger == faster, more memory */
unsigned searchLog; /**< nb of searches : larger == more compression, slower */
unsigned searchLength; /**< match length searched : larger == faster decompression, sometimes less compression */
unsigned targetLength; /**< acceptable match size for optimal parser (only) : larger == more compression, slower */
ZSTD_strategy strategy;
} ZSTD_compressionParameters;
typedef struct { /* === Constants === */
unsigned contentSizeFlag; /**< 1: content size will be in frame header (when known) */
unsigned checksumFlag; /**< 1: generate a 32-bits checksum at end of frame, for error detection */
unsigned noDictIDFlag; /**< 1: no dictID will be saved into frame header (if dictionary compression) */
} ZSTD_frameParameters;
typedef struct { /* all magic numbers are supposed read/written to/from files/memory using little-endian convention */
ZSTD_compressionParameters cParams; #define ZSTD_MAGICNUMBER 0xFD2FB528 /* valid since v0.8.0 */
ZSTD_frameParameters fParams; #define ZSTD_MAGIC_DICTIONARY 0xEC30A437 /* valid since v0.7.0 */
} ZSTD_parameters; #define ZSTD_MAGIC_SKIPPABLE_START 0x184D2A50 /* all 16 values, from 0x184D2A50 to 0x184D2A5F, signal the beginning of a skippable frame */
#define ZSTD_MAGIC_SKIPPABLE_MASK 0xFFFFFFF0
typedef struct ZSTD_CCtx_params_s ZSTD_CCtx_params; #define ZSTD_BLOCKSIZELOG_MAX 17
#define ZSTD_BLOCKSIZE_MAX (1<<ZSTD_BLOCKSIZELOG_MAX)
typedef enum {
ZSTD_dct_auto=0, /* dictionary is "full" when starting with ZSTD_MAGIC_DICTIONARY, otherwise it is "rawContent" */
ZSTD_dct_rawContent, /* ensures dictionary is always loaded as rawContent, even if it starts with ZSTD_MAGIC_DICTIONARY */
ZSTD_dct_fullDict /* refuses to load a dictionary if it does not respect Zstandard's specification */
} ZSTD_dictContentType_e;
typedef enum { /* === query limits === */
ZSTD_dlm_byCopy = 0, /**< Copy dictionary content internally */
ZSTD_dlm_byRef, /**< Reference dictionary content -- the dictionary buffer must outlive its users. */
} ZSTD_dictLoadMethod_e;
ZSTDLIB_API int ZSTD_minCLevel(void); /*!< minimum negative compression level allowed */
/*************************************** /* === frame size === */
* Frame size functions
***************************************/
/*! ZSTD_findFrameCompressedSize() : /*! ZSTD_findFrameCompressedSize() :
* `src` should point to the start of a ZSTD encoded frame or skippable frame * `src` should point to the start of a ZSTD frame or skippable frame.
* `srcSize` must be >= first frame size * `srcSize` must be >= first frame size
* @return : the compressed size of the first frame starting at `src`, * @return : the compressed size of the first frame starting at `src`,
* suitable to pass to `ZSTD_decompress` or similar, * suitable to pass as `srcSize` to `ZSTD_decompress` or similar,
* or an error code if input is invalid */ * or an error code if input is invalid */
ZSTDLIB_API size_t ZSTD_findFrameCompressedSize(const void* src, size_t srcSize); ZSTDLIB_API size_t ZSTD_findFrameCompressedSize(const void* src, size_t srcSize);
/*! ZSTD_findDecompressedSize() :
* `src` should point the start of a series of ZSTD encoded and/or skippable frames
* `srcSize` must be the _exact_ size of this series
* (i.e. there should be a frame boundary exactly at `srcSize` bytes after `src`)
* @return : - decompressed size of all data in all successive frames
* - if the decompressed size cannot be determined: ZSTD_CONTENTSIZE_UNKNOWN
* - if an error occurred: ZSTD_CONTENTSIZE_ERROR
*
* note 1 : decompressed size is an optional field, that may not be present, especially in streaming mode.
* When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size.
* In which case, it's necessary to use streaming mode to decompress data.
* note 2 : decompressed size is always present when compression is done with ZSTD_compress()
* note 3 : decompressed size can be very large (64-bits value),
* potentially larger than what local system can handle as a single memory segment.
* In which case, it's necessary to use streaming mode to decompress data.
* note 4 : If source is untrusted, decompressed size could be wrong or intentionally modified.
* Always ensure result fits within application's authorized limits.
* Each application can set its own limits.
* note 5 : ZSTD_findDecompressedSize handles multiple frames, and so it must traverse the input to
* read each contained frame header. This is fast as most of the data is skipped,
* however it does mean that all frame data must be present and valid. */
ZSTDLIB_API unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize);
/*! ZSTD_frameHeaderSize() :
* srcSize must be >= ZSTD_frameHeaderSize_prefix.
* @return : size of the Frame Header,
* or an error code (if srcSize is too small) */
ZSTDLIB_API size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize);
/* === Memory management === */
/***************************************
* Memory management
***************************************/
/*! ZSTD_sizeof_*() : /*! ZSTD_sizeof_*() :
* These functions give the current memory usage of selected object. * These functions give the _current_ memory usage of selected object.
* Object memory usage can evolve when re-used. */ * Note that object memory usage can evolve (increase or decrease) over time. */
ZSTDLIB_API size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx); ZSTDLIB_API size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx);
ZSTDLIB_API size_t ZSTD_sizeof_DCtx(const ZSTD_DCtx* dctx); ZSTDLIB_API size_t ZSTD_sizeof_DCtx(const ZSTD_DCtx* dctx);
ZSTDLIB_API size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs); ZSTDLIB_API size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs);
ZSTDLIB_API size_t ZSTD_sizeof_DStream(const ZSTD_DStream* zds); ZSTDLIB_API size_t ZSTD_sizeof_DStream(const ZSTD_DStream* zds);
ZSTDLIB_API size_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict); ZSTDLIB_API size_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict);
ZSTDLIB_API size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict); ZSTDLIB_API size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict);
/*! ZSTD_estimate*() :
* These functions make it possible to estimate memory usage
* of a future {D,C}Ctx, before its creation.
* ZSTD_estimateCCtxSize() will provide a budget large enough for any compression level up to selected one.
* It will also consider src size to be arbitrarily "large", which is worst case.
* If srcSize is known to always be small, ZSTD_estimateCCtxSize_usingCParams() can provide a tighter estimation.
* ZSTD_estimateCCtxSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel.
* ZSTD_estimateCCtxSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParam_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_p_nbWorkers is >= 1.
* Note : CCtx size estimation is only correct for single-threaded compression. */
ZSTDLIB_API size_t ZSTD_estimateCCtxSize(int compressionLevel);
ZSTDLIB_API size_t ZSTD_estimateCCtxSize_usingCParams(ZSTD_compressionParameters cParams);
ZSTDLIB_API size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params);
ZSTDLIB_API size_t ZSTD_estimateDCtxSize(void);
/*! ZSTD_estimateCStreamSize() : /***************************************
* ZSTD_estimateCStreamSize() will provide a budget large enough for any compression level up to selected one. * Advanced compression API
* It will also consider src size to be arbitrarily "large", which is worst case. ***************************************/
* If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation.
* ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel.
* ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParam_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_p_nbWorkers is >= 1.
* Note : CStream size estimation is only correct for single-threaded compression.
* ZSTD_DStream memory budget depends on window Size.
* This information can be passed manually, using ZSTD_estimateDStreamSize,
* or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame();
* Note : if streaming is init with function ZSTD_init?Stream_usingDict(),
* an internal ?Dict will be created, which additional size is not estimated here.
* In this case, get total size by adding ZSTD_estimate?DictSize */
ZSTDLIB_API size_t ZSTD_estimateCStreamSize(int compressionLevel);
ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams);
ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params);
ZSTDLIB_API size_t ZSTD_estimateDStreamSize(size_t windowSize);
ZSTDLIB_API size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize);
/*! ZSTD_estimate?DictSize() : /* API design :
* ZSTD_estimateCDictSize() will bet that src size is relatively "small", and content is copied, like ZSTD_createCDict(). * Parameters are pushed one by one into an existing context,
* ZSTD_estimateCDictSize_advanced() makes it possible to control compression parameters precisely, like ZSTD_createCDict_advanced(). * using ZSTD_CCtx_set*() functions.
* Note : dictionaries created by reference (`ZSTD_dlm_byRef`) are logically smaller. * Pushed parameters are sticky : they are valid for next compressed frame, and any subsequent frame.
* "sticky" parameters are applicable to `ZSTD_compress2()` and `ZSTD_compressStream*()` !
* They do not apply to "simple" one-shot variants such as ZSTD_compressCCtx()
*
* It's possible to reset all parameters to "default" using ZSTD_CCtx_reset().
*
* This API supercedes all other "advanced" API entry points in the experimental section.
* In the future, we expect to remove from experimental API entry points which are redundant with this API.
*/ */
ZSTDLIB_API size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel);
ZSTDLIB_API size_t ZSTD_estimateCDictSize_advanced(size_t dictSize, ZSTD_compressionParameters cParams, ZSTD_dictLoadMethod_e dictLoadMethod);
ZSTDLIB_API size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod);
/*! ZSTD_initStatic*() :
* Initialize an object using a pre-allocated fixed-size buffer.
* workspace: The memory area to emplace the object into.
* Provided pointer *must be 8-bytes aligned*.
* Buffer must outlive object.
* workspaceSize: Use ZSTD_estimate*Size() to determine
* how large workspace must be to support target scenario.
* @return : pointer to object (same address as workspace, just different type),
* or NULL if error (size too small, incorrect alignment, etc.)
* Note : zstd will never resize nor malloc() when using a static buffer.
* If the object requires more memory than available,
* zstd will just error out (typically ZSTD_error_memory_allocation).
* Note 2 : there is no corresponding "free" function.
* Since workspace is allocated externally, it must be freed externally too.
* Note 3 : cParams : use ZSTD_getCParams() to convert a compression level
* into its associated cParams.
* Limitation 1 : currently not compatible with internal dictionary creation, triggered by
* ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict().
* Limitation 2 : static cctx currently not compatible with multi-threading.
* Limitation 3 : static dctx is incompatible with legacy support.
*/
ZSTDLIB_API ZSTD_CCtx* ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize);
ZSTDLIB_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize); /**< same as ZSTD_initStaticCCtx() */
ZSTDLIB_API ZSTD_DCtx* ZSTD_initStaticDCtx(void* workspace, size_t workspaceSize); /* Compression strategies, listed from fastest to strongest */
ZSTDLIB_API ZSTD_DStream* ZSTD_initStaticDStream(void* workspace, size_t workspaceSize); /**< same as ZSTD_initStaticDCtx() */ typedef enum { ZSTD_fast=1,
ZSTD_dfast=2,
ZSTD_greedy=3,
ZSTD_lazy=4,
ZSTD_lazy2=5,
ZSTD_btlazy2=6,
ZSTD_btopt=7,
ZSTD_btultra=8,
ZSTD_btultra2=9
/* note : new strategies _might_ be added in the future.
Only the order (from fast to strong) is guaranteed */
} ZSTD_strategy;
ZSTDLIB_API const ZSTD_CDict* ZSTD_initStaticCDict(
void* workspace, size_t workspaceSize,
const void* dict, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType,
ZSTD_compressionParameters cParams);
ZSTDLIB_API const ZSTD_DDict* ZSTD_initStaticDDict( typedef enum {
void* workspace, size_t workspaceSize,
const void* dict, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType);
/*! Custom memory allocation : /* compression parameters */
* These prototypes make it possible to pass your own allocation/free functions. ZSTD_c_compressionLevel=100, /* Update all compression parameters according to pre-defined cLevel table
* ZSTD_customMem is provided at creation time, using ZSTD_create*_advanced() variants listed below. * Default level is ZSTD_CLEVEL_DEFAULT==3.
* All allocation/free operations will be completed using these custom variants instead of regular <stdlib.h> ones. * Special: value 0 means default, which is controlled by ZSTD_CLEVEL_DEFAULT.
*/ * Note 1 : it's possible to pass a negative compression level.
typedef void* (*ZSTD_allocFunction) (void* opaque, size_t size); * Note 2 : setting a level sets all default values of other compression parameters */
typedef void (*ZSTD_freeFunction) (void* opaque, void* address); ZSTD_c_windowLog=101, /* Maximum allowed back-reference distance, expressed as power of 2.
typedef struct { ZSTD_allocFunction customAlloc; ZSTD_freeFunction customFree; void* opaque; } ZSTD_customMem; * Must be clamped between ZSTD_WINDOWLOG_MIN and ZSTD_WINDOWLOG_MAX.
static ZSTD_customMem const ZSTD_defaultCMem = { NULL, NULL, NULL }; /**< this constant defers to stdlib's functions */ * Special: value 0 means "use default windowLog".
* Note: Using a windowLog greater than ZSTD_WINDOWLOG_LIMIT_DEFAULT
* requires explicitly allowing such window size at decompression stage if using streaming. */
ZSTD_c_hashLog=102, /* Size of the initial probe table, as a power of 2.
* Resulting memory usage is (1 << (hashLog+2)).
* Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX.
* Larger tables improve compression ratio of strategies <= dFast,
* and improve speed of strategies > dFast.
* Special: value 0 means "use default hashLog". */
ZSTD_c_chainLog=103, /* Size of the multi-probe search table, as a power of 2.
* Resulting memory usage is (1 << (chainLog+2)).
* Must be clamped between ZSTD_CHAINLOG_MIN and ZSTD_CHAINLOG_MAX.
* Larger tables result in better and slower compression.
* This parameter is useless when using "fast" strategy.
* It's still useful when using "dfast" strategy,
* in which case it defines a secondary probe table.
* Special: value 0 means "use default chainLog". */
ZSTD_c_searchLog=104, /* Number of search attempts, as a power of 2.
* More attempts result in better and slower compression.
* This parameter is useless when using "fast" and "dFast" strategies.
* Special: value 0 means "use default searchLog". */
ZSTD_c_minMatch=105, /* Minimum size of searched matches.
* Note that Zstandard can still find matches of smaller size,
* it just tweaks its search algorithm to look for this size and larger.
* Larger values increase compression and decompression speed, but decrease ratio.
* Must be clamped between ZSTD_MINMATCH_MIN and ZSTD_MINMATCH_MAX.
* Note that currently, for all strategies < btopt, effective minimum is 4.
* , for all strategies > fast, effective maximum is 6.
* Special: value 0 means "use default minMatchLength". */
ZSTD_c_targetLength=106, /* Impact of this field depends on strategy.
* For strategies btopt, btultra & btultra2:
* Length of Match considered "good enough" to stop search.
* Larger values make compression stronger, and slower.
* For strategy fast:
* Distance between match sampling.
* Larger values make compression faster, and weaker.
* Special: value 0 means "use default targetLength". */
ZSTD_c_strategy=107, /* See ZSTD_strategy enum definition.
* The higher the value of selected strategy, the more complex it is,
* resulting in stronger and slower compression.
* Special: value 0 means "use default strategy". */
ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem); /* LDM mode parameters */
ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem); ZSTD_c_enableLongDistanceMatching=160, /* Enable long distance matching.
ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem); * This parameter is designed to improve compression ratio
ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem); * for large inputs, by finding large matches at long distance.
* It increases memory usage and window size.
* Note: enabling this parameter increases default ZSTD_c_windowLog to 128 MB
* except when expressly set to a different value. */
ZSTD_c_ldmHashLog=161, /* Size of the table for long distance matching, as a power of 2.
* Larger values increase memory usage and compression ratio,
* but decrease compression speed.
* Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX
* default: windowlog - 7.
* Special: value 0 means "automatically determine hashlog". */
ZSTD_c_ldmMinMatch=162, /* Minimum match size for long distance matcher.
* Larger/too small values usually decrease compression ratio.
* Must be clamped between ZSTD_LDM_MINMATCH_MIN and ZSTD_LDM_MINMATCH_MAX.
* Special: value 0 means "use default value" (default: 64). */
ZSTD_c_ldmBucketSizeLog=163, /* Log size of each bucket in the LDM hash table for collision resolution.
* Larger values improve collision resolution but decrease compression speed.
* The maximum value is ZSTD_LDM_BUCKETSIZELOG_MAX.
* Special: value 0 means "use default value" (default: 3). */
ZSTD_c_ldmHashRateLog=164, /* Frequency of inserting/looking up entries into the LDM hash table.
* Must be clamped between 0 and (ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN).
* Default is MAX(0, (windowLog - ldmHashLog)), optimizing hash table usage.
* Larger values improve compression speed.
* Deviating far from default value will likely result in a compression ratio decrease.
* Special: value 0 means "automatically determine hashRateLog". */
ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict_advanced(const void* dict, size_t dictSize, /* frame parameters */
ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_c_contentSizeFlag=200, /* Content size will be written into frame header _whenever known_ (default:1)
ZSTD_dictContentType_e dictContentType, * Content size must be known at the beginning of compression.
ZSTD_compressionParameters cParams, * This is automatically the case when using ZSTD_compress2(),
ZSTD_customMem customMem); * For streaming variants, content size must be provided with ZSTD_CCtx_setPledgedSrcSize() */
ZSTD_c_checksumFlag=201, /* A 32-bits checksum of content is written at end of frame (default:0) */
ZSTD_c_dictIDFlag=202, /* When applicable, dictionary's ID is written into frame header (default:1) */
ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict_advanced(const void* dict, size_t dictSize, /* multi-threading parameters */
ZSTD_dictLoadMethod_e dictLoadMethod, /* These parameters are only useful if multi-threading is enabled (compiled with build macro ZSTD_MULTITHREAD).
ZSTD_dictContentType_e dictContentType, * They return an error otherwise. */
ZSTD_customMem customMem); ZSTD_c_nbWorkers=400, /* Select how many threads will be spawned to compress in parallel.
* When nbWorkers >= 1, triggers asynchronous mode when used with ZSTD_compressStream*() :
* ZSTD_compressStream*() consumes input and flush output if possible, but immediately gives back control to caller,
* while compression work is performed in parallel, within worker threads.
* (note : a strong exception to this rule is when first invocation of ZSTD_compressStream2() sets ZSTD_e_end :
* in which case, ZSTD_compressStream2() delegates to ZSTD_compress2(), which is always a blocking call).
* More workers improve speed, but also increase memory usage.
* Default value is `0`, aka "single-threaded mode" : no worker is spawned, compression is performed inside Caller's thread, all invocations are blocking */
ZSTD_c_jobSize=401, /* Size of a compression job. This value is enforced only when nbWorkers >= 1.
* Each compression job is completed in parallel, so this value can indirectly impact the nb of active threads.
* 0 means default, which is dynamically determined based on compression parameters.
* Job size must be a minimum of overlap size, or 1 MB, whichever is largest.
* The minimum size is automatically and transparently enforced */
ZSTD_c_overlapLog=402, /* Control the overlap size, as a fraction of window size.
* The overlap size is an amount of data reloaded from previous job at the beginning of a new job.
* It helps preserve compression ratio, while each job is compressed in parallel.
* This value is enforced only when nbWorkers >= 1.
* Larger values increase compression ratio, but decrease speed.
* Possible values range from 0 to 9 :
* - 0 means "default" : value will be determined by the library, depending on strategy
* - 1 means "no overlap"
* - 9 means "full overlap", using a full window size.
* Each intermediate rank increases/decreases load size by a factor 2 :
* 9: full window; 8: w/2; 7: w/4; 6: w/8; 5:w/16; 4: w/32; 3:w/64; 2:w/128; 1:no overlap; 0:default
* default value varies between 6 and 9, depending on strategy */
/* note : additional experimental parameters are also available
* within the experimental section of the API.
* At the time of this writing, they include :
* ZSTD_c_rsyncable
* ZSTD_c_format
* ZSTD_c_forceMaxWindow
* ZSTD_c_forceAttachDict
* Because they are not stable, it's necessary to define ZSTD_STATIC_LINKING_ONLY to access them.
* note : never ever use experimentalParam? names directly;
* also, the enums values themselves are unstable and can still change.
*/
ZSTD_c_experimentalParam1=500,
ZSTD_c_experimentalParam2=10,
ZSTD_c_experimentalParam3=1000,
ZSTD_c_experimentalParam4=1001
} ZSTD_cParameter;
typedef struct {
size_t error;
int lowerBound;
int upperBound;
} ZSTD_bounds;
/*! ZSTD_cParam_getBounds() :
* All parameters must belong to an interval with lower and upper bounds,
* otherwise they will either trigger an error or be automatically clamped.
* @return : a structure, ZSTD_bounds, which contains
* - an error status field, which must be tested using ZSTD_isError()
* - lower and upper bounds, both inclusive
*/
ZSTDLIB_API ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter cParam);
/*************************************** /*! ZSTD_CCtx_setParameter() :
* Advanced compression functions * Set one compression parameter, selected by enum ZSTD_cParameter.
***************************************/ * All parameters have valid bounds. Bounds can be queried using ZSTD_cParam_getBounds().
* Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter).
/*! ZSTD_createCDict_byReference() : * Setting a parameter is generally only possible during frame initialization (before starting compression).
* Create a digested dictionary for compression * Exception : when using multi-threading mode (nbWorkers >= 1),
* Dictionary content is simply referenced, and therefore stays in dictBuffer. * the following parameters can be updated _during_ compression (within same frame):
* It is important that dictBuffer outlives CDict, it must remain read accessible throughout the lifetime of CDict */ * => compressionLevel, hashLog, chainLog, searchLog, minMatch, targetLength and strategy.
ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict_byReference(const void* dictBuffer, size_t dictSize, int compressionLevel); * new parameters will be active for next job only (after a flush()).
* @return : an error code (which can be tested using ZSTD_isError()).
*/
ZSTDLIB_API size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value);
/*! ZSTD_getCParams() : /*! ZSTD_CCtx_setPledgedSrcSize() :
* @return ZSTD_compressionParameters structure for a selected compression level and estimated srcSize. * Total input data size to be compressed as a single frame.
* `estimatedSrcSize` value is optional, select 0 if not known */ * Value will be written in frame header, unless if explicitly forbidden using ZSTD_c_contentSizeFlag.
ZSTDLIB_API ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize); * This value will also be controlled at end of frame, and trigger an error if not respected.
* @result : 0, or an error code (which can be tested with ZSTD_isError()).
* Note 1 : pledgedSrcSize==0 actually means zero, aka an empty frame.
* In order to mean "unknown content size", pass constant ZSTD_CONTENTSIZE_UNKNOWN.
* ZSTD_CONTENTSIZE_UNKNOWN is default value for any new frame.
* Note 2 : pledgedSrcSize is only valid once, for the next frame.
* It's discarded at the end of the frame, and replaced by ZSTD_CONTENTSIZE_UNKNOWN.
* Note 3 : Whenever all input data is provided and consumed in a single round,
* for example with ZSTD_compress2(),
* or invoking immediately ZSTD_compressStream2(,,,ZSTD_e_end),
* this value is automatically overriden by srcSize instead.
*/
ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize);
/*! ZSTD_getParams() : /*! ZSTD_CCtx_loadDictionary() :
* same as ZSTD_getCParams(), but @return a full `ZSTD_parameters` object instead of sub-component `ZSTD_compressionParameters`. * Create an internal CDict from `dict` buffer.
* All fields of `ZSTD_frameParameters` are set to default : contentSize=1, checksum=0, noDictID=0 */ * Decompression will have to use same dictionary.
ZSTDLIB_API ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize); * @result : 0, or an error code (which can be tested with ZSTD_isError()).
* Special: Loading a NULL (or 0-size) dictionary invalidates previous dictionary,
* meaning "return to no-dictionary mode".
* Note 1 : Dictionary is sticky, it will be used for all future compressed frames.
* To return to "no-dictionary" situation, load a NULL dictionary (or reset parameters).
* Note 2 : Loading a dictionary involves building tables.
* It's also a CPU consuming operation, with non-negligible impact on latency.
* Tables are dependent on compression parameters, and for this reason,
* compression parameters can no longer be changed after loading a dictionary.
* Note 3 :`dict` content will be copied internally.
* Use experimental ZSTD_CCtx_loadDictionary_byReference() to reference content instead.
* In such a case, dictionary buffer must outlive its users.
* Note 4 : Use ZSTD_CCtx_loadDictionary_advanced()
* to precisely select how dictionary content must be interpreted. */
ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary(ZSTD_CCtx* cctx, const void* dict, size_t dictSize);
/*! ZSTD_checkCParams() : /*! ZSTD_CCtx_refCDict() :
* Ensure param values remain within authorized range */ * Reference a prepared dictionary, to be used for all next compressed frames.
ZSTDLIB_API size_t ZSTD_checkCParams(ZSTD_compressionParameters params); * Note that compression parameters are enforced from within CDict,
* and supercede any compression parameter previously set within CCtx.
* The dictionary will remain valid for future compressed frames using same CCtx.
* @result : 0, or an error code (which can be tested with ZSTD_isError()).
* Special : Referencing a NULL CDict means "return to no-dictionary mode".
* Note 1 : Currently, only one dictionary can be managed.
* Referencing a new dictionary effectively "discards" any previous one.
* Note 2 : CDict is just referenced, its lifetime must outlive its usage within CCtx. */
ZSTDLIB_API size_t ZSTD_CCtx_refCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict);
/*! ZSTD_adjustCParams() : /*! ZSTD_CCtx_refPrefix() :
* optimize params for a given `srcSize` and `dictSize`. * Reference a prefix (single-usage dictionary) for next compressed frame.
* both values are optional, select `0` if unknown. */ * A prefix is **only used once**. Tables are discarded at end of frame (ZSTD_e_end).
ZSTDLIB_API ZSTD_compressionParameters ZSTD_adjustCParams(ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize); * Decompression will need same prefix to properly regenerate data.
* Compressing with a prefix is similar in outcome as performing a diff and compressing it,
* but performs much faster, especially during decompression (compression speed is tunable with compression level).
* @result : 0, or an error code (which can be tested with ZSTD_isError()).
* Special: Adding any prefix (including NULL) invalidates any previous prefix or dictionary
* Note 1 : Prefix buffer is referenced. It **must** outlive compression.
* Its content must remain unmodified during compression.
* Note 2 : If the intention is to diff some large src data blob with some prior version of itself,
* ensure that the window size is large enough to contain the entire source.
* See ZSTD_c_windowLog.
* Note 3 : Referencing a prefix involves building tables, which are dependent on compression parameters.
* It's a CPU consuming operation, with non-negligible impact on latency.
* If there is a need to use the same prefix multiple times, consider loadDictionary instead.
* Note 4 : By default, the prefix is interpreted as raw content (ZSTD_dm_rawContent).
* Use experimental ZSTD_CCtx_refPrefix_advanced() to alter dictionary interpretation. */
ZSTDLIB_API size_t ZSTD_CCtx_refPrefix(ZSTD_CCtx* cctx,
const void* prefix, size_t prefixSize);
/*! ZSTD_compress_advanced() :
* Same as ZSTD_compress_usingDict(), with fine-tune control over each compression parameter */
ZSTDLIB_API size_t ZSTD_compress_advanced (ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize,
const void* dict,size_t dictSize,
ZSTD_parameters params);
/*! ZSTD_compress_usingCDict_advanced() : typedef enum {
* Same as ZSTD_compress_usingCDict(), with fine-tune control over frame parameters */ ZSTD_reset_session_only = 1,
ZSTDLIB_API size_t ZSTD_compress_usingCDict_advanced(ZSTD_CCtx* cctx, ZSTD_reset_parameters = 2,
void* dst, size_t dstCapacity, ZSTD_reset_session_and_parameters = 3
const void* src, size_t srcSize, } ZSTD_ResetDirective;
const ZSTD_CDict* cdict, ZSTD_frameParameters fParams);
/*! ZSTD_CCtx_reset() :
* There are 2 different things that can be reset, independently or jointly :
* - The session : will stop compressing current frame, and make CCtx ready to start a new one.
* Useful after an error, or to interrupt any ongoing compression.
* Any internal data not yet flushed is cancelled.
* Compression parameters and dictionary remain unchanged.
* They will be used to compress next frame.
* Resetting session never fails.
* - The parameters : changes all parameters back to "default".
* This removes any reference to any dictionary too.
* Parameters can only be changed between 2 sessions (i.e. no compression is currently ongoing)
* otherwise the reset fails, and function returns an error value (which can be tested using ZSTD_isError())
* - Both : similar to resetting the session, followed by resetting parameters.
*/
ZSTDLIB_API size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset);
/*--- Advanced decompression functions ---*/
/*! ZSTD_isFrame() :
* Tells if the content of `buffer` starts with a valid Frame Identifier.
* Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
* Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled.
* Note 3 : Skippable Frame Identifiers are considered valid. */
ZSTDLIB_API unsigned ZSTD_isFrame(const void* buffer, size_t size);
/*! ZSTD_createDDict_byReference() : /*! ZSTD_compress2() :
* Create a digested dictionary, ready to start decompression operation without startup delay. * Behave the same as ZSTD_compressCCtx(), but compression parameters are set using the advanced API.
* Dictionary content is referenced, and therefore stays in dictBuffer. * ZSTD_compress2() always starts a new frame.
* It is important that dictBuffer outlives DDict, * Should cctx hold data from a previously unfinished frame, everything about it is forgotten.
* it must remain read accessible throughout the lifetime of DDict */ * - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()
ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize); * - The function is always blocking, returns when compression is completed.
* Hint : compression runs faster if `dstCapacity` >= `ZSTD_compressBound(srcSize)`.
* @return : compressed size written into `dst` (<= `dstCapacity),
* or an error code if it fails (which can be tested using ZSTD_isError()).
*/
ZSTDLIB_API size_t ZSTD_compress2( ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize);
typedef enum {
ZSTD_e_continue=0, /* collect more data, encoder decides when to output compressed result, for optimal compression ratio */
ZSTD_e_flush=1, /* flush any data provided so far,
* it creates (at least) one new block, that can be decoded immediately on reception;
* frame will continue: any future data can still reference previously compressed data, improving compression. */
ZSTD_e_end=2 /* flush any remaining data _and_ close current frame.
* note that frame is only closed after compressed data is fully flushed (return value == 0).
* After that point, any additional data starts a new frame.
* note : each frame is independent (does not reference any content from previous frame). */
} ZSTD_EndDirective;
/*! ZSTD_getDictID_fromDict() : /*! ZSTD_compressStream2() :
* Provides the dictID stored within dictionary. * Behaves about the same as ZSTD_compressStream, with additional control on end directive.
* if @return == 0, the dictionary is not conformant with Zstandard specification. * - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()
* It can still be loaded, but as a content-only dictionary. */ * - Compression parameters cannot be changed once compression is started (save a list of exceptions in multi-threading mode)
ZSTDLIB_API unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize); * - outpot->pos must be <= dstCapacity, input->pos must be <= srcSize
* - outpot->pos and input->pos will be updated. They are guaranteed to remain below their respective limit.
* - When nbWorkers==0 (default), function is blocking : it completes its job before returning to caller.
* - When nbWorkers>=1, function is non-blocking : it just acquires a copy of input, and distributes jobs to internal worker threads, flush whatever is available,
* and then immediately returns, just indicating that there is some data remaining to be flushed.
* The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte.
* - Exception : if the first call requests a ZSTD_e_end directive and provides enough dstCapacity, the function delegates to ZSTD_compress2() which is always blocking.
* - @return provides a minimum amount of data remaining to be flushed from internal buffers
* or an error code, which can be tested using ZSTD_isError().
* if @return != 0, flush is not fully completed, there is still some data left within internal buffers.
* This is useful for ZSTD_e_flush, since in this case more flushes are necessary to empty all buffers.
* For ZSTD_e_end, @return == 0 when internal buffers are fully flushed and frame is completed.
* - after a ZSTD_e_end directive, if internal buffer is not fully flushed (@return != 0),
* only ZSTD_e_end or ZSTD_e_flush operations are allowed.
* Before starting a new compression job, or changing compression parameters,
* it is required to fully flush internal buffers.
*/
ZSTDLIB_API size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
ZSTD_outBuffer* output,
ZSTD_inBuffer* input,
ZSTD_EndDirective endOp);
/*! ZSTD_getDictID_fromDDict() :
* Provides the dictID of the dictionary loaded into `ddict`.
* If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.
* Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */
ZSTDLIB_API unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict);
/*! ZSTD_getDictID_fromFrame() :
* Provides the dictID required to decompressed the frame stored within `src`.
* If @return == 0, the dictID could not be decoded.
* This could for one of the following reasons :
* - The frame does not require a dictionary to be decoded (most common case).
* - The frame was built with dictID intentionally removed. Whatever dictionary is necessary is a hidden information.
* Note : this use case also happens when using a non-conformant dictionary.
* - `srcSize` is too small, and as a result, the frame header could not be decoded (only possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`).
* - This is not a Zstandard frame.
* When identifying the exact failure cause, it's possible to use ZSTD_getFrameHeader(), which will provide a more precise error code. */
ZSTDLIB_API unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize);
/* ============================== */
/* Advanced decompression API */
/* ============================== */
/* The advanced API pushes parameters one by one into an existing DCtx context.
* Parameters are sticky, and remain valid for all following frames
* using the same DCtx context.
* It's possible to reset parameters to default values using ZSTD_DCtx_reset().
* Note : This API is compatible with existing ZSTD_decompressDCtx() and ZSTD_decompressStream().
* Therefore, no new decompression function is necessary.
*/
/********************************************************************
* Advanced streaming functions
********************************************************************/
/*===== Advanced Streaming compression functions =====*/ typedef enum {
ZSTDLIB_API size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize); /**< pledgedSrcSize must be correct. If it is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs, "0" also disables frame content size field. It may be enabled in the future. */
ZSTDLIB_API size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel); /**< creates of an internal CDict (incompatible with static CCtx), except if dict == NULL or dictSize < 8, in which case no dict is used. Note: dict is loaded with ZSTD_dm_auto (treated as a full zstd dictionary if it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy.*/
ZSTDLIB_API size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs, const void* dict, size_t dictSize,
ZSTD_parameters params, unsigned long long pledgedSrcSize); /**< pledgedSrcSize must be correct. If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */
ZSTDLIB_API size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict); /**< note : cdict will just be referenced, and must outlive compression session */
ZSTDLIB_API size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams, unsigned long long pledgedSrcSize); /**< same as ZSTD_initCStream_usingCDict(), with control over frame parameters. pledgedSrcSize must be correct. If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. */
/*! ZSTD_resetCStream() : ZSTD_d_windowLogMax=100, /* Select a size limit (in power of 2) beyond which
* start a new compression job, using same parameters from previous job. * the streaming API will refuse to allocate memory buffer
* This is typically useful to skip dictionary loading stage, since it will re-use it in-place. * in order to protect the host from unreasonable memory requirements.
* Note that zcs must be init at least once before using ZSTD_resetCStream(). * This parameter is only useful in streaming mode, since no internal buffer is allocated in single-pass mode.
* If pledgedSrcSize is not known at reset time, use macro ZSTD_CONTENTSIZE_UNKNOWN. * By default, a decompression context accepts window sizes <= (1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT) */
* If pledgedSrcSize > 0, its value must be correct, as it will be written in header, and controlled at the end.
* For the time being, pledgedSrcSize==0 is interpreted as "srcSize unknown" for compatibility with older programs, /* note : additional experimental parameters are also available
* but it will change to mean "empty" in future version, so use macro ZSTD_CONTENTSIZE_UNKNOWN instead. * within the experimental section of the API.
* @return : 0, or an error code (which can be tested using ZSTD_isError()) * At the time of this writing, they include :
* ZSTD_c_format
* Because they are not stable, it's necessary to define ZSTD_STATIC_LINKING_ONLY to access them.
* note : never ever use experimentalParam? names directly
*/
ZSTD_d_experimentalParam1=1000
} ZSTD_dParameter;
/*! ZSTD_dParam_getBounds() :
* All parameters must belong to an interval with lower and upper bounds,
* otherwise they will either trigger an error or be automatically clamped.
* @return : a structure, ZSTD_bounds, which contains
* - an error status field, which must be tested using ZSTD_isError()
* - both lower and upper bounds, inclusive
*/
ZSTDLIB_API ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam);
/*! ZSTD_DCtx_setParameter() :
* Set one compression parameter, selected by enum ZSTD_dParameter.
* All parameters have valid bounds. Bounds can be queried using ZSTD_dParam_getBounds().
* Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter).
* Setting a parameter is only possible during frame initialization (before starting decompression).
* @return : 0, or an error code (which can be tested using ZSTD_isError()).
*/ */
ZSTDLIB_API size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize); ZSTDLIB_API size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int value);
typedef struct { /*! ZSTD_DCtx_loadDictionary() :
unsigned long long ingested; /* nb input bytes read and buffered */ * Create an internal DDict from dict buffer,
unsigned long long consumed; /* nb input bytes actually compressed */ * to be used to decompress next frames.
unsigned long long produced; /* nb of compressed bytes generated and buffered */ * The dictionary remains valid for all future frames, until explicitly invalidated.
unsigned long long flushed; /* nb of compressed bytes flushed : not provided; can be tracked from caller side */ * @result : 0, or an error code (which can be tested with ZSTD_isError()).
unsigned currentJobID; /* MT only : latest started job nb */ * Special : Adding a NULL (or 0-size) dictionary invalidates any previous dictionary,
unsigned nbActiveWorkers; /* MT only : nb of workers actively compressing at probe time */ * meaning "return to no-dictionary mode".
} ZSTD_frameProgression; * Note 1 : Loading a dictionary involves building tables,
* which has a non-negligible impact on CPU usage and latency.
* It's recommended to "load once, use many times", to amortize the cost
* Note 2 :`dict` content will be copied internally, so `dict` can be released after loading.
* Use ZSTD_DCtx_loadDictionary_byReference() to reference dictionary content instead.
* Note 3 : Use ZSTD_DCtx_loadDictionary_advanced() to take control of
* how dictionary content is loaded and interpreted.
*/
ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
/* ZSTD_getFrameProgression() : /*! ZSTD_DCtx_refDDict() :
* tells how much data has been ingested (read from input) * Reference a prepared dictionary, to be used to decompress next frames.
* consumed (input actually compressed) and produced (output) for current frame. * The dictionary remains active for decompression of future frames using same DCtx.
* Note : (ingested - consumed) is amount of input data buffered internally, not yet compressed. * @result : 0, or an error code (which can be tested with ZSTD_isError()).
* Aggregates progression inside active worker threads. * Note 1 : Currently, only one dictionary can be managed.
* Referencing a new dictionary effectively "discards" any previous one.
* Special: referencing a NULL DDict means "return to no-dictionary mode".
* Note 2 : DDict is just referenced, its lifetime must outlive its usage from DCtx.
*/ */
ZSTDLIB_API ZSTD_frameProgression ZSTD_getFrameProgression(const ZSTD_CCtx* cctx); ZSTDLIB_API size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);
/*! ZSTD_toFlushNow() : /*! ZSTD_DCtx_refPrefix() :
* Tell how many bytes are ready to be flushed immediately. * Reference a prefix (single-usage dictionary) to decompress next frame.
* Useful for multithreading scenarios (nbWorkers >= 1). * This is the reverse operation of ZSTD_CCtx_refPrefix(),
* Probe the oldest active job, defined as oldest job not yet entirely flushed, * and must use the same prefix as the one used during compression.
* and check its output buffer. * Prefix is **only used once**. Reference is discarded at end of frame.
* @return : amount of data stored in oldest job and ready to be flushed immediately. * End of frame is reached when ZSTD_decompressStream() returns 0.
* if @return == 0, it means either : * @result : 0, or an error code (which can be tested with ZSTD_isError()).
* + there is no active job (could be checked with ZSTD_frameProgression()), or * Note 1 : Adding any prefix (including NULL) invalidates any previously set prefix or dictionary
* + oldest job is still actively compressing data, * Note 2 : Prefix buffer is referenced. It **must** outlive decompression.
* but everything it has produced has also been flushed so far, * Prefix buffer must remain unmodified up to the end of frame,
* therefore flushing speed is currently limited by production speed of oldest job * reached when ZSTD_decompressStream() returns 0.
* irrespective of the speed of concurrent newer jobs. * Note 3 : By default, the prefix is treated as raw content (ZSTD_dm_rawContent).
* Use ZSTD_CCtx_refPrefix_advanced() to alter dictMode (Experimental section)
* Note 4 : Referencing a raw content prefix has almost no cpu nor memory cost.
* A full dictionary is more costly, as it requires building tables.
*/ */
ZSTDLIB_API size_t ZSTD_toFlushNow(ZSTD_CCtx* cctx); ZSTDLIB_API size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx,
const void* prefix, size_t prefixSize);
/*! ZSTD_DCtx_reset() :
* Return a DCtx to clean state.
* Session and parameters can be reset jointly or separately.
* Parameters can only be reset when no active frame is being decompressed.
* @return : 0, or an error code, which can be tested with ZSTD_isError()
*/
ZSTDLIB_API size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset);
/*===== Advanced Streaming decompression functions =====*/
typedef enum { DStream_p_maxWindowSize } ZSTD_DStreamParameter_e;
ZSTDLIB_API size_t ZSTD_setDStreamParameter(ZSTD_DStream* zds, ZSTD_DStreamParameter_e paramType, unsigned paramValue); /* obsolete : this API will be removed in a future version */
ZSTDLIB_API size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize); /**< note: no dictionary will be used if dict == NULL or dictSize < 8 */
ZSTDLIB_API size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* zds, const ZSTD_DDict* ddict); /**< note : ddict is referenced, it must outlive decompression session */
ZSTDLIB_API size_t ZSTD_resetDStream(ZSTD_DStream* zds); /**< re-use decompression parameters from previous init; saves dictionary loading */
/****************************************************************************************
* experimental API (static linking only)
****************************************************************************************
* The following symbols and constants
* are not planned to join "stable API" status in the near future.
* They can still change in future versions.
* Some of them are planned to remain in the static_only section indefinitely.
* Some of them might be removed in the future (especially when redundant with existing stable functions)
* ***************************************************************************************/
/********************************************************************* #define ZSTD_FRAMEHEADERSIZE_PREFIX 5 /* minimum input size required to query frame header size */
* Buffer-less and synchronous inner streaming functions #define ZSTD_FRAMEHEADERSIZE_MIN 6
* #define ZSTD_FRAMEHEADERSIZE_MAX 18 /* can be useful for static allocation */
* This is an advanced API, giving full control over buffer management, for users which need direct control over memory. #define ZSTD_SKIPPABLEHEADERSIZE 8
* But it's also a complex one, with several restrictions, documented below.
* Prefer normal streaming API for an easier experience.
********************************************************************* */
/** /* compression parameter bounds */
Buffer-less streaming compression (synchronous mode) #define ZSTD_WINDOWLOG_MAX_32 30
#define ZSTD_WINDOWLOG_MAX_64 31
#define ZSTD_WINDOWLOG_MAX ((int)(sizeof(size_t) == 4 ? ZSTD_WINDOWLOG_MAX_32 : ZSTD_WINDOWLOG_MAX_64))
#define ZSTD_WINDOWLOG_MIN 10
#define ZSTD_HASHLOG_MAX ((ZSTD_WINDOWLOG_MAX < 30) ? ZSTD_WINDOWLOG_MAX : 30)
#define ZSTD_HASHLOG_MIN 6
#define ZSTD_CHAINLOG_MAX_32 29
#define ZSTD_CHAINLOG_MAX_64 30
#define ZSTD_CHAINLOG_MAX ((int)(sizeof(size_t) == 4 ? ZSTD_CHAINLOG_MAX_32 : ZSTD_CHAINLOG_MAX_64))
#define ZSTD_CHAINLOG_MIN ZSTD_HASHLOG_MIN
#define ZSTD_SEARCHLOG_MAX (ZSTD_WINDOWLOG_MAX-1)
#define ZSTD_SEARCHLOG_MIN 1
#define ZSTD_MINMATCH_MAX 7 /* only for ZSTD_fast, other strategies are limited to 6 */
#define ZSTD_MINMATCH_MIN 3 /* only for ZSTD_btopt+, faster strategies are limited to 4 */
#define ZSTD_TARGETLENGTH_MAX ZSTD_BLOCKSIZE_MAX
#define ZSTD_TARGETLENGTH_MIN 0 /* note : comparing this constant to an unsigned results in a tautological test */
#define ZSTD_STRATEGY_MIN ZSTD_fast
#define ZSTD_STRATEGY_MAX ZSTD_btultra2
A ZSTD_CCtx object is required to track streaming operations.
Use ZSTD_createCCtx() / ZSTD_freeCCtx() to manage resource.
ZSTD_CCtx object can be re-used multiple times within successive compression operations.
Start by initializing a context. #define ZSTD_OVERLAPLOG_MIN 0
Use ZSTD_compressBegin(), or ZSTD_compressBegin_usingDict() for dictionary compression, #define ZSTD_OVERLAPLOG_MAX 9
or ZSTD_compressBegin_advanced(), for finer parameter control.
It's also possible to duplicate a reference context which has already been initialized, using ZSTD_copyCCtx()
Then, consume your input using ZSTD_compressContinue(). #define ZSTD_WINDOWLOG_LIMIT_DEFAULT 27 /* by default, the streaming decoder will refuse any frame
There are some important considerations to keep in mind when using this advanced function : * requiring larger than (1<<ZSTD_WINDOWLOG_LIMIT_DEFAULT) window size,
- ZSTD_compressContinue() has no internal buffer. It uses externally provided buffers only. * to preserve host's memory from unreasonable requirements.
- Interface is synchronous : input is consumed entirely and produces 1+ compressed blocks. * This limit can be overriden using ZSTD_DCtx_setParameter(,ZSTD_d_windowLogMax,).
- Caller must ensure there is enough space in `dst` to store compressed data under worst case scenario. * The limit does not apply for one-pass decoders (such as ZSTD_decompress()), since no additional memory is allocated */
Worst case evaluation is provided by ZSTD_compressBound().
ZSTD_compressContinue() doesn't guarantee recover after a failed compression.
- ZSTD_compressContinue() presumes prior input ***is still accessible and unmodified*** (up to maximum distance size, see WindowLog).
It remembers all previous contiguous blocks, plus one separated memory segment (which can itself consists of multiple contiguous blocks)
- ZSTD_compressContinue() detects that prior input has been overwritten when `src` buffer overlaps.
In which case, it will "discard" the relevant memory section from its history.
Finish a frame with ZSTD_compressEnd(), which will write the last block(s) and optional checksum.
It's possible to use srcSize==0, in which case, it will write a final empty block to end the frame.
Without last block mark, frames are considered unfinished (hence corrupted) by compliant decoders.
`ZSTD_CCtx` object can be re-used (ZSTD_compressBegin()) to compress again.
*/
/*===== Buffer-less streaming compression functions =====*/
ZSTDLIB_API size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel);
ZSTDLIB_API size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel);
ZSTDLIB_API size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize); /**< pledgedSrcSize : If srcSize is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN */
ZSTDLIB_API size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict); /**< note: fails if cdict==NULL */
ZSTDLIB_API size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict, ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize); /* compression parameters are already set within cdict. pledgedSrcSize must be correct. If srcSize is not known, use macro ZSTD_CONTENTSIZE_UNKNOWN */
ZSTDLIB_API size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx, unsigned long long pledgedSrcSize); /**< note: if pledgedSrcSize is not known, use ZSTD_CONTENTSIZE_UNKNOWN */
ZSTDLIB_API size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
ZSTDLIB_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
/*-
Buffer-less streaming decompression (synchronous mode)
A ZSTD_DCtx object is required to track streaming operations.
Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it.
A ZSTD_DCtx object can be re-used multiple times.
First typical operation is to retrieve frame parameters, using ZSTD_getFrameHeader().
Frame header is extracted from the beginning of compressed frame, so providing only the frame's beginning is enough.
Data fragment must be large enough to ensure successful decoding.
`ZSTD_frameHeaderSize_max` bytes is guaranteed to always be large enough.
@result : 0 : successful decoding, the `ZSTD_frameHeader` structure is correctly filled.
>0 : `srcSize` is too small, please provide at least @result bytes on next attempt.
errorCode, which can be tested using ZSTD_isError().
It fills a ZSTD_frameHeader structure with important information to correctly decode the frame,
such as the dictionary ID, content size, or maximum back-reference distance (`windowSize`).
Note that these values could be wrong, either because of data corruption, or because a 3rd party deliberately spoofs false information.
As a consequence, check that values remain within valid application range.
For example, do not allocate memory blindly, check that `windowSize` is within expectation.
Each application can set its own limits, depending on local restrictions.
For extended interoperability, it is recommended to support `windowSize` of at least 8 MB.
ZSTD_decompressContinue() needs previous data blocks during decompression, up to `windowSize` bytes.
ZSTD_decompressContinue() is very sensitive to contiguity,
if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place,
or that previous contiguous segment is large enough to properly handle maximum back-reference distance.
There are multiple ways to guarantee this condition.
The most memory efficient way is to use a round buffer of sufficient size.
Sufficient size is determined by invoking ZSTD_decodingBufferSize_min(),
which can @return an error code if required value is too large for current system (in 32-bits mode).
In a round buffer methodology, ZSTD_decompressContinue() decompresses each block next to previous one,
up to the moment there is not enough room left in the buffer to guarantee decoding another full block,
which maximum size is provided in `ZSTD_frameHeader` structure, field `blockSizeMax`.
At which point, decoding can resume from the beginning of the buffer.
Note that already decoded data stored in the buffer should be flushed before being overwritten.
There are alternatives possible, for example using two or more buffers of size `windowSize` each, though they consume more memory.
Finally, if you control the compression process, you can also ignore all buffer size rules,
as long as the encoder and decoder progress in "lock-step",
aka use exactly the same buffer sizes, break contiguity at the same place, etc.
Once buffers are setup, start decompression, with ZSTD_decompressBegin().
If decompression requires a dictionary, use ZSTD_decompressBegin_usingDict() or ZSTD_decompressBegin_usingDDict().
Then use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively.
ZSTD_nextSrcSizeToDecompress() tells how many bytes to provide as 'srcSize' to ZSTD_decompressContinue().
ZSTD_decompressContinue() requires this _exact_ amount of bytes, or it will fail.
@result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity). /* LDM parameter bounds */
It can be zero : it just means ZSTD_decompressContinue() has decoded some metadata item. #define ZSTD_LDM_HASHLOG_MIN ZSTD_HASHLOG_MIN
It can also be an error code, which can be tested with ZSTD_isError(). #define ZSTD_LDM_HASHLOG_MAX ZSTD_HASHLOG_MAX
#define ZSTD_LDM_MINMATCH_MIN 4
#define ZSTD_LDM_MINMATCH_MAX 4096
#define ZSTD_LDM_BUCKETSIZELOG_MIN 1
#define ZSTD_LDM_BUCKETSIZELOG_MAX 8
#define ZSTD_LDM_HASHRATELOG_MIN 0
#define ZSTD_LDM_HASHRATELOG_MAX (ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN)
A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero. /* internal */
Context can then be reset to start a new decompression. #define ZSTD_HASHLOG3_MAX 17
Note : it's possible to know if next input to present is a header or a block, using ZSTD_nextInputType().
This information is not required to properly decode a frame.
== Special case : skippable frames == /* --- Advanced types --- */
Skippable frames allow integration of user-defined data into a flow of concatenated frames. typedef struct ZSTD_CCtx_params_s ZSTD_CCtx_params;
Skippable frames will be ignored (skipped) by decompressor.
The format of skippable frames is as follows :
a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F
b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits
c) Frame Content - any content (User Data) of length equal to Frame Size
For skippable frames ZSTD_getFrameHeader() returns zfhPtr->frameType==ZSTD_skippableFrame.
For skippable frames ZSTD_decompressContinue() always returns 0 : it only skips the content.
*/
/*===== Buffer-less streaming decompression functions =====*/
typedef enum { ZSTD_frame, ZSTD_skippableFrame } ZSTD_frameType_e;
typedef struct { typedef struct {
unsigned long long frameContentSize; /* if == ZSTD_CONTENTSIZE_UNKNOWN, it means this field is not available. 0 means "empty" */ unsigned windowLog; /**< largest match distance : larger == more compression, more memory needed during decompression */
unsigned long long windowSize; /* can be very large, up to <= frameContentSize */ unsigned chainLog; /**< fully searched segment : larger == more compression, slower, more memory (useless for fast) */
unsigned blockSizeMax; unsigned hashLog; /**< dispatch table : larger == faster, more memory */
ZSTD_frameType_e frameType; /* if == ZSTD_skippableFrame, frameContentSize is the size of skippable content */ unsigned searchLog; /**< nb of searches : larger == more compression, slower */
unsigned headerSize; unsigned minMatch; /**< match length searched : larger == faster decompression, sometimes less compression */
unsigned dictID; unsigned targetLength; /**< acceptable match size for optimal parser (only) : larger == more compression, slower */
unsigned checksumFlag; ZSTD_strategy strategy; /**< see ZSTD_strategy definition above */
} ZSTD_frameHeader; } ZSTD_compressionParameters;
/** ZSTD_getFrameHeader() :
* decode Frame Header, or requires larger `srcSize`.
* @return : 0, `zfhPtr` is correctly filled,
* >0, `srcSize` is too small, value is wanted `srcSize` amount,
* or an error code, which can be tested using ZSTD_isError() */
ZSTDLIB_API size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize); /**< doesn't consume input */
ZSTDLIB_API size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize); /**< when frame content size is not known, pass in frameContentSize == ZSTD_CONTENTSIZE_UNKNOWN */
ZSTDLIB_API size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx);
ZSTDLIB_API size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
ZSTDLIB_API size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);
ZSTDLIB_API size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx);
ZSTDLIB_API size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
/* misc */
ZSTDLIB_API void ZSTD_copyDCtx(ZSTD_DCtx* dctx, const ZSTD_DCtx* preparedDCtx);
typedef enum { ZSTDnit_frameHeader, ZSTDnit_blockHeader, ZSTDnit_block, ZSTDnit_lastBlock, ZSTDnit_checksum, ZSTDnit_skippableFrame } ZSTD_nextInputType_e;
ZSTDLIB_API ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx);
typedef struct {
int contentSizeFlag; /**< 1: content size will be in frame header (when known) */
int checksumFlag; /**< 1: generate a 32-bits checksum using XXH64 algorithm at end of frame, for error detection */
int noDictIDFlag; /**< 1: no dictID will be saved into frame header (dictID is only useful for dictionary compression) */
} ZSTD_frameParameters;
/* ============================================ */ typedef struct {
/** New advanced API (experimental) */ ZSTD_compressionParameters cParams;
/* ============================================ */ ZSTD_frameParameters fParams;
} ZSTD_parameters;
/* API design : typedef enum {
* In this advanced API, parameters are pushed one by one into an existing context, ZSTD_dct_auto = 0, /* dictionary is "full" when starting with ZSTD_MAGIC_DICTIONARY, otherwise it is "rawContent" */
* using ZSTD_CCtx_set*() functions. ZSTD_dct_rawContent = 1, /* ensures dictionary is always loaded as rawContent, even if it starts with ZSTD_MAGIC_DICTIONARY */
* Pushed parameters are sticky : they are applied to next job, and any subsequent job. ZSTD_dct_fullDict = 2 /* refuses to load a dictionary if it does not respect Zstandard's specification, starting with ZSTD_MAGIC_DICTIONARY */
* It's possible to reset parameters to "default" using ZSTD_CCtx_reset(). } ZSTD_dictContentType_e;
* Important : "sticky" parameters only work with `ZSTD_compress_generic()` !
* For any other entry point, "sticky" parameters are ignored !
*
* This API is intended to replace all others advanced / experimental API entry points.
*/
/* note on enum design : typedef enum {
* All enum will be pinned to explicit values before reaching "stable API" status */ ZSTD_dlm_byCopy = 0, /**< Copy dictionary content internally */
ZSTD_dlm_byRef = 1, /**< Reference dictionary content -- the dictionary buffer must outlive its users. */
} ZSTD_dictLoadMethod_e;
typedef enum { typedef enum {
/* Opened question : should we have a format ZSTD_f_auto ? /* Opened question : should we have a format ZSTD_f_auto ?
* Today, it would mean exactly the same as ZSTD_f_zstd1. * Today, it would mean exactly the same as ZSTD_f_zstd1.
* But, in the future, should several formats become supported, * But, in the future, should several formats become supported,
* on the compression side, it would mean "default format". * on the compression side, it would mean "default format".
* On the decompression side, it would mean "automatic format detection", * On the decompression side, it would mean "automatic format detection",
* so that ZSTD_f_zstd1 would mean "accept *only* zstd frames". * so that ZSTD_f_zstd1 would mean "accept *only* zstd frames".
* Since meaning is a little different, another option could be to define different enums for compression and decompression. * Since meaning is a little different, another option could be to define different enums for compression and decompression.
* This question could be kept for later, when there are actually multiple formats to support, * This question could be kept for later, when there are actually multiple formats to support,
* but there is also the question of pinning enum values, and pinning value `0` is especially important */ * but there is also the question of pinning enum values, and pinning value `0` is especially important */
ZSTD_f_zstd1 = 0, /* zstd frame format, specified in zstd_compression_format.md (default) */ ZSTD_f_zstd1 = 0, /* zstd frame format, specified in zstd_compression_format.md (default) */
ZSTD_f_zstd1_magicless, /* Variant of zstd frame format, without initial 4-bytes magic number. ZSTD_f_zstd1_magicless = 1, /* Variant of zstd frame format, without initial 4-bytes magic number.
* Useful to save 4 bytes per generated frame. * Useful to save 4 bytes per generated frame.
* Decoder cannot recognise automatically this format, requiring instructions. */ * Decoder cannot recognise automatically this format, requiring this instruction. */
} ZSTD_format_e; } ZSTD_format_e;
typedef enum { typedef enum {
/* compression format */ /* Note: this enum and the behavior it controls are effectively internal
ZSTD_p_format = 10, /* See ZSTD_format_e enum definition. * implementation details of the compressor. They are expected to continue
* Cast selected format as unsigned for ZSTD_CCtx_setParameter() compatibility. */ * to evolve and should be considered only in the context of extremely
* advanced performance tuning.
/* compression parameters */ *
ZSTD_p_compressionLevel=100, /* Update all compression parameters according to pre-defined cLevel table * Zstd currently supports the use of a CDict in two ways:
* Default level is ZSTD_CLEVEL_DEFAULT==3. *
* Special: value 0 means default, which is controlled by ZSTD_CLEVEL_DEFAULT. * - The contents of the CDict can be copied into the working context. This
* Note 1 : it's possible to pass a negative compression level by casting it to unsigned type. * means that the compression can search both the dictionary and input
* Note 2 : setting a level sets all default values of other compression parameters. * while operating on a single set of internal tables. This makes
* Note 3 : setting compressionLevel automatically updates ZSTD_p_compressLiterals. */ * the compression faster per-byte of input. However, the initial copy of
ZSTD_p_windowLog, /* Maximum allowed back-reference distance, expressed as power of 2. * the CDict's tables incurs a fixed cost at the beginning of the
* Must be clamped between ZSTD_WINDOWLOG_MIN and ZSTD_WINDOWLOG_MAX. * compression. For small compressions (< 8 KB), that copy can dominate
* Special: value 0 means "use default windowLog". * the cost of the compression.
* Note: Using a window size greater than ZSTD_MAXWINDOWSIZE_DEFAULT (default: 2^27) *
* requires explicitly allowing such window size during decompression stage. */ * - The CDict's tables can be used in-place. In this model, compression is
ZSTD_p_hashLog, /* Size of the initial probe table, as a power of 2. * slower per input byte, because the compressor has to search two sets of
* Resulting table size is (1 << (hashLog+2)). * tables. However, this model incurs no start-up cost (as long as the
* Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX. * working context's tables can be reused). For small inputs, this can be
* Larger tables improve compression ratio of strategies <= dFast, * faster than copying the CDict's tables.
* and improve speed of strategies > dFast. *
* Special: value 0 means "use default hashLog". */ * Zstd has a simple internal heuristic that selects which strategy to use
ZSTD_p_chainLog, /* Size of the multi-probe search table, as a power of 2. * at the beginning of a compression. However, if experimentation shows that
* Resulting table size is (1 << (chainLog+2)). * Zstd is making poor choices, it is possible to override that choice with
* Must be clamped between ZSTD_CHAINLOG_MIN and ZSTD_CHAINLOG_MAX. * this enum.
* Larger tables result in better and slower compression. */
* This parameter is useless when using "fast" strategy. ZSTD_dictDefaultAttach = 0, /* Use the default heuristic. */
* Note it's still useful when using "dfast" strategy, ZSTD_dictForceAttach = 1, /* Never copy the dictionary. */
* in which case it defines a secondary probe table. ZSTD_dictForceCopy = 2, /* Always copy the dictionary. */
* Special: value 0 means "use default chainLog". */ } ZSTD_dictAttachPref_e;
ZSTD_p_searchLog, /* Number of search attempts, as a power of 2.
* More attempts result in better and slower compression.
* This parameter is useless when using "fast" and "dFast" strategies.
* Special: value 0 means "use default searchLog". */
ZSTD_p_minMatch, /* Minimum size of searched matches (note : repCode matches can be smaller).
* Larger values make faster compression and decompression, but decrease ratio.
* Must be clamped between ZSTD_SEARCHLENGTH_MIN and ZSTD_SEARCHLENGTH_MAX.
* Note that currently, for all strategies < btopt, effective minimum is 4.
* , for all strategies > fast, effective maximum is 6.
* Special: value 0 means "use default minMatchLength". */
ZSTD_p_targetLength, /* Impact of this field depends on strategy.
* For strategies btopt & btultra:
* Length of Match considered "good enough" to stop search.
* Larger values make compression stronger, and slower.
* For strategy fast:
* Distance between match sampling.
* Larger values make compression faster, and weaker.
* Special: value 0 means "use default targetLength". */
ZSTD_p_compressionStrategy, /* See ZSTD_strategy enum definition.
* Cast selected strategy as unsigned for ZSTD_CCtx_setParameter() compatibility.
* The higher the value of selected strategy, the more complex it is,
* resulting in stronger and slower compression.
* Special: value 0 means "use default strategy". */
ZSTD_p_enableLongDistanceMatching=160, /* Enable long distance matching.
* This parameter is designed to improve compression ratio
* for large inputs, by finding large matches at long distance.
* It increases memory usage and window size.
* Note: enabling this parameter increases ZSTD_p_windowLog to 128 MB
* except when expressly set to a different value. */
ZSTD_p_ldmHashLog, /* Size of the table for long distance matching, as a power of 2.
* Larger values increase memory usage and compression ratio,
* but decrease compression speed.
* Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX
* default: windowlog - 7.
* Special: value 0 means "automatically determine hashlog". */
ZSTD_p_ldmMinMatch, /* Minimum match size for long distance matcher.
* Larger/too small values usually decrease compression ratio.
* Must be clamped between ZSTD_LDM_MINMATCH_MIN and ZSTD_LDM_MINMATCH_MAX.
* Special: value 0 means "use default value" (default: 64). */
ZSTD_p_ldmBucketSizeLog, /* Log size of each bucket in the LDM hash table for collision resolution.
* Larger values improve collision resolution but decrease compression speed.
* The maximum value is ZSTD_LDM_BUCKETSIZELOG_MAX .
* Special: value 0 means "use default value" (default: 3). */
ZSTD_p_ldmHashEveryLog, /* Frequency of inserting/looking up entries in the LDM hash table.
* Must be clamped between 0 and (ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN).
* Default is MAX(0, (windowLog - ldmHashLog)), optimizing hash table usage.
* Larger values improve compression speed.
* Deviating far from default value will likely result in a compression ratio decrease.
* Special: value 0 means "automatically determine hashEveryLog". */
/* frame parameters */ /***************************************
ZSTD_p_contentSizeFlag=200, /* Content size will be written into frame header _whenever known_ (default:1) * Frame size functions
* Content size must be known at the beginning of compression, ***************************************/
* it is provided using ZSTD_CCtx_setPledgedSrcSize() */
ZSTD_p_checksumFlag, /* A 32-bits checksum of content is written at end of frame (default:0) */
ZSTD_p_dictIDFlag, /* When applicable, dictionary's ID is written into frame header (default:1) */
/* multi-threading parameters */ /*! ZSTD_findDecompressedSize() :
/* These parameters are only useful if multi-threading is enabled (ZSTD_MULTITHREAD). * `src` should point the start of a series of ZSTD encoded and/or skippable frames
* They return an error otherwise. */ * `srcSize` must be the _exact_ size of this series
ZSTD_p_nbWorkers=400, /* Select how many threads will be spawned to compress in parallel. * (i.e. there should be a frame boundary exactly at `srcSize` bytes after `src`)
* When nbWorkers >= 1, triggers asynchronous mode : * @return : - decompressed size of all data in all successive frames
* ZSTD_compress_generic() consumes some input, flush some output if possible, and immediately gives back control to caller, * - if the decompressed size cannot be determined: ZSTD_CONTENTSIZE_UNKNOWN
* while compression work is performed in parallel, within worker threads. * - if an error occurred: ZSTD_CONTENTSIZE_ERROR
* (note : a strong exception to this rule is when first invocation sets ZSTD_e_end : it becomes a blocking call). *
* More workers improve speed, but also increase memory usage. * note 1 : decompressed size is an optional field, that may not be present, especially in streaming mode.
* Default value is `0`, aka "single-threaded mode" : no worker is spawned, compression is performed inside Caller's thread, all invocations are blocking */ * When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size.
ZSTD_p_jobSize, /* Size of a compression job. This value is enforced only in non-blocking mode. * In which case, it's necessary to use streaming mode to decompress data.
* Each compression job is completed in parallel, so this value indirectly controls the nb of active threads. * note 2 : decompressed size is always present when compression is done with ZSTD_compress()
* 0 means default, which is dynamically determined based on compression parameters. * note 3 : decompressed size can be very large (64-bits value),
* Job size must be a minimum of overlapSize, or 1 MB, whichever is largest. * potentially larger than what local system can handle as a single memory segment.
* The minimum size is automatically and transparently enforced */ * In which case, it's necessary to use streaming mode to decompress data.
ZSTD_p_overlapSizeLog, /* Size of previous input reloaded at the beginning of each job. * note 4 : If source is untrusted, decompressed size could be wrong or intentionally modified.
* 0 => no overlap, 6(default) => use 1/8th of windowSize, >=9 => use full windowSize */ * Always ensure result fits within application's authorized limits.
* Each application can set its own limits.
* note 5 : ZSTD_findDecompressedSize handles multiple frames, and so it must traverse the input to
* read each contained frame header. This is fast as most of the data is skipped,
* however it does mean that all frame data must be present and valid. */
ZSTDLIB_API unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize);
/* =================================================================== */ /*! ZSTD_frameHeaderSize() :
/* experimental parameters - no stability guaranteed */ * srcSize must be >= ZSTD_FRAMEHEADERSIZE_PREFIX.
/* =================================================================== */ * @return : size of the Frame Header,
* or an error code (if srcSize is too small) */
ZSTDLIB_API size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize);
ZSTD_p_forceMaxWindow=1100, /* Force back-reference distances to remain < windowSize,
* even when referencing into Dictionary content (default:0) */
ZSTD_p_forceAttachDict, /* ZSTD supports usage of a CDict in-place
* (avoiding having to copy the compression tables
* from the CDict into the working context). Using
* a CDict in this way saves an initial setup step,
* but comes at the cost of more work per byte of
* input. ZSTD has a simple internal heuristic that
* guesses which strategy will be faster. You can
* use this flag to override that guess.
*
* Note that the by-reference, in-place strategy is
* only used when reusing a compression context
* with compatible compression parameters. (If
* incompatible / uninitialized, the working
* context needs to be cleared anyways, which is
* about as expensive as overwriting it with the
* dictionary context, so there's no savings in
* using the CDict by-ref.)
*
* Values greater than 0 force attaching the dict.
* Values less than 0 force copying the dict.
* 0 selects the default heuristic-guided behavior.
*/
} ZSTD_cParameter; /***************************************
* Memory management
***************************************/
/*! ZSTD_estimate*() :
* These functions make it possible to estimate memory usage
* of a future {D,C}Ctx, before its creation.
* ZSTD_estimateCCtxSize() will provide a budget large enough for any compression level up to selected one.
* It will also consider src size to be arbitrarily "large", which is worst case.
* If srcSize is known to always be small, ZSTD_estimateCCtxSize_usingCParams() can provide a tighter estimation.
* ZSTD_estimateCCtxSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel.
* ZSTD_estimateCCtxSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParam_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_c_nbWorkers is >= 1.
* Note : CCtx size estimation is only correct for single-threaded compression. */
ZSTDLIB_API size_t ZSTD_estimateCCtxSize(int compressionLevel);
ZSTDLIB_API size_t ZSTD_estimateCCtxSize_usingCParams(ZSTD_compressionParameters cParams);
ZSTDLIB_API size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params);
ZSTDLIB_API size_t ZSTD_estimateDCtxSize(void);
/*! ZSTD_CCtx_setParameter() : /*! ZSTD_estimateCStreamSize() :
* Set one compression parameter, selected by enum ZSTD_cParameter. * ZSTD_estimateCStreamSize() will provide a budget large enough for any compression level up to selected one.
* Setting a parameter is generally only possible during frame initialization (before starting compression). * It will also consider src size to be arbitrarily "large", which is worst case.
* Exception : when using multi-threading mode (nbThreads >= 1), * If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation.
* following parameters can be updated _during_ compression (within same frame): * ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel.
* => compressionLevel, hashLog, chainLog, searchLog, minMatch, targetLength and strategy. * ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParam_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_c_nbWorkers is >= 1.
* new parameters will be active on next job, or after a flush(). * Note : CStream size estimation is only correct for single-threaded compression.
* Note : when `value` type is not unsigned (int, or enum), cast it to unsigned for proper type checking. * ZSTD_DStream memory budget depends on window Size.
* @result : informational value (typically, value being set, correctly clamped), * This information can be passed manually, using ZSTD_estimateDStreamSize,
* or an error code (which can be tested with ZSTD_isError()). */ * or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame();
ZSTDLIB_API size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned value); * Note : if streaming is init with function ZSTD_init?Stream_usingDict(),
* an internal ?Dict will be created, which additional size is not estimated here.
* In this case, get total size by adding ZSTD_estimate?DictSize */
ZSTDLIB_API size_t ZSTD_estimateCStreamSize(int compressionLevel);
ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams);
ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params);
ZSTDLIB_API size_t ZSTD_estimateDStreamSize(size_t windowSize);
ZSTDLIB_API size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize);
/*! ZSTD_CCtx_getParameter() : /*! ZSTD_estimate?DictSize() :
* Get the requested value of one compression parameter, selected by enum ZSTD_cParameter. * ZSTD_estimateCDictSize() will bet that src size is relatively "small", and content is copied, like ZSTD_createCDict().
* @result : 0, or an error code (which can be tested with ZSTD_isError()). * ZSTD_estimateCDictSize_advanced() makes it possible to control compression parameters precisely, like ZSTD_createCDict_advanced().
* Note : dictionaries created by reference (`ZSTD_dlm_byRef`) are logically smaller.
*/ */
ZSTDLIB_API size_t ZSTD_CCtx_getParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned* value); ZSTDLIB_API size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel);
ZSTDLIB_API size_t ZSTD_estimateCDictSize_advanced(size_t dictSize, ZSTD_compressionParameters cParams, ZSTD_dictLoadMethod_e dictLoadMethod);
ZSTDLIB_API size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod);
/*! ZSTD_CCtx_setPledgedSrcSize() : /*! ZSTD_initStatic*() :
* Total input data size to be compressed as a single frame. * Initialize an object using a pre-allocated fixed-size buffer.
* This value will be controlled at the end, and result in error if not respected. * workspace: The memory area to emplace the object into.
* @result : 0, or an error code (which can be tested with ZSTD_isError()). * Provided pointer *must be 8-bytes aligned*.
* Note 1 : 0 means zero, empty. * Buffer must outlive object.
* In order to mean "unknown content size", pass constant ZSTD_CONTENTSIZE_UNKNOWN. * workspaceSize: Use ZSTD_estimate*Size() to determine
* ZSTD_CONTENTSIZE_UNKNOWN is default value for any new compression job. * how large workspace must be to support target scenario.
* Note 2 : If all data is provided and consumed in a single round, * @return : pointer to object (same address as workspace, just different type),
* this value is overriden by srcSize instead. */ * or NULL if error (size too small, incorrect alignment, etc.)
ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize); * Note : zstd will never resize nor malloc() when using a static buffer.
* If the object requires more memory than available,
* zstd will just error out (typically ZSTD_error_memory_allocation).
* Note 2 : there is no corresponding "free" function.
* Since workspace is allocated externally, it must be freed externally too.
* Note 3 : cParams : use ZSTD_getCParams() to convert a compression level
* into its associated cParams.
* Limitation 1 : currently not compatible with internal dictionary creation, triggered by
* ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict().
* Limitation 2 : static cctx currently not compatible with multi-threading.
* Limitation 3 : static dctx is incompatible with legacy support.
*/
ZSTDLIB_API ZSTD_CCtx* ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize);
ZSTDLIB_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize); /**< same as ZSTD_initStaticCCtx() */
/*! ZSTD_CCtx_loadDictionary() : ZSTDLIB_API ZSTD_DCtx* ZSTD_initStaticDCtx(void* workspace, size_t workspaceSize);
* Create an internal CDict from `dict` buffer. ZSTDLIB_API ZSTD_DStream* ZSTD_initStaticDStream(void* workspace, size_t workspaceSize); /**< same as ZSTD_initStaticDCtx() */
* Decompression will have to use same dictionary.
* @result : 0, or an error code (which can be tested with ZSTD_isError()). ZSTDLIB_API const ZSTD_CDict* ZSTD_initStaticCDict(
* Special: Adding a NULL (or 0-size) dictionary invalidates previous dictionary, void* workspace, size_t workspaceSize,
* meaning "return to no-dictionary mode". const void* dict, size_t dictSize,
* Note 1 : Dictionary will be used for all future compression jobs. ZSTD_dictLoadMethod_e dictLoadMethod,
* To return to "no-dictionary" situation, load a NULL dictionary ZSTD_dictContentType_e dictContentType,
* Note 2 : Loading a dictionary involves building tables, which are dependent on compression parameters. ZSTD_compressionParameters cParams);
* For this reason, compression parameters cannot be changed anymore after loading a dictionary.
* It's also a CPU consuming operation, with non-negligible impact on latency. ZSTDLIB_API const ZSTD_DDict* ZSTD_initStaticDDict(
* Note 3 :`dict` content will be copied internally. void* workspace, size_t workspaceSize,
* Use ZSTD_CCtx_loadDictionary_byReference() to reference dictionary content instead. const void* dict, size_t dictSize,
* In such a case, dictionary buffer must outlive its users. ZSTD_dictLoadMethod_e dictLoadMethod,
* Note 4 : Use ZSTD_CCtx_loadDictionary_advanced() ZSTD_dictContentType_e dictContentType);
* to precisely select how dictionary content must be interpreted. */
ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary(ZSTD_CCtx* cctx, const void* dict, size_t dictSize);
/*! Custom memory allocation :
* These prototypes make it possible to pass your own allocation/free functions.
* ZSTD_customMem is provided at creation time, using ZSTD_create*_advanced() variants listed below.
* All allocation/free operations will be completed using these custom variants instead of regular <stdlib.h> ones.
*/
typedef void* (*ZSTD_allocFunction) (void* opaque, size_t size);
typedef void (*ZSTD_freeFunction) (void* opaque, void* address);
typedef struct { ZSTD_allocFunction customAlloc; ZSTD_freeFunction customFree; void* opaque; } ZSTD_customMem;
static ZSTD_customMem const ZSTD_defaultCMem = { NULL, NULL, NULL }; /**< this constant defers to stdlib's functions */
ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem);
ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem);
ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem);
ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem);
ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict_advanced(const void* dict, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType,
ZSTD_compressionParameters cParams,
ZSTD_customMem customMem);
ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict_advanced(const void* dict, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType,
ZSTD_customMem customMem);
/***************************************
* Advanced compression functions
***************************************/
/*! ZSTD_createCDict_byReference() :
* Create a digested dictionary for compression
* Dictionary content is just referenced, not duplicated.
* As a consequence, `dictBuffer` **must** outlive CDict,
* and its content must remain unmodified throughout the lifetime of CDict. */
ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict_byReference(const void* dictBuffer, size_t dictSize, int compressionLevel);
/*! ZSTD_getCParams() :
* @return ZSTD_compressionParameters structure for a selected compression level and estimated srcSize.
* `estimatedSrcSize` value is optional, select 0 if not known */
ZSTDLIB_API ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize);
/*! ZSTD_getParams() :
* same as ZSTD_getCParams(), but @return a full `ZSTD_parameters` object instead of sub-component `ZSTD_compressionParameters`.
* All fields of `ZSTD_frameParameters` are set to default : contentSize=1, checksum=0, noDictID=0 */
ZSTDLIB_API ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize);
/*! ZSTD_checkCParams() :
* Ensure param values remain within authorized range */
ZSTDLIB_API size_t ZSTD_checkCParams(ZSTD_compressionParameters params);
/*! ZSTD_adjustCParams() :
* optimize params for a given `srcSize` and `dictSize`.
* both values are optional, select `0` if unknown. */
ZSTDLIB_API ZSTD_compressionParameters ZSTD_adjustCParams(ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize);
/*! ZSTD_compress_advanced() :
* Same as ZSTD_compress_usingDict(), with fine-tune control over compression parameters (by structure) */
ZSTDLIB_API size_t ZSTD_compress_advanced(ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize,
const void* dict,size_t dictSize,
ZSTD_parameters params);
/*! ZSTD_compress_usingCDict_advanced() :
* Same as ZSTD_compress_usingCDict(), with fine-tune control over frame parameters */
ZSTDLIB_API size_t ZSTD_compress_usingCDict_advanced(ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize,
const ZSTD_CDict* cdict,
ZSTD_frameParameters fParams);
/*! ZSTD_CCtx_loadDictionary_byReference() :
* Same as ZSTD_CCtx_loadDictionary(), but dictionary content is referenced, instead of being copied into CCtx.
* It saves some memory, but also requires that `dict` outlives its usage within `cctx` */
ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary_byReference(ZSTD_CCtx* cctx, const void* dict, size_t dictSize); ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary_byReference(ZSTD_CCtx* cctx, const void* dict, size_t dictSize);
/*! ZSTD_CCtx_loadDictionary_advanced() :
* Same as ZSTD_CCtx_loadDictionary(), but gives finer control over
* how to load the dictionary (by copy ? by reference ?)
* and how to interpret it (automatic ? force raw mode ? full mode only ?) */
ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType); ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType);
/*! ZSTD_CCtx_refPrefix_advanced() :
* Same as ZSTD_CCtx_refPrefix(), but gives finer control over
* how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?) */
ZSTDLIB_API size_t ZSTD_CCtx_refPrefix_advanced(ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType);
/* === experimental parameters === */
/* these parameters can be used with ZSTD_setParameter()
* they are not guaranteed to remain supported in the future */
/* Enables rsyncable mode,
* which makes compressed files more rsync friendly
* by adding periodic synchronization points to the compressed data.
* The target average block size is ZSTD_c_jobSize / 2.
* It's possible to modify the job size to increase or decrease
* the granularity of the synchronization point.
* Once the jobSize is smaller than the window size,
* it will result in compression ratio degradation.
* NOTE 1: rsyncable mode only works when multithreading is enabled.
* NOTE 2: rsyncable performs poorly in combination with long range mode,
* since it will decrease the effectiveness of synchronization points,
* though mileage may vary.
* NOTE 3: Rsyncable mode limits maximum compression speed to ~400 MB/s.
* If the selected compression level is already running significantly slower,
* the overall speed won't be significantly impacted.
*/
#define ZSTD_c_rsyncable ZSTD_c_experimentalParam1
/* Select a compression format.
* The value must be of type ZSTD_format_e.
* See ZSTD_format_e enum definition for details */
#define ZSTD_c_format ZSTD_c_experimentalParam2
/*! ZSTD_CCtx_refCDict() : /* Force back-reference distances to remain < windowSize,
* Reference a prepared dictionary, to be used for all next compression jobs. * even when referencing into Dictionary content (default:0) */
* Note that compression parameters are enforced from within CDict, #define ZSTD_c_forceMaxWindow ZSTD_c_experimentalParam3
* and supercede any compression parameter previously set within CCtx.
* The dictionary will remain valid for future compression jobs using same CCtx. /* Controls whether the contents of a CDict
* are used in place, or copied into the working context.
* Accepts values from the ZSTD_dictAttachPref_e enum.
* See the comments on that enum for an explanation of the feature. */
#define ZSTD_c_forceAttachDict ZSTD_c_experimentalParam4
/*! ZSTD_CCtx_getParameter() :
* Get the requested compression parameter value, selected by enum ZSTD_cParameter,
* and store it into int* value.
* @return : 0, or an error code (which can be tested with ZSTD_isError()).
*/
ZSTDLIB_API size_t ZSTD_CCtx_getParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int* value);
/*! ZSTD_CCtx_params :
* Quick howto :
* - ZSTD_createCCtxParams() : Create a ZSTD_CCtx_params structure
* - ZSTD_CCtxParam_setParameter() : Push parameters one by one into
* an existing ZSTD_CCtx_params structure.
* This is similar to
* ZSTD_CCtx_setParameter().
* - ZSTD_CCtx_setParametersUsingCCtxParams() : Apply parameters to
* an existing CCtx.
* These parameters will be applied to
* all subsequent frames.
* - ZSTD_compressStream2() : Do compression using the CCtx.
* - ZSTD_freeCCtxParams() : Free the memory.
*
* This can be used with ZSTD_estimateCCtxSize_advanced_usingCCtxParams()
* for static allocation of CCtx for single-threaded compression.
*/
ZSTDLIB_API ZSTD_CCtx_params* ZSTD_createCCtxParams(void);
ZSTDLIB_API size_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params);
/*! ZSTD_CCtxParams_reset() :
* Reset params to default values.
*/
ZSTDLIB_API size_t ZSTD_CCtxParams_reset(ZSTD_CCtx_params* params);
/*! ZSTD_CCtxParams_init() :
* Initializes the compression parameters of cctxParams according to
* compression level. All other parameters are reset to their default values.
*/
ZSTDLIB_API size_t ZSTD_CCtxParams_init(ZSTD_CCtx_params* cctxParams, int compressionLevel);
/*! ZSTD_CCtxParams_init_advanced() :
* Initializes the compression and frame parameters of cctxParams according to
* params. All other parameters are reset to their default values.
*/
ZSTDLIB_API size_t ZSTD_CCtxParams_init_advanced(ZSTD_CCtx_params* cctxParams, ZSTD_parameters params);
/*! ZSTD_CCtxParam_setParameter() :
* Similar to ZSTD_CCtx_setParameter.
* Set one compression parameter, selected by enum ZSTD_cParameter.
* Parameters must be applied to a ZSTD_CCtx using ZSTD_CCtx_setParametersUsingCCtxParams().
* @result : 0, or an error code (which can be tested with ZSTD_isError()). * @result : 0, or an error code (which can be tested with ZSTD_isError()).
* Special : adding a NULL CDict means "return to no-dictionary mode". */
* Note 1 : Currently, only one dictionary can be managed. ZSTDLIB_API size_t ZSTD_CCtxParam_setParameter(ZSTD_CCtx_params* params, ZSTD_cParameter param, int value);
* Adding a new dictionary effectively "discards" any previous one.
* Note 2 : CDict is just referenced, its lifetime must outlive CCtx. */
ZSTDLIB_API size_t ZSTD_CCtx_refCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict);
/*! ZSTD_CCtx_refPrefix() : /*! ZSTD_CCtxParam_getParameter() :
* Reference a prefix (single-usage dictionary) for next compression job. * Similar to ZSTD_CCtx_getParameter.
* Decompression will need same prefix to properly regenerate data. * Get the requested value of one compression parameter, selected by enum ZSTD_cParameter.
* Compressing with a prefix is similar in outcome as performing a diff and compressing it,
* but performs much faster, especially during decompression (compression speed is tunable with compression level).
* Note that prefix is **only used once**. Tables are discarded at end of compression job (ZSTD_e_end).
* @result : 0, or an error code (which can be tested with ZSTD_isError()). * @result : 0, or an error code (which can be tested with ZSTD_isError()).
* Special: Adding any prefix (including NULL) invalidates any previous prefix or dictionary */
* Note 1 : Prefix buffer is referenced. It **must** outlive compression job. ZSTDLIB_API size_t ZSTD_CCtxParam_getParameter(ZSTD_CCtx_params* params, ZSTD_cParameter param, int* value);
* Its contain must remain unmodified up to end of compression (ZSTD_e_end).
* Note 2 : If the intention is to diff some large src data blob with some prior version of itself,
* ensure that the window size is large enough to contain the entire source.
* See ZSTD_p_windowLog.
* Note 3 : Referencing a prefix involves building tables, which are dependent on compression parameters.
* It's a CPU consuming operation, with non-negligible impact on latency.
* If there is a need to use same prefix multiple times, consider loadDictionary instead.
* Note 4 : By default, the prefix is treated as raw content (ZSTD_dm_rawContent).
* Use ZSTD_CCtx_refPrefix_advanced() to alter dictMode. */
ZSTDLIB_API size_t ZSTD_CCtx_refPrefix(ZSTD_CCtx* cctx,
const void* prefix, size_t prefixSize);
ZSTDLIB_API size_t ZSTD_CCtx_refPrefix_advanced(ZSTD_CCtx* cctx,
const void* prefix, size_t prefixSize,
ZSTD_dictContentType_e dictContentType);
/*! ZSTD_CCtx_reset() : /*! ZSTD_CCtx_setParametersUsingCCtxParams() :
* Return a CCtx to clean state. * Apply a set of ZSTD_CCtx_params to the compression context.
* Useful after an error, or to interrupt an ongoing compression job and start a new one. * This can be done even after compression is started,
* Any internal data not yet flushed is cancelled. * if nbWorkers==0, this will have no impact until a new compression is started.
* The parameters and dictionary are kept unchanged, to reset them use ZSTD_CCtx_resetParameters(). * if nbWorkers>=1, new parameters will be picked up at next job,
* with a few restrictions (windowLog, pledgedSrcSize, nbWorkers, jobSize, and overlapLog are not updated).
*/ */
ZSTDLIB_API void ZSTD_CCtx_reset(ZSTD_CCtx* cctx); ZSTDLIB_API size_t ZSTD_CCtx_setParametersUsingCCtxParams(
ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params);
/*! ZSTD_CCtx_resetParameters() : /*! ZSTD_compressStream2_simpleArgs() :
* All parameters are back to default values (compression level is ZSTD_CLEVEL_DEFAULT). * Same as ZSTD_compressStream2(),
* Dictionary (if any) is dropped. * but using only integral types as arguments.
* Resetting parameters is only possible during frame initialization (before starting compression). * This variant might be helpful for binders from dynamic languages
* To reset the context use ZSTD_CCtx_reset(). * which have troubles handling structures containing memory pointers.
* @return 0 or an error code (which can be checked with ZSTD_isError()).
*/ */
ZSTDLIB_API size_t ZSTD_CCtx_resetParameters(ZSTD_CCtx* cctx); ZSTDLIB_API size_t ZSTD_compressStream2_simpleArgs (
ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity, size_t* dstPos,
const void* src, size_t srcSize, size_t* srcPos,
ZSTD_EndDirective endOp);
/***************************************
* Advanced decompression functions
***************************************/
typedef enum { /*! ZSTD_isFrame() :
ZSTD_e_continue=0, /* collect more data, encoder decides when to output compressed result, for optimal conditions */ * Tells if the content of `buffer` starts with a valid Frame Identifier.
ZSTD_e_flush, /* flush any data provided so far - frame will continue, future data can still reference previous data for better compression */ * Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
ZSTD_e_end /* flush any remaining data and close current frame. Any additional data starts a new frame. */ * Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled.
} ZSTD_EndDirective; * Note 3 : Skippable Frame Identifiers are considered valid. */
ZSTDLIB_API unsigned ZSTD_isFrame(const void* buffer, size_t size);
/*! ZSTD_compress_generic() : /*! ZSTD_createDDict_byReference() :
* Behave about the same as ZSTD_compressStream. To note : * Create a digested dictionary, ready to start decompression operation without startup delay.
* - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_setParameter() * Dictionary content is referenced, and therefore stays in dictBuffer.
* - Compression parameters cannot be changed once compression is started. * It is important that dictBuffer outlives DDict,
* - outpot->pos must be <= dstCapacity, input->pos must be <= srcSize * it must remain read accessible throughout the lifetime of DDict */
* - outpot->pos and input->pos will be updated. They are guaranteed to remain below their respective limit. ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize);
* - In single-thread mode (default), function is blocking : it completed its job before returning to caller.
* - In multi-thread mode, function is non-blocking : it just acquires a copy of input, and distribute job to internal worker threads,
* and then immediately returns, just indicating that there is some data remaining to be flushed. /*! ZSTD_getDictID_fromDict() :
* The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte. * Provides the dictID stored within dictionary.
* - Exception : in multi-threading mode, if the first call requests a ZSTD_e_end directive, it is blocking : it will complete compression before giving back control to caller. * if @return == 0, the dictionary is not conformant with Zstandard specification.
* - @return provides a minimum amount of data remaining to be flushed from internal buffers * It can still be loaded, but as a content-only dictionary. */
* or an error code, which can be tested using ZSTD_isError(). ZSTDLIB_API unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize);
* if @return != 0, flush is not fully completed, there is still some data left within internal buffers.
* This is useful for ZSTD_e_flush, since in this case more flushes are necessary to empty all buffers. /*! ZSTD_getDictID_fromDDict() :
* For ZSTD_e_end, @return == 0 when internal buffers are fully flushed and frame is completed. * Provides the dictID of the dictionary loaded into `ddict`.
* - after a ZSTD_e_end directive, if internal buffer is not fully flushed (@return != 0), * If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.
* only ZSTD_e_end or ZSTD_e_flush operations are allowed. * Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */
* Before starting a new compression job, or changing compression parameters, ZSTDLIB_API unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict);
* it is required to fully flush internal buffers.
/*! ZSTD_getDictID_fromFrame() :
* Provides the dictID required to decompressed the frame stored within `src`.
* If @return == 0, the dictID could not be decoded.
* This could for one of the following reasons :
* - The frame does not require a dictionary to be decoded (most common case).
* - The frame was built with dictID intentionally removed. Whatever dictionary is necessary is a hidden information.
* Note : this use case also happens when using a non-conformant dictionary.
* - `srcSize` is too small, and as a result, the frame header could not be decoded (only possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`).
* - This is not a Zstandard frame.
* When identifying the exact failure cause, it's possible to use ZSTD_getFrameHeader(), which will provide a more precise error code. */
ZSTDLIB_API unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize);
/*! ZSTD_DCtx_loadDictionary_byReference() :
* Same as ZSTD_DCtx_loadDictionary(),
* but references `dict` content instead of copying it into `dctx`.
* This saves memory if `dict` remains around.,
* However, it's imperative that `dict` remains accessible (and unmodified) while being used, so it must outlive decompression. */
ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
/*! ZSTD_DCtx_loadDictionary_advanced() :
* Same as ZSTD_DCtx_loadDictionary(),
* but gives direct control over
* how to load the dictionary (by copy ? by reference ?)
* and how to interpret it (automatic ? force raw mode ? full mode only ?). */
ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType);
/*! ZSTD_DCtx_refPrefix_advanced() :
* Same as ZSTD_DCtx_refPrefix(), but gives finer control over
* how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?) */
ZSTDLIB_API size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType);
/*! ZSTD_DCtx_setMaxWindowSize() :
* Refuses allocating internal buffers for frames requiring a window size larger than provided limit.
* This protects a decoder context from reserving too much memory for itself (potential attack scenario).
* This parameter is only useful in streaming mode, since no internal buffer is allocated in single-pass mode.
* By default, a decompression context accepts all window sizes <= (1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT)
* @return : 0, or an error code (which can be tested using ZSTD_isError()).
*/
ZSTDLIB_API size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize);
/* ZSTD_d_format
* experimental parameter,
* allowing selection between ZSTD_format_e input compression formats
*/
#define ZSTD_d_format ZSTD_d_experimentalParam1
/*! ZSTD_DCtx_setFormat() :
* Instruct the decoder context about what kind of data to decode next.
* This instruction is mandatory to decode data without a fully-formed header,
* such ZSTD_f_zstd1_magicless for example.
* @return : 0, or an error code (which can be tested using ZSTD_isError()). */
ZSTDLIB_API size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format);
/*! ZSTD_decompressStream_simpleArgs() :
* Same as ZSTD_decompressStream(),
* but using only integral types as arguments.
* This can be helpful for binders from dynamic languages
* which have troubles handling structures containing memory pointers.
*/
ZSTDLIB_API size_t ZSTD_decompressStream_simpleArgs (
ZSTD_DCtx* dctx,
void* dst, size_t dstCapacity, size_t* dstPos,
const void* src, size_t srcSize, size_t* srcPos);
/********************************************************************
* Advanced streaming functions
* Warning : most of these functions are now redundant with the Advanced API.
* Once Advanced API reaches "stable" status,
* redundant functions will be deprecated, and then at some point removed.
********************************************************************/
/*===== Advanced Streaming compression functions =====*/
ZSTDLIB_API size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize); /**< pledgedSrcSize must be correct. If it is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs, "0" also disables frame content size field. It may be enabled in the future. */
ZSTDLIB_API size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel); /**< creates of an internal CDict (incompatible with static CCtx), except if dict == NULL or dictSize < 8, in which case no dict is used. Note: dict is loaded with ZSTD_dm_auto (treated as a full zstd dictionary if it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy.*/
ZSTDLIB_API size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs, const void* dict, size_t dictSize,
ZSTD_parameters params, unsigned long long pledgedSrcSize); /**< pledgedSrcSize must be correct. If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */
ZSTDLIB_API size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict); /**< note : cdict will just be referenced, and must outlive compression session */
ZSTDLIB_API size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams, unsigned long long pledgedSrcSize); /**< same as ZSTD_initCStream_usingCDict(), with control over frame parameters. pledgedSrcSize must be correct. If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. */
/*! ZSTD_resetCStream() :
* start a new frame, using same parameters from previous frame.
* This is typically useful to skip dictionary loading stage, since it will re-use it in-place.
* Note that zcs must be init at least once before using ZSTD_resetCStream().
* If pledgedSrcSize is not known at reset time, use macro ZSTD_CONTENTSIZE_UNKNOWN.
* If pledgedSrcSize > 0, its value must be correct, as it will be written in header, and controlled at the end.
* For the time being, pledgedSrcSize==0 is interpreted as "srcSize unknown" for compatibility with older programs,
* but it will change to mean "empty" in future version, so use macro ZSTD_CONTENTSIZE_UNKNOWN instead.
* @return : 0, or an error code (which can be tested using ZSTD_isError())
*/
ZSTDLIB_API size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize);
typedef struct {
unsigned long long ingested; /* nb input bytes read and buffered */
unsigned long long consumed; /* nb input bytes actually compressed */
unsigned long long produced; /* nb of compressed bytes generated and buffered */
unsigned long long flushed; /* nb of compressed bytes flushed : not provided; can be tracked from caller side */
unsigned currentJobID; /* MT only : latest started job nb */
unsigned nbActiveWorkers; /* MT only : nb of workers actively compressing at probe time */
} ZSTD_frameProgression;
/* ZSTD_getFrameProgression() :
* tells how much data has been ingested (read from input)
* consumed (input actually compressed) and produced (output) for current frame.
* Note : (ingested - consumed) is amount of input data buffered internally, not yet compressed.
* Aggregates progression inside active worker threads.
*/
ZSTDLIB_API ZSTD_frameProgression ZSTD_getFrameProgression(const ZSTD_CCtx* cctx);
/*! ZSTD_toFlushNow() :
* Tell how many bytes are ready to be flushed immediately.
* Useful for multithreading scenarios (nbWorkers >= 1).
* Probe the oldest active job, defined as oldest job not yet entirely flushed,
* and check its output buffer.
* @return : amount of data stored in oldest job and ready to be flushed immediately.
* if @return == 0, it means either :
* + there is no active job (could be checked with ZSTD_frameProgression()), or
* + oldest job is still actively compressing data,
* but everything it has produced has also been flushed so far,
* therefore flush speed is limited by production speed of oldest job
* irrespective of the speed of concurrent (and newer) jobs.
*/ */
ZSTDLIB_API size_t ZSTD_compress_generic (ZSTD_CCtx* cctx, ZSTDLIB_API size_t ZSTD_toFlushNow(ZSTD_CCtx* cctx);
ZSTD_outBuffer* output,
ZSTD_inBuffer* input,
ZSTD_EndDirective endOp);
/*! ZSTD_compress_generic_simpleArgs() : /*===== Advanced Streaming decompression functions =====*/
* Same as ZSTD_compress_generic(), ZSTDLIB_API size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize); /**< note: no dictionary will be used if dict == NULL or dictSize < 8 */
* but using only integral types as arguments. ZSTDLIB_API size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* zds, const ZSTD_DDict* ddict); /**< note : ddict is referenced, it must outlive decompression session */
* Argument list is larger than ZSTD_{in,out}Buffer, ZSTDLIB_API size_t ZSTD_resetDStream(ZSTD_DStream* zds); /**< re-use decompression parameters from previous init; saves dictionary loading */
* but can be helpful for binders from dynamic languages
* which have troubles handling structures containing memory pointers.
*/
ZSTDLIB_API size_t ZSTD_compress_generic_simpleArgs (
ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity, size_t* dstPos,
const void* src, size_t srcSize, size_t* srcPos,
ZSTD_EndDirective endOp);
/*! ZSTD_CCtx_params : /*********************************************************************
* Quick howto : * Buffer-less and synchronous inner streaming functions
* - ZSTD_createCCtxParams() : Create a ZSTD_CCtx_params structure
* - ZSTD_CCtxParam_setParameter() : Push parameters one by one into
* an existing ZSTD_CCtx_params structure.
* This is similar to
* ZSTD_CCtx_setParameter().
* - ZSTD_CCtx_setParametersUsingCCtxParams() : Apply parameters to
* an existing CCtx.
* These parameters will be applied to
* all subsequent compression jobs.
* - ZSTD_compress_generic() : Do compression using the CCtx.
* - ZSTD_freeCCtxParams() : Free the memory.
* *
* This can be used with ZSTD_estimateCCtxSize_advanced_usingCCtxParams() * This is an advanced API, giving full control over buffer management, for users which need direct control over memory.
* for static allocation for single-threaded compression. * But it's also a complex one, with several restrictions, documented below.
*/ * Prefer normal streaming API for an easier experience.
ZSTDLIB_API ZSTD_CCtx_params* ZSTD_createCCtxParams(void); ********************************************************************* */
ZSTDLIB_API size_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params);
/**
Buffer-less streaming compression (synchronous mode)
/*! ZSTD_CCtxParams_reset() : A ZSTD_CCtx object is required to track streaming operations.
* Reset params to default values. Use ZSTD_createCCtx() / ZSTD_freeCCtx() to manage resource.
*/ ZSTD_CCtx object can be re-used multiple times within successive compression operations.
ZSTDLIB_API size_t ZSTD_CCtxParams_reset(ZSTD_CCtx_params* params);
/*! ZSTD_CCtxParams_init() : Start by initializing a context.
* Initializes the compression parameters of cctxParams according to Use ZSTD_compressBegin(), or ZSTD_compressBegin_usingDict() for dictionary compression,
* compression level. All other parameters are reset to their default values. or ZSTD_compressBegin_advanced(), for finer parameter control.
*/ It's also possible to duplicate a reference context which has already been initialized, using ZSTD_copyCCtx()
ZSTDLIB_API size_t ZSTD_CCtxParams_init(ZSTD_CCtx_params* cctxParams, int compressionLevel);
/*! ZSTD_CCtxParams_init_advanced() : Then, consume your input using ZSTD_compressContinue().
* Initializes the compression and frame parameters of cctxParams according to There are some important considerations to keep in mind when using this advanced function :
* params. All other parameters are reset to their default values. - ZSTD_compressContinue() has no internal buffer. It uses externally provided buffers only.
*/ - Interface is synchronous : input is consumed entirely and produces 1+ compressed blocks.
ZSTDLIB_API size_t ZSTD_CCtxParams_init_advanced(ZSTD_CCtx_params* cctxParams, ZSTD_parameters params); - Caller must ensure there is enough space in `dst` to store compressed data under worst case scenario.
Worst case evaluation is provided by ZSTD_compressBound().
ZSTD_compressContinue() doesn't guarantee recover after a failed compression.
- ZSTD_compressContinue() presumes prior input ***is still accessible and unmodified*** (up to maximum distance size, see WindowLog).
It remembers all previous contiguous blocks, plus one separated memory segment (which can itself consists of multiple contiguous blocks)
- ZSTD_compressContinue() detects that prior input has been overwritten when `src` buffer overlaps.
In which case, it will "discard" the relevant memory section from its history.
Finish a frame with ZSTD_compressEnd(), which will write the last block(s) and optional checksum.
It's possible to use srcSize==0, in which case, it will write a final empty block to end the frame.
Without last block mark, frames are considered unfinished (hence corrupted) by compliant decoders.
/*! ZSTD_CCtxParam_setParameter() : `ZSTD_CCtx` object can be re-used (ZSTD_compressBegin()) to compress again.
* Similar to ZSTD_CCtx_setParameter.
* Set one compression parameter, selected by enum ZSTD_cParameter.
* Parameters must be applied to a ZSTD_CCtx using ZSTD_CCtx_setParametersUsingCCtxParams().
* Note : when `value` is an enum, cast it to unsigned for proper type checking.
* @result : 0, or an error code (which can be tested with ZSTD_isError()).
*/ */
ZSTDLIB_API size_t ZSTD_CCtxParam_setParameter(ZSTD_CCtx_params* params, ZSTD_cParameter param, unsigned value);
/*! ZSTD_CCtxParam_getParameter() : /*===== Buffer-less streaming compression functions =====*/
* Similar to ZSTD_CCtx_getParameter. ZSTDLIB_API size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel);
* Get the requested value of one compression parameter, selected by enum ZSTD_cParameter. ZSTDLIB_API size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel);
* @result : 0, or an error code (which can be tested with ZSTD_isError()). ZSTDLIB_API size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize); /**< pledgedSrcSize : If srcSize is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN */
*/ ZSTDLIB_API size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict); /**< note: fails if cdict==NULL */
ZSTDLIB_API size_t ZSTD_CCtxParam_getParameter(ZSTD_CCtx_params* params, ZSTD_cParameter param, unsigned* value); ZSTDLIB_API size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict, ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize); /* compression parameters are already set within cdict. pledgedSrcSize must be correct. If srcSize is not known, use macro ZSTD_CONTENTSIZE_UNKNOWN */
ZSTDLIB_API size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx, unsigned long long pledgedSrcSize); /**< note: if pledgedSrcSize is not known, use ZSTD_CONTENTSIZE_UNKNOWN */
/*! ZSTD_CCtx_setParametersUsingCCtxParams() : ZSTDLIB_API size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
* Apply a set of ZSTD_CCtx_params to the compression context. ZSTDLIB_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
* This can be done even after compression is started,
* if nbWorkers==0, this will have no impact until a new compression is started.
* if nbWorkers>=1, new parameters will be picked up at next job,
* with a few restrictions (windowLog, pledgedSrcSize, nbWorkers, jobSize, and overlapLog are not updated).
*/
ZSTDLIB_API size_t ZSTD_CCtx_setParametersUsingCCtxParams(
ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params);
/* ==================================== */ /*-
/*=== Advanced decompression API ===*/ Buffer-less streaming decompression (synchronous mode)
/* ==================================== */
/* The following API works the same way as the advanced compression API :
* a context is created, parameters are pushed into it one by one,
* then the context can be used to decompress data using an interface similar to the straming API.
*/
/*! ZSTD_DCtx_loadDictionary() : A ZSTD_DCtx object is required to track streaming operations.
* Create an internal DDict from dict buffer, Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it.
* to be used to decompress next frames. A ZSTD_DCtx object can be re-used multiple times.
* @result : 0, or an error code (which can be tested with ZSTD_isError()).
* Special : Adding a NULL (or 0-size) dictionary invalidates any previous dictionary, First typical operation is to retrieve frame parameters, using ZSTD_getFrameHeader().
* meaning "return to no-dictionary mode". Frame header is extracted from the beginning of compressed frame, so providing only the frame's beginning is enough.
* Note 1 : `dict` content will be copied internally. Data fragment must be large enough to ensure successful decoding.
* Use ZSTD_DCtx_loadDictionary_byReference() `ZSTD_frameHeaderSize_max` bytes is guaranteed to always be large enough.
* to reference dictionary content instead. @result : 0 : successful decoding, the `ZSTD_frameHeader` structure is correctly filled.
* In which case, the dictionary buffer must outlive its users. >0 : `srcSize` is too small, please provide at least @result bytes on next attempt.
* Note 2 : Loading a dictionary involves building tables, errorCode, which can be tested using ZSTD_isError().
* which has a non-negligible impact on CPU usage and latency.
* Note 3 : Use ZSTD_DCtx_loadDictionary_advanced() to select
* how dictionary content will be interpreted and loaded.
*/
ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType);
It fills a ZSTD_frameHeader structure with important information to correctly decode the frame,
such as the dictionary ID, content size, or maximum back-reference distance (`windowSize`).
Note that these values could be wrong, either because of data corruption, or because a 3rd party deliberately spoofs false information.
As a consequence, check that values remain within valid application range.
For example, do not allocate memory blindly, check that `windowSize` is within expectation.
Each application can set its own limits, depending on local restrictions.
For extended interoperability, it is recommended to support `windowSize` of at least 8 MB.
/*! ZSTD_DCtx_refDDict() : ZSTD_decompressContinue() needs previous data blocks during decompression, up to `windowSize` bytes.
* Reference a prepared dictionary, to be used to decompress next frames. ZSTD_decompressContinue() is very sensitive to contiguity,
* The dictionary remains active for decompression of future frames using same DCtx. if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place,
* @result : 0, or an error code (which can be tested with ZSTD_isError()). or that previous contiguous segment is large enough to properly handle maximum back-reference distance.
* Note 1 : Currently, only one dictionary can be managed. There are multiple ways to guarantee this condition.
* Referencing a new dictionary effectively "discards" any previous one.
* Special : adding a NULL DDict means "return to no-dictionary mode".
* Note 2 : DDict is just referenced, its lifetime must outlive its usage from DCtx.
*/
ZSTDLIB_API size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);
The most memory efficient way is to use a round buffer of sufficient size.
Sufficient size is determined by invoking ZSTD_decodingBufferSize_min(),
which can @return an error code if required value is too large for current system (in 32-bits mode).
In a round buffer methodology, ZSTD_decompressContinue() decompresses each block next to previous one,
up to the moment there is not enough room left in the buffer to guarantee decoding another full block,
which maximum size is provided in `ZSTD_frameHeader` structure, field `blockSizeMax`.
At which point, decoding can resume from the beginning of the buffer.
Note that already decoded data stored in the buffer should be flushed before being overwritten.
/*! ZSTD_DCtx_refPrefix() : There are alternatives possible, for example using two or more buffers of size `windowSize` each, though they consume more memory.
* Reference a prefix (single-usage dictionary) for next compression job.
* This is the reverse operation of ZSTD_CCtx_refPrefix(),
* and must use the same prefix as the one used during compression.
* Prefix is **only used once**. Reference is discarded at end of frame.
* End of frame is reached when ZSTD_DCtx_decompress_generic() returns 0.
* @result : 0, or an error code (which can be tested with ZSTD_isError()).
* Note 1 : Adding any prefix (including NULL) invalidates any previously set prefix or dictionary
* Note 2 : Prefix buffer is referenced. It **must** outlive decompression job.
* Prefix buffer must remain unmodified up to the end of frame,
* reached when ZSTD_DCtx_decompress_generic() returns 0.
* Note 3 : By default, the prefix is treated as raw content (ZSTD_dm_rawContent).
* Use ZSTD_CCtx_refPrefix_advanced() to alter dictMode.
* Note 4 : Referencing a raw content prefix has almost no cpu nor memory cost.
* A fulldict prefix is more costly though.
*/
ZSTDLIB_API size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx,
const void* prefix, size_t prefixSize);
ZSTDLIB_API size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx,
const void* prefix, size_t prefixSize,
ZSTD_dictContentType_e dictContentType);
Finally, if you control the compression process, you can also ignore all buffer size rules,
as long as the encoder and decoder progress in "lock-step",
aka use exactly the same buffer sizes, break contiguity at the same place, etc.
/*! ZSTD_DCtx_setMaxWindowSize() : Once buffers are setup, start decompression, with ZSTD_decompressBegin().
* Refuses allocating internal buffers for frames requiring a window size larger than provided limit. If decompression requires a dictionary, use ZSTD_decompressBegin_usingDict() or ZSTD_decompressBegin_usingDDict().
* This is useful to prevent a decoder context from reserving too much memory for itself (potential attack scenario).
* This parameter is only useful in streaming mode, since no internal buffer is allocated in direct mode.
* By default, a decompression context accepts all window sizes <= (1 << ZSTD_WINDOWLOG_MAX)
* @return : 0, or an error code (which can be tested using ZSTD_isError()).
*/
ZSTDLIB_API size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize);
Then use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively.
ZSTD_nextSrcSizeToDecompress() tells how many bytes to provide as 'srcSize' to ZSTD_decompressContinue().
ZSTD_decompressContinue() requires this _exact_ amount of bytes, or it will fail.
/*! ZSTD_DCtx_setFormat() : @result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity).
* Instruct the decoder context about what kind of data to decode next. It can be zero : it just means ZSTD_decompressContinue() has decoded some metadata item.
* This instruction is mandatory to decode data without a fully-formed header, It can also be an error code, which can be tested with ZSTD_isError().
* such ZSTD_f_zstd1_magicless for example.
* @return : 0, or an error code (which can be tested using ZSTD_isError()). A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero.
Context can then be reset to start a new decompression.
Note : it's possible to know if next input to present is a header or a block, using ZSTD_nextInputType().
This information is not required to properly decode a frame.
== Special case : skippable frames ==
Skippable frames allow integration of user-defined data into a flow of concatenated frames.
Skippable frames will be ignored (skipped) by decompressor.
The format of skippable frames is as follows :
a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F
b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits
c) Frame Content - any content (User Data) of length equal to Frame Size
For skippable frames ZSTD_getFrameHeader() returns zfhPtr->frameType==ZSTD_skippableFrame.
For skippable frames ZSTD_decompressContinue() always returns 0 : it only skips the content.
*/ */
ZSTDLIB_API size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format);
/*===== Buffer-less streaming decompression functions =====*/
typedef enum { ZSTD_frame, ZSTD_skippableFrame } ZSTD_frameType_e;
typedef struct {
unsigned long long frameContentSize; /* if == ZSTD_CONTENTSIZE_UNKNOWN, it means this field is not available. 0 means "empty" */
unsigned long long windowSize; /* can be very large, up to <= frameContentSize */
unsigned blockSizeMax;
ZSTD_frameType_e frameType; /* if == ZSTD_skippableFrame, frameContentSize is the size of skippable content */
unsigned headerSize;
unsigned dictID;
unsigned checksumFlag;
} ZSTD_frameHeader;
/** ZSTD_getFrameHeader() :
* decode Frame Header, or requires larger `srcSize`.
* @return : 0, `zfhPtr` is correctly filled,
* >0, `srcSize` is too small, value is wanted `srcSize` amount,
* or an error code, which can be tested using ZSTD_isError() */
ZSTDLIB_API size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize); /**< doesn't consume input */
/*! ZSTD_getFrameHeader_advanced() : /*! ZSTD_getFrameHeader_advanced() :
* same as ZSTD_getFrameHeader(), * same as ZSTD_getFrameHeader(),
* with added capability to select a format (like ZSTD_f_zstd1_magicless) */ * with added capability to select a format (like ZSTD_f_zstd1_magicless) */
ZSTDLIB_API size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, ZSTDLIB_API size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format);
const void* src, size_t srcSize, ZSTD_format_e format); ZSTDLIB_API size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize); /**< when frame content size is not known, pass in frameContentSize == ZSTD_CONTENTSIZE_UNKNOWN */
/*! ZSTD_decompress_generic() :
* Behave the same as ZSTD_decompressStream.
* Decompression parameters cannot be changed once decompression is started.
* @return : an error code, which can be tested using ZSTD_isError()
* if >0, a hint, nb of expected input bytes for next invocation.
* `0` means : a frame has just been fully decoded and flushed.
*/
ZSTDLIB_API size_t ZSTD_decompress_generic(ZSTD_DCtx* dctx,
ZSTD_outBuffer* output,
ZSTD_inBuffer* input);
ZSTDLIB_API size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx);
ZSTDLIB_API size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
ZSTDLIB_API size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);
/*! ZSTD_decompress_generic_simpleArgs() : ZSTDLIB_API size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx);
* Same as ZSTD_decompress_generic(), ZSTDLIB_API size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
* but using only integral types as arguments.
* Argument list is larger than ZSTD_{in,out}Buffer,
* but can be helpful for binders from dynamic languages
* which have troubles handling structures containing memory pointers.
*/
ZSTDLIB_API size_t ZSTD_decompress_generic_simpleArgs (
ZSTD_DCtx* dctx,
void* dst, size_t dstCapacity, size_t* dstPos,
const void* src, size_t srcSize, size_t* srcPos);
/* misc */
ZSTDLIB_API void ZSTD_copyDCtx(ZSTD_DCtx* dctx, const ZSTD_DCtx* preparedDCtx);
typedef enum { ZSTDnit_frameHeader, ZSTDnit_blockHeader, ZSTDnit_block, ZSTDnit_lastBlock, ZSTDnit_checksum, ZSTDnit_skippableFrame } ZSTD_nextInputType_e;
ZSTDLIB_API ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx);
/*! ZSTD_DCtx_reset() :
* Return a DCtx to clean state.
* If a decompression was ongoing, any internal data not yet flushed is cancelled.
* All parameters are back to default values, including sticky ones.
* Dictionary (if any) is dropped.
* Parameters can be modified again after a reset.
*/
ZSTDLIB_API void ZSTD_DCtx_reset(ZSTD_DCtx* dctx);
/* ============================ */ /* ============================ */
/** Block level API */ /** Block level API */
/* ============================ */ /* ============================ */
/*! /*!
Block functions produce and decode raw zstd blocks, without frame metadata. Block functions produce and decode raw zstd blocks, without frame metadata.
Frame metadata cost is typically ~18 bytes, which can be non-negligible for very small blocks (< 100 bytes). Frame metadata cost is typically ~18 bytes, which can be non-negligible for very small blocks (< 100 bytes).
User will have to take in charge required information to regenerate data, such as compressed and content sizes. User will have to take in charge required information to regenerate data, such as compressed and content sizes.
A few rules to respect : A few rules to respect :
- Compressing and decompressing require a context structure - Compressing and decompressing require a context structure
+ Use ZSTD_createCCtx() and ZSTD_createDCtx() + Use ZSTD_createCCtx() and ZSTD_createDCtx()
- It is necessary to init context before starting - It is necessary to init context before starting
+ compression : any ZSTD_compressBegin*() variant, including with dictionary + compression : any ZSTD_compressBegin*() variant, including with dictionary
+ decompression : any ZSTD_decompressBegin*() variant, including with dictionary + decompression : any ZSTD_decompressBegin*() variant, including with dictionary
+ copyCCtx() and copyDCtx() can be used too + copyCCtx() and copyDCtx() can be used too
- Block size is limited, it must be <= ZSTD_getBlockSize() <= ZSTD_BLOCKSIZE_MAX == 128 KB - Block size is limited, it must be <= ZSTD_getBlockSize() <= ZSTD_BLOCKSIZE_MAX == 128 KB
+ If input is larger than a block size, it's necessary to split input data into multiple blocks + If input is larger than a block size, it's necessary to split input data into multiple blocks
+ For inputs larger than a single block size, consider using the regular ZSTD_compress() instead. + For inputs larger than a single block, really consider using regular ZSTD_compress() instead.
Frame metadata is not that costly, and quickly becomes negligible as source size grows larger. Frame metadata is not that costly, and quickly becomes negligible as source size grows larger.
- When a block is considered not compressible enough, ZSTD_compressBlock() result will be zero. - When a block is considered not compressible enough, ZSTD_compressBlock() result will be zero.
In which case, nothing is produced into `dst`. In which case, nothing is produced into `dst` !
+ User must test for such outcome and deal directly with uncompressed data + User must test for such outcome and deal directly with uncompressed data
+ ZSTD_decompressBlock() doesn't accept uncompressed data as input !!! + ZSTD_decompressBlock() doesn't accept uncompressed data as input !!!
+ In case of multiple successive blocks, should some of them be uncompressed, + In case of multiple successive blocks, should some of them be uncompressed,
decoder must be informed of their existence in order to follow proper history. decoder must be informed of their existence in order to follow proper history.
Use ZSTD_insertBlock() for such a case. Use ZSTD_insertBlock() for such a case.
*/ */
/*===== Raw zstd block functions =====*/ /*===== Raw zstd block functions =====*/

contrib/python-zstandard/zstd_cffi.py

  • This file was moved to contrib/python-zstandard/zstandard/cffi.py.

tests/test-check-py3-compat.t

#if py3 #if py3
$ testrepohg files 'set:(**.py) - grep(pygments)' \ $ testrepohg files 'set:(**.py) - grep(pygments)' \
> -X hgdemandimport/demandimportpy2.py \ > -X hgdemandimport/demandimportpy2.py \
> -X hgext/fsmonitor/pywatchman \ > -X hgext/fsmonitor/pywatchman \
> -X mercurial/cffi \ > -X mercurial/cffi \
> -X mercurial/thirdparty \ > -X mercurial/thirdparty \
> | sed 's|\\|/|g' | xargs "$PYTHON" contrib/check-py3-compat.py \ > | sed 's|\\|/|g' | xargs "$PYTHON" contrib/check-py3-compat.py \
> | sed 's/[0-9][0-9]*)$/*)/' > | sed 's/[0-9][0-9]*)$/*)/'
contrib/python-zstandard/tests/test_compressor.py:324: SyntaxWarning: invalid escape sequence \( (py38 !)
with self.assertRaisesRegexp(zstd.ZstdError, 'cannot call compress\(\) after compressor'): (py38 !)
contrib/python-zstandard/tests/test_compressor.py:1329: SyntaxWarning: invalid escape sequence \( (py38 !)
'cannot call compress\(\) after compression finished'): (py38 !)
contrib/python-zstandard/tests/test_compressor.py:1341: SyntaxWarning: invalid escape sequence \( (py38 !)
'cannot call flush\(\) after compression finished'): (py38 !)
contrib/python-zstandard/tests/test_compressor.py:1353: SyntaxWarning: invalid escape sequence \( (py38 !)
'cannot call finish\(\) after compression finished'): (py38 !)
hgext/convert/transport.py: error importing: <*Error> No module named 'svn.client' (error at transport.py:*) (glob) (?) hgext/convert/transport.py: error importing: <*Error> No module named 'svn.client' (error at transport.py:*) (glob) (?)
hgext/infinitepush/sqlindexapi.py: error importing: <*Error> No module named 'mysql' (error at sqlindexapi.py:*) (glob) (?) hgext/infinitepush/sqlindexapi.py: error importing: <*Error> No module named 'mysql' (error at sqlindexapi.py:*) (glob) (?)
mercurial/scmwindows.py: error importing: <ValueError> _type_ 'v' not supported (error at win32.py:*) (no-windows !) mercurial/scmwindows.py: error importing: <ValueError> _type_ 'v' not supported (error at win32.py:*) (no-windows !)
mercurial/win32.py: error importing: <ValueError> _type_ 'v' not supported (error at win32.py:*) (no-windows !) mercurial/win32.py: error importing: <ValueError> _type_ 'v' not supported (error at win32.py:*) (no-windows !)
mercurial/windows.py: error importing: <ModuleNotFoundError> No module named 'msvcrt' (error at windows.py:*) (no-windows !) mercurial/windows.py: error importing: <ModuleNotFoundError> No module named 'msvcrt' (error at windows.py:*) (no-windows !)
mercurial/posix.py: error importing: <ModuleNotFoundError> No module named 'fcntl' (error at posix.py:*) (windows !) mercurial/posix.py: error importing: <ModuleNotFoundError> No module named 'fcntl' (error at posix.py:*) (windows !)
mercurial/scmposix.py: error importing: <ModuleNotFoundError> No module named 'fcntl' (error at scmposix.py:*) (windows !) mercurial/scmposix.py: error importing: <ModuleNotFoundError> No module named 'fcntl' (error at scmposix.py:*) (windows !)
#endif #endif
#if py3 pygments #if py3 pygments
$ testrepohg files 'set:(**.py) and grep(pygments)' | sed 's|\\|/|g' \ $ testrepohg files 'set:(**.py) and grep(pygments)' | sed 's|\\|/|g' \
> | xargs "$PYTHON" contrib/check-py3-compat.py \ > | xargs "$PYTHON" contrib/check-py3-compat.py \
> | sed 's/[0-9][0-9]*)$/*)/' > | sed 's/[0-9][0-9]*)$/*)/'
#endif #endif

tests/test-http-api-httpv2.t

s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 11\r\n s> 11\r\n
s> \t\x00\x00\x01\x00\x02\x01\x92 s> \t\x00\x00\x01\x00\x02\x01\x92
s> Hzstd-8mb s> Hzstd-8mb
s> \r\n s> \r\n
s> 25\r\n s> 25\r\n
s> \x1d\x00\x00\x01\x00\x02\x042 s> \x1d\x00\x00\x01\x00\x02\x042
s> (\xb5/\xfd\x00P\xa4\x00\x00p\xa1FstatusBok\x81T\x00\x01\x00\tP\x02 s> (\xb5/\xfd\x00X\xa4\x00\x00p\xa1FstatusBok\x81T\x00\x01\x00\tP\x02
s> \r\n s> \r\n
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: [ response: [
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
] ]
(sent 2 HTTP requests and * bytes; received * bytes in responses) (glob) (sent 2 HTTP requests and * bytes; received * bytes in responses) (glob)
#endif #endif
$ cat error.log $ cat error.log

tests/test-http-protocol.t

server: testing stub value server: testing stub value
transfer-encoding: chunked transfer-encoding: chunked
#if zstd #if zstd
zstd is used if available zstd is used if available
$ get-with-headers.py --hgproto '0.2 comp=zstd' $LOCALIP:$HGPORT '?cmd=getbundle&heads=e93700bd72895c5addab234c56d4024b487a362f&common=0000000000000000000000000000000000000000' > resp $ get-with-headers.py --hgproto '0.2 comp=zstd' $LOCALIP:$HGPORT '?cmd=getbundle&heads=e93700bd72895c5addab234c56d4024b487a362f&common=0000000000000000000000000000000000000000' > resp
$ f --size --hexdump --bytes 36 --sha1 resp $ f --size --hexdump --bytes 36 --sha1 resp
resp: size=248, sha1=4d8d8f87fb82bd542ce52881fdc94f850748 resp: size=248, sha1=f11b5c098c638068b3d5fe2f9e6241bf5228
0000: 32 30 30 20 53 63 72 69 70 74 20 6f 75 74 70 75 |200 Script outpu| 0000: 32 30 30 20 53 63 72 69 70 74 20 6f 75 74 70 75 |200 Script outpu|
0010: 74 20 66 6f 6c 6c 6f 77 73 0a 0a 04 7a 73 74 64 |t follows...zstd| 0010: 74 20 66 6f 6c 6c 6f 77 73 0a 0a 04 7a 73 74 64 |t follows...zstd|
0020: 28 b5 2f fd |(./.| 0020: 28 b5 2f fd |(./.|
#endif #endif
application/mercurial-0.2 is not yet used on non-streaming responses application/mercurial-0.2 is not yet used on non-streaming responses