zstd/common/huf.h

0001 /* ******************************************************************
0002  * huff0 huffman codec,
0003  * part of Finite State Entropy library
0004  * Copyright (c) Yann Collet, Facebook, Inc.
0005  *
0006  * You can contact the author at :
0007  * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
0008  *
0009  * This source code is licensed under both the BSD-style license (found in the
0010  * LICENSE file in the root directory of this source tree) and the GPLv2 (found
0011  * in the COPYING file in the root directory of this source tree).
0012  * You may select, at your option, one of the above-listed licenses.
0013 ****************************************************************** */
0014
0015
0016 #ifndef HUF_H_298734234
0017 #define HUF_H_298734234
0018
0019 /* *** Dependencies *** */
0020 #include "zstd_deps.h"    /* size_t */
0021
0022
0023 /* *** library symbols visibility *** */
0024 /* Note : when linking with -fvisibility=hidden on gcc, or by default on Visual,
0025  *        HUF symbols remain "private" (internal symbols for library only).
0026  *        Set macro FSE_DLL_EXPORT to 1 if you want HUF symbols visible on DLL interface */
0027 #if defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1) && defined(__GNUC__) && (__GNUC__ >= 4)
0028 #  define HUF_PUBLIC_API __attribute__ ((visibility ("default")))
0029 #elif defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1)   /* Visual expected */
0030 #  define HUF_PUBLIC_API __declspec(dllexport)
0031 #elif defined(FSE_DLL_IMPORT) && (FSE_DLL_IMPORT==1)
0032 #  define HUF_PUBLIC_API __declspec(dllimport)  /* not required, just to generate faster code (saves a function pointer load from IAT and an indirect jump) */
0033 #else
0034 #  define HUF_PUBLIC_API
0035 #endif
0036
0037
0038 /* ========================== */
0039 /* ***  simple functions  *** */
0040 /* ========================== */
0041
0042 /* HUF_compress() :
0043  *  Compress content from buffer 'src', of size 'srcSize', into buffer 'dst'.
0044  * 'dst' buffer must be already allocated.
0045  *  Compression runs faster if `dstCapacity` >= HUF_compressBound(srcSize).
0046  * `srcSize` must be <= `HUF_BLOCKSIZE_MAX` == 128 KB.
0047  * @return : size of compressed data (<= `dstCapacity`).
0048  *  Special values : if return == 0, srcData is not compressible => Nothing is stored within dst !!!
0049  *                   if HUF_isError(return), compression failed (more details using HUF_getErrorName())
0050  */
0051 HUF_PUBLIC_API size_t HUF_compress(void* dst, size_t dstCapacity,
0052                              const void* src, size_t srcSize);
0053
0054 /* HUF_decompress() :
0055  *  Decompress HUF data from buffer 'cSrc', of size 'cSrcSize',
0056  *  into already allocated buffer 'dst', of minimum size 'dstSize'.
0057  * `originalSize` : **must** be the ***exact*** size of original (uncompressed) data.
0058  *  Note : in contrast with FSE, HUF_decompress can regenerate
0059  *         RLE (cSrcSize==1) and uncompressed (cSrcSize==dstSize) data,
0060  *         because it knows size to regenerate (originalSize).
0061  * @return : size of regenerated data (== originalSize),
0062  *           or an error code, which can be tested using HUF_isError()
0063  */
0064 HUF_PUBLIC_API size_t HUF_decompress(void* dst,  size_t originalSize,
0065                                const void* cSrc, size_t cSrcSize);
0066
0067
0068 /* ***   Tool functions *** */
0069 #define HUF_BLOCKSIZE_MAX (128 * 1024)                  /*< maximum input size for a single block compressed with HUF_compress */
0070 HUF_PUBLIC_API size_t HUF_compressBound(size_t size);   /*< maximum compressed size (worst case) */
0071
0072 /* Error Management */
0073 HUF_PUBLIC_API unsigned    HUF_isError(size_t code);       /*< tells if a return value is an error code */
0074 HUF_PUBLIC_API const char* HUF_getErrorName(size_t code);  /*< provides error code string (useful for debugging) */
0075
0076
0077 /* ***   Advanced function   *** */
0078
0079 /* HUF_compress2() :
0080  *  Same as HUF_compress(), but offers control over `maxSymbolValue` and `tableLog`.
0081  * `maxSymbolValue` must be <= HUF_SYMBOLVALUE_MAX .
0082  * `tableLog` must be `<= HUF_TABLELOG_MAX` . */
0083 HUF_PUBLIC_API size_t HUF_compress2 (void* dst, size_t dstCapacity,
0084                                const void* src, size_t srcSize,
0085                                unsigned maxSymbolValue, unsigned tableLog);
0086
0087 /* HUF_compress4X_wksp() :
0088  *  Same as HUF_compress2(), but uses externally allocated `workSpace`.
0089  * `workspace` must have minimum alignment of 4, and be at least as large as HUF_WORKSPACE_SIZE */
0090 #define HUF_WORKSPACE_SIZE ((6 << 10) + 256)
0091 #define HUF_WORKSPACE_SIZE_U32 (HUF_WORKSPACE_SIZE / sizeof(U32))
0092 HUF_PUBLIC_API size_t HUF_compress4X_wksp (void* dst, size_t dstCapacity,
0093                                      const void* src, size_t srcSize,
0094                                      unsigned maxSymbolValue, unsigned tableLog,
0095                                      void* workSpace, size_t wkspSize);
0096
0097 #endif   /* HUF_H_298734234 */
0098
0099 /* ******************************************************************
0100  *  WARNING !!
0101  *  The following section contains advanced and experimental definitions
0102  *  which shall never be used in the context of a dynamic library,
0103  *  because they are not guaranteed to remain stable in the future.
0104  *  Only consider them in association with static linking.
0105  * *****************************************************************/
0106 #if !defined(HUF_H_HUF_STATIC_LINKING_ONLY)
0107 #define HUF_H_HUF_STATIC_LINKING_ONLY
0108
0109 /* *** Dependencies *** */
0110 #include "mem.h"   /* U32 */
0111 #define FSE_STATIC_LINKING_ONLY
0112 #include "fse.h"
0113
0114
0115 /* *** Constants *** */
0116 #define HUF_TABLELOG_MAX      12      /* max runtime value of tableLog (due to static allocation); can be modified up to HUF_ABSOLUTEMAX_TABLELOG */
0117 #define HUF_TABLELOG_DEFAULT  11      /* default tableLog value when none specified */
0118 #define HUF_SYMBOLVALUE_MAX  255
0119
0120 #define HUF_TABLELOG_ABSOLUTEMAX  15  /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */
0121 #if (HUF_TABLELOG_MAX > HUF_TABLELOG_ABSOLUTEMAX)
0122 #  error "HUF_TABLELOG_MAX is too large !"
0123 #endif
0124
0125
0126 /* ****************************************
0127 *  Static allocation
0128 ******************************************/
0129 /* HUF buffer bounds */
0130 #define HUF_CTABLEBOUND 129
0131 #define HUF_BLOCKBOUND(size) (size + (size>>8) + 8)   /* only true when incompressible is pre-filtered with fast heuristic */
0132 #define HUF_COMPRESSBOUND(size) (HUF_CTABLEBOUND + HUF_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
0133
0134 /* static allocation of HUF's Compression Table */
0135 /* this is a private definition, just exposed for allocation and strict aliasing purpose. never EVER access its members directly */
0136 struct HUF_CElt_s {
0137   U16  val;
0138   BYTE nbBits;
0139 };   /* typedef'd to HUF_CElt */
0140 typedef struct HUF_CElt_s HUF_CElt;   /* consider it an incomplete type */
0141 #define HUF_CTABLE_SIZE_U32(maxSymbolValue)   ((maxSymbolValue)+1)   /* Use tables of U32, for proper alignment */
0142 #define HUF_CTABLE_SIZE(maxSymbolValue)       (HUF_CTABLE_SIZE_U32(maxSymbolValue) * sizeof(U32))
0143 #define HUF_CREATE_STATIC_CTABLE(name, maxSymbolValue) \
0144     HUF_CElt name[HUF_CTABLE_SIZE_U32(maxSymbolValue)] /* no final ; */
0145
0146 /* static allocation of HUF's DTable */
0147 typedef U32 HUF_DTable;
0148 #define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<(maxTableLog)))
0149 #define HUF_CREATE_STATIC_DTABLEX1(DTable, maxTableLog) \
0150         HUF_DTable DTable[HUF_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1) * 0x01000001) }
0151 #define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
0152         HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog) * 0x01000001) }
0153
0154
0155 /* ****************************************
0156 *  Advanced decompression functions
0157 ******************************************/
0158 size_t HUF_decompress4X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /*< single-symbol decoder */
0159 #ifndef HUF_FORCE_DECOMPRESS_X1
0160 size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /*< double-symbols decoder */
0161 #endif
0162
0163 size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /*< decodes RLE and uncompressed */
0164 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 */
0165 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 */
0166 size_t HUF_decompress4X1_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /*< single-symbol decoder */
0167 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 */
0168 #ifndef HUF_FORCE_DECOMPRESS_X1
0169 size_t HUF_decompress4X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /*< double-symbols decoder */
0170 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 */
0171 #endif
0172
0173
0174 /* ****************************************
0175  *  HUF detailed API
0176  * ****************************************/
0177
0178 /*! HUF_compress() does the following:
0179  *  1. count symbol occurrence from source[] into table count[] using FSE_count() (exposed within "fse.h")
0180  *  2. (optional) refine tableLog using HUF_optimalTableLog()
0181  *  3. build Huffman table from count using HUF_buildCTable()
0182  *  4. save Huffman table to memory buffer using HUF_writeCTable()
0183  *  5. encode the data stream using HUF_compress4X_usingCTable()
0184  *
0185  *  The following API allows targeting specific sub-functions for advanced tasks.
0186  *  For example, it's possible to compress several blocks using the same 'CTable',
0187  *  or to save and regenerate 'CTable' using external methods.
0188  */
0189 unsigned HUF_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue);
0190 size_t HUF_buildCTable (HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue, unsigned maxNbBits);   /* @return : maxNbBits; CTable and count can overlap. In which case, CTable will overwrite count content */
0191 size_t HUF_writeCTable (void* dst, size_t maxDstSize, const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog);
0192 size_t HUF_writeCTable_wksp(void* dst, size_t maxDstSize, const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog, void* workspace, size_t workspaceSize);
0193 size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable);
0194 size_t HUF_estimateCompressedSize(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue);
0195 int HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue);
0196
0197 typedef enum {
0198    HUF_repeat_none,  /*< Cannot use the previous table */
0199    HUF_repeat_check, /*< Can use the previous table but it must be checked. Note : The previous table must have been constructed by HUF_compress{1, 4}X_repeat */
0200    HUF_repeat_valid  /*< Can use the previous table and it is assumed to be valid */
0201  } HUF_repeat;
0202 /* HUF_compress4X_repeat() :
0203  *  Same as HUF_compress4X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none.
0204  *  If it uses hufTable it does not modify hufTable or repeat.
0205  *  If it doesn't, it sets *repeat = HUF_repeat_none, and it sets hufTable to the table used.
0206  *  If preferRepeat then the old table will always be used if valid. */
0207 size_t HUF_compress4X_repeat(void* dst, size_t dstSize,
0208                        const void* src, size_t srcSize,
0209                        unsigned maxSymbolValue, unsigned tableLog,
0210                        void* workSpace, size_t wkspSize,    /*< `workSpace` must be aligned on 4-bytes boundaries, `wkspSize` must be >= HUF_WORKSPACE_SIZE */
0211                        HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2);
0212
0213 /* HUF_buildCTable_wksp() :
0214  *  Same as HUF_buildCTable(), but using externally allocated scratch buffer.
0215  * `workSpace` must be aligned on 4-bytes boundaries, and its size must be >= HUF_CTABLE_WORKSPACE_SIZE.
0216  */
0217 #define HUF_CTABLE_WORKSPACE_SIZE_U32 (2*HUF_SYMBOLVALUE_MAX +1 +1)
0218 #define HUF_CTABLE_WORKSPACE_SIZE (HUF_CTABLE_WORKSPACE_SIZE_U32 * sizeof(unsigned))
0219 size_t HUF_buildCTable_wksp (HUF_CElt* tree,
0220                        const unsigned* count, U32 maxSymbolValue, U32 maxNbBits,
0221                              void* workSpace, size_t wkspSize);
0222
0223 /*! HUF_readStats() :
0224  *  Read compact Huffman tree, saved by HUF_writeCTable().
0225  * `huffWeight` is destination buffer.
0226  * @return : size read from `src` , or an error Code .
0227  *  Note : Needed by HUF_readCTable() and HUF_readDTableXn() . */
0228 size_t HUF_readStats(BYTE* huffWeight, size_t hwSize,
0229                      U32* rankStats, U32* nbSymbolsPtr, U32* tableLogPtr,
0230                      const void* src, size_t srcSize);
0231
0232 /*! HUF_readStats_wksp() :
0233  * Same as HUF_readStats() but takes an external workspace which must be
0234  * 4-byte aligned and its size must be >= HUF_READ_STATS_WORKSPACE_SIZE.
0235  * If the CPU has BMI2 support, pass bmi2=1, otherwise pass bmi2=0.
0236  */
0237 #define HUF_READ_STATS_WORKSPACE_SIZE_U32 FSE_DECOMPRESS_WKSP_SIZE_U32(6, HUF_TABLELOG_MAX-1)
0238 #define HUF_READ_STATS_WORKSPACE_SIZE (HUF_READ_STATS_WORKSPACE_SIZE_U32 * sizeof(unsigned))
0239 size_t HUF_readStats_wksp(BYTE* huffWeight, size_t hwSize,
0240                           U32* rankStats, U32* nbSymbolsPtr, U32* tableLogPtr,
0241                           const void* src, size_t srcSize,
0242                           void* workspace, size_t wkspSize,
0243                           int bmi2);
0244
0245 /* HUF_readCTable() :
0246  *  Loading a CTable saved with HUF_writeCTable() */
0247 size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize, unsigned *hasZeroWeights);
0248
0249 /* HUF_getNbBits() :
0250  *  Read nbBits from CTable symbolTable, for symbol `symbolValue` presumed <= HUF_SYMBOLVALUE_MAX
0251  *  Note 1 : is not inlined, as HUF_CElt definition is private
0252  *  Note 2 : const void* used, so that it can provide a statically allocated table as argument (which uses type U32) */
0253 U32 HUF_getNbBits(const void* symbolTable, U32 symbolValue);
0254
0255 /*
0256  * HUF_decompress() does the following:
0257  * 1. select the decompression algorithm (X1, X2) based on pre-computed heuristics
0258  * 2. build Huffman table from save, using HUF_readDTableX?()
0259  * 3. decode 1 or 4 segments in parallel using HUF_decompress?X?_usingDTable()
0260  */
0261
0262 /* HUF_selectDecoder() :
0263  *  Tells which decoder is likely to decode faster,
0264  *  based on a set of pre-computed metrics.
0265  * @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 .
0266  *  Assumption : 0 < dstSize <= 128 KB */
0267 U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize);
0268
0269 /*
0270  *  The minimum workspace size for the `workSpace` used in
0271  *  HUF_readDTableX1_wksp() and HUF_readDTableX2_wksp().
0272  *
0273  *  The space used depends on HUF_TABLELOG_MAX, ranging from ~1500 bytes when
0274  *  HUF_TABLE_LOG_MAX=12 to ~1850 bytes when HUF_TABLE_LOG_MAX=15.
0275  *  Buffer overflow errors may potentially occur if code modifications result in
0276  *  a required workspace size greater than that specified in the following
0277  *  macro.
0278  */
0279 #define HUF_DECOMPRESS_WORKSPACE_SIZE ((2 << 10) + (1 << 9))
0280 #define HUF_DECOMPRESS_WORKSPACE_SIZE_U32 (HUF_DECOMPRESS_WORKSPACE_SIZE / sizeof(U32))
0281
0282 #ifndef HUF_FORCE_DECOMPRESS_X2
0283 size_t HUF_readDTableX1 (HUF_DTable* DTable, const void* src, size_t srcSize);
0284 size_t HUF_readDTableX1_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize);
0285 #endif
0286 #ifndef HUF_FORCE_DECOMPRESS_X1
0287 size_t HUF_readDTableX2 (HUF_DTable* DTable, const void* src, size_t srcSize);
0288 size_t HUF_readDTableX2_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize);
0289 #endif
0290
0291 size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
0292 #ifndef HUF_FORCE_DECOMPRESS_X2
0293 size_t HUF_decompress4X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
0294 #endif
0295 #ifndef HUF_FORCE_DECOMPRESS_X1
0296 size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
0297 #endif
0298
0299
0300 /* ====================== */
0301 /* single stream variants */
0302 /* ====================== */
0303
0304 size_t HUF_compress1X (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog);
0305 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 */
0306 size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable);
0307 /* HUF_compress1X_repeat() :
0308  *  Same as HUF_compress1X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none.
0309  *  If it uses hufTable it does not modify hufTable or repeat.
0310  *  If it doesn't, it sets *repeat = HUF_repeat_none, and it sets hufTable to the table used.
0311  *  If preferRepeat then the old table will always be used if valid. */
0312 size_t HUF_compress1X_repeat(void* dst, size_t dstSize,
0313                        const void* src, size_t srcSize,
0314                        unsigned maxSymbolValue, unsigned tableLog,
0315                        void* workSpace, size_t wkspSize,   /*< `workSpace` must be aligned on 4-bytes boundaries, `wkspSize` must be >= HUF_WORKSPACE_SIZE */
0316                        HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2);
0317
0318 size_t HUF_decompress1X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
0319 #ifndef HUF_FORCE_DECOMPRESS_X1
0320 size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbol decoder */
0321 #endif
0322
0323 size_t HUF_decompress1X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
0324 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);
0325 #ifndef HUF_FORCE_DECOMPRESS_X2
0326 size_t HUF_decompress1X1_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /*< single-symbol decoder */
0327 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 */
0328 #endif
0329 #ifndef HUF_FORCE_DECOMPRESS_X1
0330 size_t HUF_decompress1X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /*< double-symbols decoder */
0331 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 */
0332 #endif
0333
0334 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 */
0335 #ifndef HUF_FORCE_DECOMPRESS_X2
0336 size_t HUF_decompress1X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
0337 #endif
0338 #ifndef HUF_FORCE_DECOMPRESS_X1
0339 size_t HUF_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
0340 #endif
0341
0342 /* BMI2 variants.
0343  * If the CPU has BMI2 support, pass bmi2=1, otherwise pass bmi2=0.
0344  */
0345 size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2);
0346 #ifndef HUF_FORCE_DECOMPRESS_X2
0347 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);
0348 #endif
0349 size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2);
0350 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);
0351 #ifndef HUF_FORCE_DECOMPRESS_X2
0352 size_t HUF_readDTableX1_wksp_bmi2(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize, int bmi2);
0353 #endif
0354
0355 #endif /* HUF_STATIC_LINKING_ONLY */
0356