1 /**

     1 /*

     5  * This source code is licensed under the BSD-style license found in the

     5  * This source code is licensed under both the BSD-style license (found in the

     6  * LICENSE file in the root directory of this source tree. An additional grant

     6  * LICENSE file in the root directory of this source tree) and the GPLv2 (found

     7  * of patent rights can be found in the PATENTS file in the same directory.

     7  * in the COPYING file in the root directory of this source tree).

     8  * You may select, at your option, one of the above-listed licenses.

    18 /* Note : All prototypes defined in this file shall be considered experimental.

    19 /* Note : This is an internal API.

    19  *        There is no guarantee of API continuity (yet) on any of these prototypes */

    20  *        Some methods are still exposed (ZSTDLIB_API),

    21  *        because it used to be the only way to invoke MT compression.

    22  *        Now, it's recommended to use ZSTD_compress_generic() instead.

    23  *        These methods will stop being exposed in a future version */

    22 #include <stddef.h>   /* size_t */

    26 #include <stddef.h>                /* size_t */

    24 #include "zstd.h"     /* ZSTD_inBuffer, ZSTD_outBuffer, ZSTDLIB_API */

    28 #include "zstd.h"            /* ZSTD_inBuffer, ZSTD_outBuffer, ZSTDLIB_API */

    27 /* ===   Simple one-pass functions   === */

    31 /* ===   Memory management   === */

    32 typedef struct ZSTDMT_CCtx_s ZSTDMT_CCtx;

    33 ZSTDLIB_API ZSTDMT_CCtx* ZSTDMT_createCCtx(unsigned nbWorkers);

    34 ZSTDLIB_API ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbWorkers,

    35                                                     ZSTD_customMem cMem);

    36 ZSTDLIB_API size_t ZSTDMT_freeCCtx(ZSTDMT_CCtx* mtctx);

    29 typedef struct ZSTDMT_CCtx_s ZSTDMT_CCtx;

    38 ZSTDLIB_API size_t ZSTDMT_sizeof_CCtx(ZSTDMT_CCtx* mtctx);

    30 ZSTDLIB_API ZSTDMT_CCtx* ZSTDMT_createCCtx(unsigned nbThreads);

    31 ZSTDLIB_API size_t ZSTDMT_freeCCtx(ZSTDMT_CCtx* cctx);

    33 ZSTDLIB_API size_t ZSTDMT_compressCCtx(ZSTDMT_CCtx* cctx,

    40 

    34                            void* dst, size_t dstCapacity,

    41 /* ===   Simple one-pass compression function   === */

    35                      const void* src, size_t srcSize,

    42 

    36                            int compressionLevel);

    43 ZSTDLIB_API size_t ZSTDMT_compressCCtx(ZSTDMT_CCtx* mtctx,

    44                                        void* dst, size_t dstCapacity,

    45                                  const void* src, size_t srcSize,

    46                                        int compressionLevel);

    47 

    42 ZSTDLIB_API size_t ZSTDMT_resetCStream(ZSTDMT_CCtx* mtctx, unsigned long long pledgedSrcSize);    /**< pledgedSrcSize is optional and can be zero == unknown */

    53 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" */

    52 #ifndef ZSTDMT_SECTION_SIZE_MIN

    63 #ifndef ZSTDMT_JOBSIZE_MIN

    53 #  define ZSTDMT_SECTION_SIZE_MIN (1U << 20)   /* 1 MB - Minimum size of each compression job */

    64 #  define ZSTDMT_JOBSIZE_MIN (1U << 20)   /* 1 MB - Minimum size of each compression job */

    56 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 */

    67 ZSTDLIB_API size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx,

    57                                           ZSTD_parameters params, unsigned long long pledgedSrcSize);  /**< pledgedSrcSize is optional and can be zero == unknown */

    68                                            void* dst, size_t dstCapacity,

    69                                      const void* src, size_t srcSize,

    70                                      const ZSTD_CDict* cdict,

    71                                            ZSTD_parameters params,

    72                                            unsigned overlapLog);

    59 /* ZSDTMT_parameter :

    74 ZSTDLIB_API size_t ZSTDMT_initCStream_advanced(ZSTDMT_CCtx* mtctx,

    75                                         const void* dict, size_t dictSize,   /* dict can be released after init, a local copy is preserved within zcs */

    76                                         ZSTD_parameters params,

    77                                         unsigned long long pledgedSrcSize);  /* pledgedSrcSize is optional and can be zero == unknown */

    78 

    79 ZSTDLIB_API size_t ZSTDMT_initCStream_usingCDict(ZSTDMT_CCtx* mtctx,

    80                                         const ZSTD_CDict* cdict,

    81                                         ZSTD_frameParameters fparams,

    82                                         unsigned long long pledgedSrcSize);  /* note : zero means empty */

    83 

    84 /* ZSTDMT_parameter :

    62     ZSTDMT_p_sectionSize,        /* size of input "section". Each section is compressed in parallel. 0 means default, which is dynamically determined within compression functions */

    87     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. */

    63     ZSTDMT_p_overlapSectionLog   /* Log of overlapped section; 0 == no overlap, 6(default) == use 1/8th of window, >=9 == use full window */

    88     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 */

    64 } ZSDTMT_parameter;

    89 } ZSTDMT_parameter;

    68  * The function must be called typically after ZSTD_createCCtx().

    93  * The function must be called typically after ZSTD_createCCtx() but __before ZSTDMT_init*() !__

    71 ZSTDLIB_API size_t ZSTDMT_setMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSDTMT_parameter parameter, unsigned value);

    96 ZSTDLIB_API size_t ZSTDMT_setMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSTDMT_parameter parameter, unsigned value);

    97 

    98 

    99 /*! ZSTDMT_compressStream_generic() :

   100  *  Combines ZSTDMT_compressStream() with optional ZSTDMT_flushStream() or ZSTDMT_endStream()

   101  *  depending on flush directive.

   102  * @return : minimum amount of data still to be flushed

   103  *           0 if fully flushed

   104  *           or an error code

   105  *  note : needs to be init using any ZSTD_initCStream*() variant */

   106 ZSTDLIB_API size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,

   107                                                 ZSTD_outBuffer* output,

   108                                                 ZSTD_inBuffer* input,

   109                                                 ZSTD_EndDirective endOp);

   110 

   111 

   112 /* ========================================================

   113  * ===  Private interface, for use by ZSTD_compress.c   ===

   114  * ===  Not exposed in libzstd. Never invoke directly   ===

   115  * ======================================================== */

   116 

   117 size_t ZSTDMT_CCtxParam_setMTCtxParameter(ZSTD_CCtx_params* params, ZSTDMT_parameter parameter, unsigned value);

   118 

   119 /* ZSTDMT_CCtxParam_setNbWorkers()

   120  * Set nbWorkers, and clamp it.

   121  * Also reset jobSize and overlapLog */

   122 size_t ZSTDMT_CCtxParam_setNbWorkers(ZSTD_CCtx_params* params, unsigned nbWorkers);

   123 

   124 /*! ZSTDMT_updateCParams_whileCompressing() :

   125  *  Updates only a selected set of compression parameters, to remain compatible with current frame.

   126  *  New parameters will be applied to next compression job. */

   127 void ZSTDMT_updateCParams_whileCompressing(ZSTDMT_CCtx* mtctx, const ZSTD_CCtx_params* cctxParams);

   128 

   129 /* ZSTDMT_getNbWorkers():

   130  * @return nb threads currently active in mtctx.

   131  * mtctx must be valid */

   132 unsigned ZSTDMT_getNbWorkers(const ZSTDMT_CCtx* mtctx);

   133 

   134 /* ZSTDMT_getFrameProgression():

   135  * tells how much data has been consumed (input) and produced (output) for current frame.

   136  * able to count progression inside worker threads.

   137  */

   138 ZSTD_frameProgression ZSTDMT_getFrameProgression(ZSTDMT_CCtx* mtctx);

   139 

   140 

   141 /*! ZSTDMT_initCStream_internal() :

   142  *  Private use only. Init streaming operation.

   143  *  expects params to be valid.

   144  *  must receive dict, or cdict, or none, but not both.

   145  *  @return : 0, or an error code */

   146 size_t ZSTDMT_initCStream_internal(ZSTDMT_CCtx* zcs,

   147                     const void* dict, size_t dictSize, ZSTD_dictContentType_e dictContentType,

   148                     const ZSTD_CDict* cdict,

   149                     ZSTD_CCtx_params params, unsigned long long pledgedSrcSize);