{"header":{"message":"Reboot, again","description":null,"timestamp":"2023-02-24T13:03:06.646630128Z","authors":[{}]},"hash":"SMODSZD3RKFNFHFPPGUFGAX6OAWTRA3RTKGYFNL2IXPX4FYEI32QC","authors":[{"login":"pmeunier","key":"FZQ2g7VfnzLYM4mtTVDk9HAZjA8Jk9ndkwN1icgbtWUr"}],"deps":{"hashes":[["SMODSZD3RKFNFHFPPGUFGAX6OAWTRA3RTKGYFNL2IXPX4FYEI32QC","Reboot, again"],["AA",null],["NPLNTM3BHNQ4KL57FGMLHEXTZIRZQLALKDC3OXCHH3QRWVTEMNNQC",""]],"deps":["NPLNTM3BHNQ4KL57FGMLHEXTZIRZQLALKDC3OXCHH3QRWVTEMNNQC"],"known":[]},"hunks":[{"FileAdd":{"meta":{"basename":"zstd","metadata":576},"context":[{"change":2,"pos":1}],"contents":[]}},{"FileAdd":{"meta":{"basename":"lib","metadata":576},"context":[{"change":0,"pos":1}],"contents":[]}},{"FileAdd":{"meta":{"basename":"zstd.h","metadata":0},"context":[{"change":0,"pos":19}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) 2016-2021, Yann Collet, Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"#ifndef ZSTD_H_235446"},{"Add":"#define ZSTD_H_235446"},{"Add":""},{"Add":"/* ====== Dependency ======*/"},{"Add":"#include /* INT_MAX */"},{"Add":"#include /* size_t */"},{"Add":""},{"Add":""},{"Add":"/* ===== ZSTDLIB_API : control library symbols visibility ===== */"},{"Add":"#ifndef ZSTDLIB_VISIBILITY"},{"Add":"# if defined(__GNUC__) && (__GNUC__ >= 4)"},{"Add":"# define ZSTDLIB_VISIBILITY __attribute__ ((visibility (\"default\")))"},{"Add":"# else"},{"Add":"# define ZSTDLIB_VISIBILITY"},{"Add":"# endif"},{"Add":"#endif"},{"Add":"#if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)"},{"Add":"# define ZSTDLIB_API __declspec(dllexport) ZSTDLIB_VISIBILITY"},{"Add":"#elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)"},{"Add":"# define ZSTDLIB_API __declspec(dllimport) ZSTDLIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/"},{"Add":"#else"},{"Add":"# define ZSTDLIB_API ZSTDLIB_VISIBILITY"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*******************************************************************************"},{"Add":" Introduction"},{"Add":""},{"Add":" zstd, short for Zstandard, is a fast lossless compression algorithm, targeting"},{"Add":" real-time compression scenarios at zlib-level and better compression ratios."},{"Add":" The zstd compression library provides in-memory compression and decompression"},{"Add":" functions."},{"Add":""},{"Add":" The library supports regular compression levels from 1 up to ZSTD_maxCLevel(),"},{"Add":" which is currently 22. Levels >= 20, labeled `--ultra`, should be used with"},{"Add":" caution, as they require more memory. The library also offers negative"},{"Add":" compression levels, which extend the range of speed vs. ratio preferences."},{"Add":" The lower the level, the faster the speed (at the cost of compression)."},{"Add":""},{"Add":" Compression can be done in:"},{"Add":" - a single step (described as Simple API)"},{"Add":" - a single step, reusing a context (described as Explicit context)"},{"Add":" - unbounded multiple steps (described as Streaming compression)"},{"Add":""},{"Add":" The compression ratio achievable on small data can be highly improved using"},{"Add":" a dictionary. Dictionary compression can be performed in:"},{"Add":" - a single step (described as Simple dictionary API)"},{"Add":" - a single step, reusing a dictionary (described as Bulk-processing"},{"Add":" dictionary API)"},{"Add":""},{"Add":" Advanced experimental functions can be accessed using"},{"Add":" `#define ZSTD_STATIC_LINKING_ONLY` before including zstd.h."},{"Add":""},{"Add":" Advanced experimental APIs should never be used with a dynamically-linked"},{"Add":" library. They are not \"stable\"; their definitions or signatures may change in"},{"Add":" the future. Only static linking is allowed."},{"Add":"*******************************************************************************/"},{"Add":""},{"Add":"/*------ Version ------*/"},{"Add":"#define ZSTD_VERSION_MAJOR 1"},{"Add":"#define ZSTD_VERSION_MINOR 4"},{"Add":"#define ZSTD_VERSION_RELEASE 9"},{"Add":"#define ZSTD_VERSION_NUMBER (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)"},{"Add":""},{"Add":"/*! ZSTD_versionNumber() :"},{"Add":" * Return runtime library version, the value is (MAJOR*100*100 + MINOR*100 + RELEASE). */"},{"Add":"ZSTDLIB_API unsigned ZSTD_versionNumber(void);"},{"Add":""},{"Add":"#define ZSTD_LIB_VERSION ZSTD_VERSION_MAJOR.ZSTD_VERSION_MINOR.ZSTD_VERSION_RELEASE"},{"Add":"#define ZSTD_QUOTE(str) #str"},{"Add":"#define ZSTD_EXPAND_AND_QUOTE(str) ZSTD_QUOTE(str)"},{"Add":"#define ZSTD_VERSION_STRING ZSTD_EXPAND_AND_QUOTE(ZSTD_LIB_VERSION)"},{"Add":""},{"Add":"/*! ZSTD_versionString() :"},{"Add":" * Return runtime library version, like \"1.4.5\". Requires v1.3.0+. */"},{"Add":"ZSTDLIB_API const char* ZSTD_versionString(void);"},{"Add":""},{"Add":"/* *************************************"},{"Add":" * Default constant"},{"Add":" ***************************************/"},{"Add":"#ifndef ZSTD_CLEVEL_DEFAULT"},{"Add":"# define ZSTD_CLEVEL_DEFAULT 3"},{"Add":"#endif"},{"Add":""},{"Add":"/* *************************************"},{"Add":" * Constants"},{"Add":" ***************************************/"},{"Add":""},{"Add":"/* All magic numbers are supposed read/written to/from files/memory using little-endian convention */"},{"Add":"#define ZSTD_MAGICNUMBER 0xFD2FB528 /* valid since v0.8.0 */"},{"Add":"#define ZSTD_MAGIC_DICTIONARY 0xEC30A437 /* valid since v0.7.0 */"},{"Add":"#define ZSTD_MAGIC_SKIPPABLE_START 0x184D2A50 /* all 16 values, from 0x184D2A50 to 0x184D2A5F, signal the beginning of a skippable frame */"},{"Add":"#define ZSTD_MAGIC_SKIPPABLE_MASK 0xFFFFFFF0"},{"Add":""},{"Add":"#define ZSTD_BLOCKSIZELOG_MAX 17"},{"Add":"#define ZSTD_BLOCKSIZE_MAX (1<= `ZSTD_compressBound(srcSize)`."},{"Add":" * @return : compressed size written into `dst` (<= `dstCapacity),"},{"Add":" * or an error code if it fails (which can be tested using ZSTD_isError()). */"},{"Add":"ZSTDLIB_API size_t ZSTD_compress( void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" int compressionLevel);"},{"Add":""},{"Add":"/*! ZSTD_decompress() :"},{"Add":" * `compressedSize` : must be the _exact_ size of some number of compressed and/or skippable frames."},{"Add":" * `dstCapacity` is an upper bound of originalSize to regenerate."},{"Add":" * If user cannot imply a maximum upper bound, it's better to use streaming mode to decompress data."},{"Add":" * @return : the number of bytes decompressed into `dst` (<= `dstCapacity`),"},{"Add":" * or an errorCode if it fails (which can be tested using ZSTD_isError()). */"},{"Add":"ZSTDLIB_API size_t ZSTD_decompress( void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t compressedSize);"},{"Add":""},{"Add":"/*! ZSTD_getFrameContentSize() : requires v1.3.0+"},{"Add":" * `src` should point to the start of a ZSTD encoded frame."},{"Add":" * `srcSize` must be at least as large as the frame header."},{"Add":" * hint : any size >= `ZSTD_frameHeaderSize_max` is large enough."},{"Add":" * @return : - decompressed size of `src` frame content, if known"},{"Add":" * - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined"},{"Add":" * - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small)"},{"Add":" * note 1 : a 0 return value means the frame is valid but \"empty\"."},{"Add":" * note 2 : decompressed size is an optional field, it may not be present, typically in streaming mode."},{"Add":" * When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size."},{"Add":" * In which case, it's necessary to use streaming mode to decompress data."},{"Add":" * Optionally, application can rely on some implicit limit,"},{"Add":" * as ZSTD_decompress() only needs an upper bound of decompressed size."},{"Add":" * (For example, data could be necessarily cut into blocks <= 16 KB)."},{"Add":" * note 3 : decompressed size is always present when compression is completed using single-pass functions,"},{"Add":" * such as ZSTD_compress(), ZSTD_compressCCtx() ZSTD_compress_usingDict() or ZSTD_compress_usingCDict()."},{"Add":" * note 4 : decompressed size can be very large (64-bits value),"},{"Add":" * potentially larger than what local system can handle as a single memory segment."},{"Add":" * In which case, it's necessary to use streaming mode to decompress data."},{"Add":" * note 5 : If source is untrusted, decompressed size could be wrong or intentionally modified."},{"Add":" * Always ensure return value fits within application's authorized limits."},{"Add":" * Each application can set its own limits."},{"Add":" * note 6 : This function replaces ZSTD_getDecompressedSize() */"},{"Add":"#define ZSTD_CONTENTSIZE_UNKNOWN (0ULL - 1)"},{"Add":"#define ZSTD_CONTENTSIZE_ERROR (0ULL - 2)"},{"Add":"ZSTDLIB_API unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize);"},{"Add":""},{"Add":"/*! ZSTD_getDecompressedSize() :"},{"Add":" * NOTE: This function is now obsolete, in favor of ZSTD_getFrameContentSize()."},{"Add":" * Both functions work the same way, but ZSTD_getDecompressedSize() blends"},{"Add":" * \"empty\", \"unknown\" and \"error\" results to the same return value (0),"},{"Add":" * while ZSTD_getFrameContentSize() gives them separate return values."},{"Add":" * @return : decompressed size of `src` frame content _if known and not empty_, 0 otherwise. */"},{"Add":"ZSTDLIB_API unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize);"},{"Add":""},{"Add":"/*! ZSTD_findFrameCompressedSize() :"},{"Add":" * `src` should point to the start of a ZSTD frame or skippable frame."},{"Add":" * `srcSize` must be >= first frame size"},{"Add":" * @return : the compressed size of the first frame starting at `src`,"},{"Add":" * suitable to pass as `srcSize` to `ZSTD_decompress` or similar,"},{"Add":" * or an error code if input is invalid */"},{"Add":"ZSTDLIB_API size_t ZSTD_findFrameCompressedSize(const void* src, size_t srcSize);"},{"Add":""},{"Add":""},{"Add":"/*====== Helper functions ======*/"},{"Add":"#define ZSTD_COMPRESSBOUND(srcSize) ((srcSize) + ((srcSize)>>8) + (((srcSize) < (128<<10)) ? (((128<<10) - (srcSize)) >> 11) /* margin, from 64 to 0 */ : 0)) /* this formula ensures that bound(A) + bound(B) <= bound(A+B) as long as A and B >= 128 KB */"},{"Add":"ZSTDLIB_API size_t ZSTD_compressBound(size_t srcSize); /*!< maximum compressed size in worst case single-pass scenario */"},{"Add":"ZSTDLIB_API unsigned ZSTD_isError(size_t code); /*!< tells if a `size_t` function result is an error code */"},{"Add":"ZSTDLIB_API const char* ZSTD_getErrorName(size_t code); /*!< provides readable string from an error code */"},{"Add":"ZSTDLIB_API int ZSTD_minCLevel(void); /*!< minimum negative compression level allowed */"},{"Add":"ZSTDLIB_API int ZSTD_maxCLevel(void); /*!< maximum compression level available */"},{"Add":""},{"Add":""},{"Add":"/***************************************"},{"Add":"* Explicit context"},{"Add":"***************************************/"},{"Add":"/*= Compression context"},{"Add":" * When compressing many times,"},{"Add":" * it is recommended to allocate a context just once,"},{"Add":" * and re-use it for each successive compression operation."},{"Add":" * This will make workload friendlier for system's memory."},{"Add":" * Note : re-using context is just a speed / resource optimization."},{"Add":" * It doesn't change the compression ratio, which remains identical."},{"Add":" * Note 2 : In multi-threaded environments,"},{"Add":" * use one different context per thread for parallel execution."},{"Add":" */"},{"Add":"typedef struct ZSTD_CCtx_s ZSTD_CCtx;"},{"Add":"ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx(void);"},{"Add":"ZSTDLIB_API size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx);"},{"Add":""},{"Add":"/*! ZSTD_compressCCtx() :"},{"Add":" * Same as ZSTD_compress(), using an explicit ZSTD_CCtx."},{"Add":" * Important : in order to behave similarly to `ZSTD_compress()`,"},{"Add":" * this function compresses at requested compression level,"},{"Add":" * __ignoring any other parameter__ ."},{"Add":" * If any advanced parameter was set using the advanced API,"},{"Add":" * they will all be reset. Only `compressionLevel` remains."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" int compressionLevel);"},{"Add":""},{"Add":"/*= Decompression context"},{"Add":" * When decompressing many times,"},{"Add":" * it is recommended to allocate a context only once,"},{"Add":" * and re-use it for each successive compression operation."},{"Add":" * This will make workload friendlier for system's memory."},{"Add":" * Use one context per thread for parallel execution. */"},{"Add":"typedef struct ZSTD_DCtx_s ZSTD_DCtx;"},{"Add":"ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx(void);"},{"Add":"ZSTDLIB_API size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx);"},{"Add":""},{"Add":"/*! ZSTD_decompressDCtx() :"},{"Add":" * Same as ZSTD_decompress(),"},{"Add":" * requires an allocated ZSTD_DCtx."},{"Add":" * Compatible with sticky parameters."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize);"},{"Add":""},{"Add":""},{"Add":"/***************************************"},{"Add":"* Advanced compression API"},{"Add":"***************************************/"},{"Add":""},{"Add":"/* API design :"},{"Add":" * Parameters are pushed one by one into an existing context,"},{"Add":" * using ZSTD_CCtx_set*() functions."},{"Add":" * Pushed parameters are sticky : they are valid for next compressed frame, and any subsequent frame."},{"Add":" * \"sticky\" parameters are applicable to `ZSTD_compress2()` and `ZSTD_compressStream*()` !"},{"Add":" * __They do not apply to \"simple\" one-shot variants such as ZSTD_compressCCtx()__ ."},{"Add":" *"},{"Add":" * It's possible to reset all parameters to \"default\" using ZSTD_CCtx_reset()."},{"Add":" *"},{"Add":" * This API supercedes all other \"advanced\" API entry points in the experimental section."},{"Add":" * In the future, we expect to remove from experimental API entry points which are redundant with this API."},{"Add":" */"},{"Add":""},{"Add":""},{"Add":"/* Compression strategies, listed from fastest to strongest */"},{"Add":"typedef enum { ZSTD_fast=1,"},{"Add":" ZSTD_dfast=2,"},{"Add":" ZSTD_greedy=3,"},{"Add":" ZSTD_lazy=4,"},{"Add":" ZSTD_lazy2=5,"},{"Add":" ZSTD_btlazy2=6,"},{"Add":" ZSTD_btopt=7,"},{"Add":" ZSTD_btultra=8,"},{"Add":" ZSTD_btultra2=9"},{"Add":" /* note : new strategies _might_ be added in the future."},{"Add":" Only the order (from fast to strong) is guaranteed */"},{"Add":"} ZSTD_strategy;"},{"Add":""},{"Add":""},{"Add":"typedef enum {"},{"Add":""},{"Add":" /* compression parameters"},{"Add":" * Note: When compressing with a ZSTD_CDict these parameters are superseded"},{"Add":" * by the parameters used to construct the ZSTD_CDict."},{"Add":" * See ZSTD_CCtx_refCDict() for more info (superseded-by-cdict). */"},{"Add":" ZSTD_c_compressionLevel=100, /* Set compression parameters according to pre-defined cLevel table."},{"Add":" * Note that exact compression parameters are dynamically determined,"},{"Add":" * depending on both compression level and srcSize (when known)."},{"Add":" * Default level is ZSTD_CLEVEL_DEFAULT==3."},{"Add":" * Special: value 0 means default, which is controlled by ZSTD_CLEVEL_DEFAULT."},{"Add":" * Note 1 : it's possible to pass a negative compression level."},{"Add":" * Note 2 : setting a level does not automatically set all other compression parameters"},{"Add":" * to default. Setting this will however eventually dynamically impact the compression"},{"Add":" * parameters which have not been manually set. The manually set"},{"Add":" * ones will 'stick'. */"},{"Add":" /* Advanced compression parameters :"},{"Add":" * It's possible to pin down compression parameters to some specific values."},{"Add":" * In which case, these values are no longer dynamically selected by the compressor */"},{"Add":" ZSTD_c_windowLog=101, /* Maximum allowed back-reference distance, expressed as power of 2."},{"Add":" * This will set a memory budget for streaming decompression,"},{"Add":" * with larger values requiring more memory"},{"Add":" * and typically compressing more."},{"Add":" * Must be clamped between ZSTD_WINDOWLOG_MIN and ZSTD_WINDOWLOG_MAX."},{"Add":" * Special: value 0 means \"use default windowLog\"."},{"Add":" * Note: Using a windowLog greater than ZSTD_WINDOWLOG_LIMIT_DEFAULT"},{"Add":" * requires explicitly allowing such size at streaming decompression stage. */"},{"Add":" ZSTD_c_hashLog=102, /* Size of the initial probe table, as a power of 2."},{"Add":" * Resulting memory usage is (1 << (hashLog+2))."},{"Add":" * Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX."},{"Add":" * Larger tables improve compression ratio of strategies <= dFast,"},{"Add":" * and improve speed of strategies > dFast."},{"Add":" * Special: value 0 means \"use default hashLog\". */"},{"Add":" ZSTD_c_chainLog=103, /* Size of the multi-probe search table, as a power of 2."},{"Add":" * Resulting memory usage is (1 << (chainLog+2))."},{"Add":" * Must be clamped between ZSTD_CHAINLOG_MIN and ZSTD_CHAINLOG_MAX."},{"Add":" * Larger tables result in better and slower compression."},{"Add":" * This parameter is useless for \"fast\" strategy."},{"Add":" * It's still useful when using \"dfast\" strategy,"},{"Add":" * in which case it defines a secondary probe table."},{"Add":" * Special: value 0 means \"use default chainLog\". */"},{"Add":" ZSTD_c_searchLog=104, /* Number of search attempts, as a power of 2."},{"Add":" * More attempts result in better and slower compression."},{"Add":" * This parameter is useless for \"fast\" and \"dFast\" strategies."},{"Add":" * Special: value 0 means \"use default searchLog\". */"},{"Add":" ZSTD_c_minMatch=105, /* Minimum size of searched matches."},{"Add":" * Note that Zstandard can still find matches of smaller size,"},{"Add":" * it just tweaks its search algorithm to look for this size and larger."},{"Add":" * Larger values increase compression and decompression speed, but decrease ratio."},{"Add":" * Must be clamped between ZSTD_MINMATCH_MIN and ZSTD_MINMATCH_MAX."},{"Add":" * Note that currently, for all strategies < btopt, effective minimum is 4."},{"Add":" * , for all strategies > fast, effective maximum is 6."},{"Add":" * Special: value 0 means \"use default minMatchLength\". */"},{"Add":" ZSTD_c_targetLength=106, /* Impact of this field depends on strategy."},{"Add":" * For strategies btopt, btultra & btultra2:"},{"Add":" * Length of Match considered \"good enough\" to stop search."},{"Add":" * Larger values make compression stronger, and slower."},{"Add":" * For strategy fast:"},{"Add":" * Distance between match sampling."},{"Add":" * Larger values make compression faster, and weaker."},{"Add":" * Special: value 0 means \"use default targetLength\". */"},{"Add":" ZSTD_c_strategy=107, /* See ZSTD_strategy enum definition."},{"Add":" * The higher the value of selected strategy, the more complex it is,"},{"Add":" * resulting in stronger and slower compression."},{"Add":" * Special: value 0 means \"use default strategy\". */"},{"Add":""},{"Add":" /* LDM mode parameters */"},{"Add":" ZSTD_c_enableLongDistanceMatching=160, /* Enable long distance matching."},{"Add":" * This parameter is designed to improve compression ratio"},{"Add":" * for large inputs, by finding large matches at long distance."},{"Add":" * It increases memory usage and window size."},{"Add":" * Note: enabling this parameter increases default ZSTD_c_windowLog to 128 MB"},{"Add":" * except when expressly set to a different value."},{"Add":" * Note: will be enabled by default if ZSTD_c_windowLog >= 128 MB and"},{"Add":" * compression strategy >= ZSTD_btopt (== compression level 16+) */"},{"Add":" ZSTD_c_ldmHashLog=161, /* Size of the table for long distance matching, as a power of 2."},{"Add":" * Larger values increase memory usage and compression ratio,"},{"Add":" * but decrease compression speed."},{"Add":" * Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX"},{"Add":" * default: windowlog - 7."},{"Add":" * Special: value 0 means \"automatically determine hashlog\". */"},{"Add":" ZSTD_c_ldmMinMatch=162, /* Minimum match size for long distance matcher."},{"Add":" * Larger/too small values usually decrease compression ratio."},{"Add":" * Must be clamped between ZSTD_LDM_MINMATCH_MIN and ZSTD_LDM_MINMATCH_MAX."},{"Add":" * Special: value 0 means \"use default value\" (default: 64). */"},{"Add":" ZSTD_c_ldmBucketSizeLog=163, /* Log size of each bucket in the LDM hash table for collision resolution."},{"Add":" * Larger values improve collision resolution but decrease compression speed."},{"Add":" * The maximum value is ZSTD_LDM_BUCKETSIZELOG_MAX."},{"Add":" * Special: value 0 means \"use default value\" (default: 3). */"},{"Add":" ZSTD_c_ldmHashRateLog=164, /* Frequency of inserting/looking up entries into the LDM hash table."},{"Add":" * Must be clamped between 0 and (ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN)."},{"Add":" * Default is MAX(0, (windowLog - ldmHashLog)), optimizing hash table usage."},{"Add":" * Larger values improve compression speed."},{"Add":" * Deviating far from default value will likely result in a compression ratio decrease."},{"Add":" * Special: value 0 means \"automatically determine hashRateLog\". */"},{"Add":""},{"Add":" /* frame parameters */"},{"Add":" ZSTD_c_contentSizeFlag=200, /* Content size will be written into frame header _whenever known_ (default:1)"},{"Add":" * Content size must be known at the beginning of compression."},{"Add":" * This is automatically the case when using ZSTD_compress2(),"},{"Add":" * For streaming scenarios, content size must be provided with ZSTD_CCtx_setPledgedSrcSize() */"},{"Add":" ZSTD_c_checksumFlag=201, /* A 32-bits checksum of content is written at end of frame (default:0) */"},{"Add":" ZSTD_c_dictIDFlag=202, /* When applicable, dictionary's ID is written into frame header (default:1) */"},{"Add":""},{"Add":" /* multi-threading parameters */"},{"Add":" /* These parameters are only active if multi-threading is enabled (compiled with build macro ZSTD_MULTITHREAD)."},{"Add":" * Otherwise, trying to set any other value than default (0) will be a no-op and return an error."},{"Add":" * In a situation where it's unknown if the linked library supports multi-threading or not,"},{"Add":" * setting ZSTD_c_nbWorkers to any value >= 1 and consulting the return value provides a quick way to check this property."},{"Add":" */"},{"Add":" ZSTD_c_nbWorkers=400, /* Select how many threads will be spawned to compress in parallel."},{"Add":" * When nbWorkers >= 1, triggers asynchronous mode when invoking ZSTD_compressStream*() :"},{"Add":" * ZSTD_compressStream*() consumes input and flush output if possible, but immediately gives back control to caller,"},{"Add":" * while compression is performed in parallel, within worker thread(s)."},{"Add":" * (note : a strong exception to this rule is when first invocation of ZSTD_compressStream2() sets ZSTD_e_end :"},{"Add":" * in which case, ZSTD_compressStream2() delegates to ZSTD_compress2(), which is always a blocking call)."},{"Add":" * More workers improve speed, but also increase memory usage."},{"Add":" * Default value is `0`, aka \"single-threaded mode\" : no worker is spawned,"},{"Add":" * compression is performed inside Caller's thread, and all invocations are blocking */"},{"Add":" ZSTD_c_jobSize=401, /* Size of a compression job. This value is enforced only when nbWorkers >= 1."},{"Add":" * Each compression job is completed in parallel, so this value can indirectly impact the nb of active threads."},{"Add":" * 0 means default, which is dynamically determined based on compression parameters."},{"Add":" * Job size must be a minimum of overlap size, or 1 MB, whichever is largest."},{"Add":" * The minimum size is automatically and transparently enforced. */"},{"Add":" ZSTD_c_overlapLog=402, /* Control the overlap size, as a fraction of window size."},{"Add":" * The overlap size is an amount of data reloaded from previous job at the beginning of a new job."},{"Add":" * It helps preserve compression ratio, while each job is compressed in parallel."},{"Add":" * This value is enforced only when nbWorkers >= 1."},{"Add":" * Larger values increase compression ratio, but decrease speed."},{"Add":" * Possible values range from 0 to 9 :"},{"Add":" * - 0 means \"default\" : value will be determined by the library, depending on strategy"},{"Add":" * - 1 means \"no overlap\""},{"Add":" * - 9 means \"full overlap\", using a full window size."},{"Add":" * Each intermediate rank increases/decreases load size by a factor 2 :"},{"Add":" * 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"},{"Add":" * default value varies between 6 and 9, depending on strategy */"},{"Add":""},{"Add":" /* note : additional experimental parameters are also available"},{"Add":" * within the experimental section of the API."},{"Add":" * At the time of this writing, they include :"},{"Add":" * ZSTD_c_rsyncable"},{"Add":" * ZSTD_c_format"},{"Add":" * ZSTD_c_forceMaxWindow"},{"Add":" * ZSTD_c_forceAttachDict"},{"Add":" * ZSTD_c_literalCompressionMode"},{"Add":" * ZSTD_c_targetCBlockSize"},{"Add":" * ZSTD_c_srcSizeHint"},{"Add":" * ZSTD_c_enableDedicatedDictSearch"},{"Add":" * ZSTD_c_stableInBuffer"},{"Add":" * ZSTD_c_stableOutBuffer"},{"Add":" * ZSTD_c_blockDelimiters"},{"Add":" * ZSTD_c_validateSequences"},{"Add":" * Because they are not stable, it's necessary to define ZSTD_STATIC_LINKING_ONLY to access them."},{"Add":" * note : never ever use experimentalParam? names directly;"},{"Add":" * also, the enums values themselves are unstable and can still change."},{"Add":" */"},{"Add":" ZSTD_c_experimentalParam1=500,"},{"Add":" ZSTD_c_experimentalParam2=10,"},{"Add":" ZSTD_c_experimentalParam3=1000,"},{"Add":" ZSTD_c_experimentalParam4=1001,"},{"Add":" ZSTD_c_experimentalParam5=1002,"},{"Add":" ZSTD_c_experimentalParam6=1003,"},{"Add":" ZSTD_c_experimentalParam7=1004,"},{"Add":" ZSTD_c_experimentalParam8=1005,"},{"Add":" ZSTD_c_experimentalParam9=1006,"},{"Add":" ZSTD_c_experimentalParam10=1007,"},{"Add":" ZSTD_c_experimentalParam11=1008,"},{"Add":" ZSTD_c_experimentalParam12=1009"},{"Add":"} ZSTD_cParameter;"},{"Add":""},{"Add":"typedef struct {"},{"Add":" size_t error;"},{"Add":" int lowerBound;"},{"Add":" int upperBound;"},{"Add":"} ZSTD_bounds;"},{"Add":""},{"Add":"/*! ZSTD_cParam_getBounds() :"},{"Add":" * All parameters must belong to an interval with lower and upper bounds,"},{"Add":" * otherwise they will either trigger an error or be automatically clamped."},{"Add":" * @return : a structure, ZSTD_bounds, which contains"},{"Add":" * - an error status field, which must be tested using ZSTD_isError()"},{"Add":" * - lower and upper bounds, both inclusive"},{"Add":" */"},{"Add":"ZSTDLIB_API ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter cParam);"},{"Add":""},{"Add":"/*! ZSTD_CCtx_setParameter() :"},{"Add":" * Set one compression parameter, selected by enum ZSTD_cParameter."},{"Add":" * All parameters have valid bounds. Bounds can be queried using ZSTD_cParam_getBounds()."},{"Add":" * Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter)."},{"Add":" * Setting a parameter is generally only possible during frame initialization (before starting compression)."},{"Add":" * Exception : when using multi-threading mode (nbWorkers >= 1),"},{"Add":" * the following parameters can be updated _during_ compression (within same frame):"},{"Add":" * => compressionLevel, hashLog, chainLog, searchLog, minMatch, targetLength and strategy."},{"Add":" * new parameters will be active for next job only (after a flush())."},{"Add":" * @return : an error code (which can be tested using ZSTD_isError())."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value);"},{"Add":""},{"Add":"/*! ZSTD_CCtx_setPledgedSrcSize() :"},{"Add":" * Total input data size to be compressed as a single frame."},{"Add":" * Value will be written in frame header, unless if explicitly forbidden using ZSTD_c_contentSizeFlag."},{"Add":" * This value will also be controlled at end of frame, and trigger an error if not respected."},{"Add":" * @result : 0, or an error code (which can be tested with ZSTD_isError())."},{"Add":" * Note 1 : pledgedSrcSize==0 actually means zero, aka an empty frame."},{"Add":" * In order to mean \"unknown content size\", pass constant ZSTD_CONTENTSIZE_UNKNOWN."},{"Add":" * ZSTD_CONTENTSIZE_UNKNOWN is default value for any new frame."},{"Add":" * Note 2 : pledgedSrcSize is only valid once, for the next frame."},{"Add":" * It's discarded at the end of the frame, and replaced by ZSTD_CONTENTSIZE_UNKNOWN."},{"Add":" * Note 3 : Whenever all input data is provided and consumed in a single round,"},{"Add":" * for example with ZSTD_compress2(),"},{"Add":" * or invoking immediately ZSTD_compressStream2(,,,ZSTD_e_end),"},{"Add":" * this value is automatically overridden by srcSize instead."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize);"},{"Add":""},{"Add":"typedef enum {"},{"Add":" ZSTD_reset_session_only = 1,"},{"Add":" ZSTD_reset_parameters = 2,"},{"Add":" ZSTD_reset_session_and_parameters = 3"},{"Add":"} ZSTD_ResetDirective;"},{"Add":""},{"Add":"/*! ZSTD_CCtx_reset() :"},{"Add":" * There are 2 different things that can be reset, independently or jointly :"},{"Add":" * - The session : will stop compressing current frame, and make CCtx ready to start a new one."},{"Add":" * Useful after an error, or to interrupt any ongoing compression."},{"Add":" * Any internal data not yet flushed is cancelled."},{"Add":" * Compression parameters and dictionary remain unchanged."},{"Add":" * They will be used to compress next frame."},{"Add":" * Resetting session never fails."},{"Add":" * - The parameters : changes all parameters back to \"default\"."},{"Add":" * This removes any reference to any dictionary too."},{"Add":" * Parameters can only be changed between 2 sessions (i.e. no compression is currently ongoing)"},{"Add":" * otherwise the reset fails, and function returns an error value (which can be tested using ZSTD_isError())"},{"Add":" * - Both : similar to resetting the session, followed by resetting parameters."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset);"},{"Add":""},{"Add":"/*! ZSTD_compress2() :"},{"Add":" * Behave the same as ZSTD_compressCCtx(), but compression parameters are set using the advanced API."},{"Add":" * ZSTD_compress2() always starts a new frame."},{"Add":" * Should cctx hold data from a previously unfinished frame, everything about it is forgotten."},{"Add":" * - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()"},{"Add":" * - The function is always blocking, returns when compression is completed."},{"Add":" * Hint : compression runs faster if `dstCapacity` >= `ZSTD_compressBound(srcSize)`."},{"Add":" * @return : compressed size written into `dst` (<= `dstCapacity),"},{"Add":" * or an error code if it fails (which can be tested using ZSTD_isError())."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_compress2( ZSTD_CCtx* cctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize);"},{"Add":""},{"Add":""},{"Add":"/***************************************"},{"Add":"* Advanced decompression API"},{"Add":"***************************************/"},{"Add":""},{"Add":"/* The advanced API pushes parameters one by one into an existing DCtx context."},{"Add":" * Parameters are sticky, and remain valid for all following frames"},{"Add":" * using the same DCtx context."},{"Add":" * It's possible to reset parameters to default values using ZSTD_DCtx_reset()."},{"Add":" * Note : This API is compatible with existing ZSTD_decompressDCtx() and ZSTD_decompressStream()."},{"Add":" * Therefore, no new decompression function is necessary."},{"Add":" */"},{"Add":""},{"Add":"typedef enum {"},{"Add":""},{"Add":" ZSTD_d_windowLogMax=100, /* Select a size limit (in power of 2) beyond which"},{"Add":" * the streaming API will refuse to allocate memory buffer"},{"Add":" * in order to protect the host from unreasonable memory requirements."},{"Add":" * This parameter is only useful in streaming mode, since no internal buffer is allocated in single-pass mode."},{"Add":" * By default, a decompression context accepts window sizes <= (1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT)."},{"Add":" * Special: value 0 means \"use default maximum windowLog\". */"},{"Add":""},{"Add":" /* note : additional experimental parameters are also available"},{"Add":" * within the experimental section of the API."},{"Add":" * At the time of this writing, they include :"},{"Add":" * ZSTD_d_format"},{"Add":" * ZSTD_d_stableOutBuffer"},{"Add":" * ZSTD_d_forceIgnoreChecksum"},{"Add":" * ZSTD_d_refMultipleDDicts"},{"Add":" * Because they are not stable, it's necessary to define ZSTD_STATIC_LINKING_ONLY to access them."},{"Add":" * note : never ever use experimentalParam? names directly"},{"Add":" */"},{"Add":" ZSTD_d_experimentalParam1=1000,"},{"Add":" ZSTD_d_experimentalParam2=1001,"},{"Add":" ZSTD_d_experimentalParam3=1002,"},{"Add":" ZSTD_d_experimentalParam4=1003"},{"Add":""},{"Add":"} ZSTD_dParameter;"},{"Add":""},{"Add":"/*! ZSTD_dParam_getBounds() :"},{"Add":" * All parameters must belong to an interval with lower and upper bounds,"},{"Add":" * otherwise they will either trigger an error or be automatically clamped."},{"Add":" * @return : a structure, ZSTD_bounds, which contains"},{"Add":" * - an error status field, which must be tested using ZSTD_isError()"},{"Add":" * - both lower and upper bounds, inclusive"},{"Add":" */"},{"Add":"ZSTDLIB_API ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam);"},{"Add":""},{"Add":"/*! ZSTD_DCtx_setParameter() :"},{"Add":" * Set one compression parameter, selected by enum ZSTD_dParameter."},{"Add":" * All parameters have valid bounds. Bounds can be queried using ZSTD_dParam_getBounds()."},{"Add":" * Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter)."},{"Add":" * Setting a parameter is only possible during frame initialization (before starting decompression)."},{"Add":" * @return : 0, or an error code (which can be tested using ZSTD_isError())."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int value);"},{"Add":""},{"Add":"/*! ZSTD_DCtx_reset() :"},{"Add":" * Return a DCtx to clean state."},{"Add":" * Session and parameters can be reset jointly or separately."},{"Add":" * Parameters can only be reset when no active frame is being decompressed."},{"Add":" * @return : 0, or an error code, which can be tested with ZSTD_isError()"},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset);"},{"Add":""},{"Add":""},{"Add":"/****************************"},{"Add":"* Streaming"},{"Add":"****************************/"},{"Add":""},{"Add":"typedef struct ZSTD_inBuffer_s {"},{"Add":" const void* src; /**< start of input buffer */"},{"Add":" size_t size; /**< size of input buffer */"},{"Add":" size_t pos; /**< position where reading stopped. Will be updated. Necessarily 0 <= pos <= size */"},{"Add":"} ZSTD_inBuffer;"},{"Add":""},{"Add":"typedef struct ZSTD_outBuffer_s {"},{"Add":" void* dst; /**< start of output buffer */"},{"Add":" size_t size; /**< size of output buffer */"},{"Add":" size_t pos; /**< position where writing stopped. Will be updated. Necessarily 0 <= pos <= size */"},{"Add":"} ZSTD_outBuffer;"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-***********************************************************************"},{"Add":"* Streaming compression - HowTo"},{"Add":"*"},{"Add":"* A ZSTD_CStream object is required to track streaming operation."},{"Add":"* Use ZSTD_createCStream() and ZSTD_freeCStream() to create/release resources."},{"Add":"* ZSTD_CStream objects can be reused multiple times on consecutive compression operations."},{"Add":"* It is recommended to re-use ZSTD_CStream since it will play nicer with system's memory, by re-using already allocated memory."},{"Add":"*"},{"Add":"* For parallel execution, use one separate ZSTD_CStream per thread."},{"Add":"*"},{"Add":"* note : since v1.3.0, ZSTD_CStream and ZSTD_CCtx are the same thing."},{"Add":"*"},{"Add":"* Parameters are sticky : when starting a new compression on the same context,"},{"Add":"* it will re-use the same sticky parameters as previous compression session."},{"Add":"* When in doubt, it's recommended to fully initialize the context before usage."},{"Add":"* Use ZSTD_CCtx_reset() to reset the context and ZSTD_CCtx_setParameter(),"},{"Add":"* ZSTD_CCtx_setPledgedSrcSize(), or ZSTD_CCtx_loadDictionary() and friends to"},{"Add":"* set more specific parameters, the pledged source size, or load a dictionary."},{"Add":"*"},{"Add":"* Use ZSTD_compressStream2() with ZSTD_e_continue as many times as necessary to"},{"Add":"* consume input stream. The function will automatically update both `pos`"},{"Add":"* fields within `input` and `output`."},{"Add":"* Note that the function may not consume the entire input, for example, because"},{"Add":"* the output buffer is already full, in which case `input.pos < input.size`."},{"Add":"* The caller must check if input has been entirely consumed."},{"Add":"* If not, the caller must make some room to receive more compressed data,"},{"Add":"* and then present again remaining input data."},{"Add":"* note: ZSTD_e_continue is guaranteed to make some forward progress when called,"},{"Add":"* but doesn't guarantee maximal forward progress. This is especially relevant"},{"Add":"* when compressing with multiple threads. The call won't block if it can"},{"Add":"* consume some input, but if it can't it will wait for some, but not all,"},{"Add":"* output to be flushed."},{"Add":"* @return : provides a minimum amount of data remaining to be flushed from internal buffers"},{"Add":"* or an error code, which can be tested using ZSTD_isError()."},{"Add":"*"},{"Add":"* At any moment, it's possible to flush whatever data might remain stuck within internal buffer,"},{"Add":"* using ZSTD_compressStream2() with ZSTD_e_flush. `output->pos` will be updated."},{"Add":"* Note that, if `output->size` is too small, a single invocation with ZSTD_e_flush might not be enough (return code > 0)."},{"Add":"* In which case, make some room to receive more compressed data, and call again ZSTD_compressStream2() with ZSTD_e_flush."},{"Add":"* You must continue calling ZSTD_compressStream2() with ZSTD_e_flush until it returns 0, at which point you can change the"},{"Add":"* operation."},{"Add":"* note: ZSTD_e_flush will flush as much output as possible, meaning when compressing with multiple threads, it will"},{"Add":"* block until the flush is complete or the output buffer is full."},{"Add":"* @return : 0 if internal buffers are entirely flushed,"},{"Add":"* >0 if some data still present within internal buffer (the value is minimal estimation of remaining size),"},{"Add":"* or an error code, which can be tested using ZSTD_isError()."},{"Add":"*"},{"Add":"* Calling ZSTD_compressStream2() with ZSTD_e_end instructs to finish a frame."},{"Add":"* It will perform a flush and write frame epilogue."},{"Add":"* The epilogue is required for decoders to consider a frame completed."},{"Add":"* flush operation is the same, and follows same rules as calling ZSTD_compressStream2() with ZSTD_e_flush."},{"Add":"* You must continue calling ZSTD_compressStream2() with ZSTD_e_end until it returns 0, at which point you are free to"},{"Add":"* start a new frame."},{"Add":"* note: ZSTD_e_end will flush as much output as possible, meaning when compressing with multiple threads, it will"},{"Add":"* block until the flush is complete or the output buffer is full."},{"Add":"* @return : 0 if frame fully completed and fully flushed,"},{"Add":"* >0 if some data still present within internal buffer (the value is minimal estimation of remaining size),"},{"Add":"* or an error code, which can be tested using ZSTD_isError()."},{"Add":"*"},{"Add":"* *******************************************************************/"},{"Add":""},{"Add":"typedef ZSTD_CCtx ZSTD_CStream; /**< CCtx and CStream are now effectively same object (>= v1.3.0) */"},{"Add":" /* Continue to distinguish them for compatibility with older versions <= v1.2.0 */"},{"Add":"/*===== ZSTD_CStream management functions =====*/"},{"Add":"ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream(void);"},{"Add":"ZSTDLIB_API size_t ZSTD_freeCStream(ZSTD_CStream* zcs);"},{"Add":""},{"Add":"/*===== Streaming compression functions =====*/"},{"Add":"typedef enum {"},{"Add":" ZSTD_e_continue=0, /* collect more data, encoder decides when to output compressed result, for optimal compression ratio */"},{"Add":" ZSTD_e_flush=1, /* flush any data provided so far,"},{"Add":" * it creates (at least) one new block, that can be decoded immediately on reception;"},{"Add":" * frame will continue: any future data can still reference previously compressed data, improving compression."},{"Add":" * note : multithreaded compression will block to flush as much output as possible. */"},{"Add":" ZSTD_e_end=2 /* flush any remaining data _and_ close current frame."},{"Add":" * note that frame is only closed after compressed data is fully flushed (return value == 0)."},{"Add":" * After that point, any additional data starts a new frame."},{"Add":" * note : each frame is independent (does not reference any content from previous frame)."},{"Add":" : note : multithreaded compression will block to flush as much output as possible. */"},{"Add":"} ZSTD_EndDirective;"},{"Add":""},{"Add":"/*! ZSTD_compressStream2() :"},{"Add":" * Behaves about the same as ZSTD_compressStream, with additional control on end directive."},{"Add":" * - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()"},{"Add":" * - Compression parameters cannot be changed once compression is started (save a list of exceptions in multi-threading mode)"},{"Add":" * - output->pos must be <= dstCapacity, input->pos must be <= srcSize"},{"Add":" * - output->pos and input->pos will be updated. They are guaranteed to remain below their respective limit."},{"Add":" * - endOp must be a valid directive"},{"Add":" * - When nbWorkers==0 (default), function is blocking : it completes its job before returning to caller."},{"Add":" * - When nbWorkers>=1, function is non-blocking : it copies a portion of input, distributes jobs to internal worker threads, flush to output whatever is available,"},{"Add":" * and then immediately returns, just indicating that there is some data remaining to be flushed."},{"Add":" * The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte."},{"Add":" * - 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."},{"Add":" * - @return provides a minimum amount of data remaining to be flushed from internal buffers"},{"Add":" * or an error code, which can be tested using ZSTD_isError()."},{"Add":" * if @return != 0, flush is not fully completed, there is still some data left within internal buffers."},{"Add":" * This is useful for ZSTD_e_flush, since in this case more flushes are necessary to empty all buffers."},{"Add":" * For ZSTD_e_end, @return == 0 when internal buffers are fully flushed and frame is completed."},{"Add":" * - after a ZSTD_e_end directive, if internal buffer is not fully flushed (@return != 0),"},{"Add":" * only ZSTD_e_end or ZSTD_e_flush operations are allowed."},{"Add":" * Before starting a new compression job, or changing compression parameters,"},{"Add":" * it is required to fully flush internal buffers."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,"},{"Add":" ZSTD_outBuffer* output,"},{"Add":" ZSTD_inBuffer* input,"},{"Add":" ZSTD_EndDirective endOp);"},{"Add":""},{"Add":""},{"Add":"/* These buffer sizes are softly recommended."},{"Add":" * They are not required : ZSTD_compressStream*() happily accepts any buffer size, for both input and output."},{"Add":" * Respecting the recommended size just makes it a bit easier for ZSTD_compressStream*(),"},{"Add":" * reducing the amount of memory shuffling and buffering, resulting in minor performance savings."},{"Add":" *"},{"Add":" * However, note that these recommendations are from the perspective of a C caller program."},{"Add":" * If the streaming interface is invoked from some other language,"},{"Add":" * especially managed ones such as Java or Go, through a foreign function interface such as jni or cgo,"},{"Add":" * a major performance rule is to reduce crossing such interface to an absolute minimum."},{"Add":" * It's not rare that performance ends being spent more into the interface, rather than compression itself."},{"Add":" * In which cases, prefer using large buffers, as large as practical,"},{"Add":" * for both input and output, to reduce the nb of roundtrips."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_CStreamInSize(void); /**< recommended size for input buffer */"},{"Add":"ZSTDLIB_API size_t ZSTD_CStreamOutSize(void); /**< recommended size for output buffer. Guarantee to successfully flush at least one complete compressed block. */"},{"Add":""},{"Add":""},{"Add":"/* *****************************************************************************"},{"Add":" * This following is a legacy streaming API."},{"Add":" * It can be replaced by ZSTD_CCtx_reset() and ZSTD_compressStream2()."},{"Add":" * It is redundant, but remains fully supported."},{"Add":" * Advanced parameters and dictionary compression can only be used through the"},{"Add":" * new API."},{"Add":" ******************************************************************************/"},{"Add":""},{"Add":"/*!"},{"Add":" * Equivalent to:"},{"Add":" *"},{"Add":" * ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);"},{"Add":" * ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any)"},{"Add":" * ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);"},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel);"},{"Add":"/*!"},{"Add":" * Alternative for ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue)."},{"Add":" * NOTE: The return value is different. ZSTD_compressStream() returns a hint for"},{"Add":" * the next read size (if non-zero and not an error). ZSTD_compressStream2()"},{"Add":" * returns the minimum nb of bytes left to flush (if non-zero and not an error)."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input);"},{"Add":"/*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_flush). */"},{"Add":"ZSTDLIB_API size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);"},{"Add":"/*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_end). */"},{"Add":"ZSTDLIB_API size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);"},{"Add":""},{"Add":""},{"Add":"/*-***************************************************************************"},{"Add":"* Streaming decompression - HowTo"},{"Add":"*"},{"Add":"* A ZSTD_DStream object is required to track streaming operations."},{"Add":"* Use ZSTD_createDStream() and ZSTD_freeDStream() to create/release resources."},{"Add":"* ZSTD_DStream objects can be re-used multiple times."},{"Add":"*"},{"Add":"* Use ZSTD_initDStream() to start a new decompression operation."},{"Add":"* @return : recommended first input size"},{"Add":"* Alternatively, use advanced API to set specific properties."},{"Add":"*"},{"Add":"* Use ZSTD_decompressStream() repetitively to consume your input."},{"Add":"* The function will update both `pos` fields."},{"Add":"* If `input.pos < input.size`, some input has not been consumed."},{"Add":"* It's up to the caller to present again remaining data."},{"Add":"* The function tries to flush all data decoded immediately, respecting output buffer size."},{"Add":"* If `output.pos < output.size`, decoder has flushed everything it could."},{"Add":"* But if `output.pos == output.size`, there might be some data left within internal buffers.,"},{"Add":"* In which case, call ZSTD_decompressStream() again to flush whatever remains in the buffer."},{"Add":"* Note : with no additional input provided, amount of data flushed is necessarily <= ZSTD_BLOCKSIZE_MAX."},{"Add":"* @return : 0 when a frame is completely decoded and fully flushed,"},{"Add":"* or an error code, which can be tested using ZSTD_isError(),"},{"Add":"* or any other value > 0, which means there is still some decoding or flushing to do to complete current frame :"},{"Add":"* the return value is a suggested next input size (just a hint for better latency)"},{"Add":"* that will never request more than the remaining frame size."},{"Add":"* *******************************************************************************/"},{"Add":""},{"Add":"typedef ZSTD_DCtx ZSTD_DStream; /**< DCtx and DStream are now effectively same object (>= v1.3.0) */"},{"Add":" /* For compatibility with versions <= v1.2.0, prefer differentiating them. */"},{"Add":"/*===== ZSTD_DStream management functions =====*/"},{"Add":"ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream(void);"},{"Add":"ZSTDLIB_API size_t ZSTD_freeDStream(ZSTD_DStream* zds);"},{"Add":""},{"Add":"/*===== Streaming decompression functions =====*/"},{"Add":""},{"Add":"/* This function is redundant with the advanced API and equivalent to:"},{"Add":" *"},{"Add":" * ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);"},{"Add":" * ZSTD_DCtx_refDDict(zds, NULL);"},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_initDStream(ZSTD_DStream* zds);"},{"Add":""},{"Add":"ZSTDLIB_API size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input);"},{"Add":""},{"Add":"ZSTDLIB_API size_t ZSTD_DStreamInSize(void); /*!< recommended size for input buffer */"},{"Add":"ZSTDLIB_API size_t ZSTD_DStreamOutSize(void); /*!< recommended size for output buffer. Guarantee to successfully flush at least one complete block in all circumstances. */"},{"Add":""},{"Add":""},{"Add":"/**************************"},{"Add":"* Simple dictionary API"},{"Add":"***************************/"},{"Add":"/*! ZSTD_compress_usingDict() :"},{"Add":" * Compression at an explicit compression level using a Dictionary."},{"Add":" * A dictionary can be any arbitrary data segment (also called a prefix),"},{"Add":" * or a buffer with specified information (see dictBuilder/zdict.h)."},{"Add":" * Note : This function loads the dictionary, resulting in significant startup delay."},{"Add":" * It's intended for a dictionary used only once."},{"Add":" * Note 2 : When `dict == NULL || dictSize < 8` no dictionary is used. */"},{"Add":"ZSTDLIB_API size_t ZSTD_compress_usingDict(ZSTD_CCtx* ctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const void* dict,size_t dictSize,"},{"Add":" int compressionLevel);"},{"Add":""},{"Add":"/*! ZSTD_decompress_usingDict() :"},{"Add":" * Decompression using a known Dictionary."},{"Add":" * Dictionary must be identical to the one used during compression."},{"Add":" * Note : This function loads the dictionary, resulting in significant startup delay."},{"Add":" * It's intended for a dictionary used only once."},{"Add":" * Note : When `dict == NULL || dictSize < 8` no dictionary is used. */"},{"Add":"ZSTDLIB_API size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const void* dict,size_t dictSize);"},{"Add":""},{"Add":""},{"Add":"/***********************************"},{"Add":" * Bulk processing dictionary API"},{"Add":" **********************************/"},{"Add":"typedef struct ZSTD_CDict_s ZSTD_CDict;"},{"Add":""},{"Add":"/*! ZSTD_createCDict() :"},{"Add":" * When compressing multiple messages or blocks using the same dictionary,"},{"Add":" * it's recommended to digest the dictionary only once, since it's a costly operation."},{"Add":" * ZSTD_createCDict() will create a state from digesting a dictionary."},{"Add":" * The resulting state can be used for future compression operations with very limited startup cost."},{"Add":" * ZSTD_CDict can be created once and shared by multiple threads concurrently, since its usage is read-only."},{"Add":" * @dictBuffer can be released after ZSTD_CDict creation, because its content is copied within CDict."},{"Add":" * Note 1 : Consider experimental function `ZSTD_createCDict_byReference()` if you prefer to not duplicate @dictBuffer content."},{"Add":" * Note 2 : A ZSTD_CDict can be created from an empty @dictBuffer,"},{"Add":" * in which case the only thing that it transports is the @compressionLevel."},{"Add":" * This can be useful in a pipeline featuring ZSTD_compress_usingCDict() exclusively,"},{"Add":" * expecting a ZSTD_CDict parameter with any data, including those without a known dictionary. */"},{"Add":"ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict(const void* dictBuffer, size_t dictSize,"},{"Add":" int compressionLevel);"},{"Add":""},{"Add":"/*! ZSTD_freeCDict() :"},{"Add":" * Function frees memory allocated by ZSTD_createCDict(). */"},{"Add":"ZSTDLIB_API size_t ZSTD_freeCDict(ZSTD_CDict* CDict);"},{"Add":""},{"Add":"/*! ZSTD_compress_usingCDict() :"},{"Add":" * Compression using a digested Dictionary."},{"Add":" * Recommended when same dictionary is used multiple times."},{"Add":" * Note : compression level is _decided at dictionary creation time_,"},{"Add":" * and frame parameters are hardcoded (dictID=yes, contentSize=yes, checksum=no) */"},{"Add":"ZSTDLIB_API size_t ZSTD_compress_usingCDict(ZSTD_CCtx* cctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const ZSTD_CDict* cdict);"},{"Add":""},{"Add":""},{"Add":"typedef struct ZSTD_DDict_s ZSTD_DDict;"},{"Add":""},{"Add":"/*! ZSTD_createDDict() :"},{"Add":" * Create a digested dictionary, ready to start decompression operation without startup delay."},{"Add":" * dictBuffer can be released after DDict creation, as its content is copied inside DDict. */"},{"Add":"ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict(const void* dictBuffer, size_t dictSize);"},{"Add":""},{"Add":"/*! ZSTD_freeDDict() :"},{"Add":" * Function frees memory allocated with ZSTD_createDDict() */"},{"Add":"ZSTDLIB_API size_t ZSTD_freeDDict(ZSTD_DDict* ddict);"},{"Add":""},{"Add":"/*! ZSTD_decompress_usingDDict() :"},{"Add":" * Decompression using a digested Dictionary."},{"Add":" * Recommended when same dictionary is used multiple times. */"},{"Add":"ZSTDLIB_API size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const ZSTD_DDict* ddict);"},{"Add":""},{"Add":""},{"Add":"/********************************"},{"Add":" * Dictionary helper functions"},{"Add":" *******************************/"},{"Add":""},{"Add":"/*! ZSTD_getDictID_fromDict() :"},{"Add":" * Provides the dictID stored within dictionary."},{"Add":" * if @return == 0, the dictionary is not conformant with Zstandard specification."},{"Add":" * It can still be loaded, but as a content-only dictionary. */"},{"Add":"ZSTDLIB_API unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize);"},{"Add":""},{"Add":"/*! ZSTD_getDictID_fromDDict() :"},{"Add":" * Provides the dictID of the dictionary loaded into `ddict`."},{"Add":" * If @return == 0, the dictionary is not conformant to Zstandard specification, or empty."},{"Add":" * Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */"},{"Add":"ZSTDLIB_API unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict);"},{"Add":""},{"Add":"/*! ZSTD_getDictID_fromFrame() :"},{"Add":" * Provides the dictID required to decompressed the frame stored within `src`."},{"Add":" * If @return == 0, the dictID could not be decoded."},{"Add":" * This could for one of the following reasons :"},{"Add":" * - The frame does not require a dictionary to be decoded (most common case)."},{"Add":" * - The frame was built with dictID intentionally removed. Whatever dictionary is necessary is a hidden information."},{"Add":" * Note : this use case also happens when using a non-conformant dictionary."},{"Add":" * - `srcSize` is too small, and as a result, the frame header could not be decoded (only possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`)."},{"Add":" * - This is not a Zstandard frame."},{"Add":" * When identifying the exact failure cause, it's possible to use ZSTD_getFrameHeader(), which will provide a more precise error code. */"},{"Add":"ZSTDLIB_API unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize);"},{"Add":""},{"Add":""},{"Add":"/*******************************************************************************"},{"Add":" * Advanced dictionary and prefix API"},{"Add":" *"},{"Add":" * This API allows dictionaries to be used with ZSTD_compress2(),"},{"Add":" * ZSTD_compressStream2(), and ZSTD_decompress(). Dictionaries are sticky, and"},{"Add":" * only reset with the context is reset with ZSTD_reset_parameters or"},{"Add":" * ZSTD_reset_session_and_parameters. Prefixes are single-use."},{"Add":" ******************************************************************************/"},{"Add":""},{"Add":""},{"Add":"/*! ZSTD_CCtx_loadDictionary() :"},{"Add":" * Create an internal CDict from `dict` buffer."},{"Add":" * Decompression will have to use same dictionary."},{"Add":" * @result : 0, or an error code (which can be tested with ZSTD_isError())."},{"Add":" * Special: Loading a NULL (or 0-size) dictionary invalidates previous dictionary,"},{"Add":" * meaning \"return to no-dictionary mode\"."},{"Add":" * Note 1 : Dictionary is sticky, it will be used for all future compressed frames."},{"Add":" * To return to \"no-dictionary\" situation, load a NULL dictionary (or reset parameters)."},{"Add":" * Note 2 : Loading a dictionary involves building tables."},{"Add":" * It's also a CPU consuming operation, with non-negligible impact on latency."},{"Add":" * Tables are dependent on compression parameters, and for this reason,"},{"Add":" * compression parameters can no longer be changed after loading a dictionary."},{"Add":" * Note 3 :`dict` content will be copied internally."},{"Add":" * Use experimental ZSTD_CCtx_loadDictionary_byReference() to reference content instead."},{"Add":" * In such a case, dictionary buffer must outlive its users."},{"Add":" * Note 4 : Use ZSTD_CCtx_loadDictionary_advanced()"},{"Add":" * to precisely select how dictionary content must be interpreted. */"},{"Add":"ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary(ZSTD_CCtx* cctx, const void* dict, size_t dictSize);"},{"Add":""},{"Add":"/*! ZSTD_CCtx_refCDict() :"},{"Add":" * Reference a prepared dictionary, to be used for all next compressed frames."},{"Add":" * Note that compression parameters are enforced from within CDict,"},{"Add":" * and supersede any compression parameter previously set within CCtx."},{"Add":" * The parameters ignored are labelled as \"superseded-by-cdict\" in the ZSTD_cParameter enum docs."},{"Add":" * The ignored parameters will be used again if the CCtx is returned to no-dictionary mode."},{"Add":" * The dictionary will remain valid for future compressed frames using same CCtx."},{"Add":" * @result : 0, or an error code (which can be tested with ZSTD_isError())."},{"Add":" * Special : Referencing a NULL CDict means \"return to no-dictionary mode\"."},{"Add":" * Note 1 : Currently, only one dictionary can be managed."},{"Add":" * Referencing a new dictionary effectively \"discards\" any previous one."},{"Add":" * Note 2 : CDict is just referenced, its lifetime must outlive its usage within CCtx. */"},{"Add":"ZSTDLIB_API size_t ZSTD_CCtx_refCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict);"},{"Add":""},{"Add":"/*! ZSTD_CCtx_refPrefix() :"},{"Add":" * Reference a prefix (single-usage dictionary) for next compressed frame."},{"Add":" * A prefix is **only used once**. Tables are discarded at end of frame (ZSTD_e_end)."},{"Add":" * Decompression will need same prefix to properly regenerate data."},{"Add":" * Compressing with a prefix is similar in outcome as performing a diff and compressing it,"},{"Add":" * but performs much faster, especially during decompression (compression speed is tunable with compression level)."},{"Add":" * @result : 0, or an error code (which can be tested with ZSTD_isError())."},{"Add":" * Special: Adding any prefix (including NULL) invalidates any previous prefix or dictionary"},{"Add":" * Note 1 : Prefix buffer is referenced. It **must** outlive compression."},{"Add":" * Its content must remain unmodified during compression."},{"Add":" * Note 2 : If the intention is to diff some large src data blob with some prior version of itself,"},{"Add":" * ensure that the window size is large enough to contain the entire source."},{"Add":" * See ZSTD_c_windowLog."},{"Add":" * Note 3 : Referencing a prefix involves building tables, which are dependent on compression parameters."},{"Add":" * It's a CPU consuming operation, with non-negligible impact on latency."},{"Add":" * If there is a need to use the same prefix multiple times, consider loadDictionary instead."},{"Add":" * Note 4 : By default, the prefix is interpreted as raw content (ZSTD_dct_rawContent)."},{"Add":" * Use experimental ZSTD_CCtx_refPrefix_advanced() to alter dictionary interpretation. */"},{"Add":"ZSTDLIB_API size_t ZSTD_CCtx_refPrefix(ZSTD_CCtx* cctx,"},{"Add":" const void* prefix, size_t prefixSize);"},{"Add":""},{"Add":"/*! ZSTD_DCtx_loadDictionary() :"},{"Add":" * Create an internal DDict from dict buffer,"},{"Add":" * to be used to decompress next frames."},{"Add":" * The dictionary remains valid for all future frames, until explicitly invalidated."},{"Add":" * @result : 0, or an error code (which can be tested with ZSTD_isError())."},{"Add":" * Special : Adding a NULL (or 0-size) dictionary invalidates any previous dictionary,"},{"Add":" * meaning \"return to no-dictionary mode\"."},{"Add":" * Note 1 : Loading a dictionary involves building tables,"},{"Add":" * which has a non-negligible impact on CPU usage and latency."},{"Add":" * It's recommended to \"load once, use many times\", to amortize the cost"},{"Add":" * Note 2 :`dict` content will be copied internally, so `dict` can be released after loading."},{"Add":" * Use ZSTD_DCtx_loadDictionary_byReference() to reference dictionary content instead."},{"Add":" * Note 3 : Use ZSTD_DCtx_loadDictionary_advanced() to take control of"},{"Add":" * how dictionary content is loaded and interpreted."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);"},{"Add":""},{"Add":"/*! ZSTD_DCtx_refDDict() :"},{"Add":" * Reference a prepared dictionary, to be used to decompress next frames."},{"Add":" * The dictionary remains active for decompression of future frames using same DCtx."},{"Add":" *"},{"Add":" * If called with ZSTD_d_refMultipleDDicts enabled, repeated calls of this function"},{"Add":" * will store the DDict references in a table, and the DDict used for decompression"},{"Add":" * will be determined at decompression time, as per the dict ID in the frame."},{"Add":" * The memory for the table is allocated on the first call to refDDict, and can be"},{"Add":" * freed with ZSTD_freeDCtx()."},{"Add":" *"},{"Add":" * @result : 0, or an error code (which can be tested with ZSTD_isError())."},{"Add":" * Note 1 : Currently, only one dictionary can be managed."},{"Add":" * Referencing a new dictionary effectively \"discards\" any previous one."},{"Add":" * Special: referencing a NULL DDict means \"return to no-dictionary mode\"."},{"Add":" * Note 2 : DDict is just referenced, its lifetime must outlive its usage from DCtx."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);"},{"Add":""},{"Add":"/*! ZSTD_DCtx_refPrefix() :"},{"Add":" * Reference a prefix (single-usage dictionary) to decompress next frame."},{"Add":" * This is the reverse operation of ZSTD_CCtx_refPrefix(),"},{"Add":" * and must use the same prefix as the one used during compression."},{"Add":" * Prefix is **only used once**. Reference is discarded at end of frame."},{"Add":" * End of frame is reached when ZSTD_decompressStream() returns 0."},{"Add":" * @result : 0, or an error code (which can be tested with ZSTD_isError())."},{"Add":" * Note 1 : Adding any prefix (including NULL) invalidates any previously set prefix or dictionary"},{"Add":" * Note 2 : Prefix buffer is referenced. It **must** outlive decompression."},{"Add":" * Prefix buffer must remain unmodified up to the end of frame,"},{"Add":" * reached when ZSTD_decompressStream() returns 0."},{"Add":" * Note 3 : By default, the prefix is treated as raw content (ZSTD_dct_rawContent)."},{"Add":" * Use ZSTD_CCtx_refPrefix_advanced() to alter dictMode (Experimental section)"},{"Add":" * Note 4 : Referencing a raw content prefix has almost no cpu nor memory cost."},{"Add":" * A full dictionary is more costly, as it requires building tables."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx,"},{"Add":" const void* prefix, size_t prefixSize);"},{"Add":""},{"Add":"/* === Memory management === */"},{"Add":""},{"Add":"/*! ZSTD_sizeof_*() :"},{"Add":" * These functions give the _current_ memory usage of selected object."},{"Add":" * Note that object memory usage can evolve (increase or decrease) over time. */"},{"Add":"ZSTDLIB_API size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx);"},{"Add":"ZSTDLIB_API size_t ZSTD_sizeof_DCtx(const ZSTD_DCtx* dctx);"},{"Add":"ZSTDLIB_API size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs);"},{"Add":"ZSTDLIB_API size_t ZSTD_sizeof_DStream(const ZSTD_DStream* zds);"},{"Add":"ZSTDLIB_API size_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict);"},{"Add":"ZSTDLIB_API size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict);"},{"Add":""},{"Add":"#endif /* ZSTD_H_235446 */"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************************************"},{"Add":" * ADVANCED AND EXPERIMENTAL FUNCTIONS"},{"Add":" ****************************************************************************************"},{"Add":" * The definitions in the following section are considered experimental."},{"Add":" * They are provided for advanced scenarios."},{"Add":" * They should never be used with a dynamic library, as prototypes may change in the future."},{"Add":" * Use them only in association with static linking."},{"Add":" * ***************************************************************************************/"},{"Add":""},{"Add":"#if defined(ZSTD_STATIC_LINKING_ONLY) && !defined(ZSTD_H_ZSTD_STATIC_LINKING_ONLY)"},{"Add":"#define ZSTD_H_ZSTD_STATIC_LINKING_ONLY"},{"Add":""},{"Add":"/****************************************************************************************"},{"Add":" * experimental API (static linking only)"},{"Add":" ****************************************************************************************"},{"Add":" * The following symbols and constants"},{"Add":" * are not planned to join \"stable API\" status in the near future."},{"Add":" * They can still change in future versions."},{"Add":" * Some of them are planned to remain in the static_only section indefinitely."},{"Add":" * Some of them might be removed in the future (especially when redundant with existing stable functions)"},{"Add":" * ***************************************************************************************/"},{"Add":""},{"Add":"#define ZSTD_FRAMEHEADERSIZE_PREFIX(format) ((format) == ZSTD_f_zstd1 ? 5 : 1) /* minimum input size required to query frame header size */"},{"Add":"#define ZSTD_FRAMEHEADERSIZE_MIN(format) ((format) == ZSTD_f_zstd1 ? 6 : 2)"},{"Add":"#define ZSTD_FRAMEHEADERSIZE_MAX 18 /* can be useful for static allocation */"},{"Add":"#define ZSTD_SKIPPABLEHEADERSIZE 8"},{"Add":""},{"Add":"/* compression parameter bounds */"},{"Add":"#define ZSTD_WINDOWLOG_MAX_32 30"},{"Add":"#define ZSTD_WINDOWLOG_MAX_64 31"},{"Add":"#define ZSTD_WINDOWLOG_MAX ((int)(sizeof(size_t) == 4 ? ZSTD_WINDOWLOG_MAX_32 : ZSTD_WINDOWLOG_MAX_64))"},{"Add":"#define ZSTD_WINDOWLOG_MIN 10"},{"Add":"#define ZSTD_HASHLOG_MAX ((ZSTD_WINDOWLOG_MAX < 30) ? ZSTD_WINDOWLOG_MAX : 30)"},{"Add":"#define ZSTD_HASHLOG_MIN 6"},{"Add":"#define ZSTD_CHAINLOG_MAX_32 29"},{"Add":"#define ZSTD_CHAINLOG_MAX_64 30"},{"Add":"#define ZSTD_CHAINLOG_MAX ((int)(sizeof(size_t) == 4 ? ZSTD_CHAINLOG_MAX_32 : ZSTD_CHAINLOG_MAX_64))"},{"Add":"#define ZSTD_CHAINLOG_MIN ZSTD_HASHLOG_MIN"},{"Add":"#define ZSTD_SEARCHLOG_MAX (ZSTD_WINDOWLOG_MAX-1)"},{"Add":"#define ZSTD_SEARCHLOG_MIN 1"},{"Add":"#define ZSTD_MINMATCH_MAX 7 /* only for ZSTD_fast, other strategies are limited to 6 */"},{"Add":"#define ZSTD_MINMATCH_MIN 3 /* only for ZSTD_btopt+, faster strategies are limited to 4 */"},{"Add":"#define ZSTD_TARGETLENGTH_MAX ZSTD_BLOCKSIZE_MAX"},{"Add":"#define ZSTD_TARGETLENGTH_MIN 0 /* note : comparing this constant to an unsigned results in a tautological test */"},{"Add":"#define ZSTD_STRATEGY_MIN ZSTD_fast"},{"Add":"#define ZSTD_STRATEGY_MAX ZSTD_btultra2"},{"Add":""},{"Add":""},{"Add":"#define ZSTD_OVERLAPLOG_MIN 0"},{"Add":"#define ZSTD_OVERLAPLOG_MAX 9"},{"Add":""},{"Add":"#define ZSTD_WINDOWLOG_LIMIT_DEFAULT 27 /* by default, the streaming decoder will refuse any frame"},{"Add":" * requiring larger than (1< 0:"},{"Add":" * If litLength != 0:"},{"Add":" * rep == 1 --> offset == repeat_offset_1"},{"Add":" * rep == 2 --> offset == repeat_offset_2"},{"Add":" * rep == 3 --> offset == repeat_offset_3"},{"Add":" * If litLength == 0:"},{"Add":" * rep == 1 --> offset == repeat_offset_2"},{"Add":" * rep == 2 --> offset == repeat_offset_3"},{"Add":" * rep == 3 --> offset == repeat_offset_1 - 1"},{"Add":" *"},{"Add":" * Note: This field is optional. ZSTD_generateSequences() will calculate the value of"},{"Add":" * 'rep', but repeat offsets do not necessarily need to be calculated from an external"},{"Add":" * sequence provider's perspective. For example, ZSTD_compressSequences() does not"},{"Add":" * use this 'rep' field at all (as of now)."},{"Add":" */"},{"Add":"} ZSTD_Sequence;"},{"Add":""},{"Add":"typedef struct {"},{"Add":" unsigned windowLog; /**< largest match distance : larger == more compression, more memory needed during decompression */"},{"Add":" unsigned chainLog; /**< fully searched segment : larger == more compression, slower, more memory (useless for fast) */"},{"Add":" unsigned hashLog; /**< dispatch table : larger == faster, more memory */"},{"Add":" unsigned searchLog; /**< nb of searches : larger == more compression, slower */"},{"Add":" unsigned minMatch; /**< match length searched : larger == faster decompression, sometimes less compression */"},{"Add":" unsigned targetLength; /**< acceptable match size for optimal parser (only) : larger == more compression, slower */"},{"Add":" ZSTD_strategy strategy; /**< see ZSTD_strategy definition above */"},{"Add":"} ZSTD_compressionParameters;"},{"Add":""},{"Add":"typedef struct {"},{"Add":" int contentSizeFlag; /**< 1: content size will be in frame header (when known) */"},{"Add":" int checksumFlag; /**< 1: generate a 32-bits checksum using XXH64 algorithm at end of frame, for error detection */"},{"Add":" int noDictIDFlag; /**< 1: no dictID will be saved into frame header (dictID is only useful for dictionary compression) */"},{"Add":"} ZSTD_frameParameters;"},{"Add":""},{"Add":"typedef struct {"},{"Add":" ZSTD_compressionParameters cParams;"},{"Add":" ZSTD_frameParameters fParams;"},{"Add":"} ZSTD_parameters;"},{"Add":""},{"Add":"typedef enum {"},{"Add":" ZSTD_dct_auto = 0, /* dictionary is \"full\" when starting with ZSTD_MAGIC_DICTIONARY, otherwise it is \"rawContent\" */"},{"Add":" ZSTD_dct_rawContent = 1, /* ensures dictionary is always loaded as rawContent, even if it starts with ZSTD_MAGIC_DICTIONARY */"},{"Add":" ZSTD_dct_fullDict = 2 /* refuses to load a dictionary if it does not respect Zstandard's specification, starting with ZSTD_MAGIC_DICTIONARY */"},{"Add":"} ZSTD_dictContentType_e;"},{"Add":""},{"Add":"typedef enum {"},{"Add":" ZSTD_dlm_byCopy = 0, /**< Copy dictionary content internally */"},{"Add":" ZSTD_dlm_byRef = 1 /**< Reference dictionary content -- the dictionary buffer must outlive its users. */"},{"Add":"} ZSTD_dictLoadMethod_e;"},{"Add":""},{"Add":"typedef enum {"},{"Add":" ZSTD_f_zstd1 = 0, /* zstd frame format, specified in zstd_compression_format.md (default) */"},{"Add":" ZSTD_f_zstd1_magicless = 1 /* Variant of zstd frame format, without initial 4-bytes magic number."},{"Add":" * Useful to save 4 bytes per generated frame."},{"Add":" * Decoder cannot recognise automatically this format, requiring this instruction. */"},{"Add":"} ZSTD_format_e;"},{"Add":""},{"Add":"typedef enum {"},{"Add":" /* Note: this enum controls ZSTD_d_forceIgnoreChecksum */"},{"Add":" ZSTD_d_validateChecksum = 0,"},{"Add":" ZSTD_d_ignoreChecksum = 1"},{"Add":"} ZSTD_forceIgnoreChecksum_e;"},{"Add":""},{"Add":"typedef enum {"},{"Add":" /* Note: this enum controls ZSTD_d_refMultipleDDicts */"},{"Add":" ZSTD_rmd_refSingleDDict = 0,"},{"Add":" ZSTD_rmd_refMultipleDDicts = 1"},{"Add":"} ZSTD_refMultipleDDicts_e;"},{"Add":""},{"Add":"typedef enum {"},{"Add":" /* Note: this enum and the behavior it controls are effectively internal"},{"Add":" * implementation details of the compressor. They are expected to continue"},{"Add":" * to evolve and should be considered only in the context of extremely"},{"Add":" * advanced performance tuning."},{"Add":" *"},{"Add":" * Zstd currently supports the use of a CDict in three ways:"},{"Add":" *"},{"Add":" * - The contents of the CDict can be copied into the working context. This"},{"Add":" * means that the compression can search both the dictionary and input"},{"Add":" * while operating on a single set of internal tables. This makes"},{"Add":" * the compression faster per-byte of input. However, the initial copy of"},{"Add":" * the CDict's tables incurs a fixed cost at the beginning of the"},{"Add":" * compression. For small compressions (< 8 KB), that copy can dominate"},{"Add":" * the cost of the compression."},{"Add":" *"},{"Add":" * - The CDict's tables can be used in-place. In this model, compression is"},{"Add":" * slower per input byte, because the compressor has to search two sets of"},{"Add":" * tables. However, this model incurs no start-up cost (as long as the"},{"Add":" * working context's tables can be reused). For small inputs, this can be"},{"Add":" * faster than copying the CDict's tables."},{"Add":" *"},{"Add":" * - The CDict's tables are not used at all, and instead we use the working"},{"Add":" * context alone to reload the dictionary and use params based on the source"},{"Add":" * size. See ZSTD_compress_insertDictionary() and ZSTD_compress_usingDict()."},{"Add":" * This method is effective when the dictionary sizes are very small relative"},{"Add":" * to the input size, and the input size is fairly large to begin with."},{"Add":" *"},{"Add":" * Zstd has a simple internal heuristic that selects which strategy to use"},{"Add":" * at the beginning of a compression. However, if experimentation shows that"},{"Add":" * Zstd is making poor choices, it is possible to override that choice with"},{"Add":" * this enum."},{"Add":" */"},{"Add":" ZSTD_dictDefaultAttach = 0, /* Use the default heuristic. */"},{"Add":" ZSTD_dictForceAttach = 1, /* Never copy the dictionary. */"},{"Add":" ZSTD_dictForceCopy = 2, /* Always copy the dictionary. */"},{"Add":" ZSTD_dictForceLoad = 3 /* Always reload the dictionary */"},{"Add":"} ZSTD_dictAttachPref_e;"},{"Add":""},{"Add":"typedef enum {"},{"Add":" ZSTD_lcm_auto = 0, /**< Automatically determine the compression mode based on the compression level."},{"Add":" * Negative compression levels will be uncompressed, and positive compression"},{"Add":" * levels will be compressed. */"},{"Add":" ZSTD_lcm_huffman = 1, /**< Always attempt Huffman compression. Uncompressed literals will still be"},{"Add":" * emitted if Huffman compression is not profitable. */"},{"Add":" ZSTD_lcm_uncompressed = 2 /**< Always emit uncompressed literals. */"},{"Add":"} ZSTD_literalCompressionMode_e;"},{"Add":""},{"Add":""},{"Add":"/***************************************"},{"Add":"* Frame size functions"},{"Add":"***************************************/"},{"Add":""},{"Add":"/*! ZSTD_findDecompressedSize() :"},{"Add":" * `src` should point to the start of a series of ZSTD encoded and/or skippable frames"},{"Add":" * `srcSize` must be the _exact_ size of this series"},{"Add":" * (i.e. there should be a frame boundary at `src + srcSize`)"},{"Add":" * @return : - decompressed size of all data in all successive frames"},{"Add":" * - if the decompressed size cannot be determined: ZSTD_CONTENTSIZE_UNKNOWN"},{"Add":" * - if an error occurred: ZSTD_CONTENTSIZE_ERROR"},{"Add":" *"},{"Add":" * note 1 : decompressed size is an optional field, that may not be present, especially in streaming mode."},{"Add":" * When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size."},{"Add":" * In which case, it's necessary to use streaming mode to decompress data."},{"Add":" * note 2 : decompressed size is always present when compression is done with ZSTD_compress()"},{"Add":" * note 3 : decompressed size can be very large (64-bits value),"},{"Add":" * potentially larger than what local system can handle as a single memory segment."},{"Add":" * In which case, it's necessary to use streaming mode to decompress data."},{"Add":" * note 4 : If source is untrusted, decompressed size could be wrong or intentionally modified."},{"Add":" * Always ensure result fits within application's authorized limits."},{"Add":" * Each application can set its own limits."},{"Add":" * note 5 : ZSTD_findDecompressedSize handles multiple frames, and so it must traverse the input to"},{"Add":" * read each contained frame header. This is fast as most of the data is skipped,"},{"Add":" * however it does mean that all frame data must be present and valid. */"},{"Add":"ZSTDLIB_API unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize);"},{"Add":""},{"Add":"/*! ZSTD_decompressBound() :"},{"Add":" * `src` should point to the start of a series of ZSTD encoded and/or skippable frames"},{"Add":" * `srcSize` must be the _exact_ size of this series"},{"Add":" * (i.e. there should be a frame boundary at `src + srcSize`)"},{"Add":" * @return : - upper-bound for the decompressed size of all data in all successive frames"},{"Add":" * - if an error occurred: ZSTD_CONTENTSIZE_ERROR"},{"Add":" *"},{"Add":" * note 1 : an error can occur if `src` contains an invalid or incorrectly formatted frame."},{"Add":" * note 2 : the upper-bound is exact when the decompressed size field is available in every ZSTD encoded frame of `src`."},{"Add":" * in this case, `ZSTD_findDecompressedSize` and `ZSTD_decompressBound` return the same value."},{"Add":" * note 3 : when the decompressed size field isn't available, the upper-bound for that frame is calculated by:"},{"Add":" * upper-bound = # blocks * min(128 KB, Window_Size)"},{"Add":" */"},{"Add":"ZSTDLIB_API unsigned long long ZSTD_decompressBound(const void* src, size_t srcSize);"},{"Add":""},{"Add":"/*! ZSTD_frameHeaderSize() :"},{"Add":" * srcSize must be >= ZSTD_FRAMEHEADERSIZE_PREFIX."},{"Add":" * @return : size of the Frame Header,"},{"Add":" * or an error code (if srcSize is too small) */"},{"Add":"ZSTDLIB_API size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize);"},{"Add":""},{"Add":"typedef enum {"},{"Add":" ZSTD_sf_noBlockDelimiters = 0, /* Representation of ZSTD_Sequence has no block delimiters, sequences only */"},{"Add":" ZSTD_sf_explicitBlockDelimiters = 1 /* Representation of ZSTD_Sequence contains explicit block delimiters */"},{"Add":"} ZSTD_sequenceFormat_e;"},{"Add":""},{"Add":"/*! ZSTD_generateSequences() :"},{"Add":" * Generate sequences using ZSTD_compress2, given a source buffer."},{"Add":" *"},{"Add":" * Each block will end with a dummy sequence"},{"Add":" * with offset == 0, matchLength == 0, and litLength == length of last literals."},{"Add":" * litLength may be == 0, and if so, then the sequence of (of: 0 ml: 0 ll: 0)"},{"Add":" * simply acts as a block delimiter."},{"Add":" *"},{"Add":" * zc can be used to insert custom compression params."},{"Add":" * This function invokes ZSTD_compress2"},{"Add":" *"},{"Add":" * The output of this function can be fed into ZSTD_compressSequences() with CCtx"},{"Add":" * setting of ZSTD_c_blockDelimiters as ZSTD_sf_explicitBlockDelimiters"},{"Add":" * @return : number of sequences generated"},{"Add":" */"},{"Add":""},{"Add":"ZSTDLIB_API size_t ZSTD_generateSequences(ZSTD_CCtx* zc, ZSTD_Sequence* outSeqs,"},{"Add":" size_t outSeqsSize, const void* src, size_t srcSize);"},{"Add":""},{"Add":"/*! ZSTD_mergeBlockDelimiters() :"},{"Add":" * Given an array of ZSTD_Sequence, remove all sequences that represent block delimiters/last literals"},{"Add":" * by merging them into into the literals of the next sequence."},{"Add":" *"},{"Add":" * As such, the final generated result has no explicit representation of block boundaries,"},{"Add":" * and the final last literals segment is not represented in the sequences."},{"Add":" *"},{"Add":" * The output of this function can be fed into ZSTD_compressSequences() with CCtx"},{"Add":" * setting of ZSTD_c_blockDelimiters as ZSTD_sf_noBlockDelimiters"},{"Add":" * @return : number of sequences left after merging"},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_mergeBlockDelimiters(ZSTD_Sequence* sequences, size_t seqsSize);"},{"Add":""},{"Add":"/*! ZSTD_compressSequences() :"},{"Add":" * Compress an array of ZSTD_Sequence, generated from the original source buffer, into dst."},{"Add":" * If a dictionary is included, then the cctx should reference the dict. (see: ZSTD_CCtx_refCDict(), ZSTD_CCtx_loadDictionary(), etc.)"},{"Add":" * The entire source is compressed into a single frame."},{"Add":" *"},{"Add":" * The compression behavior changes based on cctx params. In particular:"},{"Add":" * If ZSTD_c_blockDelimiters == ZSTD_sf_noBlockDelimiters, the array of ZSTD_Sequence is expected to contain"},{"Add":" * no block delimiters (defined in ZSTD_Sequence). Block boundaries are roughly determined based on"},{"Add":" * the block size derived from the cctx, and sequences may be split. This is the default setting."},{"Add":" *"},{"Add":" * If ZSTD_c_blockDelimiters == ZSTD_sf_explicitBlockDelimiters, the array of ZSTD_Sequence is expected to contain"},{"Add":" * block delimiters (defined in ZSTD_Sequence). Behavior is undefined if no block delimiters are provided."},{"Add":" *"},{"Add":" * If ZSTD_c_validateSequences == 0, this function will blindly accept the sequences provided. Invalid sequences cause undefined"},{"Add":" * behavior. If ZSTD_c_validateSequences == 1, then if sequence is invalid (see doc/zstd_compression_format.md for"},{"Add":" * specifics regarding offset/matchlength requirements) then the function will bail out and return an error."},{"Add":" *"},{"Add":" * In addition to the two adjustable experimental params, there are other important cctx params."},{"Add":" * - ZSTD_c_minMatch MUST be set as less than or equal to the smallest match generated by the match finder. It has a minimum value of ZSTD_MINMATCH_MIN."},{"Add":" * - ZSTD_c_compressionLevel accordingly adjusts the strength of the entropy coder, as it would in typical compression."},{"Add":" * - ZSTD_c_windowLog affects offset validation: this function will return an error at higher debug levels if a provided offset"},{"Add":" * is larger than what the spec allows for a given window log and dictionary (if present). See: doc/zstd_compression_format.md"},{"Add":" *"},{"Add":" * Note: Repcodes are, as of now, always re-calculated within this function, so ZSTD_Sequence::rep is unused."},{"Add":" * Note 2: Once we integrate ability to ingest repcodes, the explicit block delims mode must respect those repcodes exactly,"},{"Add":" * and cannot emit an RLE block that disagrees with the repcode history"},{"Add":" * @return : final compressed size or a ZSTD error."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_compressSequences(ZSTD_CCtx* const cctx, void* dst, size_t dstSize,"},{"Add":" const ZSTD_Sequence* inSeqs, size_t inSeqsSize,"},{"Add":" const void* src, size_t srcSize);"},{"Add":""},{"Add":""},{"Add":"/*! ZSTD_writeSkippableFrame() :"},{"Add":" * Generates a zstd skippable frame containing data given by src, and writes it to dst buffer."},{"Add":" *"},{"Add":" * Skippable frames begin with a a 4-byte magic number. There are 16 possible choices of magic number,"},{"Add":" * ranging from ZSTD_MAGIC_SKIPPABLE_START to ZSTD_MAGIC_SKIPPABLE_START+15."},{"Add":" * As such, the parameter magicVariant controls the exact skippable frame magic number variant used, so"},{"Add":" * the magic number used will be ZSTD_MAGIC_SKIPPABLE_START + magicVariant."},{"Add":" *"},{"Add":" * Returns an error if destination buffer is not large enough, if the source size is not representable"},{"Add":" * with a 4-byte unsigned int, or if the parameter magicVariant is greater than 15 (and therefore invalid)."},{"Add":" *"},{"Add":" * @return : number of bytes written or a ZSTD error."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_writeSkippableFrame(void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize, unsigned magicVariant);"},{"Add":""},{"Add":""},{"Add":"/***************************************"},{"Add":"* Memory management"},{"Add":"***************************************/"},{"Add":""},{"Add":"/*! ZSTD_estimate*() :"},{"Add":" * These functions make it possible to estimate memory usage"},{"Add":" * of a future {D,C}Ctx, before its creation."},{"Add":" *"},{"Add":" * ZSTD_estimateCCtxSize() will provide a memory budget large enough"},{"Add":" * for any compression level up to selected one."},{"Add":" * Note : Unlike ZSTD_estimateCStreamSize*(), this estimate"},{"Add":" * does not include space for a window buffer."},{"Add":" * Therefore, the estimation is only guaranteed for single-shot compressions, not streaming."},{"Add":" * The estimate will assume the input may be arbitrarily large,"},{"Add":" * which is the worst case."},{"Add":" *"},{"Add":" * When srcSize can be bound by a known and rather \"small\" value,"},{"Add":" * this fact can be used to provide a tighter estimation"},{"Add":" * because the CCtx compression context will need less memory."},{"Add":" * This tighter estimation can be provided by more advanced functions"},{"Add":" * ZSTD_estimateCCtxSize_usingCParams(), which can be used in tandem with ZSTD_getCParams(),"},{"Add":" * and ZSTD_estimateCCtxSize_usingCCtxParams(), which can be used in tandem with ZSTD_CCtxParams_setParameter()."},{"Add":" * Both can be used to estimate memory using custom compression parameters and arbitrary srcSize limits."},{"Add":" *"},{"Add":" * Note 2 : only single-threaded compression is supported."},{"Add":" * ZSTD_estimateCCtxSize_usingCCtxParams() will return an error code if ZSTD_c_nbWorkers is >= 1."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_estimateCCtxSize(int compressionLevel);"},{"Add":"ZSTDLIB_API size_t ZSTD_estimateCCtxSize_usingCParams(ZSTD_compressionParameters cParams);"},{"Add":"ZSTDLIB_API size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params);"},{"Add":"ZSTDLIB_API size_t ZSTD_estimateDCtxSize(void);"},{"Add":""},{"Add":"/*! ZSTD_estimateCStreamSize() :"},{"Add":" * ZSTD_estimateCStreamSize() will provide a budget large enough for any compression level up to selected one."},{"Add":" * It will also consider src size to be arbitrarily \"large\", which is worst case."},{"Add":" * If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation."},{"Add":" * ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel."},{"Add":" * ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParams_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_c_nbWorkers is >= 1."},{"Add":" * Note : CStream size estimation is only correct for single-threaded compression."},{"Add":" * ZSTD_DStream memory budget depends on window Size."},{"Add":" * This information can be passed manually, using ZSTD_estimateDStreamSize,"},{"Add":" * or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame();"},{"Add":" * Note : if streaming is init with function ZSTD_init?Stream_usingDict(),"},{"Add":" * an internal ?Dict will be created, which additional size is not estimated here."},{"Add":" * In this case, get total size by adding ZSTD_estimate?DictSize */"},{"Add":"ZSTDLIB_API size_t ZSTD_estimateCStreamSize(int compressionLevel);"},{"Add":"ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams);"},{"Add":"ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params);"},{"Add":"ZSTDLIB_API size_t ZSTD_estimateDStreamSize(size_t windowSize);"},{"Add":"ZSTDLIB_API size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize);"},{"Add":""},{"Add":"/*! ZSTD_estimate?DictSize() :"},{"Add":" * ZSTD_estimateCDictSize() will bet that src size is relatively \"small\", and content is copied, like ZSTD_createCDict()."},{"Add":" * ZSTD_estimateCDictSize_advanced() makes it possible to control compression parameters precisely, like ZSTD_createCDict_advanced()."},{"Add":" * Note : dictionaries created by reference (`ZSTD_dlm_byRef`) are logically smaller."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel);"},{"Add":"ZSTDLIB_API size_t ZSTD_estimateCDictSize_advanced(size_t dictSize, ZSTD_compressionParameters cParams, ZSTD_dictLoadMethod_e dictLoadMethod);"},{"Add":"ZSTDLIB_API size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod);"},{"Add":""},{"Add":"/*! ZSTD_initStatic*() :"},{"Add":" * Initialize an object using a pre-allocated fixed-size buffer."},{"Add":" * workspace: The memory area to emplace the object into."},{"Add":" * Provided pointer *must be 8-bytes aligned*."},{"Add":" * Buffer must outlive object."},{"Add":" * workspaceSize: Use ZSTD_estimate*Size() to determine"},{"Add":" * how large workspace must be to support target scenario."},{"Add":" * @return : pointer to object (same address as workspace, just different type),"},{"Add":" * or NULL if error (size too small, incorrect alignment, etc.)"},{"Add":" * Note : zstd will never resize nor malloc() when using a static buffer."},{"Add":" * If the object requires more memory than available,"},{"Add":" * zstd will just error out (typically ZSTD_error_memory_allocation)."},{"Add":" * Note 2 : there is no corresponding \"free\" function."},{"Add":" * Since workspace is allocated externally, it must be freed externally too."},{"Add":" * Note 3 : cParams : use ZSTD_getCParams() to convert a compression level"},{"Add":" * into its associated cParams."},{"Add":" * Limitation 1 : currently not compatible with internal dictionary creation, triggered by"},{"Add":" * ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict()."},{"Add":" * Limitation 2 : static cctx currently not compatible with multi-threading."},{"Add":" * Limitation 3 : static dctx is incompatible with legacy support."},{"Add":" */"},{"Add":"ZSTDLIB_API ZSTD_CCtx* ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize);"},{"Add":"ZSTDLIB_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize); /**< same as ZSTD_initStaticCCtx() */"},{"Add":""},{"Add":"ZSTDLIB_API ZSTD_DCtx* ZSTD_initStaticDCtx(void* workspace, size_t workspaceSize);"},{"Add":"ZSTDLIB_API ZSTD_DStream* ZSTD_initStaticDStream(void* workspace, size_t workspaceSize); /**< same as ZSTD_initStaticDCtx() */"},{"Add":""},{"Add":"ZSTDLIB_API const ZSTD_CDict* ZSTD_initStaticCDict("},{"Add":" void* workspace, size_t workspaceSize,"},{"Add":" const void* dict, size_t dictSize,"},{"Add":" ZSTD_dictLoadMethod_e dictLoadMethod,"},{"Add":" ZSTD_dictContentType_e dictContentType,"},{"Add":" ZSTD_compressionParameters cParams);"},{"Add":""},{"Add":"ZSTDLIB_API const ZSTD_DDict* ZSTD_initStaticDDict("},{"Add":" void* workspace, size_t workspaceSize,"},{"Add":" const void* dict, size_t dictSize,"},{"Add":" ZSTD_dictLoadMethod_e dictLoadMethod,"},{"Add":" ZSTD_dictContentType_e dictContentType);"},{"Add":""},{"Add":""},{"Add":"/*! Custom memory allocation :"},{"Add":" * These prototypes make it possible to pass your own allocation/free functions."},{"Add":" * ZSTD_customMem is provided at creation time, using ZSTD_create*_advanced() variants listed below."},{"Add":" * All allocation/free operations will be completed using these custom variants instead of regular ones."},{"Add":" */"},{"Add":"typedef void* (*ZSTD_allocFunction) (void* opaque, size_t size);"},{"Add":"typedef void (*ZSTD_freeFunction) (void* opaque, void* address);"},{"Add":"typedef struct { ZSTD_allocFunction customAlloc; ZSTD_freeFunction customFree; void* opaque; } ZSTD_customMem;"},{"Add":"static"},{"Add":"#ifdef __GNUC__"},{"Add":"__attribute__((__unused__))"},{"Add":"#endif"},{"Add":"ZSTD_customMem const ZSTD_defaultCMem = { NULL, NULL, NULL }; /**< this constant defers to stdlib's functions */"},{"Add":""},{"Add":"ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem);"},{"Add":"ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem);"},{"Add":"ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem);"},{"Add":"ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem);"},{"Add":""},{"Add":"ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict_advanced(const void* dict, size_t dictSize,"},{"Add":" ZSTD_dictLoadMethod_e dictLoadMethod,"},{"Add":" ZSTD_dictContentType_e dictContentType,"},{"Add":" ZSTD_compressionParameters cParams,"},{"Add":" ZSTD_customMem customMem);"},{"Add":""},{"Add":"/* ! Thread pool :"},{"Add":" * These prototypes make it possible to share a thread pool among multiple compression contexts."},{"Add":" * This can limit resources for applications with multiple threads where each one uses"},{"Add":" * a threaded compression mode (via ZSTD_c_nbWorkers parameter)."},{"Add":" * ZSTD_createThreadPool creates a new thread pool with a given number of threads."},{"Add":" * Note that the lifetime of such pool must exist while being used."},{"Add":" * ZSTD_CCtx_refThreadPool assigns a thread pool to a context (use NULL argument value"},{"Add":" * to use an internal thread pool)."},{"Add":" * ZSTD_freeThreadPool frees a thread pool."},{"Add":" */"},{"Add":"typedef struct POOL_ctx_s ZSTD_threadPool;"},{"Add":"ZSTDLIB_API ZSTD_threadPool* ZSTD_createThreadPool(size_t numThreads);"},{"Add":"ZSTDLIB_API void ZSTD_freeThreadPool (ZSTD_threadPool* pool);"},{"Add":"ZSTDLIB_API size_t ZSTD_CCtx_refThreadPool(ZSTD_CCtx* cctx, ZSTD_threadPool* pool);"},{"Add":""},{"Add":""},{"Add":"/*"},{"Add":" * This API is temporary and is expected to change or disappear in the future!"},{"Add":" */"},{"Add":"ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict_advanced2("},{"Add":" const void* dict, size_t dictSize,"},{"Add":" ZSTD_dictLoadMethod_e dictLoadMethod,"},{"Add":" ZSTD_dictContentType_e dictContentType,"},{"Add":" const ZSTD_CCtx_params* cctxParams,"},{"Add":" ZSTD_customMem customMem);"},{"Add":""},{"Add":"ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict_advanced("},{"Add":" const void* dict, size_t dictSize,"},{"Add":" ZSTD_dictLoadMethod_e dictLoadMethod,"},{"Add":" ZSTD_dictContentType_e dictContentType,"},{"Add":" ZSTD_customMem customMem);"},{"Add":""},{"Add":""},{"Add":"/***************************************"},{"Add":"* Advanced compression functions"},{"Add":"***************************************/"},{"Add":""},{"Add":"/*! ZSTD_createCDict_byReference() :"},{"Add":" * Create a digested dictionary for compression"},{"Add":" * Dictionary content is just referenced, not duplicated."},{"Add":" * As a consequence, `dictBuffer` **must** outlive CDict,"},{"Add":" * and its content must remain unmodified throughout the lifetime of CDict."},{"Add":" * note: equivalent to ZSTD_createCDict_advanced(), with dictLoadMethod==ZSTD_dlm_byRef */"},{"Add":"ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict_byReference(const void* dictBuffer, size_t dictSize, int compressionLevel);"},{"Add":""},{"Add":"/*! ZSTD_getDictID_fromCDict() :"},{"Add":" * Provides the dictID of the dictionary loaded into `cdict`."},{"Add":" * If @return == 0, the dictionary is not conformant to Zstandard specification, or empty."},{"Add":" * Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */"},{"Add":"ZSTDLIB_API unsigned ZSTD_getDictID_fromCDict(const ZSTD_CDict* cdict);"},{"Add":""},{"Add":"/*! ZSTD_getCParams() :"},{"Add":" * @return ZSTD_compressionParameters structure for a selected compression level and estimated srcSize."},{"Add":" * `estimatedSrcSize` value is optional, select 0 if not known */"},{"Add":"ZSTDLIB_API ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize);"},{"Add":""},{"Add":"/*! ZSTD_getParams() :"},{"Add":" * same as ZSTD_getCParams(), but @return a full `ZSTD_parameters` object instead of sub-component `ZSTD_compressionParameters`."},{"Add":" * All fields of `ZSTD_frameParameters` are set to default : contentSize=1, checksum=0, noDictID=0 */"},{"Add":"ZSTDLIB_API ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize);"},{"Add":""},{"Add":"/*! ZSTD_checkCParams() :"},{"Add":" * Ensure param values remain within authorized range."},{"Add":" * @return 0 on success, or an error code (can be checked with ZSTD_isError()) */"},{"Add":"ZSTDLIB_API size_t ZSTD_checkCParams(ZSTD_compressionParameters params);"},{"Add":""},{"Add":"/*! ZSTD_adjustCParams() :"},{"Add":" * optimize params for a given `srcSize` and `dictSize`."},{"Add":" * `srcSize` can be unknown, in which case use ZSTD_CONTENTSIZE_UNKNOWN."},{"Add":" * `dictSize` must be `0` when there is no dictionary."},{"Add":" * cPar can be invalid : all parameters will be clamped within valid range in the @return struct."},{"Add":" * This function never fails (wide contract) */"},{"Add":"ZSTDLIB_API ZSTD_compressionParameters ZSTD_adjustCParams(ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize);"},{"Add":""},{"Add":"/*! ZSTD_compress_advanced() :"},{"Add":" * Note : this function is now DEPRECATED."},{"Add":" * It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_setParameter() and other parameter setters."},{"Add":" * This prototype will be marked as deprecated and generate compilation warning on reaching v1.5.x */"},{"Add":"ZSTDLIB_API size_t ZSTD_compress_advanced(ZSTD_CCtx* cctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const void* dict,size_t dictSize,"},{"Add":" ZSTD_parameters params);"},{"Add":""},{"Add":"/*! ZSTD_compress_usingCDict_advanced() :"},{"Add":" * Note : this function is now REDUNDANT."},{"Add":" * It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_loadDictionary() and other parameter setters."},{"Add":" * This prototype will be marked as deprecated and generate compilation warning in some future version */"},{"Add":"ZSTDLIB_API size_t ZSTD_compress_usingCDict_advanced(ZSTD_CCtx* cctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const ZSTD_CDict* cdict,"},{"Add":" ZSTD_frameParameters fParams);"},{"Add":""},{"Add":""},{"Add":"/*! ZSTD_CCtx_loadDictionary_byReference() :"},{"Add":" * Same as ZSTD_CCtx_loadDictionary(), but dictionary content is referenced, instead of being copied into CCtx."},{"Add":" * It saves some memory, but also requires that `dict` outlives its usage within `cctx` */"},{"Add":"ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary_byReference(ZSTD_CCtx* cctx, const void* dict, size_t dictSize);"},{"Add":""},{"Add":"/*! ZSTD_CCtx_loadDictionary_advanced() :"},{"Add":" * Same as ZSTD_CCtx_loadDictionary(), but gives finer control over"},{"Add":" * how to load the dictionary (by copy ? by reference ?)"},{"Add":" * and how to interpret it (automatic ? force raw mode ? full mode only ?) */"},{"Add":"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);"},{"Add":""},{"Add":"/*! ZSTD_CCtx_refPrefix_advanced() :"},{"Add":" * Same as ZSTD_CCtx_refPrefix(), but gives finer control over"},{"Add":" * how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?) */"},{"Add":"ZSTDLIB_API size_t ZSTD_CCtx_refPrefix_advanced(ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType);"},{"Add":""},{"Add":"/* === experimental parameters === */"},{"Add":"/* these parameters can be used with ZSTD_setParameter()"},{"Add":" * they are not guaranteed to remain supported in the future */"},{"Add":""},{"Add":" /* Enables rsyncable mode,"},{"Add":" * which makes compressed files more rsync friendly"},{"Add":" * by adding periodic synchronization points to the compressed data."},{"Add":" * The target average block size is ZSTD_c_jobSize / 2."},{"Add":" * It's possible to modify the job size to increase or decrease"},{"Add":" * the granularity of the synchronization point."},{"Add":" * Once the jobSize is smaller than the window size,"},{"Add":" * it will result in compression ratio degradation."},{"Add":" * NOTE 1: rsyncable mode only works when multithreading is enabled."},{"Add":" * NOTE 2: rsyncable performs poorly in combination with long range mode,"},{"Add":" * since it will decrease the effectiveness of synchronization points,"},{"Add":" * though mileage may vary."},{"Add":" * NOTE 3: Rsyncable mode limits maximum compression speed to ~400 MB/s."},{"Add":" * If the selected compression level is already running significantly slower,"},{"Add":" * the overall speed won't be significantly impacted."},{"Add":" */"},{"Add":" #define ZSTD_c_rsyncable ZSTD_c_experimentalParam1"},{"Add":""},{"Add":"/* Select a compression format."},{"Add":" * The value must be of type ZSTD_format_e."},{"Add":" * See ZSTD_format_e enum definition for details */"},{"Add":"#define ZSTD_c_format ZSTD_c_experimentalParam2"},{"Add":""},{"Add":"/* Force back-reference distances to remain < windowSize,"},{"Add":" * even when referencing into Dictionary content (default:0) */"},{"Add":"#define ZSTD_c_forceMaxWindow ZSTD_c_experimentalParam3"},{"Add":""},{"Add":"/* Controls whether the contents of a CDict"},{"Add":" * are used in place, or copied into the working context."},{"Add":" * Accepts values from the ZSTD_dictAttachPref_e enum."},{"Add":" * See the comments on that enum for an explanation of the feature. */"},{"Add":"#define ZSTD_c_forceAttachDict ZSTD_c_experimentalParam4"},{"Add":""},{"Add":"/* Controls how the literals are compressed (default is auto)."},{"Add":" * The value must be of type ZSTD_literalCompressionMode_e."},{"Add":" * See ZSTD_literalCompressionMode_t enum definition for details."},{"Add":" */"},{"Add":"#define ZSTD_c_literalCompressionMode ZSTD_c_experimentalParam5"},{"Add":""},{"Add":"/* Tries to fit compressed block size to be around targetCBlockSize."},{"Add":" * No target when targetCBlockSize == 0."},{"Add":" * There is no guarantee on compressed block size (default:0) */"},{"Add":"#define ZSTD_c_targetCBlockSize ZSTD_c_experimentalParam6"},{"Add":""},{"Add":"/* User's best guess of source size."},{"Add":" * Hint is not valid when srcSizeHint == 0."},{"Add":" * There is no guarantee that hint is close to actual source size,"},{"Add":" * but compression ratio may regress significantly if guess considerably underestimates */"},{"Add":"#define ZSTD_c_srcSizeHint ZSTD_c_experimentalParam7"},{"Add":""},{"Add":"/* Controls whether the new and experimental \"dedicated dictionary search"},{"Add":" * structure\" can be used. This feature is still rough around the edges, be"},{"Add":" * prepared for surprising behavior!"},{"Add":" *"},{"Add":" * How to use it:"},{"Add":" *"},{"Add":" * When using a CDict, whether to use this feature or not is controlled at"},{"Add":" * CDict creation, and it must be set in a CCtxParams set passed into that"},{"Add":" * construction (via ZSTD_createCDict_advanced2()). A compression will then"},{"Add":" * use the feature or not based on how the CDict was constructed; the value of"},{"Add":" * this param, set in the CCtx, will have no effect."},{"Add":" *"},{"Add":" * However, when a dictionary buffer is passed into a CCtx, such as via"},{"Add":" * ZSTD_CCtx_loadDictionary(), this param can be set on the CCtx to control"},{"Add":" * whether the CDict that is created internally can use the feature or not."},{"Add":" *"},{"Add":" * What it does:"},{"Add":" *"},{"Add":" * Normally, the internal data structures of the CDict are analogous to what"},{"Add":" * would be stored in a CCtx after compressing the contents of a dictionary."},{"Add":" * To an approximation, a compression using a dictionary can then use those"},{"Add":" * data structures to simply continue what is effectively a streaming"},{"Add":" * compression where the simulated compression of the dictionary left off."},{"Add":" * Which is to say, the search structures in the CDict are normally the same"},{"Add":" * format as in the CCtx."},{"Add":" *"},{"Add":" * It is possible to do better, since the CDict is not like a CCtx: the search"},{"Add":" * structures are written once during CDict creation, and then are only read"},{"Add":" * after that, while the search structures in the CCtx are both read and"},{"Add":" * written as the compression goes along. This means we can choose a search"},{"Add":" * structure for the dictionary that is read-optimized."},{"Add":" *"},{"Add":" * This feature enables the use of that different structure."},{"Add":" *"},{"Add":" * Note that some of the members of the ZSTD_compressionParameters struct have"},{"Add":" * different semantics and constraints in the dedicated search structure. It is"},{"Add":" * highly recommended that you simply set a compression level in the CCtxParams"},{"Add":" * you pass into the CDict creation call, and avoid messing with the cParams"},{"Add":" * directly."},{"Add":" *"},{"Add":" * Effects:"},{"Add":" *"},{"Add":" * This will only have any effect when the selected ZSTD_strategy"},{"Add":" * implementation supports this feature. Currently, that's limited to"},{"Add":" * ZSTD_greedy, ZSTD_lazy, and ZSTD_lazy2."},{"Add":" *"},{"Add":" * Note that this means that the CDict tables can no longer be copied into the"},{"Add":" * CCtx, so the dict attachment mode ZSTD_dictForceCopy will no longer be"},{"Add":" * useable. The dictionary can only be attached or reloaded."},{"Add":" *"},{"Add":" * In general, you should expect compression to be faster--sometimes very much"},{"Add":" * so--and CDict creation to be slightly slower. Eventually, we will probably"},{"Add":" * make this mode the default."},{"Add":" */"},{"Add":"#define ZSTD_c_enableDedicatedDictSearch ZSTD_c_experimentalParam8"},{"Add":""},{"Add":"/* ZSTD_c_stableInBuffer"},{"Add":" * Experimental parameter."},{"Add":" * Default is 0 == disabled. Set to 1 to enable."},{"Add":" *"},{"Add":" * Tells the compressor that the ZSTD_inBuffer will ALWAYS be the same"},{"Add":" * between calls, except for the modifications that zstd makes to pos (the"},{"Add":" * caller must not modify pos). This is checked by the compressor, and"},{"Add":" * compression will fail if it ever changes. This means the only flush"},{"Add":" * mode that makes sense is ZSTD_e_end, so zstd will error if ZSTD_e_end"},{"Add":" * is not used. The data in the ZSTD_inBuffer in the range [src, src + pos)"},{"Add":" * MUST not be modified during compression or you will get data corruption."},{"Add":" *"},{"Add":" * When this flag is enabled zstd won't allocate an input window buffer,"},{"Add":" * because the user guarantees it can reference the ZSTD_inBuffer until"},{"Add":" * the frame is complete. But, it will still allocate an output buffer"},{"Add":" * large enough to fit a block (see ZSTD_c_stableOutBuffer). This will also"},{"Add":" * avoid the memcpy() from the input buffer to the input window buffer."},{"Add":" *"},{"Add":" * NOTE: ZSTD_compressStream2() will error if ZSTD_e_end is not used."},{"Add":" * That means this flag cannot be used with ZSTD_compressStream()."},{"Add":" *"},{"Add":" * NOTE: So long as the ZSTD_inBuffer always points to valid memory, using"},{"Add":" * this flag is ALWAYS memory safe, and will never access out-of-bounds"},{"Add":" * memory. However, compression WILL fail if you violate the preconditions."},{"Add":" *"},{"Add":" * WARNING: The data in the ZSTD_inBuffer in the range [dst, dst + pos) MUST"},{"Add":" * not be modified during compression or you will get data corruption. This"},{"Add":" * is because zstd needs to reference data in the ZSTD_inBuffer to find"},{"Add":" * matches. Normally zstd maintains its own window buffer for this purpose,"},{"Add":" * but passing this flag tells zstd to use the user provided buffer."},{"Add":" */"},{"Add":"#define ZSTD_c_stableInBuffer ZSTD_c_experimentalParam9"},{"Add":""},{"Add":"/* ZSTD_c_stableOutBuffer"},{"Add":" * Experimental parameter."},{"Add":" * Default is 0 == disabled. Set to 1 to enable."},{"Add":" *"},{"Add":" * Tells he compressor that the ZSTD_outBuffer will not be resized between"},{"Add":" * calls. Specifically: (out.size - out.pos) will never grow. This gives the"},{"Add":" * compressor the freedom to say: If the compressed data doesn't fit in the"},{"Add":" * output buffer then return ZSTD_error_dstSizeTooSmall. This allows us to"},{"Add":" * always decompress directly into the output buffer, instead of decompressing"},{"Add":" * into an internal buffer and copying to the output buffer."},{"Add":" *"},{"Add":" * When this flag is enabled zstd won't allocate an output buffer, because"},{"Add":" * it can write directly to the ZSTD_outBuffer. It will still allocate the"},{"Add":" * input window buffer (see ZSTD_c_stableInBuffer)."},{"Add":" *"},{"Add":" * Zstd will check that (out.size - out.pos) never grows and return an error"},{"Add":" * if it does. While not strictly necessary, this should prevent surprises."},{"Add":" */"},{"Add":"#define ZSTD_c_stableOutBuffer ZSTD_c_experimentalParam10"},{"Add":""},{"Add":"/* ZSTD_c_blockDelimiters"},{"Add":" * Default is 0 == ZSTD_sf_noBlockDelimiters."},{"Add":" *"},{"Add":" * For use with sequence compression API: ZSTD_compressSequences()."},{"Add":" *"},{"Add":" * Designates whether or not the given array of ZSTD_Sequence contains block delimiters"},{"Add":" * and last literals, which are defined as sequences with offset == 0 and matchLength == 0."},{"Add":" * See the definition of ZSTD_Sequence for more specifics."},{"Add":" */"},{"Add":"#define ZSTD_c_blockDelimiters ZSTD_c_experimentalParam11"},{"Add":""},{"Add":"/* ZSTD_c_validateSequences"},{"Add":" * Default is 0 == disabled. Set to 1 to enable sequence validation."},{"Add":" *"},{"Add":" * For use with sequence compression API: ZSTD_compressSequences()."},{"Add":" * Designates whether or not we validate sequences provided to ZSTD_compressSequences()"},{"Add":" * during function execution."},{"Add":" *"},{"Add":" * Without validation, providing a sequence that does not conform to the zstd spec will cause"},{"Add":" * undefined behavior, and may produce a corrupted block."},{"Add":" *"},{"Add":" * With validation enabled, a if sequence is invalid (see doc/zstd_compression_format.md for"},{"Add":" * specifics regarding offset/matchlength requirements) then the function will bail out and"},{"Add":" * return an error."},{"Add":" *"},{"Add":" */"},{"Add":"#define ZSTD_c_validateSequences ZSTD_c_experimentalParam12"},{"Add":""},{"Add":"/*! ZSTD_CCtx_getParameter() :"},{"Add":" * Get the requested compression parameter value, selected by enum ZSTD_cParameter,"},{"Add":" * and store it into int* value."},{"Add":" * @return : 0, or an error code (which can be tested with ZSTD_isError())."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_CCtx_getParameter(const ZSTD_CCtx* cctx, ZSTD_cParameter param, int* value);"},{"Add":""},{"Add":""},{"Add":"/*! ZSTD_CCtx_params :"},{"Add":" * Quick howto :"},{"Add":" * - ZSTD_createCCtxParams() : Create a ZSTD_CCtx_params structure"},{"Add":" * - ZSTD_CCtxParams_setParameter() : Push parameters one by one into"},{"Add":" * an existing ZSTD_CCtx_params structure."},{"Add":" * This is similar to"},{"Add":" * ZSTD_CCtx_setParameter()."},{"Add":" * - ZSTD_CCtx_setParametersUsingCCtxParams() : Apply parameters to"},{"Add":" * an existing CCtx."},{"Add":" * These parameters will be applied to"},{"Add":" * all subsequent frames."},{"Add":" * - ZSTD_compressStream2() : Do compression using the CCtx."},{"Add":" * - ZSTD_freeCCtxParams() : Free the memory."},{"Add":" *"},{"Add":" * This can be used with ZSTD_estimateCCtxSize_advanced_usingCCtxParams()"},{"Add":" * for static allocation of CCtx for single-threaded compression."},{"Add":" */"},{"Add":"ZSTDLIB_API ZSTD_CCtx_params* ZSTD_createCCtxParams(void);"},{"Add":"ZSTDLIB_API size_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params);"},{"Add":""},{"Add":"/*! ZSTD_CCtxParams_reset() :"},{"Add":" * Reset params to default values."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_CCtxParams_reset(ZSTD_CCtx_params* params);"},{"Add":""},{"Add":"/*! ZSTD_CCtxParams_init() :"},{"Add":" * Initializes the compression parameters of cctxParams according to"},{"Add":" * compression level. All other parameters are reset to their default values."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_CCtxParams_init(ZSTD_CCtx_params* cctxParams, int compressionLevel);"},{"Add":""},{"Add":"/*! ZSTD_CCtxParams_init_advanced() :"},{"Add":" * Initializes the compression and frame parameters of cctxParams according to"},{"Add":" * params. All other parameters are reset to their default values."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_CCtxParams_init_advanced(ZSTD_CCtx_params* cctxParams, ZSTD_parameters params);"},{"Add":""},{"Add":"/*! ZSTD_CCtxParams_setParameter() :"},{"Add":" * Similar to ZSTD_CCtx_setParameter."},{"Add":" * Set one compression parameter, selected by enum ZSTD_cParameter."},{"Add":" * Parameters must be applied to a ZSTD_CCtx using"},{"Add":" * ZSTD_CCtx_setParametersUsingCCtxParams()."},{"Add":" * @result : a code representing success or failure (which can be tested with"},{"Add":" * ZSTD_isError())."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_CCtxParams_setParameter(ZSTD_CCtx_params* params, ZSTD_cParameter param, int value);"},{"Add":""},{"Add":"/*! ZSTD_CCtxParams_getParameter() :"},{"Add":" * Similar to ZSTD_CCtx_getParameter."},{"Add":" * Get the requested value of one compression parameter, selected by enum ZSTD_cParameter."},{"Add":" * @result : 0, or an error code (which can be tested with ZSTD_isError())."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_CCtxParams_getParameter(const ZSTD_CCtx_params* params, ZSTD_cParameter param, int* value);"},{"Add":""},{"Add":"/*! ZSTD_CCtx_setParametersUsingCCtxParams() :"},{"Add":" * Apply a set of ZSTD_CCtx_params to the compression context."},{"Add":" * This can be done even after compression is started,"},{"Add":" * if nbWorkers==0, this will have no impact until a new compression is started."},{"Add":" * if nbWorkers>=1, new parameters will be picked up at next job,"},{"Add":" * with a few restrictions (windowLog, pledgedSrcSize, nbWorkers, jobSize, and overlapLog are not updated)."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_CCtx_setParametersUsingCCtxParams("},{"Add":" ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params);"},{"Add":""},{"Add":"/*! ZSTD_compressStream2_simpleArgs() :"},{"Add":" * Same as ZSTD_compressStream2(),"},{"Add":" * but using only integral types as arguments."},{"Add":" * This variant might be helpful for binders from dynamic languages"},{"Add":" * which have troubles handling structures containing memory pointers."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_compressStream2_simpleArgs ("},{"Add":" ZSTD_CCtx* cctx,"},{"Add":" void* dst, size_t dstCapacity, size_t* dstPos,"},{"Add":" const void* src, size_t srcSize, size_t* srcPos,"},{"Add":" ZSTD_EndDirective endOp);"},{"Add":""},{"Add":""},{"Add":"/***************************************"},{"Add":"* Advanced decompression functions"},{"Add":"***************************************/"},{"Add":""},{"Add":"/*! ZSTD_isFrame() :"},{"Add":" * Tells if the content of `buffer` starts with a valid Frame Identifier."},{"Add":" * Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0."},{"Add":" * Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled."},{"Add":" * Note 3 : Skippable Frame Identifiers are considered valid. */"},{"Add":"ZSTDLIB_API unsigned ZSTD_isFrame(const void* buffer, size_t size);"},{"Add":""},{"Add":"/*! ZSTD_createDDict_byReference() :"},{"Add":" * Create a digested dictionary, ready to start decompression operation without startup delay."},{"Add":" * Dictionary content is referenced, and therefore stays in dictBuffer."},{"Add":" * It is important that dictBuffer outlives DDict,"},{"Add":" * it must remain read accessible throughout the lifetime of DDict */"},{"Add":"ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize);"},{"Add":""},{"Add":"/*! ZSTD_DCtx_loadDictionary_byReference() :"},{"Add":" * Same as ZSTD_DCtx_loadDictionary(),"},{"Add":" * but references `dict` content instead of copying it into `dctx`."},{"Add":" * This saves memory if `dict` remains around.,"},{"Add":" * However, it's imperative that `dict` remains accessible (and unmodified) while being used, so it must outlive decompression. */"},{"Add":"ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);"},{"Add":""},{"Add":"/*! ZSTD_DCtx_loadDictionary_advanced() :"},{"Add":" * Same as ZSTD_DCtx_loadDictionary(),"},{"Add":" * but gives direct control over"},{"Add":" * how to load the dictionary (by copy ? by reference ?)"},{"Add":" * and how to interpret it (automatic ? force raw mode ? full mode only ?). */"},{"Add":"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);"},{"Add":""},{"Add":"/*! ZSTD_DCtx_refPrefix_advanced() :"},{"Add":" * Same as ZSTD_DCtx_refPrefix(), but gives finer control over"},{"Add":" * how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?) */"},{"Add":"ZSTDLIB_API size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType);"},{"Add":""},{"Add":"/*! ZSTD_DCtx_setMaxWindowSize() :"},{"Add":" * Refuses allocating internal buffers for frames requiring a window size larger than provided limit."},{"Add":" * This protects a decoder context from reserving too much memory for itself (potential attack scenario)."},{"Add":" * This parameter is only useful in streaming mode, since no internal buffer is allocated in single-pass mode."},{"Add":" * By default, a decompression context accepts all window sizes <= (1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT)"},{"Add":" * @return : 0, or an error code (which can be tested using ZSTD_isError())."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize);"},{"Add":""},{"Add":"/*! ZSTD_DCtx_getParameter() :"},{"Add":" * Get the requested decompression parameter value, selected by enum ZSTD_dParameter,"},{"Add":" * and store it into int* value."},{"Add":" * @return : 0, or an error code (which can be tested with ZSTD_isError())."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_DCtx_getParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int* value);"},{"Add":""},{"Add":"/* ZSTD_d_format"},{"Add":" * experimental parameter,"},{"Add":" * allowing selection between ZSTD_format_e input compression formats"},{"Add":" */"},{"Add":"#define ZSTD_d_format ZSTD_d_experimentalParam1"},{"Add":"/* ZSTD_d_stableOutBuffer"},{"Add":" * Experimental parameter."},{"Add":" * Default is 0 == disabled. Set to 1 to enable."},{"Add":" *"},{"Add":" * Tells the decompressor that the ZSTD_outBuffer will ALWAYS be the same"},{"Add":" * between calls, except for the modifications that zstd makes to pos (the"},{"Add":" * caller must not modify pos). This is checked by the decompressor, and"},{"Add":" * decompression will fail if it ever changes. Therefore the ZSTD_outBuffer"},{"Add":" * MUST be large enough to fit the entire decompressed frame. This will be"},{"Add":" * checked when the frame content size is known. The data in the ZSTD_outBuffer"},{"Add":" * in the range [dst, dst + pos) MUST not be modified during decompression"},{"Add":" * or you will get data corruption."},{"Add":" *"},{"Add":" * When this flags is enabled zstd won't allocate an output buffer, because"},{"Add":" * it can write directly to the ZSTD_outBuffer, but it will still allocate"},{"Add":" * an input buffer large enough to fit any compressed block. This will also"},{"Add":" * avoid the memcpy() from the internal output buffer to the ZSTD_outBuffer."},{"Add":" * If you need to avoid the input buffer allocation use the buffer-less"},{"Add":" * streaming API."},{"Add":" *"},{"Add":" * NOTE: So long as the ZSTD_outBuffer always points to valid memory, using"},{"Add":" * this flag is ALWAYS memory safe, and will never access out-of-bounds"},{"Add":" * memory. However, decompression WILL fail if you violate the preconditions."},{"Add":" *"},{"Add":" * WARNING: The data in the ZSTD_outBuffer in the range [dst, dst + pos) MUST"},{"Add":" * not be modified during decompression or you will get data corruption. This"},{"Add":" * is because zstd needs to reference data in the ZSTD_outBuffer to regenerate"},{"Add":" * matches. Normally zstd maintains its own buffer for this purpose, but passing"},{"Add":" * this flag tells zstd to use the user provided buffer."},{"Add":" */"},{"Add":"#define ZSTD_d_stableOutBuffer ZSTD_d_experimentalParam2"},{"Add":""},{"Add":"/* ZSTD_d_forceIgnoreChecksum"},{"Add":" * Experimental parameter."},{"Add":" * Default is 0 == disabled. Set to 1 to enable"},{"Add":" *"},{"Add":" * Tells the decompressor to skip checksum validation during decompression, regardless"},{"Add":" * of whether checksumming was specified during compression. This offers some"},{"Add":" * slight performance benefits, and may be useful for debugging."},{"Add":" * Param has values of type ZSTD_forceIgnoreChecksum_e"},{"Add":" */"},{"Add":"#define ZSTD_d_forceIgnoreChecksum ZSTD_d_experimentalParam3"},{"Add":""},{"Add":"/* ZSTD_d_refMultipleDDicts"},{"Add":" * Experimental parameter."},{"Add":" * Default is 0 == disabled. Set to 1 to enable"},{"Add":" *"},{"Add":" * If enabled and dctx is allocated on the heap, then additional memory will be allocated"},{"Add":" * to store references to multiple ZSTD_DDict. That is, multiple calls of ZSTD_refDDict()"},{"Add":" * using a given ZSTD_DCtx, rather than overwriting the previous DDict reference, will instead"},{"Add":" * store all references. At decompression time, the appropriate dictID is selected"},{"Add":" * from the set of DDicts based on the dictID in the frame."},{"Add":" *"},{"Add":" * Usage is simply calling ZSTD_refDDict() on multiple dict buffers."},{"Add":" *"},{"Add":" * Param has values of byte ZSTD_refMultipleDDicts_e"},{"Add":" *"},{"Add":" * WARNING: Enabling this parameter and calling ZSTD_DCtx_refDDict(), will trigger memory"},{"Add":" * allocation for the hash table. ZSTD_freeDCtx() also frees this memory."},{"Add":" * Memory is allocated as per ZSTD_DCtx::customMem."},{"Add":" *"},{"Add":" * Although this function allocates memory for the table, the user is still responsible for"},{"Add":" * memory management of the underlying ZSTD_DDict* themselves."},{"Add":" */"},{"Add":"#define ZSTD_d_refMultipleDDicts ZSTD_d_experimentalParam4"},{"Add":""},{"Add":""},{"Add":"/*! ZSTD_DCtx_setFormat() :"},{"Add":" * Instruct the decoder context about what kind of data to decode next."},{"Add":" * This instruction is mandatory to decode data without a fully-formed header,"},{"Add":" * such ZSTD_f_zstd1_magicless for example."},{"Add":" * @return : 0, or an error code (which can be tested using ZSTD_isError()). */"},{"Add":"ZSTDLIB_API size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format);"},{"Add":""},{"Add":"/*! ZSTD_decompressStream_simpleArgs() :"},{"Add":" * Same as ZSTD_decompressStream(),"},{"Add":" * but using only integral types as arguments."},{"Add":" * This can be helpful for binders from dynamic languages"},{"Add":" * which have troubles handling structures containing memory pointers."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_decompressStream_simpleArgs ("},{"Add":" ZSTD_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity, size_t* dstPos,"},{"Add":" const void* src, size_t srcSize, size_t* srcPos);"},{"Add":""},{"Add":""},{"Add":"/********************************************************************"},{"Add":"* Advanced streaming functions"},{"Add":"* Warning : most of these functions are now redundant with the Advanced API."},{"Add":"* Once Advanced API reaches \"stable\" status,"},{"Add":"* redundant functions will be deprecated, and then at some point removed."},{"Add":"********************************************************************/"},{"Add":""},{"Add":"/*===== Advanced Streaming compression functions =====*/"},{"Add":""},{"Add":"/*! ZSTD_initCStream_srcSize() :"},{"Add":" * This function is deprecated, and equivalent to:"},{"Add":" * ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);"},{"Add":" * ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any)"},{"Add":" * ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);"},{"Add":" * ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);"},{"Add":" *"},{"Add":" * pledgedSrcSize must be correct. If it is not known at init time, use"},{"Add":" * ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs,"},{"Add":" * \"0\" also disables frame content size field. It may be enabled in the future."},{"Add":" * Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"},{"Add":" */"},{"Add":"ZSTDLIB_API size_t"},{"Add":"ZSTD_initCStream_srcSize(ZSTD_CStream* zcs,"},{"Add":" int compressionLevel,"},{"Add":" unsigned long long pledgedSrcSize);"},{"Add":""},{"Add":"/*! ZSTD_initCStream_usingDict() :"},{"Add":" * This function is deprecated, and is equivalent to:"},{"Add":" * ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);"},{"Add":" * ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);"},{"Add":" * ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);"},{"Add":" *"},{"Add":" * Creates of an internal CDict (incompatible with static CCtx), except if"},{"Add":" * dict == NULL or dictSize < 8, in which case no dict is used."},{"Add":" * Note: dict is loaded with ZSTD_dct_auto (treated as a full zstd dictionary if"},{"Add":" * it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy."},{"Add":" * Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"},{"Add":" */"},{"Add":"ZSTDLIB_API size_t"},{"Add":"ZSTD_initCStream_usingDict(ZSTD_CStream* zcs,"},{"Add":" const void* dict, size_t dictSize,"},{"Add":" int compressionLevel);"},{"Add":""},{"Add":"/*! ZSTD_initCStream_advanced() :"},{"Add":" * This function is deprecated, and is approximately equivalent to:"},{"Add":" * ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);"},{"Add":" * // Pseudocode: Set each zstd parameter and leave the rest as-is."},{"Add":" * for ((param, value) : params) {"},{"Add":" * ZSTD_CCtx_setParameter(zcs, param, value);"},{"Add":" * }"},{"Add":" * ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);"},{"Add":" * ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);"},{"Add":" *"},{"Add":" * dict is loaded with ZSTD_dct_auto and ZSTD_dlm_byCopy."},{"Add":" * pledgedSrcSize must be correct."},{"Add":" * If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN."},{"Add":" * Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"},{"Add":" */"},{"Add":"ZSTDLIB_API size_t"},{"Add":"ZSTD_initCStream_advanced(ZSTD_CStream* zcs,"},{"Add":" const void* dict, size_t dictSize,"},{"Add":" ZSTD_parameters params,"},{"Add":" unsigned long long pledgedSrcSize);"},{"Add":""},{"Add":"/*! ZSTD_initCStream_usingCDict() :"},{"Add":" * This function is deprecated, and equivalent to:"},{"Add":" * ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);"},{"Add":" * ZSTD_CCtx_refCDict(zcs, cdict);"},{"Add":" *"},{"Add":" * note : cdict will just be referenced, and must outlive compression session"},{"Add":" * Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);"},{"Add":""},{"Add":"/*! ZSTD_initCStream_usingCDict_advanced() :"},{"Add":" * This function is DEPRECATED, and is approximately equivalent to:"},{"Add":" * ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);"},{"Add":" * // Pseudocode: Set each zstd frame parameter and leave the rest as-is."},{"Add":" * for ((fParam, value) : fParams) {"},{"Add":" * ZSTD_CCtx_setParameter(zcs, fParam, value);"},{"Add":" * }"},{"Add":" * ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);"},{"Add":" * ZSTD_CCtx_refCDict(zcs, cdict);"},{"Add":" *"},{"Add":" * same as ZSTD_initCStream_usingCDict(), with control over frame parameters."},{"Add":" * pledgedSrcSize must be correct. If srcSize is not known at init time, use"},{"Add":" * value ZSTD_CONTENTSIZE_UNKNOWN."},{"Add":" * Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"},{"Add":" */"},{"Add":"ZSTDLIB_API size_t"},{"Add":"ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,"},{"Add":" const ZSTD_CDict* cdict,"},{"Add":" ZSTD_frameParameters fParams,"},{"Add":" unsigned long long pledgedSrcSize);"},{"Add":""},{"Add":"/*! ZSTD_resetCStream() :"},{"Add":" * This function is deprecated, and is equivalent to:"},{"Add":" * ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);"},{"Add":" * ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);"},{"Add":" *"},{"Add":" * start a new frame, using same parameters from previous frame."},{"Add":" * This is typically useful to skip dictionary loading stage, since it will re-use it in-place."},{"Add":" * Note that zcs must be init at least once before using ZSTD_resetCStream()."},{"Add":" * If pledgedSrcSize is not known at reset time, use macro ZSTD_CONTENTSIZE_UNKNOWN."},{"Add":" * If pledgedSrcSize > 0, its value must be correct, as it will be written in header, and controlled at the end."},{"Add":" * For the time being, pledgedSrcSize==0 is interpreted as \"srcSize unknown\" for compatibility with older programs,"},{"Add":" * but it will change to mean \"empty\" in future version, so use macro ZSTD_CONTENTSIZE_UNKNOWN instead."},{"Add":" * @return : 0, or an error code (which can be tested using ZSTD_isError())"},{"Add":" * Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize);"},{"Add":""},{"Add":""},{"Add":"typedef struct {"},{"Add":" unsigned long long ingested; /* nb input bytes read and buffered */"},{"Add":" unsigned long long consumed; /* nb input bytes actually compressed */"},{"Add":" unsigned long long produced; /* nb of compressed bytes generated and buffered */"},{"Add":" unsigned long long flushed; /* nb of compressed bytes flushed : not provided; can be tracked from caller side */"},{"Add":" unsigned currentJobID; /* MT only : latest started job nb */"},{"Add":" unsigned nbActiveWorkers; /* MT only : nb of workers actively compressing at probe time */"},{"Add":"} ZSTD_frameProgression;"},{"Add":""},{"Add":"/* ZSTD_getFrameProgression() :"},{"Add":" * tells how much data has been ingested (read from input)"},{"Add":" * consumed (input actually compressed) and produced (output) for current frame."},{"Add":" * Note : (ingested - consumed) is amount of input data buffered internally, not yet compressed."},{"Add":" * Aggregates progression inside active worker threads."},{"Add":" */"},{"Add":"ZSTDLIB_API ZSTD_frameProgression ZSTD_getFrameProgression(const ZSTD_CCtx* cctx);"},{"Add":""},{"Add":"/*! ZSTD_toFlushNow() :"},{"Add":" * Tell how many bytes are ready to be flushed immediately."},{"Add":" * Useful for multithreading scenarios (nbWorkers >= 1)."},{"Add":" * Probe the oldest active job, defined as oldest job not yet entirely flushed,"},{"Add":" * and check its output buffer."},{"Add":" * @return : amount of data stored in oldest job and ready to be flushed immediately."},{"Add":" * if @return == 0, it means either :"},{"Add":" * + there is no active job (could be checked with ZSTD_frameProgression()), or"},{"Add":" * + oldest job is still actively compressing data,"},{"Add":" * but everything it has produced has also been flushed so far,"},{"Add":" * therefore flush speed is limited by production speed of oldest job"},{"Add":" * irrespective of the speed of concurrent (and newer) jobs."},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_toFlushNow(ZSTD_CCtx* cctx);"},{"Add":""},{"Add":""},{"Add":"/*===== Advanced Streaming decompression functions =====*/"},{"Add":""},{"Add":"/*!"},{"Add":" * This function is deprecated, and is equivalent to:"},{"Add":" *"},{"Add":" * ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);"},{"Add":" * ZSTD_DCtx_loadDictionary(zds, dict, dictSize);"},{"Add":" *"},{"Add":" * note: no dictionary will be used if dict == NULL or dictSize < 8"},{"Add":" * Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize);"},{"Add":""},{"Add":"/*!"},{"Add":" * This function is deprecated, and is equivalent to:"},{"Add":" *"},{"Add":" * ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);"},{"Add":" * ZSTD_DCtx_refDDict(zds, ddict);"},{"Add":" *"},{"Add":" * note : ddict is referenced, it must outlive decompression session"},{"Add":" * Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* zds, const ZSTD_DDict* ddict);"},{"Add":""},{"Add":"/*!"},{"Add":" * This function is deprecated, and is equivalent to:"},{"Add":" *"},{"Add":" * ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);"},{"Add":" *"},{"Add":" * re-use decompression parameters from previous init; saves dictionary loading"},{"Add":" * Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"},{"Add":" */"},{"Add":"ZSTDLIB_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);"},{"Add":""},{"Add":""},{"Add":"/*********************************************************************"},{"Add":"* Buffer-less and synchronous inner streaming functions"},{"Add":"*"},{"Add":"* This is an advanced API, giving full control over buffer management, for users which need direct control over memory."},{"Add":"* But it's also a complex one, with several restrictions, documented below."},{"Add":"* Prefer normal streaming API for an easier experience."},{"Add":"********************************************************************* */"},{"Add":""},{"Add":"/**"},{"Add":" Buffer-less streaming compression (synchronous mode)"},{"Add":""},{"Add":" A ZSTD_CCtx object is required to track streaming operations."},{"Add":" Use ZSTD_createCCtx() / ZSTD_freeCCtx() to manage resource."},{"Add":" ZSTD_CCtx object can be re-used multiple times within successive compression operations."},{"Add":""},{"Add":" Start by initializing a context."},{"Add":" Use ZSTD_compressBegin(), or ZSTD_compressBegin_usingDict() for dictionary compression,"},{"Add":" or ZSTD_compressBegin_advanced(), for finer parameter control."},{"Add":" It's also possible to duplicate a reference context which has already been initialized, using ZSTD_copyCCtx()"},{"Add":""},{"Add":" Then, consume your input using ZSTD_compressContinue()."},{"Add":" There are some important considerations to keep in mind when using this advanced function :"},{"Add":" - ZSTD_compressContinue() has no internal buffer. It uses externally provided buffers only."},{"Add":" - Interface is synchronous : input is consumed entirely and produces 1+ compressed blocks."},{"Add":" - Caller must ensure there is enough space in `dst` to store compressed data under worst case scenario."},{"Add":" Worst case evaluation is provided by ZSTD_compressBound()."},{"Add":" ZSTD_compressContinue() doesn't guarantee recover after a failed compression."},{"Add":" - ZSTD_compressContinue() presumes prior input ***is still accessible and unmodified*** (up to maximum distance size, see WindowLog)."},{"Add":" It remembers all previous contiguous blocks, plus one separated memory segment (which can itself consists of multiple contiguous blocks)"},{"Add":" - ZSTD_compressContinue() detects that prior input has been overwritten when `src` buffer overlaps."},{"Add":" In which case, it will \"discard\" the relevant memory section from its history."},{"Add":""},{"Add":" Finish a frame with ZSTD_compressEnd(), which will write the last block(s) and optional checksum."},{"Add":" It's possible to use srcSize==0, in which case, it will write a final empty block to end the frame."},{"Add":" Without last block mark, frames are considered unfinished (hence corrupted) by compliant decoders."},{"Add":""},{"Add":" `ZSTD_CCtx` object can be re-used (ZSTD_compressBegin()) to compress again."},{"Add":"*/"},{"Add":""},{"Add":"/*===== Buffer-less streaming compression functions =====*/"},{"Add":"ZSTDLIB_API size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel);"},{"Add":"ZSTDLIB_API size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel);"},{"Add":"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 */"},{"Add":"ZSTDLIB_API size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict); /**< note: fails if cdict==NULL */"},{"Add":"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 */"},{"Add":"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 */"},{"Add":""},{"Add":"ZSTDLIB_API size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);"},{"Add":"ZSTDLIB_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);"},{"Add":""},{"Add":""},{"Add":"/**"},{"Add":" Buffer-less streaming decompression (synchronous mode)"},{"Add":""},{"Add":" A ZSTD_DCtx object is required to track streaming operations."},{"Add":" Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it."},{"Add":" A ZSTD_DCtx object can be re-used multiple times."},{"Add":""},{"Add":" First typical operation is to retrieve frame parameters, using ZSTD_getFrameHeader()."},{"Add":" Frame header is extracted from the beginning of compressed frame, so providing only the frame's beginning is enough."},{"Add":" Data fragment must be large enough to ensure successful decoding."},{"Add":" `ZSTD_frameHeaderSize_max` bytes is guaranteed to always be large enough."},{"Add":" @result : 0 : successful decoding, the `ZSTD_frameHeader` structure is correctly filled."},{"Add":" >0 : `srcSize` is too small, please provide at least @result bytes on next attempt."},{"Add":" errorCode, which can be tested using ZSTD_isError()."},{"Add":""},{"Add":" It fills a ZSTD_frameHeader structure with important information to correctly decode the frame,"},{"Add":" such as the dictionary ID, content size, or maximum back-reference distance (`windowSize`)."},{"Add":" Note that these values could be wrong, either because of data corruption, or because a 3rd party deliberately spoofs false information."},{"Add":" As a consequence, check that values remain within valid application range."},{"Add":" For example, do not allocate memory blindly, check that `windowSize` is within expectation."},{"Add":" Each application can set its own limits, depending on local restrictions."},{"Add":" For extended interoperability, it is recommended to support `windowSize` of at least 8 MB."},{"Add":""},{"Add":" ZSTD_decompressContinue() needs previous data blocks during decompression, up to `windowSize` bytes."},{"Add":" ZSTD_decompressContinue() is very sensitive to contiguity,"},{"Add":" if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place,"},{"Add":" or that previous contiguous segment is large enough to properly handle maximum back-reference distance."},{"Add":" There are multiple ways to guarantee this condition."},{"Add":""},{"Add":" The most memory efficient way is to use a round buffer of sufficient size."},{"Add":" Sufficient size is determined by invoking ZSTD_decodingBufferSize_min(),"},{"Add":" which can @return an error code if required value is too large for current system (in 32-bits mode)."},{"Add":" In a round buffer methodology, ZSTD_decompressContinue() decompresses each block next to previous one,"},{"Add":" up to the moment there is not enough room left in the buffer to guarantee decoding another full block,"},{"Add":" which maximum size is provided in `ZSTD_frameHeader` structure, field `blockSizeMax`."},{"Add":" At which point, decoding can resume from the beginning of the buffer."},{"Add":" Note that already decoded data stored in the buffer should be flushed before being overwritten."},{"Add":""},{"Add":" There are alternatives possible, for example using two or more buffers of size `windowSize` each, though they consume more memory."},{"Add":""},{"Add":" Finally, if you control the compression process, you can also ignore all buffer size rules,"},{"Add":" as long as the encoder and decoder progress in \"lock-step\","},{"Add":" aka use exactly the same buffer sizes, break contiguity at the same place, etc."},{"Add":""},{"Add":" Once buffers are setup, start decompression, with ZSTD_decompressBegin()."},{"Add":" If decompression requires a dictionary, use ZSTD_decompressBegin_usingDict() or ZSTD_decompressBegin_usingDDict()."},{"Add":""},{"Add":" Then use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively."},{"Add":" ZSTD_nextSrcSizeToDecompress() tells how many bytes to provide as 'srcSize' to ZSTD_decompressContinue()."},{"Add":" ZSTD_decompressContinue() requires this _exact_ amount of bytes, or it will fail."},{"Add":""},{"Add":" @result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity)."},{"Add":" It can be zero : it just means ZSTD_decompressContinue() has decoded some metadata item."},{"Add":" It can also be an error code, which can be tested with ZSTD_isError()."},{"Add":""},{"Add":" A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero."},{"Add":" Context can then be reset to start a new decompression."},{"Add":""},{"Add":" Note : it's possible to know if next input to present is a header or a block, using ZSTD_nextInputType()."},{"Add":" This information is not required to properly decode a frame."},{"Add":""},{"Add":" == Special case : skippable frames =="},{"Add":""},{"Add":" Skippable frames allow integration of user-defined data into a flow of concatenated frames."},{"Add":" Skippable frames will be ignored (skipped) by decompressor."},{"Add":" The format of skippable frames is as follows :"},{"Add":" a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F"},{"Add":" b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits"},{"Add":" c) Frame Content - any content (User Data) of length equal to Frame Size"},{"Add":" For skippable frames ZSTD_getFrameHeader() returns zfhPtr->frameType==ZSTD_skippableFrame."},{"Add":" For skippable frames ZSTD_decompressContinue() always returns 0 : it only skips the content."},{"Add":"*/"},{"Add":""},{"Add":"/*===== Buffer-less streaming decompression functions =====*/"},{"Add":"typedef enum { ZSTD_frame, ZSTD_skippableFrame } ZSTD_frameType_e;"},{"Add":"typedef struct {"},{"Add":" unsigned long long frameContentSize; /* if == ZSTD_CONTENTSIZE_UNKNOWN, it means this field is not available. 0 means \"empty\" */"},{"Add":" unsigned long long windowSize; /* can be very large, up to <= frameContentSize */"},{"Add":" unsigned blockSizeMax;"},{"Add":" ZSTD_frameType_e frameType; /* if == ZSTD_skippableFrame, frameContentSize is the size of skippable content */"},{"Add":" unsigned headerSize;"},{"Add":" unsigned dictID;"},{"Add":" unsigned checksumFlag;"},{"Add":"} ZSTD_frameHeader;"},{"Add":""},{"Add":"/*! ZSTD_getFrameHeader() :"},{"Add":" * decode Frame Header, or requires larger `srcSize`."},{"Add":" * @return : 0, `zfhPtr` is correctly filled,"},{"Add":" * >0, `srcSize` is too small, value is wanted `srcSize` amount,"},{"Add":" * or an error code, which can be tested using ZSTD_isError() */"},{"Add":"ZSTDLIB_API size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize); /**< doesn't consume input */"},{"Add":"/*! ZSTD_getFrameHeader_advanced() :"},{"Add":" * same as ZSTD_getFrameHeader(),"},{"Add":" * with added capability to select a format (like ZSTD_f_zstd1_magicless) */"},{"Add":"ZSTDLIB_API size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format);"},{"Add":"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 */"},{"Add":""},{"Add":"ZSTDLIB_API size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx);"},{"Add":"ZSTDLIB_API size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);"},{"Add":"ZSTDLIB_API size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);"},{"Add":""},{"Add":"ZSTDLIB_API size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx);"},{"Add":"ZSTDLIB_API size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);"},{"Add":""},{"Add":"/* misc */"},{"Add":"ZSTDLIB_API void ZSTD_copyDCtx(ZSTD_DCtx* dctx, const ZSTD_DCtx* preparedDCtx);"},{"Add":"typedef enum { ZSTDnit_frameHeader, ZSTDnit_blockHeader, ZSTDnit_block, ZSTDnit_lastBlock, ZSTDnit_checksum, ZSTDnit_skippableFrame } ZSTD_nextInputType_e;"},{"Add":"ZSTDLIB_API ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx);"},{"Add":""},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* ============================ */"},{"Add":"/** Block level API */"},{"Add":"/* ============================ */"},{"Add":""},{"Add":"/*!"},{"Add":" Block functions produce and decode raw zstd blocks, without frame metadata."},{"Add":" Frame metadata cost is typically ~12 bytes, which can be non-negligible for very small blocks (< 100 bytes)."},{"Add":" But users will have to take in charge needed metadata to regenerate data, such as compressed and content sizes."},{"Add":""},{"Add":" A few rules to respect :"},{"Add":" - Compressing and decompressing require a context structure"},{"Add":" + Use ZSTD_createCCtx() and ZSTD_createDCtx()"},{"Add":" - It is necessary to init context before starting"},{"Add":" + compression : any ZSTD_compressBegin*() variant, including with dictionary"},{"Add":" + decompression : any ZSTD_decompressBegin*() variant, including with dictionary"},{"Add":" + copyCCtx() and copyDCtx() can be used too"},{"Add":" - Block size is limited, it must be <= ZSTD_getBlockSize() <= ZSTD_BLOCKSIZE_MAX == 128 KB"},{"Add":" + If input is larger than a block size, it's necessary to split input data into multiple blocks"},{"Add":" + For inputs larger than a single block, consider using regular ZSTD_compress() instead."},{"Add":" Frame metadata is not that costly, and quickly becomes negligible as source size grows larger than a block."},{"Add":" - When a block is considered not compressible enough, ZSTD_compressBlock() result will be 0 (zero) !"},{"Add":" ===> In which case, nothing is produced into `dst` !"},{"Add":" + User __must__ test for such outcome and deal directly with uncompressed data"},{"Add":" + A block cannot be declared incompressible if ZSTD_compressBlock() return value was != 0."},{"Add":" Doing so would mess up with statistics history, leading to potential data corruption."},{"Add":" + ZSTD_decompressBlock() _doesn't accept uncompressed data as input_ !!"},{"Add":" + In case of multiple successive blocks, should some of them be uncompressed,"},{"Add":" decoder must be informed of their existence in order to follow proper history."},{"Add":" Use ZSTD_insertBlock() for such a case."},{"Add":"*/"},{"Add":""},{"Add":"/*===== Raw zstd block functions =====*/"},{"Add":"ZSTDLIB_API size_t ZSTD_getBlockSize (const ZSTD_CCtx* cctx);"},{"Add":"ZSTDLIB_API size_t ZSTD_compressBlock (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);"},{"Add":"ZSTDLIB_API size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);"},{"Add":"ZSTDLIB_API size_t ZSTD_insertBlock (ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize); /**< insert uncompressed block into `dctx` history. Useful for multi-blocks decompression. */"},{"Add":""},{"Add":""},{"Add":"#endif /* ZSTD_H_ZSTD_STATIC_LINKING_ONLY */"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"}]}},{"FileAdd":{"meta":{"basename":"legacy","metadata":576},"context":[{"change":0,"pos":19}],"contents":[]}},{"FileAdd":{"meta":{"basename":"zstd_v07.h","metadata":0},"context":[{"change":0,"pos":140938}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) 2016-2021, Yann Collet, Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":""},{"Add":"#ifndef ZSTDv07_H_235446"},{"Add":"#define ZSTDv07_H_235446"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"/*====== Dependency ======*/"},{"Add":"#include /* size_t */"},{"Add":""},{"Add":""},{"Add":"/*====== Export for Windows ======*/"},{"Add":"/*!"},{"Add":"* ZSTDv07_DLL_EXPORT :"},{"Add":"* Enable exporting of functions when building a Windows DLL"},{"Add":"*/"},{"Add":"#if defined(_WIN32) && defined(ZSTDv07_DLL_EXPORT) && (ZSTDv07_DLL_EXPORT==1)"},{"Add":"# define ZSTDLIBv07_API __declspec(dllexport)"},{"Add":"#else"},{"Add":"# define ZSTDLIBv07_API"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Simple API"},{"Add":"***************************************/"},{"Add":"/*! ZSTDv07_getDecompressedSize() :"},{"Add":"* @return : decompressed size if known, 0 otherwise."},{"Add":" note 1 : if `0`, follow up with ZSTDv07_getFrameParams() to know precise failure cause."},{"Add":" note 2 : decompressed size could be wrong or intentionally modified !"},{"Add":" always ensure results fit within application's authorized limits */"},{"Add":"unsigned long long ZSTDv07_getDecompressedSize(const void* src, size_t srcSize);"},{"Add":""},{"Add":"/*! ZSTDv07_decompress() :"},{"Add":" `compressedSize` : must be _exact_ size of compressed input, otherwise decompression will fail."},{"Add":" `dstCapacity` must be equal or larger than originalSize."},{"Add":" @return : the number of bytes decompressed into `dst` (<= `dstCapacity`),"},{"Add":" or an errorCode if it fails (which can be tested using ZSTDv07_isError()) */"},{"Add":"ZSTDLIBv07_API size_t ZSTDv07_decompress( void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t compressedSize);"},{"Add":""},{"Add":"/**"},{"Add":"ZSTDv07_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.7.x format"},{"Add":" srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'"},{"Add":" cSize (output parameter) : the number of bytes that would be read to decompress this frame"},{"Add":" or an error code if it fails (which can be tested using ZSTDv01_isError())"},{"Add":" dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame"},{"Add":" or ZSTD_CONTENTSIZE_ERROR if an error occurs"},{"Add":""},{"Add":" note : assumes `cSize` and `dBound` are _not_ NULL."},{"Add":"*/"},{"Add":"void ZSTDv07_findFrameSizeInfoLegacy(const void *src, size_t srcSize,"},{"Add":" size_t* cSize, unsigned long long* dBound);"},{"Add":""},{"Add":"/*====== Helper functions ======*/"},{"Add":"ZSTDLIBv07_API unsigned ZSTDv07_isError(size_t code); /*!< tells if a `size_t` function result is an error code */"},{"Add":"ZSTDLIBv07_API const char* ZSTDv07_getErrorName(size_t code); /*!< provides readable string from an error code */"},{"Add":""},{"Add":""},{"Add":"/*-*************************************"},{"Add":"* Explicit memory management"},{"Add":"***************************************/"},{"Add":"/** Decompression context */"},{"Add":"typedef struct ZSTDv07_DCtx_s ZSTDv07_DCtx;"},{"Add":"ZSTDLIBv07_API ZSTDv07_DCtx* ZSTDv07_createDCtx(void);"},{"Add":"ZSTDLIBv07_API size_t ZSTDv07_freeDCtx(ZSTDv07_DCtx* dctx); /*!< @return : errorCode */"},{"Add":""},{"Add":"/** ZSTDv07_decompressDCtx() :"},{"Add":"* Same as ZSTDv07_decompress(), requires an allocated ZSTDv07_DCtx (see ZSTDv07_createDCtx()) */"},{"Add":"ZSTDLIBv07_API size_t ZSTDv07_decompressDCtx(ZSTDv07_DCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);"},{"Add":""},{"Add":""},{"Add":"/*-************************"},{"Add":"* Simple dictionary API"},{"Add":"***************************/"},{"Add":"/*! ZSTDv07_decompress_usingDict() :"},{"Add":"* Decompression using a pre-defined Dictionary content (see dictBuilder)."},{"Add":"* Dictionary must be identical to the one used during compression."},{"Add":"* Note : This function load the dictionary, resulting in a significant startup time */"},{"Add":"ZSTDLIBv07_API size_t ZSTDv07_decompress_usingDict(ZSTDv07_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const void* dict,size_t dictSize);"},{"Add":""},{"Add":""},{"Add":"/*-**************************"},{"Add":"* Advanced Dictionary API"},{"Add":"****************************/"},{"Add":"/*! ZSTDv07_createDDict() :"},{"Add":"* Create a digested dictionary, ready to start decompression operation without startup delay."},{"Add":"* `dict` can be released after creation */"},{"Add":"typedef struct ZSTDv07_DDict_s ZSTDv07_DDict;"},{"Add":"ZSTDLIBv07_API ZSTDv07_DDict* ZSTDv07_createDDict(const void* dict, size_t dictSize);"},{"Add":"ZSTDLIBv07_API size_t ZSTDv07_freeDDict(ZSTDv07_DDict* ddict);"},{"Add":""},{"Add":"/*! ZSTDv07_decompress_usingDDict() :"},{"Add":"* Decompression using a pre-digested Dictionary"},{"Add":"* Faster startup than ZSTDv07_decompress_usingDict(), recommended when same dictionary is used multiple times. */"},{"Add":"ZSTDLIBv07_API size_t ZSTDv07_decompress_usingDDict(ZSTDv07_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const ZSTDv07_DDict* ddict);"},{"Add":""},{"Add":"typedef struct {"},{"Add":" unsigned long long frameContentSize;"},{"Add":" unsigned windowSize;"},{"Add":" unsigned dictID;"},{"Add":" unsigned checksumFlag;"},{"Add":"} ZSTDv07_frameParams;"},{"Add":""},{"Add":"ZSTDLIBv07_API size_t ZSTDv07_getFrameParams(ZSTDv07_frameParams* fparamsPtr, const void* src, size_t srcSize); /**< doesn't consume input */"},{"Add":""},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Streaming functions"},{"Add":"***************************************/"},{"Add":"typedef struct ZBUFFv07_DCtx_s ZBUFFv07_DCtx;"},{"Add":"ZSTDLIBv07_API ZBUFFv07_DCtx* ZBUFFv07_createDCtx(void);"},{"Add":"ZSTDLIBv07_API size_t ZBUFFv07_freeDCtx(ZBUFFv07_DCtx* dctx);"},{"Add":""},{"Add":"ZSTDLIBv07_API size_t ZBUFFv07_decompressInit(ZBUFFv07_DCtx* dctx);"},{"Add":"ZSTDLIBv07_API size_t ZBUFFv07_decompressInitDictionary(ZBUFFv07_DCtx* dctx, const void* dict, size_t dictSize);"},{"Add":""},{"Add":"ZSTDLIBv07_API size_t ZBUFFv07_decompressContinue(ZBUFFv07_DCtx* dctx,"},{"Add":" void* dst, size_t* dstCapacityPtr,"},{"Add":" const void* src, size_t* srcSizePtr);"},{"Add":""},{"Add":"/*-***************************************************************************"},{"Add":"* Streaming decompression howto"},{"Add":"*"},{"Add":"* A ZBUFFv07_DCtx object is required to track streaming operations."},{"Add":"* Use ZBUFFv07_createDCtx() and ZBUFFv07_freeDCtx() to create/release resources."},{"Add":"* Use ZBUFFv07_decompressInit() to start a new decompression operation,"},{"Add":"* or ZBUFFv07_decompressInitDictionary() if decompression requires a dictionary."},{"Add":"* Note that ZBUFFv07_DCtx objects can be re-init multiple times."},{"Add":"*"},{"Add":"* Use ZBUFFv07_decompressContinue() repetitively to consume your input."},{"Add":"* *srcSizePtr and *dstCapacityPtr can be any size."},{"Add":"* The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr."},{"Add":"* Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again."},{"Add":"* The content of `dst` will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change `dst`."},{"Add":"* @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency),"},{"Add":"* or 0 when a frame is completely decoded,"},{"Add":"* or an error code, which can be tested using ZBUFFv07_isError()."},{"Add":"*"},{"Add":"* Hint : recommended buffer sizes (not compulsory) : ZBUFFv07_recommendedDInSize() and ZBUFFv07_recommendedDOutSize()"},{"Add":"* output : ZBUFFv07_recommendedDOutSize== 128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded."},{"Add":"* input : ZBUFFv07_recommendedDInSize == 128KB + 3;"},{"Add":"* just follow indications from ZBUFFv07_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 ."},{"Add":"* *******************************************************************************/"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Tool functions"},{"Add":"***************************************/"},{"Add":"ZSTDLIBv07_API unsigned ZBUFFv07_isError(size_t errorCode);"},{"Add":"ZSTDLIBv07_API const char* ZBUFFv07_getErrorName(size_t errorCode);"},{"Add":""},{"Add":"/** Functions below provide recommended buffer sizes for Compression or Decompression operations."},{"Add":"* These sizes are just hints, they tend to offer better latency */"},{"Add":"ZSTDLIBv07_API size_t ZBUFFv07_recommendedDInSize(void);"},{"Add":"ZSTDLIBv07_API size_t ZBUFFv07_recommendedDOutSize(void);"},{"Add":""},{"Add":""},{"Add":"/*-*************************************"},{"Add":"* Constants"},{"Add":"***************************************/"},{"Add":"#define ZSTDv07_MAGICNUMBER 0xFD2FB527 /* v0.7 */"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* ZSTDv07_H_235446 */"}]}},{"FileAdd":{"meta":{"basename":"zstd_v07.c","metadata":0},"context":[{"change":0,"pos":140938}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) 2016-2021, Yann Collet, Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":""},{"Add":""},{"Add":"/*- Dependencies -*/"},{"Add":"#include /* size_t, ptrdiff_t */"},{"Add":"#include /* memcpy */"},{"Add":"#include /* malloc, free, qsort */"},{"Add":""},{"Add":"#ifndef XXH_STATIC_LINKING_ONLY"},{"Add":"# define XXH_STATIC_LINKING_ONLY /* XXH64_state_t */"},{"Add":"#endif"},{"Add":"#include \"../common/xxhash.h\" /* XXH64_* */"},{"Add":"#include \"zstd_v07.h\""},{"Add":""},{"Add":"#define FSEv07_STATIC_LINKING_ONLY /* FSEv07_MIN_TABLELOG */"},{"Add":"#define HUFv07_STATIC_LINKING_ONLY /* HUFv07_TABLELOG_ABSOLUTEMAX */"},{"Add":"#define ZSTDv07_STATIC_LINKING_ONLY"},{"Add":""},{"Add":"#include \"../common/error_private.h\""},{"Add":""},{"Add":""},{"Add":"#ifdef ZSTDv07_STATIC_LINKING_ONLY"},{"Add":""},{"Add":"/* ===================================================================================="},{"Add":" * The definitions in this section are considered experimental."},{"Add":" * They should never be used with a dynamic library, as they may change in the future."},{"Add":" * They are provided for advanced usages."},{"Add":" * Use them only in association with static linking."},{"Add":" * ==================================================================================== */"},{"Add":""},{"Add":"/*--- Constants ---*/"},{"Add":"#define ZSTDv07_MAGIC_SKIPPABLE_START 0x184D2A50U"},{"Add":""},{"Add":"#define ZSTDv07_WINDOWLOG_MAX_32 25"},{"Add":"#define ZSTDv07_WINDOWLOG_MAX_64 27"},{"Add":"#define ZSTDv07_WINDOWLOG_MAX ((U32)(MEM_32bits() ? ZSTDv07_WINDOWLOG_MAX_32 : ZSTDv07_WINDOWLOG_MAX_64))"},{"Add":"#define ZSTDv07_WINDOWLOG_MIN 18"},{"Add":"#define ZSTDv07_CHAINLOG_MAX (ZSTDv07_WINDOWLOG_MAX+1)"},{"Add":"#define ZSTDv07_CHAINLOG_MIN 4"},{"Add":"#define ZSTDv07_HASHLOG_MAX ZSTDv07_WINDOWLOG_MAX"},{"Add":"#define ZSTDv07_HASHLOG_MIN 12"},{"Add":"#define ZSTDv07_HASHLOG3_MAX 17"},{"Add":"#define ZSTDv07_SEARCHLOG_MAX (ZSTDv07_WINDOWLOG_MAX-1)"},{"Add":"#define ZSTDv07_SEARCHLOG_MIN 1"},{"Add":"#define ZSTDv07_SEARCHLENGTH_MAX 7"},{"Add":"#define ZSTDv07_SEARCHLENGTH_MIN 3"},{"Add":"#define ZSTDv07_TARGETLENGTH_MIN 4"},{"Add":"#define ZSTDv07_TARGETLENGTH_MAX 999"},{"Add":""},{"Add":"#define ZSTDv07_FRAMEHEADERSIZE_MAX 18 /* for static allocation */"},{"Add":"static const size_t ZSTDv07_frameHeaderSize_min = 5;"},{"Add":"static const size_t ZSTDv07_frameHeaderSize_max = ZSTDv07_FRAMEHEADERSIZE_MAX;"},{"Add":"static const size_t ZSTDv07_skippableHeaderSize = 8; /* magic number + skippable frame length */"},{"Add":""},{"Add":""},{"Add":"/* custom memory allocation functions */"},{"Add":"typedef void* (*ZSTDv07_allocFunction) (void* opaque, size_t size);"},{"Add":"typedef void (*ZSTDv07_freeFunction) (void* opaque, void* address);"},{"Add":"typedef struct { ZSTDv07_allocFunction customAlloc; ZSTDv07_freeFunction customFree; void* opaque; } ZSTDv07_customMem;"},{"Add":""},{"Add":""},{"Add":"/*--- Advanced Decompression functions ---*/"},{"Add":""},{"Add":"/*! ZSTDv07_estimateDCtxSize() :"},{"Add":" * Gives the potential amount of memory allocated to create a ZSTDv07_DCtx */"},{"Add":"ZSTDLIBv07_API size_t ZSTDv07_estimateDCtxSize(void);"},{"Add":""},{"Add":"/*! ZSTDv07_createDCtx_advanced() :"},{"Add":" * Create a ZSTD decompression context using external alloc and free functions */"},{"Add":"ZSTDLIBv07_API ZSTDv07_DCtx* ZSTDv07_createDCtx_advanced(ZSTDv07_customMem customMem);"},{"Add":""},{"Add":"/*! ZSTDv07_sizeofDCtx() :"},{"Add":" * Gives the amount of memory used by a given ZSTDv07_DCtx */"},{"Add":"ZSTDLIBv07_API size_t ZSTDv07_sizeofDCtx(const ZSTDv07_DCtx* dctx);"},{"Add":""},{"Add":""},{"Add":"/* ******************************************************************"},{"Add":"* Buffer-less streaming functions (synchronous mode)"},{"Add":"********************************************************************/"},{"Add":""},{"Add":"ZSTDLIBv07_API size_t ZSTDv07_decompressBegin(ZSTDv07_DCtx* dctx);"},{"Add":"ZSTDLIBv07_API size_t ZSTDv07_decompressBegin_usingDict(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize);"},{"Add":"ZSTDLIBv07_API void ZSTDv07_copyDCtx(ZSTDv07_DCtx* dctx, const ZSTDv07_DCtx* preparedDCtx);"},{"Add":""},{"Add":"ZSTDLIBv07_API size_t ZSTDv07_nextSrcSizeToDecompress(ZSTDv07_DCtx* dctx);"},{"Add":"ZSTDLIBv07_API size_t ZSTDv07_decompressContinue(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);"},{"Add":""},{"Add":"/*"},{"Add":" Buffer-less streaming decompression (synchronous mode)"},{"Add":""},{"Add":" A ZSTDv07_DCtx object is required to track streaming operations."},{"Add":" Use ZSTDv07_createDCtx() / ZSTDv07_freeDCtx() to manage it."},{"Add":" A ZSTDv07_DCtx object can be re-used multiple times."},{"Add":""},{"Add":" First optional operation is to retrieve frame parameters, using ZSTDv07_getFrameParams(), which doesn't consume the input."},{"Add":" It can provide the minimum size of rolling buffer required to properly decompress data (`windowSize`),"},{"Add":" and optionally the final size of uncompressed content."},{"Add":" (Note : content size is an optional info that may not be present. 0 means : content size unknown)"},{"Add":" Frame parameters are extracted from the beginning of compressed frame."},{"Add":" The amount of data to read is variable, from ZSTDv07_frameHeaderSize_min to ZSTDv07_frameHeaderSize_max (so if `srcSize` >= ZSTDv07_frameHeaderSize_max, it will always work)"},{"Add":" If `srcSize` is too small for operation to succeed, function will return the minimum size it requires to produce a result."},{"Add":" Result : 0 when successful, it means the ZSTDv07_frameParams structure has been filled."},{"Add":" >0 : means there is not enough data into `src`. Provides the expected size to successfully decode header."},{"Add":" errorCode, which can be tested using ZSTDv07_isError()"},{"Add":""},{"Add":" Start decompression, with ZSTDv07_decompressBegin() or ZSTDv07_decompressBegin_usingDict()."},{"Add":" Alternatively, you can copy a prepared context, using ZSTDv07_copyDCtx()."},{"Add":""},{"Add":" Then use ZSTDv07_nextSrcSizeToDecompress() and ZSTDv07_decompressContinue() alternatively."},{"Add":" ZSTDv07_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTDv07_decompressContinue()."},{"Add":" ZSTDv07_decompressContinue() requires this exact amount of bytes, or it will fail."},{"Add":""},{"Add":" @result of ZSTDv07_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity)."},{"Add":" It can be zero, which is not an error; it just means ZSTDv07_decompressContinue() has decoded some header."},{"Add":""},{"Add":" ZSTDv07_decompressContinue() needs previous data blocks during decompression, up to `windowSize`."},{"Add":" They should preferably be located contiguously, prior to current block."},{"Add":" Alternatively, a round buffer of sufficient size is also possible. Sufficient size is determined by frame parameters."},{"Add":" ZSTDv07_decompressContinue() is very sensitive to contiguity,"},{"Add":" if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place,"},{"Add":" or that previous contiguous segment is large enough to properly handle maximum back-reference."},{"Add":""},{"Add":" A frame is fully decoded when ZSTDv07_nextSrcSizeToDecompress() returns zero."},{"Add":" Context can then be reset to start a new decompression."},{"Add":""},{"Add":""},{"Add":" == Special case : skippable frames =="},{"Add":""},{"Add":" Skippable frames allow the integration of user-defined data into a flow of concatenated frames."},{"Add":" Skippable frames will be ignored (skipped) by a decompressor. The format of skippable frame is following:"},{"Add":" a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F"},{"Add":" b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits"},{"Add":" c) Frame Content - any content (User Data) of length equal to Frame Size"},{"Add":" For skippable frames ZSTDv07_decompressContinue() always returns 0."},{"Add":" For skippable frames ZSTDv07_getFrameParams() returns fparamsPtr->windowLog==0 what means that a frame is skippable."},{"Add":" It also returns Frame Size as fparamsPtr->frameContentSize."},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/* **************************************"},{"Add":"* Block functions"},{"Add":"****************************************/"},{"Add":"/*! Block functions produce and decode raw zstd blocks, without frame metadata."},{"Add":" Frame metadata cost is typically ~18 bytes, which can be non-negligible for very small blocks (< 100 bytes)."},{"Add":" User will have to take in charge required information to regenerate data, such as compressed and content sizes."},{"Add":""},{"Add":" A few rules to respect :"},{"Add":" - Compressing and decompressing require a context structure"},{"Add":" + Use ZSTDv07_createCCtx() and ZSTDv07_createDCtx()"},{"Add":" - It is necessary to init context before starting"},{"Add":" + compression : ZSTDv07_compressBegin()"},{"Add":" + decompression : ZSTDv07_decompressBegin()"},{"Add":" + variants _usingDict() are also allowed"},{"Add":" + copyCCtx() and copyDCtx() work too"},{"Add":" - Block size is limited, it must be <= ZSTDv07_getBlockSizeMax()"},{"Add":" + If you need to compress more, cut data into multiple blocks"},{"Add":" + Consider using the regular ZSTDv07_compress() instead, as frame metadata costs become negligible when source size is large."},{"Add":" - When a block is considered not compressible enough, ZSTDv07_compressBlock() result will be zero."},{"Add":" In which case, nothing is produced into `dst`."},{"Add":" + User must test for such outcome and deal directly with uncompressed data"},{"Add":" + ZSTDv07_decompressBlock() doesn't accept uncompressed data as input !!!"},{"Add":" + In case of multiple successive blocks, decoder must be informed of uncompressed block existence to follow proper history."},{"Add":" Use ZSTDv07_insertBlock() in such a case."},{"Add":"*/"},{"Add":""},{"Add":"#define ZSTDv07_BLOCKSIZE_ABSOLUTEMAX (128 * 1024) /* define, for static allocation */"},{"Add":"ZSTDLIBv07_API size_t ZSTDv07_decompressBlock(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);"},{"Add":"ZSTDLIBv07_API size_t ZSTDv07_insertBlock(ZSTDv07_DCtx* dctx, const void* blockStart, size_t blockSize); /**< insert block into `dctx` history. Useful for uncompressed blocks */"},{"Add":""},{"Add":""},{"Add":"#endif /* ZSTDv07_STATIC_LINKING_ONLY */"},{"Add":""},{"Add":""},{"Add":"/* ******************************************************************"},{"Add":" mem.h"},{"Add":" low-level memory access routines"},{"Add":" Copyright (C) 2013-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":"#ifndef MEM_H_MODULE"},{"Add":"#define MEM_H_MODULE"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"/*-****************************************"},{"Add":"* Compiler specifics"},{"Add":"******************************************/"},{"Add":"#if defined(_MSC_VER) /* Visual Studio */"},{"Add":"# include /* _byteswap_ulong */"},{"Add":"# include /* _byteswap_* */"},{"Add":"#endif"},{"Add":"#if defined(__GNUC__)"},{"Add":"# define MEM_STATIC static __attribute__((unused))"},{"Add":"#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)"},{"Add":"# define MEM_STATIC static inline"},{"Add":"#elif defined(_MSC_VER)"},{"Add":"# define MEM_STATIC static __inline"},{"Add":"#else"},{"Add":"# define MEM_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*-**************************************************************"},{"Add":"* Basic Types"},{"Add":"*****************************************************************/"},{"Add":"#if !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )"},{"Add":"# if defined(_AIX)"},{"Add":"# include "},{"Add":"# else"},{"Add":"# include /* intptr_t */"},{"Add":"# endif"},{"Add":" typedef uint8_t BYTE;"},{"Add":" typedef uint16_t U16;"},{"Add":" typedef int16_t S16;"},{"Add":" typedef uint32_t U32;"},{"Add":" typedef int32_t S32;"},{"Add":" typedef uint64_t U64;"},{"Add":" typedef int64_t S64;"},{"Add":"#else"},{"Add":" typedef unsigned char BYTE;"},{"Add":" typedef unsigned short U16;"},{"Add":" typedef signed short S16;"},{"Add":" typedef unsigned int U32;"},{"Add":" typedef signed int S32;"},{"Add":" typedef unsigned long long U64;"},{"Add":" typedef signed long long S64;"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*-**************************************************************"},{"Add":"* Memory I/O"},{"Add":"*****************************************************************/"},{"Add":"/* MEM_FORCE_MEMORY_ACCESS :"},{"Add":" * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable."},{"Add":" * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal."},{"Add":" * The below switch allow to select different access method for improved performance."},{"Add":" * Method 0 (default) : use `memcpy()`. Safe and portable."},{"Add":" * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable)."},{"Add":" * This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`."},{"Add":" * Method 2 : direct access. This method is portable but violate C standard."},{"Add":" * It can generate buggy code on targets depending on alignment."},{"Add":" * In some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)"},{"Add":" * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details."},{"Add":" * Prefer these methods in priority order (0 > 1 > 2)"},{"Add":" */"},{"Add":"#ifndef MEM_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */"},{"Add":"# if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )"},{"Add":"# define MEM_FORCE_MEMORY_ACCESS 2"},{"Add":"# elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \\"},{"Add":" (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))"},{"Add":"# define MEM_FORCE_MEMORY_ACCESS 1"},{"Add":"# endif"},{"Add":"#endif"},{"Add":""},{"Add":"MEM_STATIC unsigned MEM_32bits(void) { return sizeof(size_t)==4; }"},{"Add":"MEM_STATIC unsigned MEM_64bits(void) { return sizeof(size_t)==8; }"},{"Add":""},{"Add":"MEM_STATIC unsigned MEM_isLittleEndian(void)"},{"Add":"{"},{"Add":" const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */"},{"Add":" return one.c[0];"},{"Add":"}"},{"Add":""},{"Add":"#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)"},{"Add":""},{"Add":"/* violates C standard, by lying on structure alignment."},{"Add":"Only use if no other choice to achieve best performance on target platform */"},{"Add":"MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }"},{"Add":"MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }"},{"Add":"MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }"},{"Add":""},{"Add":"#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)"},{"Add":""},{"Add":"/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */"},{"Add":"/* currently only defined for gcc and icc */"},{"Add":"typedef union { U16 u16; U32 u32; U64 u64; size_t st; } __attribute__((packed)) unalign;"},{"Add":""},{"Add":"MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }"},{"Add":"MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }"},{"Add":"MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }"},{"Add":""},{"Add":"#else"},{"Add":""},{"Add":"/* default method, safe and standard."},{"Add":" can sometimes prove slower */"},{"Add":""},{"Add":"MEM_STATIC U16 MEM_read16(const void* memPtr)"},{"Add":"{"},{"Add":" U16 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_read32(const void* memPtr)"},{"Add":"{"},{"Add":" U32 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U64 MEM_read64(const void* memPtr)"},{"Add":"{"},{"Add":" U64 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value)"},{"Add":"{"},{"Add":" memcpy(memPtr, &value, sizeof(value));"},{"Add":"}"},{"Add":""},{"Add":"#endif /* MEM_FORCE_MEMORY_ACCESS */"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_swap32(U32 in)"},{"Add":"{"},{"Add":"#if defined(_MSC_VER) /* Visual Studio */"},{"Add":" return _byteswap_ulong(in);"},{"Add":"#elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)"},{"Add":" return __builtin_bswap32(in);"},{"Add":"#else"},{"Add":" return ((in << 24) & 0xff000000 ) |"},{"Add":" ((in << 8) & 0x00ff0000 ) |"},{"Add":" ((in >> 8) & 0x0000ff00 ) |"},{"Add":" ((in >> 24) & 0x000000ff );"},{"Add":"#endif"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U64 MEM_swap64(U64 in)"},{"Add":"{"},{"Add":"#if defined(_MSC_VER) /* Visual Studio */"},{"Add":" return _byteswap_uint64(in);"},{"Add":"#elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)"},{"Add":" return __builtin_bswap64(in);"},{"Add":"#else"},{"Add":" return ((in << 56) & 0xff00000000000000ULL) |"},{"Add":" ((in << 40) & 0x00ff000000000000ULL) |"},{"Add":" ((in << 24) & 0x0000ff0000000000ULL) |"},{"Add":" ((in << 8) & 0x000000ff00000000ULL) |"},{"Add":" ((in >> 8) & 0x00000000ff000000ULL) |"},{"Add":" ((in >> 24) & 0x0000000000ff0000ULL) |"},{"Add":" ((in >> 40) & 0x000000000000ff00ULL) |"},{"Add":" ((in >> 56) & 0x00000000000000ffULL);"},{"Add":"#endif"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*=== Little endian r/w ===*/"},{"Add":""},{"Add":"MEM_STATIC U16 MEM_readLE16(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read16(memPtr);"},{"Add":" else {"},{"Add":" const BYTE* p = (const BYTE*)memPtr;"},{"Add":" return (U16)(p[0] + (p[1]<<8));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian()) {"},{"Add":" MEM_write16(memPtr, val);"},{"Add":" } else {"},{"Add":" BYTE* p = (BYTE*)memPtr;"},{"Add":" p[0] = (BYTE)val;"},{"Add":" p[1] = (BYTE)(val>>8);"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_readLE32(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read32(memPtr);"},{"Add":" else"},{"Add":" return MEM_swap32(MEM_read32(memPtr));"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"MEM_STATIC U64 MEM_readLE64(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read64(memPtr);"},{"Add":" else"},{"Add":" return MEM_swap64(MEM_read64(memPtr));"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC size_t MEM_readLEST(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_32bits())"},{"Add":" return (size_t)MEM_readLE32(memPtr);"},{"Add":" else"},{"Add":" return (size_t)MEM_readLE64(memPtr);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* MEM_H_MODULE */"},{"Add":"/* ******************************************************************"},{"Add":" bitstream"},{"Add":" Part of FSE library"},{"Add":" header file (to include)"},{"Add":" Copyright (C) 2013-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":"****************************************************************** */"},{"Add":"#ifndef BITSTREAM_H_MODULE"},{"Add":"#define BITSTREAM_H_MODULE"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*"},{"Add":"* This API consists of small unitary functions, which must be inlined for best performance."},{"Add":"* Since link-time-optimization is not available for all compilers,"},{"Add":"* these functions are defined into a .h to be included."},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/*========================================="},{"Add":"* Target specific"},{"Add":"=========================================*/"},{"Add":"#if defined(__BMI__) && defined(__GNUC__)"},{"Add":"# include /* support for bextr (experimental) */"},{"Add":"#endif"},{"Add":""},{"Add":"/*-********************************************"},{"Add":"* bitStream decoding API (read backward)"},{"Add":"**********************************************/"},{"Add":"typedef struct"},{"Add":"{"},{"Add":" size_t bitContainer;"},{"Add":" unsigned bitsConsumed;"},{"Add":" const char* ptr;"},{"Add":" const char* start;"},{"Add":"} BITv07_DStream_t;"},{"Add":""},{"Add":"typedef enum { BITv07_DStream_unfinished = 0,"},{"Add":" BITv07_DStream_endOfBuffer = 1,"},{"Add":" BITv07_DStream_completed = 2,"},{"Add":" BITv07_DStream_overflow = 3 } BITv07_DStream_status; /* result of BITv07_reloadDStream() */"},{"Add":" /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */"},{"Add":""},{"Add":"MEM_STATIC size_t BITv07_initDStream(BITv07_DStream_t* bitD, const void* srcBuffer, size_t srcSize);"},{"Add":"MEM_STATIC size_t BITv07_readBits(BITv07_DStream_t* bitD, unsigned nbBits);"},{"Add":"MEM_STATIC BITv07_DStream_status BITv07_reloadDStream(BITv07_DStream_t* bitD);"},{"Add":"MEM_STATIC unsigned BITv07_endOfDStream(const BITv07_DStream_t* bitD);"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-****************************************"},{"Add":"* unsafe API"},{"Add":"******************************************/"},{"Add":"MEM_STATIC size_t BITv07_readBitsFast(BITv07_DStream_t* bitD, unsigned nbBits);"},{"Add":"/* faster, but works only if nbBits >= 1 */"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-**************************************************************"},{"Add":"* Internal functions"},{"Add":"****************************************************************/"},{"Add":"MEM_STATIC unsigned BITv07_highbit32 (U32 val)"},{"Add":"{"},{"Add":"# if defined(_MSC_VER) /* Visual */"},{"Add":" unsigned long r=0;"},{"Add":" _BitScanReverse ( &r, val );"},{"Add":" return (unsigned) r;"},{"Add":"# elif defined(__GNUC__) && (__GNUC__ >= 3) /* Use GCC Intrinsic */"},{"Add":" return __builtin_clz (val) ^ 31;"},{"Add":"# else /* Software version */"},{"Add":" static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };"},{"Add":" U32 v = val;"},{"Add":" v |= v >> 1;"},{"Add":" v |= v >> 2;"},{"Add":" v |= v >> 4;"},{"Add":" v |= v >> 8;"},{"Add":" v |= v >> 16;"},{"Add":" return DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];"},{"Add":"# endif"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-********************************************************"},{"Add":"* bitStream decoding"},{"Add":"**********************************************************/"},{"Add":"/*! BITv07_initDStream() :"},{"Add":"* Initialize a BITv07_DStream_t."},{"Add":"* `bitD` : a pointer to an already allocated BITv07_DStream_t structure."},{"Add":"* `srcSize` must be the *exact* size of the bitStream, in bytes."},{"Add":"* @return : size of stream (== srcSize) or an errorCode if a problem is detected"},{"Add":"*/"},{"Add":"MEM_STATIC size_t BITv07_initDStream(BITv07_DStream_t* bitD, const void* srcBuffer, size_t srcSize)"},{"Add":"{"},{"Add":" if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }"},{"Add":""},{"Add":" if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */"},{"Add":" bitD->start = (const char*)srcBuffer;"},{"Add":" bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr);"},{"Add":" { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];"},{"Add":" bitD->bitsConsumed = lastByte ? 8 - BITv07_highbit32(lastByte) : 0;"},{"Add":" if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }"},{"Add":" } else {"},{"Add":" bitD->start = (const char*)srcBuffer;"},{"Add":" bitD->ptr = bitD->start;"},{"Add":" bitD->bitContainer = *(const BYTE*)(bitD->start);"},{"Add":" switch(srcSize)"},{"Add":" {"},{"Add":" case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);/* fall-through */"},{"Add":" case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);/* fall-through */"},{"Add":" case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);/* fall-through */"},{"Add":" case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24; /* fall-through */"},{"Add":" case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16; /* fall-through */"},{"Add":" case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) << 8; /* fall-through */"},{"Add":" default: break;"},{"Add":" }"},{"Add":" { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];"},{"Add":" bitD->bitsConsumed = lastByte ? 8 - BITv07_highbit32(lastByte) : 0;"},{"Add":" if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }"},{"Add":" bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;"},{"Add":" }"},{"Add":""},{"Add":" return srcSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":" MEM_STATIC size_t BITv07_lookBits(const BITv07_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1;"},{"Add":" return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);"},{"Add":"}"},{"Add":""},{"Add":"/*! BITv07_lookBitsFast() :"},{"Add":"* unsafe version; only works only if nbBits >= 1 */"},{"Add":"MEM_STATIC size_t BITv07_lookBitsFast(const BITv07_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1;"},{"Add":" return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void BITv07_skipBits(BITv07_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" bitD->bitsConsumed += nbBits;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC size_t BITv07_readBits(BITv07_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" size_t const value = BITv07_lookBits(bitD, nbBits);"},{"Add":" BITv07_skipBits(bitD, nbBits);"},{"Add":" return value;"},{"Add":"}"},{"Add":""},{"Add":"/*! BITv07_readBitsFast() :"},{"Add":"* unsafe version; only works only if nbBits >= 1 */"},{"Add":"MEM_STATIC size_t BITv07_readBitsFast(BITv07_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" size_t const value = BITv07_lookBitsFast(bitD, nbBits);"},{"Add":" BITv07_skipBits(bitD, nbBits);"},{"Add":" return value;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BITv07_DStream_status BITv07_reloadDStream(BITv07_DStream_t* bitD)"},{"Add":"{"},{"Add":" if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* should not happen => corruption detected */"},{"Add":" return BITv07_DStream_overflow;"},{"Add":""},{"Add":" if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) {"},{"Add":" bitD->ptr -= bitD->bitsConsumed >> 3;"},{"Add":" bitD->bitsConsumed &= 7;"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr);"},{"Add":" return BITv07_DStream_unfinished;"},{"Add":" }"},{"Add":" if (bitD->ptr == bitD->start) {"},{"Add":" if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BITv07_DStream_endOfBuffer;"},{"Add":" return BITv07_DStream_completed;"},{"Add":" }"},{"Add":" { U32 nbBytes = bitD->bitsConsumed >> 3;"},{"Add":" BITv07_DStream_status result = BITv07_DStream_unfinished;"},{"Add":" if (bitD->ptr - nbBytes < bitD->start) {"},{"Add":" nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */"},{"Add":" result = BITv07_DStream_endOfBuffer;"},{"Add":" }"},{"Add":" bitD->ptr -= nbBytes;"},{"Add":" bitD->bitsConsumed -= nbBytes*8;"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD) */"},{"Add":" return result;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"/*! BITv07_endOfDStream() :"},{"Add":"* @return Tells if DStream has exactly reached its end (all bits consumed)."},{"Add":"*/"},{"Add":"MEM_STATIC unsigned BITv07_endOfDStream(const BITv07_DStream_t* DStream)"},{"Add":"{"},{"Add":" return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));"},{"Add":"}"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* BITSTREAM_H_MODULE */"},{"Add":"/* ******************************************************************"},{"Add":" FSE : Finite State Entropy codec"},{"Add":" Public Prototypes declaration"},{"Add":" Copyright (C) 2013-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":"****************************************************************** */"},{"Add":"#ifndef FSEv07_H"},{"Add":"#define FSEv07_H"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-****************************************"},{"Add":"* FSE simple functions"},{"Add":"******************************************/"},{"Add":""},{"Add":"/*! FSEv07_decompress():"},{"Add":" Decompress FSE data from buffer 'cSrc', of size 'cSrcSize',"},{"Add":" into already allocated destination buffer 'dst', of size 'dstCapacity'."},{"Add":" @return : size of regenerated data (<= maxDstSize),"},{"Add":" or an error code, which can be tested using FSEv07_isError() ."},{"Add":""},{"Add":" ** Important ** : FSEv07_decompress() does not decompress non-compressible nor RLE data !!!"},{"Add":" Why ? : making this distinction requires a header."},{"Add":" Header management is intentionally delegated to the user layer, which can better manage special cases."},{"Add":"*/"},{"Add":"size_t FSEv07_decompress(void* dst, size_t dstCapacity,"},{"Add":" const void* cSrc, size_t cSrcSize);"},{"Add":""},{"Add":""},{"Add":"/* Error Management */"},{"Add":"unsigned FSEv07_isError(size_t code); /* tells if a return value is an error code */"},{"Add":"const char* FSEv07_getErrorName(size_t code); /* provides error code string (useful for debugging) */"},{"Add":""},{"Add":""},{"Add":"/*-*****************************************"},{"Add":"* FSE detailed API"},{"Add":"******************************************/"},{"Add":"/*!"},{"Add":"FSEv07_decompress() does the following:"},{"Add":"1. read normalized counters with readNCount()"},{"Add":"2. build decoding table 'DTable' from normalized counters"},{"Add":"3. decode the data stream using decoding table 'DTable'"},{"Add":""},{"Add":"The following API allows targeting specific sub-functions for advanced tasks."},{"Add":"For example, it's possible to compress several blocks using the same 'CTable',"},{"Add":"or to save and provide normalized distribution using external method."},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/* *** DECOMPRESSION *** */"},{"Add":""},{"Add":"/*! FSEv07_readNCount():"},{"Add":" Read compactly saved 'normalizedCounter' from 'rBuffer'."},{"Add":" @return : size read from 'rBuffer',"},{"Add":" or an errorCode, which can be tested using FSEv07_isError()."},{"Add":" maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */"},{"Add":"size_t FSEv07_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize);"},{"Add":""},{"Add":"/*! Constructor and Destructor of FSEv07_DTable."},{"Add":" Note that its size depends on 'tableLog' */"},{"Add":"typedef unsigned FSEv07_DTable; /* don't allocate that. It's just a way to be more restrictive than void* */"},{"Add":"FSEv07_DTable* FSEv07_createDTable(unsigned tableLog);"},{"Add":"void FSEv07_freeDTable(FSEv07_DTable* dt);"},{"Add":""},{"Add":"/*! FSEv07_buildDTable():"},{"Add":" Builds 'dt', which must be already allocated, using FSEv07_createDTable()."},{"Add":" return : 0, or an errorCode, which can be tested using FSEv07_isError() */"},{"Add":"size_t FSEv07_buildDTable (FSEv07_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);"},{"Add":""},{"Add":"/*! FSEv07_decompress_usingDTable():"},{"Add":" Decompress compressed source `cSrc` of size `cSrcSize` using `dt`"},{"Add":" into `dst` which must be already allocated."},{"Add":" @return : size of regenerated data (necessarily <= `dstCapacity`),"},{"Add":" or an errorCode, which can be tested using FSEv07_isError() */"},{"Add":"size_t FSEv07_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSEv07_DTable* dt);"},{"Add":""},{"Add":"/*!"},{"Add":"Tutorial :"},{"Add":"----------"},{"Add":"(Note : these functions only decompress FSE-compressed blocks."},{"Add":" If block is uncompressed, use memcpy() instead"},{"Add":" If block is a single repeated byte, use memset() instead )"},{"Add":""},{"Add":"The first step is to obtain the normalized frequencies of symbols."},{"Add":"This can be performed by FSEv07_readNCount() if it was saved using FSEv07_writeNCount()."},{"Add":"'normalizedCounter' must be already allocated, and have at least 'maxSymbolValuePtr[0]+1' cells of signed short."},{"Add":"In practice, that means it's necessary to know 'maxSymbolValue' beforehand,"},{"Add":"or size the table to handle worst case situations (typically 256)."},{"Add":"FSEv07_readNCount() will provide 'tableLog' and 'maxSymbolValue'."},{"Add":"The result of FSEv07_readNCount() is the number of bytes read from 'rBuffer'."},{"Add":"Note that 'rBufferSize' must be at least 4 bytes, even if useful information is less than that."},{"Add":"If there is an error, the function will return an error code, which can be tested using FSEv07_isError()."},{"Add":""},{"Add":"The next step is to build the decompression tables 'FSEv07_DTable' from 'normalizedCounter'."},{"Add":"This is performed by the function FSEv07_buildDTable()."},{"Add":"The space required by 'FSEv07_DTable' must be already allocated using FSEv07_createDTable()."},{"Add":"If there is an error, the function will return an error code, which can be tested using FSEv07_isError()."},{"Add":""},{"Add":"`FSEv07_DTable` can then be used to decompress `cSrc`, with FSEv07_decompress_usingDTable()."},{"Add":"`cSrcSize` must be strictly correct, otherwise decompression will fail."},{"Add":"FSEv07_decompress_usingDTable() result will tell how many bytes were regenerated (<=`dstCapacity`)."},{"Add":"If there is an error, the function will return an error code, which can be tested using FSEv07_isError(). (ex: dst buffer too small)"},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"#ifdef FSEv07_STATIC_LINKING_ONLY"},{"Add":""},{"Add":""},{"Add":"/* *****************************************"},{"Add":"* Static allocation"},{"Add":"*******************************************/"},{"Add":"/* FSE buffer bounds */"},{"Add":"#define FSEv07_NCOUNTBOUND 512"},{"Add":"#define FSEv07_BLOCKBOUND(size) (size + (size>>7))"},{"Add":""},{"Add":"/* It is possible to statically allocate FSE CTable/DTable as a table of unsigned using below macros */"},{"Add":"#define FSEv07_DTABLE_SIZE_U32(maxTableLog) (1 + (1<= 1 (otherwise, result will be corrupted) */"},{"Add":""},{"Add":""},{"Add":"/* ====== Decompression ====== */"},{"Add":""},{"Add":"typedef struct {"},{"Add":" U16 tableLog;"},{"Add":" U16 fastMode;"},{"Add":"} FSEv07_DTableHeader; /* sizeof U32 */"},{"Add":""},{"Add":"typedef struct"},{"Add":"{"},{"Add":" unsigned short newState;"},{"Add":" unsigned char symbol;"},{"Add":" unsigned char nbBits;"},{"Add":"} FSEv07_decode_t; /* size == U32 */"},{"Add":""},{"Add":"MEM_STATIC void FSEv07_initDState(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD, const FSEv07_DTable* dt)"},{"Add":"{"},{"Add":" const void* ptr = dt;"},{"Add":" const FSEv07_DTableHeader* const DTableH = (const FSEv07_DTableHeader*)ptr;"},{"Add":" DStatePtr->state = BITv07_readBits(bitD, DTableH->tableLog);"},{"Add":" BITv07_reloadDStream(bitD);"},{"Add":" DStatePtr->table = dt + 1;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BYTE FSEv07_peekSymbol(const FSEv07_DState_t* DStatePtr)"},{"Add":"{"},{"Add":" FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state];"},{"Add":" return DInfo.symbol;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void FSEv07_updateState(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD)"},{"Add":"{"},{"Add":" FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state];"},{"Add":" U32 const nbBits = DInfo.nbBits;"},{"Add":" size_t const lowBits = BITv07_readBits(bitD, nbBits);"},{"Add":" DStatePtr->state = DInfo.newState + lowBits;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BYTE FSEv07_decodeSymbol(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD)"},{"Add":"{"},{"Add":" FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state];"},{"Add":" U32 const nbBits = DInfo.nbBits;"},{"Add":" BYTE const symbol = DInfo.symbol;"},{"Add":" size_t const lowBits = BITv07_readBits(bitD, nbBits);"},{"Add":""},{"Add":" DStatePtr->state = DInfo.newState + lowBits;"},{"Add":" return symbol;"},{"Add":"}"},{"Add":""},{"Add":"/*! FSEv07_decodeSymbolFast() :"},{"Add":" unsafe, only works if no symbol has a probability > 50% */"},{"Add":"MEM_STATIC BYTE FSEv07_decodeSymbolFast(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD)"},{"Add":"{"},{"Add":" FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state];"},{"Add":" U32 const nbBits = DInfo.nbBits;"},{"Add":" BYTE const symbol = DInfo.symbol;"},{"Add":" size_t const lowBits = BITv07_readBitsFast(bitD, nbBits);"},{"Add":""},{"Add":" DStatePtr->state = DInfo.newState + lowBits;"},{"Add":" return symbol;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"#ifndef FSEv07_COMMONDEFS_ONLY"},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Tuning parameters"},{"Add":"****************************************************************/"},{"Add":"/*!MEMORY_USAGE :"},{"Add":"* Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)"},{"Add":"* Increasing memory usage improves compression ratio"},{"Add":"* Reduced memory usage can improve speed, due to cache effect"},{"Add":"* Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */"},{"Add":"#define FSEv07_MAX_MEMORY_USAGE 14"},{"Add":"#define FSEv07_DEFAULT_MEMORY_USAGE 13"},{"Add":""},{"Add":"/*!FSEv07_MAX_SYMBOL_VALUE :"},{"Add":"* Maximum symbol value authorized."},{"Add":"* Required for proper stack allocation */"},{"Add":"#define FSEv07_MAX_SYMBOL_VALUE 255"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* template functions type & suffix"},{"Add":"****************************************************************/"},{"Add":"#define FSEv07_FUNCTION_TYPE BYTE"},{"Add":"#define FSEv07_FUNCTION_EXTENSION"},{"Add":"#define FSEv07_DECODE_TYPE FSEv07_decode_t"},{"Add":""},{"Add":""},{"Add":"#endif /* !FSEv07_COMMONDEFS_ONLY */"},{"Add":""},{"Add":""},{"Add":"/* ***************************************************************"},{"Add":"* Constants"},{"Add":"*****************************************************************/"},{"Add":"#define FSEv07_MAX_TABLELOG (FSEv07_MAX_MEMORY_USAGE-2)"},{"Add":"#define FSEv07_MAX_TABLESIZE (1U< FSEv07_TABLELOG_ABSOLUTE_MAX"},{"Add":"# error \"FSEv07_MAX_TABLELOG > FSEv07_TABLELOG_ABSOLUTE_MAX is not supported\""},{"Add":"#endif"},{"Add":""},{"Add":"#define FSEv07_TABLESTEP(tableSize) ((tableSize>>1) + (tableSize>>3) + 3)"},{"Add":""},{"Add":""},{"Add":"#endif /* FSEv07_STATIC_LINKING_ONLY */"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* FSEv07_H */"},{"Add":"/* ******************************************************************"},{"Add":" Huffman coder, part of New Generation Entropy library"},{"Add":" header file"},{"Add":" Copyright (C) 2013-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":"****************************************************************** */"},{"Add":"#ifndef HUFv07_H_298734234"},{"Add":"#define HUFv07_H_298734234"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* *** simple functions *** */"},{"Add":"/**"},{"Add":"HUFv07_decompress() :"},{"Add":" Decompress HUF data from buffer 'cSrc', of size 'cSrcSize',"},{"Add":" into already allocated buffer 'dst', of minimum size 'dstSize'."},{"Add":" `dstSize` : **must** be the ***exact*** size of original (uncompressed) data."},{"Add":" Note : in contrast with FSE, HUFv07_decompress can regenerate"},{"Add":" RLE (cSrcSize==1) and uncompressed (cSrcSize==dstSize) data,"},{"Add":" because it knows size to regenerate."},{"Add":" @return : size of regenerated data (== dstSize),"},{"Add":" or an error code, which can be tested using HUFv07_isError()"},{"Add":"*/"},{"Add":"size_t HUFv07_decompress(void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize);"},{"Add":""},{"Add":""},{"Add":"/* ****************************************"},{"Add":"* Tool functions"},{"Add":"******************************************/"},{"Add":"#define HUFv07_BLOCKSIZE_MAX (128 * 1024)"},{"Add":""},{"Add":"/* Error Management */"},{"Add":"unsigned HUFv07_isError(size_t code); /**< tells if a return value is an error code */"},{"Add":"const char* HUFv07_getErrorName(size_t code); /**< provides error code string (useful for debugging) */"},{"Add":""},{"Add":""},{"Add":"/* *** Advanced function *** */"},{"Add":""},{"Add":""},{"Add":"#ifdef HUFv07_STATIC_LINKING_ONLY"},{"Add":""},{"Add":""},{"Add":"/* *** Constants *** */"},{"Add":"#define HUFv07_TABLELOG_ABSOLUTEMAX 16 /* absolute limit of HUFv07_MAX_TABLELOG. Beyond that value, code does not work */"},{"Add":"#define HUFv07_TABLELOG_MAX 12 /* max configured tableLog (for static allocation); can be modified up to HUFv07_ABSOLUTEMAX_TABLELOG */"},{"Add":"#define HUFv07_TABLELOG_DEFAULT 11 /* tableLog by default, when not specified */"},{"Add":"#define HUFv07_SYMBOLVALUE_MAX 255"},{"Add":"#if (HUFv07_TABLELOG_MAX > HUFv07_TABLELOG_ABSOLUTEMAX)"},{"Add":"# error \"HUFv07_TABLELOG_MAX is too large !\""},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* ****************************************"},{"Add":"* Static allocation"},{"Add":"******************************************/"},{"Add":"/* HUF buffer bounds */"},{"Add":"#define HUFv07_BLOCKBOUND(size) (size + (size>>8) + 8) /* only true if incompressible pre-filtered with fast heuristic */"},{"Add":""},{"Add":"/* static allocation of HUF's DTable */"},{"Add":"typedef U32 HUFv07_DTable;"},{"Add":"#define HUFv07_DTABLE_SIZE(maxTableLog) (1 + (1<<(maxTableLog)))"},{"Add":"#define HUFv07_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \\"},{"Add":" HUFv07_DTable DTable[HUFv07_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1)*0x1000001) }"},{"Add":"#define HUFv07_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \\"},{"Add":" HUFv07_DTable DTable[HUFv07_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog)*0x1000001) }"},{"Add":""},{"Add":""},{"Add":"/* ****************************************"},{"Add":"* Advanced decompression functions"},{"Add":"******************************************/"},{"Add":"size_t HUFv07_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */"},{"Add":"size_t HUFv07_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */"},{"Add":""},{"Add":"size_t HUFv07_decompress4X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< decodes RLE and uncompressed */"},{"Add":"size_t HUFv07_decompress4X_hufOnly(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< considers RLE and uncompressed as errors */"},{"Add":"size_t HUFv07_decompress4X2_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */"},{"Add":"size_t HUFv07_decompress4X4_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */"},{"Add":""},{"Add":"size_t HUFv07_decompress1X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);"},{"Add":"size_t HUFv07_decompress1X2_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */"},{"Add":"size_t HUFv07_decompress1X4_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */"},{"Add":""},{"Add":""},{"Add":"/* ****************************************"},{"Add":"* HUF detailed API"},{"Add":"******************************************/"},{"Add":"/*!"},{"Add":"The following API allows targeting specific sub-functions for advanced tasks."},{"Add":"For example, it's possible to compress several blocks using the same 'CTable',"},{"Add":"or to save and regenerate 'CTable' using external methods."},{"Add":"*/"},{"Add":"/* FSEv07_count() : find it within \"fse.h\" */"},{"Add":""},{"Add":"/*! HUFv07_readStats() :"},{"Add":" Read compact Huffman tree, saved by HUFv07_writeCTable()."},{"Add":" `huffWeight` is destination buffer."},{"Add":" @return : size read from `src` , or an error Code ."},{"Add":" Note : Needed by HUFv07_readCTable() and HUFv07_readDTableXn() . */"},{"Add":"size_t HUFv07_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,"},{"Add":" U32* nbSymbolsPtr, U32* tableLogPtr,"},{"Add":" const void* src, size_t srcSize);"},{"Add":""},{"Add":""},{"Add":"/*"},{"Add":"HUFv07_decompress() does the following:"},{"Add":"1. select the decompression algorithm (X2, X4) based on pre-computed heuristics"},{"Add":"2. build Huffman table from save, using HUFv07_readDTableXn()"},{"Add":"3. decode 1 or 4 segments in parallel using HUFv07_decompressSXn_usingDTable"},{"Add":"*/"},{"Add":""},{"Add":"/** HUFv07_selectDecoder() :"},{"Add":"* Tells which decoder is likely to decode faster,"},{"Add":"* based on a set of pre-determined metrics."},{"Add":"* @return : 0==HUFv07_decompress4X2, 1==HUFv07_decompress4X4 ."},{"Add":"* Assumption : 0 < cSrcSize < dstSize <= 128 KB */"},{"Add":"U32 HUFv07_selectDecoder (size_t dstSize, size_t cSrcSize);"},{"Add":""},{"Add":"size_t HUFv07_readDTableX2 (HUFv07_DTable* DTable, const void* src, size_t srcSize);"},{"Add":"size_t HUFv07_readDTableX4 (HUFv07_DTable* DTable, const void* src, size_t srcSize);"},{"Add":""},{"Add":"size_t HUFv07_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);"},{"Add":"size_t HUFv07_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);"},{"Add":"size_t HUFv07_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);"},{"Add":""},{"Add":""},{"Add":"/* single stream variants */"},{"Add":"size_t HUFv07_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /* single-symbol decoder */"},{"Add":"size_t HUFv07_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /* double-symbol decoder */"},{"Add":""},{"Add":"size_t HUFv07_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);"},{"Add":"size_t HUFv07_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);"},{"Add":"size_t HUFv07_decompress1X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);"},{"Add":""},{"Add":""},{"Add":"#endif /* HUFv07_STATIC_LINKING_ONLY */"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* HUFv07_H_298734234 */"},{"Add":"/*"},{"Add":" Common functions of New Generation Entropy library"},{"Add":" Copyright (C) 2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"*************************************************************************** */"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-****************************************"},{"Add":"* FSE Error Management"},{"Add":"******************************************/"},{"Add":"unsigned FSEv07_isError(size_t code) { return ERR_isError(code); }"},{"Add":""},{"Add":"const char* FSEv07_getErrorName(size_t code) { return ERR_getErrorName(code); }"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* HUF Error Management"},{"Add":"****************************************************************/"},{"Add":"unsigned HUFv07_isError(size_t code) { return ERR_isError(code); }"},{"Add":""},{"Add":"const char* HUFv07_getErrorName(size_t code) { return ERR_getErrorName(code); }"},{"Add":""},{"Add":""},{"Add":"/*-**************************************************************"},{"Add":"* FSE NCount encoding-decoding"},{"Add":"****************************************************************/"},{"Add":"static short FSEv07_abs(short a) { return (short)(a<0 ? -a : a); }"},{"Add":""},{"Add":"size_t FSEv07_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,"},{"Add":" const void* headerBuffer, size_t hbSize)"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE*) headerBuffer;"},{"Add":" const BYTE* const iend = istart + hbSize;"},{"Add":" const BYTE* ip = istart;"},{"Add":" int nbBits;"},{"Add":" int remaining;"},{"Add":" int threshold;"},{"Add":" U32 bitStream;"},{"Add":" int bitCount;"},{"Add":" unsigned charnum = 0;"},{"Add":" int previous0 = 0;"},{"Add":""},{"Add":" if (hbSize < 4) return ERROR(srcSize_wrong);"},{"Add":" bitStream = MEM_readLE32(ip);"},{"Add":" nbBits = (bitStream & 0xF) + FSEv07_MIN_TABLELOG; /* extract tableLog */"},{"Add":" if (nbBits > FSEv07_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);"},{"Add":" bitStream >>= 4;"},{"Add":" bitCount = 4;"},{"Add":" *tableLogPtr = nbBits;"},{"Add":" remaining = (1<1) && (charnum<=*maxSVPtr)) {"},{"Add":" if (previous0) {"},{"Add":" unsigned n0 = charnum;"},{"Add":" while ((bitStream & 0xFFFF) == 0xFFFF) {"},{"Add":" n0+=24;"},{"Add":" if (ip < iend-5) {"},{"Add":" ip+=2;"},{"Add":" bitStream = MEM_readLE32(ip) >> bitCount;"},{"Add":" } else {"},{"Add":" bitStream >>= 16;"},{"Add":" bitCount+=16;"},{"Add":" } }"},{"Add":" while ((bitStream & 3) == 3) {"},{"Add":" n0+=3;"},{"Add":" bitStream>>=2;"},{"Add":" bitCount+=2;"},{"Add":" }"},{"Add":" n0 += bitStream & 3;"},{"Add":" bitCount += 2;"},{"Add":" if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);"},{"Add":" while (charnum < n0) normalizedCounter[charnum++] = 0;"},{"Add":" if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {"},{"Add":" ip += bitCount>>3;"},{"Add":" bitCount &= 7;"},{"Add":" bitStream = MEM_readLE32(ip) >> bitCount;"},{"Add":" }"},{"Add":" else"},{"Add":" bitStream >>= 2;"},{"Add":" }"},{"Add":" { short const max = (short)((2*threshold-1)-remaining);"},{"Add":" short count;"},{"Add":""},{"Add":" if ((bitStream & (threshold-1)) < (U32)max) {"},{"Add":" count = (short)(bitStream & (threshold-1));"},{"Add":" bitCount += nbBits-1;"},{"Add":" } else {"},{"Add":" count = (short)(bitStream & (2*threshold-1));"},{"Add":" if (count >= threshold) count -= max;"},{"Add":" bitCount += nbBits;"},{"Add":" }"},{"Add":""},{"Add":" count--; /* extra accuracy */"},{"Add":" remaining -= FSEv07_abs(count);"},{"Add":" normalizedCounter[charnum++] = count;"},{"Add":" previous0 = !count;"},{"Add":" while (remaining < threshold) {"},{"Add":" nbBits--;"},{"Add":" threshold >>= 1;"},{"Add":" }"},{"Add":""},{"Add":" if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {"},{"Add":" ip += bitCount>>3;"},{"Add":" bitCount &= 7;"},{"Add":" } else {"},{"Add":" bitCount -= (int)(8 * (iend - 4 - ip));"},{"Add":" ip = iend - 4;"},{"Add":" }"},{"Add":" bitStream = MEM_readLE32(ip) >> (bitCount & 31);"},{"Add":" } } /* while ((remaining>1) && (charnum<=*maxSVPtr)) */"},{"Add":" if (remaining != 1) return ERROR(GENERIC);"},{"Add":" *maxSVPtr = charnum-1;"},{"Add":""},{"Add":" ip += (bitCount+7)>>3;"},{"Add":" if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong);"},{"Add":" return ip-istart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*! HUFv07_readStats() :"},{"Add":" Read compact Huffman tree, saved by HUFv07_writeCTable()."},{"Add":" `huffWeight` is destination buffer."},{"Add":" @return : size read from `src` , or an error Code ."},{"Add":" Note : Needed by HUFv07_readCTable() and HUFv07_readDTableXn() ."},{"Add":"*/"},{"Add":"size_t HUFv07_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,"},{"Add":" U32* nbSymbolsPtr, U32* tableLogPtr,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" U32 weightTotal;"},{"Add":" const BYTE* ip = (const BYTE*) src;"},{"Add":" size_t iSize;"},{"Add":" size_t oSize;"},{"Add":""},{"Add":" if (!srcSize) return ERROR(srcSize_wrong);"},{"Add":" iSize = ip[0];"},{"Add":" /* memset(huffWeight, 0, hwSize); */ /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" if (iSize >= 128) { /* special header */"},{"Add":" if (iSize >= (242)) { /* RLE */"},{"Add":" static U32 l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };"},{"Add":" oSize = l[iSize-242];"},{"Add":" memset(huffWeight, 1, hwSize);"},{"Add":" iSize = 0;"},{"Add":" }"},{"Add":" else { /* Incompressible */"},{"Add":" oSize = iSize - 127;"},{"Add":" iSize = ((oSize+1)/2);"},{"Add":" if (iSize+1 > srcSize) return ERROR(srcSize_wrong);"},{"Add":" if (oSize >= hwSize) return ERROR(corruption_detected);"},{"Add":" ip += 1;"},{"Add":" { U32 n;"},{"Add":" for (n=0; n> 4;"},{"Add":" huffWeight[n+1] = ip[n/2] & 15;"},{"Add":" } } } }"},{"Add":" else { /* header compressed with FSE (normal case) */"},{"Add":" if (iSize+1 > srcSize) return ERROR(srcSize_wrong);"},{"Add":" oSize = FSEv07_decompress(huffWeight, hwSize-1, ip+1, iSize); /* max (hwSize-1) values decoded, as last one is implied */"},{"Add":" if (FSEv07_isError(oSize)) return oSize;"},{"Add":" }"},{"Add":""},{"Add":" /* collect weight stats */"},{"Add":" memset(rankStats, 0, (HUFv07_TABLELOG_ABSOLUTEMAX + 1) * sizeof(U32));"},{"Add":" weightTotal = 0;"},{"Add":" { U32 n; for (n=0; n= HUFv07_TABLELOG_ABSOLUTEMAX) return ERROR(corruption_detected);"},{"Add":" rankStats[huffWeight[n]]++;"},{"Add":" weightTotal += (1 << huffWeight[n]) >> 1;"},{"Add":" } }"},{"Add":" if (weightTotal == 0) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* get last non-null symbol weight (implied, total must be 2^n) */"},{"Add":" { U32 const tableLog = BITv07_highbit32(weightTotal) + 1;"},{"Add":" if (tableLog > HUFv07_TABLELOG_ABSOLUTEMAX) return ERROR(corruption_detected);"},{"Add":" *tableLogPtr = tableLog;"},{"Add":" /* determine last weight */"},{"Add":" { U32 const total = 1 << tableLog;"},{"Add":" U32 const rest = total - weightTotal;"},{"Add":" U32 const verif = 1 << BITv07_highbit32(rest);"},{"Add":" U32 const lastWeight = BITv07_highbit32(rest) + 1;"},{"Add":" if (verif != rest) return ERROR(corruption_detected); /* last value must be a clean power of 2 */"},{"Add":" huffWeight[oSize] = (BYTE)lastWeight;"},{"Add":" rankStats[lastWeight]++;"},{"Add":" } }"},{"Add":""},{"Add":" /* check tree construction validity */"},{"Add":" if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected); /* by construction : at least 2 elts of rank 1, must be even */"},{"Add":""},{"Add":" /* results */"},{"Add":" *nbSymbolsPtr = (U32)(oSize+1);"},{"Add":" return iSize+1;"},{"Add":"}"},{"Add":"/* ******************************************************************"},{"Add":" FSE : Finite State Entropy decoder"},{"Add":" Copyright (C) 2013-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Compiler specifics"},{"Add":"****************************************************************/"},{"Add":"#ifdef _MSC_VER /* Visual Studio */"},{"Add":"# define FORCE_INLINE static __forceinline"},{"Add":"# include /* For Visual 2005 */"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"# pragma warning(disable : 4214) /* disable: C4214: non-int bitfields */"},{"Add":"#else"},{"Add":"# if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */"},{"Add":"# ifdef __GNUC__"},{"Add":"# define FORCE_INLINE static inline __attribute__((always_inline))"},{"Add":"# else"},{"Add":"# define FORCE_INLINE static inline"},{"Add":"# endif"},{"Add":"# else"},{"Add":"# define FORCE_INLINE static"},{"Add":"# endif /* __STDC_VERSION__ */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Error Management"},{"Add":"****************************************************************/"},{"Add":"#define FSEv07_isError ERR_isError"},{"Add":"#define FSEv07_STATIC_ASSERT(c) { enum { FSEv07_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Complex types"},{"Add":"****************************************************************/"},{"Add":"typedef U32 DTable_max_t[FSEv07_DTABLE_SIZE_U32(FSEv07_MAX_TABLELOG)];"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Templates"},{"Add":"****************************************************************/"},{"Add":"/*"},{"Add":" designed to be included"},{"Add":" for type-specific functions (template emulation in C)"},{"Add":" Objective is to write these functions only once, for improved maintenance"},{"Add":"*/"},{"Add":""},{"Add":"/* safety checks */"},{"Add":"#ifndef FSEv07_FUNCTION_EXTENSION"},{"Add":"# error \"FSEv07_FUNCTION_EXTENSION must be defined\""},{"Add":"#endif"},{"Add":"#ifndef FSEv07_FUNCTION_TYPE"},{"Add":"# error \"FSEv07_FUNCTION_TYPE must be defined\""},{"Add":"#endif"},{"Add":""},{"Add":"/* Function names */"},{"Add":"#define FSEv07_CAT(X,Y) X##Y"},{"Add":"#define FSEv07_FUNCTION_NAME(X,Y) FSEv07_CAT(X,Y)"},{"Add":"#define FSEv07_TYPE_NAME(X,Y) FSEv07_CAT(X,Y)"},{"Add":""},{"Add":""},{"Add":"/* Function templates */"},{"Add":"FSEv07_DTable* FSEv07_createDTable (unsigned tableLog)"},{"Add":"{"},{"Add":" if (tableLog > FSEv07_TABLELOG_ABSOLUTE_MAX) tableLog = FSEv07_TABLELOG_ABSOLUTE_MAX;"},{"Add":" return (FSEv07_DTable*)malloc( FSEv07_DTABLE_SIZE_U32(tableLog) * sizeof (U32) );"},{"Add":"}"},{"Add":""},{"Add":"void FSEv07_freeDTable (FSEv07_DTable* dt)"},{"Add":"{"},{"Add":" free(dt);"},{"Add":"}"},{"Add":""},{"Add":"size_t FSEv07_buildDTable(FSEv07_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)"},{"Add":"{"},{"Add":" void* const tdPtr = dt+1; /* because *dt is unsigned, 32-bits aligned on 32-bits */"},{"Add":" FSEv07_DECODE_TYPE* const tableDecode = (FSEv07_DECODE_TYPE*) (tdPtr);"},{"Add":" U16 symbolNext[FSEv07_MAX_SYMBOL_VALUE+1];"},{"Add":""},{"Add":" U32 const maxSV1 = maxSymbolValue + 1;"},{"Add":" U32 const tableSize = 1 << tableLog;"},{"Add":" U32 highThreshold = tableSize-1;"},{"Add":""},{"Add":" /* Sanity Checks */"},{"Add":" if (maxSymbolValue > FSEv07_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);"},{"Add":" if (tableLog > FSEv07_MAX_TABLELOG) return ERROR(tableLog_tooLarge);"},{"Add":""},{"Add":" /* Init, lay down lowprob symbols */"},{"Add":" { FSEv07_DTableHeader DTableH;"},{"Add":" DTableH.tableLog = (U16)tableLog;"},{"Add":" DTableH.fastMode = 1;"},{"Add":" { S16 const largeLimit= (S16)(1 << (tableLog-1));"},{"Add":" U32 s;"},{"Add":" for (s=0; s= largeLimit) DTableH.fastMode=0;"},{"Add":" symbolNext[s] = normalizedCounter[s];"},{"Add":" } } }"},{"Add":" memcpy(dt, &DTableH, sizeof(DTableH));"},{"Add":" }"},{"Add":""},{"Add":" /* Spread symbols */"},{"Add":" { U32 const tableMask = tableSize-1;"},{"Add":" U32 const step = FSEv07_TABLESTEP(tableSize);"},{"Add":" U32 s, position = 0;"},{"Add":" for (s=0; s highThreshold) position = (position + step) & tableMask; /* lowprob area */"},{"Add":" } }"},{"Add":""},{"Add":" if (position!=0) return ERROR(GENERIC); /* position must reach all cells once, otherwise normalizedCounter is incorrect */"},{"Add":" }"},{"Add":""},{"Add":" /* Build Decoding table */"},{"Add":" { U32 u;"},{"Add":" for (u=0; utableLog = 0;"},{"Add":" DTableH->fastMode = 0;"},{"Add":""},{"Add":" cell->newState = 0;"},{"Add":" cell->symbol = symbolValue;"},{"Add":" cell->nbBits = 0;"},{"Add":""},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t FSEv07_buildDTable_raw (FSEv07_DTable* dt, unsigned nbBits)"},{"Add":"{"},{"Add":" void* ptr = dt;"},{"Add":" FSEv07_DTableHeader* const DTableH = (FSEv07_DTableHeader*)ptr;"},{"Add":" void* dPtr = dt + 1;"},{"Add":" FSEv07_decode_t* const dinfo = (FSEv07_decode_t*)dPtr;"},{"Add":" const unsigned tableSize = 1 << nbBits;"},{"Add":" const unsigned tableMask = tableSize - 1;"},{"Add":" const unsigned maxSV1 = tableMask+1;"},{"Add":" unsigned s;"},{"Add":""},{"Add":" /* Sanity checks */"},{"Add":" if (nbBits < 1) return ERROR(GENERIC); /* min size */"},{"Add":""},{"Add":" /* Build Decoding Table */"},{"Add":" DTableH->tableLog = (U16)nbBits;"},{"Add":" DTableH->fastMode = 1;"},{"Add":" for (s=0; s sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" BITv07_reloadDStream(&bitD);"},{"Add":""},{"Add":" op[1] = FSEv07_GETSYMBOL(&state2);"},{"Add":""},{"Add":" if (FSEv07_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" { if (BITv07_reloadDStream(&bitD) > BITv07_DStream_unfinished) { op+=2; break; } }"},{"Add":""},{"Add":" op[2] = FSEv07_GETSYMBOL(&state1);"},{"Add":""},{"Add":" if (FSEv07_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" BITv07_reloadDStream(&bitD);"},{"Add":""},{"Add":" op[3] = FSEv07_GETSYMBOL(&state2);"},{"Add":" }"},{"Add":""},{"Add":" /* tail */"},{"Add":" /* note : BITv07_reloadDStream(&bitD) >= FSEv07_DStream_partiallyFilled; Ends at exactly BITv07_DStream_completed */"},{"Add":" while (1) {"},{"Add":" if (op>(omax-2)) return ERROR(dstSize_tooSmall);"},{"Add":""},{"Add":" *op++ = FSEv07_GETSYMBOL(&state1);"},{"Add":""},{"Add":" if (BITv07_reloadDStream(&bitD)==BITv07_DStream_overflow) {"},{"Add":" *op++ = FSEv07_GETSYMBOL(&state2);"},{"Add":" break;"},{"Add":" }"},{"Add":""},{"Add":" if (op>(omax-2)) return ERROR(dstSize_tooSmall);"},{"Add":""},{"Add":" *op++ = FSEv07_GETSYMBOL(&state2);"},{"Add":""},{"Add":" if (BITv07_reloadDStream(&bitD)==BITv07_DStream_overflow) {"},{"Add":" *op++ = FSEv07_GETSYMBOL(&state1);"},{"Add":" break;"},{"Add":" } }"},{"Add":""},{"Add":" return op-ostart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t FSEv07_decompress_usingDTable(void* dst, size_t originalSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const FSEv07_DTable* dt)"},{"Add":"{"},{"Add":" const void* ptr = dt;"},{"Add":" const FSEv07_DTableHeader* DTableH = (const FSEv07_DTableHeader*)ptr;"},{"Add":" const U32 fastMode = DTableH->fastMode;"},{"Add":""},{"Add":" /* select fast mode (static) */"},{"Add":" if (fastMode) return FSEv07_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);"},{"Add":" return FSEv07_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t FSEv07_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE*)cSrc;"},{"Add":" const BYTE* ip = istart;"},{"Add":" short counting[FSEv07_MAX_SYMBOL_VALUE+1];"},{"Add":" DTable_max_t dt; /* Static analyzer seems unable to understand this table will be properly initialized later */"},{"Add":" unsigned tableLog;"},{"Add":" unsigned maxSymbolValue = FSEv07_MAX_SYMBOL_VALUE;"},{"Add":""},{"Add":" if (cSrcSize<2) return ERROR(srcSize_wrong); /* too small input size */"},{"Add":""},{"Add":" /* normal FSE decoding mode */"},{"Add":" { size_t const NCountLength = FSEv07_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);"},{"Add":" if (FSEv07_isError(NCountLength)) return NCountLength;"},{"Add":" if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong); /* too small input size */"},{"Add":" ip += NCountLength;"},{"Add":" cSrcSize -= NCountLength;"},{"Add":" }"},{"Add":""},{"Add":" { size_t const errorCode = FSEv07_buildDTable (dt, counting, maxSymbolValue, tableLog);"},{"Add":" if (FSEv07_isError(errorCode)) return errorCode; }"},{"Add":""},{"Add":" return FSEv07_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt); /* always return, even if it is an error code */"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"#endif /* FSEv07_COMMONDEFS_ONLY */"},{"Add":""},{"Add":"/* ******************************************************************"},{"Add":" Huffman decoder, part of New Generation Entropy library"},{"Add":" Copyright (C) 2013-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Compiler specifics"},{"Add":"****************************************************************/"},{"Add":"#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)"},{"Add":"/* inline is defined */"},{"Add":"#elif defined(_MSC_VER)"},{"Add":"# define inline __inline"},{"Add":"#else"},{"Add":"# define inline /* disable inline */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"#ifdef _MSC_VER /* Visual Studio */"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Error Management"},{"Add":"****************************************************************/"},{"Add":"#define HUFv07_STATIC_ASSERT(c) { enum { HUFv07_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */"},{"Add":""},{"Add":""},{"Add":"/*-***************************/"},{"Add":"/* generic DTableDesc */"},{"Add":"/*-***************************/"},{"Add":""},{"Add":"typedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc;"},{"Add":""},{"Add":"static DTableDesc HUFv07_getDTableDesc(const HUFv07_DTable* table)"},{"Add":"{"},{"Add":" DTableDesc dtd;"},{"Add":" memcpy(&dtd, table, sizeof(dtd));"},{"Add":" return dtd;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*-***************************/"},{"Add":"/* single-symbol decoding */"},{"Add":"/*-***************************/"},{"Add":""},{"Add":"typedef struct { BYTE byte; BYTE nbBits; } HUFv07_DEltX2; /* single-symbol decoding */"},{"Add":""},{"Add":"size_t HUFv07_readDTableX2 (HUFv07_DTable* DTable, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" BYTE huffWeight[HUFv07_SYMBOLVALUE_MAX + 1];"},{"Add":" U32 rankVal[HUFv07_TABLELOG_ABSOLUTEMAX + 1]; /* large enough for values from 0 to 16 */"},{"Add":" U32 tableLog = 0;"},{"Add":" U32 nbSymbols = 0;"},{"Add":" size_t iSize;"},{"Add":" void* const dtPtr = DTable + 1;"},{"Add":" HUFv07_DEltX2* const dt = (HUFv07_DEltX2*)dtPtr;"},{"Add":""},{"Add":" HUFv07_STATIC_ASSERT(sizeof(DTableDesc) == sizeof(HUFv07_DTable));"},{"Add":" /* memset(huffWeight, 0, sizeof(huffWeight)); */ /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" iSize = HUFv07_readStats(huffWeight, HUFv07_SYMBOLVALUE_MAX + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);"},{"Add":" if (HUFv07_isError(iSize)) return iSize;"},{"Add":""},{"Add":" /* Table header */"},{"Add":" { DTableDesc dtd = HUFv07_getDTableDesc(DTable);"},{"Add":" if (tableLog > (U32)(dtd.maxTableLog+1)) return ERROR(tableLog_tooLarge); /* DTable too small, huffman tree cannot fit in */"},{"Add":" dtd.tableType = 0;"},{"Add":" dtd.tableLog = (BYTE)tableLog;"},{"Add":" memcpy(DTable, &dtd, sizeof(dtd));"},{"Add":" }"},{"Add":""},{"Add":" /* Prepare ranks */"},{"Add":" { U32 n, nextRankStart = 0;"},{"Add":" for (n=1; n> 1;"},{"Add":" U32 i;"},{"Add":" HUFv07_DEltX2 D;"},{"Add":" D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);"},{"Add":" for (i = rankVal[w]; i < rankVal[w] + length; i++)"},{"Add":" dt[i] = D;"},{"Add":" rankVal[w] += length;"},{"Add":" } }"},{"Add":""},{"Add":" return iSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static BYTE HUFv07_decodeSymbolX2(BITv07_DStream_t* Dstream, const HUFv07_DEltX2* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" size_t const val = BITv07_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */"},{"Add":" BYTE const c = dt[val].byte;"},{"Add":" BITv07_skipBits(Dstream, dt[val].nbBits);"},{"Add":" return c;"},{"Add":"}"},{"Add":""},{"Add":"#define HUFv07_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \\"},{"Add":" *ptr++ = HUFv07_decodeSymbolX2(DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUFv07_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits() || (HUFv07_TABLELOG_MAX<=12)) \\"},{"Add":" HUFv07_DECODE_SYMBOLX2_0(ptr, DStreamPtr)"},{"Add":""},{"Add":"#define HUFv07_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits()) \\"},{"Add":" HUFv07_DECODE_SYMBOLX2_0(ptr, DStreamPtr)"},{"Add":""},{"Add":"static inline size_t HUFv07_decodeStreamX2(BYTE* p, BITv07_DStream_t* const bitDPtr, BYTE* const pEnd, const HUFv07_DEltX2* const dt, const U32 dtLog)"},{"Add":"{"},{"Add":" BYTE* const pStart = p;"},{"Add":""},{"Add":" /* up to 4 symbols at a time */"},{"Add":" while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p <= pEnd-4)) {"},{"Add":" HUFv07_DECODE_SYMBOLX2_2(p, bitDPtr);"},{"Add":" HUFv07_DECODE_SYMBOLX2_1(p, bitDPtr);"},{"Add":" HUFv07_DECODE_SYMBOLX2_2(p, bitDPtr);"},{"Add":" HUFv07_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":" }"},{"Add":""},{"Add":" /* closer to the end */"},{"Add":" while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p < pEnd))"},{"Add":" HUFv07_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":""},{"Add":" /* no more data to retrieve from bitstream, hence no need to reload */"},{"Add":" while (p < pEnd)"},{"Add":" HUFv07_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":""},{"Add":" return pEnd-pStart;"},{"Add":"}"},{"Add":""},{"Add":"static size_t HUFv07_decompress1X2_usingDTable_internal("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const HUFv07_DTable* DTable)"},{"Add":"{"},{"Add":" BYTE* op = (BYTE*)dst;"},{"Add":" BYTE* const oend = op + dstSize;"},{"Add":" const void* dtPtr = DTable + 1;"},{"Add":" const HUFv07_DEltX2* const dt = (const HUFv07_DEltX2*)dtPtr;"},{"Add":" BITv07_DStream_t bitD;"},{"Add":" DTableDesc const dtd = HUFv07_getDTableDesc(DTable);"},{"Add":" U32 const dtLog = dtd.tableLog;"},{"Add":""},{"Add":" { size_t const errorCode = BITv07_initDStream(&bitD, cSrc, cSrcSize);"},{"Add":" if (HUFv07_isError(errorCode)) return errorCode; }"},{"Add":""},{"Add":" HUFv07_decodeStreamX2(op, &bitD, oend, dt, dtLog);"},{"Add":""},{"Add":" /* check */"},{"Add":" if (!BITv07_endOfDStream(&bitD)) return ERROR(corruption_detected);"},{"Add":""},{"Add":" return dstSize;"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv07_decompress1X2_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const HUFv07_DTable* DTable)"},{"Add":"{"},{"Add":" DTableDesc dtd = HUFv07_getDTableDesc(DTable);"},{"Add":" if (dtd.tableType != 0) return ERROR(GENERIC);"},{"Add":" return HUFv07_decompress1X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv07_decompress1X2_DCtx (HUFv07_DTable* DCtx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":""},{"Add":" size_t const hSize = HUFv07_readDTableX2 (DCtx, cSrc, cSrcSize);"},{"Add":" if (HUFv07_isError(hSize)) return hSize;"},{"Add":" if (hSize >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += hSize; cSrcSize -= hSize;"},{"Add":""},{"Add":" return HUFv07_decompress1X2_usingDTable_internal (dst, dstSize, ip, cSrcSize, DCtx);"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv07_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUFv07_CREATE_STATIC_DTABLEX2(DTable, HUFv07_TABLELOG_MAX);"},{"Add":" return HUFv07_decompress1X2_DCtx (DTable, dst, dstSize, cSrc, cSrcSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t HUFv07_decompress4X2_usingDTable_internal("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const HUFv07_DTable* DTable)"},{"Add":"{"},{"Add":" /* Check */"},{"Add":" if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */"},{"Add":""},{"Add":" { const BYTE* const istart = (const BYTE*) cSrc;"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* const oend = ostart + dstSize;"},{"Add":" const void* const dtPtr = DTable + 1;"},{"Add":" const HUFv07_DEltX2* const dt = (const HUFv07_DEltX2*)dtPtr;"},{"Add":""},{"Add":" /* Init */"},{"Add":" BITv07_DStream_t bitD1;"},{"Add":" BITv07_DStream_t bitD2;"},{"Add":" BITv07_DStream_t bitD3;"},{"Add":" BITv07_DStream_t bitD4;"},{"Add":" size_t const length1 = MEM_readLE16(istart);"},{"Add":" size_t const length2 = MEM_readLE16(istart+2);"},{"Add":" size_t const length3 = MEM_readLE16(istart+4);"},{"Add":" size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);"},{"Add":" const BYTE* const istart1 = istart + 6; /* jumpTable */"},{"Add":" const BYTE* const istart2 = istart1 + length1;"},{"Add":" const BYTE* const istart3 = istart2 + length2;"},{"Add":" const BYTE* const istart4 = istart3 + length3;"},{"Add":" const size_t segmentSize = (dstSize+3) / 4;"},{"Add":" BYTE* const opStart2 = ostart + segmentSize;"},{"Add":" BYTE* const opStart3 = opStart2 + segmentSize;"},{"Add":" BYTE* const opStart4 = opStart3 + segmentSize;"},{"Add":" BYTE* op1 = ostart;"},{"Add":" BYTE* op2 = opStart2;"},{"Add":" BYTE* op3 = opStart3;"},{"Add":" BYTE* op4 = opStart4;"},{"Add":" U32 endSignal;"},{"Add":" DTableDesc const dtd = HUFv07_getDTableDesc(DTable);"},{"Add":" U32 const dtLog = dtd.tableLog;"},{"Add":""},{"Add":" if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */"},{"Add":" { size_t const errorCode = BITv07_initDStream(&bitD1, istart1, length1);"},{"Add":" if (HUFv07_isError(errorCode)) return errorCode; }"},{"Add":" { size_t const errorCode = BITv07_initDStream(&bitD2, istart2, length2);"},{"Add":" if (HUFv07_isError(errorCode)) return errorCode; }"},{"Add":" { size_t const errorCode = BITv07_initDStream(&bitD3, istart3, length3);"},{"Add":" if (HUFv07_isError(errorCode)) return errorCode; }"},{"Add":" { size_t const errorCode = BITv07_initDStream(&bitD4, istart4, length4);"},{"Add":" if (HUFv07_isError(errorCode)) return errorCode; }"},{"Add":""},{"Add":" /* 16-32 symbols per loop (4-8 symbols per stream) */"},{"Add":" endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_reloadDStream(&bitD4);"},{"Add":" for ( ; (endSignal==BITv07_DStream_unfinished) && (op4<(oend-7)) ; ) {"},{"Add":" HUFv07_DECODE_SYMBOLX2_2(op1, &bitD1);"},{"Add":" HUFv07_DECODE_SYMBOLX2_2(op2, &bitD2);"},{"Add":" HUFv07_DECODE_SYMBOLX2_2(op3, &bitD3);"},{"Add":" HUFv07_DECODE_SYMBOLX2_2(op4, &bitD4);"},{"Add":" HUFv07_DECODE_SYMBOLX2_1(op1, &bitD1);"},{"Add":" HUFv07_DECODE_SYMBOLX2_1(op2, &bitD2);"},{"Add":" HUFv07_DECODE_SYMBOLX2_1(op3, &bitD3);"},{"Add":" HUFv07_DECODE_SYMBOLX2_1(op4, &bitD4);"},{"Add":" HUFv07_DECODE_SYMBOLX2_2(op1, &bitD1);"},{"Add":" HUFv07_DECODE_SYMBOLX2_2(op2, &bitD2);"},{"Add":" HUFv07_DECODE_SYMBOLX2_2(op3, &bitD3);"},{"Add":" HUFv07_DECODE_SYMBOLX2_2(op4, &bitD4);"},{"Add":" HUFv07_DECODE_SYMBOLX2_0(op1, &bitD1);"},{"Add":" HUFv07_DECODE_SYMBOLX2_0(op2, &bitD2);"},{"Add":" HUFv07_DECODE_SYMBOLX2_0(op3, &bitD3);"},{"Add":" HUFv07_DECODE_SYMBOLX2_0(op4, &bitD4);"},{"Add":" endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_reloadDStream(&bitD4);"},{"Add":" }"},{"Add":""},{"Add":" /* check corruption */"},{"Add":" if (op1 > opStart2) return ERROR(corruption_detected);"},{"Add":" if (op2 > opStart3) return ERROR(corruption_detected);"},{"Add":" if (op3 > opStart4) return ERROR(corruption_detected);"},{"Add":" /* note : op4 supposed already verified within main loop */"},{"Add":""},{"Add":" /* finish bitStreams one by one */"},{"Add":" HUFv07_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);"},{"Add":" HUFv07_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);"},{"Add":" HUFv07_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);"},{"Add":" HUFv07_decodeStreamX2(op4, &bitD4, oend, dt, dtLog);"},{"Add":""},{"Add":" /* check */"},{"Add":" endSignal = BITv07_endOfDStream(&bitD1) & BITv07_endOfDStream(&bitD2) & BITv07_endOfDStream(&bitD3) & BITv07_endOfDStream(&bitD4);"},{"Add":" if (!endSignal) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* decoded size */"},{"Add":" return dstSize;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t HUFv07_decompress4X2_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const HUFv07_DTable* DTable)"},{"Add":"{"},{"Add":" DTableDesc dtd = HUFv07_getDTableDesc(DTable);"},{"Add":" if (dtd.tableType != 0) return ERROR(GENERIC);"},{"Add":" return HUFv07_decompress4X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t HUFv07_decompress4X2_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":""},{"Add":" size_t const hSize = HUFv07_readDTableX2 (dctx, cSrc, cSrcSize);"},{"Add":" if (HUFv07_isError(hSize)) return hSize;"},{"Add":" if (hSize >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += hSize; cSrcSize -= hSize;"},{"Add":""},{"Add":" return HUFv07_decompress4X2_usingDTable_internal (dst, dstSize, ip, cSrcSize, dctx);"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv07_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUFv07_CREATE_STATIC_DTABLEX2(DTable, HUFv07_TABLELOG_MAX);"},{"Add":" return HUFv07_decompress4X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/* *************************/"},{"Add":"/* double-symbols decoding */"},{"Add":"/* *************************/"},{"Add":"typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUFv07_DEltX4; /* double-symbols decoding */"},{"Add":""},{"Add":"typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;"},{"Add":""},{"Add":"static void HUFv07_fillDTableX4Level2(HUFv07_DEltX4* DTable, U32 sizeLog, const U32 consumed,"},{"Add":" const U32* rankValOrigin, const int minWeight,"},{"Add":" const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,"},{"Add":" U32 nbBitsBaseline, U16 baseSeq)"},{"Add":"{"},{"Add":" HUFv07_DEltX4 DElt;"},{"Add":" U32 rankVal[HUFv07_TABLELOG_ABSOLUTEMAX + 1];"},{"Add":""},{"Add":" /* get pre-calculated rankVal */"},{"Add":" memcpy(rankVal, rankValOrigin, sizeof(rankVal));"},{"Add":""},{"Add":" /* fill skipped values */"},{"Add":" if (minWeight>1) {"},{"Add":" U32 i, skipSize = rankVal[minWeight];"},{"Add":" MEM_writeLE16(&(DElt.sequence), baseSeq);"},{"Add":" DElt.nbBits = (BYTE)(consumed);"},{"Add":" DElt.length = 1;"},{"Add":" for (i = 0; i < skipSize; i++)"},{"Add":" DTable[i] = DElt;"},{"Add":" }"},{"Add":""},{"Add":" /* fill DTable */"},{"Add":" { U32 s; for (s=0; s= 1 */"},{"Add":""},{"Add":" rankVal[weight] += length;"},{"Add":" }}"},{"Add":"}"},{"Add":""},{"Add":"typedef U32 rankVal_t[HUFv07_TABLELOG_ABSOLUTEMAX][HUFv07_TABLELOG_ABSOLUTEMAX + 1];"},{"Add":""},{"Add":"static void HUFv07_fillDTableX4(HUFv07_DEltX4* DTable, const U32 targetLog,"},{"Add":" const sortedSymbol_t* sortedList, const U32 sortedListSize,"},{"Add":" const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,"},{"Add":" const U32 nbBitsBaseline)"},{"Add":"{"},{"Add":" U32 rankVal[HUFv07_TABLELOG_ABSOLUTEMAX + 1];"},{"Add":" const int scaleLog = nbBitsBaseline - targetLog; /* note : targetLog >= srcLog, hence scaleLog <= 1 */"},{"Add":" const U32 minBits = nbBitsBaseline - maxWeight;"},{"Add":" U32 s;"},{"Add":""},{"Add":" memcpy(rankVal, rankValOrigin, sizeof(rankVal));"},{"Add":""},{"Add":" /* fill DTable */"},{"Add":" for (s=0; s= minBits) { /* enough room for a second symbol */"},{"Add":" U32 sortedRank;"},{"Add":" int minWeight = nbBits + scaleLog;"},{"Add":" if (minWeight < 1) minWeight = 1;"},{"Add":" sortedRank = rankStart[minWeight];"},{"Add":" HUFv07_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,"},{"Add":" rankValOrigin[nbBits], minWeight,"},{"Add":" sortedList+sortedRank, sortedListSize-sortedRank,"},{"Add":" nbBitsBaseline, symbol);"},{"Add":" } else {"},{"Add":" HUFv07_DEltX4 DElt;"},{"Add":" MEM_writeLE16(&(DElt.sequence), symbol);"},{"Add":" DElt.nbBits = (BYTE)(nbBits);"},{"Add":" DElt.length = 1;"},{"Add":" { U32 u;"},{"Add":" const U32 end = start + length;"},{"Add":" for (u = start; u < end; u++) DTable[u] = DElt;"},{"Add":" } }"},{"Add":" rankVal[weight] += length;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv07_readDTableX4 (HUFv07_DTable* DTable, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" BYTE weightList[HUFv07_SYMBOLVALUE_MAX + 1];"},{"Add":" sortedSymbol_t sortedSymbol[HUFv07_SYMBOLVALUE_MAX + 1];"},{"Add":" U32 rankStats[HUFv07_TABLELOG_ABSOLUTEMAX + 1] = { 0 };"},{"Add":" U32 rankStart0[HUFv07_TABLELOG_ABSOLUTEMAX + 2] = { 0 };"},{"Add":" U32* const rankStart = rankStart0+1;"},{"Add":" rankVal_t rankVal;"},{"Add":" U32 tableLog, maxW, sizeOfSort, nbSymbols;"},{"Add":" DTableDesc dtd = HUFv07_getDTableDesc(DTable);"},{"Add":" U32 const maxTableLog = dtd.maxTableLog;"},{"Add":" size_t iSize;"},{"Add":" void* dtPtr = DTable+1; /* force compiler to avoid strict-aliasing */"},{"Add":" HUFv07_DEltX4* const dt = (HUFv07_DEltX4*)dtPtr;"},{"Add":""},{"Add":" HUFv07_STATIC_ASSERT(sizeof(HUFv07_DEltX4) == sizeof(HUFv07_DTable)); /* if compilation fails here, assertion is false */"},{"Add":" if (maxTableLog > HUFv07_TABLELOG_ABSOLUTEMAX) return ERROR(tableLog_tooLarge);"},{"Add":" /* memset(weightList, 0, sizeof(weightList)); */ /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" iSize = HUFv07_readStats(weightList, HUFv07_SYMBOLVALUE_MAX + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);"},{"Add":" if (HUFv07_isError(iSize)) return iSize;"},{"Add":""},{"Add":" /* check result */"},{"Add":" if (tableLog > maxTableLog) return ERROR(tableLog_tooLarge); /* DTable can't fit code depth */"},{"Add":""},{"Add":" /* find maxWeight */"},{"Add":" for (maxW = tableLog; rankStats[maxW]==0; maxW--) {} /* necessarily finds a solution before 0 */"},{"Add":""},{"Add":" /* Get start index of each weight */"},{"Add":" { U32 w, nextRankStart = 0;"},{"Add":" for (w=1; w> consumed;"},{"Add":" } } } }"},{"Add":""},{"Add":" HUFv07_fillDTableX4(dt, maxTableLog,"},{"Add":" sortedSymbol, sizeOfSort,"},{"Add":" rankStart0, rankVal, maxW,"},{"Add":" tableLog+1);"},{"Add":""},{"Add":" dtd.tableLog = (BYTE)maxTableLog;"},{"Add":" dtd.tableType = 1;"},{"Add":" memcpy(DTable, &dtd, sizeof(dtd));"},{"Add":" return iSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static U32 HUFv07_decodeSymbolX4(void* op, BITv07_DStream_t* DStream, const HUFv07_DEltX4* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" const size_t val = BITv07_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */"},{"Add":" memcpy(op, dt+val, 2);"},{"Add":" BITv07_skipBits(DStream, dt[val].nbBits);"},{"Add":" return dt[val].length;"},{"Add":"}"},{"Add":""},{"Add":"static U32 HUFv07_decodeLastSymbolX4(void* op, BITv07_DStream_t* DStream, const HUFv07_DEltX4* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" const size_t val = BITv07_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */"},{"Add":" memcpy(op, dt+val, 1);"},{"Add":" if (dt[val].length==1) BITv07_skipBits(DStream, dt[val].nbBits);"},{"Add":" else {"},{"Add":" if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) {"},{"Add":" BITv07_skipBits(DStream, dt[val].nbBits);"},{"Add":" if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))"},{"Add":" DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8); /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */"},{"Add":" } }"},{"Add":" return 1;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"#define HUFv07_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \\"},{"Add":" ptr += HUFv07_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUFv07_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits() || (HUFv07_TABLELOG_MAX<=12)) \\"},{"Add":" ptr += HUFv07_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUFv07_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits()) \\"},{"Add":" ptr += HUFv07_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"static inline size_t HUFv07_decodeStreamX4(BYTE* p, BITv07_DStream_t* bitDPtr, BYTE* const pEnd, const HUFv07_DEltX4* const dt, const U32 dtLog)"},{"Add":"{"},{"Add":" BYTE* const pStart = p;"},{"Add":""},{"Add":" /* up to 8 symbols at a time */"},{"Add":" while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p < pEnd-7)) {"},{"Add":" HUFv07_DECODE_SYMBOLX4_2(p, bitDPtr);"},{"Add":" HUFv07_DECODE_SYMBOLX4_1(p, bitDPtr);"},{"Add":" HUFv07_DECODE_SYMBOLX4_2(p, bitDPtr);"},{"Add":" HUFv07_DECODE_SYMBOLX4_0(p, bitDPtr);"},{"Add":" }"},{"Add":""},{"Add":" /* closer to end : up to 2 symbols at a time */"},{"Add":" while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p <= pEnd-2))"},{"Add":" HUFv07_DECODE_SYMBOLX4_0(p, bitDPtr);"},{"Add":""},{"Add":" while (p <= pEnd-2)"},{"Add":" HUFv07_DECODE_SYMBOLX4_0(p, bitDPtr); /* no need to reload : reached the end of DStream */"},{"Add":""},{"Add":" if (p < pEnd)"},{"Add":" p += HUFv07_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);"},{"Add":""},{"Add":" return p-pStart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t HUFv07_decompress1X4_usingDTable_internal("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const HUFv07_DTable* DTable)"},{"Add":"{"},{"Add":" BITv07_DStream_t bitD;"},{"Add":""},{"Add":" /* Init */"},{"Add":" { size_t const errorCode = BITv07_initDStream(&bitD, cSrc, cSrcSize);"},{"Add":" if (HUFv07_isError(errorCode)) return errorCode;"},{"Add":" }"},{"Add":""},{"Add":" /* decode */"},{"Add":" { BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* const oend = ostart + dstSize;"},{"Add":" const void* const dtPtr = DTable+1; /* force compiler to not use strict-aliasing */"},{"Add":" const HUFv07_DEltX4* const dt = (const HUFv07_DEltX4*)dtPtr;"},{"Add":" DTableDesc const dtd = HUFv07_getDTableDesc(DTable);"},{"Add":" HUFv07_decodeStreamX4(ostart, &bitD, oend, dt, dtd.tableLog);"},{"Add":" }"},{"Add":""},{"Add":" /* check */"},{"Add":" if (!BITv07_endOfDStream(&bitD)) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* decoded size */"},{"Add":" return dstSize;"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv07_decompress1X4_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const HUFv07_DTable* DTable)"},{"Add":"{"},{"Add":" DTableDesc dtd = HUFv07_getDTableDesc(DTable);"},{"Add":" if (dtd.tableType != 1) return ERROR(GENERIC);"},{"Add":" return HUFv07_decompress1X4_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv07_decompress1X4_DCtx (HUFv07_DTable* DCtx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":""},{"Add":" size_t const hSize = HUFv07_readDTableX4 (DCtx, cSrc, cSrcSize);"},{"Add":" if (HUFv07_isError(hSize)) return hSize;"},{"Add":" if (hSize >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += hSize; cSrcSize -= hSize;"},{"Add":""},{"Add":" return HUFv07_decompress1X4_usingDTable_internal (dst, dstSize, ip, cSrcSize, DCtx);"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv07_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUFv07_CREATE_STATIC_DTABLEX4(DTable, HUFv07_TABLELOG_MAX);"},{"Add":" return HUFv07_decompress1X4_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);"},{"Add":"}"},{"Add":""},{"Add":"static size_t HUFv07_decompress4X4_usingDTable_internal("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const HUFv07_DTable* DTable)"},{"Add":"{"},{"Add":" if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */"},{"Add":""},{"Add":" { const BYTE* const istart = (const BYTE*) cSrc;"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* const oend = ostart + dstSize;"},{"Add":" const void* const dtPtr = DTable+1;"},{"Add":" const HUFv07_DEltX4* const dt = (const HUFv07_DEltX4*)dtPtr;"},{"Add":""},{"Add":" /* Init */"},{"Add":" BITv07_DStream_t bitD1;"},{"Add":" BITv07_DStream_t bitD2;"},{"Add":" BITv07_DStream_t bitD3;"},{"Add":" BITv07_DStream_t bitD4;"},{"Add":" size_t const length1 = MEM_readLE16(istart);"},{"Add":" size_t const length2 = MEM_readLE16(istart+2);"},{"Add":" size_t const length3 = MEM_readLE16(istart+4);"},{"Add":" size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);"},{"Add":" const BYTE* const istart1 = istart + 6; /* jumpTable */"},{"Add":" const BYTE* const istart2 = istart1 + length1;"},{"Add":" const BYTE* const istart3 = istart2 + length2;"},{"Add":" const BYTE* const istart4 = istart3 + length3;"},{"Add":" size_t const segmentSize = (dstSize+3) / 4;"},{"Add":" BYTE* const opStart2 = ostart + segmentSize;"},{"Add":" BYTE* const opStart3 = opStart2 + segmentSize;"},{"Add":" BYTE* const opStart4 = opStart3 + segmentSize;"},{"Add":" BYTE* op1 = ostart;"},{"Add":" BYTE* op2 = opStart2;"},{"Add":" BYTE* op3 = opStart3;"},{"Add":" BYTE* op4 = opStart4;"},{"Add":" U32 endSignal;"},{"Add":" DTableDesc const dtd = HUFv07_getDTableDesc(DTable);"},{"Add":" U32 const dtLog = dtd.tableLog;"},{"Add":""},{"Add":" if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */"},{"Add":" { size_t const errorCode = BITv07_initDStream(&bitD1, istart1, length1);"},{"Add":" if (HUFv07_isError(errorCode)) return errorCode; }"},{"Add":" { size_t const errorCode = BITv07_initDStream(&bitD2, istart2, length2);"},{"Add":" if (HUFv07_isError(errorCode)) return errorCode; }"},{"Add":" { size_t const errorCode = BITv07_initDStream(&bitD3, istart3, length3);"},{"Add":" if (HUFv07_isError(errorCode)) return errorCode; }"},{"Add":" { size_t const errorCode = BITv07_initDStream(&bitD4, istart4, length4);"},{"Add":" if (HUFv07_isError(errorCode)) return errorCode; }"},{"Add":""},{"Add":" /* 16-32 symbols per loop (4-8 symbols per stream) */"},{"Add":" endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_reloadDStream(&bitD4);"},{"Add":" for ( ; (endSignal==BITv07_DStream_unfinished) && (op4<(oend-7)) ; ) {"},{"Add":" HUFv07_DECODE_SYMBOLX4_2(op1, &bitD1);"},{"Add":" HUFv07_DECODE_SYMBOLX4_2(op2, &bitD2);"},{"Add":" HUFv07_DECODE_SYMBOLX4_2(op3, &bitD3);"},{"Add":" HUFv07_DECODE_SYMBOLX4_2(op4, &bitD4);"},{"Add":" HUFv07_DECODE_SYMBOLX4_1(op1, &bitD1);"},{"Add":" HUFv07_DECODE_SYMBOLX4_1(op2, &bitD2);"},{"Add":" HUFv07_DECODE_SYMBOLX4_1(op3, &bitD3);"},{"Add":" HUFv07_DECODE_SYMBOLX4_1(op4, &bitD4);"},{"Add":" HUFv07_DECODE_SYMBOLX4_2(op1, &bitD1);"},{"Add":" HUFv07_DECODE_SYMBOLX4_2(op2, &bitD2);"},{"Add":" HUFv07_DECODE_SYMBOLX4_2(op3, &bitD3);"},{"Add":" HUFv07_DECODE_SYMBOLX4_2(op4, &bitD4);"},{"Add":" HUFv07_DECODE_SYMBOLX4_0(op1, &bitD1);"},{"Add":" HUFv07_DECODE_SYMBOLX4_0(op2, &bitD2);"},{"Add":" HUFv07_DECODE_SYMBOLX4_0(op3, &bitD3);"},{"Add":" HUFv07_DECODE_SYMBOLX4_0(op4, &bitD4);"},{"Add":""},{"Add":" endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_reloadDStream(&bitD4);"},{"Add":" }"},{"Add":""},{"Add":" /* check corruption */"},{"Add":" if (op1 > opStart2) return ERROR(corruption_detected);"},{"Add":" if (op2 > opStart3) return ERROR(corruption_detected);"},{"Add":" if (op3 > opStart4) return ERROR(corruption_detected);"},{"Add":" /* note : op4 supposed already verified within main loop */"},{"Add":""},{"Add":" /* finish bitStreams one by one */"},{"Add":" HUFv07_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);"},{"Add":" HUFv07_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);"},{"Add":" HUFv07_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);"},{"Add":" HUFv07_decodeStreamX4(op4, &bitD4, oend, dt, dtLog);"},{"Add":""},{"Add":" /* check */"},{"Add":" { U32 const endCheck = BITv07_endOfDStream(&bitD1) & BITv07_endOfDStream(&bitD2) & BITv07_endOfDStream(&bitD3) & BITv07_endOfDStream(&bitD4);"},{"Add":" if (!endCheck) return ERROR(corruption_detected); }"},{"Add":""},{"Add":" /* decoded size */"},{"Add":" return dstSize;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t HUFv07_decompress4X4_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const HUFv07_DTable* DTable)"},{"Add":"{"},{"Add":" DTableDesc dtd = HUFv07_getDTableDesc(DTable);"},{"Add":" if (dtd.tableType != 1) return ERROR(GENERIC);"},{"Add":" return HUFv07_decompress4X4_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t HUFv07_decompress4X4_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":""},{"Add":" size_t hSize = HUFv07_readDTableX4 (dctx, cSrc, cSrcSize);"},{"Add":" if (HUFv07_isError(hSize)) return hSize;"},{"Add":" if (hSize >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += hSize; cSrcSize -= hSize;"},{"Add":""},{"Add":" return HUFv07_decompress4X4_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx);"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv07_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUFv07_CREATE_STATIC_DTABLEX4(DTable, HUFv07_TABLELOG_MAX);"},{"Add":" return HUFv07_decompress4X4_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/* ********************************/"},{"Add":"/* Generic decompression selector */"},{"Add":"/* ********************************/"},{"Add":""},{"Add":"size_t HUFv07_decompress1X_usingDTable(void* dst, size_t maxDstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const HUFv07_DTable* DTable)"},{"Add":"{"},{"Add":" DTableDesc const dtd = HUFv07_getDTableDesc(DTable);"},{"Add":" return dtd.tableType ? HUFv07_decompress1X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable) :"},{"Add":" HUFv07_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv07_decompress4X_usingDTable(void* dst, size_t maxDstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const HUFv07_DTable* DTable)"},{"Add":"{"},{"Add":" DTableDesc const dtd = HUFv07_getDTableDesc(DTable);"},{"Add":" return dtd.tableType ? HUFv07_decompress4X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable) :"},{"Add":" HUFv07_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;"},{"Add":"static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] ="},{"Add":"{"},{"Add":" /* single, double, quad */"},{"Add":" {{0,0}, {1,1}, {2,2}}, /* Q==0 : impossible */"},{"Add":" {{0,0}, {1,1}, {2,2}}, /* Q==1 : impossible */"},{"Add":" {{ 38,130}, {1313, 74}, {2151, 38}}, /* Q == 2 : 12-18% */"},{"Add":" {{ 448,128}, {1353, 74}, {2238, 41}}, /* Q == 3 : 18-25% */"},{"Add":" {{ 556,128}, {1353, 74}, {2238, 47}}, /* Q == 4 : 25-32% */"},{"Add":" {{ 714,128}, {1418, 74}, {2436, 53}}, /* Q == 5 : 32-38% */"},{"Add":" {{ 883,128}, {1437, 74}, {2464, 61}}, /* Q == 6 : 38-44% */"},{"Add":" {{ 897,128}, {1515, 75}, {2622, 68}}, /* Q == 7 : 44-50% */"},{"Add":" {{ 926,128}, {1613, 75}, {2730, 75}}, /* Q == 8 : 50-56% */"},{"Add":" {{ 947,128}, {1729, 77}, {3359, 77}}, /* Q == 9 : 56-62% */"},{"Add":" {{1107,128}, {2083, 81}, {4006, 84}}, /* Q ==10 : 62-69% */"},{"Add":" {{1177,128}, {2379, 87}, {4785, 88}}, /* Q ==11 : 69-75% */"},{"Add":" {{1242,128}, {2415, 93}, {5155, 84}}, /* Q ==12 : 75-81% */"},{"Add":" {{1349,128}, {2644,106}, {5260,106}}, /* Q ==13 : 81-87% */"},{"Add":" {{1455,128}, {2422,124}, {4174,124}}, /* Q ==14 : 87-93% */"},{"Add":" {{ 722,128}, {1891,145}, {1936,146}}, /* Q ==15 : 93-99% */"},{"Add":"};"},{"Add":""},{"Add":"/** HUFv07_selectDecoder() :"},{"Add":"* Tells which decoder is likely to decode faster,"},{"Add":"* based on a set of pre-determined metrics."},{"Add":"* @return : 0==HUFv07_decompress4X2, 1==HUFv07_decompress4X4 ."},{"Add":"* Assumption : 0 < cSrcSize < dstSize <= 128 KB */"},{"Add":"U32 HUFv07_selectDecoder (size_t dstSize, size_t cSrcSize)"},{"Add":"{"},{"Add":" /* decoder timing evaluation */"},{"Add":" U32 const Q = (U32)(cSrcSize * 16 / dstSize); /* Q < 16 since dstSize > cSrcSize */"},{"Add":" U32 const D256 = (U32)(dstSize >> 8);"},{"Add":" U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256);"},{"Add":" U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256);"},{"Add":" DTime1 += DTime1 >> 3; /* advantage to algorithm using less memory, for cache eviction */"},{"Add":""},{"Add":" return DTime1 < DTime0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);"},{"Add":""},{"Add":"size_t HUFv07_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" static const decompressionAlgo decompress[2] = { HUFv07_decompress4X2, HUFv07_decompress4X4 };"},{"Add":""},{"Add":" /* validation checks */"},{"Add":" if (dstSize == 0) return ERROR(dstSize_tooSmall);"},{"Add":" if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */"},{"Add":" if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */"},{"Add":" if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */"},{"Add":""},{"Add":" { U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize);"},{"Add":" return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);"},{"Add":" }"},{"Add":""},{"Add":" /* return HUFv07_decompress4X2(dst, dstSize, cSrc, cSrcSize); */ /* multi-streams single-symbol decoding */"},{"Add":" /* return HUFv07_decompress4X4(dst, dstSize, cSrc, cSrcSize); */ /* multi-streams double-symbols decoding */"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv07_decompress4X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" /* validation checks */"},{"Add":" if (dstSize == 0) return ERROR(dstSize_tooSmall);"},{"Add":" if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */"},{"Add":" if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */"},{"Add":" if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */"},{"Add":""},{"Add":" { U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize);"},{"Add":" return algoNb ? HUFv07_decompress4X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :"},{"Add":" HUFv07_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv07_decompress4X_hufOnly (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" /* validation checks */"},{"Add":" if (dstSize == 0) return ERROR(dstSize_tooSmall);"},{"Add":" if ((cSrcSize >= dstSize) || (cSrcSize <= 1)) return ERROR(corruption_detected); /* invalid */"},{"Add":""},{"Add":" { U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize);"},{"Add":" return algoNb ? HUFv07_decompress4X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :"},{"Add":" HUFv07_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv07_decompress1X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" /* validation checks */"},{"Add":" if (dstSize == 0) return ERROR(dstSize_tooSmall);"},{"Add":" if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */"},{"Add":" if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */"},{"Add":" if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */"},{"Add":""},{"Add":" { U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize);"},{"Add":" return algoNb ? HUFv07_decompress1X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :"},{"Add":" HUFv07_decompress1X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;"},{"Add":" }"},{"Add":"}"},{"Add":"/*"},{"Add":" Common functions of Zstd compression library"},{"Add":" Copyright (C) 2015-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - zstd homepage : http://www.zstd.net/"},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-****************************************"},{"Add":"* ZSTD Error Management"},{"Add":"******************************************/"},{"Add":"/*! ZSTDv07_isError() :"},{"Add":"* tells if a return value is an error code */"},{"Add":"unsigned ZSTDv07_isError(size_t code) { return ERR_isError(code); }"},{"Add":""},{"Add":"/*! ZSTDv07_getErrorName() :"},{"Add":"* provides error code string from function result (useful for debugging) */"},{"Add":"const char* ZSTDv07_getErrorName(size_t code) { return ERR_getErrorName(code); }"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* ZBUFF Error Management"},{"Add":"****************************************************************/"},{"Add":"unsigned ZBUFFv07_isError(size_t errorCode) { return ERR_isError(errorCode); }"},{"Add":""},{"Add":"const char* ZBUFFv07_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }"},{"Add":""},{"Add":""},{"Add":""},{"Add":"static void* ZSTDv07_defaultAllocFunction(void* opaque, size_t size)"},{"Add":"{"},{"Add":" void* address = malloc(size);"},{"Add":" (void)opaque;"},{"Add":" /* printf(\"alloc %p, %d opaque=%p \\n\", address, (int)size, opaque); */"},{"Add":" return address;"},{"Add":"}"},{"Add":""},{"Add":"static void ZSTDv07_defaultFreeFunction(void* opaque, void* address)"},{"Add":"{"},{"Add":" (void)opaque;"},{"Add":" /* if (address) printf(\"free %p opaque=%p \\n\", address, opaque); */"},{"Add":" free(address);"},{"Add":"}"},{"Add":"/*"},{"Add":" zstd_internal - common functions to include"},{"Add":" Header File for include"},{"Add":" Copyright (C) 2014-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - zstd homepage : https://www.zstd.net"},{"Add":"*/"},{"Add":"#ifndef ZSTDv07_CCOMMON_H_MODULE"},{"Add":"#define ZSTDv07_CCOMMON_H_MODULE"},{"Add":""},{"Add":""},{"Add":"/*-*************************************"},{"Add":"* Common macros"},{"Add":"***************************************/"},{"Add":"#define MIN(a,b) ((a)<(b) ? (a) : (b))"},{"Add":"#define MAX(a,b) ((a)>(b) ? (a) : (b))"},{"Add":""},{"Add":""},{"Add":"/*-*************************************"},{"Add":"* Common constants"},{"Add":"***************************************/"},{"Add":"#define ZSTDv07_OPT_NUM (1<<12)"},{"Add":"#define ZSTDv07_DICT_MAGIC 0xEC30A437 /* v0.7 */"},{"Add":""},{"Add":"#define ZSTDv07_REP_NUM 3"},{"Add":"#define ZSTDv07_REP_INIT ZSTDv07_REP_NUM"},{"Add":"#define ZSTDv07_REP_MOVE (ZSTDv07_REP_NUM-1)"},{"Add":"static const U32 repStartValue[ZSTDv07_REP_NUM] = { 1, 4, 8 };"},{"Add":""},{"Add":"#define KB *(1 <<10)"},{"Add":"#define MB *(1 <<20)"},{"Add":"#define GB *(1U<<30)"},{"Add":""},{"Add":"#define BIT7 128"},{"Add":"#define BIT6 64"},{"Add":"#define BIT5 32"},{"Add":"#define BIT4 16"},{"Add":"#define BIT1 2"},{"Add":"#define BIT0 1"},{"Add":""},{"Add":"#define ZSTDv07_WINDOWLOG_ABSOLUTEMIN 10"},{"Add":"static const size_t ZSTDv07_fcs_fieldSize[4] = { 0, 2, 4, 8 };"},{"Add":"static const size_t ZSTDv07_did_fieldSize[4] = { 0, 1, 2, 4 };"},{"Add":""},{"Add":"#define ZSTDv07_BLOCKHEADERSIZE 3 /* C standard doesn't allow `static const` variable to be init using another `static const` variable */"},{"Add":"static const size_t ZSTDv07_blockHeaderSize = ZSTDv07_BLOCKHEADERSIZE;"},{"Add":"typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t;"},{"Add":""},{"Add":"#define MIN_SEQUENCES_SIZE 1 /* nbSeq==0 */"},{"Add":"#define MIN_CBLOCK_SIZE (1 /*litCSize*/ + 1 /* RLE or RAW */ + MIN_SEQUENCES_SIZE /* nbSeq==0 */) /* for a non-null block */"},{"Add":""},{"Add":"#define HufLog 12"},{"Add":"typedef enum { lbt_huffman, lbt_repeat, lbt_raw, lbt_rle } litBlockType_t;"},{"Add":""},{"Add":"#define LONGNBSEQ 0x7F00"},{"Add":""},{"Add":"#define MINMATCH 3"},{"Add":"#define EQUAL_READ32 4"},{"Add":""},{"Add":"#define Litbits 8"},{"Add":"#define MaxLit ((1< /* For Visual 2005 */"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"# pragma warning(disable : 4324) /* disable: C4324: padded structure */"},{"Add":"# pragma warning(disable : 4100) /* disable: C4100: unreferenced formal parameter */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*-*************************************"},{"Add":"* Macros"},{"Add":"***************************************/"},{"Add":"#define ZSTDv07_isError ERR_isError /* for inlining */"},{"Add":"#define FSEv07_isError ERR_isError"},{"Add":"#define HUFv07_isError ERR_isError"},{"Add":""},{"Add":""},{"Add":"/*_*******************************************************"},{"Add":"* Memory operations"},{"Add":"**********************************************************/"},{"Add":"static void ZSTDv07_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }"},{"Add":""},{"Add":""},{"Add":"/*-*************************************************************"},{"Add":"* Context management"},{"Add":"***************************************************************/"},{"Add":"typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,"},{"Add":" ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock,"},{"Add":" ZSTDds_decodeSkippableHeader, ZSTDds_skipFrame } ZSTDv07_dStage;"},{"Add":""},{"Add":"struct ZSTDv07_DCtx_s"},{"Add":"{"},{"Add":" FSEv07_DTable LLTable[FSEv07_DTABLE_SIZE_U32(LLFSELog)];"},{"Add":" FSEv07_DTable OffTable[FSEv07_DTABLE_SIZE_U32(OffFSELog)];"},{"Add":" FSEv07_DTable MLTable[FSEv07_DTABLE_SIZE_U32(MLFSELog)];"},{"Add":" HUFv07_DTable hufTable[HUFv07_DTABLE_SIZE(HufLog)]; /* can accommodate HUFv07_decompress4X */"},{"Add":" const void* previousDstEnd;"},{"Add":" const void* base;"},{"Add":" const void* vBase;"},{"Add":" const void* dictEnd;"},{"Add":" size_t expected;"},{"Add":" U32 rep[3];"},{"Add":" ZSTDv07_frameParams fParams;"},{"Add":" blockType_t bType; /* used in ZSTDv07_decompressContinue(), to transfer blockType between header decoding and block decoding stages */"},{"Add":" ZSTDv07_dStage stage;"},{"Add":" U32 litEntropy;"},{"Add":" U32 fseEntropy;"},{"Add":" XXH64_state_t xxhState;"},{"Add":" size_t headerSize;"},{"Add":" U32 dictID;"},{"Add":" const BYTE* litPtr;"},{"Add":" ZSTDv07_customMem customMem;"},{"Add":" size_t litSize;"},{"Add":" BYTE litBuffer[ZSTDv07_BLOCKSIZE_ABSOLUTEMAX + WILDCOPY_OVERLENGTH];"},{"Add":" BYTE headerBuffer[ZSTDv07_FRAMEHEADERSIZE_MAX];"},{"Add":"}; /* typedef'd to ZSTDv07_DCtx within \"zstd_static.h\" */"},{"Add":""},{"Add":"int ZSTDv07_isSkipFrame(ZSTDv07_DCtx* dctx);"},{"Add":""},{"Add":"size_t ZSTDv07_sizeofDCtx (const ZSTDv07_DCtx* dctx) { return sizeof(*dctx); }"},{"Add":""},{"Add":"size_t ZSTDv07_estimateDCtxSize(void) { return sizeof(ZSTDv07_DCtx); }"},{"Add":""},{"Add":"size_t ZSTDv07_decompressBegin(ZSTDv07_DCtx* dctx)"},{"Add":"{"},{"Add":" dctx->expected = ZSTDv07_frameHeaderSize_min;"},{"Add":" dctx->stage = ZSTDds_getFrameHeaderSize;"},{"Add":" dctx->previousDstEnd = NULL;"},{"Add":" dctx->base = NULL;"},{"Add":" dctx->vBase = NULL;"},{"Add":" dctx->dictEnd = NULL;"},{"Add":" dctx->hufTable[0] = (HUFv07_DTable)((HufLog)*0x1000001);"},{"Add":" dctx->litEntropy = dctx->fseEntropy = 0;"},{"Add":" dctx->dictID = 0;"},{"Add":" { int i; for (i=0; irep[i] = repStartValue[i]; }"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"ZSTDv07_DCtx* ZSTDv07_createDCtx_advanced(ZSTDv07_customMem customMem)"},{"Add":"{"},{"Add":" ZSTDv07_DCtx* dctx;"},{"Add":""},{"Add":" if (!customMem.customAlloc && !customMem.customFree)"},{"Add":" customMem = defaultCustomMem;"},{"Add":""},{"Add":" if (!customMem.customAlloc || !customMem.customFree)"},{"Add":" return NULL;"},{"Add":""},{"Add":" dctx = (ZSTDv07_DCtx*) customMem.customAlloc(customMem.opaque, sizeof(ZSTDv07_DCtx));"},{"Add":" if (!dctx) return NULL;"},{"Add":" memcpy(&dctx->customMem, &customMem, sizeof(ZSTDv07_customMem));"},{"Add":" ZSTDv07_decompressBegin(dctx);"},{"Add":" return dctx;"},{"Add":"}"},{"Add":""},{"Add":"ZSTDv07_DCtx* ZSTDv07_createDCtx(void)"},{"Add":"{"},{"Add":" return ZSTDv07_createDCtx_advanced(defaultCustomMem);"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTDv07_freeDCtx(ZSTDv07_DCtx* dctx)"},{"Add":"{"},{"Add":" if (dctx==NULL) return 0; /* support free on NULL */"},{"Add":" dctx->customMem.customFree(dctx->customMem.opaque, dctx);"},{"Add":" return 0; /* reserved as a potential error code in the future */"},{"Add":"}"},{"Add":""},{"Add":"void ZSTDv07_copyDCtx(ZSTDv07_DCtx* dstDCtx, const ZSTDv07_DCtx* srcDCtx)"},{"Add":"{"},{"Add":" memcpy(dstDCtx, srcDCtx,"},{"Add":" sizeof(ZSTDv07_DCtx) - (ZSTDv07_BLOCKSIZE_ABSOLUTEMAX+WILDCOPY_OVERLENGTH + ZSTDv07_frameHeaderSize_max)); /* no need to copy workspace */"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*-*************************************************************"},{"Add":"* Decompression section"},{"Add":"***************************************************************/"},{"Add":""},{"Add":"/* Frame format description"},{"Add":" Frame Header - [ Block Header - Block ] - Frame End"},{"Add":" 1) Frame Header"},{"Add":" - 4 bytes - Magic Number : ZSTDv07_MAGICNUMBER (defined within zstd.h)"},{"Add":" - 1 byte - Frame Descriptor"},{"Add":" 2) Block Header"},{"Add":" - 3 bytes, starting with a 2-bits descriptor"},{"Add":" Uncompressed, Compressed, Frame End, unused"},{"Add":" 3) Block"},{"Add":" See Block Format Description"},{"Add":" 4) Frame End"},{"Add":" - 3 bytes, compatible with Block Header"},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/* Frame Header :"},{"Add":""},{"Add":" 1 byte - FrameHeaderDescription :"},{"Add":" bit 0-1 : dictID (0, 1, 2 or 4 bytes)"},{"Add":" bit 2 : checksumFlag"},{"Add":" bit 3 : reserved (must be zero)"},{"Add":" bit 4 : reserved (unused, can be any value)"},{"Add":" bit 5 : Single Segment (if 1, WindowLog byte is not present)"},{"Add":" bit 6-7 : FrameContentFieldSize (0, 2, 4, or 8)"},{"Add":" if (SkippedWindowLog && !FrameContentFieldsize) FrameContentFieldsize=1;"},{"Add":""},{"Add":" Optional : WindowLog (0 or 1 byte)"},{"Add":" bit 0-2 : octal Fractional (1/8th)"},{"Add":" bit 3-7 : Power of 2, with 0 = 1 KB (up to 2 TB)"},{"Add":""},{"Add":" Optional : dictID (0, 1, 2 or 4 bytes)"},{"Add":" Automatic adaptation"},{"Add":" 0 : no dictID"},{"Add":" 1 : 1 - 255"},{"Add":" 2 : 256 - 65535"},{"Add":" 4 : all other values"},{"Add":""},{"Add":" Optional : content size (0, 1, 2, 4 or 8 bytes)"},{"Add":" 0 : unknown (fcfs==0 and swl==0)"},{"Add":" 1 : 0-255 bytes (fcfs==0 and swl==1)"},{"Add":" 2 : 256 - 65535+256 (fcfs==1)"},{"Add":" 4 : 0 - 4GB-1 (fcfs==2)"},{"Add":" 8 : 0 - 16EB-1 (fcfs==3)"},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/* Compressed Block, format description"},{"Add":""},{"Add":" Block = Literal Section - Sequences Section"},{"Add":" Prerequisite : size of (compressed) block, maximum size of regenerated data"},{"Add":""},{"Add":" 1) Literal Section"},{"Add":""},{"Add":" 1.1) Header : 1-5 bytes"},{"Add":" flags: 2 bits"},{"Add":" 00 compressed by Huff0"},{"Add":" 01 unused"},{"Add":" 10 is Raw (uncompressed)"},{"Add":" 11 is Rle"},{"Add":" Note : using 01 => Huff0 with precomputed table ?"},{"Add":" Note : delta map ? => compressed ?"},{"Add":""},{"Add":" 1.1.1) Huff0-compressed literal block : 3-5 bytes"},{"Add":" srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream"},{"Add":" srcSize < 1 KB => 3 bytes (2-2-10-10)"},{"Add":" srcSize < 16KB => 4 bytes (2-2-14-14)"},{"Add":" else => 5 bytes (2-2-18-18)"},{"Add":" big endian convention"},{"Add":""},{"Add":" 1.1.2) Raw (uncompressed) literal block header : 1-3 bytes"},{"Add":" size : 5 bits: (IS_RAW<<6) + (0<<4) + size"},{"Add":" 12 bits: (IS_RAW<<6) + (2<<4) + (size>>8)"},{"Add":" size&255"},{"Add":" 20 bits: (IS_RAW<<6) + (3<<4) + (size>>16)"},{"Add":" size>>8&255"},{"Add":" size&255"},{"Add":""},{"Add":" 1.1.3) Rle (repeated single byte) literal block header : 1-3 bytes"},{"Add":" size : 5 bits: (IS_RLE<<6) + (0<<4) + size"},{"Add":" 12 bits: (IS_RLE<<6) + (2<<4) + (size>>8)"},{"Add":" size&255"},{"Add":" 20 bits: (IS_RLE<<6) + (3<<4) + (size>>16)"},{"Add":" size>>8&255"},{"Add":" size&255"},{"Add":""},{"Add":" 1.1.4) Huff0-compressed literal block, using precomputed CTables : 3-5 bytes"},{"Add":" srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream"},{"Add":" srcSize < 1 KB => 3 bytes (2-2-10-10)"},{"Add":" srcSize < 16KB => 4 bytes (2-2-14-14)"},{"Add":" else => 5 bytes (2-2-18-18)"},{"Add":" big endian convention"},{"Add":""},{"Add":" 1- CTable available (stored into workspace ?)"},{"Add":" 2- Small input (fast heuristic ? Full comparison ? depend on clevel ?)"},{"Add":""},{"Add":""},{"Add":" 1.2) Literal block content"},{"Add":""},{"Add":" 1.2.1) Huff0 block, using sizes from header"},{"Add":" See Huff0 format"},{"Add":""},{"Add":" 1.2.2) Huff0 block, using prepared table"},{"Add":""},{"Add":" 1.2.3) Raw content"},{"Add":""},{"Add":" 1.2.4) single byte"},{"Add":""},{"Add":""},{"Add":" 2) Sequences section"},{"Add":" TO DO"},{"Add":"*/"},{"Add":""},{"Add":"/** ZSTDv07_frameHeaderSize() :"},{"Add":"* srcSize must be >= ZSTDv07_frameHeaderSize_min."},{"Add":"* @return : size of the Frame Header */"},{"Add":"static size_t ZSTDv07_frameHeaderSize(const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" if (srcSize < ZSTDv07_frameHeaderSize_min) return ERROR(srcSize_wrong);"},{"Add":" { BYTE const fhd = ((const BYTE*)src)[4];"},{"Add":" U32 const dictID= fhd & 3;"},{"Add":" U32 const directMode = (fhd >> 5) & 1;"},{"Add":" U32 const fcsId = fhd >> 6;"},{"Add":" return ZSTDv07_frameHeaderSize_min + !directMode + ZSTDv07_did_fieldSize[dictID] + ZSTDv07_fcs_fieldSize[fcsId]"},{"Add":" + (directMode && !ZSTDv07_fcs_fieldSize[fcsId]);"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/** ZSTDv07_getFrameParams() :"},{"Add":"* decode Frame Header, or require larger `srcSize`."},{"Add":"* @return : 0, `fparamsPtr` is correctly filled,"},{"Add":"* >0, `srcSize` is too small, result is expected `srcSize`,"},{"Add":"* or an error code, which can be tested using ZSTDv07_isError() */"},{"Add":"size_t ZSTDv07_getFrameParams(ZSTDv07_frameParams* fparamsPtr, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":""},{"Add":" if (srcSize < ZSTDv07_frameHeaderSize_min) return ZSTDv07_frameHeaderSize_min;"},{"Add":" memset(fparamsPtr, 0, sizeof(*fparamsPtr));"},{"Add":" if (MEM_readLE32(src) != ZSTDv07_MAGICNUMBER) {"},{"Add":" if ((MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTDv07_MAGIC_SKIPPABLE_START) {"},{"Add":" if (srcSize < ZSTDv07_skippableHeaderSize) return ZSTDv07_skippableHeaderSize; /* magic number + skippable frame length */"},{"Add":" fparamsPtr->frameContentSize = MEM_readLE32((const char *)src + 4);"},{"Add":" fparamsPtr->windowSize = 0; /* windowSize==0 means a frame is skippable */"},{"Add":" return 0;"},{"Add":" }"},{"Add":" return ERROR(prefix_unknown);"},{"Add":" }"},{"Add":""},{"Add":" /* ensure there is enough `srcSize` to fully read/decode frame header */"},{"Add":" { size_t const fhsize = ZSTDv07_frameHeaderSize(src, srcSize);"},{"Add":" if (srcSize < fhsize) return fhsize; }"},{"Add":""},{"Add":" { BYTE const fhdByte = ip[4];"},{"Add":" size_t pos = 5;"},{"Add":" U32 const dictIDSizeCode = fhdByte&3;"},{"Add":" U32 const checksumFlag = (fhdByte>>2)&1;"},{"Add":" U32 const directMode = (fhdByte>>5)&1;"},{"Add":" U32 const fcsID = fhdByte>>6;"},{"Add":" U32 const windowSizeMax = 1U << ZSTDv07_WINDOWLOG_MAX;"},{"Add":" U32 windowSize = 0;"},{"Add":" U32 dictID = 0;"},{"Add":" U64 frameContentSize = 0;"},{"Add":" if ((fhdByte & 0x08) != 0) /* reserved bits, which must be zero */"},{"Add":" return ERROR(frameParameter_unsupported);"},{"Add":" if (!directMode) {"},{"Add":" BYTE const wlByte = ip[pos++];"},{"Add":" U32 const windowLog = (wlByte >> 3) + ZSTDv07_WINDOWLOG_ABSOLUTEMIN;"},{"Add":" if (windowLog > ZSTDv07_WINDOWLOG_MAX)"},{"Add":" return ERROR(frameParameter_unsupported);"},{"Add":" windowSize = (1U << windowLog);"},{"Add":" windowSize += (windowSize >> 3) * (wlByte&7);"},{"Add":" }"},{"Add":""},{"Add":" switch(dictIDSizeCode)"},{"Add":" {"},{"Add":" default: /* impossible */"},{"Add":" case 0 : break;"},{"Add":" case 1 : dictID = ip[pos]; pos++; break;"},{"Add":" case 2 : dictID = MEM_readLE16(ip+pos); pos+=2; break;"},{"Add":" case 3 : dictID = MEM_readLE32(ip+pos); pos+=4; break;"},{"Add":" }"},{"Add":" switch(fcsID)"},{"Add":" {"},{"Add":" default: /* impossible */"},{"Add":" case 0 : if (directMode) frameContentSize = ip[pos]; break;"},{"Add":" case 1 : frameContentSize = MEM_readLE16(ip+pos)+256; break;"},{"Add":" case 2 : frameContentSize = MEM_readLE32(ip+pos); break;"},{"Add":" case 3 : frameContentSize = MEM_readLE64(ip+pos); break;"},{"Add":" }"},{"Add":" if (!windowSize) windowSize = (U32)frameContentSize;"},{"Add":" if (windowSize > windowSizeMax)"},{"Add":" return ERROR(frameParameter_unsupported);"},{"Add":" fparamsPtr->frameContentSize = frameContentSize;"},{"Add":" fparamsPtr->windowSize = windowSize;"},{"Add":" fparamsPtr->dictID = dictID;"},{"Add":" fparamsPtr->checksumFlag = checksumFlag;"},{"Add":" }"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/** ZSTDv07_getDecompressedSize() :"},{"Add":"* compatible with legacy mode"},{"Add":"* @return : decompressed size if known, 0 otherwise"},{"Add":" note : 0 can mean any of the following :"},{"Add":" - decompressed size is not provided within frame header"},{"Add":" - frame header unknown / not supported"},{"Add":" - frame header not completely provided (`srcSize` too small) */"},{"Add":"unsigned long long ZSTDv07_getDecompressedSize(const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" ZSTDv07_frameParams fparams;"},{"Add":" size_t const frResult = ZSTDv07_getFrameParams(&fparams, src, srcSize);"},{"Add":" if (frResult!=0) return 0;"},{"Add":" return fparams.frameContentSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/** ZSTDv07_decodeFrameHeader() :"},{"Add":"* `srcSize` must be the size provided by ZSTDv07_frameHeaderSize()."},{"Add":"* @return : 0 if success, or an error code, which can be tested using ZSTDv07_isError() */"},{"Add":"static size_t ZSTDv07_decodeFrameHeader(ZSTDv07_DCtx* dctx, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" size_t const result = ZSTDv07_getFrameParams(&(dctx->fParams), src, srcSize);"},{"Add":" if (dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID)) return ERROR(dictionary_wrong);"},{"Add":" if (dctx->fParams.checksumFlag) XXH64_reset(&dctx->xxhState, 0);"},{"Add":" return result;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"typedef struct"},{"Add":"{"},{"Add":" blockType_t blockType;"},{"Add":" U32 origSize;"},{"Add":"} blockProperties_t;"},{"Add":""},{"Add":"/*! ZSTDv07_getcBlockSize() :"},{"Add":"* Provides the size of compressed block from block header `src` */"},{"Add":"static size_t ZSTDv07_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)"},{"Add":"{"},{"Add":" const BYTE* const in = (const BYTE*)src;"},{"Add":" U32 cSize;"},{"Add":""},{"Add":" if (srcSize < ZSTDv07_blockHeaderSize) return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" bpPtr->blockType = (blockType_t)((*in) >> 6);"},{"Add":" cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);"},{"Add":" bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;"},{"Add":""},{"Add":" if (bpPtr->blockType == bt_end) return 0;"},{"Add":" if (bpPtr->blockType == bt_rle) return 1;"},{"Add":" return cSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTDv07_copyRawBlock(void* dst, size_t dstCapacity, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" if (srcSize > dstCapacity) return ERROR(dstSize_tooSmall);"},{"Add":" if (srcSize > 0) {"},{"Add":" memcpy(dst, src, srcSize);"},{"Add":" }"},{"Add":" return srcSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*! ZSTDv07_decodeLiteralsBlock() :"},{"Add":" @return : nb of bytes read from src (< srcSize ) */"},{"Add":"static size_t ZSTDv07_decodeLiteralsBlock(ZSTDv07_DCtx* dctx,"},{"Add":" const void* src, size_t srcSize) /* note : srcSize < BLOCKSIZE */"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE*) src;"},{"Add":""},{"Add":" if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);"},{"Add":""},{"Add":" switch((litBlockType_t)(istart[0]>> 6))"},{"Add":" {"},{"Add":" case lbt_huffman:"},{"Add":" { size_t litSize, litCSize, singleStream=0;"},{"Add":" U32 lhSize = (istart[0] >> 4) & 3;"},{"Add":" if (srcSize < 5) return ERROR(corruption_detected); /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for lhSize, + cSize (+nbSeq) */"},{"Add":" switch(lhSize)"},{"Add":" {"},{"Add":" case 0: case 1: default: /* note : default is impossible, since lhSize into [0..3] */"},{"Add":" /* 2 - 2 - 10 - 10 */"},{"Add":" lhSize=3;"},{"Add":" singleStream = istart[0] & 16;"},{"Add":" litSize = ((istart[0] & 15) << 6) + (istart[1] >> 2);"},{"Add":" litCSize = ((istart[1] & 3) << 8) + istart[2];"},{"Add":" break;"},{"Add":" case 2:"},{"Add":" /* 2 - 2 - 14 - 14 */"},{"Add":" lhSize=4;"},{"Add":" litSize = ((istart[0] & 15) << 10) + (istart[1] << 2) + (istart[2] >> 6);"},{"Add":" litCSize = ((istart[2] & 63) << 8) + istart[3];"},{"Add":" break;"},{"Add":" case 3:"},{"Add":" /* 2 - 2 - 18 - 18 */"},{"Add":" lhSize=5;"},{"Add":" litSize = ((istart[0] & 15) << 14) + (istart[1] << 6) + (istart[2] >> 2);"},{"Add":" litCSize = ((istart[2] & 3) << 16) + (istart[3] << 8) + istart[4];"},{"Add":" break;"},{"Add":" }"},{"Add":" if (litSize > ZSTDv07_BLOCKSIZE_ABSOLUTEMAX) return ERROR(corruption_detected);"},{"Add":" if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);"},{"Add":""},{"Add":" if (HUFv07_isError(singleStream ?"},{"Add":" HUFv07_decompress1X2_DCtx(dctx->hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize) :"},{"Add":" HUFv07_decompress4X_hufOnly (dctx->hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize) ))"},{"Add":" return ERROR(corruption_detected);"},{"Add":""},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" dctx->litEntropy = 1;"},{"Add":" memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);"},{"Add":" return litCSize + lhSize;"},{"Add":" }"},{"Add":" case lbt_repeat:"},{"Add":" { size_t litSize, litCSize;"},{"Add":" U32 lhSize = ((istart[0]) >> 4) & 3;"},{"Add":" if (lhSize != 1) /* only case supported for now : small litSize, single stream */"},{"Add":" return ERROR(corruption_detected);"},{"Add":" if (dctx->litEntropy==0)"},{"Add":" return ERROR(dictionary_corrupted);"},{"Add":""},{"Add":" /* 2 - 2 - 10 - 10 */"},{"Add":" lhSize=3;"},{"Add":" litSize = ((istart[0] & 15) << 6) + (istart[1] >> 2);"},{"Add":" litCSize = ((istart[1] & 3) << 8) + istart[2];"},{"Add":" if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);"},{"Add":""},{"Add":" { size_t const errorCode = HUFv07_decompress1X4_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->hufTable);"},{"Add":" if (HUFv07_isError(errorCode)) return ERROR(corruption_detected);"},{"Add":" }"},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);"},{"Add":" return litCSize + lhSize;"},{"Add":" }"},{"Add":" case lbt_raw:"},{"Add":" { size_t litSize;"},{"Add":" U32 lhSize = ((istart[0]) >> 4) & 3;"},{"Add":" switch(lhSize)"},{"Add":" {"},{"Add":" case 0: case 1: default: /* note : default is impossible, since lhSize into [0..3] */"},{"Add":" lhSize=1;"},{"Add":" litSize = istart[0] & 31;"},{"Add":" break;"},{"Add":" case 2:"},{"Add":" litSize = ((istart[0] & 15) << 8) + istart[1];"},{"Add":" break;"},{"Add":" case 3:"},{"Add":" litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2];"},{"Add":" break;"},{"Add":" }"},{"Add":""},{"Add":" if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) { /* risk reading beyond src buffer with wildcopy */"},{"Add":" if (litSize+lhSize > srcSize) return ERROR(corruption_detected);"},{"Add":" memcpy(dctx->litBuffer, istart+lhSize, litSize);"},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);"},{"Add":" return lhSize+litSize;"},{"Add":" }"},{"Add":" /* direct reference into compressed stream */"},{"Add":" dctx->litPtr = istart+lhSize;"},{"Add":" dctx->litSize = litSize;"},{"Add":" return lhSize+litSize;"},{"Add":" }"},{"Add":" case lbt_rle:"},{"Add":" { size_t litSize;"},{"Add":" U32 lhSize = ((istart[0]) >> 4) & 3;"},{"Add":" switch(lhSize)"},{"Add":" {"},{"Add":" case 0: case 1: default: /* note : default is impossible, since lhSize into [0..3] */"},{"Add":" lhSize = 1;"},{"Add":" litSize = istart[0] & 31;"},{"Add":" break;"},{"Add":" case 2:"},{"Add":" litSize = ((istart[0] & 15) << 8) + istart[1];"},{"Add":" break;"},{"Add":" case 3:"},{"Add":" litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2];"},{"Add":" if (srcSize<4) return ERROR(corruption_detected); /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4 */"},{"Add":" break;"},{"Add":" }"},{"Add":" if (litSize > ZSTDv07_BLOCKSIZE_ABSOLUTEMAX) return ERROR(corruption_detected);"},{"Add":" memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH);"},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" return lhSize+1;"},{"Add":" }"},{"Add":" default:"},{"Add":" return ERROR(corruption_detected); /* impossible */"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*! ZSTDv07_buildSeqTable() :"},{"Add":" @return : nb bytes read from src,"},{"Add":" or an error code if it fails, testable with ZSTDv07_isError()"},{"Add":"*/"},{"Add":"static size_t ZSTDv07_buildSeqTable(FSEv07_DTable* DTable, U32 type, U32 max, U32 maxLog,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const S16* defaultNorm, U32 defaultLog, U32 flagRepeatTable)"},{"Add":"{"},{"Add":" switch(type)"},{"Add":" {"},{"Add":" case FSEv07_ENCODING_RLE :"},{"Add":" if (!srcSize) return ERROR(srcSize_wrong);"},{"Add":" if ( (*(const BYTE*)src) > max) return ERROR(corruption_detected);"},{"Add":" FSEv07_buildDTable_rle(DTable, *(const BYTE*)src); /* if *src > max, data is corrupted */"},{"Add":" return 1;"},{"Add":" case FSEv07_ENCODING_RAW :"},{"Add":" FSEv07_buildDTable(DTable, defaultNorm, max, defaultLog);"},{"Add":" return 0;"},{"Add":" case FSEv07_ENCODING_STATIC:"},{"Add":" if (!flagRepeatTable) return ERROR(corruption_detected);"},{"Add":" return 0;"},{"Add":" default : /* impossible */"},{"Add":" case FSEv07_ENCODING_DYNAMIC :"},{"Add":" { U32 tableLog;"},{"Add":" S16 norm[MaxSeq+1];"},{"Add":" size_t const headerSize = FSEv07_readNCount(norm, &max, &tableLog, src, srcSize);"},{"Add":" if (FSEv07_isError(headerSize)) return ERROR(corruption_detected);"},{"Add":" if (tableLog > maxLog) return ERROR(corruption_detected);"},{"Add":" FSEv07_buildDTable(DTable, norm, max, tableLog);"},{"Add":" return headerSize;"},{"Add":" } }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTDv07_decodeSeqHeaders(int* nbSeqPtr,"},{"Add":" FSEv07_DTable* DTableLL, FSEv07_DTable* DTableML, FSEv07_DTable* DTableOffb, U32 flagRepeatTable,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE*)src;"},{"Add":" const BYTE* const iend = istart + srcSize;"},{"Add":" const BYTE* ip = istart;"},{"Add":""},{"Add":" /* check */"},{"Add":" if (srcSize < MIN_SEQUENCES_SIZE) return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" /* SeqHead */"},{"Add":" { int nbSeq = *ip++;"},{"Add":" if (!nbSeq) { *nbSeqPtr=0; return 1; }"},{"Add":" if (nbSeq > 0x7F) {"},{"Add":" if (nbSeq == 0xFF) {"},{"Add":" if (ip+2 > iend) return ERROR(srcSize_wrong);"},{"Add":" nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2;"},{"Add":" } else {"},{"Add":" if (ip >= iend) return ERROR(srcSize_wrong);"},{"Add":" nbSeq = ((nbSeq-0x80)<<8) + *ip++;"},{"Add":" }"},{"Add":" }"},{"Add":" *nbSeqPtr = nbSeq;"},{"Add":" }"},{"Add":""},{"Add":" /* FSE table descriptors */"},{"Add":" if (ip + 4 > iend) return ERROR(srcSize_wrong); /* min : header byte + all 3 are \"raw\", hence no header, but at least xxLog bits per type */"},{"Add":" { U32 const LLtype = *ip >> 6;"},{"Add":" U32 const OFtype = (*ip >> 4) & 3;"},{"Add":" U32 const MLtype = (*ip >> 2) & 3;"},{"Add":" ip++;"},{"Add":""},{"Add":" /* Build DTables */"},{"Add":" { size_t const llhSize = ZSTDv07_buildSeqTable(DTableLL, LLtype, MaxLL, LLFSELog, ip, iend-ip, LL_defaultNorm, LL_defaultNormLog, flagRepeatTable);"},{"Add":" if (ZSTDv07_isError(llhSize)) return ERROR(corruption_detected);"},{"Add":" ip += llhSize;"},{"Add":" }"},{"Add":" { size_t const ofhSize = ZSTDv07_buildSeqTable(DTableOffb, OFtype, MaxOff, OffFSELog, ip, iend-ip, OF_defaultNorm, OF_defaultNormLog, flagRepeatTable);"},{"Add":" if (ZSTDv07_isError(ofhSize)) return ERROR(corruption_detected);"},{"Add":" ip += ofhSize;"},{"Add":" }"},{"Add":" { size_t const mlhSize = ZSTDv07_buildSeqTable(DTableML, MLtype, MaxML, MLFSELog, ip, iend-ip, ML_defaultNorm, ML_defaultNormLog, flagRepeatTable);"},{"Add":" if (ZSTDv07_isError(mlhSize)) return ERROR(corruption_detected);"},{"Add":" ip += mlhSize;"},{"Add":" } }"},{"Add":""},{"Add":" return ip-istart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"typedef struct {"},{"Add":" size_t litLength;"},{"Add":" size_t matchLength;"},{"Add":" size_t offset;"},{"Add":"} seq_t;"},{"Add":""},{"Add":"typedef struct {"},{"Add":" BITv07_DStream_t DStream;"},{"Add":" FSEv07_DState_t stateLL;"},{"Add":" FSEv07_DState_t stateOffb;"},{"Add":" FSEv07_DState_t stateML;"},{"Add":" size_t prevOffset[ZSTDv07_REP_INIT];"},{"Add":"} seqState_t;"},{"Add":""},{"Add":""},{"Add":"static seq_t ZSTDv07_decodeSequence(seqState_t* seqState)"},{"Add":"{"},{"Add":" seq_t seq;"},{"Add":""},{"Add":" U32 const llCode = FSEv07_peekSymbol(&(seqState->stateLL));"},{"Add":" U32 const mlCode = FSEv07_peekSymbol(&(seqState->stateML));"},{"Add":" U32 const ofCode = FSEv07_peekSymbol(&(seqState->stateOffb)); /* <= maxOff, by table construction */"},{"Add":""},{"Add":" U32 const llBits = LL_bits[llCode];"},{"Add":" U32 const mlBits = ML_bits[mlCode];"},{"Add":" U32 const ofBits = ofCode;"},{"Add":" U32 const totalBits = llBits+mlBits+ofBits;"},{"Add":""},{"Add":" static const U32 LL_base[MaxLL+1] = {"},{"Add":" 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,"},{"Add":" 16, 18, 20, 22, 24, 28, 32, 40, 48, 64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000,"},{"Add":" 0x2000, 0x4000, 0x8000, 0x10000 };"},{"Add":""},{"Add":" static const U32 ML_base[MaxML+1] = {"},{"Add":" 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,"},{"Add":" 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,"},{"Add":" 35, 37, 39, 41, 43, 47, 51, 59, 67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803,"},{"Add":" 0x1003, 0x2003, 0x4003, 0x8003, 0x10003 };"},{"Add":""},{"Add":" static const U32 OF_base[MaxOff+1] = {"},{"Add":" 0, 1, 1, 5, 0xD, 0x1D, 0x3D, 0x7D,"},{"Add":" 0xFD, 0x1FD, 0x3FD, 0x7FD, 0xFFD, 0x1FFD, 0x3FFD, 0x7FFD,"},{"Add":" 0xFFFD, 0x1FFFD, 0x3FFFD, 0x7FFFD, 0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD,"},{"Add":" 0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD };"},{"Add":""},{"Add":" /* sequence */"},{"Add":" { size_t offset;"},{"Add":" if (!ofCode)"},{"Add":" offset = 0;"},{"Add":" else {"},{"Add":" offset = OF_base[ofCode] + BITv07_readBits(&(seqState->DStream), ofBits); /* <= (ZSTDv07_WINDOWLOG_MAX-1) bits */"},{"Add":" if (MEM_32bits()) BITv07_reloadDStream(&(seqState->DStream));"},{"Add":" }"},{"Add":""},{"Add":" if (ofCode <= 1) {"},{"Add":" if ((llCode == 0) & (offset <= 1)) offset = 1-offset;"},{"Add":" if (offset) {"},{"Add":" size_t const temp = seqState->prevOffset[offset];"},{"Add":" if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];"},{"Add":" seqState->prevOffset[1] = seqState->prevOffset[0];"},{"Add":" seqState->prevOffset[0] = offset = temp;"},{"Add":" } else {"},{"Add":" offset = seqState->prevOffset[0];"},{"Add":" }"},{"Add":" } else {"},{"Add":" seqState->prevOffset[2] = seqState->prevOffset[1];"},{"Add":" seqState->prevOffset[1] = seqState->prevOffset[0];"},{"Add":" seqState->prevOffset[0] = offset;"},{"Add":" }"},{"Add":" seq.offset = offset;"},{"Add":" }"},{"Add":""},{"Add":" seq.matchLength = ML_base[mlCode] + ((mlCode>31) ? BITv07_readBits(&(seqState->DStream), mlBits) : 0); /* <= 16 bits */"},{"Add":" if (MEM_32bits() && (mlBits+llBits>24)) BITv07_reloadDStream(&(seqState->DStream));"},{"Add":""},{"Add":" seq.litLength = LL_base[llCode] + ((llCode>15) ? BITv07_readBits(&(seqState->DStream), llBits) : 0); /* <= 16 bits */"},{"Add":" if (MEM_32bits() ||"},{"Add":" (totalBits > 64 - 7 - (LLFSELog+MLFSELog+OffFSELog)) ) BITv07_reloadDStream(&(seqState->DStream));"},{"Add":""},{"Add":" /* ANS state update */"},{"Add":" FSEv07_updateState(&(seqState->stateLL), &(seqState->DStream)); /* <= 9 bits */"},{"Add":" FSEv07_updateState(&(seqState->stateML), &(seqState->DStream)); /* <= 9 bits */"},{"Add":" if (MEM_32bits()) BITv07_reloadDStream(&(seqState->DStream)); /* <= 18 bits */"},{"Add":" FSEv07_updateState(&(seqState->stateOffb), &(seqState->DStream)); /* <= 8 bits */"},{"Add":""},{"Add":" return seq;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static"},{"Add":"size_t ZSTDv07_execSequence(BYTE* op,"},{"Add":" BYTE* const oend, seq_t sequence,"},{"Add":" const BYTE** litPtr, const BYTE* const litLimit,"},{"Add":" const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)"},{"Add":"{"},{"Add":" BYTE* const oLitEnd = op + sequence.litLength;"},{"Add":" size_t const sequenceLength = sequence.litLength + sequence.matchLength;"},{"Add":" BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */"},{"Add":" BYTE* const oend_w = oend-WILDCOPY_OVERLENGTH;"},{"Add":" const BYTE* const iLitEnd = *litPtr + sequence.litLength;"},{"Add":" const BYTE* match = oLitEnd - sequence.offset;"},{"Add":""},{"Add":" /* check */"},{"Add":" if ((oLitEnd>oend_w) | (oMatchEnd>oend)) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */"},{"Add":" if (iLitEnd > litLimit) return ERROR(corruption_detected); /* over-read beyond lit buffer */"},{"Add":""},{"Add":" /* copy Literals */"},{"Add":" ZSTDv07_wildcopy(op, *litPtr, sequence.litLength); /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, no risk of overwrite beyond oend */"},{"Add":" op = oLitEnd;"},{"Add":" *litPtr = iLitEnd; /* update for next sequence */"},{"Add":""},{"Add":" /* copy Match */"},{"Add":" if (sequence.offset > (size_t)(oLitEnd - base)) {"},{"Add":" /* offset beyond prefix */"},{"Add":" if (sequence.offset > (size_t)(oLitEnd - vBase)) return ERROR(corruption_detected);"},{"Add":" match = dictEnd - (base-match);"},{"Add":" if (match + sequence.matchLength <= dictEnd) {"},{"Add":" memmove(oLitEnd, match, sequence.matchLength);"},{"Add":" return sequenceLength;"},{"Add":" }"},{"Add":" /* span extDict & currentPrefixSegment */"},{"Add":" { size_t const length1 = dictEnd - match;"},{"Add":" memmove(oLitEnd, match, length1);"},{"Add":" op = oLitEnd + length1;"},{"Add":" sequence.matchLength -= length1;"},{"Add":" match = base;"},{"Add":" if (op > oend_w || sequence.matchLength < MINMATCH) {"},{"Add":" while (op < oMatchEnd) *op++ = *match++;"},{"Add":" return sequenceLength;"},{"Add":" }"},{"Add":" } }"},{"Add":" /* Requirement: op <= oend_w */"},{"Add":""},{"Add":" /* match within prefix */"},{"Add":" if (sequence.offset < 8) {"},{"Add":" /* close range match, overlap */"},{"Add":" static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 }; /* added */"},{"Add":" static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 }; /* subtracted */"},{"Add":" int const sub2 = dec64table[sequence.offset];"},{"Add":" op[0] = match[0];"},{"Add":" op[1] = match[1];"},{"Add":" op[2] = match[2];"},{"Add":" op[3] = match[3];"},{"Add":" match += dec32table[sequence.offset];"},{"Add":" ZSTDv07_copy4(op+4, match);"},{"Add":" match -= sub2;"},{"Add":" } else {"},{"Add":" ZSTDv07_copy8(op, match);"},{"Add":" }"},{"Add":" op += 8; match += 8;"},{"Add":""},{"Add":" if (oMatchEnd > oend-(16-MINMATCH)) {"},{"Add":" if (op < oend_w) {"},{"Add":" ZSTDv07_wildcopy(op, match, oend_w - op);"},{"Add":" match += oend_w - op;"},{"Add":" op = oend_w;"},{"Add":" }"},{"Add":" while (op < oMatchEnd) *op++ = *match++;"},{"Add":" } else {"},{"Add":" ZSTDv07_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8); /* works even if matchLength < 8 */"},{"Add":" }"},{"Add":" return sequenceLength;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTDv07_decompressSequences("},{"Add":" ZSTDv07_DCtx* dctx,"},{"Add":" void* dst, size_t maxDstSize,"},{"Add":" const void* seqStart, size_t seqSize)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)seqStart;"},{"Add":" const BYTE* const iend = ip + seqSize;"},{"Add":" BYTE* const ostart = (BYTE*)dst;"},{"Add":" BYTE* const oend = ostart + maxDstSize;"},{"Add":" BYTE* op = ostart;"},{"Add":" const BYTE* litPtr = dctx->litPtr;"},{"Add":" const BYTE* const litEnd = litPtr + dctx->litSize;"},{"Add":" FSEv07_DTable* DTableLL = dctx->LLTable;"},{"Add":" FSEv07_DTable* DTableML = dctx->MLTable;"},{"Add":" FSEv07_DTable* DTableOffb = dctx->OffTable;"},{"Add":" const BYTE* const base = (const BYTE*) (dctx->base);"},{"Add":" const BYTE* const vBase = (const BYTE*) (dctx->vBase);"},{"Add":" const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);"},{"Add":" int nbSeq;"},{"Add":""},{"Add":" /* Build Decoding Tables */"},{"Add":" { size_t const seqHSize = ZSTDv07_decodeSeqHeaders(&nbSeq, DTableLL, DTableML, DTableOffb, dctx->fseEntropy, ip, seqSize);"},{"Add":" if (ZSTDv07_isError(seqHSize)) return seqHSize;"},{"Add":" ip += seqHSize;"},{"Add":" }"},{"Add":""},{"Add":" /* Regen sequences */"},{"Add":" if (nbSeq) {"},{"Add":" seqState_t seqState;"},{"Add":" dctx->fseEntropy = 1;"},{"Add":" { U32 i; for (i=0; irep[i]; }"},{"Add":" { size_t const errorCode = BITv07_initDStream(&(seqState.DStream), ip, iend-ip);"},{"Add":" if (ERR_isError(errorCode)) return ERROR(corruption_detected); }"},{"Add":" FSEv07_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);"},{"Add":" FSEv07_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);"},{"Add":" FSEv07_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);"},{"Add":""},{"Add":" for ( ; (BITv07_reloadDStream(&(seqState.DStream)) <= BITv07_DStream_completed) && nbSeq ; ) {"},{"Add":" nbSeq--;"},{"Add":" { seq_t const sequence = ZSTDv07_decodeSequence(&seqState);"},{"Add":" size_t const oneSeqSize = ZSTDv07_execSequence(op, oend, sequence, &litPtr, litEnd, base, vBase, dictEnd);"},{"Add":" if (ZSTDv07_isError(oneSeqSize)) return oneSeqSize;"},{"Add":" op += oneSeqSize;"},{"Add":" } }"},{"Add":""},{"Add":" /* check if reached exact end */"},{"Add":" if (nbSeq) return ERROR(corruption_detected);"},{"Add":" /* save reps for next block */"},{"Add":" { U32 i; for (i=0; irep[i] = (U32)(seqState.prevOffset[i]); }"},{"Add":" }"},{"Add":""},{"Add":" /* last literal segment */"},{"Add":" { size_t const lastLLSize = litEnd - litPtr;"},{"Add":" /* if (litPtr > litEnd) return ERROR(corruption_detected); */ /* too many literals already used */"},{"Add":" if (lastLLSize > (size_t)(oend-op)) return ERROR(dstSize_tooSmall);"},{"Add":" if (lastLLSize > 0) {"},{"Add":" memcpy(op, litPtr, lastLLSize);"},{"Add":" op += lastLLSize;"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" return op-ostart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static void ZSTDv07_checkContinuity(ZSTDv07_DCtx* dctx, const void* dst)"},{"Add":"{"},{"Add":" if (dst != dctx->previousDstEnd) { /* not contiguous */"},{"Add":" dctx->dictEnd = dctx->previousDstEnd;"},{"Add":" dctx->vBase = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));"},{"Add":" dctx->base = dst;"},{"Add":" dctx->previousDstEnd = dst;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTDv07_decompressBlock_internal(ZSTDv07_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{ /* blockType == blockCompressed */"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":""},{"Add":" if (srcSize >= ZSTDv07_BLOCKSIZE_ABSOLUTEMAX) return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" /* Decode literals sub-block */"},{"Add":" { size_t const litCSize = ZSTDv07_decodeLiteralsBlock(dctx, src, srcSize);"},{"Add":" if (ZSTDv07_isError(litCSize)) return litCSize;"},{"Add":" ip += litCSize;"},{"Add":" srcSize -= litCSize;"},{"Add":" }"},{"Add":" return ZSTDv07_decompressSequences(dctx, dst, dstCapacity, ip, srcSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t ZSTDv07_decompressBlock(ZSTDv07_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" size_t dSize;"},{"Add":" ZSTDv07_checkContinuity(dctx, dst);"},{"Add":" dSize = ZSTDv07_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);"},{"Add":" dctx->previousDstEnd = (char*)dst + dSize;"},{"Add":" return dSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/** ZSTDv07_insertBlock() :"},{"Add":" insert `src` block into `dctx` history. Useful to track uncompressed blocks. */"},{"Add":"ZSTDLIBv07_API size_t ZSTDv07_insertBlock(ZSTDv07_DCtx* dctx, const void* blockStart, size_t blockSize)"},{"Add":"{"},{"Add":" ZSTDv07_checkContinuity(dctx, blockStart);"},{"Add":" dctx->previousDstEnd = (const char*)blockStart + blockSize;"},{"Add":" return blockSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTDv07_generateNxBytes(void* dst, size_t dstCapacity, BYTE byte, size_t length)"},{"Add":"{"},{"Add":" if (length > dstCapacity) return ERROR(dstSize_tooSmall);"},{"Add":" if (length > 0) {"},{"Add":" memset(dst, byte, length);"},{"Add":" }"},{"Add":" return length;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*! ZSTDv07_decompressFrame() :"},{"Add":"* `dctx` must be properly initialized */"},{"Add":"static size_t ZSTDv07_decompressFrame(ZSTDv07_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":" const BYTE* const iend = ip + srcSize;"},{"Add":" BYTE* const ostart = (BYTE*)dst;"},{"Add":" BYTE* const oend = ostart + dstCapacity;"},{"Add":" BYTE* op = ostart;"},{"Add":" size_t remainingSize = srcSize;"},{"Add":""},{"Add":" /* check */"},{"Add":" if (srcSize < ZSTDv07_frameHeaderSize_min+ZSTDv07_blockHeaderSize) return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" /* Frame Header */"},{"Add":" { size_t const frameHeaderSize = ZSTDv07_frameHeaderSize(src, ZSTDv07_frameHeaderSize_min);"},{"Add":" if (ZSTDv07_isError(frameHeaderSize)) return frameHeaderSize;"},{"Add":" if (srcSize < frameHeaderSize+ZSTDv07_blockHeaderSize) return ERROR(srcSize_wrong);"},{"Add":" if (ZSTDv07_decodeFrameHeader(dctx, src, frameHeaderSize)) return ERROR(corruption_detected);"},{"Add":" ip += frameHeaderSize; remainingSize -= frameHeaderSize;"},{"Add":" }"},{"Add":""},{"Add":" /* Loop on each block */"},{"Add":" while (1) {"},{"Add":" size_t decodedSize;"},{"Add":" blockProperties_t blockProperties;"},{"Add":" size_t const cBlockSize = ZSTDv07_getcBlockSize(ip, iend-ip, &blockProperties);"},{"Add":" if (ZSTDv07_isError(cBlockSize)) return cBlockSize;"},{"Add":""},{"Add":" ip += ZSTDv07_blockHeaderSize;"},{"Add":" remainingSize -= ZSTDv07_blockHeaderSize;"},{"Add":" if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" switch(blockProperties.blockType)"},{"Add":" {"},{"Add":" case bt_compressed:"},{"Add":" decodedSize = ZSTDv07_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize);"},{"Add":" break;"},{"Add":" case bt_raw :"},{"Add":" decodedSize = ZSTDv07_copyRawBlock(op, oend-op, ip, cBlockSize);"},{"Add":" break;"},{"Add":" case bt_rle :"},{"Add":" decodedSize = ZSTDv07_generateNxBytes(op, oend-op, *ip, blockProperties.origSize);"},{"Add":" break;"},{"Add":" case bt_end :"},{"Add":" /* end of frame */"},{"Add":" if (remainingSize) return ERROR(srcSize_wrong);"},{"Add":" decodedSize = 0;"},{"Add":" break;"},{"Add":" default:"},{"Add":" return ERROR(GENERIC); /* impossible */"},{"Add":" }"},{"Add":" if (blockProperties.blockType == bt_end) break; /* bt_end */"},{"Add":""},{"Add":" if (ZSTDv07_isError(decodedSize)) return decodedSize;"},{"Add":" if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, op, decodedSize);"},{"Add":" op += decodedSize;"},{"Add":" ip += cBlockSize;"},{"Add":" remainingSize -= cBlockSize;"},{"Add":" }"},{"Add":""},{"Add":" return op-ostart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*! ZSTDv07_decompress_usingPreparedDCtx() :"},{"Add":"* Same as ZSTDv07_decompress_usingDict, but using a reference context `preparedDCtx`, where dictionary has been loaded."},{"Add":"* It avoids reloading the dictionary each time."},{"Add":"* `preparedDCtx` must have been properly initialized using ZSTDv07_decompressBegin_usingDict()."},{"Add":"* Requires 2 contexts : 1 for reference (preparedDCtx), which will not be modified, and 1 to run the decompression operation (dctx) */"},{"Add":"static size_t ZSTDv07_decompress_usingPreparedDCtx(ZSTDv07_DCtx* dctx, const ZSTDv07_DCtx* refDCtx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" ZSTDv07_copyDCtx(dctx, refDCtx);"},{"Add":" ZSTDv07_checkContinuity(dctx, dst);"},{"Add":" return ZSTDv07_decompressFrame(dctx, dst, dstCapacity, src, srcSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t ZSTDv07_decompress_usingDict(ZSTDv07_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" ZSTDv07_decompressBegin_usingDict(dctx, dict, dictSize);"},{"Add":" ZSTDv07_checkContinuity(dctx, dst);"},{"Add":" return ZSTDv07_decompressFrame(dctx, dst, dstCapacity, src, srcSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t ZSTDv07_decompressDCtx(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" return ZSTDv07_decompress_usingDict(dctx, dst, dstCapacity, src, srcSize, NULL, 0);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t ZSTDv07_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":"#if defined(ZSTDv07_HEAPMODE) && (ZSTDv07_HEAPMODE==1)"},{"Add":" size_t regenSize;"},{"Add":" ZSTDv07_DCtx* const dctx = ZSTDv07_createDCtx();"},{"Add":" if (dctx==NULL) return ERROR(memory_allocation);"},{"Add":" regenSize = ZSTDv07_decompressDCtx(dctx, dst, dstCapacity, src, srcSize);"},{"Add":" ZSTDv07_freeDCtx(dctx);"},{"Add":" return regenSize;"},{"Add":"#else /* stack mode */"},{"Add":" ZSTDv07_DCtx dctx;"},{"Add":" return ZSTDv07_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);"},{"Add":"#endif"},{"Add":"}"},{"Add":""},{"Add":"/* ZSTD_errorFrameSizeInfoLegacy() :"},{"Add":" assumes `cSize` and `dBound` are _not_ NULL */"},{"Add":"static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)"},{"Add":"{"},{"Add":" *cSize = ret;"},{"Add":" *dBound = ZSTD_CONTENTSIZE_ERROR;"},{"Add":"}"},{"Add":""},{"Add":"void ZSTDv07_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cSize, unsigned long long* dBound)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":" size_t remainingSize = srcSize;"},{"Add":" size_t nbBlocks = 0;"},{"Add":""},{"Add":" /* check */"},{"Add":" if (srcSize < ZSTDv07_frameHeaderSize_min+ZSTDv07_blockHeaderSize) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));"},{"Add":" return;"},{"Add":" }"},{"Add":""},{"Add":" /* Frame Header */"},{"Add":" { size_t const frameHeaderSize = ZSTDv07_frameHeaderSize(src, srcSize);"},{"Add":" if (ZSTDv07_isError(frameHeaderSize)) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, frameHeaderSize);"},{"Add":" return;"},{"Add":" }"},{"Add":" if (MEM_readLE32(src) != ZSTDv07_MAGICNUMBER) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(prefix_unknown));"},{"Add":" return;"},{"Add":" }"},{"Add":" if (srcSize < frameHeaderSize+ZSTDv07_blockHeaderSize) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));"},{"Add":" return;"},{"Add":" }"},{"Add":" ip += frameHeaderSize; remainingSize -= frameHeaderSize;"},{"Add":" }"},{"Add":""},{"Add":" /* Loop on each block */"},{"Add":" while (1) {"},{"Add":" blockProperties_t blockProperties;"},{"Add":" size_t const cBlockSize = ZSTDv07_getcBlockSize(ip, remainingSize, &blockProperties);"},{"Add":" if (ZSTDv07_isError(cBlockSize)) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, cBlockSize);"},{"Add":" return;"},{"Add":" }"},{"Add":""},{"Add":" ip += ZSTDv07_blockHeaderSize;"},{"Add":" remainingSize -= ZSTDv07_blockHeaderSize;"},{"Add":""},{"Add":" if (blockProperties.blockType == bt_end) break;"},{"Add":""},{"Add":" if (cBlockSize > remainingSize) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));"},{"Add":" return;"},{"Add":" }"},{"Add":""},{"Add":" ip += cBlockSize;"},{"Add":" remainingSize -= cBlockSize;"},{"Add":" nbBlocks++;"},{"Add":" }"},{"Add":""},{"Add":" *cSize = ip - (const BYTE*)src;"},{"Add":" *dBound = nbBlocks * ZSTDv07_BLOCKSIZE_ABSOLUTEMAX;"},{"Add":"}"},{"Add":""},{"Add":"/*_******************************"},{"Add":"* Streaming Decompression API"},{"Add":"********************************/"},{"Add":"size_t ZSTDv07_nextSrcSizeToDecompress(ZSTDv07_DCtx* dctx)"},{"Add":"{"},{"Add":" return dctx->expected;"},{"Add":"}"},{"Add":""},{"Add":"int ZSTDv07_isSkipFrame(ZSTDv07_DCtx* dctx)"},{"Add":"{"},{"Add":" return dctx->stage == ZSTDds_skipFrame;"},{"Add":"}"},{"Add":""},{"Add":"/** ZSTDv07_decompressContinue() :"},{"Add":"* @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity)"},{"Add":"* or an error code, which can be tested using ZSTDv07_isError() */"},{"Add":"size_t ZSTDv07_decompressContinue(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" /* Sanity check */"},{"Add":" if (srcSize != dctx->expected) return ERROR(srcSize_wrong);"},{"Add":" if (dstCapacity) ZSTDv07_checkContinuity(dctx, dst);"},{"Add":""},{"Add":" switch (dctx->stage)"},{"Add":" {"},{"Add":" case ZSTDds_getFrameHeaderSize :"},{"Add":" if (srcSize != ZSTDv07_frameHeaderSize_min) return ERROR(srcSize_wrong); /* impossible */"},{"Add":" if ((MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTDv07_MAGIC_SKIPPABLE_START) {"},{"Add":" memcpy(dctx->headerBuffer, src, ZSTDv07_frameHeaderSize_min);"},{"Add":" dctx->expected = ZSTDv07_skippableHeaderSize - ZSTDv07_frameHeaderSize_min; /* magic number + skippable frame length */"},{"Add":" dctx->stage = ZSTDds_decodeSkippableHeader;"},{"Add":" return 0;"},{"Add":" }"},{"Add":" dctx->headerSize = ZSTDv07_frameHeaderSize(src, ZSTDv07_frameHeaderSize_min);"},{"Add":" if (ZSTDv07_isError(dctx->headerSize)) return dctx->headerSize;"},{"Add":" memcpy(dctx->headerBuffer, src, ZSTDv07_frameHeaderSize_min);"},{"Add":" if (dctx->headerSize > ZSTDv07_frameHeaderSize_min) {"},{"Add":" dctx->expected = dctx->headerSize - ZSTDv07_frameHeaderSize_min;"},{"Add":" dctx->stage = ZSTDds_decodeFrameHeader;"},{"Add":" return 0;"},{"Add":" }"},{"Add":" dctx->expected = 0; /* not necessary to copy more */"},{"Add":"\t/* fall-through */"},{"Add":" case ZSTDds_decodeFrameHeader:"},{"Add":" { size_t result;"},{"Add":" memcpy(dctx->headerBuffer + ZSTDv07_frameHeaderSize_min, src, dctx->expected);"},{"Add":" result = ZSTDv07_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize);"},{"Add":" if (ZSTDv07_isError(result)) return result;"},{"Add":" dctx->expected = ZSTDv07_blockHeaderSize;"},{"Add":" dctx->stage = ZSTDds_decodeBlockHeader;"},{"Add":" return 0;"},{"Add":" }"},{"Add":" case ZSTDds_decodeBlockHeader:"},{"Add":" { blockProperties_t bp;"},{"Add":" size_t const cBlockSize = ZSTDv07_getcBlockSize(src, ZSTDv07_blockHeaderSize, &bp);"},{"Add":" if (ZSTDv07_isError(cBlockSize)) return cBlockSize;"},{"Add":" if (bp.blockType == bt_end) {"},{"Add":" if (dctx->fParams.checksumFlag) {"},{"Add":" U64 const h64 = XXH64_digest(&dctx->xxhState);"},{"Add":" U32 const h32 = (U32)(h64>>11) & ((1<<22)-1);"},{"Add":" const BYTE* const ip = (const BYTE*)src;"},{"Add":" U32 const check32 = ip[2] + (ip[1] << 8) + ((ip[0] & 0x3F) << 16);"},{"Add":" if (check32 != h32) return ERROR(checksum_wrong);"},{"Add":" }"},{"Add":" dctx->expected = 0;"},{"Add":" dctx->stage = ZSTDds_getFrameHeaderSize;"},{"Add":" } else {"},{"Add":" dctx->expected = cBlockSize;"},{"Add":" dctx->bType = bp.blockType;"},{"Add":" dctx->stage = ZSTDds_decompressBlock;"},{"Add":" }"},{"Add":" return 0;"},{"Add":" }"},{"Add":" case ZSTDds_decompressBlock:"},{"Add":" { size_t rSize;"},{"Add":" switch(dctx->bType)"},{"Add":" {"},{"Add":" case bt_compressed:"},{"Add":" rSize = ZSTDv07_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);"},{"Add":" break;"},{"Add":" case bt_raw :"},{"Add":" rSize = ZSTDv07_copyRawBlock(dst, dstCapacity, src, srcSize);"},{"Add":" break;"},{"Add":" case bt_rle :"},{"Add":" return ERROR(GENERIC); /* not yet handled */"},{"Add":" break;"},{"Add":" case bt_end : /* should never happen (filtered at phase 1) */"},{"Add":" rSize = 0;"},{"Add":" break;"},{"Add":" default:"},{"Add":" return ERROR(GENERIC); /* impossible */"},{"Add":" }"},{"Add":" dctx->stage = ZSTDds_decodeBlockHeader;"},{"Add":" dctx->expected = ZSTDv07_blockHeaderSize;"},{"Add":" dctx->previousDstEnd = (char*)dst + rSize;"},{"Add":" if (ZSTDv07_isError(rSize)) return rSize;"},{"Add":" if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, dst, rSize);"},{"Add":" return rSize;"},{"Add":" }"},{"Add":" case ZSTDds_decodeSkippableHeader:"},{"Add":" { memcpy(dctx->headerBuffer + ZSTDv07_frameHeaderSize_min, src, dctx->expected);"},{"Add":" dctx->expected = MEM_readLE32(dctx->headerBuffer + 4);"},{"Add":" dctx->stage = ZSTDds_skipFrame;"},{"Add":" return 0;"},{"Add":" }"},{"Add":" case ZSTDds_skipFrame:"},{"Add":" { dctx->expected = 0;"},{"Add":" dctx->stage = ZSTDds_getFrameHeaderSize;"},{"Add":" return 0;"},{"Add":" }"},{"Add":" default:"},{"Add":" return ERROR(GENERIC); /* impossible */"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTDv07_refDictContent(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" dctx->dictEnd = dctx->previousDstEnd;"},{"Add":" dctx->vBase = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));"},{"Add":" dctx->base = dict;"},{"Add":" dctx->previousDstEnd = (const char*)dict + dictSize;"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZSTDv07_loadEntropy(ZSTDv07_DCtx* dctx, const void* const dict, size_t const dictSize)"},{"Add":"{"},{"Add":" const BYTE* dictPtr = (const BYTE*)dict;"},{"Add":" const BYTE* const dictEnd = dictPtr + dictSize;"},{"Add":""},{"Add":" { size_t const hSize = HUFv07_readDTableX4(dctx->hufTable, dict, dictSize);"},{"Add":" if (HUFv07_isError(hSize)) return ERROR(dictionary_corrupted);"},{"Add":" dictPtr += hSize;"},{"Add":" }"},{"Add":""},{"Add":" { short offcodeNCount[MaxOff+1];"},{"Add":" U32 offcodeMaxValue=MaxOff, offcodeLog;"},{"Add":" size_t const offcodeHeaderSize = FSEv07_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr);"},{"Add":" if (FSEv07_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted);"},{"Add":" if (offcodeLog > OffFSELog) return ERROR(dictionary_corrupted);"},{"Add":" { size_t const errorCode = FSEv07_buildDTable(dctx->OffTable, offcodeNCount, offcodeMaxValue, offcodeLog);"},{"Add":" if (FSEv07_isError(errorCode)) return ERROR(dictionary_corrupted); }"},{"Add":" dictPtr += offcodeHeaderSize;"},{"Add":" }"},{"Add":""},{"Add":" { short matchlengthNCount[MaxML+1];"},{"Add":" unsigned matchlengthMaxValue = MaxML, matchlengthLog;"},{"Add":" size_t const matchlengthHeaderSize = FSEv07_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr);"},{"Add":" if (FSEv07_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted);"},{"Add":" if (matchlengthLog > MLFSELog) return ERROR(dictionary_corrupted);"},{"Add":" { size_t const errorCode = FSEv07_buildDTable(dctx->MLTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog);"},{"Add":" if (FSEv07_isError(errorCode)) return ERROR(dictionary_corrupted); }"},{"Add":" dictPtr += matchlengthHeaderSize;"},{"Add":" }"},{"Add":""},{"Add":" { short litlengthNCount[MaxLL+1];"},{"Add":" unsigned litlengthMaxValue = MaxLL, litlengthLog;"},{"Add":" size_t const litlengthHeaderSize = FSEv07_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr);"},{"Add":" if (FSEv07_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted);"},{"Add":" if (litlengthLog > LLFSELog) return ERROR(dictionary_corrupted);"},{"Add":" { size_t const errorCode = FSEv07_buildDTable(dctx->LLTable, litlengthNCount, litlengthMaxValue, litlengthLog);"},{"Add":" if (FSEv07_isError(errorCode)) return ERROR(dictionary_corrupted); }"},{"Add":" dictPtr += litlengthHeaderSize;"},{"Add":" }"},{"Add":""},{"Add":" if (dictPtr+12 > dictEnd) return ERROR(dictionary_corrupted);"},{"Add":" dctx->rep[0] = MEM_readLE32(dictPtr+0); if (dctx->rep[0] == 0 || dctx->rep[0] >= dictSize) return ERROR(dictionary_corrupted);"},{"Add":" dctx->rep[1] = MEM_readLE32(dictPtr+4); if (dctx->rep[1] == 0 || dctx->rep[1] >= dictSize) return ERROR(dictionary_corrupted);"},{"Add":" dctx->rep[2] = MEM_readLE32(dictPtr+8); if (dctx->rep[2] == 0 || dctx->rep[2] >= dictSize) return ERROR(dictionary_corrupted);"},{"Add":" dictPtr += 12;"},{"Add":""},{"Add":" dctx->litEntropy = dctx->fseEntropy = 1;"},{"Add":" return dictPtr - (const BYTE*)dict;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZSTDv07_decompress_insertDictionary(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" if (dictSize < 8) return ZSTDv07_refDictContent(dctx, dict, dictSize);"},{"Add":" { U32 const magic = MEM_readLE32(dict);"},{"Add":" if (magic != ZSTDv07_DICT_MAGIC) {"},{"Add":" return ZSTDv07_refDictContent(dctx, dict, dictSize); /* pure content mode */"},{"Add":" } }"},{"Add":" dctx->dictID = MEM_readLE32((const char*)dict + 4);"},{"Add":""},{"Add":" /* load entropy tables */"},{"Add":" dict = (const char*)dict + 8;"},{"Add":" dictSize -= 8;"},{"Add":" { size_t const eSize = ZSTDv07_loadEntropy(dctx, dict, dictSize);"},{"Add":" if (ZSTDv07_isError(eSize)) return ERROR(dictionary_corrupted);"},{"Add":" dict = (const char*)dict + eSize;"},{"Add":" dictSize -= eSize;"},{"Add":" }"},{"Add":""},{"Add":" /* reference dictionary content */"},{"Add":" return ZSTDv07_refDictContent(dctx, dict, dictSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t ZSTDv07_decompressBegin_usingDict(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" { size_t const errorCode = ZSTDv07_decompressBegin(dctx);"},{"Add":" if (ZSTDv07_isError(errorCode)) return errorCode; }"},{"Add":""},{"Add":" if (dict && dictSize) {"},{"Add":" size_t const errorCode = ZSTDv07_decompress_insertDictionary(dctx, dict, dictSize);"},{"Add":" if (ZSTDv07_isError(errorCode)) return ERROR(dictionary_corrupted);"},{"Add":" }"},{"Add":""},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"struct ZSTDv07_DDict_s {"},{"Add":" void* dict;"},{"Add":" size_t dictSize;"},{"Add":" ZSTDv07_DCtx* refContext;"},{"Add":"}; /* typedef'd tp ZSTDv07_CDict within zstd.h */"},{"Add":""},{"Add":"static ZSTDv07_DDict* ZSTDv07_createDDict_advanced(const void* dict, size_t dictSize, ZSTDv07_customMem customMem)"},{"Add":"{"},{"Add":" if (!customMem.customAlloc && !customMem.customFree)"},{"Add":" customMem = defaultCustomMem;"},{"Add":""},{"Add":" if (!customMem.customAlloc || !customMem.customFree)"},{"Add":" return NULL;"},{"Add":""},{"Add":" { ZSTDv07_DDict* const ddict = (ZSTDv07_DDict*) customMem.customAlloc(customMem.opaque, sizeof(*ddict));"},{"Add":" void* const dictContent = customMem.customAlloc(customMem.opaque, dictSize);"},{"Add":" ZSTDv07_DCtx* const dctx = ZSTDv07_createDCtx_advanced(customMem);"},{"Add":""},{"Add":" if (!dictContent || !ddict || !dctx) {"},{"Add":" customMem.customFree(customMem.opaque, dictContent);"},{"Add":" customMem.customFree(customMem.opaque, ddict);"},{"Add":" customMem.customFree(customMem.opaque, dctx);"},{"Add":" return NULL;"},{"Add":" }"},{"Add":""},{"Add":" memcpy(dictContent, dict, dictSize);"},{"Add":" { size_t const errorCode = ZSTDv07_decompressBegin_usingDict(dctx, dictContent, dictSize);"},{"Add":" if (ZSTDv07_isError(errorCode)) {"},{"Add":" customMem.customFree(customMem.opaque, dictContent);"},{"Add":" customMem.customFree(customMem.opaque, ddict);"},{"Add":" customMem.customFree(customMem.opaque, dctx);"},{"Add":" return NULL;"},{"Add":" } }"},{"Add":""},{"Add":" ddict->dict = dictContent;"},{"Add":" ddict->dictSize = dictSize;"},{"Add":" ddict->refContext = dctx;"},{"Add":" return ddict;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"/*! ZSTDv07_createDDict() :"},{"Add":"* Create a digested dictionary, ready to start decompression without startup delay."},{"Add":"* `dict` can be released after `ZSTDv07_DDict` creation */"},{"Add":"ZSTDv07_DDict* ZSTDv07_createDDict(const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" ZSTDv07_customMem const allocator = { NULL, NULL, NULL };"},{"Add":" return ZSTDv07_createDDict_advanced(dict, dictSize, allocator);"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTDv07_freeDDict(ZSTDv07_DDict* ddict)"},{"Add":"{"},{"Add":" ZSTDv07_freeFunction const cFree = ddict->refContext->customMem.customFree;"},{"Add":" void* const opaque = ddict->refContext->customMem.opaque;"},{"Add":" ZSTDv07_freeDCtx(ddict->refContext);"},{"Add":" cFree(opaque, ddict->dict);"},{"Add":" cFree(opaque, ddict);"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"/*! ZSTDv07_decompress_usingDDict() :"},{"Add":"* Decompression using a pre-digested Dictionary"},{"Add":"* Use dictionary without significant overhead. */"},{"Add":"ZSTDLIBv07_API size_t ZSTDv07_decompress_usingDDict(ZSTDv07_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const ZSTDv07_DDict* ddict)"},{"Add":"{"},{"Add":" return ZSTDv07_decompress_usingPreparedDCtx(dctx, ddict->refContext,"},{"Add":" dst, dstCapacity,"},{"Add":" src, srcSize);"},{"Add":"}"},{"Add":"/*"},{"Add":" Buffered version of Zstd compression library"},{"Add":" Copyright (C) 2015-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - zstd homepage : http://www.zstd.net/"},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-***************************************************************************"},{"Add":"* Streaming decompression howto"},{"Add":"*"},{"Add":"* A ZBUFFv07_DCtx object is required to track streaming operations."},{"Add":"* Use ZBUFFv07_createDCtx() and ZBUFFv07_freeDCtx() to create/release resources."},{"Add":"* Use ZBUFFv07_decompressInit() to start a new decompression operation,"},{"Add":"* or ZBUFFv07_decompressInitDictionary() if decompression requires a dictionary."},{"Add":"* Note that ZBUFFv07_DCtx objects can be re-init multiple times."},{"Add":"*"},{"Add":"* Use ZBUFFv07_decompressContinue() repetitively to consume your input."},{"Add":"* *srcSizePtr and *dstCapacityPtr can be any size."},{"Add":"* The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr."},{"Add":"* Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again."},{"Add":"* The content of @dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change @dst."},{"Add":"* @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency),"},{"Add":"* or 0 when a frame is completely decoded,"},{"Add":"* or an error code, which can be tested using ZBUFFv07_isError()."},{"Add":"*"},{"Add":"* Hint : recommended buffer sizes (not compulsory) : ZBUFFv07_recommendedDInSize() and ZBUFFv07_recommendedDOutSize()"},{"Add":"* output : ZBUFFv07_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded."},{"Add":"* input : ZBUFFv07_recommendedDInSize == 128KB + 3;"},{"Add":"* just follow indications from ZBUFFv07_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 ."},{"Add":"* *******************************************************************************/"},{"Add":""},{"Add":"typedef enum { ZBUFFds_init, ZBUFFds_loadHeader,"},{"Add":" ZBUFFds_read, ZBUFFds_load, ZBUFFds_flush } ZBUFFv07_dStage;"},{"Add":""},{"Add":"/* *** Resource management *** */"},{"Add":"struct ZBUFFv07_DCtx_s {"},{"Add":" ZSTDv07_DCtx* zd;"},{"Add":" ZSTDv07_frameParams fParams;"},{"Add":" ZBUFFv07_dStage stage;"},{"Add":" char* inBuff;"},{"Add":" size_t inBuffSize;"},{"Add":" size_t inPos;"},{"Add":" char* outBuff;"},{"Add":" size_t outBuffSize;"},{"Add":" size_t outStart;"},{"Add":" size_t outEnd;"},{"Add":" size_t blockSize;"},{"Add":" BYTE headerBuffer[ZSTDv07_FRAMEHEADERSIZE_MAX];"},{"Add":" size_t lhSize;"},{"Add":" ZSTDv07_customMem customMem;"},{"Add":"}; /* typedef'd to ZBUFFv07_DCtx within \"zstd_buffered.h\" */"},{"Add":""},{"Add":"ZSTDLIBv07_API ZBUFFv07_DCtx* ZBUFFv07_createDCtx_advanced(ZSTDv07_customMem customMem);"},{"Add":""},{"Add":"ZBUFFv07_DCtx* ZBUFFv07_createDCtx(void)"},{"Add":"{"},{"Add":" return ZBUFFv07_createDCtx_advanced(defaultCustomMem);"},{"Add":"}"},{"Add":""},{"Add":"ZBUFFv07_DCtx* ZBUFFv07_createDCtx_advanced(ZSTDv07_customMem customMem)"},{"Add":"{"},{"Add":" ZBUFFv07_DCtx* zbd;"},{"Add":""},{"Add":" if (!customMem.customAlloc && !customMem.customFree)"},{"Add":" customMem = defaultCustomMem;"},{"Add":""},{"Add":" if (!customMem.customAlloc || !customMem.customFree)"},{"Add":" return NULL;"},{"Add":""},{"Add":" zbd = (ZBUFFv07_DCtx*)customMem.customAlloc(customMem.opaque, sizeof(ZBUFFv07_DCtx));"},{"Add":" if (zbd==NULL) return NULL;"},{"Add":" memset(zbd, 0, sizeof(ZBUFFv07_DCtx));"},{"Add":" memcpy(&zbd->customMem, &customMem, sizeof(ZSTDv07_customMem));"},{"Add":" zbd->zd = ZSTDv07_createDCtx_advanced(customMem);"},{"Add":" if (zbd->zd == NULL) { ZBUFFv07_freeDCtx(zbd); return NULL; }"},{"Add":" zbd->stage = ZBUFFds_init;"},{"Add":" return zbd;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZBUFFv07_freeDCtx(ZBUFFv07_DCtx* zbd)"},{"Add":"{"},{"Add":" if (zbd==NULL) return 0; /* support free on null */"},{"Add":" ZSTDv07_freeDCtx(zbd->zd);"},{"Add":" if (zbd->inBuff) zbd->customMem.customFree(zbd->customMem.opaque, zbd->inBuff);"},{"Add":" if (zbd->outBuff) zbd->customMem.customFree(zbd->customMem.opaque, zbd->outBuff);"},{"Add":" zbd->customMem.customFree(zbd->customMem.opaque, zbd);"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/* *** Initialization *** */"},{"Add":""},{"Add":"size_t ZBUFFv07_decompressInitDictionary(ZBUFFv07_DCtx* zbd, const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" zbd->stage = ZBUFFds_loadHeader;"},{"Add":" zbd->lhSize = zbd->inPos = zbd->outStart = zbd->outEnd = 0;"},{"Add":" return ZSTDv07_decompressBegin_usingDict(zbd->zd, dict, dictSize);"},{"Add":"}"},{"Add":""},{"Add":"size_t ZBUFFv07_decompressInit(ZBUFFv07_DCtx* zbd)"},{"Add":"{"},{"Add":" return ZBUFFv07_decompressInitDictionary(zbd, NULL, 0);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/* internal util function */"},{"Add":"MEM_STATIC size_t ZBUFFv07_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" size_t const length = MIN(dstCapacity, srcSize);"},{"Add":" if (length > 0) {"},{"Add":" memcpy(dst, src, length);"},{"Add":" }"},{"Add":" return length;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/* *** Decompression *** */"},{"Add":""},{"Add":"size_t ZBUFFv07_decompressContinue(ZBUFFv07_DCtx* zbd,"},{"Add":" void* dst, size_t* dstCapacityPtr,"},{"Add":" const void* src, size_t* srcSizePtr)"},{"Add":"{"},{"Add":" const char* const istart = (const char*)src;"},{"Add":" const char* const iend = istart + *srcSizePtr;"},{"Add":" const char* ip = istart;"},{"Add":" char* const ostart = (char*)dst;"},{"Add":" char* const oend = ostart + *dstCapacityPtr;"},{"Add":" char* op = ostart;"},{"Add":" U32 notDone = 1;"},{"Add":""},{"Add":" while (notDone) {"},{"Add":" switch(zbd->stage)"},{"Add":" {"},{"Add":" case ZBUFFds_init :"},{"Add":" return ERROR(init_missing);"},{"Add":""},{"Add":" case ZBUFFds_loadHeader :"},{"Add":" { size_t const hSize = ZSTDv07_getFrameParams(&(zbd->fParams), zbd->headerBuffer, zbd->lhSize);"},{"Add":" if (ZSTDv07_isError(hSize)) return hSize;"},{"Add":" if (hSize != 0) {"},{"Add":" size_t const toLoad = hSize - zbd->lhSize; /* if hSize!=0, hSize > zbd->lhSize */"},{"Add":" if (toLoad > (size_t)(iend-ip)) { /* not enough input to load full header */"},{"Add":" memcpy(zbd->headerBuffer + zbd->lhSize, ip, iend-ip);"},{"Add":" zbd->lhSize += iend-ip;"},{"Add":" *dstCapacityPtr = 0;"},{"Add":" return (hSize - zbd->lhSize) + ZSTDv07_blockHeaderSize; /* remaining header bytes + next block header */"},{"Add":" }"},{"Add":" memcpy(zbd->headerBuffer + zbd->lhSize, ip, toLoad); zbd->lhSize = hSize; ip += toLoad;"},{"Add":" break;"},{"Add":" } }"},{"Add":""},{"Add":" /* Consume header */"},{"Add":" { size_t const h1Size = ZSTDv07_nextSrcSizeToDecompress(zbd->zd); /* == ZSTDv07_frameHeaderSize_min */"},{"Add":" size_t const h1Result = ZSTDv07_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer, h1Size);"},{"Add":" if (ZSTDv07_isError(h1Result)) return h1Result;"},{"Add":" if (h1Size < zbd->lhSize) { /* long header */"},{"Add":" size_t const h2Size = ZSTDv07_nextSrcSizeToDecompress(zbd->zd);"},{"Add":" size_t const h2Result = ZSTDv07_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer+h1Size, h2Size);"},{"Add":" if (ZSTDv07_isError(h2Result)) return h2Result;"},{"Add":" } }"},{"Add":""},{"Add":" zbd->fParams.windowSize = MAX(zbd->fParams.windowSize, 1U << ZSTDv07_WINDOWLOG_ABSOLUTEMIN);"},{"Add":""},{"Add":" /* Frame header instruct buffer sizes */"},{"Add":" { size_t const blockSize = MIN(zbd->fParams.windowSize, ZSTDv07_BLOCKSIZE_ABSOLUTEMAX);"},{"Add":" zbd->blockSize = blockSize;"},{"Add":" if (zbd->inBuffSize < blockSize) {"},{"Add":" zbd->customMem.customFree(zbd->customMem.opaque, zbd->inBuff);"},{"Add":" zbd->inBuffSize = blockSize;"},{"Add":" zbd->inBuff = (char*)zbd->customMem.customAlloc(zbd->customMem.opaque, blockSize);"},{"Add":" if (zbd->inBuff == NULL) return ERROR(memory_allocation);"},{"Add":" }"},{"Add":" { size_t const neededOutSize = zbd->fParams.windowSize + blockSize + WILDCOPY_OVERLENGTH * 2;"},{"Add":" if (zbd->outBuffSize < neededOutSize) {"},{"Add":" zbd->customMem.customFree(zbd->customMem.opaque, zbd->outBuff);"},{"Add":" zbd->outBuffSize = neededOutSize;"},{"Add":" zbd->outBuff = (char*)zbd->customMem.customAlloc(zbd->customMem.opaque, neededOutSize);"},{"Add":" if (zbd->outBuff == NULL) return ERROR(memory_allocation);"},{"Add":" } } }"},{"Add":" zbd->stage = ZBUFFds_read;"},{"Add":" /* pass-through */"},{"Add":"\t /* fall-through */"},{"Add":" case ZBUFFds_read:"},{"Add":" { size_t const neededInSize = ZSTDv07_nextSrcSizeToDecompress(zbd->zd);"},{"Add":" if (neededInSize==0) { /* end of frame */"},{"Add":" zbd->stage = ZBUFFds_init;"},{"Add":" notDone = 0;"},{"Add":" break;"},{"Add":" }"},{"Add":" if ((size_t)(iend-ip) >= neededInSize) { /* decode directly from src */"},{"Add":" const int isSkipFrame = ZSTDv07_isSkipFrame(zbd->zd);"},{"Add":" size_t const decodedSize = ZSTDv07_decompressContinue(zbd->zd,"},{"Add":" zbd->outBuff + zbd->outStart, (isSkipFrame ? 0 : zbd->outBuffSize - zbd->outStart),"},{"Add":" ip, neededInSize);"},{"Add":" if (ZSTDv07_isError(decodedSize)) return decodedSize;"},{"Add":" ip += neededInSize;"},{"Add":" if (!decodedSize && !isSkipFrame) break; /* this was just a header */"},{"Add":" zbd->outEnd = zbd->outStart + decodedSize;"},{"Add":" zbd->stage = ZBUFFds_flush;"},{"Add":" break;"},{"Add":" }"},{"Add":" if (ip==iend) { notDone = 0; break; } /* no more input */"},{"Add":" zbd->stage = ZBUFFds_load;"},{"Add":" }"},{"Add":"\t /* fall-through */"},{"Add":" case ZBUFFds_load:"},{"Add":" { size_t const neededInSize = ZSTDv07_nextSrcSizeToDecompress(zbd->zd);"},{"Add":" size_t const toLoad = neededInSize - zbd->inPos; /* should always be <= remaining space within inBuff */"},{"Add":" size_t loadedSize;"},{"Add":" if (toLoad > zbd->inBuffSize - zbd->inPos) return ERROR(corruption_detected); /* should never happen */"},{"Add":" loadedSize = ZBUFFv07_limitCopy(zbd->inBuff + zbd->inPos, toLoad, ip, iend-ip);"},{"Add":" ip += loadedSize;"},{"Add":" zbd->inPos += loadedSize;"},{"Add":" if (loadedSize < toLoad) { notDone = 0; break; } /* not enough input, wait for more */"},{"Add":""},{"Add":" /* decode loaded input */"},{"Add":" { const int isSkipFrame = ZSTDv07_isSkipFrame(zbd->zd);"},{"Add":" size_t const decodedSize = ZSTDv07_decompressContinue(zbd->zd,"},{"Add":" zbd->outBuff + zbd->outStart, zbd->outBuffSize - zbd->outStart,"},{"Add":" zbd->inBuff, neededInSize);"},{"Add":" if (ZSTDv07_isError(decodedSize)) return decodedSize;"},{"Add":" zbd->inPos = 0; /* input is consumed */"},{"Add":" if (!decodedSize && !isSkipFrame) { zbd->stage = ZBUFFds_read; break; } /* this was just a header */"},{"Add":" zbd->outEnd = zbd->outStart + decodedSize;"},{"Add":" zbd->stage = ZBUFFds_flush;"},{"Add":" /* break; */"},{"Add":" /* pass-through */"},{"Add":" }"},{"Add":"\t }"},{"Add":"\t /* fall-through */"},{"Add":" case ZBUFFds_flush:"},{"Add":" { size_t const toFlushSize = zbd->outEnd - zbd->outStart;"},{"Add":" size_t const flushedSize = ZBUFFv07_limitCopy(op, oend-op, zbd->outBuff + zbd->outStart, toFlushSize);"},{"Add":" op += flushedSize;"},{"Add":" zbd->outStart += flushedSize;"},{"Add":" if (flushedSize == toFlushSize) {"},{"Add":" zbd->stage = ZBUFFds_read;"},{"Add":" if (zbd->outStart + zbd->blockSize > zbd->outBuffSize)"},{"Add":" zbd->outStart = zbd->outEnd = 0;"},{"Add":" break;"},{"Add":" }"},{"Add":" /* cannot flush everything */"},{"Add":" notDone = 0;"},{"Add":" break;"},{"Add":" }"},{"Add":" default: return ERROR(GENERIC); /* impossible */"},{"Add":" } }"},{"Add":""},{"Add":" /* result */"},{"Add":" *srcSizePtr = ip-istart;"},{"Add":" *dstCapacityPtr = op-ostart;"},{"Add":" { size_t nextSrcSizeHint = ZSTDv07_nextSrcSizeToDecompress(zbd->zd);"},{"Add":" nextSrcSizeHint -= zbd->inPos; /* already loaded*/"},{"Add":" return nextSrcSizeHint;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Tool functions"},{"Add":"***************************************/"},{"Add":"size_t ZBUFFv07_recommendedDInSize(void) { return ZSTDv07_BLOCKSIZE_ABSOLUTEMAX + ZSTDv07_blockHeaderSize /* block header size*/ ; }"},{"Add":"size_t ZBUFFv07_recommendedDOutSize(void) { return ZSTDv07_BLOCKSIZE_ABSOLUTEMAX; }"}]}},{"FileAdd":{"meta":{"basename":"zstd_v06.h","metadata":0},"context":[{"change":0,"pos":140938}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) 2016-2021, Yann Collet, Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":""},{"Add":"#ifndef ZSTDv06_H"},{"Add":"#define ZSTDv06_H"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"/*====== Dependency ======*/"},{"Add":"#include /* size_t */"},{"Add":""},{"Add":""},{"Add":"/*====== Export for Windows ======*/"},{"Add":"/*!"},{"Add":"* ZSTDv06_DLL_EXPORT :"},{"Add":"* Enable exporting of functions when building a Windows DLL"},{"Add":"*/"},{"Add":"#if defined(_WIN32) && defined(ZSTDv06_DLL_EXPORT) && (ZSTDv06_DLL_EXPORT==1)"},{"Add":"# define ZSTDLIBv06_API __declspec(dllexport)"},{"Add":"#else"},{"Add":"# define ZSTDLIBv06_API"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Simple functions"},{"Add":"***************************************/"},{"Add":"/*! ZSTDv06_decompress() :"},{"Add":" `compressedSize` : is the _exact_ size of the compressed blob, otherwise decompression will fail."},{"Add":" `dstCapacity` must be large enough, equal or larger than originalSize."},{"Add":" @return : the number of bytes decompressed into `dst` (<= `dstCapacity`),"},{"Add":" or an errorCode if it fails (which can be tested using ZSTDv06_isError()) */"},{"Add":"ZSTDLIBv06_API size_t ZSTDv06_decompress( void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t compressedSize);"},{"Add":""},{"Add":"/**"},{"Add":"ZSTDv06_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.6.x format"},{"Add":" srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'"},{"Add":" cSize (output parameter) : the number of bytes that would be read to decompress this frame"},{"Add":" or an error code if it fails (which can be tested using ZSTDv01_isError())"},{"Add":" dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame"},{"Add":" or ZSTD_CONTENTSIZE_ERROR if an error occurs"},{"Add":""},{"Add":" note : assumes `cSize` and `dBound` are _not_ NULL."},{"Add":"*/"},{"Add":"void ZSTDv06_findFrameSizeInfoLegacy(const void *src, size_t srcSize,"},{"Add":" size_t* cSize, unsigned long long* dBound);"},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Helper functions"},{"Add":"***************************************/"},{"Add":"ZSTDLIBv06_API size_t ZSTDv06_compressBound(size_t srcSize); /*!< maximum compressed size (worst case scenario) */"},{"Add":""},{"Add":"/* Error Management */"},{"Add":"ZSTDLIBv06_API unsigned ZSTDv06_isError(size_t code); /*!< tells if a `size_t` function result is an error code */"},{"Add":"ZSTDLIBv06_API const char* ZSTDv06_getErrorName(size_t code); /*!< provides readable string for an error code */"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Explicit memory management"},{"Add":"***************************************/"},{"Add":"/** Decompression context */"},{"Add":"typedef struct ZSTDv06_DCtx_s ZSTDv06_DCtx;"},{"Add":"ZSTDLIBv06_API ZSTDv06_DCtx* ZSTDv06_createDCtx(void);"},{"Add":"ZSTDLIBv06_API size_t ZSTDv06_freeDCtx(ZSTDv06_DCtx* dctx); /*!< @return : errorCode */"},{"Add":""},{"Add":"/** ZSTDv06_decompressDCtx() :"},{"Add":"* Same as ZSTDv06_decompress(), but requires an already allocated ZSTDv06_DCtx (see ZSTDv06_createDCtx()) */"},{"Add":"ZSTDLIBv06_API size_t ZSTDv06_decompressDCtx(ZSTDv06_DCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);"},{"Add":""},{"Add":""},{"Add":"/*-***********************"},{"Add":"* Dictionary API"},{"Add":"*************************/"},{"Add":"/*! ZSTDv06_decompress_usingDict() :"},{"Add":"* Decompression using a pre-defined Dictionary content (see dictBuilder)."},{"Add":"* Dictionary must be identical to the one used during compression, otherwise regenerated data will be corrupted."},{"Add":"* Note : dict can be NULL, in which case, it's equivalent to ZSTDv06_decompressDCtx() */"},{"Add":"ZSTDLIBv06_API size_t ZSTDv06_decompress_usingDict(ZSTDv06_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const void* dict,size_t dictSize);"},{"Add":""},{"Add":""},{"Add":"/*-************************"},{"Add":"* Advanced Streaming API"},{"Add":"***************************/"},{"Add":"struct ZSTDv06_frameParams_s { unsigned long long frameContentSize; unsigned windowLog; };"},{"Add":"typedef struct ZSTDv06_frameParams_s ZSTDv06_frameParams;"},{"Add":""},{"Add":"ZSTDLIBv06_API size_t ZSTDv06_getFrameParams(ZSTDv06_frameParams* fparamsPtr, const void* src, size_t srcSize); /**< doesn't consume input */"},{"Add":"ZSTDLIBv06_API size_t ZSTDv06_decompressBegin_usingDict(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize);"},{"Add":"ZSTDLIBv06_API void ZSTDv06_copyDCtx(ZSTDv06_DCtx* dctx, const ZSTDv06_DCtx* preparedDCtx);"},{"Add":""},{"Add":"ZSTDLIBv06_API size_t ZSTDv06_nextSrcSizeToDecompress(ZSTDv06_DCtx* dctx);"},{"Add":"ZSTDLIBv06_API size_t ZSTDv06_decompressContinue(ZSTDv06_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* ZBUFF API"},{"Add":"***************************************/"},{"Add":""},{"Add":"typedef struct ZBUFFv06_DCtx_s ZBUFFv06_DCtx;"},{"Add":"ZSTDLIBv06_API ZBUFFv06_DCtx* ZBUFFv06_createDCtx(void);"},{"Add":"ZSTDLIBv06_API size_t ZBUFFv06_freeDCtx(ZBUFFv06_DCtx* dctx);"},{"Add":""},{"Add":"ZSTDLIBv06_API size_t ZBUFFv06_decompressInit(ZBUFFv06_DCtx* dctx);"},{"Add":"ZSTDLIBv06_API size_t ZBUFFv06_decompressInitDictionary(ZBUFFv06_DCtx* dctx, const void* dict, size_t dictSize);"},{"Add":""},{"Add":"ZSTDLIBv06_API size_t ZBUFFv06_decompressContinue(ZBUFFv06_DCtx* dctx,"},{"Add":" void* dst, size_t* dstCapacityPtr,"},{"Add":" const void* src, size_t* srcSizePtr);"},{"Add":""},{"Add":"/*-***************************************************************************"},{"Add":"* Streaming decompression howto"},{"Add":"*"},{"Add":"* A ZBUFFv06_DCtx object is required to track streaming operations."},{"Add":"* Use ZBUFFv06_createDCtx() and ZBUFFv06_freeDCtx() to create/release resources."},{"Add":"* Use ZBUFFv06_decompressInit() to start a new decompression operation,"},{"Add":"* or ZBUFFv06_decompressInitDictionary() if decompression requires a dictionary."},{"Add":"* Note that ZBUFFv06_DCtx objects can be re-init multiple times."},{"Add":"*"},{"Add":"* Use ZBUFFv06_decompressContinue() repetitively to consume your input."},{"Add":"* *srcSizePtr and *dstCapacityPtr can be any size."},{"Add":"* The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr."},{"Add":"* Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again."},{"Add":"* The content of `dst` will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change `dst`."},{"Add":"* @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency),"},{"Add":"* or 0 when a frame is completely decoded,"},{"Add":"* or an error code, which can be tested using ZBUFFv06_isError()."},{"Add":"*"},{"Add":"* Hint : recommended buffer sizes (not compulsory) : ZBUFFv06_recommendedDInSize() and ZBUFFv06_recommendedDOutSize()"},{"Add":"* output : ZBUFFv06_recommendedDOutSize== 128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded."},{"Add":"* input : ZBUFFv06_recommendedDInSize == 128KB + 3;"},{"Add":"* just follow indications from ZBUFFv06_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 ."},{"Add":"* *******************************************************************************/"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Tool functions"},{"Add":"***************************************/"},{"Add":"ZSTDLIBv06_API unsigned ZBUFFv06_isError(size_t errorCode);"},{"Add":"ZSTDLIBv06_API const char* ZBUFFv06_getErrorName(size_t errorCode);"},{"Add":""},{"Add":"/** Functions below provide recommended buffer sizes for Compression or Decompression operations."},{"Add":"* These sizes are just hints, they tend to offer better latency */"},{"Add":"ZSTDLIBv06_API size_t ZBUFFv06_recommendedDInSize(void);"},{"Add":"ZSTDLIBv06_API size_t ZBUFFv06_recommendedDOutSize(void);"},{"Add":""},{"Add":""},{"Add":"/*-*************************************"},{"Add":"* Constants"},{"Add":"***************************************/"},{"Add":"#define ZSTDv06_MAGICNUMBER 0xFD2FB526 /* v0.6 */"},{"Add":""},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* ZSTDv06_BUFFERED_H */"}]}},{"FileAdd":{"meta":{"basename":"zstd_v06.c","metadata":0},"context":[{"change":0,"pos":140938}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) 2016-2021, Yann Collet, Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":""},{"Add":""},{"Add":"/*- Dependencies -*/"},{"Add":"#include \"zstd_v06.h\""},{"Add":"#include /* size_t, ptrdiff_t */"},{"Add":"#include /* memcpy */"},{"Add":"#include /* malloc, free, qsort */"},{"Add":"#include \"../common/error_private.h\""},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* ******************************************************************"},{"Add":" mem.h"},{"Add":" low-level memory access routines"},{"Add":" Copyright (C) 2013-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":"#ifndef MEM_H_MODULE"},{"Add":"#define MEM_H_MODULE"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*-****************************************"},{"Add":"* Compiler specifics"},{"Add":"******************************************/"},{"Add":"#if defined(_MSC_VER) /* Visual Studio */"},{"Add":"# include /* _byteswap_ulong */"},{"Add":"# include /* _byteswap_* */"},{"Add":"#endif"},{"Add":"#if defined(__GNUC__)"},{"Add":"# define MEM_STATIC static __attribute__((unused))"},{"Add":"#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)"},{"Add":"# define MEM_STATIC static inline"},{"Add":"#elif defined(_MSC_VER)"},{"Add":"# define MEM_STATIC static __inline"},{"Add":"#else"},{"Add":"# define MEM_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*-**************************************************************"},{"Add":"* Basic Types"},{"Add":"*****************************************************************/"},{"Add":"#if !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )"},{"Add":"# if defined(_AIX)"},{"Add":"# include "},{"Add":"# else"},{"Add":"# include /* intptr_t */"},{"Add":"# endif"},{"Add":" typedef uint8_t BYTE;"},{"Add":" typedef uint16_t U16;"},{"Add":" typedef int16_t S16;"},{"Add":" typedef uint32_t U32;"},{"Add":" typedef int32_t S32;"},{"Add":" typedef uint64_t U64;"},{"Add":" typedef int64_t S64;"},{"Add":"#else"},{"Add":" typedef unsigned char BYTE;"},{"Add":" typedef unsigned short U16;"},{"Add":" typedef signed short S16;"},{"Add":" typedef unsigned int U32;"},{"Add":" typedef signed int S32;"},{"Add":" typedef unsigned long long U64;"},{"Add":" typedef signed long long S64;"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*-**************************************************************"},{"Add":"* Memory I/O"},{"Add":"*****************************************************************/"},{"Add":"/* MEM_FORCE_MEMORY_ACCESS :"},{"Add":" * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable."},{"Add":" * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal."},{"Add":" * The below switch allow to select different access method for improved performance."},{"Add":" * Method 0 (default) : use `memcpy()`. Safe and portable."},{"Add":" * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable)."},{"Add":" * This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`."},{"Add":" * Method 2 : direct access. This method is portable but violate C standard."},{"Add":" * It can generate buggy code on targets depending on alignment."},{"Add":" * In some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)"},{"Add":" * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details."},{"Add":" * Prefer these methods in priority order (0 > 1 > 2)"},{"Add":" */"},{"Add":"#ifndef MEM_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */"},{"Add":"# if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )"},{"Add":"# define MEM_FORCE_MEMORY_ACCESS 2"},{"Add":"# elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \\"},{"Add":" (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))"},{"Add":"# define MEM_FORCE_MEMORY_ACCESS 1"},{"Add":"# endif"},{"Add":"#endif"},{"Add":""},{"Add":"MEM_STATIC unsigned MEM_32bits(void) { return sizeof(size_t)==4; }"},{"Add":"MEM_STATIC unsigned MEM_64bits(void) { return sizeof(size_t)==8; }"},{"Add":""},{"Add":"MEM_STATIC unsigned MEM_isLittleEndian(void)"},{"Add":"{"},{"Add":" const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */"},{"Add":" return one.c[0];"},{"Add":"}"},{"Add":""},{"Add":"#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)"},{"Add":""},{"Add":"/* violates C standard, by lying on structure alignment."},{"Add":"Only use if no other choice to achieve best performance on target platform */"},{"Add":"MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }"},{"Add":"MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }"},{"Add":"MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }"},{"Add":""},{"Add":"#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)"},{"Add":""},{"Add":"/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */"},{"Add":"/* currently only defined for gcc and icc */"},{"Add":"typedef union { U16 u16; U32 u32; U64 u64; size_t st; } __attribute__((packed)) unalign;"},{"Add":""},{"Add":"MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }"},{"Add":"MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }"},{"Add":"MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }"},{"Add":""},{"Add":"#else"},{"Add":""},{"Add":"/* default method, safe and standard."},{"Add":" can sometimes prove slower */"},{"Add":""},{"Add":"MEM_STATIC U16 MEM_read16(const void* memPtr)"},{"Add":"{"},{"Add":" U16 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_read32(const void* memPtr)"},{"Add":"{"},{"Add":" U32 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U64 MEM_read64(const void* memPtr)"},{"Add":"{"},{"Add":" U64 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value)"},{"Add":"{"},{"Add":" memcpy(memPtr, &value, sizeof(value));"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"#endif /* MEM_FORCE_MEMORY_ACCESS */"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_swap32(U32 in)"},{"Add":"{"},{"Add":"#if defined(_MSC_VER) /* Visual Studio */"},{"Add":" return _byteswap_ulong(in);"},{"Add":"#elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)"},{"Add":" return __builtin_bswap32(in);"},{"Add":"#else"},{"Add":" return ((in << 24) & 0xff000000 ) |"},{"Add":" ((in << 8) & 0x00ff0000 ) |"},{"Add":" ((in >> 8) & 0x0000ff00 ) |"},{"Add":" ((in >> 24) & 0x000000ff );"},{"Add":"#endif"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U64 MEM_swap64(U64 in)"},{"Add":"{"},{"Add":"#if defined(_MSC_VER) /* Visual Studio */"},{"Add":" return _byteswap_uint64(in);"},{"Add":"#elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)"},{"Add":" return __builtin_bswap64(in);"},{"Add":"#else"},{"Add":" return ((in << 56) & 0xff00000000000000ULL) |"},{"Add":" ((in << 40) & 0x00ff000000000000ULL) |"},{"Add":" ((in << 24) & 0x0000ff0000000000ULL) |"},{"Add":" ((in << 8) & 0x000000ff00000000ULL) |"},{"Add":" ((in >> 8) & 0x00000000ff000000ULL) |"},{"Add":" ((in >> 24) & 0x0000000000ff0000ULL) |"},{"Add":" ((in >> 40) & 0x000000000000ff00ULL) |"},{"Add":" ((in >> 56) & 0x00000000000000ffULL);"},{"Add":"#endif"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*=== Little endian r/w ===*/"},{"Add":""},{"Add":"MEM_STATIC U16 MEM_readLE16(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read16(memPtr);"},{"Add":" else {"},{"Add":" const BYTE* p = (const BYTE*)memPtr;"},{"Add":" return (U16)(p[0] + (p[1]<<8));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian()) {"},{"Add":" MEM_write16(memPtr, val);"},{"Add":" } else {"},{"Add":" BYTE* p = (BYTE*)memPtr;"},{"Add":" p[0] = (BYTE)val;"},{"Add":" p[1] = (BYTE)(val>>8);"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_readLE32(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read32(memPtr);"},{"Add":" else"},{"Add":" return MEM_swap32(MEM_read32(memPtr));"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"MEM_STATIC U64 MEM_readLE64(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read64(memPtr);"},{"Add":" else"},{"Add":" return MEM_swap64(MEM_read64(memPtr));"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"MEM_STATIC size_t MEM_readLEST(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_32bits())"},{"Add":" return (size_t)MEM_readLE32(memPtr);"},{"Add":" else"},{"Add":" return (size_t)MEM_readLE64(memPtr);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* MEM_H_MODULE */"},{"Add":""},{"Add":"/*"},{"Add":" zstd - standard compression library"},{"Add":" Header File for static linking only"},{"Add":" Copyright (C) 2014-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - zstd homepage : http://www.zstd.net"},{"Add":"*/"},{"Add":"#ifndef ZSTDv06_STATIC_H"},{"Add":"#define ZSTDv06_STATIC_H"},{"Add":""},{"Add":"/* The prototypes defined within this file are considered experimental."},{"Add":" * They should not be used in the context DLL as they may change in the future."},{"Add":" * Prefer static linking if you need them, to control breaking version changes issues."},{"Add":" */"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*- Advanced Decompression functions -*/"},{"Add":""},{"Add":"/*! ZSTDv06_decompress_usingPreparedDCtx() :"},{"Add":"* Same as ZSTDv06_decompress_usingDict, but using a reference context `preparedDCtx`, where dictionary has been loaded."},{"Add":"* It avoids reloading the dictionary each time."},{"Add":"* `preparedDCtx` must have been properly initialized using ZSTDv06_decompressBegin_usingDict()."},{"Add":"* Requires 2 contexts : 1 for reference (preparedDCtx), which will not be modified, and 1 to run the decompression operation (dctx) */"},{"Add":"ZSTDLIBv06_API size_t ZSTDv06_decompress_usingPreparedDCtx("},{"Add":" ZSTDv06_DCtx* dctx, const ZSTDv06_DCtx* preparedDCtx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize);"},{"Add":""},{"Add":""},{"Add":""},{"Add":"#define ZSTDv06_FRAMEHEADERSIZE_MAX 13 /* for static allocation */"},{"Add":"static const size_t ZSTDv06_frameHeaderSize_min = 5;"},{"Add":"static const size_t ZSTDv06_frameHeaderSize_max = ZSTDv06_FRAMEHEADERSIZE_MAX;"},{"Add":""},{"Add":"ZSTDLIBv06_API size_t ZSTDv06_decompressBegin(ZSTDv06_DCtx* dctx);"},{"Add":""},{"Add":"/*"},{"Add":" Streaming decompression, direct mode (bufferless)"},{"Add":""},{"Add":" A ZSTDv06_DCtx object is required to track streaming operations."},{"Add":" Use ZSTDv06_createDCtx() / ZSTDv06_freeDCtx() to manage it."},{"Add":" A ZSTDv06_DCtx object can be re-used multiple times."},{"Add":""},{"Add":" First optional operation is to retrieve frame parameters, using ZSTDv06_getFrameParams(), which doesn't consume the input."},{"Add":" It can provide the minimum size of rolling buffer required to properly decompress data,"},{"Add":" and optionally the final size of uncompressed content."},{"Add":" (Note : content size is an optional info that may not be present. 0 means : content size unknown)"},{"Add":" Frame parameters are extracted from the beginning of compressed frame."},{"Add":" The amount of data to read is variable, from ZSTDv06_frameHeaderSize_min to ZSTDv06_frameHeaderSize_max (so if `srcSize` >= ZSTDv06_frameHeaderSize_max, it will always work)"},{"Add":" If `srcSize` is too small for operation to succeed, function will return the minimum size it requires to produce a result."},{"Add":" Result : 0 when successful, it means the ZSTDv06_frameParams structure has been filled."},{"Add":" >0 : means there is not enough data into `src`. Provides the expected size to successfully decode header."},{"Add":" errorCode, which can be tested using ZSTDv06_isError()"},{"Add":""},{"Add":" Start decompression, with ZSTDv06_decompressBegin() or ZSTDv06_decompressBegin_usingDict()."},{"Add":" Alternatively, you can copy a prepared context, using ZSTDv06_copyDCtx()."},{"Add":""},{"Add":" Then use ZSTDv06_nextSrcSizeToDecompress() and ZSTDv06_decompressContinue() alternatively."},{"Add":" ZSTDv06_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTDv06_decompressContinue()."},{"Add":" ZSTDv06_decompressContinue() requires this exact amount of bytes, or it will fail."},{"Add":" ZSTDv06_decompressContinue() needs previous data blocks during decompression, up to (1 << windowlog)."},{"Add":" They should preferably be located contiguously, prior to current block. Alternatively, a round buffer is also possible."},{"Add":""},{"Add":" @result of ZSTDv06_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity)"},{"Add":" It can be zero, which is not an error; it just means ZSTDv06_decompressContinue() has decoded some header."},{"Add":""},{"Add":" A frame is fully decoded when ZSTDv06_nextSrcSizeToDecompress() returns zero."},{"Add":" Context can then be reset to start a new decompression."},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/* **************************************"},{"Add":"* Block functions"},{"Add":"****************************************/"},{"Add":"/*! Block functions produce and decode raw zstd blocks, without frame metadata."},{"Add":" User will have to take in charge required information to regenerate data, such as compressed and content sizes."},{"Add":""},{"Add":" A few rules to respect :"},{"Add":" - Uncompressed block size must be <= ZSTDv06_BLOCKSIZE_MAX (128 KB)"},{"Add":" - Compressing or decompressing requires a context structure"},{"Add":" + Use ZSTDv06_createCCtx() and ZSTDv06_createDCtx()"},{"Add":" - It is necessary to init context before starting"},{"Add":" + compression : ZSTDv06_compressBegin()"},{"Add":" + decompression : ZSTDv06_decompressBegin()"},{"Add":" + variants _usingDict() are also allowed"},{"Add":" + copyCCtx() and copyDCtx() work too"},{"Add":" - When a block is considered not compressible enough, ZSTDv06_compressBlock() result will be zero."},{"Add":" In which case, nothing is produced into `dst`."},{"Add":" + User must test for such outcome and deal directly with uncompressed data"},{"Add":" + ZSTDv06_decompressBlock() doesn't accept uncompressed data as input !!"},{"Add":"*/"},{"Add":""},{"Add":"#define ZSTDv06_BLOCKSIZE_MAX (128 * 1024) /* define, for static allocation */"},{"Add":"ZSTDLIBv06_API size_t ZSTDv06_decompressBlock(ZSTDv06_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);"},{"Add":""},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* ZSTDv06_STATIC_H */"},{"Add":"/*"},{"Add":" zstd_internal - common functions to include"},{"Add":" Header File for include"},{"Add":" Copyright (C) 2014-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - zstd homepage : https://www.zstd.net"},{"Add":"*/"},{"Add":"#ifndef ZSTDv06_CCOMMON_H_MODULE"},{"Add":"#define ZSTDv06_CCOMMON_H_MODULE"},{"Add":""},{"Add":""},{"Add":"/*-*************************************"},{"Add":"* Common macros"},{"Add":"***************************************/"},{"Add":"#define MIN(a,b) ((a)<(b) ? (a) : (b))"},{"Add":"#define MAX(a,b) ((a)>(b) ? (a) : (b))"},{"Add":""},{"Add":""},{"Add":"/*-*************************************"},{"Add":"* Common constants"},{"Add":"***************************************/"},{"Add":"#define ZSTDv06_DICT_MAGIC 0xEC30A436"},{"Add":""},{"Add":"#define ZSTDv06_REP_NUM 3"},{"Add":"#define ZSTDv06_REP_INIT ZSTDv06_REP_NUM"},{"Add":"#define ZSTDv06_REP_MOVE (ZSTDv06_REP_NUM-1)"},{"Add":""},{"Add":"#define KB *(1 <<10)"},{"Add":"#define MB *(1 <<20)"},{"Add":"#define GB *(1U<<30)"},{"Add":""},{"Add":"#define BIT7 128"},{"Add":"#define BIT6 64"},{"Add":"#define BIT5 32"},{"Add":"#define BIT4 16"},{"Add":"#define BIT1 2"},{"Add":"#define BIT0 1"},{"Add":""},{"Add":"#define ZSTDv06_WINDOWLOG_ABSOLUTEMIN 12"},{"Add":"static const size_t ZSTDv06_fcs_fieldSize[4] = { 0, 1, 2, 8 };"},{"Add":""},{"Add":"#define ZSTDv06_BLOCKHEADERSIZE 3 /* because C standard does not allow a static const value to be defined using another static const value .... :( */"},{"Add":"static const size_t ZSTDv06_blockHeaderSize = ZSTDv06_BLOCKHEADERSIZE;"},{"Add":"typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t;"},{"Add":""},{"Add":"#define MIN_SEQUENCES_SIZE 1 /* nbSeq==0 */"},{"Add":"#define MIN_CBLOCK_SIZE (1 /*litCSize*/ + 1 /* RLE or RAW */ + MIN_SEQUENCES_SIZE /* nbSeq==0 */) /* for a non-null block */"},{"Add":""},{"Add":"#define HufLog 12"},{"Add":""},{"Add":"#define IS_HUF 0"},{"Add":"#define IS_PCH 1"},{"Add":"#define IS_RAW 2"},{"Add":"#define IS_RLE 3"},{"Add":""},{"Add":"#define LONGNBSEQ 0x7F00"},{"Add":""},{"Add":"#define MINMATCH 3"},{"Add":"#define EQUAL_READ32 4"},{"Add":"#define REPCODE_STARTVALUE 1"},{"Add":""},{"Add":"#define Litbits 8"},{"Add":"#define MaxLit ((1< /* support for bextr (experimental) */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-********************************************"},{"Add":"* bitStream decoding API (read backward)"},{"Add":"**********************************************/"},{"Add":"typedef struct"},{"Add":"{"},{"Add":" size_t bitContainer;"},{"Add":" unsigned bitsConsumed;"},{"Add":" const char* ptr;"},{"Add":" const char* start;"},{"Add":"} BITv06_DStream_t;"},{"Add":""},{"Add":"typedef enum { BITv06_DStream_unfinished = 0,"},{"Add":" BITv06_DStream_endOfBuffer = 1,"},{"Add":" BITv06_DStream_completed = 2,"},{"Add":" BITv06_DStream_overflow = 3 } BITv06_DStream_status; /* result of BITv06_reloadDStream() */"},{"Add":" /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */"},{"Add":""},{"Add":"MEM_STATIC size_t BITv06_initDStream(BITv06_DStream_t* bitD, const void* srcBuffer, size_t srcSize);"},{"Add":"MEM_STATIC size_t BITv06_readBits(BITv06_DStream_t* bitD, unsigned nbBits);"},{"Add":"MEM_STATIC BITv06_DStream_status BITv06_reloadDStream(BITv06_DStream_t* bitD);"},{"Add":"MEM_STATIC unsigned BITv06_endOfDStream(const BITv06_DStream_t* bitD);"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-****************************************"},{"Add":"* unsafe API"},{"Add":"******************************************/"},{"Add":"MEM_STATIC size_t BITv06_readBitsFast(BITv06_DStream_t* bitD, unsigned nbBits);"},{"Add":"/* faster, but works only if nbBits >= 1 */"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-**************************************************************"},{"Add":"* Internal functions"},{"Add":"****************************************************************/"},{"Add":"MEM_STATIC unsigned BITv06_highbit32 ( U32 val)"},{"Add":"{"},{"Add":"# if defined(_MSC_VER) /* Visual */"},{"Add":" unsigned long r=0;"},{"Add":" _BitScanReverse ( &r, val );"},{"Add":" return (unsigned) r;"},{"Add":"# elif defined(__GNUC__) && (__GNUC__ >= 3) /* Use GCC Intrinsic */"},{"Add":" return __builtin_clz (val) ^ 31;"},{"Add":"# else /* Software version */"},{"Add":" static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };"},{"Add":" U32 v = val;"},{"Add":" unsigned r;"},{"Add":" v |= v >> 1;"},{"Add":" v |= v >> 2;"},{"Add":" v |= v >> 4;"},{"Add":" v |= v >> 8;"},{"Add":" v |= v >> 16;"},{"Add":" r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];"},{"Add":" return r;"},{"Add":"# endif"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-********************************************************"},{"Add":"* bitStream decoding"},{"Add":"**********************************************************/"},{"Add":"/*! BITv06_initDStream() :"},{"Add":"* Initialize a BITv06_DStream_t."},{"Add":"* `bitD` : a pointer to an already allocated BITv06_DStream_t structure."},{"Add":"* `srcSize` must be the *exact* size of the bitStream, in bytes."},{"Add":"* @return : size of stream (== srcSize) or an errorCode if a problem is detected"},{"Add":"*/"},{"Add":"MEM_STATIC size_t BITv06_initDStream(BITv06_DStream_t* bitD, const void* srcBuffer, size_t srcSize)"},{"Add":"{"},{"Add":" if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }"},{"Add":""},{"Add":" if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */"},{"Add":" bitD->start = (const char*)srcBuffer;"},{"Add":" bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr);"},{"Add":" { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];"},{"Add":" if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */"},{"Add":" bitD->bitsConsumed = 8 - BITv06_highbit32(lastByte); }"},{"Add":" } else {"},{"Add":" bitD->start = (const char*)srcBuffer;"},{"Add":" bitD->ptr = bitD->start;"},{"Add":" bitD->bitContainer = *(const BYTE*)(bitD->start);"},{"Add":" switch(srcSize)"},{"Add":" {"},{"Add":" case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);/* fall-through */"},{"Add":" case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);/* fall-through */"},{"Add":" case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);/* fall-through */"},{"Add":" case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24; /* fall-through */"},{"Add":" case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16; /* fall-through */"},{"Add":" case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) << 8; /* fall-through */"},{"Add":" default: break;"},{"Add":" }"},{"Add":" { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];"},{"Add":" if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */"},{"Add":" bitD->bitsConsumed = 8 - BITv06_highbit32(lastByte); }"},{"Add":" bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;"},{"Add":" }"},{"Add":""},{"Add":" return srcSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":" MEM_STATIC size_t BITv06_lookBits(const BITv06_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1;"},{"Add":" return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);"},{"Add":"}"},{"Add":""},{"Add":"/*! BITv06_lookBitsFast() :"},{"Add":"* unsafe version; only works only if nbBits >= 1 */"},{"Add":"MEM_STATIC size_t BITv06_lookBitsFast(const BITv06_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1;"},{"Add":" return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void BITv06_skipBits(BITv06_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" bitD->bitsConsumed += nbBits;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC size_t BITv06_readBits(BITv06_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" size_t const value = BITv06_lookBits(bitD, nbBits);"},{"Add":" BITv06_skipBits(bitD, nbBits);"},{"Add":" return value;"},{"Add":"}"},{"Add":""},{"Add":"/*! BITv06_readBitsFast() :"},{"Add":"* unsafe version; only works only if nbBits >= 1 */"},{"Add":"MEM_STATIC size_t BITv06_readBitsFast(BITv06_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" size_t const value = BITv06_lookBitsFast(bitD, nbBits);"},{"Add":" BITv06_skipBits(bitD, nbBits);"},{"Add":" return value;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BITv06_DStream_status BITv06_reloadDStream(BITv06_DStream_t* bitD)"},{"Add":"{"},{"Add":" if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* should never happen */"},{"Add":" return BITv06_DStream_overflow;"},{"Add":""},{"Add":" if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) {"},{"Add":" bitD->ptr -= bitD->bitsConsumed >> 3;"},{"Add":" bitD->bitsConsumed &= 7;"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr);"},{"Add":" return BITv06_DStream_unfinished;"},{"Add":" }"},{"Add":" if (bitD->ptr == bitD->start) {"},{"Add":" if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BITv06_DStream_endOfBuffer;"},{"Add":" return BITv06_DStream_completed;"},{"Add":" }"},{"Add":" { U32 nbBytes = bitD->bitsConsumed >> 3;"},{"Add":" BITv06_DStream_status result = BITv06_DStream_unfinished;"},{"Add":" if (bitD->ptr - nbBytes < bitD->start) {"},{"Add":" nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */"},{"Add":" result = BITv06_DStream_endOfBuffer;"},{"Add":" }"},{"Add":" bitD->ptr -= nbBytes;"},{"Add":" bitD->bitsConsumed -= nbBytes*8;"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD) */"},{"Add":" return result;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"/*! BITv06_endOfDStream() :"},{"Add":"* @return Tells if DStream has exactly reached its end (all bits consumed)."},{"Add":"*/"},{"Add":"MEM_STATIC unsigned BITv06_endOfDStream(const BITv06_DStream_t* DStream)"},{"Add":"{"},{"Add":" return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));"},{"Add":"}"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* BITSTREAM_H_MODULE */"},{"Add":"/* ******************************************************************"},{"Add":" FSE : Finite State Entropy coder"},{"Add":" header file for static linking (only)"},{"Add":" Copyright (C) 2013-2015, Yann Collet"},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":"#ifndef FSEv06_STATIC_H"},{"Add":"#define FSEv06_STATIC_H"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* *****************************************"},{"Add":"* Static allocation"},{"Add":"*******************************************/"},{"Add":"/* FSE buffer bounds */"},{"Add":"#define FSEv06_NCOUNTBOUND 512"},{"Add":"#define FSEv06_BLOCKBOUND(size) (size + (size>>7))"},{"Add":"#define FSEv06_COMPRESSBOUND(size) (FSEv06_NCOUNTBOUND + FSEv06_BLOCKBOUND(size)) /* Macro version, useful for static allocation */"},{"Add":""},{"Add":"/* It is possible to statically allocate FSE CTable/DTable as a table of unsigned using below macros */"},{"Add":"#define FSEv06_DTABLE_SIZE_U32(maxTableLog) (1 + (1<= 1 (otherwise, result will be corrupted) */"},{"Add":""},{"Add":""},{"Add":"/* *****************************************"},{"Add":"* Implementation of inlined functions"},{"Add":"*******************************************/"},{"Add":""},{"Add":""},{"Add":"/* ====== Decompression ====== */"},{"Add":""},{"Add":"typedef struct {"},{"Add":" U16 tableLog;"},{"Add":" U16 fastMode;"},{"Add":"} FSEv06_DTableHeader; /* sizeof U32 */"},{"Add":""},{"Add":"typedef struct"},{"Add":"{"},{"Add":" unsigned short newState;"},{"Add":" unsigned char symbol;"},{"Add":" unsigned char nbBits;"},{"Add":"} FSEv06_decode_t; /* size == U32 */"},{"Add":""},{"Add":"MEM_STATIC void FSEv06_initDState(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD, const FSEv06_DTable* dt)"},{"Add":"{"},{"Add":" const void* ptr = dt;"},{"Add":" const FSEv06_DTableHeader* const DTableH = (const FSEv06_DTableHeader*)ptr;"},{"Add":" DStatePtr->state = BITv06_readBits(bitD, DTableH->tableLog);"},{"Add":" BITv06_reloadDStream(bitD);"},{"Add":" DStatePtr->table = dt + 1;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BYTE FSEv06_peekSymbol(const FSEv06_DState_t* DStatePtr)"},{"Add":"{"},{"Add":" FSEv06_decode_t const DInfo = ((const FSEv06_decode_t*)(DStatePtr->table))[DStatePtr->state];"},{"Add":" return DInfo.symbol;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void FSEv06_updateState(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD)"},{"Add":"{"},{"Add":" FSEv06_decode_t const DInfo = ((const FSEv06_decode_t*)(DStatePtr->table))[DStatePtr->state];"},{"Add":" U32 const nbBits = DInfo.nbBits;"},{"Add":" size_t const lowBits = BITv06_readBits(bitD, nbBits);"},{"Add":" DStatePtr->state = DInfo.newState + lowBits;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BYTE FSEv06_decodeSymbol(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD)"},{"Add":"{"},{"Add":" FSEv06_decode_t const DInfo = ((const FSEv06_decode_t*)(DStatePtr->table))[DStatePtr->state];"},{"Add":" U32 const nbBits = DInfo.nbBits;"},{"Add":" BYTE const symbol = DInfo.symbol;"},{"Add":" size_t const lowBits = BITv06_readBits(bitD, nbBits);"},{"Add":""},{"Add":" DStatePtr->state = DInfo.newState + lowBits;"},{"Add":" return symbol;"},{"Add":"}"},{"Add":""},{"Add":"/*! FSEv06_decodeSymbolFast() :"},{"Add":" unsafe, only works if no symbol has a probability > 50% */"},{"Add":"MEM_STATIC BYTE FSEv06_decodeSymbolFast(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD)"},{"Add":"{"},{"Add":" FSEv06_decode_t const DInfo = ((const FSEv06_decode_t*)(DStatePtr->table))[DStatePtr->state];"},{"Add":" U32 const nbBits = DInfo.nbBits;"},{"Add":" BYTE const symbol = DInfo.symbol;"},{"Add":" size_t const lowBits = BITv06_readBitsFast(bitD, nbBits);"},{"Add":""},{"Add":" DStatePtr->state = DInfo.newState + lowBits;"},{"Add":" return symbol;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"#ifndef FSEv06_COMMONDEFS_ONLY"},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Tuning parameters"},{"Add":"****************************************************************/"},{"Add":"/*!MEMORY_USAGE :"},{"Add":"* Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)"},{"Add":"* Increasing memory usage improves compression ratio"},{"Add":"* Reduced memory usage can improve speed, due to cache effect"},{"Add":"* Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */"},{"Add":"#define FSEv06_MAX_MEMORY_USAGE 14"},{"Add":"#define FSEv06_DEFAULT_MEMORY_USAGE 13"},{"Add":""},{"Add":"/*!FSEv06_MAX_SYMBOL_VALUE :"},{"Add":"* Maximum symbol value authorized."},{"Add":"* Required for proper stack allocation */"},{"Add":"#define FSEv06_MAX_SYMBOL_VALUE 255"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* template functions type & suffix"},{"Add":"****************************************************************/"},{"Add":"#define FSEv06_FUNCTION_TYPE BYTE"},{"Add":"#define FSEv06_FUNCTION_EXTENSION"},{"Add":"#define FSEv06_DECODE_TYPE FSEv06_decode_t"},{"Add":""},{"Add":""},{"Add":"#endif /* !FSEv06_COMMONDEFS_ONLY */"},{"Add":""},{"Add":""},{"Add":"/* ***************************************************************"},{"Add":"* Constants"},{"Add":"*****************************************************************/"},{"Add":"#define FSEv06_MAX_TABLELOG (FSEv06_MAX_MEMORY_USAGE-2)"},{"Add":"#define FSEv06_MAX_TABLESIZE (1U< FSEv06_TABLELOG_ABSOLUTE_MAX"},{"Add":"#error \"FSEv06_MAX_TABLELOG > FSEv06_TABLELOG_ABSOLUTE_MAX is not supported\""},{"Add":"#endif"},{"Add":""},{"Add":"#define FSEv06_TABLESTEP(tableSize) ((tableSize>>1) + (tableSize>>3) + 3)"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* FSEv06_STATIC_H */"},{"Add":"/*"},{"Add":" Common functions of New Generation Entropy library"},{"Add":" Copyright (C) 2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"*************************************************************************** */"},{"Add":""},{"Add":""},{"Add":"/*-****************************************"},{"Add":"* FSE Error Management"},{"Add":"******************************************/"},{"Add":"unsigned FSEv06_isError(size_t code) { return ERR_isError(code); }"},{"Add":""},{"Add":"const char* FSEv06_getErrorName(size_t code) { return ERR_getErrorName(code); }"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* HUF Error Management"},{"Add":"****************************************************************/"},{"Add":"static unsigned HUFv06_isError(size_t code) { return ERR_isError(code); }"},{"Add":""},{"Add":""},{"Add":"/*-**************************************************************"},{"Add":"* FSE NCount encoding-decoding"},{"Add":"****************************************************************/"},{"Add":"static short FSEv06_abs(short a) { return a<0 ? -a : a; }"},{"Add":""},{"Add":"size_t FSEv06_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,"},{"Add":" const void* headerBuffer, size_t hbSize)"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE*) headerBuffer;"},{"Add":" const BYTE* const iend = istart + hbSize;"},{"Add":" const BYTE* ip = istart;"},{"Add":" int nbBits;"},{"Add":" int remaining;"},{"Add":" int threshold;"},{"Add":" U32 bitStream;"},{"Add":" int bitCount;"},{"Add":" unsigned charnum = 0;"},{"Add":" int previous0 = 0;"},{"Add":""},{"Add":" if (hbSize < 4) return ERROR(srcSize_wrong);"},{"Add":" bitStream = MEM_readLE32(ip);"},{"Add":" nbBits = (bitStream & 0xF) + FSEv06_MIN_TABLELOG; /* extract tableLog */"},{"Add":" if (nbBits > FSEv06_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);"},{"Add":" bitStream >>= 4;"},{"Add":" bitCount = 4;"},{"Add":" *tableLogPtr = nbBits;"},{"Add":" remaining = (1<1) && (charnum<=*maxSVPtr)) {"},{"Add":" if (previous0) {"},{"Add":" unsigned n0 = charnum;"},{"Add":" while ((bitStream & 0xFFFF) == 0xFFFF) {"},{"Add":" n0+=24;"},{"Add":" if (ip < iend-5) {"},{"Add":" ip+=2;"},{"Add":" bitStream = MEM_readLE32(ip) >> bitCount;"},{"Add":" } else {"},{"Add":" bitStream >>= 16;"},{"Add":" bitCount+=16;"},{"Add":" } }"},{"Add":" while ((bitStream & 3) == 3) {"},{"Add":" n0+=3;"},{"Add":" bitStream>>=2;"},{"Add":" bitCount+=2;"},{"Add":" }"},{"Add":" n0 += bitStream & 3;"},{"Add":" bitCount += 2;"},{"Add":" if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);"},{"Add":" while (charnum < n0) normalizedCounter[charnum++] = 0;"},{"Add":" if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {"},{"Add":" ip += bitCount>>3;"},{"Add":" bitCount &= 7;"},{"Add":" bitStream = MEM_readLE32(ip) >> bitCount;"},{"Add":" }"},{"Add":" else"},{"Add":" bitStream >>= 2;"},{"Add":" }"},{"Add":" { short const max = (short)((2*threshold-1)-remaining);"},{"Add":" short count;"},{"Add":""},{"Add":" if ((bitStream & (threshold-1)) < (U32)max) {"},{"Add":" count = (short)(bitStream & (threshold-1));"},{"Add":" bitCount += nbBits-1;"},{"Add":" } else {"},{"Add":" count = (short)(bitStream & (2*threshold-1));"},{"Add":" if (count >= threshold) count -= max;"},{"Add":" bitCount += nbBits;"},{"Add":" }"},{"Add":""},{"Add":" count--; /* extra accuracy */"},{"Add":" remaining -= FSEv06_abs(count);"},{"Add":" normalizedCounter[charnum++] = count;"},{"Add":" previous0 = !count;"},{"Add":" while (remaining < threshold) {"},{"Add":" nbBits--;"},{"Add":" threshold >>= 1;"},{"Add":" }"},{"Add":""},{"Add":" if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {"},{"Add":" ip += bitCount>>3;"},{"Add":" bitCount &= 7;"},{"Add":" } else {"},{"Add":" bitCount -= (int)(8 * (iend - 4 - ip));"},{"Add":" ip = iend - 4;"},{"Add":" }"},{"Add":" bitStream = MEM_readLE32(ip) >> (bitCount & 31);"},{"Add":" } } /* while ((remaining>1) && (charnum<=*maxSVPtr)) */"},{"Add":" if (remaining != 1) return ERROR(GENERIC);"},{"Add":" *maxSVPtr = charnum-1;"},{"Add":""},{"Add":" ip += (bitCount+7)>>3;"},{"Add":" if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong);"},{"Add":" return ip-istart;"},{"Add":"}"},{"Add":"/* ******************************************************************"},{"Add":" FSE : Finite State Entropy decoder"},{"Add":" Copyright (C) 2013-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Compiler specifics"},{"Add":"****************************************************************/"},{"Add":"#ifdef _MSC_VER /* Visual Studio */"},{"Add":"# define FORCE_INLINE static __forceinline"},{"Add":"# include /* For Visual 2005 */"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"# pragma warning(disable : 4214) /* disable: C4214: non-int bitfields */"},{"Add":"#else"},{"Add":"# if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */"},{"Add":"# ifdef __GNUC__"},{"Add":"# define FORCE_INLINE static inline __attribute__((always_inline))"},{"Add":"# else"},{"Add":"# define FORCE_INLINE static inline"},{"Add":"# endif"},{"Add":"# else"},{"Add":"# define FORCE_INLINE static"},{"Add":"# endif /* __STDC_VERSION__ */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Error Management"},{"Add":"****************************************************************/"},{"Add":"#define FSEv06_isError ERR_isError"},{"Add":"#define FSEv06_STATIC_ASSERT(c) { enum { FSEv06_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Complex types"},{"Add":"****************************************************************/"},{"Add":"typedef U32 DTable_max_t[FSEv06_DTABLE_SIZE_U32(FSEv06_MAX_TABLELOG)];"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Templates"},{"Add":"****************************************************************/"},{"Add":"/*"},{"Add":" designed to be included"},{"Add":" for type-specific functions (template emulation in C)"},{"Add":" Objective is to write these functions only once, for improved maintenance"},{"Add":"*/"},{"Add":""},{"Add":"/* safety checks */"},{"Add":"#ifndef FSEv06_FUNCTION_EXTENSION"},{"Add":"# error \"FSEv06_FUNCTION_EXTENSION must be defined\""},{"Add":"#endif"},{"Add":"#ifndef FSEv06_FUNCTION_TYPE"},{"Add":"# error \"FSEv06_FUNCTION_TYPE must be defined\""},{"Add":"#endif"},{"Add":""},{"Add":"/* Function names */"},{"Add":"#define FSEv06_CAT(X,Y) X##Y"},{"Add":"#define FSEv06_FUNCTION_NAME(X,Y) FSEv06_CAT(X,Y)"},{"Add":"#define FSEv06_TYPE_NAME(X,Y) FSEv06_CAT(X,Y)"},{"Add":""},{"Add":""},{"Add":"/* Function templates */"},{"Add":"FSEv06_DTable* FSEv06_createDTable (unsigned tableLog)"},{"Add":"{"},{"Add":" if (tableLog > FSEv06_TABLELOG_ABSOLUTE_MAX) tableLog = FSEv06_TABLELOG_ABSOLUTE_MAX;"},{"Add":" return (FSEv06_DTable*)malloc( FSEv06_DTABLE_SIZE_U32(tableLog) * sizeof (U32) );"},{"Add":"}"},{"Add":""},{"Add":"void FSEv06_freeDTable (FSEv06_DTable* dt)"},{"Add":"{"},{"Add":" free(dt);"},{"Add":"}"},{"Add":""},{"Add":"size_t FSEv06_buildDTable(FSEv06_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)"},{"Add":"{"},{"Add":" void* const tdPtr = dt+1; /* because *dt is unsigned, 32-bits aligned on 32-bits */"},{"Add":" FSEv06_DECODE_TYPE* const tableDecode = (FSEv06_DECODE_TYPE*) (tdPtr);"},{"Add":" U16 symbolNext[FSEv06_MAX_SYMBOL_VALUE+1];"},{"Add":""},{"Add":" U32 const maxSV1 = maxSymbolValue + 1;"},{"Add":" U32 const tableSize = 1 << tableLog;"},{"Add":" U32 highThreshold = tableSize-1;"},{"Add":""},{"Add":" /* Sanity Checks */"},{"Add":" if (maxSymbolValue > FSEv06_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);"},{"Add":" if (tableLog > FSEv06_MAX_TABLELOG) return ERROR(tableLog_tooLarge);"},{"Add":""},{"Add":" /* Init, lay down lowprob symbols */"},{"Add":" { FSEv06_DTableHeader DTableH;"},{"Add":" DTableH.tableLog = (U16)tableLog;"},{"Add":" DTableH.fastMode = 1;"},{"Add":" { S16 const largeLimit= (S16)(1 << (tableLog-1));"},{"Add":" U32 s;"},{"Add":" for (s=0; s= largeLimit) DTableH.fastMode=0;"},{"Add":" symbolNext[s] = normalizedCounter[s];"},{"Add":" } } }"},{"Add":" memcpy(dt, &DTableH, sizeof(DTableH));"},{"Add":" }"},{"Add":""},{"Add":" /* Spread symbols */"},{"Add":" { U32 const tableMask = tableSize-1;"},{"Add":" U32 const step = FSEv06_TABLESTEP(tableSize);"},{"Add":" U32 s, position = 0;"},{"Add":" for (s=0; s highThreshold) position = (position + step) & tableMask; /* lowprob area */"},{"Add":" } }"},{"Add":""},{"Add":" if (position!=0) return ERROR(GENERIC); /* position must reach all cells once, otherwise normalizedCounter is incorrect */"},{"Add":" }"},{"Add":""},{"Add":" /* Build Decoding table */"},{"Add":" { U32 u;"},{"Add":" for (u=0; utableLog = 0;"},{"Add":" DTableH->fastMode = 0;"},{"Add":""},{"Add":" cell->newState = 0;"},{"Add":" cell->symbol = symbolValue;"},{"Add":" cell->nbBits = 0;"},{"Add":""},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t FSEv06_buildDTable_raw (FSEv06_DTable* dt, unsigned nbBits)"},{"Add":"{"},{"Add":" void* ptr = dt;"},{"Add":" FSEv06_DTableHeader* const DTableH = (FSEv06_DTableHeader*)ptr;"},{"Add":" void* dPtr = dt + 1;"},{"Add":" FSEv06_decode_t* const dinfo = (FSEv06_decode_t*)dPtr;"},{"Add":" const unsigned tableSize = 1 << nbBits;"},{"Add":" const unsigned tableMask = tableSize - 1;"},{"Add":" const unsigned maxSV1 = tableMask+1;"},{"Add":" unsigned s;"},{"Add":""},{"Add":" /* Sanity checks */"},{"Add":" if (nbBits < 1) return ERROR(GENERIC); /* min size */"},{"Add":""},{"Add":" /* Build Decoding Table */"},{"Add":" DTableH->tableLog = (U16)nbBits;"},{"Add":" DTableH->fastMode = 1;"},{"Add":" for (s=0; s sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" BITv06_reloadDStream(&bitD);"},{"Add":""},{"Add":" op[1] = FSEv06_GETSYMBOL(&state2);"},{"Add":""},{"Add":" if (FSEv06_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" { if (BITv06_reloadDStream(&bitD) > BITv06_DStream_unfinished) { op+=2; break; } }"},{"Add":""},{"Add":" op[2] = FSEv06_GETSYMBOL(&state1);"},{"Add":""},{"Add":" if (FSEv06_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" BITv06_reloadDStream(&bitD);"},{"Add":""},{"Add":" op[3] = FSEv06_GETSYMBOL(&state2);"},{"Add":" }"},{"Add":""},{"Add":" /* tail */"},{"Add":" /* note : BITv06_reloadDStream(&bitD) >= FSEv06_DStream_partiallyFilled; Ends at exactly BITv06_DStream_completed */"},{"Add":" while (1) {"},{"Add":" if (op>(omax-2)) return ERROR(dstSize_tooSmall);"},{"Add":""},{"Add":" *op++ = FSEv06_GETSYMBOL(&state1);"},{"Add":""},{"Add":" if (BITv06_reloadDStream(&bitD)==BITv06_DStream_overflow) {"},{"Add":" *op++ = FSEv06_GETSYMBOL(&state2);"},{"Add":" break;"},{"Add":" }"},{"Add":""},{"Add":" if (op>(omax-2)) return ERROR(dstSize_tooSmall);"},{"Add":""},{"Add":" *op++ = FSEv06_GETSYMBOL(&state2);"},{"Add":""},{"Add":" if (BITv06_reloadDStream(&bitD)==BITv06_DStream_overflow) {"},{"Add":" *op++ = FSEv06_GETSYMBOL(&state1);"},{"Add":" break;"},{"Add":" } }"},{"Add":""},{"Add":" return op-ostart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t FSEv06_decompress_usingDTable(void* dst, size_t originalSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const FSEv06_DTable* dt)"},{"Add":"{"},{"Add":" const void* ptr = dt;"},{"Add":" const FSEv06_DTableHeader* DTableH = (const FSEv06_DTableHeader*)ptr;"},{"Add":" const U32 fastMode = DTableH->fastMode;"},{"Add":""},{"Add":" /* select fast mode (static) */"},{"Add":" if (fastMode) return FSEv06_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);"},{"Add":" return FSEv06_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t FSEv06_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE*)cSrc;"},{"Add":" const BYTE* ip = istart;"},{"Add":" short counting[FSEv06_MAX_SYMBOL_VALUE+1];"},{"Add":" DTable_max_t dt; /* Static analyzer seems unable to understand this table will be properly initialized later */"},{"Add":" unsigned tableLog;"},{"Add":" unsigned maxSymbolValue = FSEv06_MAX_SYMBOL_VALUE;"},{"Add":""},{"Add":" if (cSrcSize<2) return ERROR(srcSize_wrong); /* too small input size */"},{"Add":""},{"Add":" /* normal FSE decoding mode */"},{"Add":" { size_t const NCountLength = FSEv06_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);"},{"Add":" if (FSEv06_isError(NCountLength)) return NCountLength;"},{"Add":" if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong); /* too small input size */"},{"Add":" ip += NCountLength;"},{"Add":" cSrcSize -= NCountLength;"},{"Add":" }"},{"Add":""},{"Add":" { size_t const errorCode = FSEv06_buildDTable (dt, counting, maxSymbolValue, tableLog);"},{"Add":" if (FSEv06_isError(errorCode)) return errorCode; }"},{"Add":""},{"Add":" return FSEv06_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt); /* always return, even if it is an error code */"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"#endif /* FSEv06_COMMONDEFS_ONLY */"},{"Add":"/* ******************************************************************"},{"Add":" Huffman coder, part of New Generation Entropy library"},{"Add":" header file"},{"Add":" Copyright (C) 2013-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":"****************************************************************** */"},{"Add":"#ifndef HUFv06_H"},{"Add":"#define HUFv06_H"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* ****************************************"},{"Add":"* HUF simple functions"},{"Add":"******************************************/"},{"Add":"size_t HUFv06_decompress(void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize);"},{"Add":"/*"},{"Add":"HUFv06_decompress() :"},{"Add":" Decompress HUF data from buffer 'cSrc', of size 'cSrcSize',"},{"Add":" into already allocated destination buffer 'dst', of size 'dstSize'."},{"Add":" `dstSize` : must be the **exact** size of original (uncompressed) data."},{"Add":" Note : in contrast with FSE, HUFv06_decompress can regenerate"},{"Add":" RLE (cSrcSize==1) and uncompressed (cSrcSize==dstSize) data,"},{"Add":" because it knows size to regenerate."},{"Add":" @return : size of regenerated data (== dstSize)"},{"Add":" or an error code, which can be tested using HUFv06_isError()"},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/* ****************************************"},{"Add":"* Tool functions"},{"Add":"******************************************/"},{"Add":"size_t HUFv06_compressBound(size_t size); /**< maximum compressed size */"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* HUFv06_H */"},{"Add":"/* ******************************************************************"},{"Add":" Huffman codec, part of New Generation Entropy library"},{"Add":" header file, for static linking only"},{"Add":" Copyright (C) 2013-2016, Yann Collet"},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":"****************************************************************** */"},{"Add":"#ifndef HUFv06_STATIC_H"},{"Add":"#define HUFv06_STATIC_H"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* ****************************************"},{"Add":"* Static allocation"},{"Add":"******************************************/"},{"Add":"/* HUF buffer bounds */"},{"Add":"#define HUFv06_CTABLEBOUND 129"},{"Add":"#define HUFv06_BLOCKBOUND(size) (size + (size>>8) + 8) /* only true if incompressible pre-filtered with fast heuristic */"},{"Add":"#define HUFv06_COMPRESSBOUND(size) (HUFv06_CTABLEBOUND + HUFv06_BLOCKBOUND(size)) /* Macro version, useful for static allocation */"},{"Add":""},{"Add":"/* static allocation of HUF's DTable */"},{"Add":"#define HUFv06_DTABLE_SIZE(maxTableLog) (1 + (1< HUFv06_ABSOLUTEMAX_TABLELOG)"},{"Add":"# error \"HUFv06_MAX_TABLELOG is too large !\""},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*! HUFv06_readStats() :"},{"Add":" Read compact Huffman tree, saved by HUFv06_writeCTable()."},{"Add":" `huffWeight` is destination buffer."},{"Add":" @return : size read from `src`"},{"Add":"*/"},{"Add":"MEM_STATIC size_t HUFv06_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,"},{"Add":" U32* nbSymbolsPtr, U32* tableLogPtr,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" U32 weightTotal;"},{"Add":" const BYTE* ip = (const BYTE*) src;"},{"Add":" size_t iSize;"},{"Add":" size_t oSize;"},{"Add":""},{"Add":" if (!srcSize) return ERROR(srcSize_wrong);"},{"Add":" iSize = ip[0];"},{"Add":" /* memset(huffWeight, 0, hwSize); */ /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" if (iSize >= 128) { /* special header */"},{"Add":" if (iSize >= (242)) { /* RLE */"},{"Add":" static U32 l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };"},{"Add":" oSize = l[iSize-242];"},{"Add":" memset(huffWeight, 1, hwSize);"},{"Add":" iSize = 0;"},{"Add":" }"},{"Add":" else { /* Incompressible */"},{"Add":" oSize = iSize - 127;"},{"Add":" iSize = ((oSize+1)/2);"},{"Add":" if (iSize+1 > srcSize) return ERROR(srcSize_wrong);"},{"Add":" if (oSize >= hwSize) return ERROR(corruption_detected);"},{"Add":" ip += 1;"},{"Add":" { U32 n;"},{"Add":" for (n=0; n> 4;"},{"Add":" huffWeight[n+1] = ip[n/2] & 15;"},{"Add":" } } } }"},{"Add":" else { /* header compressed with FSE (normal case) */"},{"Add":" if (iSize+1 > srcSize) return ERROR(srcSize_wrong);"},{"Add":" oSize = FSEv06_decompress(huffWeight, hwSize-1, ip+1, iSize); /* max (hwSize-1) values decoded, as last one is implied */"},{"Add":" if (FSEv06_isError(oSize)) return oSize;"},{"Add":" }"},{"Add":""},{"Add":" /* collect weight stats */"},{"Add":" memset(rankStats, 0, (HUFv06_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32));"},{"Add":" weightTotal = 0;"},{"Add":" { U32 n; for (n=0; n= HUFv06_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);"},{"Add":" rankStats[huffWeight[n]]++;"},{"Add":" weightTotal += (1 << huffWeight[n]) >> 1;"},{"Add":" } }"},{"Add":" if (weightTotal == 0) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* get last non-null symbol weight (implied, total must be 2^n) */"},{"Add":" { U32 const tableLog = BITv06_highbit32(weightTotal) + 1;"},{"Add":" if (tableLog > HUFv06_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);"},{"Add":" *tableLogPtr = tableLog;"},{"Add":" /* determine last weight */"},{"Add":" { U32 const total = 1 << tableLog;"},{"Add":" U32 const rest = total - weightTotal;"},{"Add":" U32 const verif = 1 << BITv06_highbit32(rest);"},{"Add":" U32 const lastWeight = BITv06_highbit32(rest) + 1;"},{"Add":" if (verif != rest) return ERROR(corruption_detected); /* last value must be a clean power of 2 */"},{"Add":" huffWeight[oSize] = (BYTE)lastWeight;"},{"Add":" rankStats[lastWeight]++;"},{"Add":" } }"},{"Add":""},{"Add":" /* check tree construction validity */"},{"Add":" if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected); /* by construction : at least 2 elts of rank 1, must be even */"},{"Add":""},{"Add":" /* results */"},{"Add":" *nbSymbolsPtr = (U32)(oSize+1);"},{"Add":" return iSize+1;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* HUFv06_STATIC_H */"},{"Add":"/* ******************************************************************"},{"Add":" Huffman decoder, part of New Generation Entropy library"},{"Add":" Copyright (C) 2013-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Compiler specifics"},{"Add":"****************************************************************/"},{"Add":"#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)"},{"Add":"/* inline is defined */"},{"Add":"#elif defined(_MSC_VER)"},{"Add":"# define inline __inline"},{"Add":"#else"},{"Add":"# define inline /* disable inline */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"#ifdef _MSC_VER /* Visual Studio */"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Error Management"},{"Add":"****************************************************************/"},{"Add":"#define HUFv06_STATIC_ASSERT(c) { enum { HUFv06_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* *******************************************************"},{"Add":"* HUF : Huffman block decompression"},{"Add":"*********************************************************/"},{"Add":"typedef struct { BYTE byte; BYTE nbBits; } HUFv06_DEltX2; /* single-symbol decoding */"},{"Add":""},{"Add":"typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUFv06_DEltX4; /* double-symbols decoding */"},{"Add":""},{"Add":"typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-***************************/"},{"Add":"/* single-symbol decoding */"},{"Add":"/*-***************************/"},{"Add":""},{"Add":"size_t HUFv06_readDTableX2 (U16* DTable, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" BYTE huffWeight[HUFv06_MAX_SYMBOL_VALUE + 1];"},{"Add":" U32 rankVal[HUFv06_ABSOLUTEMAX_TABLELOG + 1]; /* large enough for values from 0 to 16 */"},{"Add":" U32 tableLog = 0;"},{"Add":" size_t iSize;"},{"Add":" U32 nbSymbols = 0;"},{"Add":" U32 n;"},{"Add":" U32 nextRankStart;"},{"Add":" void* const dtPtr = DTable + 1;"},{"Add":" HUFv06_DEltX2* const dt = (HUFv06_DEltX2*)dtPtr;"},{"Add":""},{"Add":" HUFv06_STATIC_ASSERT(sizeof(HUFv06_DEltX2) == sizeof(U16)); /* if compilation fails here, assertion is false */"},{"Add":" /* memset(huffWeight, 0, sizeof(huffWeight)); */ /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" iSize = HUFv06_readStats(huffWeight, HUFv06_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);"},{"Add":" if (HUFv06_isError(iSize)) return iSize;"},{"Add":""},{"Add":" /* check result */"},{"Add":" if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge); /* DTable is too small */"},{"Add":" DTable[0] = (U16)tableLog; /* maybe should separate sizeof allocated DTable, from used size of DTable, in case of re-use */"},{"Add":""},{"Add":" /* Prepare ranks */"},{"Add":" nextRankStart = 0;"},{"Add":" for (n=1; n> 1;"},{"Add":" U32 i;"},{"Add":" HUFv06_DEltX2 D;"},{"Add":" D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);"},{"Add":" for (i = rankVal[w]; i < rankVal[w] + length; i++)"},{"Add":" dt[i] = D;"},{"Add":" rankVal[w] += length;"},{"Add":" }"},{"Add":""},{"Add":" return iSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static BYTE HUFv06_decodeSymbolX2(BITv06_DStream_t* Dstream, const HUFv06_DEltX2* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" const size_t val = BITv06_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */"},{"Add":" const BYTE c = dt[val].byte;"},{"Add":" BITv06_skipBits(Dstream, dt[val].nbBits);"},{"Add":" return c;"},{"Add":"}"},{"Add":""},{"Add":"#define HUFv06_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \\"},{"Add":" *ptr++ = HUFv06_decodeSymbolX2(DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUFv06_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits() || (HUFv06_MAX_TABLELOG<=12)) \\"},{"Add":" HUFv06_DECODE_SYMBOLX2_0(ptr, DStreamPtr)"},{"Add":""},{"Add":"#define HUFv06_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits()) \\"},{"Add":" HUFv06_DECODE_SYMBOLX2_0(ptr, DStreamPtr)"},{"Add":""},{"Add":"static inline size_t HUFv06_decodeStreamX2(BYTE* p, BITv06_DStream_t* const bitDPtr, BYTE* const pEnd, const HUFv06_DEltX2* const dt, const U32 dtLog)"},{"Add":"{"},{"Add":" BYTE* const pStart = p;"},{"Add":""},{"Add":" /* up to 4 symbols at a time */"},{"Add":" while ((BITv06_reloadDStream(bitDPtr) == BITv06_DStream_unfinished) && (p <= pEnd-4)) {"},{"Add":" HUFv06_DECODE_SYMBOLX2_2(p, bitDPtr);"},{"Add":" HUFv06_DECODE_SYMBOLX2_1(p, bitDPtr);"},{"Add":" HUFv06_DECODE_SYMBOLX2_2(p, bitDPtr);"},{"Add":" HUFv06_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":" }"},{"Add":""},{"Add":" /* closer to the end */"},{"Add":" while ((BITv06_reloadDStream(bitDPtr) == BITv06_DStream_unfinished) && (p < pEnd))"},{"Add":" HUFv06_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":""},{"Add":" /* no more data to retrieve from bitstream, hence no need to reload */"},{"Add":" while (p < pEnd)"},{"Add":" HUFv06_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":""},{"Add":" return pEnd-pStart;"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv06_decompress1X2_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const U16* DTable)"},{"Add":"{"},{"Add":" BYTE* op = (BYTE*)dst;"},{"Add":" BYTE* const oend = op + dstSize;"},{"Add":" const U32 dtLog = DTable[0];"},{"Add":" const void* dtPtr = DTable;"},{"Add":" const HUFv06_DEltX2* const dt = ((const HUFv06_DEltX2*)dtPtr)+1;"},{"Add":" BITv06_DStream_t bitD;"},{"Add":""},{"Add":" { size_t const errorCode = BITv06_initDStream(&bitD, cSrc, cSrcSize);"},{"Add":" if (HUFv06_isError(errorCode)) return errorCode; }"},{"Add":""},{"Add":" HUFv06_decodeStreamX2(op, &bitD, oend, dt, dtLog);"},{"Add":""},{"Add":" /* check */"},{"Add":" if (!BITv06_endOfDStream(&bitD)) return ERROR(corruption_detected);"},{"Add":""},{"Add":" return dstSize;"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv06_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUFv06_CREATE_STATIC_DTABLEX2(DTable, HUFv06_MAX_TABLELOG);"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":""},{"Add":" size_t const errorCode = HUFv06_readDTableX2 (DTable, cSrc, cSrcSize);"},{"Add":" if (HUFv06_isError(errorCode)) return errorCode;"},{"Add":" if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += errorCode;"},{"Add":" cSrcSize -= errorCode;"},{"Add":""},{"Add":" return HUFv06_decompress1X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t HUFv06_decompress4X2_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const U16* DTable)"},{"Add":"{"},{"Add":" /* Check */"},{"Add":" if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */"},{"Add":""},{"Add":" { const BYTE* const istart = (const BYTE*) cSrc;"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* const oend = ostart + dstSize;"},{"Add":" const void* const dtPtr = DTable;"},{"Add":" const HUFv06_DEltX2* const dt = ((const HUFv06_DEltX2*)dtPtr) +1;"},{"Add":" const U32 dtLog = DTable[0];"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" /* Init */"},{"Add":" BITv06_DStream_t bitD1;"},{"Add":" BITv06_DStream_t bitD2;"},{"Add":" BITv06_DStream_t bitD3;"},{"Add":" BITv06_DStream_t bitD4;"},{"Add":" const size_t length1 = MEM_readLE16(istart);"},{"Add":" const size_t length2 = MEM_readLE16(istart+2);"},{"Add":" const size_t length3 = MEM_readLE16(istart+4);"},{"Add":" size_t length4;"},{"Add":" const BYTE* const istart1 = istart + 6; /* jumpTable */"},{"Add":" const BYTE* const istart2 = istart1 + length1;"},{"Add":" const BYTE* const istart3 = istart2 + length2;"},{"Add":" const BYTE* const istart4 = istart3 + length3;"},{"Add":" const size_t segmentSize = (dstSize+3) / 4;"},{"Add":" BYTE* const opStart2 = ostart + segmentSize;"},{"Add":" BYTE* const opStart3 = opStart2 + segmentSize;"},{"Add":" BYTE* const opStart4 = opStart3 + segmentSize;"},{"Add":" BYTE* op1 = ostart;"},{"Add":" BYTE* op2 = opStart2;"},{"Add":" BYTE* op3 = opStart3;"},{"Add":" BYTE* op4 = opStart4;"},{"Add":" U32 endSignal;"},{"Add":""},{"Add":" length4 = cSrcSize - (length1 + length2 + length3 + 6);"},{"Add":" if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */"},{"Add":" errorCode = BITv06_initDStream(&bitD1, istart1, length1);"},{"Add":" if (HUFv06_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BITv06_initDStream(&bitD2, istart2, length2);"},{"Add":" if (HUFv06_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BITv06_initDStream(&bitD3, istart3, length3);"},{"Add":" if (HUFv06_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BITv06_initDStream(&bitD4, istart4, length4);"},{"Add":" if (HUFv06_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" /* 16-32 symbols per loop (4-8 symbols per stream) */"},{"Add":" endSignal = BITv06_reloadDStream(&bitD1) | BITv06_reloadDStream(&bitD2) | BITv06_reloadDStream(&bitD3) | BITv06_reloadDStream(&bitD4);"},{"Add":" for ( ; (endSignal==BITv06_DStream_unfinished) && (op4<(oend-7)) ; ) {"},{"Add":" HUFv06_DECODE_SYMBOLX2_2(op1, &bitD1);"},{"Add":" HUFv06_DECODE_SYMBOLX2_2(op2, &bitD2);"},{"Add":" HUFv06_DECODE_SYMBOLX2_2(op3, &bitD3);"},{"Add":" HUFv06_DECODE_SYMBOLX2_2(op4, &bitD4);"},{"Add":" HUFv06_DECODE_SYMBOLX2_1(op1, &bitD1);"},{"Add":" HUFv06_DECODE_SYMBOLX2_1(op2, &bitD2);"},{"Add":" HUFv06_DECODE_SYMBOLX2_1(op3, &bitD3);"},{"Add":" HUFv06_DECODE_SYMBOLX2_1(op4, &bitD4);"},{"Add":" HUFv06_DECODE_SYMBOLX2_2(op1, &bitD1);"},{"Add":" HUFv06_DECODE_SYMBOLX2_2(op2, &bitD2);"},{"Add":" HUFv06_DECODE_SYMBOLX2_2(op3, &bitD3);"},{"Add":" HUFv06_DECODE_SYMBOLX2_2(op4, &bitD4);"},{"Add":" HUFv06_DECODE_SYMBOLX2_0(op1, &bitD1);"},{"Add":" HUFv06_DECODE_SYMBOLX2_0(op2, &bitD2);"},{"Add":" HUFv06_DECODE_SYMBOLX2_0(op3, &bitD3);"},{"Add":" HUFv06_DECODE_SYMBOLX2_0(op4, &bitD4);"},{"Add":" endSignal = BITv06_reloadDStream(&bitD1) | BITv06_reloadDStream(&bitD2) | BITv06_reloadDStream(&bitD3) | BITv06_reloadDStream(&bitD4);"},{"Add":" }"},{"Add":""},{"Add":" /* check corruption */"},{"Add":" if (op1 > opStart2) return ERROR(corruption_detected);"},{"Add":" if (op2 > opStart3) return ERROR(corruption_detected);"},{"Add":" if (op3 > opStart4) return ERROR(corruption_detected);"},{"Add":" /* note : op4 supposed already verified within main loop */"},{"Add":""},{"Add":" /* finish bitStreams one by one */"},{"Add":" HUFv06_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);"},{"Add":" HUFv06_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);"},{"Add":" HUFv06_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);"},{"Add":" HUFv06_decodeStreamX2(op4, &bitD4, oend, dt, dtLog);"},{"Add":""},{"Add":" /* check */"},{"Add":" endSignal = BITv06_endOfDStream(&bitD1) & BITv06_endOfDStream(&bitD2) & BITv06_endOfDStream(&bitD3) & BITv06_endOfDStream(&bitD4);"},{"Add":" if (!endSignal) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* decoded size */"},{"Add":" return dstSize;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t HUFv06_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUFv06_CREATE_STATIC_DTABLEX2(DTable, HUFv06_MAX_TABLELOG);"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":""},{"Add":" size_t const errorCode = HUFv06_readDTableX2 (DTable, cSrc, cSrcSize);"},{"Add":" if (HUFv06_isError(errorCode)) return errorCode;"},{"Add":" if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += errorCode;"},{"Add":" cSrcSize -= errorCode;"},{"Add":""},{"Add":" return HUFv06_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/* *************************/"},{"Add":"/* double-symbols decoding */"},{"Add":"/* *************************/"},{"Add":""},{"Add":"static void HUFv06_fillDTableX4Level2(HUFv06_DEltX4* DTable, U32 sizeLog, const U32 consumed,"},{"Add":" const U32* rankValOrigin, const int minWeight,"},{"Add":" const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,"},{"Add":" U32 nbBitsBaseline, U16 baseSeq)"},{"Add":"{"},{"Add":" HUFv06_DEltX4 DElt;"},{"Add":" U32 rankVal[HUFv06_ABSOLUTEMAX_TABLELOG + 1];"},{"Add":""},{"Add":" /* get pre-calculated rankVal */"},{"Add":" memcpy(rankVal, rankValOrigin, sizeof(rankVal));"},{"Add":""},{"Add":" /* fill skipped values */"},{"Add":" if (minWeight>1) {"},{"Add":" U32 i, skipSize = rankVal[minWeight];"},{"Add":" MEM_writeLE16(&(DElt.sequence), baseSeq);"},{"Add":" DElt.nbBits = (BYTE)(consumed);"},{"Add":" DElt.length = 1;"},{"Add":" for (i = 0; i < skipSize; i++)"},{"Add":" DTable[i] = DElt;"},{"Add":" }"},{"Add":""},{"Add":" /* fill DTable */"},{"Add":" { U32 s; for (s=0; s= 1 */"},{"Add":""},{"Add":" rankVal[weight] += length;"},{"Add":" }}"},{"Add":"}"},{"Add":""},{"Add":"typedef U32 rankVal_t[HUFv06_ABSOLUTEMAX_TABLELOG][HUFv06_ABSOLUTEMAX_TABLELOG + 1];"},{"Add":""},{"Add":"static void HUFv06_fillDTableX4(HUFv06_DEltX4* DTable, const U32 targetLog,"},{"Add":" const sortedSymbol_t* sortedList, const U32 sortedListSize,"},{"Add":" const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,"},{"Add":" const U32 nbBitsBaseline)"},{"Add":"{"},{"Add":" U32 rankVal[HUFv06_ABSOLUTEMAX_TABLELOG + 1];"},{"Add":" const int scaleLog = nbBitsBaseline - targetLog; /* note : targetLog >= srcLog, hence scaleLog <= 1 */"},{"Add":" const U32 minBits = nbBitsBaseline - maxWeight;"},{"Add":" U32 s;"},{"Add":""},{"Add":" memcpy(rankVal, rankValOrigin, sizeof(rankVal));"},{"Add":""},{"Add":" /* fill DTable */"},{"Add":" for (s=0; s= minBits) { /* enough room for a second symbol */"},{"Add":" U32 sortedRank;"},{"Add":" int minWeight = nbBits + scaleLog;"},{"Add":" if (minWeight < 1) minWeight = 1;"},{"Add":" sortedRank = rankStart[minWeight];"},{"Add":" HUFv06_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,"},{"Add":" rankValOrigin[nbBits], minWeight,"},{"Add":" sortedList+sortedRank, sortedListSize-sortedRank,"},{"Add":" nbBitsBaseline, symbol);"},{"Add":" } else {"},{"Add":" HUFv06_DEltX4 DElt;"},{"Add":" MEM_writeLE16(&(DElt.sequence), symbol);"},{"Add":" DElt.nbBits = (BYTE)(nbBits);"},{"Add":" DElt.length = 1;"},{"Add":" { U32 u;"},{"Add":" const U32 end = start + length;"},{"Add":" for (u = start; u < end; u++) DTable[u] = DElt;"},{"Add":" } }"},{"Add":" rankVal[weight] += length;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv06_readDTableX4 (U32* DTable, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" BYTE weightList[HUFv06_MAX_SYMBOL_VALUE + 1];"},{"Add":" sortedSymbol_t sortedSymbol[HUFv06_MAX_SYMBOL_VALUE + 1];"},{"Add":" U32 rankStats[HUFv06_ABSOLUTEMAX_TABLELOG + 1] = { 0 };"},{"Add":" U32 rankStart0[HUFv06_ABSOLUTEMAX_TABLELOG + 2] = { 0 };"},{"Add":" U32* const rankStart = rankStart0+1;"},{"Add":" rankVal_t rankVal;"},{"Add":" U32 tableLog, maxW, sizeOfSort, nbSymbols;"},{"Add":" const U32 memLog = DTable[0];"},{"Add":" size_t iSize;"},{"Add":" void* dtPtr = DTable;"},{"Add":" HUFv06_DEltX4* const dt = ((HUFv06_DEltX4*)dtPtr) + 1;"},{"Add":""},{"Add":" HUFv06_STATIC_ASSERT(sizeof(HUFv06_DEltX4) == sizeof(U32)); /* if compilation fails here, assertion is false */"},{"Add":" if (memLog > HUFv06_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);"},{"Add":" /* memset(weightList, 0, sizeof(weightList)); */ /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" iSize = HUFv06_readStats(weightList, HUFv06_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);"},{"Add":" if (HUFv06_isError(iSize)) return iSize;"},{"Add":""},{"Add":" /* check result */"},{"Add":" if (tableLog > memLog) return ERROR(tableLog_tooLarge); /* DTable can't fit code depth */"},{"Add":""},{"Add":" /* find maxWeight */"},{"Add":" for (maxW = tableLog; rankStats[maxW]==0; maxW--) {} /* necessarily finds a solution before 0 */"},{"Add":""},{"Add":" /* Get start index of each weight */"},{"Add":" { U32 w, nextRankStart = 0;"},{"Add":" for (w=1; w> consumed;"},{"Add":" } } } }"},{"Add":""},{"Add":" HUFv06_fillDTableX4(dt, memLog,"},{"Add":" sortedSymbol, sizeOfSort,"},{"Add":" rankStart0, rankVal, maxW,"},{"Add":" tableLog+1);"},{"Add":""},{"Add":" return iSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static U32 HUFv06_decodeSymbolX4(void* op, BITv06_DStream_t* DStream, const HUFv06_DEltX4* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" const size_t val = BITv06_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */"},{"Add":" memcpy(op, dt+val, 2);"},{"Add":" BITv06_skipBits(DStream, dt[val].nbBits);"},{"Add":" return dt[val].length;"},{"Add":"}"},{"Add":""},{"Add":"static U32 HUFv06_decodeLastSymbolX4(void* op, BITv06_DStream_t* DStream, const HUFv06_DEltX4* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" const size_t val = BITv06_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */"},{"Add":" memcpy(op, dt+val, 1);"},{"Add":" if (dt[val].length==1) BITv06_skipBits(DStream, dt[val].nbBits);"},{"Add":" else {"},{"Add":" if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) {"},{"Add":" BITv06_skipBits(DStream, dt[val].nbBits);"},{"Add":" if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))"},{"Add":" DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8); /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */"},{"Add":" } }"},{"Add":" return 1;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"#define HUFv06_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \\"},{"Add":" ptr += HUFv06_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUFv06_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits() || (HUFv06_MAX_TABLELOG<=12)) \\"},{"Add":" ptr += HUFv06_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUFv06_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits()) \\"},{"Add":" ptr += HUFv06_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"static inline size_t HUFv06_decodeStreamX4(BYTE* p, BITv06_DStream_t* bitDPtr, BYTE* const pEnd, const HUFv06_DEltX4* const dt, const U32 dtLog)"},{"Add":"{"},{"Add":" BYTE* const pStart = p;"},{"Add":""},{"Add":" /* up to 8 symbols at a time */"},{"Add":" while ((BITv06_reloadDStream(bitDPtr) == BITv06_DStream_unfinished) && (p < pEnd-7)) {"},{"Add":" HUFv06_DECODE_SYMBOLX4_2(p, bitDPtr);"},{"Add":" HUFv06_DECODE_SYMBOLX4_1(p, bitDPtr);"},{"Add":" HUFv06_DECODE_SYMBOLX4_2(p, bitDPtr);"},{"Add":" HUFv06_DECODE_SYMBOLX4_0(p, bitDPtr);"},{"Add":" }"},{"Add":""},{"Add":" /* closer to the end */"},{"Add":" while ((BITv06_reloadDStream(bitDPtr) == BITv06_DStream_unfinished) && (p <= pEnd-2))"},{"Add":" HUFv06_DECODE_SYMBOLX4_0(p, bitDPtr);"},{"Add":""},{"Add":" while (p <= pEnd-2)"},{"Add":" HUFv06_DECODE_SYMBOLX4_0(p, bitDPtr); /* no need to reload : reached the end of DStream */"},{"Add":""},{"Add":" if (p < pEnd)"},{"Add":" p += HUFv06_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);"},{"Add":""},{"Add":" return p-pStart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t HUFv06_decompress1X4_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const U32* DTable)"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE*) cSrc;"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* const oend = ostart + dstSize;"},{"Add":""},{"Add":" const U32 dtLog = DTable[0];"},{"Add":" const void* const dtPtr = DTable;"},{"Add":" const HUFv06_DEltX4* const dt = ((const HUFv06_DEltX4*)dtPtr) +1;"},{"Add":""},{"Add":" /* Init */"},{"Add":" BITv06_DStream_t bitD;"},{"Add":" { size_t const errorCode = BITv06_initDStream(&bitD, istart, cSrcSize);"},{"Add":" if (HUFv06_isError(errorCode)) return errorCode; }"},{"Add":""},{"Add":" /* decode */"},{"Add":" HUFv06_decodeStreamX4(ostart, &bitD, oend, dt, dtLog);"},{"Add":""},{"Add":" /* check */"},{"Add":" if (!BITv06_endOfDStream(&bitD)) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* decoded size */"},{"Add":" return dstSize;"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv06_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUFv06_CREATE_STATIC_DTABLEX4(DTable, HUFv06_MAX_TABLELOG);"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":""},{"Add":" size_t const hSize = HUFv06_readDTableX4 (DTable, cSrc, cSrcSize);"},{"Add":" if (HUFv06_isError(hSize)) return hSize;"},{"Add":" if (hSize >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += hSize;"},{"Add":" cSrcSize -= hSize;"},{"Add":""},{"Add":" return HUFv06_decompress1X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv06_decompress4X4_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const U32* DTable)"},{"Add":"{"},{"Add":" if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */"},{"Add":""},{"Add":" { const BYTE* const istart = (const BYTE*) cSrc;"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* const oend = ostart + dstSize;"},{"Add":" const void* const dtPtr = DTable;"},{"Add":" const HUFv06_DEltX4* const dt = ((const HUFv06_DEltX4*)dtPtr) +1;"},{"Add":" const U32 dtLog = DTable[0];"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" /* Init */"},{"Add":" BITv06_DStream_t bitD1;"},{"Add":" BITv06_DStream_t bitD2;"},{"Add":" BITv06_DStream_t bitD3;"},{"Add":" BITv06_DStream_t bitD4;"},{"Add":" const size_t length1 = MEM_readLE16(istart);"},{"Add":" const size_t length2 = MEM_readLE16(istart+2);"},{"Add":" const size_t length3 = MEM_readLE16(istart+4);"},{"Add":" size_t length4;"},{"Add":" const BYTE* const istart1 = istart + 6; /* jumpTable */"},{"Add":" const BYTE* const istart2 = istart1 + length1;"},{"Add":" const BYTE* const istart3 = istart2 + length2;"},{"Add":" const BYTE* const istart4 = istart3 + length3;"},{"Add":" const size_t segmentSize = (dstSize+3) / 4;"},{"Add":" BYTE* const opStart2 = ostart + segmentSize;"},{"Add":" BYTE* const opStart3 = opStart2 + segmentSize;"},{"Add":" BYTE* const opStart4 = opStart3 + segmentSize;"},{"Add":" BYTE* op1 = ostart;"},{"Add":" BYTE* op2 = opStart2;"},{"Add":" BYTE* op3 = opStart3;"},{"Add":" BYTE* op4 = opStart4;"},{"Add":" U32 endSignal;"},{"Add":""},{"Add":" length4 = cSrcSize - (length1 + length2 + length3 + 6);"},{"Add":" if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */"},{"Add":" errorCode = BITv06_initDStream(&bitD1, istart1, length1);"},{"Add":" if (HUFv06_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BITv06_initDStream(&bitD2, istart2, length2);"},{"Add":" if (HUFv06_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BITv06_initDStream(&bitD3, istart3, length3);"},{"Add":" if (HUFv06_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BITv06_initDStream(&bitD4, istart4, length4);"},{"Add":" if (HUFv06_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" /* 16-32 symbols per loop (4-8 symbols per stream) */"},{"Add":" endSignal = BITv06_reloadDStream(&bitD1) | BITv06_reloadDStream(&bitD2) | BITv06_reloadDStream(&bitD3) | BITv06_reloadDStream(&bitD4);"},{"Add":" for ( ; (endSignal==BITv06_DStream_unfinished) && (op4<(oend-7)) ; ) {"},{"Add":" HUFv06_DECODE_SYMBOLX4_2(op1, &bitD1);"},{"Add":" HUFv06_DECODE_SYMBOLX4_2(op2, &bitD2);"},{"Add":" HUFv06_DECODE_SYMBOLX4_2(op3, &bitD3);"},{"Add":" HUFv06_DECODE_SYMBOLX4_2(op4, &bitD4);"},{"Add":" HUFv06_DECODE_SYMBOLX4_1(op1, &bitD1);"},{"Add":" HUFv06_DECODE_SYMBOLX4_1(op2, &bitD2);"},{"Add":" HUFv06_DECODE_SYMBOLX4_1(op3, &bitD3);"},{"Add":" HUFv06_DECODE_SYMBOLX4_1(op4, &bitD4);"},{"Add":" HUFv06_DECODE_SYMBOLX4_2(op1, &bitD1);"},{"Add":" HUFv06_DECODE_SYMBOLX4_2(op2, &bitD2);"},{"Add":" HUFv06_DECODE_SYMBOLX4_2(op3, &bitD3);"},{"Add":" HUFv06_DECODE_SYMBOLX4_2(op4, &bitD4);"},{"Add":" HUFv06_DECODE_SYMBOLX4_0(op1, &bitD1);"},{"Add":" HUFv06_DECODE_SYMBOLX4_0(op2, &bitD2);"},{"Add":" HUFv06_DECODE_SYMBOLX4_0(op3, &bitD3);"},{"Add":" HUFv06_DECODE_SYMBOLX4_0(op4, &bitD4);"},{"Add":""},{"Add":" endSignal = BITv06_reloadDStream(&bitD1) | BITv06_reloadDStream(&bitD2) | BITv06_reloadDStream(&bitD3) | BITv06_reloadDStream(&bitD4);"},{"Add":" }"},{"Add":""},{"Add":" /* check corruption */"},{"Add":" if (op1 > opStart2) return ERROR(corruption_detected);"},{"Add":" if (op2 > opStart3) return ERROR(corruption_detected);"},{"Add":" if (op3 > opStart4) return ERROR(corruption_detected);"},{"Add":" /* note : op4 supposed already verified within main loop */"},{"Add":""},{"Add":" /* finish bitStreams one by one */"},{"Add":" HUFv06_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);"},{"Add":" HUFv06_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);"},{"Add":" HUFv06_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);"},{"Add":" HUFv06_decodeStreamX4(op4, &bitD4, oend, dt, dtLog);"},{"Add":""},{"Add":" /* check */"},{"Add":" endSignal = BITv06_endOfDStream(&bitD1) & BITv06_endOfDStream(&bitD2) & BITv06_endOfDStream(&bitD3) & BITv06_endOfDStream(&bitD4);"},{"Add":" if (!endSignal) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* decoded size */"},{"Add":" return dstSize;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t HUFv06_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUFv06_CREATE_STATIC_DTABLEX4(DTable, HUFv06_MAX_TABLELOG);"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":""},{"Add":" size_t hSize = HUFv06_readDTableX4 (DTable, cSrc, cSrcSize);"},{"Add":" if (HUFv06_isError(hSize)) return hSize;"},{"Add":" if (hSize >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += hSize;"},{"Add":" cSrcSize -= hSize;"},{"Add":""},{"Add":" return HUFv06_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* ********************************/"},{"Add":"/* Generic decompression selector */"},{"Add":"/* ********************************/"},{"Add":""},{"Add":"typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;"},{"Add":"static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] ="},{"Add":"{"},{"Add":" /* single, double, quad */"},{"Add":" {{0,0}, {1,1}, {2,2}}, /* Q==0 : impossible */"},{"Add":" {{0,0}, {1,1}, {2,2}}, /* Q==1 : impossible */"},{"Add":" {{ 38,130}, {1313, 74}, {2151, 38}}, /* Q == 2 : 12-18% */"},{"Add":" {{ 448,128}, {1353, 74}, {2238, 41}}, /* Q == 3 : 18-25% */"},{"Add":" {{ 556,128}, {1353, 74}, {2238, 47}}, /* Q == 4 : 25-32% */"},{"Add":" {{ 714,128}, {1418, 74}, {2436, 53}}, /* Q == 5 : 32-38% */"},{"Add":" {{ 883,128}, {1437, 74}, {2464, 61}}, /* Q == 6 : 38-44% */"},{"Add":" {{ 897,128}, {1515, 75}, {2622, 68}}, /* Q == 7 : 44-50% */"},{"Add":" {{ 926,128}, {1613, 75}, {2730, 75}}, /* Q == 8 : 50-56% */"},{"Add":" {{ 947,128}, {1729, 77}, {3359, 77}}, /* Q == 9 : 56-62% */"},{"Add":" {{1107,128}, {2083, 81}, {4006, 84}}, /* Q ==10 : 62-69% */"},{"Add":" {{1177,128}, {2379, 87}, {4785, 88}}, /* Q ==11 : 69-75% */"},{"Add":" {{1242,128}, {2415, 93}, {5155, 84}}, /* Q ==12 : 75-81% */"},{"Add":" {{1349,128}, {2644,106}, {5260,106}}, /* Q ==13 : 81-87% */"},{"Add":" {{1455,128}, {2422,124}, {4174,124}}, /* Q ==14 : 87-93% */"},{"Add":" {{ 722,128}, {1891,145}, {1936,146}}, /* Q ==15 : 93-99% */"},{"Add":"};"},{"Add":""},{"Add":"typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);"},{"Add":""},{"Add":"size_t HUFv06_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" static const decompressionAlgo decompress[3] = { HUFv06_decompress4X2, HUFv06_decompress4X4, NULL };"},{"Add":" U32 Dtime[3]; /* decompression time estimation */"},{"Add":""},{"Add":" /* validation checks */"},{"Add":" if (dstSize == 0) return ERROR(dstSize_tooSmall);"},{"Add":" if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */"},{"Add":" if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */"},{"Add":" if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */"},{"Add":""},{"Add":" /* decoder timing evaluation */"},{"Add":" { U32 const Q = (U32)(cSrcSize * 16 / dstSize); /* Q < 16 since dstSize > cSrcSize */"},{"Add":" U32 const D256 = (U32)(dstSize >> 8);"},{"Add":" U32 n; for (n=0; n<3; n++)"},{"Add":" Dtime[n] = algoTime[Q][n].tableTime + (algoTime[Q][n].decode256Time * D256);"},{"Add":" }"},{"Add":""},{"Add":" Dtime[1] += Dtime[1] >> 4; Dtime[2] += Dtime[2] >> 3; /* advantage to algorithms using less memory, for cache eviction */"},{"Add":""},{"Add":" { U32 algoNb = 0;"},{"Add":" if (Dtime[1] < Dtime[0]) algoNb = 1;"},{"Add":" /* if (Dtime[2] < Dtime[algoNb]) algoNb = 2; */ /* current speed of HUFv06_decompress4X6 is not good */"},{"Add":" return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);"},{"Add":" }"},{"Add":""},{"Add":" /* return HUFv06_decompress4X2(dst, dstSize, cSrc, cSrcSize); */ /* multi-streams single-symbol decoding */"},{"Add":" /* return HUFv06_decompress4X4(dst, dstSize, cSrc, cSrcSize); */ /* multi-streams double-symbols decoding */"},{"Add":" /* return HUFv06_decompress4X6(dst, dstSize, cSrc, cSrcSize); */ /* multi-streams quad-symbols decoding */"},{"Add":"}"},{"Add":"/*"},{"Add":" Common functions of Zstd compression library"},{"Add":" Copyright (C) 2015-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - zstd homepage : http://www.zstd.net/"},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/*-****************************************"},{"Add":"* Version"},{"Add":"******************************************/"},{"Add":""},{"Add":"/*-****************************************"},{"Add":"* ZSTD Error Management"},{"Add":"******************************************/"},{"Add":"/*! ZSTDv06_isError() :"},{"Add":"* tells if a return value is an error code */"},{"Add":"unsigned ZSTDv06_isError(size_t code) { return ERR_isError(code); }"},{"Add":""},{"Add":"/*! ZSTDv06_getErrorName() :"},{"Add":"* provides error code string from function result (useful for debugging) */"},{"Add":"const char* ZSTDv06_getErrorName(size_t code) { return ERR_getErrorName(code); }"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* ZBUFF Error Management"},{"Add":"****************************************************************/"},{"Add":"unsigned ZBUFFv06_isError(size_t errorCode) { return ERR_isError(errorCode); }"},{"Add":""},{"Add":"const char* ZBUFFv06_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }"},{"Add":"/*"},{"Add":" zstd - standard compression library"},{"Add":" Copyright (C) 2014-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - zstd homepage : http://www.zstd.net"},{"Add":"*/"},{"Add":""},{"Add":"/* ***************************************************************"},{"Add":"* Tuning parameters"},{"Add":"*****************************************************************/"},{"Add":"/*!"},{"Add":" * HEAPMODE :"},{"Add":" * Select how default decompression function ZSTDv06_decompress() will allocate memory,"},{"Add":" * in memory stack (0), or in memory heap (1, requires malloc())"},{"Add":" */"},{"Add":"#ifndef ZSTDv06_HEAPMODE"},{"Add":"# define ZSTDv06_HEAPMODE 1"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-*******************************************************"},{"Add":"* Compiler specifics"},{"Add":"*********************************************************/"},{"Add":"#ifdef _MSC_VER /* Visual Studio */"},{"Add":"# include /* For Visual 2005 */"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"# pragma warning(disable : 4324) /* disable: C4324: padded structure */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*-*************************************"},{"Add":"* Macros"},{"Add":"***************************************/"},{"Add":"#define ZSTDv06_isError ERR_isError /* for inlining */"},{"Add":"#define FSEv06_isError ERR_isError"},{"Add":"#define HUFv06_isError ERR_isError"},{"Add":""},{"Add":""},{"Add":"/*_*******************************************************"},{"Add":"* Memory operations"},{"Add":"**********************************************************/"},{"Add":"static void ZSTDv06_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }"},{"Add":""},{"Add":""},{"Add":"/*-*************************************************************"},{"Add":"* Context management"},{"Add":"***************************************************************/"},{"Add":"typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,"},{"Add":" ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock } ZSTDv06_dStage;"},{"Add":""},{"Add":"struct ZSTDv06_DCtx_s"},{"Add":"{"},{"Add":" FSEv06_DTable LLTable[FSEv06_DTABLE_SIZE_U32(LLFSELog)];"},{"Add":" FSEv06_DTable OffTable[FSEv06_DTABLE_SIZE_U32(OffFSELog)];"},{"Add":" FSEv06_DTable MLTable[FSEv06_DTABLE_SIZE_U32(MLFSELog)];"},{"Add":" unsigned hufTableX4[HUFv06_DTABLE_SIZE(HufLog)];"},{"Add":" const void* previousDstEnd;"},{"Add":" const void* base;"},{"Add":" const void* vBase;"},{"Add":" const void* dictEnd;"},{"Add":" size_t expected;"},{"Add":" size_t headerSize;"},{"Add":" ZSTDv06_frameParams fParams;"},{"Add":" blockType_t bType; /* used in ZSTDv06_decompressContinue(), to transfer blockType between header decoding and block decoding stages */"},{"Add":" ZSTDv06_dStage stage;"},{"Add":" U32 flagRepeatTable;"},{"Add":" const BYTE* litPtr;"},{"Add":" size_t litSize;"},{"Add":" BYTE litBuffer[ZSTDv06_BLOCKSIZE_MAX + WILDCOPY_OVERLENGTH];"},{"Add":" BYTE headerBuffer[ZSTDv06_FRAMEHEADERSIZE_MAX];"},{"Add":"}; /* typedef'd to ZSTDv06_DCtx within \"zstd_static.h\" */"},{"Add":""},{"Add":"size_t ZSTDv06_sizeofDCtx (void); /* Hidden declaration */"},{"Add":"size_t ZSTDv06_sizeofDCtx (void) { return sizeof(ZSTDv06_DCtx); }"},{"Add":""},{"Add":"size_t ZSTDv06_decompressBegin(ZSTDv06_DCtx* dctx)"},{"Add":"{"},{"Add":" dctx->expected = ZSTDv06_frameHeaderSize_min;"},{"Add":" dctx->stage = ZSTDds_getFrameHeaderSize;"},{"Add":" dctx->previousDstEnd = NULL;"},{"Add":" dctx->base = NULL;"},{"Add":" dctx->vBase = NULL;"},{"Add":" dctx->dictEnd = NULL;"},{"Add":" dctx->hufTableX4[0] = HufLog;"},{"Add":" dctx->flagRepeatTable = 0;"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"ZSTDv06_DCtx* ZSTDv06_createDCtx(void)"},{"Add":"{"},{"Add":" ZSTDv06_DCtx* dctx = (ZSTDv06_DCtx*)malloc(sizeof(ZSTDv06_DCtx));"},{"Add":" if (dctx==NULL) return NULL;"},{"Add":" ZSTDv06_decompressBegin(dctx);"},{"Add":" return dctx;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTDv06_freeDCtx(ZSTDv06_DCtx* dctx)"},{"Add":"{"},{"Add":" free(dctx);"},{"Add":" return 0; /* reserved as a potential error code in the future */"},{"Add":"}"},{"Add":""},{"Add":"void ZSTDv06_copyDCtx(ZSTDv06_DCtx* dstDCtx, const ZSTDv06_DCtx* srcDCtx)"},{"Add":"{"},{"Add":" memcpy(dstDCtx, srcDCtx,"},{"Add":" sizeof(ZSTDv06_DCtx) - (ZSTDv06_BLOCKSIZE_MAX+WILDCOPY_OVERLENGTH + ZSTDv06_frameHeaderSize_max)); /* no need to copy workspace */"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*-*************************************************************"},{"Add":"* Decompression section"},{"Add":"***************************************************************/"},{"Add":""},{"Add":"/* Frame format description"},{"Add":" Frame Header - [ Block Header - Block ] - Frame End"},{"Add":" 1) Frame Header"},{"Add":" - 4 bytes - Magic Number : ZSTDv06_MAGICNUMBER (defined within zstd_static.h)"},{"Add":" - 1 byte - Frame Descriptor"},{"Add":" 2) Block Header"},{"Add":" - 3 bytes, starting with a 2-bits descriptor"},{"Add":" Uncompressed, Compressed, Frame End, unused"},{"Add":" 3) Block"},{"Add":" See Block Format Description"},{"Add":" 4) Frame End"},{"Add":" - 3 bytes, compatible with Block Header"},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/* Frame descriptor"},{"Add":""},{"Add":" 1 byte, using :"},{"Add":" bit 0-3 : windowLog - ZSTDv06_WINDOWLOG_ABSOLUTEMIN (see zstd_internal.h)"},{"Add":" bit 4 : minmatch 4(0) or 3(1)"},{"Add":" bit 5 : reserved (must be zero)"},{"Add":" bit 6-7 : Frame content size : unknown, 1 byte, 2 bytes, 8 bytes"},{"Add":""},{"Add":" Optional : content size (0, 1, 2 or 8 bytes)"},{"Add":" 0 : unknown"},{"Add":" 1 : 0-255 bytes"},{"Add":" 2 : 256 - 65535+256"},{"Add":" 8 : up to 16 exa"},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/* Compressed Block, format description"},{"Add":""},{"Add":" Block = Literal Section - Sequences Section"},{"Add":" Prerequisite : size of (compressed) block, maximum size of regenerated data"},{"Add":""},{"Add":" 1) Literal Section"},{"Add":""},{"Add":" 1.1) Header : 1-5 bytes"},{"Add":" flags: 2 bits"},{"Add":" 00 compressed by Huff0"},{"Add":" 01 unused"},{"Add":" 10 is Raw (uncompressed)"},{"Add":" 11 is Rle"},{"Add":" Note : using 01 => Huff0 with precomputed table ?"},{"Add":" Note : delta map ? => compressed ?"},{"Add":""},{"Add":" 1.1.1) Huff0-compressed literal block : 3-5 bytes"},{"Add":" srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream"},{"Add":" srcSize < 1 KB => 3 bytes (2-2-10-10)"},{"Add":" srcSize < 16KB => 4 bytes (2-2-14-14)"},{"Add":" else => 5 bytes (2-2-18-18)"},{"Add":" big endian convention"},{"Add":""},{"Add":" 1.1.2) Raw (uncompressed) literal block header : 1-3 bytes"},{"Add":" size : 5 bits: (IS_RAW<<6) + (0<<4) + size"},{"Add":" 12 bits: (IS_RAW<<6) + (2<<4) + (size>>8)"},{"Add":" size&255"},{"Add":" 20 bits: (IS_RAW<<6) + (3<<4) + (size>>16)"},{"Add":" size>>8&255"},{"Add":" size&255"},{"Add":""},{"Add":" 1.1.3) Rle (repeated single byte) literal block header : 1-3 bytes"},{"Add":" size : 5 bits: (IS_RLE<<6) + (0<<4) + size"},{"Add":" 12 bits: (IS_RLE<<6) + (2<<4) + (size>>8)"},{"Add":" size&255"},{"Add":" 20 bits: (IS_RLE<<6) + (3<<4) + (size>>16)"},{"Add":" size>>8&255"},{"Add":" size&255"},{"Add":""},{"Add":" 1.1.4) Huff0-compressed literal block, using precomputed CTables : 3-5 bytes"},{"Add":" srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream"},{"Add":" srcSize < 1 KB => 3 bytes (2-2-10-10)"},{"Add":" srcSize < 16KB => 4 bytes (2-2-14-14)"},{"Add":" else => 5 bytes (2-2-18-18)"},{"Add":" big endian convention"},{"Add":""},{"Add":" 1- CTable available (stored into workspace ?)"},{"Add":" 2- Small input (fast heuristic ? Full comparison ? depend on clevel ?)"},{"Add":""},{"Add":""},{"Add":" 1.2) Literal block content"},{"Add":""},{"Add":" 1.2.1) Huff0 block, using sizes from header"},{"Add":" See Huff0 format"},{"Add":""},{"Add":" 1.2.2) Huff0 block, using prepared table"},{"Add":""},{"Add":" 1.2.3) Raw content"},{"Add":""},{"Add":" 1.2.4) single byte"},{"Add":""},{"Add":""},{"Add":" 2) Sequences section"},{"Add":" TO DO"},{"Add":"*/"},{"Add":""},{"Add":"/** ZSTDv06_frameHeaderSize() :"},{"Add":"* srcSize must be >= ZSTDv06_frameHeaderSize_min."},{"Add":"* @return : size of the Frame Header */"},{"Add":"static size_t ZSTDv06_frameHeaderSize(const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" if (srcSize < ZSTDv06_frameHeaderSize_min) return ERROR(srcSize_wrong);"},{"Add":" { U32 const fcsId = (((const BYTE*)src)[4]) >> 6;"},{"Add":" return ZSTDv06_frameHeaderSize_min + ZSTDv06_fcs_fieldSize[fcsId]; }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/** ZSTDv06_getFrameParams() :"},{"Add":"* decode Frame Header, or provide expected `srcSize`."},{"Add":"* @return : 0, `fparamsPtr` is correctly filled,"},{"Add":"* >0, `srcSize` is too small, result is expected `srcSize`,"},{"Add":"* or an error code, which can be tested using ZSTDv06_isError() */"},{"Add":"size_t ZSTDv06_getFrameParams(ZSTDv06_frameParams* fparamsPtr, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":""},{"Add":" if (srcSize < ZSTDv06_frameHeaderSize_min) return ZSTDv06_frameHeaderSize_min;"},{"Add":" if (MEM_readLE32(src) != ZSTDv06_MAGICNUMBER) return ERROR(prefix_unknown);"},{"Add":""},{"Add":" /* ensure there is enough `srcSize` to fully read/decode frame header */"},{"Add":" { size_t const fhsize = ZSTDv06_frameHeaderSize(src, srcSize);"},{"Add":" if (srcSize < fhsize) return fhsize; }"},{"Add":""},{"Add":" memset(fparamsPtr, 0, sizeof(*fparamsPtr));"},{"Add":" { BYTE const frameDesc = ip[4];"},{"Add":" fparamsPtr->windowLog = (frameDesc & 0xF) + ZSTDv06_WINDOWLOG_ABSOLUTEMIN;"},{"Add":" if ((frameDesc & 0x20) != 0) return ERROR(frameParameter_unsupported); /* reserved 1 bit */"},{"Add":" switch(frameDesc >> 6) /* fcsId */"},{"Add":" {"},{"Add":" default: /* impossible */"},{"Add":" case 0 : fparamsPtr->frameContentSize = 0; break;"},{"Add":" case 1 : fparamsPtr->frameContentSize = ip[5]; break;"},{"Add":" case 2 : fparamsPtr->frameContentSize = MEM_readLE16(ip+5)+256; break;"},{"Add":" case 3 : fparamsPtr->frameContentSize = MEM_readLE64(ip+5); break;"},{"Add":" } }"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/** ZSTDv06_decodeFrameHeader() :"},{"Add":"* `srcSize` must be the size provided by ZSTDv06_frameHeaderSize()."},{"Add":"* @return : 0 if success, or an error code, which can be tested using ZSTDv06_isError() */"},{"Add":"static size_t ZSTDv06_decodeFrameHeader(ZSTDv06_DCtx* zc, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" size_t const result = ZSTDv06_getFrameParams(&(zc->fParams), src, srcSize);"},{"Add":" if ((MEM_32bits()) && (zc->fParams.windowLog > 25)) return ERROR(frameParameter_unsupported);"},{"Add":" return result;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"typedef struct"},{"Add":"{"},{"Add":" blockType_t blockType;"},{"Add":" U32 origSize;"},{"Add":"} blockProperties_t;"},{"Add":""},{"Add":"/*! ZSTDv06_getcBlockSize() :"},{"Add":"* Provides the size of compressed block from block header `src` */"},{"Add":"static size_t ZSTDv06_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)"},{"Add":"{"},{"Add":" const BYTE* const in = (const BYTE*)src;"},{"Add":" U32 cSize;"},{"Add":""},{"Add":" if (srcSize < ZSTDv06_blockHeaderSize) return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" bpPtr->blockType = (blockType_t)((*in) >> 6);"},{"Add":" cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);"},{"Add":" bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;"},{"Add":""},{"Add":" if (bpPtr->blockType == bt_end) return 0;"},{"Add":" if (bpPtr->blockType == bt_rle) return 1;"},{"Add":" return cSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTDv06_copyRawBlock(void* dst, size_t dstCapacity, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" if (dst==NULL) return ERROR(dstSize_tooSmall);"},{"Add":" if (srcSize > dstCapacity) return ERROR(dstSize_tooSmall);"},{"Add":" memcpy(dst, src, srcSize);"},{"Add":" return srcSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*! ZSTDv06_decodeLiteralsBlock() :"},{"Add":" @return : nb of bytes read from src (< srcSize ) */"},{"Add":"static size_t ZSTDv06_decodeLiteralsBlock(ZSTDv06_DCtx* dctx,"},{"Add":" const void* src, size_t srcSize) /* note : srcSize < BLOCKSIZE */"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE*) src;"},{"Add":""},{"Add":" /* any compressed block with literals segment must be at least this size */"},{"Add":" if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);"},{"Add":""},{"Add":" switch(istart[0]>> 6)"},{"Add":" {"},{"Add":" case IS_HUF:"},{"Add":" { size_t litSize, litCSize, singleStream=0;"},{"Add":" U32 lhSize = ((istart[0]) >> 4) & 3;"},{"Add":" if (srcSize < 5) return ERROR(corruption_detected); /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for lhSize, + cSize (+nbSeq) */"},{"Add":" switch(lhSize)"},{"Add":" {"},{"Add":" case 0: case 1: default: /* note : default is impossible, since lhSize into [0..3] */"},{"Add":" /* 2 - 2 - 10 - 10 */"},{"Add":" lhSize=3;"},{"Add":" singleStream = istart[0] & 16;"},{"Add":" litSize = ((istart[0] & 15) << 6) + (istart[1] >> 2);"},{"Add":" litCSize = ((istart[1] & 3) << 8) + istart[2];"},{"Add":" break;"},{"Add":" case 2:"},{"Add":" /* 2 - 2 - 14 - 14 */"},{"Add":" lhSize=4;"},{"Add":" litSize = ((istart[0] & 15) << 10) + (istart[1] << 2) + (istart[2] >> 6);"},{"Add":" litCSize = ((istart[2] & 63) << 8) + istart[3];"},{"Add":" break;"},{"Add":" case 3:"},{"Add":" /* 2 - 2 - 18 - 18 */"},{"Add":" lhSize=5;"},{"Add":" litSize = ((istart[0] & 15) << 14) + (istart[1] << 6) + (istart[2] >> 2);"},{"Add":" litCSize = ((istart[2] & 3) << 16) + (istart[3] << 8) + istart[4];"},{"Add":" break;"},{"Add":" }"},{"Add":" if (litSize > ZSTDv06_BLOCKSIZE_MAX) return ERROR(corruption_detected);"},{"Add":" if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);"},{"Add":""},{"Add":" if (HUFv06_isError(singleStream ?"},{"Add":" HUFv06_decompress1X2(dctx->litBuffer, litSize, istart+lhSize, litCSize) :"},{"Add":" HUFv06_decompress (dctx->litBuffer, litSize, istart+lhSize, litCSize) ))"},{"Add":" return ERROR(corruption_detected);"},{"Add":""},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);"},{"Add":" return litCSize + lhSize;"},{"Add":" }"},{"Add":" case IS_PCH:"},{"Add":" { size_t litSize, litCSize;"},{"Add":" U32 lhSize = ((istart[0]) >> 4) & 3;"},{"Add":" if (lhSize != 1) /* only case supported for now : small litSize, single stream */"},{"Add":" return ERROR(corruption_detected);"},{"Add":" if (!dctx->flagRepeatTable)"},{"Add":" return ERROR(dictionary_corrupted);"},{"Add":""},{"Add":" /* 2 - 2 - 10 - 10 */"},{"Add":" lhSize=3;"},{"Add":" litSize = ((istart[0] & 15) << 6) + (istart[1] >> 2);"},{"Add":" litCSize = ((istart[1] & 3) << 8) + istart[2];"},{"Add":" if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);"},{"Add":""},{"Add":" { size_t const errorCode = HUFv06_decompress1X4_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->hufTableX4);"},{"Add":" if (HUFv06_isError(errorCode)) return ERROR(corruption_detected);"},{"Add":" }"},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);"},{"Add":" return litCSize + lhSize;"},{"Add":" }"},{"Add":" case IS_RAW:"},{"Add":" { size_t litSize;"},{"Add":" U32 lhSize = ((istart[0]) >> 4) & 3;"},{"Add":" switch(lhSize)"},{"Add":" {"},{"Add":" case 0: case 1: default: /* note : default is impossible, since lhSize into [0..3] */"},{"Add":" lhSize=1;"},{"Add":" litSize = istart[0] & 31;"},{"Add":" break;"},{"Add":" case 2:"},{"Add":" litSize = ((istart[0] & 15) << 8) + istart[1];"},{"Add":" break;"},{"Add":" case 3:"},{"Add":" litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2];"},{"Add":" break;"},{"Add":" }"},{"Add":""},{"Add":" if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) { /* risk reading beyond src buffer with wildcopy */"},{"Add":" if (litSize+lhSize > srcSize) return ERROR(corruption_detected);"},{"Add":" memcpy(dctx->litBuffer, istart+lhSize, litSize);"},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);"},{"Add":" return lhSize+litSize;"},{"Add":" }"},{"Add":" /* direct reference into compressed stream */"},{"Add":" dctx->litPtr = istart+lhSize;"},{"Add":" dctx->litSize = litSize;"},{"Add":" return lhSize+litSize;"},{"Add":" }"},{"Add":" case IS_RLE:"},{"Add":" { size_t litSize;"},{"Add":" U32 lhSize = ((istart[0]) >> 4) & 3;"},{"Add":" switch(lhSize)"},{"Add":" {"},{"Add":" case 0: case 1: default: /* note : default is impossible, since lhSize into [0..3] */"},{"Add":" lhSize = 1;"},{"Add":" litSize = istart[0] & 31;"},{"Add":" break;"},{"Add":" case 2:"},{"Add":" litSize = ((istart[0] & 15) << 8) + istart[1];"},{"Add":" break;"},{"Add":" case 3:"},{"Add":" litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2];"},{"Add":" if (srcSize<4) return ERROR(corruption_detected); /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4 */"},{"Add":" break;"},{"Add":" }"},{"Add":" if (litSize > ZSTDv06_BLOCKSIZE_MAX) return ERROR(corruption_detected);"},{"Add":" memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH);"},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" return lhSize+1;"},{"Add":" }"},{"Add":" default:"},{"Add":" return ERROR(corruption_detected); /* impossible */"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*! ZSTDv06_buildSeqTable() :"},{"Add":" @return : nb bytes read from src,"},{"Add":" or an error code if it fails, testable with ZSTDv06_isError()"},{"Add":"*/"},{"Add":"static size_t ZSTDv06_buildSeqTable(FSEv06_DTable* DTable, U32 type, U32 max, U32 maxLog,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const S16* defaultNorm, U32 defaultLog, U32 flagRepeatTable)"},{"Add":"{"},{"Add":" switch(type)"},{"Add":" {"},{"Add":" case FSEv06_ENCODING_RLE :"},{"Add":" if (!srcSize) return ERROR(srcSize_wrong);"},{"Add":" if ( (*(const BYTE*)src) > max) return ERROR(corruption_detected);"},{"Add":" FSEv06_buildDTable_rle(DTable, *(const BYTE*)src); /* if *src > max, data is corrupted */"},{"Add":" return 1;"},{"Add":" case FSEv06_ENCODING_RAW :"},{"Add":" FSEv06_buildDTable(DTable, defaultNorm, max, defaultLog);"},{"Add":" return 0;"},{"Add":" case FSEv06_ENCODING_STATIC:"},{"Add":" if (!flagRepeatTable) return ERROR(corruption_detected);"},{"Add":" return 0;"},{"Add":" default : /* impossible */"},{"Add":" case FSEv06_ENCODING_DYNAMIC :"},{"Add":" { U32 tableLog;"},{"Add":" S16 norm[MaxSeq+1];"},{"Add":" size_t const headerSize = FSEv06_readNCount(norm, &max, &tableLog, src, srcSize);"},{"Add":" if (FSEv06_isError(headerSize)) return ERROR(corruption_detected);"},{"Add":" if (tableLog > maxLog) return ERROR(corruption_detected);"},{"Add":" FSEv06_buildDTable(DTable, norm, max, tableLog);"},{"Add":" return headerSize;"},{"Add":" } }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTDv06_decodeSeqHeaders(int* nbSeqPtr,"},{"Add":" FSEv06_DTable* DTableLL, FSEv06_DTable* DTableML, FSEv06_DTable* DTableOffb, U32 flagRepeatTable,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE*)src;"},{"Add":" const BYTE* const iend = istart + srcSize;"},{"Add":" const BYTE* ip = istart;"},{"Add":""},{"Add":" /* check */"},{"Add":" if (srcSize < MIN_SEQUENCES_SIZE) return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" /* SeqHead */"},{"Add":" { int nbSeq = *ip++;"},{"Add":" if (!nbSeq) { *nbSeqPtr=0; return 1; }"},{"Add":" if (nbSeq > 0x7F) {"},{"Add":" if (nbSeq == 0xFF) {"},{"Add":" if (ip+2 > iend) return ERROR(srcSize_wrong);"},{"Add":" nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2;"},{"Add":" } else {"},{"Add":" if (ip >= iend) return ERROR(srcSize_wrong);"},{"Add":" nbSeq = ((nbSeq-0x80)<<8) + *ip++;"},{"Add":" }"},{"Add":" }"},{"Add":" *nbSeqPtr = nbSeq;"},{"Add":" }"},{"Add":""},{"Add":" /* FSE table descriptors */"},{"Add":" if (ip + 4 > iend) return ERROR(srcSize_wrong); /* min : header byte + all 3 are \"raw\", hence no header, but at least xxLog bits per type */"},{"Add":" { U32 const LLtype = *ip >> 6;"},{"Add":" U32 const Offtype = (*ip >> 4) & 3;"},{"Add":" U32 const MLtype = (*ip >> 2) & 3;"},{"Add":" ip++;"},{"Add":""},{"Add":" /* Build DTables */"},{"Add":" { size_t const bhSize = ZSTDv06_buildSeqTable(DTableLL, LLtype, MaxLL, LLFSELog, ip, iend-ip, LL_defaultNorm, LL_defaultNormLog, flagRepeatTable);"},{"Add":" if (ZSTDv06_isError(bhSize)) return ERROR(corruption_detected);"},{"Add":" ip += bhSize;"},{"Add":" }"},{"Add":" { size_t const bhSize = ZSTDv06_buildSeqTable(DTableOffb, Offtype, MaxOff, OffFSELog, ip, iend-ip, OF_defaultNorm, OF_defaultNormLog, flagRepeatTable);"},{"Add":" if (ZSTDv06_isError(bhSize)) return ERROR(corruption_detected);"},{"Add":" ip += bhSize;"},{"Add":" }"},{"Add":" { size_t const bhSize = ZSTDv06_buildSeqTable(DTableML, MLtype, MaxML, MLFSELog, ip, iend-ip, ML_defaultNorm, ML_defaultNormLog, flagRepeatTable);"},{"Add":" if (ZSTDv06_isError(bhSize)) return ERROR(corruption_detected);"},{"Add":" ip += bhSize;"},{"Add":" } }"},{"Add":""},{"Add":" return ip-istart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"typedef struct {"},{"Add":" size_t litLength;"},{"Add":" size_t matchLength;"},{"Add":" size_t offset;"},{"Add":"} seq_t;"},{"Add":""},{"Add":"typedef struct {"},{"Add":" BITv06_DStream_t DStream;"},{"Add":" FSEv06_DState_t stateLL;"},{"Add":" FSEv06_DState_t stateOffb;"},{"Add":" FSEv06_DState_t stateML;"},{"Add":" size_t prevOffset[ZSTDv06_REP_INIT];"},{"Add":"} seqState_t;"},{"Add":""},{"Add":""},{"Add":""},{"Add":"static void ZSTDv06_decodeSequence(seq_t* seq, seqState_t* seqState)"},{"Add":"{"},{"Add":" /* Literal length */"},{"Add":" U32 const llCode = FSEv06_peekSymbol(&(seqState->stateLL));"},{"Add":" U32 const mlCode = FSEv06_peekSymbol(&(seqState->stateML));"},{"Add":" U32 const ofCode = FSEv06_peekSymbol(&(seqState->stateOffb)); /* <= maxOff, by table construction */"},{"Add":""},{"Add":" U32 const llBits = LL_bits[llCode];"},{"Add":" U32 const mlBits = ML_bits[mlCode];"},{"Add":" U32 const ofBits = ofCode;"},{"Add":" U32 const totalBits = llBits+mlBits+ofBits;"},{"Add":""},{"Add":" static const U32 LL_base[MaxLL+1] = {"},{"Add":" 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,"},{"Add":" 16, 18, 20, 22, 24, 28, 32, 40, 48, 64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000,"},{"Add":" 0x2000, 0x4000, 0x8000, 0x10000 };"},{"Add":""},{"Add":" static const U32 ML_base[MaxML+1] = {"},{"Add":" 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,"},{"Add":" 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,"},{"Add":" 32, 34, 36, 38, 40, 44, 48, 56, 64, 80, 96, 0x80, 0x100, 0x200, 0x400, 0x800,"},{"Add":" 0x1000, 0x2000, 0x4000, 0x8000, 0x10000 };"},{"Add":""},{"Add":" static const U32 OF_base[MaxOff+1] = {"},{"Add":" 0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F,"},{"Add":" 0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF,"},{"Add":" 0xFFFF, 0x1FFFF, 0x3FFFF, 0x7FFFF, 0xFFFFF, 0x1FFFFF, 0x3FFFFF, 0x7FFFFF,"},{"Add":" 0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF, /*fake*/ 1, 1 };"},{"Add":""},{"Add":" /* sequence */"},{"Add":" { size_t offset;"},{"Add":" if (!ofCode)"},{"Add":" offset = 0;"},{"Add":" else {"},{"Add":" offset = OF_base[ofCode] + BITv06_readBits(&(seqState->DStream), ofBits); /* <= 26 bits */"},{"Add":" if (MEM_32bits()) BITv06_reloadDStream(&(seqState->DStream));"},{"Add":" }"},{"Add":""},{"Add":" if (offset < ZSTDv06_REP_NUM) {"},{"Add":" if (llCode == 0 && offset <= 1) offset = 1-offset;"},{"Add":""},{"Add":" if (offset != 0) {"},{"Add":" size_t temp = seqState->prevOffset[offset];"},{"Add":" if (offset != 1) {"},{"Add":" seqState->prevOffset[2] = seqState->prevOffset[1];"},{"Add":" }"},{"Add":" seqState->prevOffset[1] = seqState->prevOffset[0];"},{"Add":" seqState->prevOffset[0] = offset = temp;"},{"Add":""},{"Add":" } else {"},{"Add":" offset = seqState->prevOffset[0];"},{"Add":" }"},{"Add":" } else {"},{"Add":" offset -= ZSTDv06_REP_MOVE;"},{"Add":" seqState->prevOffset[2] = seqState->prevOffset[1];"},{"Add":" seqState->prevOffset[1] = seqState->prevOffset[0];"},{"Add":" seqState->prevOffset[0] = offset;"},{"Add":" }"},{"Add":" seq->offset = offset;"},{"Add":" }"},{"Add":""},{"Add":" seq->matchLength = ML_base[mlCode] + MINMATCH + ((mlCode>31) ? BITv06_readBits(&(seqState->DStream), mlBits) : 0); /* <= 16 bits */"},{"Add":" if (MEM_32bits() && (mlBits+llBits>24)) BITv06_reloadDStream(&(seqState->DStream));"},{"Add":""},{"Add":" seq->litLength = LL_base[llCode] + ((llCode>15) ? BITv06_readBits(&(seqState->DStream), llBits) : 0); /* <= 16 bits */"},{"Add":" if (MEM_32bits() ||"},{"Add":" (totalBits > 64 - 7 - (LLFSELog+MLFSELog+OffFSELog)) ) BITv06_reloadDStream(&(seqState->DStream));"},{"Add":""},{"Add":" /* ANS state update */"},{"Add":" FSEv06_updateState(&(seqState->stateLL), &(seqState->DStream)); /* <= 9 bits */"},{"Add":" FSEv06_updateState(&(seqState->stateML), &(seqState->DStream)); /* <= 9 bits */"},{"Add":" if (MEM_32bits()) BITv06_reloadDStream(&(seqState->DStream)); /* <= 18 bits */"},{"Add":" FSEv06_updateState(&(seqState->stateOffb), &(seqState->DStream)); /* <= 8 bits */"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTDv06_execSequence(BYTE* op,"},{"Add":" BYTE* const oend, seq_t sequence,"},{"Add":" const BYTE** litPtr, const BYTE* const litLimit,"},{"Add":" const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)"},{"Add":"{"},{"Add":" BYTE* const oLitEnd = op + sequence.litLength;"},{"Add":" size_t const sequenceLength = sequence.litLength + sequence.matchLength;"},{"Add":" BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */"},{"Add":" BYTE* const oend_8 = oend-8;"},{"Add":" const BYTE* const iLitEnd = *litPtr + sequence.litLength;"},{"Add":" const BYTE* match = oLitEnd - sequence.offset;"},{"Add":""},{"Add":" /* check */"},{"Add":" if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of 8 from oend */"},{"Add":" if (oMatchEnd > oend) return ERROR(dstSize_tooSmall); /* overwrite beyond dst buffer */"},{"Add":" if (iLitEnd > litLimit) return ERROR(corruption_detected); /* over-read beyond lit buffer */"},{"Add":""},{"Add":" /* copy Literals */"},{"Add":" ZSTDv06_wildcopy(op, *litPtr, sequence.litLength); /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */"},{"Add":" op = oLitEnd;"},{"Add":" *litPtr = iLitEnd; /* update for next sequence */"},{"Add":""},{"Add":" /* copy Match */"},{"Add":" if (sequence.offset > (size_t)(oLitEnd - base)) {"},{"Add":" /* offset beyond prefix */"},{"Add":" if (sequence.offset > (size_t)(oLitEnd - vBase)) return ERROR(corruption_detected);"},{"Add":" match = dictEnd - (base-match);"},{"Add":" if (match + sequence.matchLength <= dictEnd) {"},{"Add":" memmove(oLitEnd, match, sequence.matchLength);"},{"Add":" return sequenceLength;"},{"Add":" }"},{"Add":" /* span extDict & currentPrefixSegment */"},{"Add":" { size_t const length1 = dictEnd - match;"},{"Add":" memmove(oLitEnd, match, length1);"},{"Add":" op = oLitEnd + length1;"},{"Add":" sequence.matchLength -= length1;"},{"Add":" match = base;"},{"Add":" if (op > oend_8 || sequence.matchLength < MINMATCH) {"},{"Add":" while (op < oMatchEnd) *op++ = *match++;"},{"Add":" return sequenceLength;"},{"Add":" }"},{"Add":" } }"},{"Add":" /* Requirement: op <= oend_8 */"},{"Add":""},{"Add":" /* match within prefix */"},{"Add":" if (sequence.offset < 8) {"},{"Add":" /* close range match, overlap */"},{"Add":" static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 }; /* added */"},{"Add":" static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 }; /* subtracted */"},{"Add":" int const sub2 = dec64table[sequence.offset];"},{"Add":" op[0] = match[0];"},{"Add":" op[1] = match[1];"},{"Add":" op[2] = match[2];"},{"Add":" op[3] = match[3];"},{"Add":" match += dec32table[sequence.offset];"},{"Add":" ZSTDv06_copy4(op+4, match);"},{"Add":" match -= sub2;"},{"Add":" } else {"},{"Add":" ZSTDv06_copy8(op, match);"},{"Add":" }"},{"Add":" op += 8; match += 8;"},{"Add":""},{"Add":" if (oMatchEnd > oend-(16-MINMATCH)) {"},{"Add":" if (op < oend_8) {"},{"Add":" ZSTDv06_wildcopy(op, match, oend_8 - op);"},{"Add":" match += oend_8 - op;"},{"Add":" op = oend_8;"},{"Add":" }"},{"Add":" while (op < oMatchEnd) *op++ = *match++;"},{"Add":" } else {"},{"Add":" ZSTDv06_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8); /* works even if matchLength < 8 */"},{"Add":" }"},{"Add":" return sequenceLength;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTDv06_decompressSequences("},{"Add":" ZSTDv06_DCtx* dctx,"},{"Add":" void* dst, size_t maxDstSize,"},{"Add":" const void* seqStart, size_t seqSize)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)seqStart;"},{"Add":" const BYTE* const iend = ip + seqSize;"},{"Add":" BYTE* const ostart = (BYTE*)dst;"},{"Add":" BYTE* const oend = ostart + maxDstSize;"},{"Add":" BYTE* op = ostart;"},{"Add":" const BYTE* litPtr = dctx->litPtr;"},{"Add":" const BYTE* const litEnd = litPtr + dctx->litSize;"},{"Add":" FSEv06_DTable* DTableLL = dctx->LLTable;"},{"Add":" FSEv06_DTable* DTableML = dctx->MLTable;"},{"Add":" FSEv06_DTable* DTableOffb = dctx->OffTable;"},{"Add":" const BYTE* const base = (const BYTE*) (dctx->base);"},{"Add":" const BYTE* const vBase = (const BYTE*) (dctx->vBase);"},{"Add":" const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);"},{"Add":" int nbSeq;"},{"Add":""},{"Add":" /* Build Decoding Tables */"},{"Add":" { size_t const seqHSize = ZSTDv06_decodeSeqHeaders(&nbSeq, DTableLL, DTableML, DTableOffb, dctx->flagRepeatTable, ip, seqSize);"},{"Add":" if (ZSTDv06_isError(seqHSize)) return seqHSize;"},{"Add":" ip += seqHSize;"},{"Add":" dctx->flagRepeatTable = 0;"},{"Add":" }"},{"Add":""},{"Add":" /* Regen sequences */"},{"Add":" if (nbSeq) {"},{"Add":" seq_t sequence;"},{"Add":" seqState_t seqState;"},{"Add":""},{"Add":" memset(&sequence, 0, sizeof(sequence));"},{"Add":" sequence.offset = REPCODE_STARTVALUE;"},{"Add":" { U32 i; for (i=0; i= 5810037) && (pos < 5810400))"},{"Add":" printf(\"Dpos %6u :%5u literals & match %3u bytes at distance %6u \\n\","},{"Add":" pos, (U32)sequence.litLength, (U32)sequence.matchLength, (U32)sequence.offset);"},{"Add":"#endif"},{"Add":""},{"Add":" { size_t const oneSeqSize = ZSTDv06_execSequence(op, oend, sequence, &litPtr, litEnd, base, vBase, dictEnd);"},{"Add":" if (ZSTDv06_isError(oneSeqSize)) return oneSeqSize;"},{"Add":" op += oneSeqSize;"},{"Add":" } }"},{"Add":""},{"Add":" /* check if reached exact end */"},{"Add":" if (nbSeq) return ERROR(corruption_detected);"},{"Add":" }"},{"Add":""},{"Add":" /* last literal segment */"},{"Add":" { size_t const lastLLSize = litEnd - litPtr;"},{"Add":" if (litPtr > litEnd) return ERROR(corruption_detected); /* too many literals already used */"},{"Add":" if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall);"},{"Add":" if (lastLLSize > 0) {"},{"Add":" memcpy(op, litPtr, lastLLSize);"},{"Add":" op += lastLLSize;"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" return op-ostart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static void ZSTDv06_checkContinuity(ZSTDv06_DCtx* dctx, const void* dst)"},{"Add":"{"},{"Add":" if (dst != dctx->previousDstEnd) { /* not contiguous */"},{"Add":" dctx->dictEnd = dctx->previousDstEnd;"},{"Add":" dctx->vBase = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));"},{"Add":" dctx->base = dst;"},{"Add":" dctx->previousDstEnd = dst;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTDv06_decompressBlock_internal(ZSTDv06_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{ /* blockType == blockCompressed */"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":""},{"Add":" if (srcSize >= ZSTDv06_BLOCKSIZE_MAX) return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" /* Decode literals sub-block */"},{"Add":" { size_t const litCSize = ZSTDv06_decodeLiteralsBlock(dctx, src, srcSize);"},{"Add":" if (ZSTDv06_isError(litCSize)) return litCSize;"},{"Add":" ip += litCSize;"},{"Add":" srcSize -= litCSize;"},{"Add":" }"},{"Add":" return ZSTDv06_decompressSequences(dctx, dst, dstCapacity, ip, srcSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t ZSTDv06_decompressBlock(ZSTDv06_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" ZSTDv06_checkContinuity(dctx, dst);"},{"Add":" return ZSTDv06_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*! ZSTDv06_decompressFrame() :"},{"Add":"* `dctx` must be properly initialized */"},{"Add":"static size_t ZSTDv06_decompressFrame(ZSTDv06_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":" const BYTE* const iend = ip + srcSize;"},{"Add":" BYTE* const ostart = (BYTE*)dst;"},{"Add":" BYTE* op = ostart;"},{"Add":" BYTE* const oend = ostart + dstCapacity;"},{"Add":" size_t remainingSize = srcSize;"},{"Add":" blockProperties_t blockProperties = { bt_compressed, 0 };"},{"Add":""},{"Add":" /* check */"},{"Add":" if (srcSize < ZSTDv06_frameHeaderSize_min+ZSTDv06_blockHeaderSize) return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" /* Frame Header */"},{"Add":" { size_t const frameHeaderSize = ZSTDv06_frameHeaderSize(src, ZSTDv06_frameHeaderSize_min);"},{"Add":" if (ZSTDv06_isError(frameHeaderSize)) return frameHeaderSize;"},{"Add":" if (srcSize < frameHeaderSize+ZSTDv06_blockHeaderSize) return ERROR(srcSize_wrong);"},{"Add":" if (ZSTDv06_decodeFrameHeader(dctx, src, frameHeaderSize)) return ERROR(corruption_detected);"},{"Add":" ip += frameHeaderSize; remainingSize -= frameHeaderSize;"},{"Add":" }"},{"Add":""},{"Add":" /* Loop on each block */"},{"Add":" while (1) {"},{"Add":" size_t decodedSize=0;"},{"Add":" size_t const cBlockSize = ZSTDv06_getcBlockSize(ip, iend-ip, &blockProperties);"},{"Add":" if (ZSTDv06_isError(cBlockSize)) return cBlockSize;"},{"Add":""},{"Add":" ip += ZSTDv06_blockHeaderSize;"},{"Add":" remainingSize -= ZSTDv06_blockHeaderSize;"},{"Add":" if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" switch(blockProperties.blockType)"},{"Add":" {"},{"Add":" case bt_compressed:"},{"Add":" decodedSize = ZSTDv06_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize);"},{"Add":" break;"},{"Add":" case bt_raw :"},{"Add":" decodedSize = ZSTDv06_copyRawBlock(op, oend-op, ip, cBlockSize);"},{"Add":" break;"},{"Add":" case bt_rle :"},{"Add":" return ERROR(GENERIC); /* not yet supported */"},{"Add":" break;"},{"Add":" case bt_end :"},{"Add":" /* end of frame */"},{"Add":" if (remainingSize) return ERROR(srcSize_wrong);"},{"Add":" break;"},{"Add":" default:"},{"Add":" return ERROR(GENERIC); /* impossible */"},{"Add":" }"},{"Add":" if (cBlockSize == 0) break; /* bt_end */"},{"Add":""},{"Add":" if (ZSTDv06_isError(decodedSize)) return decodedSize;"},{"Add":" op += decodedSize;"},{"Add":" ip += cBlockSize;"},{"Add":" remainingSize -= cBlockSize;"},{"Add":" }"},{"Add":""},{"Add":" return op-ostart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t ZSTDv06_decompress_usingPreparedDCtx(ZSTDv06_DCtx* dctx, const ZSTDv06_DCtx* refDCtx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" ZSTDv06_copyDCtx(dctx, refDCtx);"},{"Add":" ZSTDv06_checkContinuity(dctx, dst);"},{"Add":" return ZSTDv06_decompressFrame(dctx, dst, dstCapacity, src, srcSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t ZSTDv06_decompress_usingDict(ZSTDv06_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" ZSTDv06_decompressBegin_usingDict(dctx, dict, dictSize);"},{"Add":" ZSTDv06_checkContinuity(dctx, dst);"},{"Add":" return ZSTDv06_decompressFrame(dctx, dst, dstCapacity, src, srcSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t ZSTDv06_decompressDCtx(ZSTDv06_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" return ZSTDv06_decompress_usingDict(dctx, dst, dstCapacity, src, srcSize, NULL, 0);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t ZSTDv06_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":"#if defined(ZSTDv06_HEAPMODE) && (ZSTDv06_HEAPMODE==1)"},{"Add":" size_t regenSize;"},{"Add":" ZSTDv06_DCtx* dctx = ZSTDv06_createDCtx();"},{"Add":" if (dctx==NULL) return ERROR(memory_allocation);"},{"Add":" regenSize = ZSTDv06_decompressDCtx(dctx, dst, dstCapacity, src, srcSize);"},{"Add":" ZSTDv06_freeDCtx(dctx);"},{"Add":" return regenSize;"},{"Add":"#else /* stack mode */"},{"Add":" ZSTDv06_DCtx dctx;"},{"Add":" return ZSTDv06_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);"},{"Add":"#endif"},{"Add":"}"},{"Add":""},{"Add":"/* ZSTD_errorFrameSizeInfoLegacy() :"},{"Add":" assumes `cSize` and `dBound` are _not_ NULL */"},{"Add":"static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)"},{"Add":"{"},{"Add":" *cSize = ret;"},{"Add":" *dBound = ZSTD_CONTENTSIZE_ERROR;"},{"Add":"}"},{"Add":""},{"Add":"void ZSTDv06_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cSize, unsigned long long* dBound)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":" size_t remainingSize = srcSize;"},{"Add":" size_t nbBlocks = 0;"},{"Add":" blockProperties_t blockProperties = { bt_compressed, 0 };"},{"Add":""},{"Add":" /* Frame Header */"},{"Add":" { size_t const frameHeaderSize = ZSTDv06_frameHeaderSize(src, srcSize);"},{"Add":" if (ZSTDv06_isError(frameHeaderSize)) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, frameHeaderSize);"},{"Add":" return;"},{"Add":" }"},{"Add":" if (MEM_readLE32(src) != ZSTDv06_MAGICNUMBER) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(prefix_unknown));"},{"Add":" return;"},{"Add":" }"},{"Add":" if (srcSize < frameHeaderSize+ZSTDv06_blockHeaderSize) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));"},{"Add":" return;"},{"Add":" }"},{"Add":" ip += frameHeaderSize; remainingSize -= frameHeaderSize;"},{"Add":" }"},{"Add":""},{"Add":" /* Loop on each block */"},{"Add":" while (1) {"},{"Add":" size_t const cBlockSize = ZSTDv06_getcBlockSize(ip, remainingSize, &blockProperties);"},{"Add":" if (ZSTDv06_isError(cBlockSize)) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, cBlockSize);"},{"Add":" return;"},{"Add":" }"},{"Add":""},{"Add":" ip += ZSTDv06_blockHeaderSize;"},{"Add":" remainingSize -= ZSTDv06_blockHeaderSize;"},{"Add":" if (cBlockSize > remainingSize) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));"},{"Add":" return;"},{"Add":" }"},{"Add":""},{"Add":" if (cBlockSize == 0) break; /* bt_end */"},{"Add":""},{"Add":" ip += cBlockSize;"},{"Add":" remainingSize -= cBlockSize;"},{"Add":" nbBlocks++;"},{"Add":" }"},{"Add":""},{"Add":" *cSize = ip - (const BYTE*)src;"},{"Add":" *dBound = nbBlocks * ZSTDv06_BLOCKSIZE_MAX;"},{"Add":"}"},{"Add":""},{"Add":"/*_******************************"},{"Add":"* Streaming Decompression API"},{"Add":"********************************/"},{"Add":"size_t ZSTDv06_nextSrcSizeToDecompress(ZSTDv06_DCtx* dctx)"},{"Add":"{"},{"Add":" return dctx->expected;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTDv06_decompressContinue(ZSTDv06_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" /* Sanity check */"},{"Add":" if (srcSize != dctx->expected) return ERROR(srcSize_wrong);"},{"Add":" if (dstCapacity) ZSTDv06_checkContinuity(dctx, dst);"},{"Add":""},{"Add":" /* Decompress : frame header; part 1 */"},{"Add":" switch (dctx->stage)"},{"Add":" {"},{"Add":" case ZSTDds_getFrameHeaderSize :"},{"Add":" if (srcSize != ZSTDv06_frameHeaderSize_min) return ERROR(srcSize_wrong); /* impossible */"},{"Add":" dctx->headerSize = ZSTDv06_frameHeaderSize(src, ZSTDv06_frameHeaderSize_min);"},{"Add":" if (ZSTDv06_isError(dctx->headerSize)) return dctx->headerSize;"},{"Add":" memcpy(dctx->headerBuffer, src, ZSTDv06_frameHeaderSize_min);"},{"Add":" if (dctx->headerSize > ZSTDv06_frameHeaderSize_min) {"},{"Add":" dctx->expected = dctx->headerSize - ZSTDv06_frameHeaderSize_min;"},{"Add":" dctx->stage = ZSTDds_decodeFrameHeader;"},{"Add":" return 0;"},{"Add":" }"},{"Add":" dctx->expected = 0; /* not necessary to copy more */"},{"Add":"\t/* fall-through */"},{"Add":" case ZSTDds_decodeFrameHeader:"},{"Add":" { size_t result;"},{"Add":" memcpy(dctx->headerBuffer + ZSTDv06_frameHeaderSize_min, src, dctx->expected);"},{"Add":" result = ZSTDv06_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize);"},{"Add":" if (ZSTDv06_isError(result)) return result;"},{"Add":" dctx->expected = ZSTDv06_blockHeaderSize;"},{"Add":" dctx->stage = ZSTDds_decodeBlockHeader;"},{"Add":" return 0;"},{"Add":" }"},{"Add":" case ZSTDds_decodeBlockHeader:"},{"Add":" { blockProperties_t bp;"},{"Add":" size_t const cBlockSize = ZSTDv06_getcBlockSize(src, ZSTDv06_blockHeaderSize, &bp);"},{"Add":" if (ZSTDv06_isError(cBlockSize)) return cBlockSize;"},{"Add":" if (bp.blockType == bt_end) {"},{"Add":" dctx->expected = 0;"},{"Add":" dctx->stage = ZSTDds_getFrameHeaderSize;"},{"Add":" } else {"},{"Add":" dctx->expected = cBlockSize;"},{"Add":" dctx->bType = bp.blockType;"},{"Add":" dctx->stage = ZSTDds_decompressBlock;"},{"Add":" }"},{"Add":" return 0;"},{"Add":" }"},{"Add":" case ZSTDds_decompressBlock:"},{"Add":" { size_t rSize;"},{"Add":" switch(dctx->bType)"},{"Add":" {"},{"Add":" case bt_compressed:"},{"Add":" rSize = ZSTDv06_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);"},{"Add":" break;"},{"Add":" case bt_raw :"},{"Add":" rSize = ZSTDv06_copyRawBlock(dst, dstCapacity, src, srcSize);"},{"Add":" break;"},{"Add":" case bt_rle :"},{"Add":" return ERROR(GENERIC); /* not yet handled */"},{"Add":" break;"},{"Add":" case bt_end : /* should never happen (filtered at phase 1) */"},{"Add":" rSize = 0;"},{"Add":" break;"},{"Add":" default:"},{"Add":" return ERROR(GENERIC); /* impossible */"},{"Add":" }"},{"Add":" dctx->stage = ZSTDds_decodeBlockHeader;"},{"Add":" dctx->expected = ZSTDv06_blockHeaderSize;"},{"Add":" dctx->previousDstEnd = (char*)dst + rSize;"},{"Add":" return rSize;"},{"Add":" }"},{"Add":" default:"},{"Add":" return ERROR(GENERIC); /* impossible */"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static void ZSTDv06_refDictContent(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" dctx->dictEnd = dctx->previousDstEnd;"},{"Add":" dctx->vBase = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));"},{"Add":" dctx->base = dict;"},{"Add":" dctx->previousDstEnd = (const char*)dict + dictSize;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZSTDv06_loadEntropy(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" size_t hSize, offcodeHeaderSize, matchlengthHeaderSize, litlengthHeaderSize;"},{"Add":""},{"Add":" hSize = HUFv06_readDTableX4(dctx->hufTableX4, dict, dictSize);"},{"Add":" if (HUFv06_isError(hSize)) return ERROR(dictionary_corrupted);"},{"Add":" dict = (const char*)dict + hSize;"},{"Add":" dictSize -= hSize;"},{"Add":""},{"Add":" { short offcodeNCount[MaxOff+1];"},{"Add":" U32 offcodeMaxValue=MaxOff, offcodeLog;"},{"Add":" offcodeHeaderSize = FSEv06_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dict, dictSize);"},{"Add":" if (FSEv06_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted);"},{"Add":" if (offcodeLog > OffFSELog) return ERROR(dictionary_corrupted);"},{"Add":" { size_t const errorCode = FSEv06_buildDTable(dctx->OffTable, offcodeNCount, offcodeMaxValue, offcodeLog);"},{"Add":" if (FSEv06_isError(errorCode)) return ERROR(dictionary_corrupted); }"},{"Add":" dict = (const char*)dict + offcodeHeaderSize;"},{"Add":" dictSize -= offcodeHeaderSize;"},{"Add":" }"},{"Add":""},{"Add":" { short matchlengthNCount[MaxML+1];"},{"Add":" unsigned matchlengthMaxValue = MaxML, matchlengthLog;"},{"Add":" matchlengthHeaderSize = FSEv06_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dict, dictSize);"},{"Add":" if (FSEv06_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted);"},{"Add":" if (matchlengthLog > MLFSELog) return ERROR(dictionary_corrupted);"},{"Add":" { size_t const errorCode = FSEv06_buildDTable(dctx->MLTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog);"},{"Add":" if (FSEv06_isError(errorCode)) return ERROR(dictionary_corrupted); }"},{"Add":" dict = (const char*)dict + matchlengthHeaderSize;"},{"Add":" dictSize -= matchlengthHeaderSize;"},{"Add":" }"},{"Add":""},{"Add":" { short litlengthNCount[MaxLL+1];"},{"Add":" unsigned litlengthMaxValue = MaxLL, litlengthLog;"},{"Add":" litlengthHeaderSize = FSEv06_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dict, dictSize);"},{"Add":" if (FSEv06_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted);"},{"Add":" if (litlengthLog > LLFSELog) return ERROR(dictionary_corrupted);"},{"Add":" { size_t const errorCode = FSEv06_buildDTable(dctx->LLTable, litlengthNCount, litlengthMaxValue, litlengthLog);"},{"Add":" if (FSEv06_isError(errorCode)) return ERROR(dictionary_corrupted); }"},{"Add":" }"},{"Add":""},{"Add":" dctx->flagRepeatTable = 1;"},{"Add":" return hSize + offcodeHeaderSize + matchlengthHeaderSize + litlengthHeaderSize;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZSTDv06_decompress_insertDictionary(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" size_t eSize;"},{"Add":" U32 const magic = MEM_readLE32(dict);"},{"Add":" if (magic != ZSTDv06_DICT_MAGIC) {"},{"Add":" /* pure content mode */"},{"Add":" ZSTDv06_refDictContent(dctx, dict, dictSize);"},{"Add":" return 0;"},{"Add":" }"},{"Add":" /* load entropy tables */"},{"Add":" dict = (const char*)dict + 4;"},{"Add":" dictSize -= 4;"},{"Add":" eSize = ZSTDv06_loadEntropy(dctx, dict, dictSize);"},{"Add":" if (ZSTDv06_isError(eSize)) return ERROR(dictionary_corrupted);"},{"Add":""},{"Add":" /* reference dictionary content */"},{"Add":" dict = (const char*)dict + eSize;"},{"Add":" dictSize -= eSize;"},{"Add":" ZSTDv06_refDictContent(dctx, dict, dictSize);"},{"Add":""},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t ZSTDv06_decompressBegin_usingDict(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" { size_t const errorCode = ZSTDv06_decompressBegin(dctx);"},{"Add":" if (ZSTDv06_isError(errorCode)) return errorCode; }"},{"Add":""},{"Add":" if (dict && dictSize) {"},{"Add":" size_t const errorCode = ZSTDv06_decompress_insertDictionary(dctx, dict, dictSize);"},{"Add":" if (ZSTDv06_isError(errorCode)) return ERROR(dictionary_corrupted);"},{"Add":" }"},{"Add":""},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"/*"},{"Add":" Buffered version of Zstd compression library"},{"Add":" Copyright (C) 2015-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - zstd homepage : http://www.zstd.net/"},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/*-***************************************************************************"},{"Add":"* Streaming decompression howto"},{"Add":"*"},{"Add":"* A ZBUFFv06_DCtx object is required to track streaming operations."},{"Add":"* Use ZBUFFv06_createDCtx() and ZBUFFv06_freeDCtx() to create/release resources."},{"Add":"* Use ZBUFFv06_decompressInit() to start a new decompression operation,"},{"Add":"* or ZBUFFv06_decompressInitDictionary() if decompression requires a dictionary."},{"Add":"* Note that ZBUFFv06_DCtx objects can be re-init multiple times."},{"Add":"*"},{"Add":"* Use ZBUFFv06_decompressContinue() repetitively to consume your input."},{"Add":"* *srcSizePtr and *dstCapacityPtr can be any size."},{"Add":"* The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr."},{"Add":"* Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again."},{"Add":"* The content of @dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change @dst."},{"Add":"* @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency),"},{"Add":"* or 0 when a frame is completely decoded,"},{"Add":"* or an error code, which can be tested using ZBUFFv06_isError()."},{"Add":"*"},{"Add":"* Hint : recommended buffer sizes (not compulsory) : ZBUFFv06_recommendedDInSize() and ZBUFFv06_recommendedDOutSize()"},{"Add":"* output : ZBUFFv06_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded."},{"Add":"* input : ZBUFFv06_recommendedDInSize == 128KB + 3;"},{"Add":"* just follow indications from ZBUFFv06_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 ."},{"Add":"* *******************************************************************************/"},{"Add":""},{"Add":"typedef enum { ZBUFFds_init, ZBUFFds_loadHeader,"},{"Add":" ZBUFFds_read, ZBUFFds_load, ZBUFFds_flush } ZBUFFv06_dStage;"},{"Add":""},{"Add":"/* *** Resource management *** */"},{"Add":"struct ZBUFFv06_DCtx_s {"},{"Add":" ZSTDv06_DCtx* zd;"},{"Add":" ZSTDv06_frameParams fParams;"},{"Add":" ZBUFFv06_dStage stage;"},{"Add":" char* inBuff;"},{"Add":" size_t inBuffSize;"},{"Add":" size_t inPos;"},{"Add":" char* outBuff;"},{"Add":" size_t outBuffSize;"},{"Add":" size_t outStart;"},{"Add":" size_t outEnd;"},{"Add":" size_t blockSize;"},{"Add":" BYTE headerBuffer[ZSTDv06_FRAMEHEADERSIZE_MAX];"},{"Add":" size_t lhSize;"},{"Add":"}; /* typedef'd to ZBUFFv06_DCtx within \"zstd_buffered.h\" */"},{"Add":""},{"Add":""},{"Add":"ZBUFFv06_DCtx* ZBUFFv06_createDCtx(void)"},{"Add":"{"},{"Add":" ZBUFFv06_DCtx* zbd = (ZBUFFv06_DCtx*)malloc(sizeof(ZBUFFv06_DCtx));"},{"Add":" if (zbd==NULL) return NULL;"},{"Add":" memset(zbd, 0, sizeof(*zbd));"},{"Add":" zbd->zd = ZSTDv06_createDCtx();"},{"Add":" zbd->stage = ZBUFFds_init;"},{"Add":" return zbd;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZBUFFv06_freeDCtx(ZBUFFv06_DCtx* zbd)"},{"Add":"{"},{"Add":" if (zbd==NULL) return 0; /* support free on null */"},{"Add":" ZSTDv06_freeDCtx(zbd->zd);"},{"Add":" free(zbd->inBuff);"},{"Add":" free(zbd->outBuff);"},{"Add":" free(zbd);"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/* *** Initialization *** */"},{"Add":""},{"Add":"size_t ZBUFFv06_decompressInitDictionary(ZBUFFv06_DCtx* zbd, const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" zbd->stage = ZBUFFds_loadHeader;"},{"Add":" zbd->lhSize = zbd->inPos = zbd->outStart = zbd->outEnd = 0;"},{"Add":" return ZSTDv06_decompressBegin_usingDict(zbd->zd, dict, dictSize);"},{"Add":"}"},{"Add":""},{"Add":"size_t ZBUFFv06_decompressInit(ZBUFFv06_DCtx* zbd)"},{"Add":"{"},{"Add":" return ZBUFFv06_decompressInitDictionary(zbd, NULL, 0);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"MEM_STATIC size_t ZBUFFv06_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" size_t length = MIN(dstCapacity, srcSize);"},{"Add":" if (length > 0) {"},{"Add":" memcpy(dst, src, length);"},{"Add":" }"},{"Add":" return length;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/* *** Decompression *** */"},{"Add":""},{"Add":"size_t ZBUFFv06_decompressContinue(ZBUFFv06_DCtx* zbd,"},{"Add":" void* dst, size_t* dstCapacityPtr,"},{"Add":" const void* src, size_t* srcSizePtr)"},{"Add":"{"},{"Add":" const char* const istart = (const char*)src;"},{"Add":" const char* const iend = istart + *srcSizePtr;"},{"Add":" const char* ip = istart;"},{"Add":" char* const ostart = (char*)dst;"},{"Add":" char* const oend = ostart + *dstCapacityPtr;"},{"Add":" char* op = ostart;"},{"Add":" U32 notDone = 1;"},{"Add":""},{"Add":" while (notDone) {"},{"Add":" switch(zbd->stage)"},{"Add":" {"},{"Add":" case ZBUFFds_init :"},{"Add":" return ERROR(init_missing);"},{"Add":""},{"Add":" case ZBUFFds_loadHeader :"},{"Add":" { size_t const hSize = ZSTDv06_getFrameParams(&(zbd->fParams), zbd->headerBuffer, zbd->lhSize);"},{"Add":" if (hSize != 0) {"},{"Add":" size_t const toLoad = hSize - zbd->lhSize; /* if hSize!=0, hSize > zbd->lhSize */"},{"Add":" if (ZSTDv06_isError(hSize)) return hSize;"},{"Add":" if (toLoad > (size_t)(iend-ip)) { /* not enough input to load full header */"},{"Add":" memcpy(zbd->headerBuffer + zbd->lhSize, ip, iend-ip);"},{"Add":" zbd->lhSize += iend-ip;"},{"Add":" *dstCapacityPtr = 0;"},{"Add":" return (hSize - zbd->lhSize) + ZSTDv06_blockHeaderSize; /* remaining header bytes + next block header */"},{"Add":" }"},{"Add":" memcpy(zbd->headerBuffer + zbd->lhSize, ip, toLoad); zbd->lhSize = hSize; ip += toLoad;"},{"Add":" break;"},{"Add":" } }"},{"Add":""},{"Add":" /* Consume header */"},{"Add":" { size_t const h1Size = ZSTDv06_nextSrcSizeToDecompress(zbd->zd); /* == ZSTDv06_frameHeaderSize_min */"},{"Add":" size_t const h1Result = ZSTDv06_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer, h1Size);"},{"Add":" if (ZSTDv06_isError(h1Result)) return h1Result;"},{"Add":" if (h1Size < zbd->lhSize) { /* long header */"},{"Add":" size_t const h2Size = ZSTDv06_nextSrcSizeToDecompress(zbd->zd);"},{"Add":" size_t const h2Result = ZSTDv06_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer+h1Size, h2Size);"},{"Add":" if (ZSTDv06_isError(h2Result)) return h2Result;"},{"Add":" } }"},{"Add":""},{"Add":" /* Frame header instruct buffer sizes */"},{"Add":" { size_t const blockSize = MIN(1 << zbd->fParams.windowLog, ZSTDv06_BLOCKSIZE_MAX);"},{"Add":" zbd->blockSize = blockSize;"},{"Add":" if (zbd->inBuffSize < blockSize) {"},{"Add":" free(zbd->inBuff);"},{"Add":" zbd->inBuffSize = blockSize;"},{"Add":" zbd->inBuff = (char*)malloc(blockSize);"},{"Add":" if (zbd->inBuff == NULL) return ERROR(memory_allocation);"},{"Add":" }"},{"Add":" { size_t const neededOutSize = ((size_t)1 << zbd->fParams.windowLog) + blockSize + WILDCOPY_OVERLENGTH * 2;"},{"Add":" if (zbd->outBuffSize < neededOutSize) {"},{"Add":" free(zbd->outBuff);"},{"Add":" zbd->outBuffSize = neededOutSize;"},{"Add":" zbd->outBuff = (char*)malloc(neededOutSize);"},{"Add":" if (zbd->outBuff == NULL) return ERROR(memory_allocation);"},{"Add":" } } }"},{"Add":" zbd->stage = ZBUFFds_read;"},{"Add":"\t /* fall-through */"},{"Add":" case ZBUFFds_read:"},{"Add":" { size_t const neededInSize = ZSTDv06_nextSrcSizeToDecompress(zbd->zd);"},{"Add":" if (neededInSize==0) { /* end of frame */"},{"Add":" zbd->stage = ZBUFFds_init;"},{"Add":" notDone = 0;"},{"Add":" break;"},{"Add":" }"},{"Add":" if ((size_t)(iend-ip) >= neededInSize) { /* decode directly from src */"},{"Add":" size_t const decodedSize = ZSTDv06_decompressContinue(zbd->zd,"},{"Add":" zbd->outBuff + zbd->outStart, zbd->outBuffSize - zbd->outStart,"},{"Add":" ip, neededInSize);"},{"Add":" if (ZSTDv06_isError(decodedSize)) return decodedSize;"},{"Add":" ip += neededInSize;"},{"Add":" if (!decodedSize) break; /* this was just a header */"},{"Add":" zbd->outEnd = zbd->outStart + decodedSize;"},{"Add":" zbd->stage = ZBUFFds_flush;"},{"Add":" break;"},{"Add":" }"},{"Add":" if (ip==iend) { notDone = 0; break; } /* no more input */"},{"Add":" zbd->stage = ZBUFFds_load;"},{"Add":" }"},{"Add":"\t /* fall-through */"},{"Add":" case ZBUFFds_load:"},{"Add":" { size_t const neededInSize = ZSTDv06_nextSrcSizeToDecompress(zbd->zd);"},{"Add":" size_t const toLoad = neededInSize - zbd->inPos; /* should always be <= remaining space within inBuff */"},{"Add":" size_t loadedSize;"},{"Add":" if (toLoad > zbd->inBuffSize - zbd->inPos) return ERROR(corruption_detected); /* should never happen */"},{"Add":" loadedSize = ZBUFFv06_limitCopy(zbd->inBuff + zbd->inPos, toLoad, ip, iend-ip);"},{"Add":" ip += loadedSize;"},{"Add":" zbd->inPos += loadedSize;"},{"Add":" if (loadedSize < toLoad) { notDone = 0; break; } /* not enough input, wait for more */"},{"Add":""},{"Add":" /* decode loaded input */"},{"Add":" { size_t const decodedSize = ZSTDv06_decompressContinue(zbd->zd,"},{"Add":" zbd->outBuff + zbd->outStart, zbd->outBuffSize - zbd->outStart,"},{"Add":" zbd->inBuff, neededInSize);"},{"Add":" if (ZSTDv06_isError(decodedSize)) return decodedSize;"},{"Add":" zbd->inPos = 0; /* input is consumed */"},{"Add":" if (!decodedSize) { zbd->stage = ZBUFFds_read; break; } /* this was just a header */"},{"Add":" zbd->outEnd = zbd->outStart + decodedSize;"},{"Add":" zbd->stage = ZBUFFds_flush;"},{"Add":" /* break; */ /* ZBUFFds_flush follows */"},{"Add":" }"},{"Add":"\t }"},{"Add":"\t /* fall-through */"},{"Add":" case ZBUFFds_flush:"},{"Add":" { size_t const toFlushSize = zbd->outEnd - zbd->outStart;"},{"Add":" size_t const flushedSize = ZBUFFv06_limitCopy(op, oend-op, zbd->outBuff + zbd->outStart, toFlushSize);"},{"Add":" op += flushedSize;"},{"Add":" zbd->outStart += flushedSize;"},{"Add":" if (flushedSize == toFlushSize) {"},{"Add":" zbd->stage = ZBUFFds_read;"},{"Add":" if (zbd->outStart + zbd->blockSize > zbd->outBuffSize)"},{"Add":" zbd->outStart = zbd->outEnd = 0;"},{"Add":" break;"},{"Add":" }"},{"Add":" /* cannot flush everything */"},{"Add":" notDone = 0;"},{"Add":" break;"},{"Add":" }"},{"Add":" default: return ERROR(GENERIC); /* impossible */"},{"Add":" } }"},{"Add":""},{"Add":" /* result */"},{"Add":" *srcSizePtr = ip-istart;"},{"Add":" *dstCapacityPtr = op-ostart;"},{"Add":" { size_t nextSrcSizeHint = ZSTDv06_nextSrcSizeToDecompress(zbd->zd);"},{"Add":" if (nextSrcSizeHint > ZSTDv06_blockHeaderSize) nextSrcSizeHint+= ZSTDv06_blockHeaderSize; /* get following block header too */"},{"Add":" nextSrcSizeHint -= zbd->inPos; /* already loaded*/"},{"Add":" return nextSrcSizeHint;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Tool functions"},{"Add":"***************************************/"},{"Add":"size_t ZBUFFv06_recommendedDInSize(void) { return ZSTDv06_BLOCKSIZE_MAX + ZSTDv06_blockHeaderSize /* block header size*/ ; }"},{"Add":"size_t ZBUFFv06_recommendedDOutSize(void) { return ZSTDv06_BLOCKSIZE_MAX; }"}]}},{"FileAdd":{"meta":{"basename":"zstd_v05.h","metadata":0},"context":[{"change":0,"pos":140938}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) 2016-2021, Yann Collet, Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":""},{"Add":"#ifndef ZSTDv05_H"},{"Add":"#define ZSTDv05_H"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"/*-*************************************"},{"Add":"* Dependencies"},{"Add":"***************************************/"},{"Add":"#include /* size_t */"},{"Add":"#include \"../common/mem.h\" /* U64, U32 */"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Simple functions"},{"Add":"***************************************/"},{"Add":"/*! ZSTDv05_decompress() :"},{"Add":" `compressedSize` : is the _exact_ size of the compressed blob, otherwise decompression will fail."},{"Add":" `dstCapacity` must be large enough, equal or larger than originalSize."},{"Add":" @return : the number of bytes decompressed into `dst` (<= `dstCapacity`),"},{"Add":" or an errorCode if it fails (which can be tested using ZSTDv05_isError()) */"},{"Add":"size_t ZSTDv05_decompress( void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t compressedSize);"},{"Add":""},{"Add":" /**"},{"Add":" ZSTDv05_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.5.x format"},{"Add":" srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'"},{"Add":" cSize (output parameter) : the number of bytes that would be read to decompress this frame"},{"Add":" or an error code if it fails (which can be tested using ZSTDv01_isError())"},{"Add":" dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame"},{"Add":" or ZSTD_CONTENTSIZE_ERROR if an error occurs"},{"Add":""},{"Add":" note : assumes `cSize` and `dBound` are _not_ NULL."},{"Add":" */"},{"Add":"void ZSTDv05_findFrameSizeInfoLegacy(const void *src, size_t srcSize,"},{"Add":" size_t* cSize, unsigned long long* dBound);"},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Helper functions"},{"Add":"***************************************/"},{"Add":"/* Error Management */"},{"Add":"unsigned ZSTDv05_isError(size_t code); /*!< tells if a `size_t` function result is an error code */"},{"Add":"const char* ZSTDv05_getErrorName(size_t code); /*!< provides readable string for an error code */"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Explicit memory management"},{"Add":"***************************************/"},{"Add":"/** Decompression context */"},{"Add":"typedef struct ZSTDv05_DCtx_s ZSTDv05_DCtx;"},{"Add":"ZSTDv05_DCtx* ZSTDv05_createDCtx(void);"},{"Add":"size_t ZSTDv05_freeDCtx(ZSTDv05_DCtx* dctx); /*!< @return : errorCode */"},{"Add":""},{"Add":"/** ZSTDv05_decompressDCtx() :"},{"Add":"* Same as ZSTDv05_decompress(), but requires an already allocated ZSTDv05_DCtx (see ZSTDv05_createDCtx()) */"},{"Add":"size_t ZSTDv05_decompressDCtx(ZSTDv05_DCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);"},{"Add":""},{"Add":""},{"Add":"/*-***********************"},{"Add":"* Simple Dictionary API"},{"Add":"*************************/"},{"Add":"/*! ZSTDv05_decompress_usingDict() :"},{"Add":"* Decompression using a pre-defined Dictionary content (see dictBuilder)."},{"Add":"* Dictionary must be identical to the one used during compression, otherwise regenerated data will be corrupted."},{"Add":"* Note : dict can be NULL, in which case, it's equivalent to ZSTDv05_decompressDCtx() */"},{"Add":"size_t ZSTDv05_decompress_usingDict(ZSTDv05_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const void* dict,size_t dictSize);"},{"Add":""},{"Add":"/*-************************"},{"Add":"* Advanced Streaming API"},{"Add":"***************************/"},{"Add":"typedef enum { ZSTDv05_fast, ZSTDv05_greedy, ZSTDv05_lazy, ZSTDv05_lazy2, ZSTDv05_btlazy2, ZSTDv05_opt, ZSTDv05_btopt } ZSTDv05_strategy;"},{"Add":"typedef struct {"},{"Add":" U64 srcSize;"},{"Add":" U32 windowLog; /* the only useful information to retrieve */"},{"Add":" U32 contentLog; U32 hashLog; U32 searchLog; U32 searchLength; U32 targetLength; ZSTDv05_strategy strategy;"},{"Add":"} ZSTDv05_parameters;"},{"Add":"size_t ZSTDv05_getFrameParams(ZSTDv05_parameters* params, const void* src, size_t srcSize);"},{"Add":""},{"Add":"size_t ZSTDv05_decompressBegin_usingDict(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize);"},{"Add":"void ZSTDv05_copyDCtx(ZSTDv05_DCtx* dstDCtx, const ZSTDv05_DCtx* srcDCtx);"},{"Add":"size_t ZSTDv05_nextSrcSizeToDecompress(ZSTDv05_DCtx* dctx);"},{"Add":"size_t ZSTDv05_decompressContinue(ZSTDv05_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);"},{"Add":""},{"Add":""},{"Add":"/*-***********************"},{"Add":"* ZBUFF API"},{"Add":"*************************/"},{"Add":"typedef struct ZBUFFv05_DCtx_s ZBUFFv05_DCtx;"},{"Add":"ZBUFFv05_DCtx* ZBUFFv05_createDCtx(void);"},{"Add":"size_t ZBUFFv05_freeDCtx(ZBUFFv05_DCtx* dctx);"},{"Add":""},{"Add":"size_t ZBUFFv05_decompressInit(ZBUFFv05_DCtx* dctx);"},{"Add":"size_t ZBUFFv05_decompressInitDictionary(ZBUFFv05_DCtx* dctx, const void* dict, size_t dictSize);"},{"Add":""},{"Add":"size_t ZBUFFv05_decompressContinue(ZBUFFv05_DCtx* dctx,"},{"Add":" void* dst, size_t* dstCapacityPtr,"},{"Add":" const void* src, size_t* srcSizePtr);"},{"Add":""},{"Add":"/*-***************************************************************************"},{"Add":"* Streaming decompression"},{"Add":"*"},{"Add":"* A ZBUFFv05_DCtx object is required to track streaming operations."},{"Add":"* Use ZBUFFv05_createDCtx() and ZBUFFv05_freeDCtx() to create/release resources."},{"Add":"* Use ZBUFFv05_decompressInit() to start a new decompression operation,"},{"Add":"* or ZBUFFv05_decompressInitDictionary() if decompression requires a dictionary."},{"Add":"* Note that ZBUFFv05_DCtx objects can be reused multiple times."},{"Add":"*"},{"Add":"* Use ZBUFFv05_decompressContinue() repetitively to consume your input."},{"Add":"* *srcSizePtr and *dstCapacityPtr can be any size."},{"Add":"* The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr."},{"Add":"* Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again."},{"Add":"* The content of @dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters or change @dst."},{"Add":"* @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency)"},{"Add":"* or 0 when a frame is completely decoded"},{"Add":"* or an error code, which can be tested using ZBUFFv05_isError()."},{"Add":"*"},{"Add":"* Hint : recommended buffer sizes (not compulsory) : ZBUFFv05_recommendedDInSize() / ZBUFFv05_recommendedDOutSize()"},{"Add":"* output : ZBUFFv05_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded."},{"Add":"* input : ZBUFFv05_recommendedDInSize==128Kb+3; just follow indications from ZBUFFv05_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 ."},{"Add":"* *******************************************************************************/"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Tool functions"},{"Add":"***************************************/"},{"Add":"unsigned ZBUFFv05_isError(size_t errorCode);"},{"Add":"const char* ZBUFFv05_getErrorName(size_t errorCode);"},{"Add":""},{"Add":"/** Functions below provide recommended buffer sizes for Compression or Decompression operations."},{"Add":"* These sizes are just hints, and tend to offer better latency */"},{"Add":"size_t ZBUFFv05_recommendedDInSize(void);"},{"Add":"size_t ZBUFFv05_recommendedDOutSize(void);"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-*************************************"},{"Add":"* Constants"},{"Add":"***************************************/"},{"Add":"#define ZSTDv05_MAGICNUMBER 0xFD2FB525 /* v0.5 */"},{"Add":""},{"Add":""},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* ZSTDv0505_H */"}]}},{"FileAdd":{"meta":{"basename":"zstd_v05.c","metadata":0},"context":[{"change":0,"pos":140938}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) 2016-2021, Yann Collet, Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":""},{"Add":""},{"Add":"/*- Dependencies -*/"},{"Add":"#include \"zstd_v05.h\""},{"Add":"#include \"../common/error_private.h\""},{"Add":""},{"Add":""},{"Add":"/* ******************************************************************"},{"Add":" mem.h"},{"Add":" low-level memory access routines"},{"Add":" Copyright (C) 2013-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - FSEv05 source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":"#ifndef MEM_H_MODULE"},{"Add":"#define MEM_H_MODULE"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"/*-****************************************"},{"Add":"* Dependencies"},{"Add":"******************************************/"},{"Add":"#include /* size_t, ptrdiff_t */"},{"Add":"#include /* memcpy */"},{"Add":""},{"Add":""},{"Add":"/*-****************************************"},{"Add":"* Compiler specifics"},{"Add":"******************************************/"},{"Add":"#if defined(__GNUC__)"},{"Add":"# define MEM_STATIC static __attribute__((unused))"},{"Add":"#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)"},{"Add":"# define MEM_STATIC static inline"},{"Add":"#elif defined(_MSC_VER)"},{"Add":"# define MEM_STATIC static __inline"},{"Add":"#else"},{"Add":"# define MEM_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*-**************************************************************"},{"Add":"* Basic Types"},{"Add":"*****************************************************************/"},{"Add":"#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)"},{"Add":"# if defined(_AIX)"},{"Add":"# include "},{"Add":"# else"},{"Add":"# include /* intptr_t */"},{"Add":"# endif"},{"Add":" typedef uint8_t BYTE;"},{"Add":" typedef uint16_t U16;"},{"Add":" typedef int16_t S16;"},{"Add":" typedef uint32_t U32;"},{"Add":" typedef int32_t S32;"},{"Add":" typedef uint64_t U64;"},{"Add":" typedef int64_t S64;"},{"Add":"#else"},{"Add":" typedef unsigned char BYTE;"},{"Add":" typedef unsigned short U16;"},{"Add":" typedef signed short S16;"},{"Add":" typedef unsigned int U32;"},{"Add":" typedef signed int S32;"},{"Add":" typedef unsigned long long U64;"},{"Add":" typedef signed long long S64;"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*-**************************************************************"},{"Add":"* Memory I/O"},{"Add":"*****************************************************************/"},{"Add":"/* MEM_FORCE_MEMORY_ACCESS :"},{"Add":" * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable."},{"Add":" * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal."},{"Add":" * The below switch allow to select different access method for improved performance."},{"Add":" * Method 0 (default) : use `memcpy()`. Safe and portable."},{"Add":" * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable)."},{"Add":" * This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`."},{"Add":" * Method 2 : direct access. This method is portable but violate C standard."},{"Add":" * It can generate buggy code on targets depending on alignment."},{"Add":" * In some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)"},{"Add":" * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details."},{"Add":" * Prefer these methods in priority order (0 > 1 > 2)"},{"Add":" */"},{"Add":"#ifndef MEM_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */"},{"Add":"# if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )"},{"Add":"# define MEM_FORCE_MEMORY_ACCESS 2"},{"Add":"# elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \\"},{"Add":" (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))"},{"Add":"# define MEM_FORCE_MEMORY_ACCESS 1"},{"Add":"# endif"},{"Add":"#endif"},{"Add":""},{"Add":"MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; }"},{"Add":"MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; }"},{"Add":""},{"Add":"MEM_STATIC unsigned MEM_isLittleEndian(void)"},{"Add":"{"},{"Add":" const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */"},{"Add":" return one.c[0];"},{"Add":"}"},{"Add":""},{"Add":"#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)"},{"Add":""},{"Add":"/* violates C standard, by lying on structure alignment."},{"Add":"Only use if no other choice to achieve best performance on target platform */"},{"Add":"MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }"},{"Add":"MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }"},{"Add":"MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }"},{"Add":"MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }"},{"Add":"MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; }"},{"Add":""},{"Add":"#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)"},{"Add":""},{"Add":"/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */"},{"Add":"/* currently only defined for gcc and icc */"},{"Add":"typedef union { U16 u16; U32 u32; U64 u64; size_t st; } __attribute__((packed)) unalign;"},{"Add":""},{"Add":"MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }"},{"Add":"MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }"},{"Add":"MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }"},{"Add":"MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; }"},{"Add":"MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign*)memPtr)->u64 = value; }"},{"Add":""},{"Add":"#else"},{"Add":""},{"Add":"/* default method, safe and standard."},{"Add":" can sometimes prove slower */"},{"Add":""},{"Add":"MEM_STATIC U16 MEM_read16(const void* memPtr)"},{"Add":"{"},{"Add":" U16 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_read32(const void* memPtr)"},{"Add":"{"},{"Add":" U32 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U64 MEM_read64(const void* memPtr)"},{"Add":"{"},{"Add":" U64 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value)"},{"Add":"{"},{"Add":" memcpy(memPtr, &value, sizeof(value));"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_write32(void* memPtr, U32 value)"},{"Add":"{"},{"Add":" memcpy(memPtr, &value, sizeof(value));"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_write64(void* memPtr, U64 value)"},{"Add":"{"},{"Add":" memcpy(memPtr, &value, sizeof(value));"},{"Add":"}"},{"Add":""},{"Add":"#endif /* MEM_FORCE_MEMORY_ACCESS */"},{"Add":""},{"Add":""},{"Add":"MEM_STATIC U16 MEM_readLE16(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read16(memPtr);"},{"Add":" else {"},{"Add":" const BYTE* p = (const BYTE*)memPtr;"},{"Add":" return (U16)(p[0] + (p[1]<<8));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian()) {"},{"Add":" MEM_write16(memPtr, val);"},{"Add":" } else {"},{"Add":" BYTE* p = (BYTE*)memPtr;"},{"Add":" p[0] = (BYTE)val;"},{"Add":" p[1] = (BYTE)(val>>8);"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_readLE32(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read32(memPtr);"},{"Add":" else {"},{"Add":" const BYTE* p = (const BYTE*)memPtr;"},{"Add":" return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"MEM_STATIC U64 MEM_readLE64(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read64(memPtr);"},{"Add":" else {"},{"Add":" const BYTE* p = (const BYTE*)memPtr;"},{"Add":" return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)"},{"Add":" + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"MEM_STATIC size_t MEM_readLEST(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_32bits())"},{"Add":" return (size_t)MEM_readLE32(memPtr);"},{"Add":" else"},{"Add":" return (size_t)MEM_readLE64(memPtr);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* MEM_H_MODULE */"},{"Add":""},{"Add":"/*"},{"Add":" zstd - standard compression library"},{"Add":" Header File for static linking only"},{"Add":" Copyright (C) 2014-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - zstd homepage : http://www.zstd.net"},{"Add":"*/"},{"Add":"#ifndef ZSTD_STATIC_H"},{"Add":"#define ZSTD_STATIC_H"},{"Add":""},{"Add":"/* The prototypes defined within this file are considered experimental."},{"Add":" * They should not be used in the context DLL as they may change in the future."},{"Add":" * Prefer static linking if you need them, to control breaking version changes issues."},{"Add":" */"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-*************************************"},{"Add":"* Types"},{"Add":"***************************************/"},{"Add":"#define ZSTDv05_WINDOWLOG_ABSOLUTEMIN 11"},{"Add":""},{"Add":""},{"Add":"/*-*************************************"},{"Add":"* Advanced functions"},{"Add":"***************************************/"},{"Add":"/*- Advanced Decompression functions -*/"},{"Add":""},{"Add":"/*! ZSTDv05_decompress_usingPreparedDCtx() :"},{"Add":"* Same as ZSTDv05_decompress_usingDict, but using a reference context `preparedDCtx`, where dictionary has been loaded."},{"Add":"* It avoids reloading the dictionary each time."},{"Add":"* `preparedDCtx` must have been properly initialized using ZSTDv05_decompressBegin_usingDict()."},{"Add":"* Requires 2 contexts : 1 for reference, which will not be modified, and 1 to run the decompression operation */"},{"Add":"size_t ZSTDv05_decompress_usingPreparedDCtx("},{"Add":" ZSTDv05_DCtx* dctx, const ZSTDv05_DCtx* preparedDCtx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize);"},{"Add":""},{"Add":""},{"Add":"/* **************************************"},{"Add":"* Streaming functions (direct mode)"},{"Add":"****************************************/"},{"Add":"size_t ZSTDv05_decompressBegin(ZSTDv05_DCtx* dctx);"},{"Add":""},{"Add":"/*"},{"Add":" Streaming decompression, direct mode (bufferless)"},{"Add":""},{"Add":" A ZSTDv05_DCtx object is required to track streaming operations."},{"Add":" Use ZSTDv05_createDCtx() / ZSTDv05_freeDCtx() to manage it."},{"Add":" A ZSTDv05_DCtx object can be re-used multiple times."},{"Add":""},{"Add":" First typical operation is to retrieve frame parameters, using ZSTDv05_getFrameParams()."},{"Add":" This operation is independent, and just needs enough input data to properly decode the frame header."},{"Add":" Objective is to retrieve *params.windowlog, to know minimum amount of memory required during decoding."},{"Add":" Result : 0 when successful, it means the ZSTDv05_parameters structure has been filled."},{"Add":" >0 : means there is not enough data into src. Provides the expected size to successfully decode header."},{"Add":" errorCode, which can be tested using ZSTDv05_isError()"},{"Add":""},{"Add":" Start decompression, with ZSTDv05_decompressBegin() or ZSTDv05_decompressBegin_usingDict()"},{"Add":" Alternatively, you can copy a prepared context, using ZSTDv05_copyDCtx()"},{"Add":""},{"Add":" Then use ZSTDv05_nextSrcSizeToDecompress() and ZSTDv05_decompressContinue() alternatively."},{"Add":" ZSTDv05_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTDv05_decompressContinue()."},{"Add":" ZSTDv05_decompressContinue() requires this exact amount of bytes, or it will fail."},{"Add":" ZSTDv05_decompressContinue() needs previous data blocks during decompression, up to (1 << windowlog)."},{"Add":" They should preferably be located contiguously, prior to current block. Alternatively, a round buffer is also possible."},{"Add":""},{"Add":" @result of ZSTDv05_decompressContinue() is the number of bytes regenerated within 'dst'."},{"Add":" It can be zero, which is not an error; it just means ZSTDv05_decompressContinue() has decoded some header."},{"Add":""},{"Add":" A frame is fully decoded when ZSTDv05_nextSrcSizeToDecompress() returns zero."},{"Add":" Context can then be reset to start a new decompression."},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/* **************************************"},{"Add":"* Block functions"},{"Add":"****************************************/"},{"Add":"/*! Block functions produce and decode raw zstd blocks, without frame metadata."},{"Add":" User will have to take in charge required information to regenerate data, such as block sizes."},{"Add":""},{"Add":" A few rules to respect :"},{"Add":" - Uncompressed block size must be <= 128 KB"},{"Add":" - Compressing or decompressing requires a context structure"},{"Add":" + Use ZSTDv05_createCCtx() and ZSTDv05_createDCtx()"},{"Add":" - It is necessary to init context before starting"},{"Add":" + compression : ZSTDv05_compressBegin()"},{"Add":" + decompression : ZSTDv05_decompressBegin()"},{"Add":" + variants _usingDict() are also allowed"},{"Add":" + copyCCtx() and copyDCtx() work too"},{"Add":" - When a block is considered not compressible enough, ZSTDv05_compressBlock() result will be zero."},{"Add":" In which case, nothing is produced into `dst`."},{"Add":" + User must test for such outcome and deal directly with uncompressed data"},{"Add":" + ZSTDv05_decompressBlock() doesn't accept uncompressed data as input !!"},{"Add":"*/"},{"Add":""},{"Add":"size_t ZSTDv05_decompressBlock(ZSTDv05_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);"},{"Add":""},{"Add":""},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* ZSTDv05_STATIC_H */"},{"Add":""},{"Add":""},{"Add":"/*"},{"Add":" zstd_internal - common functions to include"},{"Add":" Header File for include"},{"Add":" Copyright (C) 2014-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - zstd source repository : https://github.com/Cyan4973/zstd"},{"Add":"*/"},{"Add":"#ifndef ZSTD_CCOMMON_H_MODULE"},{"Add":"#define ZSTD_CCOMMON_H_MODULE"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-*************************************"},{"Add":"* Common macros"},{"Add":"***************************************/"},{"Add":"#define MIN(a,b) ((a)<(b) ? (a) : (b))"},{"Add":"#define MAX(a,b) ((a)>(b) ? (a) : (b))"},{"Add":""},{"Add":""},{"Add":"/*-*************************************"},{"Add":"* Common constants"},{"Add":"***************************************/"},{"Add":"#define ZSTDv05_DICT_MAGIC 0xEC30A435"},{"Add":""},{"Add":"#define KB *(1 <<10)"},{"Add":"#define MB *(1 <<20)"},{"Add":"#define GB *(1U<<30)"},{"Add":""},{"Add":"#define BLOCKSIZE (128 KB) /* define, for static allocation */"},{"Add":""},{"Add":"static const size_t ZSTDv05_blockHeaderSize = 3;"},{"Add":"static const size_t ZSTDv05_frameHeaderSize_min = 5;"},{"Add":"#define ZSTDv05_frameHeaderSize_max 5 /* define, for static allocation */"},{"Add":""},{"Add":"#define BITv057 128"},{"Add":"#define BITv056 64"},{"Add":"#define BITv055 32"},{"Add":"#define BITv054 16"},{"Add":"#define BITv051 2"},{"Add":"#define BITv050 1"},{"Add":""},{"Add":"#define IS_HUFv05 0"},{"Add":"#define IS_PCH 1"},{"Add":"#define IS_RAW 2"},{"Add":"#define IS_RLE 3"},{"Add":""},{"Add":"#define MINMATCH 4"},{"Add":"#define REPCODE_STARTVALUE 1"},{"Add":""},{"Add":"#define Litbits 8"},{"Add":"#define MLbits 7"},{"Add":"#define LLbits 6"},{"Add":"#define Offbits 5"},{"Add":"#define MaxLit ((1< /* size_t, ptrdiff_t */"},{"Add":""},{"Add":""},{"Add":"/*-****************************************"},{"Add":"* FSEv05 simple functions"},{"Add":"******************************************/"},{"Add":"size_t FSEv05_decompress(void* dst, size_t maxDstSize,"},{"Add":" const void* cSrc, size_t cSrcSize);"},{"Add":"/*!"},{"Add":"FSEv05_decompress():"},{"Add":" Decompress FSEv05 data from buffer 'cSrc', of size 'cSrcSize',"},{"Add":" into already allocated destination buffer 'dst', of size 'maxDstSize'."},{"Add":" return : size of regenerated data (<= maxDstSize)"},{"Add":" or an error code, which can be tested using FSEv05_isError()"},{"Add":""},{"Add":" ** Important ** : FSEv05_decompress() doesn't decompress non-compressible nor RLE data !!!"},{"Add":" Why ? : making this distinction requires a header."},{"Add":" Header management is intentionally delegated to the user layer, which can better manage special cases."},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/* *****************************************"},{"Add":"* Tool functions"},{"Add":"******************************************/"},{"Add":"/* Error Management */"},{"Add":"unsigned FSEv05_isError(size_t code); /* tells if a return value is an error code */"},{"Add":"const char* FSEv05_getErrorName(size_t code); /* provides error code string (useful for debugging) */"},{"Add":""},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* *****************************************"},{"Add":"* FSEv05 detailed API"},{"Add":"******************************************/"},{"Add":"/* *** DECOMPRESSION *** */"},{"Add":""},{"Add":"/*!"},{"Add":"FSEv05_readNCount():"},{"Add":" Read compactly saved 'normalizedCounter' from 'rBuffer'."},{"Add":" return : size read from 'rBuffer'"},{"Add":" or an errorCode, which can be tested using FSEv05_isError()"},{"Add":" maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */"},{"Add":"size_t FSEv05_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize);"},{"Add":""},{"Add":"/*!"},{"Add":"Constructor and Destructor of type FSEv05_DTable"},{"Add":" Note that its size depends on 'tableLog' */"},{"Add":"typedef unsigned FSEv05_DTable; /* don't allocate that. It's just a way to be more restrictive than void* */"},{"Add":"FSEv05_DTable* FSEv05_createDTable(unsigned tableLog);"},{"Add":"void FSEv05_freeDTable(FSEv05_DTable* dt);"},{"Add":""},{"Add":"/*!"},{"Add":"FSEv05_buildDTable():"},{"Add":" Builds 'dt', which must be already allocated, using FSEv05_createDTable()"},{"Add":" @return : 0,"},{"Add":" or an errorCode, which can be tested using FSEv05_isError() */"},{"Add":"size_t FSEv05_buildDTable (FSEv05_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);"},{"Add":""},{"Add":"/*!"},{"Add":"FSEv05_decompress_usingDTable():"},{"Add":" Decompress compressed source @cSrc of size @cSrcSize using `dt`"},{"Add":" into `dst` which must be already allocated."},{"Add":" @return : size of regenerated data (necessarily <= @dstCapacity)"},{"Add":" or an errorCode, which can be tested using FSEv05_isError() */"},{"Add":"size_t FSEv05_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSEv05_DTable* dt);"},{"Add":""},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* FSEv05_H */"},{"Add":"/* ******************************************************************"},{"Add":" bitstream"},{"Add":" Part of FSEv05 library"},{"Add":" header file (to include)"},{"Add":" Copyright (C) 2013-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":"****************************************************************** */"},{"Add":"#ifndef BITv05STREAM_H_MODULE"},{"Add":"#define BITv05STREAM_H_MODULE"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*"},{"Add":"* This API consists of small unitary functions, which highly benefit from being inlined."},{"Add":"* Since link-time-optimization is not available for all compilers,"},{"Add":"* these functions are defined into a .h to be included."},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-********************************************"},{"Add":"* bitStream decoding API (read backward)"},{"Add":"**********************************************/"},{"Add":"typedef struct"},{"Add":"{"},{"Add":" size_t bitContainer;"},{"Add":" unsigned bitsConsumed;"},{"Add":" const char* ptr;"},{"Add":" const char* start;"},{"Add":"} BITv05_DStream_t;"},{"Add":""},{"Add":"typedef enum { BITv05_DStream_unfinished = 0,"},{"Add":" BITv05_DStream_endOfBuffer = 1,"},{"Add":" BITv05_DStream_completed = 2,"},{"Add":" BITv05_DStream_overflow = 3 } BITv05_DStream_status; /* result of BITv05_reloadDStream() */"},{"Add":" /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */"},{"Add":""},{"Add":"MEM_STATIC size_t BITv05_initDStream(BITv05_DStream_t* bitD, const void* srcBuffer, size_t srcSize);"},{"Add":"MEM_STATIC size_t BITv05_readBits(BITv05_DStream_t* bitD, unsigned nbBits);"},{"Add":"MEM_STATIC BITv05_DStream_status BITv05_reloadDStream(BITv05_DStream_t* bitD);"},{"Add":"MEM_STATIC unsigned BITv05_endOfDStream(const BITv05_DStream_t* bitD);"},{"Add":""},{"Add":""},{"Add":"/*-****************************************"},{"Add":"* unsafe API"},{"Add":"******************************************/"},{"Add":"MEM_STATIC size_t BITv05_readBitsFast(BITv05_DStream_t* bitD, unsigned nbBits);"},{"Add":"/* faster, but works only if nbBits >= 1 */"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-**************************************************************"},{"Add":"* Helper functions"},{"Add":"****************************************************************/"},{"Add":"MEM_STATIC unsigned BITv05_highbit32 (U32 val)"},{"Add":"{"},{"Add":"# if defined(_MSC_VER) /* Visual */"},{"Add":" unsigned long r=0;"},{"Add":" _BitScanReverse ( &r, val );"},{"Add":" return (unsigned) r;"},{"Add":"# elif defined(__GNUC__) && (__GNUC__ >= 3) /* Use GCC Intrinsic */"},{"Add":" return __builtin_clz (val) ^ 31;"},{"Add":"# else /* Software version */"},{"Add":" static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };"},{"Add":" U32 v = val;"},{"Add":" unsigned r;"},{"Add":" v |= v >> 1;"},{"Add":" v |= v >> 2;"},{"Add":" v |= v >> 4;"},{"Add":" v |= v >> 8;"},{"Add":" v |= v >> 16;"},{"Add":" r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];"},{"Add":" return r;"},{"Add":"# endif"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-********************************************************"},{"Add":"* bitStream decoding"},{"Add":"**********************************************************/"},{"Add":"/*!BITv05_initDStream"},{"Add":"* Initialize a BITv05_DStream_t."},{"Add":"* @bitD : a pointer to an already allocated BITv05_DStream_t structure"},{"Add":"* @srcBuffer must point at the beginning of a bitStream"},{"Add":"* @srcSize must be the exact size of the bitStream"},{"Add":"* @result : size of stream (== srcSize) or an errorCode if a problem is detected"},{"Add":"*/"},{"Add":"MEM_STATIC size_t BITv05_initDStream(BITv05_DStream_t* bitD, const void* srcBuffer, size_t srcSize)"},{"Add":"{"},{"Add":" if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }"},{"Add":""},{"Add":" if (srcSize >= sizeof(size_t)) { /* normal case */"},{"Add":" U32 contain32;"},{"Add":" bitD->start = (const char*)srcBuffer;"},{"Add":" bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(size_t);"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr);"},{"Add":" contain32 = ((const BYTE*)srcBuffer)[srcSize-1];"},{"Add":" if (contain32 == 0) return ERROR(GENERIC); /* endMark not present */"},{"Add":" bitD->bitsConsumed = 8 - BITv05_highbit32(contain32);"},{"Add":" } else {"},{"Add":" U32 contain32;"},{"Add":" bitD->start = (const char*)srcBuffer;"},{"Add":" bitD->ptr = bitD->start;"},{"Add":" bitD->bitContainer = *(const BYTE*)(bitD->start);"},{"Add":" switch(srcSize)"},{"Add":" {"},{"Add":" case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16);/* fall-through */"},{"Add":" case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);/* fall-through */"},{"Add":" case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);/* fall-through */"},{"Add":" case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24; /* fall-through */"},{"Add":" case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16; /* fall-through */"},{"Add":" case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) << 8; /* fall-through */"},{"Add":" default: break;"},{"Add":" }"},{"Add":" contain32 = ((const BYTE*)srcBuffer)[srcSize-1];"},{"Add":" if (contain32 == 0) return ERROR(GENERIC); /* endMark not present */"},{"Add":" bitD->bitsConsumed = 8 - BITv05_highbit32(contain32);"},{"Add":" bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8;"},{"Add":" }"},{"Add":""},{"Add":" return srcSize;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC size_t BITv05_lookBits(BITv05_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;"},{"Add":" return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);"},{"Add":"}"},{"Add":""},{"Add":"/*! BITv05_lookBitsFast :"},{"Add":"* unsafe version; only works only if nbBits >= 1 */"},{"Add":"MEM_STATIC size_t BITv05_lookBitsFast(BITv05_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;"},{"Add":" return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void BITv05_skipBits(BITv05_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" bitD->bitsConsumed += nbBits;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC size_t BITv05_readBits(BITv05_DStream_t* bitD, unsigned nbBits)"},{"Add":"{"},{"Add":" size_t value = BITv05_lookBits(bitD, nbBits);"},{"Add":" BITv05_skipBits(bitD, nbBits);"},{"Add":" return value;"},{"Add":"}"},{"Add":""},{"Add":"/*!BITv05_readBitsFast :"},{"Add":"* unsafe version; only works only if nbBits >= 1 */"},{"Add":"MEM_STATIC size_t BITv05_readBitsFast(BITv05_DStream_t* bitD, unsigned nbBits)"},{"Add":"{"},{"Add":" size_t value = BITv05_lookBitsFast(bitD, nbBits);"},{"Add":" BITv05_skipBits(bitD, nbBits);"},{"Add":" return value;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BITv05_DStream_status BITv05_reloadDStream(BITv05_DStream_t* bitD)"},{"Add":"{"},{"Add":" if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* should never happen */"},{"Add":" return BITv05_DStream_overflow;"},{"Add":""},{"Add":" if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) {"},{"Add":" bitD->ptr -= bitD->bitsConsumed >> 3;"},{"Add":" bitD->bitsConsumed &= 7;"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr);"},{"Add":" return BITv05_DStream_unfinished;"},{"Add":" }"},{"Add":" if (bitD->ptr == bitD->start) {"},{"Add":" if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BITv05_DStream_endOfBuffer;"},{"Add":" return BITv05_DStream_completed;"},{"Add":" }"},{"Add":" {"},{"Add":" U32 nbBytes = bitD->bitsConsumed >> 3;"},{"Add":" BITv05_DStream_status result = BITv05_DStream_unfinished;"},{"Add":" if (bitD->ptr - nbBytes < bitD->start) {"},{"Add":" nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */"},{"Add":" result = BITv05_DStream_endOfBuffer;"},{"Add":" }"},{"Add":" bitD->ptr -= nbBytes;"},{"Add":" bitD->bitsConsumed -= nbBytes*8;"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD) */"},{"Add":" return result;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"/*! BITv05_endOfDStream"},{"Add":"* @return Tells if DStream has reached its exact end"},{"Add":"*/"},{"Add":"MEM_STATIC unsigned BITv05_endOfDStream(const BITv05_DStream_t* DStream)"},{"Add":"{"},{"Add":" return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));"},{"Add":"}"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* BITv05STREAM_H_MODULE */"},{"Add":"/* ******************************************************************"},{"Add":" FSEv05 : Finite State Entropy coder"},{"Add":" header file for static linking (only)"},{"Add":" Copyright (C) 2013-2015, Yann Collet"},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":"#ifndef FSEv05_STATIC_H"},{"Add":"#define FSEv05_STATIC_H"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* *****************************************"},{"Add":"* Static allocation"},{"Add":"*******************************************/"},{"Add":"/* It is possible to statically allocate FSEv05 CTable/DTable as a table of unsigned using below macros */"},{"Add":"#define FSEv05_DTABLE_SIZE_U32(maxTableLog) (1 + (1<= 1 (otherwise, result will be corrupted) */"},{"Add":""},{"Add":""},{"Add":"/* *****************************************"},{"Add":"* Implementation of inlined functions"},{"Add":"*******************************************/"},{"Add":"/* decompression */"},{"Add":""},{"Add":"typedef struct {"},{"Add":" U16 tableLog;"},{"Add":" U16 fastMode;"},{"Add":"} FSEv05_DTableHeader; /* sizeof U32 */"},{"Add":""},{"Add":"typedef struct"},{"Add":"{"},{"Add":" unsigned short newState;"},{"Add":" unsigned char symbol;"},{"Add":" unsigned char nbBits;"},{"Add":"} FSEv05_decode_t; /* size == U32 */"},{"Add":""},{"Add":"MEM_STATIC void FSEv05_initDState(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD, const FSEv05_DTable* dt)"},{"Add":"{"},{"Add":" const void* ptr = dt;"},{"Add":" const FSEv05_DTableHeader* const DTableH = (const FSEv05_DTableHeader*)ptr;"},{"Add":" DStatePtr->state = BITv05_readBits(bitD, DTableH->tableLog);"},{"Add":" BITv05_reloadDStream(bitD);"},{"Add":" DStatePtr->table = dt + 1;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BYTE FSEv05_peakSymbol(FSEv05_DState_t* DStatePtr)"},{"Add":"{"},{"Add":" const FSEv05_decode_t DInfo = ((const FSEv05_decode_t*)(DStatePtr->table))[DStatePtr->state];"},{"Add":" return DInfo.symbol;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BYTE FSEv05_decodeSymbol(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD)"},{"Add":"{"},{"Add":" const FSEv05_decode_t DInfo = ((const FSEv05_decode_t*)(DStatePtr->table))[DStatePtr->state];"},{"Add":" const U32 nbBits = DInfo.nbBits;"},{"Add":" BYTE symbol = DInfo.symbol;"},{"Add":" size_t lowBits = BITv05_readBits(bitD, nbBits);"},{"Add":""},{"Add":" DStatePtr->state = DInfo.newState + lowBits;"},{"Add":" return symbol;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BYTE FSEv05_decodeSymbolFast(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD)"},{"Add":"{"},{"Add":" const FSEv05_decode_t DInfo = ((const FSEv05_decode_t*)(DStatePtr->table))[DStatePtr->state];"},{"Add":" const U32 nbBits = DInfo.nbBits;"},{"Add":" BYTE symbol = DInfo.symbol;"},{"Add":" size_t lowBits = BITv05_readBitsFast(bitD, nbBits);"},{"Add":""},{"Add":" DStatePtr->state = DInfo.newState + lowBits;"},{"Add":" return symbol;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC unsigned FSEv05_endOfDState(const FSEv05_DState_t* DStatePtr)"},{"Add":"{"},{"Add":" return DStatePtr->state == 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* FSEv05_STATIC_H */"},{"Add":"/* ******************************************************************"},{"Add":" FSEv05 : Finite State Entropy coder"},{"Add":" Copyright (C) 2013-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - FSEv05 source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":""},{"Add":"#ifndef FSEv05_COMMONDEFS_ONLY"},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Tuning parameters"},{"Add":"****************************************************************/"},{"Add":"/*!MEMORY_USAGE :"},{"Add":"* Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)"},{"Add":"* Increasing memory usage improves compression ratio"},{"Add":"* Reduced memory usage can improve speed, due to cache effect"},{"Add":"* Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */"},{"Add":"#define FSEv05_MAX_MEMORY_USAGE 14"},{"Add":"#define FSEv05_DEFAULT_MEMORY_USAGE 13"},{"Add":""},{"Add":"/*!FSEv05_MAX_SYMBOL_VALUE :"},{"Add":"* Maximum symbol value authorized."},{"Add":"* Required for proper stack allocation */"},{"Add":"#define FSEv05_MAX_SYMBOL_VALUE 255"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* template functions type & suffix"},{"Add":"****************************************************************/"},{"Add":"#define FSEv05_FUNCTION_TYPE BYTE"},{"Add":"#define FSEv05_FUNCTION_EXTENSION"},{"Add":"#define FSEv05_DECODE_TYPE FSEv05_decode_t"},{"Add":""},{"Add":""},{"Add":"#endif /* !FSEv05_COMMONDEFS_ONLY */"},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Compiler specifics"},{"Add":"****************************************************************/"},{"Add":"#ifdef _MSC_VER /* Visual Studio */"},{"Add":"# define FORCE_INLINE static __forceinline"},{"Add":"# include /* For Visual 2005 */"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"# pragma warning(disable : 4214) /* disable: C4214: non-int bitfields */"},{"Add":"#else"},{"Add":"# if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */"},{"Add":"# ifdef __GNUC__"},{"Add":"# define FORCE_INLINE static inline __attribute__((always_inline))"},{"Add":"# else"},{"Add":"# define FORCE_INLINE static inline"},{"Add":"# endif"},{"Add":"# else"},{"Add":"# define FORCE_INLINE static"},{"Add":"# endif /* __STDC_VERSION__ */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Includes"},{"Add":"****************************************************************/"},{"Add":"#include /* malloc, free, qsort */"},{"Add":"#include /* memcpy, memset */"},{"Add":"#include /* printf (debug) */"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* ***************************************************************"},{"Add":"* Constants"},{"Add":"*****************************************************************/"},{"Add":"#define FSEv05_MAX_TABLELOG (FSEv05_MAX_MEMORY_USAGE-2)"},{"Add":"#define FSEv05_MAX_TABLESIZE (1U< FSEv05_TABLELOG_ABSOLUTE_MAX"},{"Add":"#error \"FSEv05_MAX_TABLELOG > FSEv05_TABLELOG_ABSOLUTE_MAX is not supported\""},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Error Management"},{"Add":"****************************************************************/"},{"Add":"#define FSEv05_STATIC_ASSERT(c) { enum { FSEv05_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Complex types"},{"Add":"****************************************************************/"},{"Add":"typedef unsigned DTable_max_t[FSEv05_DTABLE_SIZE_U32(FSEv05_MAX_TABLELOG)];"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Templates"},{"Add":"****************************************************************/"},{"Add":"/*"},{"Add":" designed to be included"},{"Add":" for type-specific functions (template emulation in C)"},{"Add":" Objective is to write these functions only once, for improved maintenance"},{"Add":"*/"},{"Add":""},{"Add":"/* safety checks */"},{"Add":"#ifndef FSEv05_FUNCTION_EXTENSION"},{"Add":"# error \"FSEv05_FUNCTION_EXTENSION must be defined\""},{"Add":"#endif"},{"Add":"#ifndef FSEv05_FUNCTION_TYPE"},{"Add":"# error \"FSEv05_FUNCTION_TYPE must be defined\""},{"Add":"#endif"},{"Add":""},{"Add":"/* Function names */"},{"Add":"#define FSEv05_CAT(X,Y) X##Y"},{"Add":"#define FSEv05_FUNCTION_NAME(X,Y) FSEv05_CAT(X,Y)"},{"Add":"#define FSEv05_TYPE_NAME(X,Y) FSEv05_CAT(X,Y)"},{"Add":""},{"Add":""},{"Add":"/* Function templates */"},{"Add":"static U32 FSEv05_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; }"},{"Add":""},{"Add":""},{"Add":""},{"Add":"FSEv05_DTable* FSEv05_createDTable (unsigned tableLog)"},{"Add":"{"},{"Add":" if (tableLog > FSEv05_TABLELOG_ABSOLUTE_MAX) tableLog = FSEv05_TABLELOG_ABSOLUTE_MAX;"},{"Add":" return (FSEv05_DTable*)malloc( FSEv05_DTABLE_SIZE_U32(tableLog) * sizeof (U32) );"},{"Add":"}"},{"Add":""},{"Add":"void FSEv05_freeDTable (FSEv05_DTable* dt)"},{"Add":"{"},{"Add":" free(dt);"},{"Add":"}"},{"Add":""},{"Add":"size_t FSEv05_buildDTable(FSEv05_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)"},{"Add":"{"},{"Add":" FSEv05_DTableHeader DTableH;"},{"Add":" void* const tdPtr = dt+1; /* because dt is unsigned, 32-bits aligned on 32-bits */"},{"Add":" FSEv05_DECODE_TYPE* const tableDecode = (FSEv05_DECODE_TYPE*) (tdPtr);"},{"Add":" const U32 tableSize = 1 << tableLog;"},{"Add":" const U32 tableMask = tableSize-1;"},{"Add":" const U32 step = FSEv05_tableStep(tableSize);"},{"Add":" U16 symbolNext[FSEv05_MAX_SYMBOL_VALUE+1];"},{"Add":" U32 position = 0;"},{"Add":" U32 highThreshold = tableSize-1;"},{"Add":" const S16 largeLimit= (S16)(1 << (tableLog-1));"},{"Add":" U32 noLarge = 1;"},{"Add":" U32 s;"},{"Add":""},{"Add":" /* Sanity Checks */"},{"Add":" if (maxSymbolValue > FSEv05_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);"},{"Add":" if (tableLog > FSEv05_MAX_TABLELOG) return ERROR(tableLog_tooLarge);"},{"Add":""},{"Add":" /* Init, lay down lowprob symbols */"},{"Add":" memset(tableDecode, 0, sizeof(FSEv05_FUNCTION_TYPE) * (maxSymbolValue+1) ); /* useless init, but keep static analyzer happy, and we don't need to performance optimize legacy decoders */"},{"Add":" DTableH.tableLog = (U16)tableLog;"},{"Add":" for (s=0; s<=maxSymbolValue; s++) {"},{"Add":" if (normalizedCounter[s]==-1) {"},{"Add":" tableDecode[highThreshold--].symbol = (FSEv05_FUNCTION_TYPE)s;"},{"Add":" symbolNext[s] = 1;"},{"Add":" } else {"},{"Add":" if (normalizedCounter[s] >= largeLimit) noLarge=0;"},{"Add":" symbolNext[s] = normalizedCounter[s];"},{"Add":" } }"},{"Add":""},{"Add":" /* Spread symbols */"},{"Add":" for (s=0; s<=maxSymbolValue; s++) {"},{"Add":" int i;"},{"Add":" for (i=0; i highThreshold) position = (position + step) & tableMask; /* lowprob area */"},{"Add":" } }"},{"Add":""},{"Add":" if (position!=0) return ERROR(GENERIC); /* position must reach all cells once, otherwise normalizedCounter is incorrect */"},{"Add":""},{"Add":" /* Build Decoding table */"},{"Add":" {"},{"Add":" U32 i;"},{"Add":" for (i=0; i FSEv05_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);"},{"Add":" bitStream >>= 4;"},{"Add":" bitCount = 4;"},{"Add":" *tableLogPtr = nbBits;"},{"Add":" remaining = (1<1) && (charnum<=*maxSVPtr)) {"},{"Add":" if (previous0) {"},{"Add":" unsigned n0 = charnum;"},{"Add":" while ((bitStream & 0xFFFF) == 0xFFFF) {"},{"Add":" n0+=24;"},{"Add":" if (ip < iend-5) {"},{"Add":" ip+=2;"},{"Add":" bitStream = MEM_readLE32(ip) >> bitCount;"},{"Add":" } else {"},{"Add":" bitStream >>= 16;"},{"Add":" bitCount+=16;"},{"Add":" } }"},{"Add":" while ((bitStream & 3) == 3) {"},{"Add":" n0+=3;"},{"Add":" bitStream>>=2;"},{"Add":" bitCount+=2;"},{"Add":" }"},{"Add":" n0 += bitStream & 3;"},{"Add":" bitCount += 2;"},{"Add":" if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);"},{"Add":" while (charnum < n0) normalizedCounter[charnum++] = 0;"},{"Add":" if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {"},{"Add":" ip += bitCount>>3;"},{"Add":" bitCount &= 7;"},{"Add":" bitStream = MEM_readLE32(ip) >> bitCount;"},{"Add":" }"},{"Add":" else"},{"Add":" bitStream >>= 2;"},{"Add":" }"},{"Add":" {"},{"Add":" const short max = (short)((2*threshold-1)-remaining);"},{"Add":" short count;"},{"Add":""},{"Add":" if ((bitStream & (threshold-1)) < (U32)max) {"},{"Add":" count = (short)(bitStream & (threshold-1));"},{"Add":" bitCount += nbBits-1;"},{"Add":" } else {"},{"Add":" count = (short)(bitStream & (2*threshold-1));"},{"Add":" if (count >= threshold) count -= max;"},{"Add":" bitCount += nbBits;"},{"Add":" }"},{"Add":""},{"Add":" count--; /* extra accuracy */"},{"Add":" remaining -= FSEv05_abs(count);"},{"Add":" normalizedCounter[charnum++] = count;"},{"Add":" previous0 = !count;"},{"Add":" while (remaining < threshold) {"},{"Add":" nbBits--;"},{"Add":" threshold >>= 1;"},{"Add":" }"},{"Add":""},{"Add":" if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {"},{"Add":" ip += bitCount>>3;"},{"Add":" bitCount &= 7;"},{"Add":" } else {"},{"Add":" bitCount -= (int)(8 * (iend - 4 - ip));"},{"Add":" ip = iend - 4;"},{"Add":" }"},{"Add":" bitStream = MEM_readLE32(ip) >> (bitCount & 31);"},{"Add":" } }"},{"Add":" if (remaining != 1) return ERROR(GENERIC);"},{"Add":" *maxSVPtr = charnum-1;"},{"Add":""},{"Add":" ip += (bitCount+7)>>3;"},{"Add":" if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong);"},{"Add":" return ip-istart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-*******************************************************"},{"Add":"* Decompression (Byte symbols)"},{"Add":"*********************************************************/"},{"Add":"size_t FSEv05_buildDTable_rle (FSEv05_DTable* dt, BYTE symbolValue)"},{"Add":"{"},{"Add":" void* ptr = dt;"},{"Add":" FSEv05_DTableHeader* const DTableH = (FSEv05_DTableHeader*)ptr;"},{"Add":" void* dPtr = dt + 1;"},{"Add":" FSEv05_decode_t* const cell = (FSEv05_decode_t*)dPtr;"},{"Add":""},{"Add":" DTableH->tableLog = 0;"},{"Add":" DTableH->fastMode = 0;"},{"Add":""},{"Add":" cell->newState = 0;"},{"Add":" cell->symbol = symbolValue;"},{"Add":" cell->nbBits = 0;"},{"Add":""},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t FSEv05_buildDTable_raw (FSEv05_DTable* dt, unsigned nbBits)"},{"Add":"{"},{"Add":" void* ptr = dt;"},{"Add":" FSEv05_DTableHeader* const DTableH = (FSEv05_DTableHeader*)ptr;"},{"Add":" void* dPtr = dt + 1;"},{"Add":" FSEv05_decode_t* const dinfo = (FSEv05_decode_t*)dPtr;"},{"Add":" const unsigned tableSize = 1 << nbBits;"},{"Add":" const unsigned tableMask = tableSize - 1;"},{"Add":" const unsigned maxSymbolValue = tableMask;"},{"Add":" unsigned s;"},{"Add":""},{"Add":" /* Sanity checks */"},{"Add":" if (nbBits < 1) return ERROR(GENERIC); /* min size */"},{"Add":""},{"Add":" /* Build Decoding Table */"},{"Add":" DTableH->tableLog = (U16)nbBits;"},{"Add":" DTableH->fastMode = 1;"},{"Add":" for (s=0; s<=maxSymbolValue; s++) {"},{"Add":" dinfo[s].newState = 0;"},{"Add":" dinfo[s].symbol = (BYTE)s;"},{"Add":" dinfo[s].nbBits = (BYTE)nbBits;"},{"Add":" }"},{"Add":""},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"FORCE_INLINE size_t FSEv05_decompress_usingDTable_generic("},{"Add":" void* dst, size_t maxDstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const FSEv05_DTable* dt, const unsigned fast)"},{"Add":"{"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* op = ostart;"},{"Add":" BYTE* const omax = op + maxDstSize;"},{"Add":" BYTE* const olimit = omax-3;"},{"Add":""},{"Add":" BITv05_DStream_t bitD;"},{"Add":" FSEv05_DState_t state1;"},{"Add":" FSEv05_DState_t state2;"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" /* Init */"},{"Add":" errorCode = BITv05_initDStream(&bitD, cSrc, cSrcSize); /* replaced last arg by maxCompressed Size */"},{"Add":" if (FSEv05_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" FSEv05_initDState(&state1, &bitD, dt);"},{"Add":" FSEv05_initDState(&state2, &bitD, dt);"},{"Add":""},{"Add":"#define FSEv05_GETSYMBOL(statePtr) fast ? FSEv05_decodeSymbolFast(statePtr, &bitD) : FSEv05_decodeSymbol(statePtr, &bitD)"},{"Add":""},{"Add":" /* 4 symbols per loop */"},{"Add":" for ( ; (BITv05_reloadDStream(&bitD)==BITv05_DStream_unfinished) && (op sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" BITv05_reloadDStream(&bitD);"},{"Add":""},{"Add":" op[1] = FSEv05_GETSYMBOL(&state2);"},{"Add":""},{"Add":" if (FSEv05_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" { if (BITv05_reloadDStream(&bitD) > BITv05_DStream_unfinished) { op+=2; break; } }"},{"Add":""},{"Add":" op[2] = FSEv05_GETSYMBOL(&state1);"},{"Add":""},{"Add":" if (FSEv05_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" BITv05_reloadDStream(&bitD);"},{"Add":""},{"Add":" op[3] = FSEv05_GETSYMBOL(&state2);"},{"Add":" }"},{"Add":""},{"Add":" /* tail */"},{"Add":" /* note : BITv05_reloadDStream(&bitD) >= FSEv05_DStream_partiallyFilled; Ends at exactly BITv05_DStream_completed */"},{"Add":" while (1) {"},{"Add":" if ( (BITv05_reloadDStream(&bitD)>BITv05_DStream_completed) || (op==omax) || (BITv05_endOfDStream(&bitD) && (fast || FSEv05_endOfDState(&state1))) )"},{"Add":" break;"},{"Add":""},{"Add":" *op++ = FSEv05_GETSYMBOL(&state1);"},{"Add":""},{"Add":" if ( (BITv05_reloadDStream(&bitD)>BITv05_DStream_completed) || (op==omax) || (BITv05_endOfDStream(&bitD) && (fast || FSEv05_endOfDState(&state2))) )"},{"Add":" break;"},{"Add":""},{"Add":" *op++ = FSEv05_GETSYMBOL(&state2);"},{"Add":" }"},{"Add":""},{"Add":" /* end ? */"},{"Add":" if (BITv05_endOfDStream(&bitD) && FSEv05_endOfDState(&state1) && FSEv05_endOfDState(&state2))"},{"Add":" return op-ostart;"},{"Add":""},{"Add":" if (op==omax) return ERROR(dstSize_tooSmall); /* dst buffer is full, but cSrc unfinished */"},{"Add":""},{"Add":" return ERROR(corruption_detected);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t FSEv05_decompress_usingDTable(void* dst, size_t originalSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const FSEv05_DTable* dt)"},{"Add":"{"},{"Add":" const void* ptr = dt;"},{"Add":" const FSEv05_DTableHeader* DTableH = (const FSEv05_DTableHeader*)ptr;"},{"Add":" const U32 fastMode = DTableH->fastMode;"},{"Add":""},{"Add":" /* select fast mode (static) */"},{"Add":" if (fastMode) return FSEv05_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);"},{"Add":" return FSEv05_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t FSEv05_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE*)cSrc;"},{"Add":" const BYTE* ip = istart;"},{"Add":" short counting[FSEv05_MAX_SYMBOL_VALUE+1];"},{"Add":" DTable_max_t dt; /* Static analyzer seems unable to understand this table will be properly initialized later */"},{"Add":" unsigned tableLog;"},{"Add":" unsigned maxSymbolValue = FSEv05_MAX_SYMBOL_VALUE;"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" if (cSrcSize<2) return ERROR(srcSize_wrong); /* too small input size */"},{"Add":""},{"Add":" /* normal FSEv05 decoding mode */"},{"Add":" errorCode = FSEv05_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);"},{"Add":" if (FSEv05_isError(errorCode)) return errorCode;"},{"Add":" if (errorCode >= cSrcSize) return ERROR(srcSize_wrong); /* too small input size */"},{"Add":" ip += errorCode;"},{"Add":" cSrcSize -= errorCode;"},{"Add":""},{"Add":" errorCode = FSEv05_buildDTable (dt, counting, maxSymbolValue, tableLog);"},{"Add":" if (FSEv05_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" /* always return, even if it is an error code */"},{"Add":" return FSEv05_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"#endif /* FSEv05_COMMONDEFS_ONLY */"},{"Add":"/* ******************************************************************"},{"Add":" Huff0 : Huffman coder, part of New Generation Entropy library"},{"Add":" header file"},{"Add":" Copyright (C) 2013-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":"****************************************************************** */"},{"Add":"#ifndef HUFF0_H"},{"Add":"#define HUFF0_H"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* ****************************************"},{"Add":"* Huff0 simple functions"},{"Add":"******************************************/"},{"Add":"size_t HUFv05_decompress(void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize);"},{"Add":"/*!"},{"Add":"HUFv05_decompress():"},{"Add":" Decompress Huff0 data from buffer 'cSrc', of size 'cSrcSize',"},{"Add":" into already allocated destination buffer 'dst', of size 'dstSize'."},{"Add":" @dstSize : must be the **exact** size of original (uncompressed) data."},{"Add":" Note : in contrast with FSEv05, HUFv05_decompress can regenerate"},{"Add":" RLE (cSrcSize==1) and uncompressed (cSrcSize==dstSize) data,"},{"Add":" because it knows size to regenerate."},{"Add":" @return : size of regenerated data (== dstSize)"},{"Add":" or an error code, which can be tested using HUFv05_isError()"},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/* ****************************************"},{"Add":"* Tool functions"},{"Add":"******************************************/"},{"Add":"/* Error Management */"},{"Add":"unsigned HUFv05_isError(size_t code); /* tells if a return value is an error code */"},{"Add":"const char* HUFv05_getErrorName(size_t code); /* provides error code string (useful for debugging) */"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* HUF0_H */"},{"Add":"/* ******************************************************************"},{"Add":" Huff0 : Huffman codec, part of New Generation Entropy library"},{"Add":" header file, for static linking only"},{"Add":" Copyright (C) 2013-2016, Yann Collet"},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":"****************************************************************** */"},{"Add":"#ifndef HUF0_STATIC_H"},{"Add":"#define HUF0_STATIC_H"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* ****************************************"},{"Add":"* Static allocation"},{"Add":"******************************************/"},{"Add":"/* static allocation of Huff0's DTable */"},{"Add":"#define HUFv05_DTABLE_SIZE(maxTableLog) (1 + (1<= 199901L) /* C99 */)"},{"Add":"/* inline is defined */"},{"Add":"#elif defined(_MSC_VER)"},{"Add":"# define inline __inline"},{"Add":"#else"},{"Add":"# define inline /* disable inline */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"#ifdef _MSC_VER /* Visual Studio */"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Includes"},{"Add":"****************************************************************/"},{"Add":"#include /* malloc, free, qsort */"},{"Add":"#include /* memcpy, memset */"},{"Add":"#include /* printf (debug) */"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Constants"},{"Add":"****************************************************************/"},{"Add":"#define HUFv05_ABSOLUTEMAX_TABLELOG 16 /* absolute limit of HUFv05_MAX_TABLELOG. Beyond that value, code does not work */"},{"Add":"#define HUFv05_MAX_TABLELOG 12 /* max configured tableLog (for static allocation); can be modified up to HUFv05_ABSOLUTEMAX_TABLELOG */"},{"Add":"#define HUFv05_DEFAULT_TABLELOG HUFv05_MAX_TABLELOG /* tableLog by default, when not specified */"},{"Add":"#define HUFv05_MAX_SYMBOL_VALUE 255"},{"Add":"#if (HUFv05_MAX_TABLELOG > HUFv05_ABSOLUTEMAX_TABLELOG)"},{"Add":"# error \"HUFv05_MAX_TABLELOG is too large !\""},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Error Management"},{"Add":"****************************************************************/"},{"Add":"unsigned HUFv05_isError(size_t code) { return ERR_isError(code); }"},{"Add":"const char* HUFv05_getErrorName(size_t code) { return ERR_getErrorName(code); }"},{"Add":"#define HUFv05_STATIC_ASSERT(c) { enum { HUFv05_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */"},{"Add":""},{"Add":""},{"Add":"/* *******************************************************"},{"Add":"* Huff0 : Huffman block decompression"},{"Add":"*********************************************************/"},{"Add":"typedef struct { BYTE byte; BYTE nbBits; } HUFv05_DEltX2; /* single-symbol decoding */"},{"Add":""},{"Add":"typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUFv05_DEltX4; /* double-symbols decoding */"},{"Add":""},{"Add":"typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;"},{"Add":""},{"Add":"/*! HUFv05_readStats"},{"Add":" Read compact Huffman tree, saved by HUFv05_writeCTable"},{"Add":" @huffWeight : destination buffer"},{"Add":" @return : size read from `src`"},{"Add":"*/"},{"Add":"static size_t HUFv05_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,"},{"Add":" U32* nbSymbolsPtr, U32* tableLogPtr,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" U32 weightTotal;"},{"Add":" U32 tableLog;"},{"Add":" const BYTE* ip = (const BYTE*) src;"},{"Add":" size_t iSize;"},{"Add":" size_t oSize;"},{"Add":" U32 n;"},{"Add":""},{"Add":" if (!srcSize) return ERROR(srcSize_wrong);"},{"Add":" iSize = ip[0];"},{"Add":" /* memset(huffWeight, 0, hwSize); */ /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" if (iSize >= 128) { /* special header */"},{"Add":" if (iSize >= (242)) { /* RLE */"},{"Add":" static int l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };"},{"Add":" oSize = l[iSize-242];"},{"Add":" memset(huffWeight, 1, hwSize);"},{"Add":" iSize = 0;"},{"Add":" }"},{"Add":" else { /* Incompressible */"},{"Add":" oSize = iSize - 127;"},{"Add":" iSize = ((oSize+1)/2);"},{"Add":" if (iSize+1 > srcSize) return ERROR(srcSize_wrong);"},{"Add":" if (oSize >= hwSize) return ERROR(corruption_detected);"},{"Add":" ip += 1;"},{"Add":" for (n=0; n> 4;"},{"Add":" huffWeight[n+1] = ip[n/2] & 15;"},{"Add":" } } }"},{"Add":" else { /* header compressed with FSEv05 (normal case) */"},{"Add":" if (iSize+1 > srcSize) return ERROR(srcSize_wrong);"},{"Add":" oSize = FSEv05_decompress(huffWeight, hwSize-1, ip+1, iSize); /* max (hwSize-1) values decoded, as last one is implied */"},{"Add":" if (FSEv05_isError(oSize)) return oSize;"},{"Add":" }"},{"Add":""},{"Add":" /* collect weight stats */"},{"Add":" memset(rankStats, 0, (HUFv05_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32));"},{"Add":" weightTotal = 0;"},{"Add":" for (n=0; n= HUFv05_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);"},{"Add":" rankStats[huffWeight[n]]++;"},{"Add":" weightTotal += (1 << huffWeight[n]) >> 1;"},{"Add":" }"},{"Add":" if (weightTotal == 0) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* get last non-null symbol weight (implied, total must be 2^n) */"},{"Add":" tableLog = BITv05_highbit32(weightTotal) + 1;"},{"Add":" if (tableLog > HUFv05_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);"},{"Add":" { /* determine last weight */"},{"Add":" U32 total = 1 << tableLog;"},{"Add":" U32 rest = total - weightTotal;"},{"Add":" U32 verif = 1 << BITv05_highbit32(rest);"},{"Add":" U32 lastWeight = BITv05_highbit32(rest) + 1;"},{"Add":" if (verif != rest) return ERROR(corruption_detected); /* last value must be a clean power of 2 */"},{"Add":" huffWeight[oSize] = (BYTE)lastWeight;"},{"Add":" rankStats[lastWeight]++;"},{"Add":" }"},{"Add":""},{"Add":" /* check tree construction validity */"},{"Add":" if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected); /* by construction : at least 2 elts of rank 1, must be even */"},{"Add":""},{"Add":" /* results */"},{"Add":" *nbSymbolsPtr = (U32)(oSize+1);"},{"Add":" *tableLogPtr = tableLog;"},{"Add":" return iSize+1;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*-***************************/"},{"Add":"/* single-symbol decoding */"},{"Add":"/*-***************************/"},{"Add":""},{"Add":"size_t HUFv05_readDTableX2 (U16* DTable, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" BYTE huffWeight[HUFv05_MAX_SYMBOL_VALUE + 1];"},{"Add":" U32 rankVal[HUFv05_ABSOLUTEMAX_TABLELOG + 1]; /* large enough for values from 0 to 16 */"},{"Add":" U32 tableLog = 0;"},{"Add":" size_t iSize;"},{"Add":" U32 nbSymbols = 0;"},{"Add":" U32 n;"},{"Add":" U32 nextRankStart;"},{"Add":" void* const dtPtr = DTable + 1;"},{"Add":" HUFv05_DEltX2* const dt = (HUFv05_DEltX2*)dtPtr;"},{"Add":""},{"Add":" HUFv05_STATIC_ASSERT(sizeof(HUFv05_DEltX2) == sizeof(U16)); /* if compilation fails here, assertion is false */"},{"Add":" /* memset(huffWeight, 0, sizeof(huffWeight)); */ /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" iSize = HUFv05_readStats(huffWeight, HUFv05_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);"},{"Add":" if (HUFv05_isError(iSize)) return iSize;"},{"Add":""},{"Add":" /* check result */"},{"Add":" if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge); /* DTable is too small */"},{"Add":" DTable[0] = (U16)tableLog; /* maybe should separate sizeof allocated DTable, from used size of DTable, in case of re-use */"},{"Add":""},{"Add":" /* Prepare ranks */"},{"Add":" nextRankStart = 0;"},{"Add":" for (n=1; n<=tableLog; n++) {"},{"Add":" U32 current = nextRankStart;"},{"Add":" nextRankStart += (rankVal[n] << (n-1));"},{"Add":" rankVal[n] = current;"},{"Add":" }"},{"Add":""},{"Add":" /* fill DTable */"},{"Add":" for (n=0; n> 1;"},{"Add":" U32 i;"},{"Add":" HUFv05_DEltX2 D;"},{"Add":" D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);"},{"Add":" for (i = rankVal[w]; i < rankVal[w] + length; i++)"},{"Add":" dt[i] = D;"},{"Add":" rankVal[w] += length;"},{"Add":" }"},{"Add":""},{"Add":" return iSize;"},{"Add":"}"},{"Add":""},{"Add":"static BYTE HUFv05_decodeSymbolX2(BITv05_DStream_t* Dstream, const HUFv05_DEltX2* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" const size_t val = BITv05_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */"},{"Add":" const BYTE c = dt[val].byte;"},{"Add":" BITv05_skipBits(Dstream, dt[val].nbBits);"},{"Add":" return c;"},{"Add":"}"},{"Add":""},{"Add":"#define HUFv05_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \\"},{"Add":" *ptr++ = HUFv05_decodeSymbolX2(DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUFv05_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits() || (HUFv05_MAX_TABLELOG<=12)) \\"},{"Add":" HUFv05_DECODE_SYMBOLX2_0(ptr, DStreamPtr)"},{"Add":""},{"Add":"#define HUFv05_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits()) \\"},{"Add":" HUFv05_DECODE_SYMBOLX2_0(ptr, DStreamPtr)"},{"Add":""},{"Add":"static inline size_t HUFv05_decodeStreamX2(BYTE* p, BITv05_DStream_t* const bitDPtr, BYTE* const pEnd, const HUFv05_DEltX2* const dt, const U32 dtLog)"},{"Add":"{"},{"Add":" BYTE* const pStart = p;"},{"Add":""},{"Add":" /* up to 4 symbols at a time */"},{"Add":" while ((BITv05_reloadDStream(bitDPtr) == BITv05_DStream_unfinished) && (p <= pEnd-4)) {"},{"Add":" HUFv05_DECODE_SYMBOLX2_2(p, bitDPtr);"},{"Add":" HUFv05_DECODE_SYMBOLX2_1(p, bitDPtr);"},{"Add":" HUFv05_DECODE_SYMBOLX2_2(p, bitDPtr);"},{"Add":" HUFv05_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":" }"},{"Add":""},{"Add":" /* closer to the end */"},{"Add":" while ((BITv05_reloadDStream(bitDPtr) == BITv05_DStream_unfinished) && (p < pEnd))"},{"Add":" HUFv05_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":""},{"Add":" /* no more data to retrieve from bitstream, hence no need to reload */"},{"Add":" while (p < pEnd)"},{"Add":" HUFv05_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":""},{"Add":" return pEnd-pStart;"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv05_decompress1X2_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const U16* DTable)"},{"Add":"{"},{"Add":" BYTE* op = (BYTE*)dst;"},{"Add":" BYTE* const oend = op + dstSize;"},{"Add":" const U32 dtLog = DTable[0];"},{"Add":" const void* dtPtr = DTable;"},{"Add":" const HUFv05_DEltX2* const dt = ((const HUFv05_DEltX2*)dtPtr)+1;"},{"Add":" BITv05_DStream_t bitD;"},{"Add":""},{"Add":" if (dstSize <= cSrcSize) return ERROR(dstSize_tooSmall);"},{"Add":" { size_t const errorCode = BITv05_initDStream(&bitD, cSrc, cSrcSize);"},{"Add":" if (HUFv05_isError(errorCode)) return errorCode; }"},{"Add":""},{"Add":" HUFv05_decodeStreamX2(op, &bitD, oend, dt, dtLog);"},{"Add":""},{"Add":" /* check */"},{"Add":" if (!BITv05_endOfDStream(&bitD)) return ERROR(corruption_detected);"},{"Add":""},{"Add":" return dstSize;"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv05_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUFv05_CREATE_STATIC_DTABLEX2(DTable, HUFv05_MAX_TABLELOG);"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" errorCode = HUFv05_readDTableX2 (DTable, cSrc, cSrcSize);"},{"Add":" if (HUFv05_isError(errorCode)) return errorCode;"},{"Add":" if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += errorCode;"},{"Add":" cSrcSize -= errorCode;"},{"Add":""},{"Add":" return HUFv05_decompress1X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t HUFv05_decompress4X2_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const U16* DTable)"},{"Add":"{"},{"Add":" /* Check */"},{"Add":" if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */"},{"Add":" {"},{"Add":" const BYTE* const istart = (const BYTE*) cSrc;"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* const oend = ostart + dstSize;"},{"Add":" const void* const dtPtr = DTable;"},{"Add":" const HUFv05_DEltX2* const dt = ((const HUFv05_DEltX2*)dtPtr) +1;"},{"Add":" const U32 dtLog = DTable[0];"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" /* Init */"},{"Add":" BITv05_DStream_t bitD1;"},{"Add":" BITv05_DStream_t bitD2;"},{"Add":" BITv05_DStream_t bitD3;"},{"Add":" BITv05_DStream_t bitD4;"},{"Add":" const size_t length1 = MEM_readLE16(istart);"},{"Add":" const size_t length2 = MEM_readLE16(istart+2);"},{"Add":" const size_t length3 = MEM_readLE16(istart+4);"},{"Add":" size_t length4;"},{"Add":" const BYTE* const istart1 = istart + 6; /* jumpTable */"},{"Add":" const BYTE* const istart2 = istart1 + length1;"},{"Add":" const BYTE* const istart3 = istart2 + length2;"},{"Add":" const BYTE* const istart4 = istart3 + length3;"},{"Add":" const size_t segmentSize = (dstSize+3) / 4;"},{"Add":" BYTE* const opStart2 = ostart + segmentSize;"},{"Add":" BYTE* const opStart3 = opStart2 + segmentSize;"},{"Add":" BYTE* const opStart4 = opStart3 + segmentSize;"},{"Add":" BYTE* op1 = ostart;"},{"Add":" BYTE* op2 = opStart2;"},{"Add":" BYTE* op3 = opStart3;"},{"Add":" BYTE* op4 = opStart4;"},{"Add":" U32 endSignal;"},{"Add":""},{"Add":" length4 = cSrcSize - (length1 + length2 + length3 + 6);"},{"Add":" if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */"},{"Add":" errorCode = BITv05_initDStream(&bitD1, istart1, length1);"},{"Add":" if (HUFv05_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BITv05_initDStream(&bitD2, istart2, length2);"},{"Add":" if (HUFv05_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BITv05_initDStream(&bitD3, istart3, length3);"},{"Add":" if (HUFv05_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BITv05_initDStream(&bitD4, istart4, length4);"},{"Add":" if (HUFv05_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" /* 16-32 symbols per loop (4-8 symbols per stream) */"},{"Add":" endSignal = BITv05_reloadDStream(&bitD1) | BITv05_reloadDStream(&bitD2) | BITv05_reloadDStream(&bitD3) | BITv05_reloadDStream(&bitD4);"},{"Add":" for ( ; (endSignal==BITv05_DStream_unfinished) && (op4<(oend-7)) ; ) {"},{"Add":" HUFv05_DECODE_SYMBOLX2_2(op1, &bitD1);"},{"Add":" HUFv05_DECODE_SYMBOLX2_2(op2, &bitD2);"},{"Add":" HUFv05_DECODE_SYMBOLX2_2(op3, &bitD3);"},{"Add":" HUFv05_DECODE_SYMBOLX2_2(op4, &bitD4);"},{"Add":" HUFv05_DECODE_SYMBOLX2_1(op1, &bitD1);"},{"Add":" HUFv05_DECODE_SYMBOLX2_1(op2, &bitD2);"},{"Add":" HUFv05_DECODE_SYMBOLX2_1(op3, &bitD3);"},{"Add":" HUFv05_DECODE_SYMBOLX2_1(op4, &bitD4);"},{"Add":" HUFv05_DECODE_SYMBOLX2_2(op1, &bitD1);"},{"Add":" HUFv05_DECODE_SYMBOLX2_2(op2, &bitD2);"},{"Add":" HUFv05_DECODE_SYMBOLX2_2(op3, &bitD3);"},{"Add":" HUFv05_DECODE_SYMBOLX2_2(op4, &bitD4);"},{"Add":" HUFv05_DECODE_SYMBOLX2_0(op1, &bitD1);"},{"Add":" HUFv05_DECODE_SYMBOLX2_0(op2, &bitD2);"},{"Add":" HUFv05_DECODE_SYMBOLX2_0(op3, &bitD3);"},{"Add":" HUFv05_DECODE_SYMBOLX2_0(op4, &bitD4);"},{"Add":" endSignal = BITv05_reloadDStream(&bitD1) | BITv05_reloadDStream(&bitD2) | BITv05_reloadDStream(&bitD3) | BITv05_reloadDStream(&bitD4);"},{"Add":" }"},{"Add":""},{"Add":" /* check corruption */"},{"Add":" if (op1 > opStart2) return ERROR(corruption_detected);"},{"Add":" if (op2 > opStart3) return ERROR(corruption_detected);"},{"Add":" if (op3 > opStart4) return ERROR(corruption_detected);"},{"Add":" /* note : op4 supposed already verified within main loop */"},{"Add":""},{"Add":" /* finish bitStreams one by one */"},{"Add":" HUFv05_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);"},{"Add":" HUFv05_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);"},{"Add":" HUFv05_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);"},{"Add":" HUFv05_decodeStreamX2(op4, &bitD4, oend, dt, dtLog);"},{"Add":""},{"Add":" /* check */"},{"Add":" endSignal = BITv05_endOfDStream(&bitD1) & BITv05_endOfDStream(&bitD2) & BITv05_endOfDStream(&bitD3) & BITv05_endOfDStream(&bitD4);"},{"Add":" if (!endSignal) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* decoded size */"},{"Add":" return dstSize;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t HUFv05_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUFv05_CREATE_STATIC_DTABLEX2(DTable, HUFv05_MAX_TABLELOG);"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" errorCode = HUFv05_readDTableX2 (DTable, cSrc, cSrcSize);"},{"Add":" if (HUFv05_isError(errorCode)) return errorCode;"},{"Add":" if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += errorCode;"},{"Add":" cSrcSize -= errorCode;"},{"Add":""},{"Add":" return HUFv05_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/* *************************/"},{"Add":"/* double-symbols decoding */"},{"Add":"/* *************************/"},{"Add":""},{"Add":"static void HUFv05_fillDTableX4Level2(HUFv05_DEltX4* DTable, U32 sizeLog, const U32 consumed,"},{"Add":" const U32* rankValOrigin, const int minWeight,"},{"Add":" const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,"},{"Add":" U32 nbBitsBaseline, U16 baseSeq)"},{"Add":"{"},{"Add":" HUFv05_DEltX4 DElt;"},{"Add":" U32 rankVal[HUFv05_ABSOLUTEMAX_TABLELOG + 1];"},{"Add":" U32 s;"},{"Add":""},{"Add":" /* get pre-calculated rankVal */"},{"Add":" memcpy(rankVal, rankValOrigin, sizeof(rankVal));"},{"Add":""},{"Add":" /* fill skipped values */"},{"Add":" if (minWeight>1) {"},{"Add":" U32 i, skipSize = rankVal[minWeight];"},{"Add":" MEM_writeLE16(&(DElt.sequence), baseSeq);"},{"Add":" DElt.nbBits = (BYTE)(consumed);"},{"Add":" DElt.length = 1;"},{"Add":" for (i = 0; i < skipSize; i++)"},{"Add":" DTable[i] = DElt;"},{"Add":" }"},{"Add":""},{"Add":" /* fill DTable */"},{"Add":" for (s=0; s= 1 */"},{"Add":""},{"Add":" rankVal[weight] += length;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"typedef U32 rankVal_t[HUFv05_ABSOLUTEMAX_TABLELOG][HUFv05_ABSOLUTEMAX_TABLELOG + 1];"},{"Add":""},{"Add":"static void HUFv05_fillDTableX4(HUFv05_DEltX4* DTable, const U32 targetLog,"},{"Add":" const sortedSymbol_t* sortedList, const U32 sortedListSize,"},{"Add":" const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,"},{"Add":" const U32 nbBitsBaseline)"},{"Add":"{"},{"Add":" U32 rankVal[HUFv05_ABSOLUTEMAX_TABLELOG + 1];"},{"Add":" const int scaleLog = nbBitsBaseline - targetLog; /* note : targetLog >= srcLog, hence scaleLog <= 1 */"},{"Add":" const U32 minBits = nbBitsBaseline - maxWeight;"},{"Add":" U32 s;"},{"Add":""},{"Add":" memcpy(rankVal, rankValOrigin, sizeof(rankVal));"},{"Add":""},{"Add":" /* fill DTable */"},{"Add":" for (s=0; s= minBits) { /* enough room for a second symbol */"},{"Add":" U32 sortedRank;"},{"Add":" int minWeight = nbBits + scaleLog;"},{"Add":" if (minWeight < 1) minWeight = 1;"},{"Add":" sortedRank = rankStart[minWeight];"},{"Add":" HUFv05_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,"},{"Add":" rankValOrigin[nbBits], minWeight,"},{"Add":" sortedList+sortedRank, sortedListSize-sortedRank,"},{"Add":" nbBitsBaseline, symbol);"},{"Add":" } else {"},{"Add":" U32 i;"},{"Add":" const U32 end = start + length;"},{"Add":" HUFv05_DEltX4 DElt;"},{"Add":""},{"Add":" MEM_writeLE16(&(DElt.sequence), symbol);"},{"Add":" DElt.nbBits = (BYTE)(nbBits);"},{"Add":" DElt.length = 1;"},{"Add":" for (i = start; i < end; i++)"},{"Add":" DTable[i] = DElt;"},{"Add":" }"},{"Add":" rankVal[weight] += length;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv05_readDTableX4 (unsigned* DTable, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" BYTE weightList[HUFv05_MAX_SYMBOL_VALUE + 1];"},{"Add":" sortedSymbol_t sortedSymbol[HUFv05_MAX_SYMBOL_VALUE + 1];"},{"Add":" U32 rankStats[HUFv05_ABSOLUTEMAX_TABLELOG + 1] = { 0 };"},{"Add":" U32 rankStart0[HUFv05_ABSOLUTEMAX_TABLELOG + 2] = { 0 };"},{"Add":" U32* const rankStart = rankStart0+1;"},{"Add":" rankVal_t rankVal;"},{"Add":" U32 tableLog, maxW, sizeOfSort, nbSymbols;"},{"Add":" const U32 memLog = DTable[0];"},{"Add":" size_t iSize;"},{"Add":" void* dtPtr = DTable;"},{"Add":" HUFv05_DEltX4* const dt = ((HUFv05_DEltX4*)dtPtr) + 1;"},{"Add":""},{"Add":" HUFv05_STATIC_ASSERT(sizeof(HUFv05_DEltX4) == sizeof(unsigned)); /* if compilation fails here, assertion is false */"},{"Add":" if (memLog > HUFv05_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);"},{"Add":" /* memset(weightList, 0, sizeof(weightList)); */ /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" iSize = HUFv05_readStats(weightList, HUFv05_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);"},{"Add":" if (HUFv05_isError(iSize)) return iSize;"},{"Add":""},{"Add":" /* check result */"},{"Add":" if (tableLog > memLog) return ERROR(tableLog_tooLarge); /* DTable can't fit code depth */"},{"Add":""},{"Add":" /* find maxWeight */"},{"Add":" for (maxW = tableLog; rankStats[maxW]==0; maxW--) {} /* necessarily finds a solution before 0 */"},{"Add":""},{"Add":" /* Get start index of each weight */"},{"Add":" {"},{"Add":" U32 w, nextRankStart = 0;"},{"Add":" for (w=1; w<=maxW; w++) {"},{"Add":" U32 current = nextRankStart;"},{"Add":" nextRankStart += rankStats[w];"},{"Add":" rankStart[w] = current;"},{"Add":" }"},{"Add":" rankStart[0] = nextRankStart; /* put all 0w symbols at the end of sorted list*/"},{"Add":" sizeOfSort = nextRankStart;"},{"Add":" }"},{"Add":""},{"Add":" /* sort symbols by weight */"},{"Add":" {"},{"Add":" U32 s;"},{"Add":" for (s=0; s> consumed;"},{"Add":" } } }"},{"Add":""},{"Add":" HUFv05_fillDTableX4(dt, memLog,"},{"Add":" sortedSymbol, sizeOfSort,"},{"Add":" rankStart0, rankVal, maxW,"},{"Add":" tableLog+1);"},{"Add":""},{"Add":" return iSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static U32 HUFv05_decodeSymbolX4(void* op, BITv05_DStream_t* DStream, const HUFv05_DEltX4* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" const size_t val = BITv05_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */"},{"Add":" memcpy(op, dt+val, 2);"},{"Add":" BITv05_skipBits(DStream, dt[val].nbBits);"},{"Add":" return dt[val].length;"},{"Add":"}"},{"Add":""},{"Add":"static U32 HUFv05_decodeLastSymbolX4(void* op, BITv05_DStream_t* DStream, const HUFv05_DEltX4* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" const size_t val = BITv05_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */"},{"Add":" memcpy(op, dt+val, 1);"},{"Add":" if (dt[val].length==1) BITv05_skipBits(DStream, dt[val].nbBits);"},{"Add":" else {"},{"Add":" if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) {"},{"Add":" BITv05_skipBits(DStream, dt[val].nbBits);"},{"Add":" if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))"},{"Add":" DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8); /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */"},{"Add":" } }"},{"Add":" return 1;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"#define HUFv05_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \\"},{"Add":" ptr += HUFv05_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUFv05_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits() || (HUFv05_MAX_TABLELOG<=12)) \\"},{"Add":" ptr += HUFv05_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUFv05_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits()) \\"},{"Add":" ptr += HUFv05_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"static inline size_t HUFv05_decodeStreamX4(BYTE* p, BITv05_DStream_t* bitDPtr, BYTE* const pEnd, const HUFv05_DEltX4* const dt, const U32 dtLog)"},{"Add":"{"},{"Add":" BYTE* const pStart = p;"},{"Add":""},{"Add":" /* up to 8 symbols at a time */"},{"Add":" while ((BITv05_reloadDStream(bitDPtr) == BITv05_DStream_unfinished) && (p < pEnd-7)) {"},{"Add":" HUFv05_DECODE_SYMBOLX4_2(p, bitDPtr);"},{"Add":" HUFv05_DECODE_SYMBOLX4_1(p, bitDPtr);"},{"Add":" HUFv05_DECODE_SYMBOLX4_2(p, bitDPtr);"},{"Add":" HUFv05_DECODE_SYMBOLX4_0(p, bitDPtr);"},{"Add":" }"},{"Add":""},{"Add":" /* closer to the end */"},{"Add":" while ((BITv05_reloadDStream(bitDPtr) == BITv05_DStream_unfinished) && (p <= pEnd-2))"},{"Add":" HUFv05_DECODE_SYMBOLX4_0(p, bitDPtr);"},{"Add":""},{"Add":" while (p <= pEnd-2)"},{"Add":" HUFv05_DECODE_SYMBOLX4_0(p, bitDPtr); /* no need to reload : reached the end of DStream */"},{"Add":""},{"Add":" if (p < pEnd)"},{"Add":" p += HUFv05_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);"},{"Add":""},{"Add":" return p-pStart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t HUFv05_decompress1X4_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const unsigned* DTable)"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE*) cSrc;"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* const oend = ostart + dstSize;"},{"Add":""},{"Add":" const U32 dtLog = DTable[0];"},{"Add":" const void* const dtPtr = DTable;"},{"Add":" const HUFv05_DEltX4* const dt = ((const HUFv05_DEltX4*)dtPtr) +1;"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" /* Init */"},{"Add":" BITv05_DStream_t bitD;"},{"Add":" errorCode = BITv05_initDStream(&bitD, istart, cSrcSize);"},{"Add":" if (HUFv05_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" /* finish bitStreams one by one */"},{"Add":" HUFv05_decodeStreamX4(ostart, &bitD, oend, dt, dtLog);"},{"Add":""},{"Add":" /* check */"},{"Add":" if (!BITv05_endOfDStream(&bitD)) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* decoded size */"},{"Add":" return dstSize;"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv05_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUFv05_CREATE_STATIC_DTABLEX4(DTable, HUFv05_MAX_TABLELOG);"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":""},{"Add":" size_t hSize = HUFv05_readDTableX4 (DTable, cSrc, cSrcSize);"},{"Add":" if (HUFv05_isError(hSize)) return hSize;"},{"Add":" if (hSize >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += hSize;"},{"Add":" cSrcSize -= hSize;"},{"Add":""},{"Add":" return HUFv05_decompress1X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":"size_t HUFv05_decompress4X4_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const unsigned* DTable)"},{"Add":"{"},{"Add":" if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */"},{"Add":""},{"Add":" {"},{"Add":" const BYTE* const istart = (const BYTE*) cSrc;"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* const oend = ostart + dstSize;"},{"Add":" const void* const dtPtr = DTable;"},{"Add":" const HUFv05_DEltX4* const dt = ((const HUFv05_DEltX4*)dtPtr) +1;"},{"Add":" const U32 dtLog = DTable[0];"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" /* Init */"},{"Add":" BITv05_DStream_t bitD1;"},{"Add":" BITv05_DStream_t bitD2;"},{"Add":" BITv05_DStream_t bitD3;"},{"Add":" BITv05_DStream_t bitD4;"},{"Add":" const size_t length1 = MEM_readLE16(istart);"},{"Add":" const size_t length2 = MEM_readLE16(istart+2);"},{"Add":" const size_t length3 = MEM_readLE16(istart+4);"},{"Add":" size_t length4;"},{"Add":" const BYTE* const istart1 = istart + 6; /* jumpTable */"},{"Add":" const BYTE* const istart2 = istart1 + length1;"},{"Add":" const BYTE* const istart3 = istart2 + length2;"},{"Add":" const BYTE* const istart4 = istart3 + length3;"},{"Add":" const size_t segmentSize = (dstSize+3) / 4;"},{"Add":" BYTE* const opStart2 = ostart + segmentSize;"},{"Add":" BYTE* const opStart3 = opStart2 + segmentSize;"},{"Add":" BYTE* const opStart4 = opStart3 + segmentSize;"},{"Add":" BYTE* op1 = ostart;"},{"Add":" BYTE* op2 = opStart2;"},{"Add":" BYTE* op3 = opStart3;"},{"Add":" BYTE* op4 = opStart4;"},{"Add":" U32 endSignal;"},{"Add":""},{"Add":" length4 = cSrcSize - (length1 + length2 + length3 + 6);"},{"Add":" if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */"},{"Add":" errorCode = BITv05_initDStream(&bitD1, istart1, length1);"},{"Add":" if (HUFv05_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BITv05_initDStream(&bitD2, istart2, length2);"},{"Add":" if (HUFv05_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BITv05_initDStream(&bitD3, istart3, length3);"},{"Add":" if (HUFv05_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BITv05_initDStream(&bitD4, istart4, length4);"},{"Add":" if (HUFv05_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" /* 16-32 symbols per loop (4-8 symbols per stream) */"},{"Add":" endSignal = BITv05_reloadDStream(&bitD1) | BITv05_reloadDStream(&bitD2) | BITv05_reloadDStream(&bitD3) | BITv05_reloadDStream(&bitD4);"},{"Add":" for ( ; (endSignal==BITv05_DStream_unfinished) && (op4<(oend-7)) ; ) {"},{"Add":" HUFv05_DECODE_SYMBOLX4_2(op1, &bitD1);"},{"Add":" HUFv05_DECODE_SYMBOLX4_2(op2, &bitD2);"},{"Add":" HUFv05_DECODE_SYMBOLX4_2(op3, &bitD3);"},{"Add":" HUFv05_DECODE_SYMBOLX4_2(op4, &bitD4);"},{"Add":" HUFv05_DECODE_SYMBOLX4_1(op1, &bitD1);"},{"Add":" HUFv05_DECODE_SYMBOLX4_1(op2, &bitD2);"},{"Add":" HUFv05_DECODE_SYMBOLX4_1(op3, &bitD3);"},{"Add":" HUFv05_DECODE_SYMBOLX4_1(op4, &bitD4);"},{"Add":" HUFv05_DECODE_SYMBOLX4_2(op1, &bitD1);"},{"Add":" HUFv05_DECODE_SYMBOLX4_2(op2, &bitD2);"},{"Add":" HUFv05_DECODE_SYMBOLX4_2(op3, &bitD3);"},{"Add":" HUFv05_DECODE_SYMBOLX4_2(op4, &bitD4);"},{"Add":" HUFv05_DECODE_SYMBOLX4_0(op1, &bitD1);"},{"Add":" HUFv05_DECODE_SYMBOLX4_0(op2, &bitD2);"},{"Add":" HUFv05_DECODE_SYMBOLX4_0(op3, &bitD3);"},{"Add":" HUFv05_DECODE_SYMBOLX4_0(op4, &bitD4);"},{"Add":""},{"Add":" endSignal = BITv05_reloadDStream(&bitD1) | BITv05_reloadDStream(&bitD2) | BITv05_reloadDStream(&bitD3) | BITv05_reloadDStream(&bitD4);"},{"Add":" }"},{"Add":""},{"Add":" /* check corruption */"},{"Add":" if (op1 > opStart2) return ERROR(corruption_detected);"},{"Add":" if (op2 > opStart3) return ERROR(corruption_detected);"},{"Add":" if (op3 > opStart4) return ERROR(corruption_detected);"},{"Add":" /* note : op4 supposed already verified within main loop */"},{"Add":""},{"Add":" /* finish bitStreams one by one */"},{"Add":" HUFv05_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);"},{"Add":" HUFv05_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);"},{"Add":" HUFv05_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);"},{"Add":" HUFv05_decodeStreamX4(op4, &bitD4, oend, dt, dtLog);"},{"Add":""},{"Add":" /* check */"},{"Add":" endSignal = BITv05_endOfDStream(&bitD1) & BITv05_endOfDStream(&bitD2) & BITv05_endOfDStream(&bitD3) & BITv05_endOfDStream(&bitD4);"},{"Add":" if (!endSignal) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* decoded size */"},{"Add":" return dstSize;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t HUFv05_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUFv05_CREATE_STATIC_DTABLEX4(DTable, HUFv05_MAX_TABLELOG);"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":""},{"Add":" size_t hSize = HUFv05_readDTableX4 (DTable, cSrc, cSrcSize);"},{"Add":" if (HUFv05_isError(hSize)) return hSize;"},{"Add":" if (hSize >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += hSize;"},{"Add":" cSrcSize -= hSize;"},{"Add":""},{"Add":" return HUFv05_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/* ********************************/"},{"Add":"/* Generic decompression selector */"},{"Add":"/* ********************************/"},{"Add":""},{"Add":"typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;"},{"Add":"static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] ="},{"Add":"{"},{"Add":" /* single, double, quad */"},{"Add":" {{0,0}, {1,1}, {2,2}}, /* Q==0 : impossible */"},{"Add":" {{0,0}, {1,1}, {2,2}}, /* Q==1 : impossible */"},{"Add":" {{ 38,130}, {1313, 74}, {2151, 38}}, /* Q == 2 : 12-18% */"},{"Add":" {{ 448,128}, {1353, 74}, {2238, 41}}, /* Q == 3 : 18-25% */"},{"Add":" {{ 556,128}, {1353, 74}, {2238, 47}}, /* Q == 4 : 25-32% */"},{"Add":" {{ 714,128}, {1418, 74}, {2436, 53}}, /* Q == 5 : 32-38% */"},{"Add":" {{ 883,128}, {1437, 74}, {2464, 61}}, /* Q == 6 : 38-44% */"},{"Add":" {{ 897,128}, {1515, 75}, {2622, 68}}, /* Q == 7 : 44-50% */"},{"Add":" {{ 926,128}, {1613, 75}, {2730, 75}}, /* Q == 8 : 50-56% */"},{"Add":" {{ 947,128}, {1729, 77}, {3359, 77}}, /* Q == 9 : 56-62% */"},{"Add":" {{1107,128}, {2083, 81}, {4006, 84}}, /* Q ==10 : 62-69% */"},{"Add":" {{1177,128}, {2379, 87}, {4785, 88}}, /* Q ==11 : 69-75% */"},{"Add":" {{1242,128}, {2415, 93}, {5155, 84}}, /* Q ==12 : 75-81% */"},{"Add":" {{1349,128}, {2644,106}, {5260,106}}, /* Q ==13 : 81-87% */"},{"Add":" {{1455,128}, {2422,124}, {4174,124}}, /* Q ==14 : 87-93% */"},{"Add":" {{ 722,128}, {1891,145}, {1936,146}}, /* Q ==15 : 93-99% */"},{"Add":"};"},{"Add":""},{"Add":"typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);"},{"Add":""},{"Add":"size_t HUFv05_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" static const decompressionAlgo decompress[3] = { HUFv05_decompress4X2, HUFv05_decompress4X4, NULL };"},{"Add":" /* estimate decompression time */"},{"Add":" U32 Q;"},{"Add":" const U32 D256 = (U32)(dstSize >> 8);"},{"Add":" U32 Dtime[3];"},{"Add":" U32 algoNb = 0;"},{"Add":" int n;"},{"Add":""},{"Add":" /* validation checks */"},{"Add":" if (dstSize == 0) return ERROR(dstSize_tooSmall);"},{"Add":" if (cSrcSize >= dstSize) return ERROR(corruption_detected); /* invalid, or not compressed, but not compressed already dealt with */"},{"Add":" if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */"},{"Add":""},{"Add":" /* decoder timing evaluation */"},{"Add":" Q = (U32)(cSrcSize * 16 / dstSize); /* Q < 16 since dstSize > cSrcSize */"},{"Add":" for (n=0; n<3; n++)"},{"Add":" Dtime[n] = algoTime[Q][n].tableTime + (algoTime[Q][n].decode256Time * D256);"},{"Add":""},{"Add":" Dtime[1] += Dtime[1] >> 4; Dtime[2] += Dtime[2] >> 3; /* advantage to algorithms using less memory, for cache eviction */"},{"Add":""},{"Add":" if (Dtime[1] < Dtime[0]) algoNb = 1;"},{"Add":""},{"Add":" return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);"},{"Add":""},{"Add":" /* return HUFv05_decompress4X2(dst, dstSize, cSrc, cSrcSize); */ /* multi-streams single-symbol decoding */"},{"Add":" /* return HUFv05_decompress4X4(dst, dstSize, cSrc, cSrcSize); */ /* multi-streams double-symbols decoding */"},{"Add":" /* return HUFv05_decompress4X6(dst, dstSize, cSrc, cSrcSize); */ /* multi-streams quad-symbols decoding */"},{"Add":"}"},{"Add":"/*"},{"Add":" zstd - standard compression library"},{"Add":" Copyright (C) 2014-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - zstd source repository : https://github.com/Cyan4973/zstd"},{"Add":"*/"},{"Add":""},{"Add":"/* ***************************************************************"},{"Add":"* Tuning parameters"},{"Add":"*****************************************************************/"},{"Add":"/*!"},{"Add":" * HEAPMODE :"},{"Add":" * Select how default decompression function ZSTDv05_decompress() will allocate memory,"},{"Add":" * in memory stack (0), or in memory heap (1, requires malloc())"},{"Add":" */"},{"Add":"#ifndef ZSTDv05_HEAPMODE"},{"Add":"# define ZSTDv05_HEAPMODE 1"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*-*******************************************************"},{"Add":"* Dependencies"},{"Add":"*********************************************************/"},{"Add":"#include /* calloc */"},{"Add":"#include /* memcpy, memmove */"},{"Add":"#include /* debug only : printf */"},{"Add":""},{"Add":""},{"Add":"/*-*******************************************************"},{"Add":"* Compiler specifics"},{"Add":"*********************************************************/"},{"Add":"#ifdef _MSC_VER /* Visual Studio */"},{"Add":"# include /* For Visual 2005 */"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"# pragma warning(disable : 4324) /* disable: C4324: padded structure */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*-*************************************"},{"Add":"* Local types"},{"Add":"***************************************/"},{"Add":"typedef struct"},{"Add":"{"},{"Add":" blockType_t blockType;"},{"Add":" U32 origSize;"},{"Add":"} blockProperties_t;"},{"Add":""},{"Add":""},{"Add":"/* *******************************************************"},{"Add":"* Memory operations"},{"Add":"**********************************************************/"},{"Add":"static void ZSTDv05_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Error Management"},{"Add":"***************************************/"},{"Add":"/*! ZSTDv05_isError() :"},{"Add":"* tells if a return value is an error code */"},{"Add":"unsigned ZSTDv05_isError(size_t code) { return ERR_isError(code); }"},{"Add":""},{"Add":""},{"Add":"/*! ZSTDv05_getErrorName() :"},{"Add":"* provides error code string (useful for debugging) */"},{"Add":"const char* ZSTDv05_getErrorName(size_t code) { return ERR_getErrorName(code); }"},{"Add":""},{"Add":""},{"Add":"/* *************************************************************"},{"Add":"* Context management"},{"Add":"***************************************************************/"},{"Add":"typedef enum { ZSTDv05ds_getFrameHeaderSize, ZSTDv05ds_decodeFrameHeader,"},{"Add":" ZSTDv05ds_decodeBlockHeader, ZSTDv05ds_decompressBlock } ZSTDv05_dStage;"},{"Add":""},{"Add":"struct ZSTDv05_DCtx_s"},{"Add":"{"},{"Add":" FSEv05_DTable LLTable[FSEv05_DTABLE_SIZE_U32(LLFSEv05Log)];"},{"Add":" FSEv05_DTable OffTable[FSEv05_DTABLE_SIZE_U32(OffFSEv05Log)];"},{"Add":" FSEv05_DTable MLTable[FSEv05_DTABLE_SIZE_U32(MLFSEv05Log)];"},{"Add":" unsigned hufTableX4[HUFv05_DTABLE_SIZE(HufLog)];"},{"Add":" const void* previousDstEnd;"},{"Add":" const void* base;"},{"Add":" const void* vBase;"},{"Add":" const void* dictEnd;"},{"Add":" size_t expected;"},{"Add":" size_t headerSize;"},{"Add":" ZSTDv05_parameters params;"},{"Add":" blockType_t bType; /* used in ZSTDv05_decompressContinue(), to transfer blockType between header decoding and block decoding stages */"},{"Add":" ZSTDv05_dStage stage;"},{"Add":" U32 flagStaticTables;"},{"Add":" const BYTE* litPtr;"},{"Add":" size_t litSize;"},{"Add":" BYTE litBuffer[BLOCKSIZE + WILDCOPY_OVERLENGTH];"},{"Add":" BYTE headerBuffer[ZSTDv05_frameHeaderSize_max];"},{"Add":"}; /* typedef'd to ZSTDv05_DCtx within \"zstd_static.h\" */"},{"Add":""},{"Add":"size_t ZSTDv05_sizeofDCtx (void); /* Hidden declaration */"},{"Add":"size_t ZSTDv05_sizeofDCtx (void) { return sizeof(ZSTDv05_DCtx); }"},{"Add":""},{"Add":"size_t ZSTDv05_decompressBegin(ZSTDv05_DCtx* dctx)"},{"Add":"{"},{"Add":" dctx->expected = ZSTDv05_frameHeaderSize_min;"},{"Add":" dctx->stage = ZSTDv05ds_getFrameHeaderSize;"},{"Add":" dctx->previousDstEnd = NULL;"},{"Add":" dctx->base = NULL;"},{"Add":" dctx->vBase = NULL;"},{"Add":" dctx->dictEnd = NULL;"},{"Add":" dctx->hufTableX4[0] = HufLog;"},{"Add":" dctx->flagStaticTables = 0;"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"ZSTDv05_DCtx* ZSTDv05_createDCtx(void)"},{"Add":"{"},{"Add":" ZSTDv05_DCtx* dctx = (ZSTDv05_DCtx*)malloc(sizeof(ZSTDv05_DCtx));"},{"Add":" if (dctx==NULL) return NULL;"},{"Add":" ZSTDv05_decompressBegin(dctx);"},{"Add":" return dctx;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTDv05_freeDCtx(ZSTDv05_DCtx* dctx)"},{"Add":"{"},{"Add":" free(dctx);"},{"Add":" return 0; /* reserved as a potential error code in the future */"},{"Add":"}"},{"Add":""},{"Add":"void ZSTDv05_copyDCtx(ZSTDv05_DCtx* dstDCtx, const ZSTDv05_DCtx* srcDCtx)"},{"Add":"{"},{"Add":" memcpy(dstDCtx, srcDCtx,"},{"Add":" sizeof(ZSTDv05_DCtx) - (BLOCKSIZE+WILDCOPY_OVERLENGTH + ZSTDv05_frameHeaderSize_max)); /* no need to copy workspace */"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/* *************************************************************"},{"Add":"* Decompression section"},{"Add":"***************************************************************/"},{"Add":""},{"Add":"/* Frame format description"},{"Add":" Frame Header - [ Block Header - Block ] - Frame End"},{"Add":" 1) Frame Header"},{"Add":" - 4 bytes - Magic Number : ZSTDv05_MAGICNUMBER (defined within zstd_internal.h)"},{"Add":" - 1 byte - Window Descriptor"},{"Add":" 2) Block Header"},{"Add":" - 3 bytes, starting with a 2-bits descriptor"},{"Add":" Uncompressed, Compressed, Frame End, unused"},{"Add":" 3) Block"},{"Add":" See Block Format Description"},{"Add":" 4) Frame End"},{"Add":" - 3 bytes, compatible with Block Header"},{"Add":"*/"},{"Add":""},{"Add":"/* Block format description"},{"Add":""},{"Add":" Block = Literal Section - Sequences Section"},{"Add":" Prerequisite : size of (compressed) block, maximum size of regenerated data"},{"Add":""},{"Add":" 1) Literal Section"},{"Add":""},{"Add":" 1.1) Header : 1-5 bytes"},{"Add":" flags: 2 bits"},{"Add":" 00 compressed by Huff0"},{"Add":" 01 unused"},{"Add":" 10 is Raw (uncompressed)"},{"Add":" 11 is Rle"},{"Add":" Note : using 01 => Huff0 with precomputed table ?"},{"Add":" Note : delta map ? => compressed ?"},{"Add":""},{"Add":" 1.1.1) Huff0-compressed literal block : 3-5 bytes"},{"Add":" srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream"},{"Add":" srcSize < 1 KB => 3 bytes (2-2-10-10)"},{"Add":" srcSize < 16KB => 4 bytes (2-2-14-14)"},{"Add":" else => 5 bytes (2-2-18-18)"},{"Add":" big endian convention"},{"Add":""},{"Add":" 1.1.2) Raw (uncompressed) literal block header : 1-3 bytes"},{"Add":" size : 5 bits: (IS_RAW<<6) + (0<<4) + size"},{"Add":" 12 bits: (IS_RAW<<6) + (2<<4) + (size>>8)"},{"Add":" size&255"},{"Add":" 20 bits: (IS_RAW<<6) + (3<<4) + (size>>16)"},{"Add":" size>>8&255"},{"Add":" size&255"},{"Add":""},{"Add":" 1.1.3) Rle (repeated single byte) literal block header : 1-3 bytes"},{"Add":" size : 5 bits: (IS_RLE<<6) + (0<<4) + size"},{"Add":" 12 bits: (IS_RLE<<6) + (2<<4) + (size>>8)"},{"Add":" size&255"},{"Add":" 20 bits: (IS_RLE<<6) + (3<<4) + (size>>16)"},{"Add":" size>>8&255"},{"Add":" size&255"},{"Add":""},{"Add":" 1.1.4) Huff0-compressed literal block, using precomputed CTables : 3-5 bytes"},{"Add":" srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream"},{"Add":" srcSize < 1 KB => 3 bytes (2-2-10-10)"},{"Add":" srcSize < 16KB => 4 bytes (2-2-14-14)"},{"Add":" else => 5 bytes (2-2-18-18)"},{"Add":" big endian convention"},{"Add":""},{"Add":" 1- CTable available (stored into workspace ?)"},{"Add":" 2- Small input (fast heuristic ? Full comparison ? depend on clevel ?)"},{"Add":""},{"Add":""},{"Add":" 1.2) Literal block content"},{"Add":""},{"Add":" 1.2.1) Huff0 block, using sizes from header"},{"Add":" See Huff0 format"},{"Add":""},{"Add":" 1.2.2) Huff0 block, using prepared table"},{"Add":""},{"Add":" 1.2.3) Raw content"},{"Add":""},{"Add":" 1.2.4) single byte"},{"Add":""},{"Add":""},{"Add":" 2) Sequences section"},{"Add":" TO DO"},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/** ZSTDv05_decodeFrameHeader_Part1() :"},{"Add":"* decode the 1st part of the Frame Header, which tells Frame Header size."},{"Add":"* srcSize must be == ZSTDv05_frameHeaderSize_min."},{"Add":"* @return : the full size of the Frame Header */"},{"Add":"static size_t ZSTDv05_decodeFrameHeader_Part1(ZSTDv05_DCtx* zc, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" U32 magicNumber;"},{"Add":" if (srcSize != ZSTDv05_frameHeaderSize_min)"},{"Add":" return ERROR(srcSize_wrong);"},{"Add":" magicNumber = MEM_readLE32(src);"},{"Add":" if (magicNumber != ZSTDv05_MAGICNUMBER) return ERROR(prefix_unknown);"},{"Add":" zc->headerSize = ZSTDv05_frameHeaderSize_min;"},{"Add":" return zc->headerSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t ZSTDv05_getFrameParams(ZSTDv05_parameters* params, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" U32 magicNumber;"},{"Add":" if (srcSize < ZSTDv05_frameHeaderSize_min) return ZSTDv05_frameHeaderSize_max;"},{"Add":" magicNumber = MEM_readLE32(src);"},{"Add":" if (magicNumber != ZSTDv05_MAGICNUMBER) return ERROR(prefix_unknown);"},{"Add":" memset(params, 0, sizeof(*params));"},{"Add":" params->windowLog = (((const BYTE*)src)[4] & 15) + ZSTDv05_WINDOWLOG_ABSOLUTEMIN;"},{"Add":" if ((((const BYTE*)src)[4] >> 4) != 0) return ERROR(frameParameter_unsupported); /* reserved bits */"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"/** ZSTDv05_decodeFrameHeader_Part2() :"},{"Add":"* decode the full Frame Header."},{"Add":"* srcSize must be the size provided by ZSTDv05_decodeFrameHeader_Part1()."},{"Add":"* @return : 0, or an error code, which can be tested using ZSTDv05_isError() */"},{"Add":"static size_t ZSTDv05_decodeFrameHeader_Part2(ZSTDv05_DCtx* zc, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" size_t result;"},{"Add":" if (srcSize != zc->headerSize)"},{"Add":" return ERROR(srcSize_wrong);"},{"Add":" result = ZSTDv05_getFrameParams(&(zc->params), src, srcSize);"},{"Add":" if ((MEM_32bits()) && (zc->params.windowLog > 25)) return ERROR(frameParameter_unsupported);"},{"Add":" return result;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTDv05_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)"},{"Add":"{"},{"Add":" const BYTE* const in = (const BYTE*)src;"},{"Add":" BYTE headerFlags;"},{"Add":" U32 cSize;"},{"Add":""},{"Add":" if (srcSize < 3)"},{"Add":" return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" headerFlags = *in;"},{"Add":" cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);"},{"Add":""},{"Add":" bpPtr->blockType = (blockType_t)(headerFlags >> 6);"},{"Add":" bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;"},{"Add":""},{"Add":" if (bpPtr->blockType == bt_end) return 0;"},{"Add":" if (bpPtr->blockType == bt_rle) return 1;"},{"Add":" return cSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTDv05_copyRawBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" if (dst==NULL) return ERROR(dstSize_tooSmall);"},{"Add":" if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall);"},{"Add":" memcpy(dst, src, srcSize);"},{"Add":" return srcSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*! ZSTDv05_decodeLiteralsBlock() :"},{"Add":" @return : nb of bytes read from src (< srcSize ) */"},{"Add":"static size_t ZSTDv05_decodeLiteralsBlock(ZSTDv05_DCtx* dctx,"},{"Add":" const void* src, size_t srcSize) /* note : srcSize < BLOCKSIZE */"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE*) src;"},{"Add":""},{"Add":" /* any compressed block with literals segment must be at least this size */"},{"Add":" if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);"},{"Add":""},{"Add":" switch(istart[0]>> 6)"},{"Add":" {"},{"Add":" case IS_HUFv05:"},{"Add":" {"},{"Add":" size_t litSize, litCSize, singleStream=0;"},{"Add":" U32 lhSize = ((istart[0]) >> 4) & 3;"},{"Add":" if (srcSize < 5) return ERROR(corruption_detected); /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for case 3 */"},{"Add":" switch(lhSize)"},{"Add":" {"},{"Add":" case 0: case 1: default: /* note : default is impossible, since lhSize into [0..3] */"},{"Add":" /* 2 - 2 - 10 - 10 */"},{"Add":" lhSize=3;"},{"Add":" singleStream = istart[0] & 16;"},{"Add":" litSize = ((istart[0] & 15) << 6) + (istart[1] >> 2);"},{"Add":" litCSize = ((istart[1] & 3) << 8) + istart[2];"},{"Add":" break;"},{"Add":" case 2:"},{"Add":" /* 2 - 2 - 14 - 14 */"},{"Add":" lhSize=4;"},{"Add":" litSize = ((istart[0] & 15) << 10) + (istart[1] << 2) + (istart[2] >> 6);"},{"Add":" litCSize = ((istart[2] & 63) << 8) + istart[3];"},{"Add":" break;"},{"Add":" case 3:"},{"Add":" /* 2 - 2 - 18 - 18 */"},{"Add":" lhSize=5;"},{"Add":" litSize = ((istart[0] & 15) << 14) + (istart[1] << 6) + (istart[2] >> 2);"},{"Add":" litCSize = ((istart[2] & 3) << 16) + (istart[3] << 8) + istart[4];"},{"Add":" break;"},{"Add":" }"},{"Add":" if (litSize > BLOCKSIZE) return ERROR(corruption_detected);"},{"Add":" if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);"},{"Add":""},{"Add":" if (HUFv05_isError(singleStream ?"},{"Add":" HUFv05_decompress1X2(dctx->litBuffer, litSize, istart+lhSize, litCSize) :"},{"Add":" HUFv05_decompress (dctx->litBuffer, litSize, istart+lhSize, litCSize) ))"},{"Add":" return ERROR(corruption_detected);"},{"Add":""},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);"},{"Add":" return litCSize + lhSize;"},{"Add":" }"},{"Add":" case IS_PCH:"},{"Add":" {"},{"Add":" size_t errorCode;"},{"Add":" size_t litSize, litCSize;"},{"Add":" U32 lhSize = ((istart[0]) >> 4) & 3;"},{"Add":" if (lhSize != 1) /* only case supported for now : small litSize, single stream */"},{"Add":" return ERROR(corruption_detected);"},{"Add":" if (!dctx->flagStaticTables)"},{"Add":" return ERROR(dictionary_corrupted);"},{"Add":""},{"Add":" /* 2 - 2 - 10 - 10 */"},{"Add":" lhSize=3;"},{"Add":" litSize = ((istart[0] & 15) << 6) + (istart[1] >> 2);"},{"Add":" litCSize = ((istart[1] & 3) << 8) + istart[2];"},{"Add":" if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);"},{"Add":""},{"Add":" errorCode = HUFv05_decompress1X4_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->hufTableX4);"},{"Add":" if (HUFv05_isError(errorCode)) return ERROR(corruption_detected);"},{"Add":""},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);"},{"Add":" return litCSize + lhSize;"},{"Add":" }"},{"Add":" case IS_RAW:"},{"Add":" {"},{"Add":" size_t litSize;"},{"Add":" U32 lhSize = ((istart[0]) >> 4) & 3;"},{"Add":" switch(lhSize)"},{"Add":" {"},{"Add":" case 0: case 1: default: /* note : default is impossible, since lhSize into [0..3] */"},{"Add":" lhSize=1;"},{"Add":" litSize = istart[0] & 31;"},{"Add":" break;"},{"Add":" case 2:"},{"Add":" litSize = ((istart[0] & 15) << 8) + istart[1];"},{"Add":" break;"},{"Add":" case 3:"},{"Add":" litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2];"},{"Add":" break;"},{"Add":" }"},{"Add":""},{"Add":" if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) { /* risk reading beyond src buffer with wildcopy */"},{"Add":" if (litSize+lhSize > srcSize) return ERROR(corruption_detected);"},{"Add":" memcpy(dctx->litBuffer, istart+lhSize, litSize);"},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);"},{"Add":" return lhSize+litSize;"},{"Add":" }"},{"Add":" /* direct reference into compressed stream */"},{"Add":" dctx->litPtr = istart+lhSize;"},{"Add":" dctx->litSize = litSize;"},{"Add":" return lhSize+litSize;"},{"Add":" }"},{"Add":" case IS_RLE:"},{"Add":" {"},{"Add":" size_t litSize;"},{"Add":" U32 lhSize = ((istart[0]) >> 4) & 3;"},{"Add":" switch(lhSize)"},{"Add":" {"},{"Add":" case 0: case 1: default: /* note : default is impossible, since lhSize into [0..3] */"},{"Add":" lhSize = 1;"},{"Add":" litSize = istart[0] & 31;"},{"Add":" break;"},{"Add":" case 2:"},{"Add":" litSize = ((istart[0] & 15) << 8) + istart[1];"},{"Add":" break;"},{"Add":" case 3:"},{"Add":" litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2];"},{"Add":" if (srcSize<4) return ERROR(corruption_detected); /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4 */"},{"Add":" break;"},{"Add":" }"},{"Add":" if (litSize > BLOCKSIZE) return ERROR(corruption_detected);"},{"Add":" memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH);"},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" return lhSize+1;"},{"Add":" }"},{"Add":" default:"},{"Add":" return ERROR(corruption_detected); /* impossible */"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTDv05_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr,"},{"Add":" FSEv05_DTable* DTableLL, FSEv05_DTable* DTableML, FSEv05_DTable* DTableOffb,"},{"Add":" const void* src, size_t srcSize, U32 flagStaticTable)"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE*)src;"},{"Add":" const BYTE* ip = istart;"},{"Add":" const BYTE* const iend = istart + srcSize;"},{"Add":" U32 LLtype, Offtype, MLtype;"},{"Add":" unsigned LLlog, Offlog, MLlog;"},{"Add":" size_t dumpsLength;"},{"Add":""},{"Add":" /* check */"},{"Add":" if (srcSize < MIN_SEQUENCES_SIZE)"},{"Add":" return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" /* SeqHead */"},{"Add":" *nbSeq = *ip++;"},{"Add":" if (*nbSeq==0) return 1;"},{"Add":" if (*nbSeq >= 128) {"},{"Add":" if (ip >= iend) return ERROR(srcSize_wrong);"},{"Add":" *nbSeq = ((nbSeq[0]-128)<<8) + *ip++;"},{"Add":" }"},{"Add":""},{"Add":" if (ip >= iend) return ERROR(srcSize_wrong);"},{"Add":" LLtype = *ip >> 6;"},{"Add":" Offtype = (*ip >> 4) & 3;"},{"Add":" MLtype = (*ip >> 2) & 3;"},{"Add":" if (*ip & 2) {"},{"Add":" if (ip+3 > iend) return ERROR(srcSize_wrong);"},{"Add":" dumpsLength = ip[2];"},{"Add":" dumpsLength += ip[1] << 8;"},{"Add":" ip += 3;"},{"Add":" } else {"},{"Add":" if (ip+2 > iend) return ERROR(srcSize_wrong);"},{"Add":" dumpsLength = ip[1];"},{"Add":" dumpsLength += (ip[0] & 1) << 8;"},{"Add":" ip += 2;"},{"Add":" }"},{"Add":" *dumpsPtr = ip;"},{"Add":" ip += dumpsLength;"},{"Add":" *dumpsLengthPtr = dumpsLength;"},{"Add":""},{"Add":" /* check */"},{"Add":" if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are \"raw\", hence no header, but at least xxLog bits per type */"},{"Add":""},{"Add":" /* sequences */"},{"Add":" {"},{"Add":" S16 norm[MaxML+1]; /* assumption : MaxML >= MaxLL >= MaxOff */"},{"Add":" size_t headerSize;"},{"Add":""},{"Add":" /* Build DTables */"},{"Add":" switch(LLtype)"},{"Add":" {"},{"Add":" case FSEv05_ENCODING_RLE :"},{"Add":" LLlog = 0;"},{"Add":" FSEv05_buildDTable_rle(DTableLL, *ip++);"},{"Add":" break;"},{"Add":" case FSEv05_ENCODING_RAW :"},{"Add":" LLlog = LLbits;"},{"Add":" FSEv05_buildDTable_raw(DTableLL, LLbits);"},{"Add":" break;"},{"Add":" case FSEv05_ENCODING_STATIC:"},{"Add":" if (!flagStaticTable) return ERROR(corruption_detected);"},{"Add":" break;"},{"Add":" case FSEv05_ENCODING_DYNAMIC :"},{"Add":" default : /* impossible */"},{"Add":" { unsigned max = MaxLL;"},{"Add":" headerSize = FSEv05_readNCount(norm, &max, &LLlog, ip, iend-ip);"},{"Add":" if (FSEv05_isError(headerSize)) return ERROR(GENERIC);"},{"Add":" if (LLlog > LLFSEv05Log) return ERROR(corruption_detected);"},{"Add":" ip += headerSize;"},{"Add":" FSEv05_buildDTable(DTableLL, norm, max, LLlog);"},{"Add":" } }"},{"Add":""},{"Add":" switch(Offtype)"},{"Add":" {"},{"Add":" case FSEv05_ENCODING_RLE :"},{"Add":" Offlog = 0;"},{"Add":" if (ip > iend-2) return ERROR(srcSize_wrong); /* min : \"raw\", hence no header, but at least xxLog bits */"},{"Add":" FSEv05_buildDTable_rle(DTableOffb, *ip++ & MaxOff); /* if *ip > MaxOff, data is corrupted */"},{"Add":" break;"},{"Add":" case FSEv05_ENCODING_RAW :"},{"Add":" Offlog = Offbits;"},{"Add":" FSEv05_buildDTable_raw(DTableOffb, Offbits);"},{"Add":" break;"},{"Add":" case FSEv05_ENCODING_STATIC:"},{"Add":" if (!flagStaticTable) return ERROR(corruption_detected);"},{"Add":" break;"},{"Add":" case FSEv05_ENCODING_DYNAMIC :"},{"Add":" default : /* impossible */"},{"Add":" { unsigned max = MaxOff;"},{"Add":" headerSize = FSEv05_readNCount(norm, &max, &Offlog, ip, iend-ip);"},{"Add":" if (FSEv05_isError(headerSize)) return ERROR(GENERIC);"},{"Add":" if (Offlog > OffFSEv05Log) return ERROR(corruption_detected);"},{"Add":" ip += headerSize;"},{"Add":" FSEv05_buildDTable(DTableOffb, norm, max, Offlog);"},{"Add":" } }"},{"Add":""},{"Add":" switch(MLtype)"},{"Add":" {"},{"Add":" case FSEv05_ENCODING_RLE :"},{"Add":" MLlog = 0;"},{"Add":" if (ip > iend-2) return ERROR(srcSize_wrong); /* min : \"raw\", hence no header, but at least xxLog bits */"},{"Add":" FSEv05_buildDTable_rle(DTableML, *ip++);"},{"Add":" break;"},{"Add":" case FSEv05_ENCODING_RAW :"},{"Add":" MLlog = MLbits;"},{"Add":" FSEv05_buildDTable_raw(DTableML, MLbits);"},{"Add":" break;"},{"Add":" case FSEv05_ENCODING_STATIC:"},{"Add":" if (!flagStaticTable) return ERROR(corruption_detected);"},{"Add":" break;"},{"Add":" case FSEv05_ENCODING_DYNAMIC :"},{"Add":" default : /* impossible */"},{"Add":" { unsigned max = MaxML;"},{"Add":" headerSize = FSEv05_readNCount(norm, &max, &MLlog, ip, iend-ip);"},{"Add":" if (FSEv05_isError(headerSize)) return ERROR(GENERIC);"},{"Add":" if (MLlog > MLFSEv05Log) return ERROR(corruption_detected);"},{"Add":" ip += headerSize;"},{"Add":" FSEv05_buildDTable(DTableML, norm, max, MLlog);"},{"Add":" } } }"},{"Add":""},{"Add":" return ip-istart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"typedef struct {"},{"Add":" size_t litLength;"},{"Add":" size_t matchLength;"},{"Add":" size_t offset;"},{"Add":"} seq_t;"},{"Add":""},{"Add":"typedef struct {"},{"Add":" BITv05_DStream_t DStream;"},{"Add":" FSEv05_DState_t stateLL;"},{"Add":" FSEv05_DState_t stateOffb;"},{"Add":" FSEv05_DState_t stateML;"},{"Add":" size_t prevOffset;"},{"Add":" const BYTE* dumps;"},{"Add":" const BYTE* dumpsEnd;"},{"Add":"} seqState_t;"},{"Add":""},{"Add":""},{"Add":""},{"Add":"static void ZSTDv05_decodeSequence(seq_t* seq, seqState_t* seqState)"},{"Add":"{"},{"Add":" size_t litLength;"},{"Add":" size_t prevOffset;"},{"Add":" size_t offset;"},{"Add":" size_t matchLength;"},{"Add":" const BYTE* dumps = seqState->dumps;"},{"Add":" const BYTE* const de = seqState->dumpsEnd;"},{"Add":""},{"Add":" /* Literal length */"},{"Add":" litLength = FSEv05_peakSymbol(&(seqState->stateLL));"},{"Add":" prevOffset = litLength ? seq->offset : seqState->prevOffset;"},{"Add":" if (litLength == MaxLL) {"},{"Add":" const U32 add = *dumps++;"},{"Add":" if (add < 255) litLength += add;"},{"Add":" else if (dumps + 2 <= de) {"},{"Add":" litLength = MEM_readLE16(dumps);"},{"Add":" dumps += 2;"},{"Add":" if ((litLength & 1) && dumps < de) {"},{"Add":" litLength += *dumps << 16;"},{"Add":" dumps += 1;"},{"Add":" }"},{"Add":" litLength>>=1;"},{"Add":" }"},{"Add":" if (dumps >= de) { dumps = de-1; } /* late correction, to avoid read overflow (data is now corrupted anyway) */"},{"Add":" }"},{"Add":""},{"Add":" /* Offset */"},{"Add":" {"},{"Add":" static const U32 offsetPrefix[MaxOff+1] = {"},{"Add":" 1 /*fake*/, 1, 2, 4, 8, 16, 32, 64, 128, 256,"},{"Add":" 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,"},{"Add":" 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, /*fake*/ 1, 1, 1, 1, 1 };"},{"Add":" U32 offsetCode = FSEv05_peakSymbol(&(seqState->stateOffb)); /* <= maxOff, by table construction */"},{"Add":" U32 nbBits = offsetCode - 1;"},{"Add":" if (offsetCode==0) nbBits = 0; /* cmove */"},{"Add":" offset = offsetPrefix[offsetCode] + BITv05_readBits(&(seqState->DStream), nbBits);"},{"Add":" if (MEM_32bits()) BITv05_reloadDStream(&(seqState->DStream));"},{"Add":" if (offsetCode==0) offset = prevOffset; /* repcode, cmove */"},{"Add":" if (offsetCode | !litLength) seqState->prevOffset = seq->offset; /* cmove */"},{"Add":" FSEv05_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream)); /* update */"},{"Add":" }"},{"Add":""},{"Add":" /* Literal length update */"},{"Add":" FSEv05_decodeSymbol(&(seqState->stateLL), &(seqState->DStream)); /* update */"},{"Add":" if (MEM_32bits()) BITv05_reloadDStream(&(seqState->DStream));"},{"Add":""},{"Add":" /* MatchLength */"},{"Add":" matchLength = FSEv05_decodeSymbol(&(seqState->stateML), &(seqState->DStream));"},{"Add":" if (matchLength == MaxML) {"},{"Add":" const U32 add = dumps>= 1;"},{"Add":" }"},{"Add":" if (dumps >= de) { dumps = de-1; } /* late correction, to avoid read overflow (data is now corrupted anyway) */"},{"Add":" }"},{"Add":" matchLength += MINMATCH;"},{"Add":""},{"Add":" /* save result */"},{"Add":" seq->litLength = litLength;"},{"Add":" seq->offset = offset;"},{"Add":" seq->matchLength = matchLength;"},{"Add":" seqState->dumps = dumps;"},{"Add":""},{"Add":"#if 0 /* debug */"},{"Add":" {"},{"Add":" static U64 totalDecoded = 0;"},{"Add":" printf(\"pos %6u : %3u literals & match %3u bytes at distance %6u \\n\","},{"Add":" (U32)(totalDecoded), (U32)litLength, (U32)matchLength, (U32)offset);"},{"Add":" totalDecoded += litLength + matchLength;"},{"Add":" }"},{"Add":"#endif"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTDv05_execSequence(BYTE* op,"},{"Add":" BYTE* const oend, seq_t sequence,"},{"Add":" const BYTE** litPtr, const BYTE* const litLimit,"},{"Add":" const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)"},{"Add":"{"},{"Add":" static const int dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 }; /* added */"},{"Add":" static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 }; /* subtracted */"},{"Add":" BYTE* const oLitEnd = op + sequence.litLength;"},{"Add":" const size_t sequenceLength = sequence.litLength + sequence.matchLength;"},{"Add":" BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */"},{"Add":" BYTE* const oend_8 = oend-8;"},{"Add":" const BYTE* const litEnd = *litPtr + sequence.litLength;"},{"Add":" const BYTE* match = oLitEnd - sequence.offset;"},{"Add":""},{"Add":" /* check */"},{"Add":" if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of 8 from oend */"},{"Add":" if (oMatchEnd > oend) return ERROR(dstSize_tooSmall); /* overwrite beyond dst buffer */"},{"Add":" if (litEnd > litLimit) return ERROR(corruption_detected); /* risk read beyond lit buffer */"},{"Add":""},{"Add":" /* copy Literals */"},{"Add":" ZSTDv05_wildcopy(op, *litPtr, sequence.litLength); /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */"},{"Add":" op = oLitEnd;"},{"Add":" *litPtr = litEnd; /* update for next sequence */"},{"Add":""},{"Add":" /* copy Match */"},{"Add":" if (sequence.offset > (size_t)(oLitEnd - base)) {"},{"Add":" /* offset beyond prefix */"},{"Add":" if (sequence.offset > (size_t)(oLitEnd - vBase))"},{"Add":" return ERROR(corruption_detected);"},{"Add":" match = dictEnd - (base-match);"},{"Add":" if (match + sequence.matchLength <= dictEnd) {"},{"Add":" memmove(oLitEnd, match, sequence.matchLength);"},{"Add":" return sequenceLength;"},{"Add":" }"},{"Add":" /* span extDict & currentPrefixSegment */"},{"Add":" {"},{"Add":" size_t length1 = dictEnd - match;"},{"Add":" memmove(oLitEnd, match, length1);"},{"Add":" op = oLitEnd + length1;"},{"Add":" sequence.matchLength -= length1;"},{"Add":" match = base;"},{"Add":" if (op > oend_8 || sequence.matchLength < MINMATCH) {"},{"Add":" while (op < oMatchEnd) *op++ = *match++;"},{"Add":" return sequenceLength;"},{"Add":" }"},{"Add":" } }"},{"Add":" /* Requirement: op <= oend_8 */"},{"Add":""},{"Add":" /* match within prefix */"},{"Add":" if (sequence.offset < 8) {"},{"Add":" /* close range match, overlap */"},{"Add":" const int sub2 = dec64table[sequence.offset];"},{"Add":" op[0] = match[0];"},{"Add":" op[1] = match[1];"},{"Add":" op[2] = match[2];"},{"Add":" op[3] = match[3];"},{"Add":" match += dec32table[sequence.offset];"},{"Add":" ZSTDv05_copy4(op+4, match);"},{"Add":" match -= sub2;"},{"Add":" } else {"},{"Add":" ZSTDv05_copy8(op, match);"},{"Add":" }"},{"Add":" op += 8; match += 8;"},{"Add":""},{"Add":" if (oMatchEnd > oend-(16-MINMATCH)) {"},{"Add":" if (op < oend_8) {"},{"Add":" ZSTDv05_wildcopy(op, match, oend_8 - op);"},{"Add":" match += oend_8 - op;"},{"Add":" op = oend_8;"},{"Add":" }"},{"Add":" while (op < oMatchEnd)"},{"Add":" *op++ = *match++;"},{"Add":" } else {"},{"Add":" ZSTDv05_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8); /* works even if matchLength < 8 */"},{"Add":" }"},{"Add":" return sequenceLength;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTDv05_decompressSequences("},{"Add":" ZSTDv05_DCtx* dctx,"},{"Add":" void* dst, size_t maxDstSize,"},{"Add":" const void* seqStart, size_t seqSize)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)seqStart;"},{"Add":" const BYTE* const iend = ip + seqSize;"},{"Add":" BYTE* const ostart = (BYTE*)dst;"},{"Add":" BYTE* op = ostart;"},{"Add":" BYTE* const oend = ostart + maxDstSize;"},{"Add":" size_t errorCode, dumpsLength=0;"},{"Add":" const BYTE* litPtr = dctx->litPtr;"},{"Add":" const BYTE* const litEnd = litPtr + dctx->litSize;"},{"Add":" int nbSeq=0;"},{"Add":" const BYTE* dumps = NULL;"},{"Add":" unsigned* DTableLL = dctx->LLTable;"},{"Add":" unsigned* DTableML = dctx->MLTable;"},{"Add":" unsigned* DTableOffb = dctx->OffTable;"},{"Add":" const BYTE* const base = (const BYTE*) (dctx->base);"},{"Add":" const BYTE* const vBase = (const BYTE*) (dctx->vBase);"},{"Add":" const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);"},{"Add":""},{"Add":" /* Build Decoding Tables */"},{"Add":" errorCode = ZSTDv05_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength,"},{"Add":" DTableLL, DTableML, DTableOffb,"},{"Add":" ip, seqSize, dctx->flagStaticTables);"},{"Add":" if (ZSTDv05_isError(errorCode)) return errorCode;"},{"Add":" ip += errorCode;"},{"Add":""},{"Add":" /* Regen sequences */"},{"Add":" if (nbSeq) {"},{"Add":" seq_t sequence;"},{"Add":" seqState_t seqState;"},{"Add":""},{"Add":" memset(&sequence, 0, sizeof(sequence));"},{"Add":" sequence.offset = REPCODE_STARTVALUE;"},{"Add":" seqState.dumps = dumps;"},{"Add":" seqState.dumpsEnd = dumps + dumpsLength;"},{"Add":" seqState.prevOffset = REPCODE_STARTVALUE;"},{"Add":" errorCode = BITv05_initDStream(&(seqState.DStream), ip, iend-ip);"},{"Add":" if (ERR_isError(errorCode)) return ERROR(corruption_detected);"},{"Add":" FSEv05_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);"},{"Add":" FSEv05_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);"},{"Add":" FSEv05_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);"},{"Add":""},{"Add":" for ( ; (BITv05_reloadDStream(&(seqState.DStream)) <= BITv05_DStream_completed) && nbSeq ; ) {"},{"Add":" size_t oneSeqSize;"},{"Add":" nbSeq--;"},{"Add":" ZSTDv05_decodeSequence(&sequence, &seqState);"},{"Add":" oneSeqSize = ZSTDv05_execSequence(op, oend, sequence, &litPtr, litEnd, base, vBase, dictEnd);"},{"Add":" if (ZSTDv05_isError(oneSeqSize)) return oneSeqSize;"},{"Add":" op += oneSeqSize;"},{"Add":" }"},{"Add":""},{"Add":" /* check if reached exact end */"},{"Add":" if (nbSeq) return ERROR(corruption_detected);"},{"Add":" }"},{"Add":""},{"Add":" /* last literal segment */"},{"Add":" {"},{"Add":" size_t lastLLSize = litEnd - litPtr;"},{"Add":" if (litPtr > litEnd) return ERROR(corruption_detected); /* too many literals already used */"},{"Add":" if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall);"},{"Add":" if (lastLLSize > 0) {"},{"Add":" memcpy(op, litPtr, lastLLSize);"},{"Add":" op += lastLLSize;"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" return op-ostart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static void ZSTDv05_checkContinuity(ZSTDv05_DCtx* dctx, const void* dst)"},{"Add":"{"},{"Add":" if (dst != dctx->previousDstEnd) { /* not contiguous */"},{"Add":" dctx->dictEnd = dctx->previousDstEnd;"},{"Add":" dctx->vBase = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));"},{"Add":" dctx->base = dst;"},{"Add":" dctx->previousDstEnd = dst;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTDv05_decompressBlock_internal(ZSTDv05_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{ /* blockType == blockCompressed */"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":" size_t litCSize;"},{"Add":""},{"Add":" if (srcSize >= BLOCKSIZE) return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" /* Decode literals sub-block */"},{"Add":" litCSize = ZSTDv05_decodeLiteralsBlock(dctx, src, srcSize);"},{"Add":" if (ZSTDv05_isError(litCSize)) return litCSize;"},{"Add":" ip += litCSize;"},{"Add":" srcSize -= litCSize;"},{"Add":""},{"Add":" return ZSTDv05_decompressSequences(dctx, dst, dstCapacity, ip, srcSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t ZSTDv05_decompressBlock(ZSTDv05_DCtx* dctx,"},{"Add":" void* dst, size_t dstCapacity,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" ZSTDv05_checkContinuity(dctx, dst);"},{"Add":" return ZSTDv05_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*! ZSTDv05_decompress_continueDCtx"},{"Add":"* dctx must have been properly initialized */"},{"Add":"static size_t ZSTDv05_decompress_continueDCtx(ZSTDv05_DCtx* dctx,"},{"Add":" void* dst, size_t maxDstSize,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":" const BYTE* iend = ip + srcSize;"},{"Add":" BYTE* const ostart = (BYTE*)dst;"},{"Add":" BYTE* op = ostart;"},{"Add":" BYTE* const oend = ostart + maxDstSize;"},{"Add":" size_t remainingSize = srcSize;"},{"Add":" blockProperties_t blockProperties;"},{"Add":" memset(&blockProperties, 0, sizeof(blockProperties));"},{"Add":""},{"Add":" /* Frame Header */"},{"Add":" { size_t frameHeaderSize;"},{"Add":" if (srcSize < ZSTDv05_frameHeaderSize_min+ZSTDv05_blockHeaderSize) return ERROR(srcSize_wrong);"},{"Add":" frameHeaderSize = ZSTDv05_decodeFrameHeader_Part1(dctx, src, ZSTDv05_frameHeaderSize_min);"},{"Add":" if (ZSTDv05_isError(frameHeaderSize)) return frameHeaderSize;"},{"Add":" if (srcSize < frameHeaderSize+ZSTDv05_blockHeaderSize) return ERROR(srcSize_wrong);"},{"Add":" ip += frameHeaderSize; remainingSize -= frameHeaderSize;"},{"Add":" frameHeaderSize = ZSTDv05_decodeFrameHeader_Part2(dctx, src, frameHeaderSize);"},{"Add":" if (ZSTDv05_isError(frameHeaderSize)) return frameHeaderSize;"},{"Add":" }"},{"Add":""},{"Add":" /* Loop on each block */"},{"Add":" while (1)"},{"Add":" {"},{"Add":" size_t decodedSize=0;"},{"Add":" size_t cBlockSize = ZSTDv05_getcBlockSize(ip, iend-ip, &blockProperties);"},{"Add":" if (ZSTDv05_isError(cBlockSize)) return cBlockSize;"},{"Add":""},{"Add":" ip += ZSTDv05_blockHeaderSize;"},{"Add":" remainingSize -= ZSTDv05_blockHeaderSize;"},{"Add":" if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" switch(blockProperties.blockType)"},{"Add":" {"},{"Add":" case bt_compressed:"},{"Add":" decodedSize = ZSTDv05_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize);"},{"Add":" break;"},{"Add":" case bt_raw :"},{"Add":" decodedSize = ZSTDv05_copyRawBlock(op, oend-op, ip, cBlockSize);"},{"Add":" break;"},{"Add":" case bt_rle :"},{"Add":" return ERROR(GENERIC); /* not yet supported */"},{"Add":" break;"},{"Add":" case bt_end :"},{"Add":" /* end of frame */"},{"Add":" if (remainingSize) return ERROR(srcSize_wrong);"},{"Add":" break;"},{"Add":" default:"},{"Add":" return ERROR(GENERIC); /* impossible */"},{"Add":" }"},{"Add":" if (cBlockSize == 0) break; /* bt_end */"},{"Add":""},{"Add":" if (ZSTDv05_isError(decodedSize)) return decodedSize;"},{"Add":" op += decodedSize;"},{"Add":" ip += cBlockSize;"},{"Add":" remainingSize -= cBlockSize;"},{"Add":" }"},{"Add":""},{"Add":" return op-ostart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t ZSTDv05_decompress_usingPreparedDCtx(ZSTDv05_DCtx* dctx, const ZSTDv05_DCtx* refDCtx,"},{"Add":" void* dst, size_t maxDstSize,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" ZSTDv05_copyDCtx(dctx, refDCtx);"},{"Add":" ZSTDv05_checkContinuity(dctx, dst);"},{"Add":" return ZSTDv05_decompress_continueDCtx(dctx, dst, maxDstSize, src, srcSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t ZSTDv05_decompress_usingDict(ZSTDv05_DCtx* dctx,"},{"Add":" void* dst, size_t maxDstSize,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" ZSTDv05_decompressBegin_usingDict(dctx, dict, dictSize);"},{"Add":" ZSTDv05_checkContinuity(dctx, dst);"},{"Add":" return ZSTDv05_decompress_continueDCtx(dctx, dst, maxDstSize, src, srcSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t ZSTDv05_decompressDCtx(ZSTDv05_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" return ZSTDv05_decompress_usingDict(dctx, dst, maxDstSize, src, srcSize, NULL, 0);"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTDv05_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":"#if defined(ZSTDv05_HEAPMODE) && (ZSTDv05_HEAPMODE==1)"},{"Add":" size_t regenSize;"},{"Add":" ZSTDv05_DCtx* dctx = ZSTDv05_createDCtx();"},{"Add":" if (dctx==NULL) return ERROR(memory_allocation);"},{"Add":" regenSize = ZSTDv05_decompressDCtx(dctx, dst, maxDstSize, src, srcSize);"},{"Add":" ZSTDv05_freeDCtx(dctx);"},{"Add":" return regenSize;"},{"Add":"#else"},{"Add":" ZSTDv05_DCtx dctx;"},{"Add":" return ZSTDv05_decompressDCtx(&dctx, dst, maxDstSize, src, srcSize);"},{"Add":"#endif"},{"Add":"}"},{"Add":""},{"Add":"/* ZSTD_errorFrameSizeInfoLegacy() :"},{"Add":" assumes `cSize` and `dBound` are _not_ NULL */"},{"Add":"static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)"},{"Add":"{"},{"Add":" *cSize = ret;"},{"Add":" *dBound = ZSTD_CONTENTSIZE_ERROR;"},{"Add":"}"},{"Add":""},{"Add":"void ZSTDv05_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cSize, unsigned long long* dBound)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":" size_t remainingSize = srcSize;"},{"Add":" size_t nbBlocks = 0;"},{"Add":" blockProperties_t blockProperties;"},{"Add":""},{"Add":" /* Frame Header */"},{"Add":" if (srcSize < ZSTDv05_frameHeaderSize_min) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));"},{"Add":" return;"},{"Add":" }"},{"Add":" if (MEM_readLE32(src) != ZSTDv05_MAGICNUMBER) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(prefix_unknown));"},{"Add":" return;"},{"Add":" }"},{"Add":" ip += ZSTDv05_frameHeaderSize_min; remainingSize -= ZSTDv05_frameHeaderSize_min;"},{"Add":""},{"Add":" /* Loop on each block */"},{"Add":" while (1)"},{"Add":" {"},{"Add":" size_t cBlockSize = ZSTDv05_getcBlockSize(ip, remainingSize, &blockProperties);"},{"Add":" if (ZSTDv05_isError(cBlockSize)) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, cBlockSize);"},{"Add":" return;"},{"Add":" }"},{"Add":""},{"Add":" ip += ZSTDv05_blockHeaderSize;"},{"Add":" remainingSize -= ZSTDv05_blockHeaderSize;"},{"Add":" if (cBlockSize > remainingSize) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));"},{"Add":" return;"},{"Add":" }"},{"Add":""},{"Add":" if (cBlockSize == 0) break; /* bt_end */"},{"Add":""},{"Add":" ip += cBlockSize;"},{"Add":" remainingSize -= cBlockSize;"},{"Add":" nbBlocks++;"},{"Add":" }"},{"Add":""},{"Add":" *cSize = ip - (const BYTE*)src;"},{"Add":" *dBound = nbBlocks * BLOCKSIZE;"},{"Add":"}"},{"Add":""},{"Add":"/* ******************************"},{"Add":"* Streaming Decompression API"},{"Add":"********************************/"},{"Add":"size_t ZSTDv05_nextSrcSizeToDecompress(ZSTDv05_DCtx* dctx)"},{"Add":"{"},{"Add":" return dctx->expected;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTDv05_decompressContinue(ZSTDv05_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" /* Sanity check */"},{"Add":" if (srcSize != dctx->expected) return ERROR(srcSize_wrong);"},{"Add":" ZSTDv05_checkContinuity(dctx, dst);"},{"Add":""},{"Add":" /* Decompress : frame header; part 1 */"},{"Add":" switch (dctx->stage)"},{"Add":" {"},{"Add":" case ZSTDv05ds_getFrameHeaderSize :"},{"Add":" /* get frame header size */"},{"Add":" if (srcSize != ZSTDv05_frameHeaderSize_min) return ERROR(srcSize_wrong); /* impossible */"},{"Add":" dctx->headerSize = ZSTDv05_decodeFrameHeader_Part1(dctx, src, ZSTDv05_frameHeaderSize_min);"},{"Add":" if (ZSTDv05_isError(dctx->headerSize)) return dctx->headerSize;"},{"Add":" memcpy(dctx->headerBuffer, src, ZSTDv05_frameHeaderSize_min);"},{"Add":" if (dctx->headerSize > ZSTDv05_frameHeaderSize_min) return ERROR(GENERIC); /* should never happen */"},{"Add":" dctx->expected = 0; /* not necessary to copy more */"},{"Add":" /* fallthrough */"},{"Add":" case ZSTDv05ds_decodeFrameHeader:"},{"Add":" /* get frame header */"},{"Add":" { size_t const result = ZSTDv05_decodeFrameHeader_Part2(dctx, dctx->headerBuffer, dctx->headerSize);"},{"Add":" if (ZSTDv05_isError(result)) return result;"},{"Add":" dctx->expected = ZSTDv05_blockHeaderSize;"},{"Add":" dctx->stage = ZSTDv05ds_decodeBlockHeader;"},{"Add":" return 0;"},{"Add":" }"},{"Add":" case ZSTDv05ds_decodeBlockHeader:"},{"Add":" {"},{"Add":" /* Decode block header */"},{"Add":" blockProperties_t bp;"},{"Add":" size_t blockSize = ZSTDv05_getcBlockSize(src, ZSTDv05_blockHeaderSize, &bp);"},{"Add":" if (ZSTDv05_isError(blockSize)) return blockSize;"},{"Add":" if (bp.blockType == bt_end) {"},{"Add":" dctx->expected = 0;"},{"Add":" dctx->stage = ZSTDv05ds_getFrameHeaderSize;"},{"Add":" }"},{"Add":" else {"},{"Add":" dctx->expected = blockSize;"},{"Add":" dctx->bType = bp.blockType;"},{"Add":" dctx->stage = ZSTDv05ds_decompressBlock;"},{"Add":" }"},{"Add":" return 0;"},{"Add":" }"},{"Add":" case ZSTDv05ds_decompressBlock:"},{"Add":" {"},{"Add":" /* Decompress : block content */"},{"Add":" size_t rSize;"},{"Add":" switch(dctx->bType)"},{"Add":" {"},{"Add":" case bt_compressed:"},{"Add":" rSize = ZSTDv05_decompressBlock_internal(dctx, dst, maxDstSize, src, srcSize);"},{"Add":" break;"},{"Add":" case bt_raw :"},{"Add":" rSize = ZSTDv05_copyRawBlock(dst, maxDstSize, src, srcSize);"},{"Add":" break;"},{"Add":" case bt_rle :"},{"Add":" return ERROR(GENERIC); /* not yet handled */"},{"Add":" break;"},{"Add":" case bt_end : /* should never happen (filtered at phase 1) */"},{"Add":" rSize = 0;"},{"Add":" break;"},{"Add":" default:"},{"Add":" return ERROR(GENERIC); /* impossible */"},{"Add":" }"},{"Add":" dctx->stage = ZSTDv05ds_decodeBlockHeader;"},{"Add":" dctx->expected = ZSTDv05_blockHeaderSize;"},{"Add":" dctx->previousDstEnd = (char*)dst + rSize;"},{"Add":" return rSize;"},{"Add":" }"},{"Add":" default:"},{"Add":" return ERROR(GENERIC); /* impossible */"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static void ZSTDv05_refDictContent(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" dctx->dictEnd = dctx->previousDstEnd;"},{"Add":" dctx->vBase = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));"},{"Add":" dctx->base = dict;"},{"Add":" dctx->previousDstEnd = (const char*)dict + dictSize;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZSTDv05_loadEntropy(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" size_t hSize, offcodeHeaderSize, matchlengthHeaderSize, errorCode, litlengthHeaderSize;"},{"Add":" short offcodeNCount[MaxOff+1];"},{"Add":" unsigned offcodeMaxValue=MaxOff, offcodeLog;"},{"Add":" short matchlengthNCount[MaxML+1];"},{"Add":" unsigned matchlengthMaxValue = MaxML, matchlengthLog;"},{"Add":" short litlengthNCount[MaxLL+1];"},{"Add":" unsigned litlengthMaxValue = MaxLL, litlengthLog;"},{"Add":""},{"Add":" hSize = HUFv05_readDTableX4(dctx->hufTableX4, dict, dictSize);"},{"Add":" if (HUFv05_isError(hSize)) return ERROR(dictionary_corrupted);"},{"Add":" dict = (const char*)dict + hSize;"},{"Add":" dictSize -= hSize;"},{"Add":""},{"Add":" offcodeHeaderSize = FSEv05_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dict, dictSize);"},{"Add":" if (FSEv05_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted);"},{"Add":" if (offcodeLog > OffFSEv05Log) return ERROR(dictionary_corrupted);"},{"Add":" errorCode = FSEv05_buildDTable(dctx->OffTable, offcodeNCount, offcodeMaxValue, offcodeLog);"},{"Add":" if (FSEv05_isError(errorCode)) return ERROR(dictionary_corrupted);"},{"Add":" dict = (const char*)dict + offcodeHeaderSize;"},{"Add":" dictSize -= offcodeHeaderSize;"},{"Add":""},{"Add":" matchlengthHeaderSize = FSEv05_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dict, dictSize);"},{"Add":" if (FSEv05_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted);"},{"Add":" if (matchlengthLog > MLFSEv05Log) return ERROR(dictionary_corrupted);"},{"Add":" errorCode = FSEv05_buildDTable(dctx->MLTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog);"},{"Add":" if (FSEv05_isError(errorCode)) return ERROR(dictionary_corrupted);"},{"Add":" dict = (const char*)dict + matchlengthHeaderSize;"},{"Add":" dictSize -= matchlengthHeaderSize;"},{"Add":""},{"Add":" litlengthHeaderSize = FSEv05_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dict, dictSize);"},{"Add":" if (litlengthLog > LLFSEv05Log) return ERROR(dictionary_corrupted);"},{"Add":" if (FSEv05_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted);"},{"Add":" errorCode = FSEv05_buildDTable(dctx->LLTable, litlengthNCount, litlengthMaxValue, litlengthLog);"},{"Add":" if (FSEv05_isError(errorCode)) return ERROR(dictionary_corrupted);"},{"Add":""},{"Add":" dctx->flagStaticTables = 1;"},{"Add":" return hSize + offcodeHeaderSize + matchlengthHeaderSize + litlengthHeaderSize;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZSTDv05_decompress_insertDictionary(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" size_t eSize;"},{"Add":" U32 magic = MEM_readLE32(dict);"},{"Add":" if (magic != ZSTDv05_DICT_MAGIC) {"},{"Add":" /* pure content mode */"},{"Add":" ZSTDv05_refDictContent(dctx, dict, dictSize);"},{"Add":" return 0;"},{"Add":" }"},{"Add":" /* load entropy tables */"},{"Add":" dict = (const char*)dict + 4;"},{"Add":" dictSize -= 4;"},{"Add":" eSize = ZSTDv05_loadEntropy(dctx, dict, dictSize);"},{"Add":" if (ZSTDv05_isError(eSize)) return ERROR(dictionary_corrupted);"},{"Add":""},{"Add":" /* reference dictionary content */"},{"Add":" dict = (const char*)dict + eSize;"},{"Add":" dictSize -= eSize;"},{"Add":" ZSTDv05_refDictContent(dctx, dict, dictSize);"},{"Add":""},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"size_t ZSTDv05_decompressBegin_usingDict(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" size_t errorCode;"},{"Add":" errorCode = ZSTDv05_decompressBegin(dctx);"},{"Add":" if (ZSTDv05_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" if (dict && dictSize) {"},{"Add":" errorCode = ZSTDv05_decompress_insertDictionary(dctx, dict, dictSize);"},{"Add":" if (ZSTDv05_isError(errorCode)) return ERROR(dictionary_corrupted);"},{"Add":" }"},{"Add":""},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"/*"},{"Add":" Buffered version of Zstd compression library"},{"Add":" Copyright (C) 2015-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - zstd source repository : https://github.com/Cyan4973/zstd"},{"Add":" - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"*/"},{"Add":""},{"Add":"/* The objects defined into this file should be considered experimental."},{"Add":" * They are not labelled stable, as their prototype may change in the future."},{"Add":" * You can use them for tests, provide feedback, or if you can endure risk of future changes."},{"Add":" */"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Constants"},{"Add":"***************************************/"},{"Add":"static size_t ZBUFFv05_blockHeaderSize = 3;"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* *** Compression *** */"},{"Add":""},{"Add":"static size_t ZBUFFv05_limitCopy(void* dst, size_t maxDstSize, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" size_t length = MIN(maxDstSize, srcSize);"},{"Add":" if (length > 0) {"},{"Add":" memcpy(dst, src, length);"},{"Add":" }"},{"Add":" return length;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":""},{"Add":"/** ************************************************"},{"Add":"* Streaming decompression"},{"Add":"*"},{"Add":"* A ZBUFFv05_DCtx object is required to track streaming operation."},{"Add":"* Use ZBUFFv05_createDCtx() and ZBUFFv05_freeDCtx() to create/release resources."},{"Add":"* Use ZBUFFv05_decompressInit() to start a new decompression operation."},{"Add":"* ZBUFFv05_DCtx objects can be reused multiple times."},{"Add":"*"},{"Add":"* Use ZBUFFv05_decompressContinue() repetitively to consume your input."},{"Add":"* *srcSizePtr and *maxDstSizePtr can be any size."},{"Add":"* The function will report how many bytes were read or written by modifying *srcSizePtr and *maxDstSizePtr."},{"Add":"* Note that it may not consume the entire input, in which case it's up to the caller to call again the function with remaining input."},{"Add":"* The content of dst will be overwritten (up to *maxDstSizePtr) at each function call, so save its content if it matters or change dst ."},{"Add":"* return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency)"},{"Add":"* or 0 when a frame is completely decoded"},{"Add":"* or an error code, which can be tested using ZBUFFv05_isError()."},{"Add":"*"},{"Add":"* Hint : recommended buffer sizes (not compulsory)"},{"Add":"* output : 128 KB block size is the internal unit, it ensures it's always possible to write a full block when it's decoded."},{"Add":"* input : just follow indications from ZBUFFv05_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 ."},{"Add":"* **************************************************/"},{"Add":""},{"Add":"typedef enum { ZBUFFv05ds_init, ZBUFFv05ds_readHeader, ZBUFFv05ds_loadHeader, ZBUFFv05ds_decodeHeader,"},{"Add":" ZBUFFv05ds_read, ZBUFFv05ds_load, ZBUFFv05ds_flush } ZBUFFv05_dStage;"},{"Add":""},{"Add":"/* *** Resource management *** */"},{"Add":""},{"Add":"#define ZSTDv05_frameHeaderSize_max 5 /* too magical, should come from reference */"},{"Add":"struct ZBUFFv05_DCtx_s {"},{"Add":" ZSTDv05_DCtx* zc;"},{"Add":" ZSTDv05_parameters params;"},{"Add":" char* inBuff;"},{"Add":" size_t inBuffSize;"},{"Add":" size_t inPos;"},{"Add":" char* outBuff;"},{"Add":" size_t outBuffSize;"},{"Add":" size_t outStart;"},{"Add":" size_t outEnd;"},{"Add":" size_t hPos;"},{"Add":" ZBUFFv05_dStage stage;"},{"Add":" unsigned char headerBuffer[ZSTDv05_frameHeaderSize_max];"},{"Add":"}; /* typedef'd to ZBUFFv05_DCtx within \"zstd_buffered.h\" */"},{"Add":""},{"Add":""},{"Add":"ZBUFFv05_DCtx* ZBUFFv05_createDCtx(void)"},{"Add":"{"},{"Add":" ZBUFFv05_DCtx* zbc = (ZBUFFv05_DCtx*)malloc(sizeof(ZBUFFv05_DCtx));"},{"Add":" if (zbc==NULL) return NULL;"},{"Add":" memset(zbc, 0, sizeof(*zbc));"},{"Add":" zbc->zc = ZSTDv05_createDCtx();"},{"Add":" zbc->stage = ZBUFFv05ds_init;"},{"Add":" return zbc;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZBUFFv05_freeDCtx(ZBUFFv05_DCtx* zbc)"},{"Add":"{"},{"Add":" if (zbc==NULL) return 0; /* support free on null */"},{"Add":" ZSTDv05_freeDCtx(zbc->zc);"},{"Add":" free(zbc->inBuff);"},{"Add":" free(zbc->outBuff);"},{"Add":" free(zbc);"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/* *** Initialization *** */"},{"Add":""},{"Add":"size_t ZBUFFv05_decompressInitDictionary(ZBUFFv05_DCtx* zbc, const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" zbc->stage = ZBUFFv05ds_readHeader;"},{"Add":" zbc->hPos = zbc->inPos = zbc->outStart = zbc->outEnd = 0;"},{"Add":" return ZSTDv05_decompressBegin_usingDict(zbc->zc, dict, dictSize);"},{"Add":"}"},{"Add":""},{"Add":"size_t ZBUFFv05_decompressInit(ZBUFFv05_DCtx* zbc)"},{"Add":"{"},{"Add":" return ZBUFFv05_decompressInitDictionary(zbc, NULL, 0);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/* *** Decompression *** */"},{"Add":""},{"Add":"size_t ZBUFFv05_decompressContinue(ZBUFFv05_DCtx* zbc, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr)"},{"Add":"{"},{"Add":" const char* const istart = (const char*)src;"},{"Add":" const char* ip = istart;"},{"Add":" const char* const iend = istart + *srcSizePtr;"},{"Add":" char* const ostart = (char*)dst;"},{"Add":" char* op = ostart;"},{"Add":" char* const oend = ostart + *maxDstSizePtr;"},{"Add":" U32 notDone = 1;"},{"Add":""},{"Add":" while (notDone) {"},{"Add":" switch(zbc->stage)"},{"Add":" {"},{"Add":" case ZBUFFv05ds_init :"},{"Add":" return ERROR(init_missing);"},{"Add":""},{"Add":" case ZBUFFv05ds_readHeader :"},{"Add":" /* read header from src */"},{"Add":" {"},{"Add":" size_t headerSize = ZSTDv05_getFrameParams(&(zbc->params), src, *srcSizePtr);"},{"Add":" if (ZSTDv05_isError(headerSize)) return headerSize;"},{"Add":" if (headerSize) {"},{"Add":" /* not enough input to decode header : tell how many bytes would be necessary */"},{"Add":" memcpy(zbc->headerBuffer+zbc->hPos, src, *srcSizePtr);"},{"Add":" zbc->hPos += *srcSizePtr;"},{"Add":" *maxDstSizePtr = 0;"},{"Add":" zbc->stage = ZBUFFv05ds_loadHeader;"},{"Add":" return headerSize - zbc->hPos;"},{"Add":" }"},{"Add":" zbc->stage = ZBUFFv05ds_decodeHeader;"},{"Add":" break;"},{"Add":" }"},{"Add":"\t /* fall-through */"},{"Add":" case ZBUFFv05ds_loadHeader:"},{"Add":" /* complete header from src */"},{"Add":" {"},{"Add":" size_t headerSize = ZBUFFv05_limitCopy("},{"Add":" zbc->headerBuffer + zbc->hPos, ZSTDv05_frameHeaderSize_max - zbc->hPos,"},{"Add":" src, *srcSizePtr);"},{"Add":" zbc->hPos += headerSize;"},{"Add":" ip += headerSize;"},{"Add":" headerSize = ZSTDv05_getFrameParams(&(zbc->params), zbc->headerBuffer, zbc->hPos);"},{"Add":" if (ZSTDv05_isError(headerSize)) return headerSize;"},{"Add":" if (headerSize) {"},{"Add":" /* not enough input to decode header : tell how many bytes would be necessary */"},{"Add":" *maxDstSizePtr = 0;"},{"Add":" return headerSize - zbc->hPos;"},{"Add":" }"},{"Add":" /* zbc->stage = ZBUFFv05ds_decodeHeader; break; */ /* useless : stage follows */"},{"Add":" }"},{"Add":"\t /* fall-through */"},{"Add":" case ZBUFFv05ds_decodeHeader:"},{"Add":" /* apply header to create / resize buffers */"},{"Add":" {"},{"Add":" size_t neededOutSize = (size_t)1 << zbc->params.windowLog;"},{"Add":" size_t neededInSize = BLOCKSIZE; /* a block is never > BLOCKSIZE */"},{"Add":" if (zbc->inBuffSize < neededInSize) {"},{"Add":" free(zbc->inBuff);"},{"Add":" zbc->inBuffSize = neededInSize;"},{"Add":" zbc->inBuff = (char*)malloc(neededInSize);"},{"Add":" if (zbc->inBuff == NULL) return ERROR(memory_allocation);"},{"Add":" }"},{"Add":" if (zbc->outBuffSize < neededOutSize) {"},{"Add":" free(zbc->outBuff);"},{"Add":" zbc->outBuffSize = neededOutSize;"},{"Add":" zbc->outBuff = (char*)malloc(neededOutSize);"},{"Add":" if (zbc->outBuff == NULL) return ERROR(memory_allocation);"},{"Add":" } }"},{"Add":" if (zbc->hPos) {"},{"Add":" /* some data already loaded into headerBuffer : transfer into inBuff */"},{"Add":" memcpy(zbc->inBuff, zbc->headerBuffer, zbc->hPos);"},{"Add":" zbc->inPos = zbc->hPos;"},{"Add":" zbc->hPos = 0;"},{"Add":" zbc->stage = ZBUFFv05ds_load;"},{"Add":" break;"},{"Add":" }"},{"Add":" zbc->stage = ZBUFFv05ds_read;"},{"Add":"\t\t/* fall-through */"},{"Add":" case ZBUFFv05ds_read:"},{"Add":" {"},{"Add":" size_t neededInSize = ZSTDv05_nextSrcSizeToDecompress(zbc->zc);"},{"Add":" if (neededInSize==0) { /* end of frame */"},{"Add":" zbc->stage = ZBUFFv05ds_init;"},{"Add":" notDone = 0;"},{"Add":" break;"},{"Add":" }"},{"Add":" if ((size_t)(iend-ip) >= neededInSize) {"},{"Add":" /* directly decode from src */"},{"Add":" size_t decodedSize = ZSTDv05_decompressContinue(zbc->zc,"},{"Add":" zbc->outBuff + zbc->outStart, zbc->outBuffSize - zbc->outStart,"},{"Add":" ip, neededInSize);"},{"Add":" if (ZSTDv05_isError(decodedSize)) return decodedSize;"},{"Add":" ip += neededInSize;"},{"Add":" if (!decodedSize) break; /* this was just a header */"},{"Add":" zbc->outEnd = zbc->outStart + decodedSize;"},{"Add":" zbc->stage = ZBUFFv05ds_flush;"},{"Add":" break;"},{"Add":" }"},{"Add":" if (ip==iend) { notDone = 0; break; } /* no more input */"},{"Add":" zbc->stage = ZBUFFv05ds_load;"},{"Add":" }"},{"Add":"\t /* fall-through */"},{"Add":" case ZBUFFv05ds_load:"},{"Add":" {"},{"Add":" size_t neededInSize = ZSTDv05_nextSrcSizeToDecompress(zbc->zc);"},{"Add":" size_t toLoad = neededInSize - zbc->inPos; /* should always be <= remaining space within inBuff */"},{"Add":" size_t loadedSize;"},{"Add":" if (toLoad > zbc->inBuffSize - zbc->inPos) return ERROR(corruption_detected); /* should never happen */"},{"Add":" loadedSize = ZBUFFv05_limitCopy(zbc->inBuff + zbc->inPos, toLoad, ip, iend-ip);"},{"Add":" ip += loadedSize;"},{"Add":" zbc->inPos += loadedSize;"},{"Add":" if (loadedSize < toLoad) { notDone = 0; break; } /* not enough input, wait for more */"},{"Add":" {"},{"Add":" size_t decodedSize = ZSTDv05_decompressContinue(zbc->zc,"},{"Add":" zbc->outBuff + zbc->outStart, zbc->outBuffSize - zbc->outStart,"},{"Add":" zbc->inBuff, neededInSize);"},{"Add":" if (ZSTDv05_isError(decodedSize)) return decodedSize;"},{"Add":" zbc->inPos = 0; /* input is consumed */"},{"Add":" if (!decodedSize) { zbc->stage = ZBUFFv05ds_read; break; } /* this was just a header */"},{"Add":" zbc->outEnd = zbc->outStart + decodedSize;"},{"Add":" zbc->stage = ZBUFFv05ds_flush;"},{"Add":" /* break; */ /* ZBUFFv05ds_flush follows */"},{"Add":" }"},{"Add":"\t }"},{"Add":"\t /* fall-through */"},{"Add":" case ZBUFFv05ds_flush:"},{"Add":" {"},{"Add":" size_t toFlushSize = zbc->outEnd - zbc->outStart;"},{"Add":" size_t flushedSize = ZBUFFv05_limitCopy(op, oend-op, zbc->outBuff + zbc->outStart, toFlushSize);"},{"Add":" op += flushedSize;"},{"Add":" zbc->outStart += flushedSize;"},{"Add":" if (flushedSize == toFlushSize) {"},{"Add":" zbc->stage = ZBUFFv05ds_read;"},{"Add":" if (zbc->outStart + BLOCKSIZE > zbc->outBuffSize)"},{"Add":" zbc->outStart = zbc->outEnd = 0;"},{"Add":" break;"},{"Add":" }"},{"Add":" /* cannot flush everything */"},{"Add":" notDone = 0;"},{"Add":" break;"},{"Add":" }"},{"Add":" default: return ERROR(GENERIC); /* impossible */"},{"Add":" } }"},{"Add":""},{"Add":" *srcSizePtr = ip-istart;"},{"Add":" *maxDstSizePtr = op-ostart;"},{"Add":""},{"Add":" { size_t nextSrcSizeHint = ZSTDv05_nextSrcSizeToDecompress(zbc->zc);"},{"Add":" if (nextSrcSizeHint > ZBUFFv05_blockHeaderSize) nextSrcSizeHint+= ZBUFFv05_blockHeaderSize; /* get next block header too */"},{"Add":" nextSrcSizeHint -= zbc->inPos; /* already loaded*/"},{"Add":" return nextSrcSizeHint;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Tool functions"},{"Add":"***************************************/"},{"Add":"unsigned ZBUFFv05_isError(size_t errorCode) { return ERR_isError(errorCode); }"},{"Add":"const char* ZBUFFv05_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }"},{"Add":""},{"Add":"size_t ZBUFFv05_recommendedDInSize(void) { return BLOCKSIZE + ZBUFFv05_blockHeaderSize /* block header size*/ ; }"},{"Add":"size_t ZBUFFv05_recommendedDOutSize(void) { return BLOCKSIZE; }"}]}},{"FileAdd":{"meta":{"basename":"zstd_v04.h","metadata":0},"context":[{"change":0,"pos":140938}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) 2016-2021, Yann Collet, Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":""},{"Add":"#ifndef ZSTD_V04_H_91868324769238"},{"Add":"#define ZSTD_V04_H_91868324769238"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Includes"},{"Add":"***************************************/"},{"Add":"#include /* size_t */"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Simple one-step function"},{"Add":"***************************************/"},{"Add":"/**"},{"Add":"ZSTDv04_decompress() : decompress ZSTD frames compliant with v0.4.x format"},{"Add":" compressedSize : is the exact source size"},{"Add":" maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated."},{"Add":" It must be equal or larger than originalSize, otherwise decompression will fail."},{"Add":" return : the number of bytes decompressed into destination buffer (originalSize)"},{"Add":" or an errorCode if it fails (which can be tested using ZSTDv01_isError())"},{"Add":"*/"},{"Add":"size_t ZSTDv04_decompress( void* dst, size_t maxOriginalSize,"},{"Add":" const void* src, size_t compressedSize);"},{"Add":""},{"Add":" /**"},{"Add":" ZSTDv04_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.4.x format"},{"Add":" srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'"},{"Add":" cSize (output parameter) : the number of bytes that would be read to decompress this frame"},{"Add":" or an error code if it fails (which can be tested using ZSTDv01_isError())"},{"Add":" dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame"},{"Add":" or ZSTD_CONTENTSIZE_ERROR if an error occurs"},{"Add":""},{"Add":" note : assumes `cSize` and `dBound` are _not_ NULL."},{"Add":" */"},{"Add":" void ZSTDv04_findFrameSizeInfoLegacy(const void *src, size_t srcSize,"},{"Add":" size_t* cSize, unsigned long long* dBound);"},{"Add":""},{"Add":"/**"},{"Add":"ZSTDv04_isError() : tells if the result of ZSTDv04_decompress() is an error"},{"Add":"*/"},{"Add":"unsigned ZSTDv04_isError(size_t code);"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Advanced functions"},{"Add":"***************************************/"},{"Add":"typedef struct ZSTDv04_Dctx_s ZSTDv04_Dctx;"},{"Add":"ZSTDv04_Dctx* ZSTDv04_createDCtx(void);"},{"Add":"size_t ZSTDv04_freeDCtx(ZSTDv04_Dctx* dctx);"},{"Add":""},{"Add":"size_t ZSTDv04_decompressDCtx(ZSTDv04_Dctx* dctx,"},{"Add":" void* dst, size_t maxOriginalSize,"},{"Add":" const void* src, size_t compressedSize);"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Direct Streaming"},{"Add":"***************************************/"},{"Add":"size_t ZSTDv04_resetDCtx(ZSTDv04_Dctx* dctx);"},{"Add":""},{"Add":"size_t ZSTDv04_nextSrcSizeToDecompress(ZSTDv04_Dctx* dctx);"},{"Add":"size_t ZSTDv04_decompressContinue(ZSTDv04_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);"},{"Add":"/**"},{"Add":" Use above functions alternatively."},{"Add":" ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue()."},{"Add":" ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block."},{"Add":" Result is the number of bytes regenerated within 'dst'."},{"Add":" It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header."},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Buffered Streaming"},{"Add":"***************************************/"},{"Add":"typedef struct ZBUFFv04_DCtx_s ZBUFFv04_DCtx;"},{"Add":"ZBUFFv04_DCtx* ZBUFFv04_createDCtx(void);"},{"Add":"size_t ZBUFFv04_freeDCtx(ZBUFFv04_DCtx* dctx);"},{"Add":""},{"Add":"size_t ZBUFFv04_decompressInit(ZBUFFv04_DCtx* dctx);"},{"Add":"size_t ZBUFFv04_decompressWithDictionary(ZBUFFv04_DCtx* dctx, const void* dict, size_t dictSize);"},{"Add":""},{"Add":"size_t ZBUFFv04_decompressContinue(ZBUFFv04_DCtx* dctx, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr);"},{"Add":""},{"Add":"/** ************************************************"},{"Add":"* Streaming decompression"},{"Add":"*"},{"Add":"* A ZBUFF_DCtx object is required to track streaming operation."},{"Add":"* Use ZBUFF_createDCtx() and ZBUFF_freeDCtx() to create/release resources."},{"Add":"* Use ZBUFF_decompressInit() to start a new decompression operation."},{"Add":"* ZBUFF_DCtx objects can be reused multiple times."},{"Add":"*"},{"Add":"* Optionally, a reference to a static dictionary can be set, using ZBUFF_decompressWithDictionary()"},{"Add":"* It must be the same content as the one set during compression phase."},{"Add":"* Dictionary content must remain accessible during the decompression process."},{"Add":"*"},{"Add":"* Use ZBUFF_decompressContinue() repetitively to consume your input."},{"Add":"* *srcSizePtr and *maxDstSizePtr can be any size."},{"Add":"* The function will report how many bytes were read or written by modifying *srcSizePtr and *maxDstSizePtr."},{"Add":"* Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again."},{"Add":"* The content of dst will be overwritten (up to *maxDstSizePtr) at each function call, so save its content if it matters or change dst."},{"Add":"* @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency)"},{"Add":"* or 0 when a frame is completely decoded"},{"Add":"* or an error code, which can be tested using ZBUFF_isError()."},{"Add":"*"},{"Add":"* Hint : recommended buffer sizes (not compulsory) : ZBUFF_recommendedDInSize / ZBUFF_recommendedDOutSize"},{"Add":"* output : ZBUFF_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when it's decoded."},{"Add":"* input : ZBUFF_recommendedDInSize==128Kb+3; just follow indications from ZBUFF_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 ."},{"Add":"* **************************************************/"},{"Add":"unsigned ZBUFFv04_isError(size_t errorCode);"},{"Add":"const char* ZBUFFv04_getErrorName(size_t errorCode);"},{"Add":""},{"Add":""},{"Add":"/** The below functions provide recommended buffer sizes for Compression or Decompression operations."},{"Add":"* These sizes are not compulsory, they just tend to offer better latency */"},{"Add":"size_t ZBUFFv04_recommendedDInSize(void);"},{"Add":"size_t ZBUFFv04_recommendedDOutSize(void);"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Prefix - version detection"},{"Add":"***************************************/"},{"Add":"#define ZSTDv04_magicNumber 0xFD2FB524 /* v0.4 */"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* ZSTD_V04_H_91868324769238 */"}]}},{"FileAdd":{"meta":{"basename":"zstd_v04.c","metadata":0},"context":[{"change":0,"pos":140938}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) 2016-2021, Yann Collet, Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":""},{"Add":""},{"Add":" /******************************************"},{"Add":" * Includes"},{"Add":" ******************************************/"},{"Add":"#include /* size_t, ptrdiff_t */"},{"Add":"#include /* memcpy */"},{"Add":""},{"Add":"#include \"zstd_v04.h\""},{"Add":"#include \"../common/error_private.h\""},{"Add":""},{"Add":""},{"Add":"/* ******************************************************************"},{"Add":" * mem.h"},{"Add":" *******************************************************************/"},{"Add":"#ifndef MEM_H_MODULE"},{"Add":"#define MEM_H_MODULE"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* Compiler-specific"},{"Add":"******************************************/"},{"Add":"#if defined(_MSC_VER) /* Visual Studio */"},{"Add":"# include /* _byteswap_ulong */"},{"Add":"# include /* _byteswap_* */"},{"Add":"#endif"},{"Add":"#if defined(__GNUC__)"},{"Add":"# define MEM_STATIC static __attribute__((unused))"},{"Add":"#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)"},{"Add":"# define MEM_STATIC static inline"},{"Add":"#elif defined(_MSC_VER)"},{"Add":"# define MEM_STATIC static __inline"},{"Add":"#else"},{"Add":"# define MEM_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Basic Types"},{"Add":"*****************************************************************/"},{"Add":"#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)"},{"Add":"# if defined(_AIX)"},{"Add":"# include "},{"Add":"# else"},{"Add":"# include /* intptr_t */"},{"Add":"# endif"},{"Add":" typedef uint8_t BYTE;"},{"Add":" typedef uint16_t U16;"},{"Add":" typedef int16_t S16;"},{"Add":" typedef uint32_t U32;"},{"Add":" typedef int32_t S32;"},{"Add":" typedef uint64_t U64;"},{"Add":" typedef int64_t S64;"},{"Add":"#else"},{"Add":" typedef unsigned char BYTE;"},{"Add":" typedef unsigned short U16;"},{"Add":" typedef signed short S16;"},{"Add":" typedef unsigned int U32;"},{"Add":" typedef signed int S32;"},{"Add":" typedef unsigned long long U64;"},{"Add":" typedef signed long long S64;"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*-*************************************"},{"Add":"* Debug"},{"Add":"***************************************/"},{"Add":"#include \"../common/debug.h\""},{"Add":"#ifndef assert"},{"Add":"# define assert(condition) ((void)0)"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Memory I/O"},{"Add":"*****************************************************************/"},{"Add":"/* MEM_FORCE_MEMORY_ACCESS"},{"Add":" * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable."},{"Add":" * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal."},{"Add":" * The below switch allow to select different access method for improved performance."},{"Add":" * Method 0 (default) : use `memcpy()`. Safe and portable."},{"Add":" * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable)."},{"Add":" * This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`."},{"Add":" * Method 2 : direct access. This method is portable but violate C standard."},{"Add":" * It can generate buggy code on targets generating assembly depending on alignment."},{"Add":" * But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)"},{"Add":" * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details."},{"Add":" * Prefer these methods in priority order (0 > 1 > 2)"},{"Add":" */"},{"Add":"#ifndef MEM_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */"},{"Add":"# if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )"},{"Add":"# define MEM_FORCE_MEMORY_ACCESS 2"},{"Add":"# elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \\"},{"Add":" (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))"},{"Add":"# define MEM_FORCE_MEMORY_ACCESS 1"},{"Add":"# endif"},{"Add":"#endif"},{"Add":""},{"Add":"MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; }"},{"Add":"MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; }"},{"Add":""},{"Add":"MEM_STATIC unsigned MEM_isLittleEndian(void)"},{"Add":"{"},{"Add":" const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */"},{"Add":" return one.c[0];"},{"Add":"}"},{"Add":""},{"Add":"#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)"},{"Add":""},{"Add":"/* violates C standard on structure alignment."},{"Add":"Only use if no other choice to achieve best performance on target platform */"},{"Add":"MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }"},{"Add":"MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }"},{"Add":"MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }"},{"Add":""},{"Add":"#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)"},{"Add":""},{"Add":"/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */"},{"Add":"/* currently only defined for gcc and icc */"},{"Add":"typedef union { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign;"},{"Add":""},{"Add":"MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }"},{"Add":"MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }"},{"Add":"MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }"},{"Add":""},{"Add":"#else"},{"Add":""},{"Add":"/* default method, safe and standard."},{"Add":" can sometimes prove slower */"},{"Add":""},{"Add":"MEM_STATIC U16 MEM_read16(const void* memPtr)"},{"Add":"{"},{"Add":" U16 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_read32(const void* memPtr)"},{"Add":"{"},{"Add":" U32 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U64 MEM_read64(const void* memPtr)"},{"Add":"{"},{"Add":" U64 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value)"},{"Add":"{"},{"Add":" memcpy(memPtr, &value, sizeof(value));"},{"Add":"}"},{"Add":""},{"Add":"#endif /* MEM_FORCE_MEMORY_ACCESS */"},{"Add":""},{"Add":""},{"Add":"MEM_STATIC U16 MEM_readLE16(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read16(memPtr);"},{"Add":" else"},{"Add":" {"},{"Add":" const BYTE* p = (const BYTE*)memPtr;"},{"Add":" return (U16)(p[0] + (p[1]<<8));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" {"},{"Add":" MEM_write16(memPtr, val);"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" BYTE* p = (BYTE*)memPtr;"},{"Add":" p[0] = (BYTE)val;"},{"Add":" p[1] = (BYTE)(val>>8);"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_readLE24(const void* memPtr)"},{"Add":"{"},{"Add":" return MEM_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_readLE32(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read32(memPtr);"},{"Add":" else"},{"Add":" {"},{"Add":" const BYTE* p = (const BYTE*)memPtr;"},{"Add":" return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"MEM_STATIC U64 MEM_readLE64(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read64(memPtr);"},{"Add":" else"},{"Add":" {"},{"Add":" const BYTE* p = (const BYTE*)memPtr;"},{"Add":" return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)"},{"Add":" + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"MEM_STATIC size_t MEM_readLEST(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_32bits())"},{"Add":" return (size_t)MEM_readLE32(memPtr);"},{"Add":" else"},{"Add":" return (size_t)MEM_readLE64(memPtr);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* MEM_H_MODULE */"},{"Add":""},{"Add":"/*"},{"Add":" zstd - standard compression library"},{"Add":" Header File for static linking only"},{"Add":"*/"},{"Add":"#ifndef ZSTD_STATIC_H"},{"Add":"#define ZSTD_STATIC_H"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Types"},{"Add":"***************************************/"},{"Add":"#define ZSTD_WINDOWLOG_ABSOLUTEMIN 11"},{"Add":""},{"Add":"/** from faster to stronger */"},{"Add":"typedef enum { ZSTD_fast, ZSTD_greedy, ZSTD_lazy, ZSTD_lazy2, ZSTD_btlazy2 } ZSTD_strategy;"},{"Add":""},{"Add":"typedef struct"},{"Add":"{"},{"Add":" U64 srcSize; /* optional : tells how much bytes are present in the frame. Use 0 if not known. */"},{"Add":" U32 windowLog; /* largest match distance : larger == more compression, more memory needed during decompression */"},{"Add":" U32 contentLog; /* full search segment : larger == more compression, slower, more memory (useless for fast) */"},{"Add":" U32 hashLog; /* dispatch table : larger == more memory, faster */"},{"Add":" U32 searchLog; /* nb of searches : larger == more compression, slower */"},{"Add":" U32 searchLength; /* size of matches : larger == faster decompression, sometimes less compression */"},{"Add":" ZSTD_strategy strategy;"},{"Add":"} ZSTD_parameters;"},{"Add":""},{"Add":"typedef ZSTDv04_Dctx ZSTD_DCtx;"},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Advanced functions"},{"Add":"***************************************/"},{"Add":"/** ZSTD_decompress_usingDict"},{"Add":"* Same as ZSTD_decompressDCtx, using a Dictionary content as prefix"},{"Add":"* Note : dict can be NULL, in which case, it's equivalent to ZSTD_decompressDCtx() */"},{"Add":"static size_t ZSTD_decompress_usingDict(ZSTD_DCtx* ctx,"},{"Add":" void* dst, size_t maxDstSize,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const void* dict,size_t dictSize);"},{"Add":""},{"Add":""},{"Add":"/* **************************************"},{"Add":"* Streaming functions (direct mode)"},{"Add":"****************************************/"},{"Add":"static size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx);"},{"Add":"static size_t ZSTD_getFrameParams(ZSTD_parameters* params, const void* src, size_t srcSize);"},{"Add":"static void ZSTD_decompress_insertDictionary(ZSTD_DCtx* ctx, const void* src, size_t srcSize);"},{"Add":""},{"Add":"static size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx);"},{"Add":"static size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);"},{"Add":""},{"Add":"/**"},{"Add":" Streaming decompression, bufferless mode"},{"Add":""},{"Add":" A ZSTD_DCtx object is required to track streaming operations."},{"Add":" Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it."},{"Add":" A ZSTD_DCtx object can be re-used multiple times. Use ZSTD_resetDCtx() to return to fresh status."},{"Add":""},{"Add":" First operation is to retrieve frame parameters, using ZSTD_getFrameParams()."},{"Add":" This function doesn't consume its input. It needs enough input data to properly decode the frame header."},{"Add":" Objective is to retrieve *params.windowlog, to know minimum amount of memory required during decoding."},{"Add":" Result : 0 when successful, it means the ZSTD_parameters structure has been filled."},{"Add":" >0 : means there is not enough data into src. Provides the expected size to successfully decode header."},{"Add":" errorCode, which can be tested using ZSTD_isError() (For example, if it's not a ZSTD header)"},{"Add":""},{"Add":" Then, you can optionally insert a dictionary."},{"Add":" This operation must mimic the compressor behavior, otherwise decompression will fail or be corrupted."},{"Add":""},{"Add":" Then it's possible to start decompression."},{"Add":" Use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively."},{"Add":" ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue()."},{"Add":" ZSTD_decompressContinue() requires this exact amount of bytes, or it will fail."},{"Add":" ZSTD_decompressContinue() needs previous data blocks during decompression, up to (1 << windowlog)."},{"Add":" They should preferably be located contiguously, prior to current block. Alternatively, a round buffer is also possible."},{"Add":""},{"Add":" @result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst'."},{"Add":" It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header."},{"Add":""},{"Add":" A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero."},{"Add":" Context can then be reset to start a new decompression."},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":""},{"Add":""},{"Add":"#endif /* ZSTD_STATIC_H */"},{"Add":""},{"Add":""},{"Add":"/*"},{"Add":" zstd_internal - common functions to include"},{"Add":" Header File for include"},{"Add":"*/"},{"Add":"#ifndef ZSTD_CCOMMON_H_MODULE"},{"Add":"#define ZSTD_CCOMMON_H_MODULE"},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Common macros"},{"Add":"***************************************/"},{"Add":"#define MIN(a,b) ((a)<(b) ? (a) : (b))"},{"Add":"#define MAX(a,b) ((a)>(b) ? (a) : (b))"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Common constants"},{"Add":"***************************************/"},{"Add":"#define ZSTD_MAGICNUMBER 0xFD2FB524 /* v0.4 */"},{"Add":""},{"Add":"#define KB *(1 <<10)"},{"Add":"#define MB *(1 <<20)"},{"Add":"#define GB *(1U<<30)"},{"Add":""},{"Add":"#define BLOCKSIZE (128 KB) /* define, for static allocation */"},{"Add":""},{"Add":"static const size_t ZSTD_blockHeaderSize = 3;"},{"Add":"static const size_t ZSTD_frameHeaderSize_min = 5;"},{"Add":"#define ZSTD_frameHeaderSize_max 5 /* define, for static allocation */"},{"Add":""},{"Add":"#define BIT7 128"},{"Add":"#define BIT6 64"},{"Add":"#define BIT5 32"},{"Add":"#define BIT4 16"},{"Add":"#define BIT1 2"},{"Add":"#define BIT0 1"},{"Add":""},{"Add":"#define IS_RAW BIT0"},{"Add":"#define IS_RLE BIT1"},{"Add":""},{"Add":"#define MINMATCH 4"},{"Add":"#define REPCODE_STARTVALUE 4"},{"Add":""},{"Add":"#define MLbits 7"},{"Add":"#define LLbits 6"},{"Add":"#define Offbits 5"},{"Add":"#define MaxML ((1< /* size_t, ptrdiff_t */"},{"Add":""},{"Add":""},{"Add":"/* *****************************************"},{"Add":"* FSE simple functions"},{"Add":"******************************************/"},{"Add":"static size_t FSE_decompress(void* dst, size_t maxDstSize,"},{"Add":" const void* cSrc, size_t cSrcSize);"},{"Add":"/*!"},{"Add":"FSE_decompress():"},{"Add":" Decompress FSE data from buffer 'cSrc', of size 'cSrcSize',"},{"Add":" into already allocated destination buffer 'dst', of size 'maxDstSize'."},{"Add":" return : size of regenerated data (<= maxDstSize)"},{"Add":" or an error code, which can be tested using FSE_isError()"},{"Add":""},{"Add":" ** Important ** : FSE_decompress() doesn't decompress non-compressible nor RLE data !!!"},{"Add":" Why ? : making this distinction requires a header."},{"Add":" Header management is intentionally delegated to the user layer, which can better manage special cases."},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/* *****************************************"},{"Add":"* Tool functions"},{"Add":"******************************************/"},{"Add":"/* Error Management */"},{"Add":"static unsigned FSE_isError(size_t code); /* tells if a return value is an error code */"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* *****************************************"},{"Add":"* FSE detailed API"},{"Add":"******************************************/"},{"Add":"/*!"},{"Add":"FSE_compress() does the following:"},{"Add":"1. count symbol occurrence from source[] into table count[]"},{"Add":"2. normalize counters so that sum(count[]) == Power_of_2 (2^tableLog)"},{"Add":"3. save normalized counters to memory buffer using writeNCount()"},{"Add":"4. build encoding table 'CTable' from normalized counters"},{"Add":"5. encode the data stream using encoding table 'CTable'"},{"Add":""},{"Add":"FSE_decompress() does the following:"},{"Add":"1. read normalized counters with readNCount()"},{"Add":"2. build decoding table 'DTable' from normalized counters"},{"Add":"3. decode the data stream using decoding table 'DTable'"},{"Add":""},{"Add":"The following API allows targeting specific sub-functions for advanced tasks."},{"Add":"For example, it's possible to compress several blocks using the same 'CTable',"},{"Add":"or to save and provide normalized distribution using external method."},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/* *** DECOMPRESSION *** */"},{"Add":""},{"Add":"/*!"},{"Add":"FSE_readNCount():"},{"Add":" Read compactly saved 'normalizedCounter' from 'rBuffer'."},{"Add":" return : size read from 'rBuffer'"},{"Add":" or an errorCode, which can be tested using FSE_isError()"},{"Add":" maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */"},{"Add":"static size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize);"},{"Add":""},{"Add":"/*!"},{"Add":"Constructor and Destructor of type FSE_DTable"},{"Add":" Note that its size depends on 'tableLog' */"},{"Add":"typedef unsigned FSE_DTable; /* don't allocate that. It's just a way to be more restrictive than void* */"},{"Add":""},{"Add":"/*!"},{"Add":"FSE_buildDTable():"},{"Add":" Builds 'dt', which must be already allocated, using FSE_createDTable()"},{"Add":" return : 0,"},{"Add":" or an errorCode, which can be tested using FSE_isError() */"},{"Add":"static size_t FSE_buildDTable ( FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);"},{"Add":""},{"Add":"/*!"},{"Add":"FSE_decompress_usingDTable():"},{"Add":" Decompress compressed source 'cSrc' of size 'cSrcSize' using 'dt'"},{"Add":" into 'dst' which must be already allocated."},{"Add":" return : size of regenerated data (necessarily <= maxDstSize)"},{"Add":" or an errorCode, which can be tested using FSE_isError() */"},{"Add":"static size_t FSE_decompress_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt);"},{"Add":""},{"Add":"/*!"},{"Add":"Tutorial :"},{"Add":"----------"},{"Add":"(Note : these functions only decompress FSE-compressed blocks."},{"Add":" If block is uncompressed, use memcpy() instead"},{"Add":" If block is a single repeated byte, use memset() instead )"},{"Add":""},{"Add":"The first step is to obtain the normalized frequencies of symbols."},{"Add":"This can be performed by FSE_readNCount() if it was saved using FSE_writeNCount()."},{"Add":"'normalizedCounter' must be already allocated, and have at least 'maxSymbolValuePtr[0]+1' cells of signed short."},{"Add":"In practice, that means it's necessary to know 'maxSymbolValue' beforehand,"},{"Add":"or size the table to handle worst case situations (typically 256)."},{"Add":"FSE_readNCount() will provide 'tableLog' and 'maxSymbolValue'."},{"Add":"The result of FSE_readNCount() is the number of bytes read from 'rBuffer'."},{"Add":"Note that 'rBufferSize' must be at least 4 bytes, even if useful information is less than that."},{"Add":"If there is an error, the function will return an error code, which can be tested using FSE_isError()."},{"Add":""},{"Add":"The next step is to build the decompression tables 'FSE_DTable' from 'normalizedCounter'."},{"Add":"This is performed by the function FSE_buildDTable()."},{"Add":"The space required by 'FSE_DTable' must be already allocated using FSE_createDTable()."},{"Add":"If there is an error, the function will return an error code, which can be tested using FSE_isError()."},{"Add":""},{"Add":"'FSE_DTable' can then be used to decompress 'cSrc', with FSE_decompress_usingDTable()."},{"Add":"'cSrcSize' must be strictly correct, otherwise decompression will fail."},{"Add":"FSE_decompress_usingDTable() result will tell how many bytes were regenerated (<=maxDstSize)."},{"Add":"If there is an error, the function will return an error code, which can be tested using FSE_isError(). (ex: dst buffer too small)"},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* FSE_H */"},{"Add":""},{"Add":""},{"Add":"/* ******************************************************************"},{"Add":" bitstream"},{"Add":" Part of NewGen Entropy library"},{"Add":" header file (to include)"},{"Add":" Copyright (C) 2013-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":"#ifndef BITSTREAM_H_MODULE"},{"Add":"#define BITSTREAM_H_MODULE"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*"},{"Add":"* This API consists of small unitary functions, which highly benefit from being inlined."},{"Add":"* Since link-time-optimization is not available for all compilers,"},{"Add":"* these functions are defined into a .h to be included."},{"Add":"*/"},{"Add":""},{"Add":"/**********************************************"},{"Add":"* bitStream decompression API (read backward)"},{"Add":"**********************************************/"},{"Add":"typedef struct"},{"Add":"{"},{"Add":" size_t bitContainer;"},{"Add":" unsigned bitsConsumed;"},{"Add":" const char* ptr;"},{"Add":" const char* start;"},{"Add":"} BIT_DStream_t;"},{"Add":""},{"Add":"typedef enum { BIT_DStream_unfinished = 0,"},{"Add":" BIT_DStream_endOfBuffer = 1,"},{"Add":" BIT_DStream_completed = 2,"},{"Add":" BIT_DStream_overflow = 3 } BIT_DStream_status; /* result of BIT_reloadDStream() */"},{"Add":" /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */"},{"Add":""},{"Add":"MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);"},{"Add":"MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);"},{"Add":"MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);"},{"Add":"MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);"},{"Add":""},{"Add":""},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* unsafe API"},{"Add":"******************************************/"},{"Add":"MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);"},{"Add":"/* faster, but works only if nbBits >= 1 */"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Helper functions"},{"Add":"****************************************************************/"},{"Add":"MEM_STATIC unsigned BIT_highbit32 (U32 val)"},{"Add":"{"},{"Add":"# if defined(_MSC_VER) /* Visual */"},{"Add":" unsigned long r=0;"},{"Add":" _BitScanReverse ( &r, val );"},{"Add":" return (unsigned) r;"},{"Add":"# elif defined(__GNUC__) && (__GNUC__ >= 3) /* Use GCC Intrinsic */"},{"Add":" return __builtin_clz (val) ^ 31;"},{"Add":"# else /* Software version */"},{"Add":" static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };"},{"Add":" U32 v = val;"},{"Add":" unsigned r;"},{"Add":" v |= v >> 1;"},{"Add":" v |= v >> 2;"},{"Add":" v |= v >> 4;"},{"Add":" v |= v >> 8;"},{"Add":" v |= v >> 16;"},{"Add":" r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];"},{"Add":" return r;"},{"Add":"# endif"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/**********************************************************"},{"Add":"* bitStream decoding"},{"Add":"**********************************************************/"},{"Add":""},{"Add":"/*!BIT_initDStream"},{"Add":"* Initialize a BIT_DStream_t."},{"Add":"* @bitD : a pointer to an already allocated BIT_DStream_t structure"},{"Add":"* @srcBuffer must point at the beginning of a bitStream"},{"Add":"* @srcSize must be the exact size of the bitStream"},{"Add":"* @result : size of stream (== srcSize) or an errorCode if a problem is detected"},{"Add":"*/"},{"Add":"MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)"},{"Add":"{"},{"Add":" if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }"},{"Add":""},{"Add":" if (srcSize >= sizeof(size_t)) /* normal case */"},{"Add":" {"},{"Add":" U32 contain32;"},{"Add":" bitD->start = (const char*)srcBuffer;"},{"Add":" bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(size_t);"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr);"},{"Add":" contain32 = ((const BYTE*)srcBuffer)[srcSize-1];"},{"Add":" if (contain32 == 0) return ERROR(GENERIC); /* endMark not present */"},{"Add":" bitD->bitsConsumed = 8 - BIT_highbit32(contain32);"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" U32 contain32;"},{"Add":" bitD->start = (const char*)srcBuffer;"},{"Add":" bitD->ptr = bitD->start;"},{"Add":" bitD->bitContainer = *(const BYTE*)(bitD->start);"},{"Add":" switch(srcSize)"},{"Add":" {"},{"Add":" case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16);/* fall-through */"},{"Add":" case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);/* fall-through */"},{"Add":" case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);/* fall-through */"},{"Add":" case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24; /* fall-through */"},{"Add":" case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16; /* fall-through */"},{"Add":" case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) << 8; /* fall-through */"},{"Add":" default: break;"},{"Add":" }"},{"Add":" contain32 = ((const BYTE*)srcBuffer)[srcSize-1];"},{"Add":" if (contain32 == 0) return ERROR(GENERIC); /* endMark not present */"},{"Add":" bitD->bitsConsumed = 8 - BIT_highbit32(contain32);"},{"Add":" bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8;"},{"Add":" }"},{"Add":""},{"Add":" return srcSize;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;"},{"Add":" return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);"},{"Add":"}"},{"Add":""},{"Add":"/*! BIT_lookBitsFast :"},{"Add":"* unsafe version; only works only if nbBits >= 1 */"},{"Add":"MEM_STATIC size_t BIT_lookBitsFast(BIT_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;"},{"Add":" return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" bitD->bitsConsumed += nbBits;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" size_t value = BIT_lookBits(bitD, nbBits);"},{"Add":" BIT_skipBits(bitD, nbBits);"},{"Add":" return value;"},{"Add":"}"},{"Add":""},{"Add":"/*!BIT_readBitsFast :"},{"Add":"* unsafe version; only works only if nbBits >= 1 */"},{"Add":"MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" size_t value = BIT_lookBitsFast(bitD, nbBits);"},{"Add":" BIT_skipBits(bitD, nbBits);"},{"Add":" return value;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)"},{"Add":"{"},{"Add":" if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* should never happen */"},{"Add":" return BIT_DStream_overflow;"},{"Add":""},{"Add":" if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer))"},{"Add":" {"},{"Add":" bitD->ptr -= bitD->bitsConsumed >> 3;"},{"Add":" bitD->bitsConsumed &= 7;"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr);"},{"Add":" return BIT_DStream_unfinished;"},{"Add":" }"},{"Add":" if (bitD->ptr == bitD->start)"},{"Add":" {"},{"Add":" if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;"},{"Add":" return BIT_DStream_completed;"},{"Add":" }"},{"Add":" {"},{"Add":" U32 nbBytes = bitD->bitsConsumed >> 3;"},{"Add":" BIT_DStream_status result = BIT_DStream_unfinished;"},{"Add":" if (bitD->ptr - nbBytes < bitD->start)"},{"Add":" {"},{"Add":" nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */"},{"Add":" result = BIT_DStream_endOfBuffer;"},{"Add":" }"},{"Add":" bitD->ptr -= nbBytes;"},{"Add":" bitD->bitsConsumed -= nbBytes*8;"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD) */"},{"Add":" return result;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"/*! BIT_endOfDStream"},{"Add":"* @return Tells if DStream has reached its exact end"},{"Add":"*/"},{"Add":"MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)"},{"Add":"{"},{"Add":" return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));"},{"Add":"}"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* BITSTREAM_H_MODULE */"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* ******************************************************************"},{"Add":" FSE : Finite State Entropy coder"},{"Add":" header file for static linking (only)"},{"Add":" Copyright (C) 2013-2015, Yann Collet"},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":"#ifndef FSE_STATIC_H"},{"Add":"#define FSE_STATIC_H"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* *****************************************"},{"Add":"* Static allocation"},{"Add":"*******************************************/"},{"Add":"/* FSE buffer bounds */"},{"Add":"#define FSE_NCOUNTBOUND 512"},{"Add":"#define FSE_BLOCKBOUND(size) (size + (size>>7))"},{"Add":"#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size)) /* Macro version, useful for static allocation */"},{"Add":""},{"Add":"/* It is possible to statically allocate FSE CTable/DTable as a table of unsigned using below macros */"},{"Add":"#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2))"},{"Add":"#define FSE_DTABLE_SIZE_U32(maxTableLog) (1 + (1<= 1 (otherwise, result will be corrupted) */"},{"Add":""},{"Add":""},{"Add":"/* *****************************************"},{"Add":"* Implementation of inlined functions"},{"Add":"*******************************************/"},{"Add":"/* decompression */"},{"Add":""},{"Add":"typedef struct {"},{"Add":" U16 tableLog;"},{"Add":" U16 fastMode;"},{"Add":"} FSE_DTableHeader; /* sizeof U32 */"},{"Add":""},{"Add":"typedef struct"},{"Add":"{"},{"Add":" unsigned short newState;"},{"Add":" unsigned char symbol;"},{"Add":" unsigned char nbBits;"},{"Add":"} FSE_decode_t; /* size == U32 */"},{"Add":""},{"Add":"MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)"},{"Add":"{"},{"Add":" FSE_DTableHeader DTableH;"},{"Add":" memcpy(&DTableH, dt, sizeof(DTableH));"},{"Add":" DStatePtr->state = BIT_readBits(bitD, DTableH.tableLog);"},{"Add":" BIT_reloadDStream(bitD);"},{"Add":" DStatePtr->table = dt + 1;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)"},{"Add":"{"},{"Add":" const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];"},{"Add":" const U32 nbBits = DInfo.nbBits;"},{"Add":" BYTE symbol = DInfo.symbol;"},{"Add":" size_t lowBits = BIT_readBits(bitD, nbBits);"},{"Add":""},{"Add":" DStatePtr->state = DInfo.newState + lowBits;"},{"Add":" return symbol;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)"},{"Add":"{"},{"Add":" const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];"},{"Add":" const U32 nbBits = DInfo.nbBits;"},{"Add":" BYTE symbol = DInfo.symbol;"},{"Add":" size_t lowBits = BIT_readBitsFast(bitD, nbBits);"},{"Add":""},{"Add":" DStatePtr->state = DInfo.newState + lowBits;"},{"Add":" return symbol;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)"},{"Add":"{"},{"Add":" return DStatePtr->state == 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* FSE_STATIC_H */"},{"Add":""},{"Add":"/* ******************************************************************"},{"Add":" FSE : Finite State Entropy coder"},{"Add":" Copyright (C) 2013-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":""},{"Add":"#ifndef FSE_COMMONDEFS_ONLY"},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Tuning parameters"},{"Add":"****************************************************************/"},{"Add":"/*!MEMORY_USAGE :"},{"Add":"* Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)"},{"Add":"* Increasing memory usage improves compression ratio"},{"Add":"* Reduced memory usage can improve speed, due to cache effect"},{"Add":"* Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */"},{"Add":"#define FSE_MAX_MEMORY_USAGE 14"},{"Add":"#define FSE_DEFAULT_MEMORY_USAGE 13"},{"Add":""},{"Add":"/*!FSE_MAX_SYMBOL_VALUE :"},{"Add":"* Maximum symbol value authorized."},{"Add":"* Required for proper stack allocation */"},{"Add":"#define FSE_MAX_SYMBOL_VALUE 255"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* template functions type & suffix"},{"Add":"****************************************************************/"},{"Add":"#define FSE_FUNCTION_TYPE BYTE"},{"Add":"#define FSE_FUNCTION_EXTENSION"},{"Add":"#define FSE_DECODE_TYPE FSE_decode_t"},{"Add":""},{"Add":""},{"Add":"#endif /* !FSE_COMMONDEFS_ONLY */"},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Compiler specifics"},{"Add":"****************************************************************/"},{"Add":"#ifdef _MSC_VER /* Visual Studio */"},{"Add":"# define FORCE_INLINE static __forceinline"},{"Add":"# include /* For Visual 2005 */"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"# pragma warning(disable : 4214) /* disable: C4214: non-int bitfields */"},{"Add":"#else"},{"Add":"# if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */"},{"Add":"# ifdef __GNUC__"},{"Add":"# define FORCE_INLINE static inline __attribute__((always_inline))"},{"Add":"# else"},{"Add":"# define FORCE_INLINE static inline"},{"Add":"# endif"},{"Add":"# else"},{"Add":"# define FORCE_INLINE static"},{"Add":"# endif /* __STDC_VERSION__ */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Dependencies"},{"Add":"****************************************************************/"},{"Add":"#include /* malloc, free, qsort */"},{"Add":"#include /* memcpy, memset */"},{"Add":"#include /* printf (debug) */"},{"Add":""},{"Add":""},{"Add":"/* ***************************************************************"},{"Add":"* Constants"},{"Add":"*****************************************************************/"},{"Add":"#define FSE_MAX_TABLELOG (FSE_MAX_MEMORY_USAGE-2)"},{"Add":"#define FSE_MAX_TABLESIZE (1U< FSE_TABLELOG_ABSOLUTE_MAX"},{"Add":"#error \"FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported\""},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Error Management"},{"Add":"****************************************************************/"},{"Add":"#define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Complex types"},{"Add":"****************************************************************/"},{"Add":"typedef U32 DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];"},{"Add":""},{"Add":""},{"Add":"/*-**************************************************************"},{"Add":"* Templates"},{"Add":"****************************************************************/"},{"Add":"/*"},{"Add":" designed to be included"},{"Add":" for type-specific functions (template emulation in C)"},{"Add":" Objective is to write these functions only once, for improved maintenance"},{"Add":"*/"},{"Add":""},{"Add":"/* safety checks */"},{"Add":"#ifndef FSE_FUNCTION_EXTENSION"},{"Add":"# error \"FSE_FUNCTION_EXTENSION must be defined\""},{"Add":"#endif"},{"Add":"#ifndef FSE_FUNCTION_TYPE"},{"Add":"# error \"FSE_FUNCTION_TYPE must be defined\""},{"Add":"#endif"},{"Add":""},{"Add":"/* Function names */"},{"Add":"#define FSE_CAT(X,Y) X##Y"},{"Add":"#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)"},{"Add":"#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)"},{"Add":""},{"Add":"static U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; }"},{"Add":""},{"Add":""},{"Add":"static size_t FSE_buildDTable(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)"},{"Add":"{"},{"Add":" FSE_DTableHeader DTableH;"},{"Add":" void* const tdPtr = dt+1; /* because dt is unsigned, 32-bits aligned on 32-bits */"},{"Add":" FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*) (tdPtr);"},{"Add":" const U32 tableSize = 1 << tableLog;"},{"Add":" const U32 tableMask = tableSize-1;"},{"Add":" const U32 step = FSE_tableStep(tableSize);"},{"Add":" U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1];"},{"Add":" U32 position = 0;"},{"Add":" U32 highThreshold = tableSize-1;"},{"Add":" const S16 largeLimit= (S16)(1 << (tableLog-1));"},{"Add":" U32 noLarge = 1;"},{"Add":" U32 s;"},{"Add":""},{"Add":" /* Sanity Checks */"},{"Add":" if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);"},{"Add":" if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);"},{"Add":""},{"Add":" /* Init, lay down lowprob symbols */"},{"Add":" memset(tableDecode, 0, sizeof(FSE_DECODE_TYPE) * (maxSymbolValue+1) ); /* useless init, but keep static analyzer happy, and we don't need to performance optimize legacy decoders */"},{"Add":" DTableH.tableLog = (U16)tableLog;"},{"Add":" for (s=0; s<=maxSymbolValue; s++)"},{"Add":" {"},{"Add":" if (normalizedCounter[s]==-1)"},{"Add":" {"},{"Add":" tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;"},{"Add":" symbolNext[s] = 1;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" if (normalizedCounter[s] >= largeLimit) noLarge=0;"},{"Add":" symbolNext[s] = normalizedCounter[s];"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" /* Spread symbols */"},{"Add":" for (s=0; s<=maxSymbolValue; s++)"},{"Add":" {"},{"Add":" int i;"},{"Add":" for (i=0; i highThreshold) position = (position + step) & tableMask; /* lowprob area */"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" if (position!=0) return ERROR(GENERIC); /* position must reach all cells once, otherwise normalizedCounter is incorrect */"},{"Add":""},{"Add":" /* Build Decoding table */"},{"Add":" {"},{"Add":" U32 i;"},{"Add":" for (i=0; i FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);"},{"Add":" bitStream >>= 4;"},{"Add":" bitCount = 4;"},{"Add":" *tableLogPtr = nbBits;"},{"Add":" remaining = (1<1) && (charnum<=*maxSVPtr))"},{"Add":" {"},{"Add":" if (previous0)"},{"Add":" {"},{"Add":" unsigned n0 = charnum;"},{"Add":" while ((bitStream & 0xFFFF) == 0xFFFF)"},{"Add":" {"},{"Add":" n0+=24;"},{"Add":" if (ip < iend-5)"},{"Add":" {"},{"Add":" ip+=2;"},{"Add":" bitStream = MEM_readLE32(ip) >> bitCount;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" bitStream >>= 16;"},{"Add":" bitCount+=16;"},{"Add":" }"},{"Add":" }"},{"Add":" while ((bitStream & 3) == 3)"},{"Add":" {"},{"Add":" n0+=3;"},{"Add":" bitStream>>=2;"},{"Add":" bitCount+=2;"},{"Add":" }"},{"Add":" n0 += bitStream & 3;"},{"Add":" bitCount += 2;"},{"Add":" if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);"},{"Add":" while (charnum < n0) normalizedCounter[charnum++] = 0;"},{"Add":" if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))"},{"Add":" {"},{"Add":" ip += bitCount>>3;"},{"Add":" bitCount &= 7;"},{"Add":" bitStream = MEM_readLE32(ip) >> bitCount;"},{"Add":" }"},{"Add":" else"},{"Add":" bitStream >>= 2;"},{"Add":" }"},{"Add":" {"},{"Add":" const short max = (short)((2*threshold-1)-remaining);"},{"Add":" short count;"},{"Add":""},{"Add":" if ((bitStream & (threshold-1)) < (U32)max)"},{"Add":" {"},{"Add":" count = (short)(bitStream & (threshold-1));"},{"Add":" bitCount += nbBits-1;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" count = (short)(bitStream & (2*threshold-1));"},{"Add":" if (count >= threshold) count -= max;"},{"Add":" bitCount += nbBits;"},{"Add":" }"},{"Add":""},{"Add":" count--; /* extra accuracy */"},{"Add":" remaining -= FSE_abs(count);"},{"Add":" normalizedCounter[charnum++] = count;"},{"Add":" previous0 = !count;"},{"Add":" while (remaining < threshold)"},{"Add":" {"},{"Add":" nbBits--;"},{"Add":" threshold >>= 1;"},{"Add":" }"},{"Add":""},{"Add":" {"},{"Add":" if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))"},{"Add":" {"},{"Add":" ip += bitCount>>3;"},{"Add":" bitCount &= 7;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" bitCount -= (int)(8 * (iend - 4 - ip));"},{"Add":" ip = iend - 4;"},{"Add":" }"},{"Add":" bitStream = MEM_readLE32(ip) >> (bitCount & 31);"},{"Add":" }"},{"Add":" }"},{"Add":" }"},{"Add":" if (remaining != 1) return ERROR(GENERIC);"},{"Add":" *maxSVPtr = charnum-1;"},{"Add":""},{"Add":" ip += (bitCount+7)>>3;"},{"Add":" if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong);"},{"Add":" return ip-istart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*********************************************************"},{"Add":"* Decompression (Byte symbols)"},{"Add":"*********************************************************/"},{"Add":"static size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)"},{"Add":"{"},{"Add":" void* ptr = dt;"},{"Add":" FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;"},{"Add":" void* dPtr = dt + 1;"},{"Add":" FSE_decode_t* const cell = (FSE_decode_t*)dPtr;"},{"Add":""},{"Add":" DTableH->tableLog = 0;"},{"Add":" DTableH->fastMode = 0;"},{"Add":""},{"Add":" cell->newState = 0;"},{"Add":" cell->symbol = symbolValue;"},{"Add":" cell->nbBits = 0;"},{"Add":""},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)"},{"Add":"{"},{"Add":" void* ptr = dt;"},{"Add":" FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;"},{"Add":" void* dPtr = dt + 1;"},{"Add":" FSE_decode_t* const dinfo = (FSE_decode_t*)dPtr;"},{"Add":" const unsigned tableSize = 1 << nbBits;"},{"Add":" const unsigned tableMask = tableSize - 1;"},{"Add":" const unsigned maxSymbolValue = tableMask;"},{"Add":" unsigned s;"},{"Add":""},{"Add":" /* Sanity checks */"},{"Add":" if (nbBits < 1) return ERROR(GENERIC); /* min size */"},{"Add":""},{"Add":" /* Build Decoding Table */"},{"Add":" DTableH->tableLog = (U16)nbBits;"},{"Add":" DTableH->fastMode = 1;"},{"Add":" for (s=0; s<=maxSymbolValue; s++)"},{"Add":" {"},{"Add":" dinfo[s].newState = 0;"},{"Add":" dinfo[s].symbol = (BYTE)s;"},{"Add":" dinfo[s].nbBits = (BYTE)nbBits;"},{"Add":" }"},{"Add":""},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"FORCE_INLINE size_t FSE_decompress_usingDTable_generic("},{"Add":" void* dst, size_t maxDstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const FSE_DTable* dt, const unsigned fast)"},{"Add":"{"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* op = ostart;"},{"Add":" BYTE* const omax = op + maxDstSize;"},{"Add":" BYTE* const olimit = omax-3;"},{"Add":""},{"Add":" BIT_DStream_t bitD;"},{"Add":" FSE_DState_t state1;"},{"Add":" FSE_DState_t state2;"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" /* Init */"},{"Add":" errorCode = BIT_initDStream(&bitD, cSrc, cSrcSize); /* replaced last arg by maxCompressed Size */"},{"Add":" if (FSE_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" FSE_initDState(&state1, &bitD, dt);"},{"Add":" FSE_initDState(&state2, &bitD, dt);"},{"Add":""},{"Add":"#define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD)"},{"Add":""},{"Add":" /* 4 symbols per loop */"},{"Add":" for ( ; (BIT_reloadDStream(&bitD)==BIT_DStream_unfinished) && (op sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" BIT_reloadDStream(&bitD);"},{"Add":""},{"Add":" op[1] = FSE_GETSYMBOL(&state2);"},{"Add":""},{"Add":" if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" { if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } }"},{"Add":""},{"Add":" op[2] = FSE_GETSYMBOL(&state1);"},{"Add":""},{"Add":" if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" BIT_reloadDStream(&bitD);"},{"Add":""},{"Add":" op[3] = FSE_GETSYMBOL(&state2);"},{"Add":" }"},{"Add":""},{"Add":" /* tail */"},{"Add":" /* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */"},{"Add":" while (1)"},{"Add":" {"},{"Add":" if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) )"},{"Add":" break;"},{"Add":""},{"Add":" *op++ = FSE_GETSYMBOL(&state1);"},{"Add":""},{"Add":" if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) )"},{"Add":" break;"},{"Add":""},{"Add":" *op++ = FSE_GETSYMBOL(&state2);"},{"Add":" }"},{"Add":""},{"Add":" /* end ? */"},{"Add":" if (BIT_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2))"},{"Add":" return op-ostart;"},{"Add":""},{"Add":" if (op==omax) return ERROR(dstSize_tooSmall); /* dst buffer is full, but cSrc unfinished */"},{"Add":""},{"Add":" return ERROR(corruption_detected);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const FSE_DTable* dt)"},{"Add":"{"},{"Add":" FSE_DTableHeader DTableH;"},{"Add":" U32 fastMode;"},{"Add":""},{"Add":" memcpy(&DTableH, dt, sizeof(DTableH));"},{"Add":" fastMode = DTableH.fastMode;"},{"Add":""},{"Add":" /* select fast mode (static) */"},{"Add":" if (fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);"},{"Add":" return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t FSE_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE*)cSrc;"},{"Add":" const BYTE* ip = istart;"},{"Add":" short counting[FSE_MAX_SYMBOL_VALUE+1];"},{"Add":" DTable_max_t dt; /* Static analyzer seems unable to understand this table will be properly initialized later */"},{"Add":" unsigned tableLog;"},{"Add":" unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" if (cSrcSize<2) return ERROR(srcSize_wrong); /* too small input size */"},{"Add":""},{"Add":" /* normal FSE decoding mode */"},{"Add":" errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);"},{"Add":" if (FSE_isError(errorCode)) return errorCode;"},{"Add":" if (errorCode >= cSrcSize) return ERROR(srcSize_wrong); /* too small input size */"},{"Add":" ip += errorCode;"},{"Add":" cSrcSize -= errorCode;"},{"Add":""},{"Add":" errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog);"},{"Add":" if (FSE_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" /* always return, even if it is an error code */"},{"Add":" return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"#endif /* FSE_COMMONDEFS_ONLY */"},{"Add":""},{"Add":""},{"Add":"/* ******************************************************************"},{"Add":" Huff0 : Huffman coder, part of New Generation Entropy library"},{"Add":" header file"},{"Add":" Copyright (C) 2013-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":"#ifndef HUFF0_H"},{"Add":"#define HUFF0_H"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* ****************************************"},{"Add":"* Dependency"},{"Add":"******************************************/"},{"Add":"#include /* size_t */"},{"Add":""},{"Add":""},{"Add":"/* ****************************************"},{"Add":"* Huff0 simple functions"},{"Add":"******************************************/"},{"Add":"static size_t HUF_decompress(void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize);"},{"Add":"/*!"},{"Add":"HUF_decompress():"},{"Add":" Decompress Huff0 data from buffer 'cSrc', of size 'cSrcSize',"},{"Add":" into already allocated destination buffer 'dst', of size 'dstSize'."},{"Add":" 'dstSize' must be the exact size of original (uncompressed) data."},{"Add":" Note : in contrast with FSE, HUF_decompress can regenerate RLE (cSrcSize==1) and uncompressed (cSrcSize==dstSize) data, because it knows size to regenerate."},{"Add":" @return : size of regenerated data (== dstSize)"},{"Add":" or an error code, which can be tested using HUF_isError()"},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/* ****************************************"},{"Add":"* Tool functions"},{"Add":"******************************************/"},{"Add":"/* Error Management */"},{"Add":"static unsigned HUF_isError(size_t code); /* tells if a return value is an error code */"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* HUFF0_H */"},{"Add":""},{"Add":""},{"Add":"/* ******************************************************************"},{"Add":" Huff0 : Huffman coder, part of New Generation Entropy library"},{"Add":" header file for static linking (only)"},{"Add":" Copyright (C) 2013-2015, Yann Collet"},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":"#ifndef HUFF0_STATIC_H"},{"Add":"#define HUFF0_STATIC_H"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* ****************************************"},{"Add":"* Static allocation macros"},{"Add":"******************************************/"},{"Add":"/* static allocation of Huff0's DTable */"},{"Add":"#define HUF_DTABLE_SIZE(maxTableLog) (1 + (1<= 199901L) /* C99 */)"},{"Add":"/* inline is defined */"},{"Add":"#elif defined(_MSC_VER)"},{"Add":"# define inline __inline"},{"Add":"#else"},{"Add":"# define inline /* disable inline */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"#ifdef _MSC_VER /* Visual Studio */"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Includes"},{"Add":"****************************************************************/"},{"Add":"#include /* malloc, free, qsort */"},{"Add":"#include /* memcpy, memset */"},{"Add":"#include /* printf (debug) */"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Constants"},{"Add":"****************************************************************/"},{"Add":"#define HUF_ABSOLUTEMAX_TABLELOG 16 /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */"},{"Add":"#define HUF_MAX_TABLELOG 12 /* max configured tableLog (for static allocation); can be modified up to HUF_ABSOLUTEMAX_TABLELOG */"},{"Add":"#define HUF_DEFAULT_TABLELOG HUF_MAX_TABLELOG /* tableLog by default, when not specified */"},{"Add":"#define HUF_MAX_SYMBOL_VALUE 255"},{"Add":"#if (HUF_MAX_TABLELOG > HUF_ABSOLUTEMAX_TABLELOG)"},{"Add":"# error \"HUF_MAX_TABLELOG is too large !\""},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* **************************************************************"},{"Add":"* Error Management"},{"Add":"****************************************************************/"},{"Add":"static unsigned HUF_isError(size_t code) { return ERR_isError(code); }"},{"Add":"#define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*-*******************************************************"},{"Add":"* Huff0 : Huffman block decompression"},{"Add":"*********************************************************/"},{"Add":"typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX2; /* single-symbol decoding */"},{"Add":""},{"Add":"typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX4; /* double-symbols decoding */"},{"Add":""},{"Add":"typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;"},{"Add":""},{"Add":"/*! HUF_readStats"},{"Add":" Read compact Huffman tree, saved by HUF_writeCTable"},{"Add":" @huffWeight : destination buffer"},{"Add":" @return : size read from `src`"},{"Add":"*/"},{"Add":"static size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,"},{"Add":" U32* nbSymbolsPtr, U32* tableLogPtr,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" U32 weightTotal;"},{"Add":" U32 tableLog;"},{"Add":" const BYTE* ip = (const BYTE*) src;"},{"Add":" size_t iSize;"},{"Add":" size_t oSize;"},{"Add":" U32 n;"},{"Add":""},{"Add":" if (!srcSize) return ERROR(srcSize_wrong);"},{"Add":" iSize = ip[0];"},{"Add":" //memset(huffWeight, 0, hwSize); /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" if (iSize >= 128) /* special header */"},{"Add":" {"},{"Add":" if (iSize >= (242)) /* RLE */"},{"Add":" {"},{"Add":" static int l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };"},{"Add":" oSize = l[iSize-242];"},{"Add":" memset(huffWeight, 1, hwSize);"},{"Add":" iSize = 0;"},{"Add":" }"},{"Add":" else /* Incompressible */"},{"Add":" {"},{"Add":" oSize = iSize - 127;"},{"Add":" iSize = ((oSize+1)/2);"},{"Add":" if (iSize+1 > srcSize) return ERROR(srcSize_wrong);"},{"Add":" if (oSize >= hwSize) return ERROR(corruption_detected);"},{"Add":" ip += 1;"},{"Add":" for (n=0; n> 4;"},{"Add":" huffWeight[n+1] = ip[n/2] & 15;"},{"Add":" }"},{"Add":" }"},{"Add":" }"},{"Add":" else /* header compressed with FSE (normal case) */"},{"Add":" {"},{"Add":" if (iSize+1 > srcSize) return ERROR(srcSize_wrong);"},{"Add":" oSize = FSE_decompress(huffWeight, hwSize-1, ip+1, iSize); /* max (hwSize-1) values decoded, as last one is implied */"},{"Add":" if (FSE_isError(oSize)) return oSize;"},{"Add":" }"},{"Add":""},{"Add":" /* collect weight stats */"},{"Add":" memset(rankStats, 0, (HUF_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32));"},{"Add":" weightTotal = 0;"},{"Add":" for (n=0; n= HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);"},{"Add":" rankStats[huffWeight[n]]++;"},{"Add":" weightTotal += (1 << huffWeight[n]) >> 1;"},{"Add":" }"},{"Add":" if (weightTotal == 0) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* get last non-null symbol weight (implied, total must be 2^n) */"},{"Add":" tableLog = BIT_highbit32(weightTotal) + 1;"},{"Add":" if (tableLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);"},{"Add":" {"},{"Add":" U32 total = 1 << tableLog;"},{"Add":" U32 rest = total - weightTotal;"},{"Add":" U32 verif = 1 << BIT_highbit32(rest);"},{"Add":" U32 lastWeight = BIT_highbit32(rest) + 1;"},{"Add":" if (verif != rest) return ERROR(corruption_detected); /* last value must be a clean power of 2 */"},{"Add":" huffWeight[oSize] = (BYTE)lastWeight;"},{"Add":" rankStats[lastWeight]++;"},{"Add":" }"},{"Add":""},{"Add":" /* check tree construction validity */"},{"Add":" if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected); /* by construction : at least 2 elts of rank 1, must be even */"},{"Add":""},{"Add":" /* results */"},{"Add":" *nbSymbolsPtr = (U32)(oSize+1);"},{"Add":" *tableLogPtr = tableLog;"},{"Add":" return iSize+1;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/**************************/"},{"Add":"/* single-symbol decoding */"},{"Add":"/**************************/"},{"Add":""},{"Add":"static size_t HUF_readDTableX2 (U16* DTable, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1];"},{"Add":" U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1]; /* large enough for values from 0 to 16 */"},{"Add":" U32 tableLog = 0;"},{"Add":" size_t iSize;"},{"Add":" U32 nbSymbols = 0;"},{"Add":" U32 n;"},{"Add":" U32 nextRankStart;"},{"Add":" void* const dtPtr = DTable + 1;"},{"Add":" HUF_DEltX2* const dt = (HUF_DEltX2*)dtPtr;"},{"Add":""},{"Add":" HUF_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(U16)); /* if compilation fails here, assertion is false */"},{"Add":" //memset(huffWeight, 0, sizeof(huffWeight)); /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" iSize = HUF_readStats(huffWeight, HUF_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);"},{"Add":" if (HUF_isError(iSize)) return iSize;"},{"Add":""},{"Add":" /* check result */"},{"Add":" if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge); /* DTable is too small */"},{"Add":" DTable[0] = (U16)tableLog; /* maybe should separate sizeof DTable, as allocated, from used size of DTable, in case of DTable re-use */"},{"Add":""},{"Add":" /* Prepare ranks */"},{"Add":" nextRankStart = 0;"},{"Add":" for (n=1; n<=tableLog; n++)"},{"Add":" {"},{"Add":" U32 current = nextRankStart;"},{"Add":" nextRankStart += (rankVal[n] << (n-1));"},{"Add":" rankVal[n] = current;"},{"Add":" }"},{"Add":""},{"Add":" /* fill DTable */"},{"Add":" for (n=0; n> 1;"},{"Add":" U32 i;"},{"Add":" HUF_DEltX2 D;"},{"Add":" D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);"},{"Add":" for (i = rankVal[w]; i < rankVal[w] + length; i++)"},{"Add":" dt[i] = D;"},{"Add":" rankVal[w] += length;"},{"Add":" }"},{"Add":""},{"Add":" return iSize;"},{"Add":"}"},{"Add":""},{"Add":"static BYTE HUF_decodeSymbolX2(BIT_DStream_t* Dstream, const HUF_DEltX2* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" const size_t val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */"},{"Add":" const BYTE c = dt[val].byte;"},{"Add":" BIT_skipBits(Dstream, dt[val].nbBits);"},{"Add":" return c;"},{"Add":"}"},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \\"},{"Add":" *ptr++ = HUF_decodeSymbolX2(DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \\"},{"Add":" HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)"},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits()) \\"},{"Add":" HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)"},{"Add":""},{"Add":"static inline size_t HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX2* const dt, const U32 dtLog)"},{"Add":"{"},{"Add":" BYTE* const pStart = p;"},{"Add":""},{"Add":" /* up to 4 symbols at a time */"},{"Add":" while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-4))"},{"Add":" {"},{"Add":" HUF_DECODE_SYMBOLX2_2(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX2_1(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX2_2(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":" }"},{"Add":""},{"Add":" /* closer to the end */"},{"Add":" while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd))"},{"Add":" HUF_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":""},{"Add":" /* no more data to retrieve from bitstream, hence no need to reload */"},{"Add":" while (p < pEnd)"},{"Add":" HUF_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":""},{"Add":" return pEnd-pStart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t HUF_decompress4X2_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const U16* DTable)"},{"Add":"{"},{"Add":" if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */"},{"Add":""},{"Add":" {"},{"Add":" const BYTE* const istart = (const BYTE*) cSrc;"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* const oend = ostart + dstSize;"},{"Add":" const void* const dtPtr = DTable;"},{"Add":" const HUF_DEltX2* const dt = ((const HUF_DEltX2*)dtPtr) +1;"},{"Add":" const U32 dtLog = DTable[0];"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" /* Init */"},{"Add":" BIT_DStream_t bitD1;"},{"Add":" BIT_DStream_t bitD2;"},{"Add":" BIT_DStream_t bitD3;"},{"Add":" BIT_DStream_t bitD4;"},{"Add":" const size_t length1 = MEM_readLE16(istart);"},{"Add":" const size_t length2 = MEM_readLE16(istart+2);"},{"Add":" const size_t length3 = MEM_readLE16(istart+4);"},{"Add":" size_t length4;"},{"Add":" const BYTE* const istart1 = istart + 6; /* jumpTable */"},{"Add":" const BYTE* const istart2 = istart1 + length1;"},{"Add":" const BYTE* const istart3 = istart2 + length2;"},{"Add":" const BYTE* const istart4 = istart3 + length3;"},{"Add":" const size_t segmentSize = (dstSize+3) / 4;"},{"Add":" BYTE* const opStart2 = ostart + segmentSize;"},{"Add":" BYTE* const opStart3 = opStart2 + segmentSize;"},{"Add":" BYTE* const opStart4 = opStart3 + segmentSize;"},{"Add":" BYTE* op1 = ostart;"},{"Add":" BYTE* op2 = opStart2;"},{"Add":" BYTE* op3 = opStart3;"},{"Add":" BYTE* op4 = opStart4;"},{"Add":" U32 endSignal;"},{"Add":""},{"Add":" length4 = cSrcSize - (length1 + length2 + length3 + 6);"},{"Add":" if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */"},{"Add":" errorCode = BIT_initDStream(&bitD1, istart1, length1);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD2, istart2, length2);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD3, istart3, length3);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD4, istart4, length4);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" /* 16-32 symbols per loop (4-8 symbols per stream) */"},{"Add":" endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);"},{"Add":" for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )"},{"Add":" {"},{"Add":" HUF_DECODE_SYMBOLX2_2(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX2_1(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX2_1(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX2_1(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX2_1(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX2_0(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX2_0(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX2_0(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX2_0(op4, &bitD4);"},{"Add":""},{"Add":" endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);"},{"Add":" }"},{"Add":""},{"Add":" /* check corruption */"},{"Add":" if (op1 > opStart2) return ERROR(corruption_detected);"},{"Add":" if (op2 > opStart3) return ERROR(corruption_detected);"},{"Add":" if (op3 > opStart4) return ERROR(corruption_detected);"},{"Add":" /* note : op4 supposed already verified within main loop */"},{"Add":""},{"Add":" /* finish bitStreams one by one */"},{"Add":" HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);"},{"Add":" HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);"},{"Add":" HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);"},{"Add":" HUF_decodeStreamX2(op4, &bitD4, oend, dt, dtLog);"},{"Add":""},{"Add":" /* check */"},{"Add":" endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);"},{"Add":" if (!endSignal) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* decoded size */"},{"Add":" return dstSize;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_MAX_TABLELOG);"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" errorCode = HUF_readDTableX2 (DTable, cSrc, cSrcSize);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += errorCode;"},{"Add":" cSrcSize -= errorCode;"},{"Add":""},{"Add":" return HUF_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/***************************/"},{"Add":"/* double-symbols decoding */"},{"Add":"/***************************/"},{"Add":""},{"Add":"static void HUF_fillDTableX4Level2(HUF_DEltX4* DTable, U32 sizeLog, const U32 consumed,"},{"Add":" const U32* rankValOrigin, const int minWeight,"},{"Add":" const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,"},{"Add":" U32 nbBitsBaseline, U16 baseSeq)"},{"Add":"{"},{"Add":" HUF_DEltX4 DElt;"},{"Add":" U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];"},{"Add":" U32 s;"},{"Add":""},{"Add":" /* get pre-calculated rankVal */"},{"Add":" memcpy(rankVal, rankValOrigin, sizeof(rankVal));"},{"Add":""},{"Add":" /* fill skipped values */"},{"Add":" if (minWeight>1)"},{"Add":" {"},{"Add":" U32 i, skipSize = rankVal[minWeight];"},{"Add":" MEM_writeLE16(&(DElt.sequence), baseSeq);"},{"Add":" DElt.nbBits = (BYTE)(consumed);"},{"Add":" DElt.length = 1;"},{"Add":" for (i = 0; i < skipSize; i++)"},{"Add":" DTable[i] = DElt;"},{"Add":" }"},{"Add":""},{"Add":" /* fill DTable */"},{"Add":" for (s=0; s= 1 */"},{"Add":""},{"Add":" rankVal[weight] += length;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"typedef U32 rankVal_t[HUF_ABSOLUTEMAX_TABLELOG][HUF_ABSOLUTEMAX_TABLELOG + 1];"},{"Add":""},{"Add":"static void HUF_fillDTableX4(HUF_DEltX4* DTable, const U32 targetLog,"},{"Add":" const sortedSymbol_t* sortedList, const U32 sortedListSize,"},{"Add":" const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,"},{"Add":" const U32 nbBitsBaseline)"},{"Add":"{"},{"Add":" U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];"},{"Add":" const int scaleLog = nbBitsBaseline - targetLog; /* note : targetLog >= srcLog, hence scaleLog <= 1 */"},{"Add":" const U32 minBits = nbBitsBaseline - maxWeight;"},{"Add":" U32 s;"},{"Add":""},{"Add":" memcpy(rankVal, rankValOrigin, sizeof(rankVal));"},{"Add":""},{"Add":" /* fill DTable */"},{"Add":" for (s=0; s= minBits) /* enough room for a second symbol */"},{"Add":" {"},{"Add":" U32 sortedRank;"},{"Add":" int minWeight = nbBits + scaleLog;"},{"Add":" if (minWeight < 1) minWeight = 1;"},{"Add":" sortedRank = rankStart[minWeight];"},{"Add":" HUF_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,"},{"Add":" rankValOrigin[nbBits], minWeight,"},{"Add":" sortedList+sortedRank, sortedListSize-sortedRank,"},{"Add":" nbBitsBaseline, symbol);"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" U32 i;"},{"Add":" const U32 end = start + length;"},{"Add":" HUF_DEltX4 DElt;"},{"Add":""},{"Add":" MEM_writeLE16(&(DElt.sequence), symbol);"},{"Add":" DElt.nbBits = (BYTE)(nbBits);"},{"Add":" DElt.length = 1;"},{"Add":" for (i = start; i < end; i++)"},{"Add":" DTable[i] = DElt;"},{"Add":" }"},{"Add":" rankVal[weight] += length;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"static size_t HUF_readDTableX4 (U32* DTable, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" BYTE weightList[HUF_MAX_SYMBOL_VALUE + 1];"},{"Add":" sortedSymbol_t sortedSymbol[HUF_MAX_SYMBOL_VALUE + 1];"},{"Add":" U32 rankStats[HUF_ABSOLUTEMAX_TABLELOG + 1] = { 0 };"},{"Add":" U32 rankStart0[HUF_ABSOLUTEMAX_TABLELOG + 2] = { 0 };"},{"Add":" U32* const rankStart = rankStart0+1;"},{"Add":" rankVal_t rankVal;"},{"Add":" U32 tableLog, maxW, sizeOfSort, nbSymbols;"},{"Add":" const U32 memLog = DTable[0];"},{"Add":" size_t iSize;"},{"Add":" void* dtPtr = DTable;"},{"Add":" HUF_DEltX4* const dt = ((HUF_DEltX4*)dtPtr) + 1;"},{"Add":""},{"Add":" HUF_STATIC_ASSERT(sizeof(HUF_DEltX4) == sizeof(U32)); /* if compilation fails here, assertion is false */"},{"Add":" if (memLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);"},{"Add":" //memset(weightList, 0, sizeof(weightList)); /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" iSize = HUF_readStats(weightList, HUF_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);"},{"Add":" if (HUF_isError(iSize)) return iSize;"},{"Add":""},{"Add":" /* check result */"},{"Add":" if (tableLog > memLog) return ERROR(tableLog_tooLarge); /* DTable can't fit code depth */"},{"Add":""},{"Add":" /* find maxWeight */"},{"Add":" for (maxW = tableLog; rankStats[maxW]==0; maxW--)"},{"Add":" { if (!maxW) return ERROR(GENERIC); } /* necessarily finds a solution before maxW==0 */"},{"Add":""},{"Add":" /* Get start index of each weight */"},{"Add":" {"},{"Add":" U32 w, nextRankStart = 0;"},{"Add":" for (w=1; w<=maxW; w++)"},{"Add":" {"},{"Add":" U32 current = nextRankStart;"},{"Add":" nextRankStart += rankStats[w];"},{"Add":" rankStart[w] = current;"},{"Add":" }"},{"Add":" rankStart[0] = nextRankStart; /* put all 0w symbols at the end of sorted list*/"},{"Add":" sizeOfSort = nextRankStart;"},{"Add":" }"},{"Add":""},{"Add":" /* sort symbols by weight */"},{"Add":" {"},{"Add":" U32 s;"},{"Add":" for (s=0; s> consumed;"},{"Add":" }"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" HUF_fillDTableX4(dt, memLog,"},{"Add":" sortedSymbol, sizeOfSort,"},{"Add":" rankStart0, rankVal, maxW,"},{"Add":" tableLog+1);"},{"Add":""},{"Add":" return iSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static U32 HUF_decodeSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" const size_t val = BIT_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */"},{"Add":" memcpy(op, dt+val, 2);"},{"Add":" BIT_skipBits(DStream, dt[val].nbBits);"},{"Add":" return dt[val].length;"},{"Add":"}"},{"Add":""},{"Add":"static U32 HUF_decodeLastSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" const size_t val = BIT_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */"},{"Add":" memcpy(op, dt+val, 1);"},{"Add":" if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits);"},{"Add":" else"},{"Add":" {"},{"Add":" if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8))"},{"Add":" {"},{"Add":" BIT_skipBits(DStream, dt[val].nbBits);"},{"Add":" if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))"},{"Add":" DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8); /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */"},{"Add":" }"},{"Add":" }"},{"Add":" return 1;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \\"},{"Add":" ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \\"},{"Add":" ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits()) \\"},{"Add":" ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"static inline size_t HUF_decodeStreamX4(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const HUF_DEltX4* const dt, const U32 dtLog)"},{"Add":"{"},{"Add":" BYTE* const pStart = p;"},{"Add":""},{"Add":" /* up to 8 symbols at a time */"},{"Add":" while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd-7))"},{"Add":" {"},{"Add":" HUF_DECODE_SYMBOLX4_2(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX4_1(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX4_2(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX4_0(p, bitDPtr);"},{"Add":" }"},{"Add":""},{"Add":" /* closer to the end */"},{"Add":" while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-2))"},{"Add":" HUF_DECODE_SYMBOLX4_0(p, bitDPtr);"},{"Add":""},{"Add":" while (p <= pEnd-2)"},{"Add":" HUF_DECODE_SYMBOLX4_0(p, bitDPtr); /* no need to reload : reached the end of DStream */"},{"Add":""},{"Add":" if (p < pEnd)"},{"Add":" p += HUF_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);"},{"Add":""},{"Add":" return p-pStart;"},{"Add":"}"},{"Add":""},{"Add":"static size_t HUF_decompress4X4_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const U32* DTable)"},{"Add":"{"},{"Add":" if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */"},{"Add":""},{"Add":" {"},{"Add":" const BYTE* const istart = (const BYTE*) cSrc;"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* const oend = ostart + dstSize;"},{"Add":" const void* const dtPtr = DTable;"},{"Add":" const HUF_DEltX4* const dt = ((const HUF_DEltX4*)dtPtr) +1;"},{"Add":" const U32 dtLog = DTable[0];"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" /* Init */"},{"Add":" BIT_DStream_t bitD1;"},{"Add":" BIT_DStream_t bitD2;"},{"Add":" BIT_DStream_t bitD3;"},{"Add":" BIT_DStream_t bitD4;"},{"Add":" const size_t length1 = MEM_readLE16(istart);"},{"Add":" const size_t length2 = MEM_readLE16(istart+2);"},{"Add":" const size_t length3 = MEM_readLE16(istart+4);"},{"Add":" size_t length4;"},{"Add":" const BYTE* const istart1 = istart + 6; /* jumpTable */"},{"Add":" const BYTE* const istart2 = istart1 + length1;"},{"Add":" const BYTE* const istart3 = istart2 + length2;"},{"Add":" const BYTE* const istart4 = istart3 + length3;"},{"Add":" const size_t segmentSize = (dstSize+3) / 4;"},{"Add":" BYTE* const opStart2 = ostart + segmentSize;"},{"Add":" BYTE* const opStart3 = opStart2 + segmentSize;"},{"Add":" BYTE* const opStart4 = opStart3 + segmentSize;"},{"Add":" BYTE* op1 = ostart;"},{"Add":" BYTE* op2 = opStart2;"},{"Add":" BYTE* op3 = opStart3;"},{"Add":" BYTE* op4 = opStart4;"},{"Add":" U32 endSignal;"},{"Add":""},{"Add":" length4 = cSrcSize - (length1 + length2 + length3 + 6);"},{"Add":" if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */"},{"Add":" errorCode = BIT_initDStream(&bitD1, istart1, length1);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD2, istart2, length2);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD3, istart3, length3);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD4, istart4, length4);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" /* 16-32 symbols per loop (4-8 symbols per stream) */"},{"Add":" endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);"},{"Add":" for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )"},{"Add":" {"},{"Add":" HUF_DECODE_SYMBOLX4_2(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX4_1(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX4_1(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX4_1(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX4_1(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX4_0(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX4_0(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX4_0(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX4_0(op4, &bitD4);"},{"Add":""},{"Add":" endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);"},{"Add":" }"},{"Add":""},{"Add":" /* check corruption */"},{"Add":" if (op1 > opStart2) return ERROR(corruption_detected);"},{"Add":" if (op2 > opStart3) return ERROR(corruption_detected);"},{"Add":" if (op3 > opStart4) return ERROR(corruption_detected);"},{"Add":" /* note : op4 supposed already verified within main loop */"},{"Add":""},{"Add":" /* finish bitStreams one by one */"},{"Add":" HUF_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);"},{"Add":" HUF_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);"},{"Add":" HUF_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);"},{"Add":" HUF_decodeStreamX4(op4, &bitD4, oend, dt, dtLog);"},{"Add":""},{"Add":" /* check */"},{"Add":" endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);"},{"Add":" if (!endSignal) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* decoded size */"},{"Add":" return dstSize;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUF_CREATE_STATIC_DTABLEX4(DTable, HUF_MAX_TABLELOG);"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":""},{"Add":" size_t hSize = HUF_readDTableX4 (DTable, cSrc, cSrcSize);"},{"Add":" if (HUF_isError(hSize)) return hSize;"},{"Add":" if (hSize >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += hSize;"},{"Add":" cSrcSize -= hSize;"},{"Add":""},{"Add":" return HUF_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/**********************************/"},{"Add":"/* Generic decompression selector */"},{"Add":"/**********************************/"},{"Add":""},{"Add":"typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;"},{"Add":"static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] ="},{"Add":"{"},{"Add":" /* single, double, quad */"},{"Add":" {{0,0}, {1,1}, {2,2}}, /* Q==0 : impossible */"},{"Add":" {{0,0}, {1,1}, {2,2}}, /* Q==1 : impossible */"},{"Add":" {{ 38,130}, {1313, 74}, {2151, 38}}, /* Q == 2 : 12-18% */"},{"Add":" {{ 448,128}, {1353, 74}, {2238, 41}}, /* Q == 3 : 18-25% */"},{"Add":" {{ 556,128}, {1353, 74}, {2238, 47}}, /* Q == 4 : 25-32% */"},{"Add":" {{ 714,128}, {1418, 74}, {2436, 53}}, /* Q == 5 : 32-38% */"},{"Add":" {{ 883,128}, {1437, 74}, {2464, 61}}, /* Q == 6 : 38-44% */"},{"Add":" {{ 897,128}, {1515, 75}, {2622, 68}}, /* Q == 7 : 44-50% */"},{"Add":" {{ 926,128}, {1613, 75}, {2730, 75}}, /* Q == 8 : 50-56% */"},{"Add":" {{ 947,128}, {1729, 77}, {3359, 77}}, /* Q == 9 : 56-62% */"},{"Add":" {{1107,128}, {2083, 81}, {4006, 84}}, /* Q ==10 : 62-69% */"},{"Add":" {{1177,128}, {2379, 87}, {4785, 88}}, /* Q ==11 : 69-75% */"},{"Add":" {{1242,128}, {2415, 93}, {5155, 84}}, /* Q ==12 : 75-81% */"},{"Add":" {{1349,128}, {2644,106}, {5260,106}}, /* Q ==13 : 81-87% */"},{"Add":" {{1455,128}, {2422,124}, {4174,124}}, /* Q ==14 : 87-93% */"},{"Add":" {{ 722,128}, {1891,145}, {1936,146}}, /* Q ==15 : 93-99% */"},{"Add":"};"},{"Add":""},{"Add":"typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);"},{"Add":""},{"Add":"static size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" static const decompressionAlgo decompress[3] = { HUF_decompress4X2, HUF_decompress4X4, NULL };"},{"Add":" /* estimate decompression time */"},{"Add":" U32 Q;"},{"Add":" const U32 D256 = (U32)(dstSize >> 8);"},{"Add":" U32 Dtime[3];"},{"Add":" U32 algoNb = 0;"},{"Add":" int n;"},{"Add":""},{"Add":" /* validation checks */"},{"Add":" if (dstSize == 0) return ERROR(dstSize_tooSmall);"},{"Add":" if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */"},{"Add":" if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */"},{"Add":" if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */"},{"Add":""},{"Add":" /* decoder timing evaluation */"},{"Add":" Q = (U32)(cSrcSize * 16 / dstSize); /* Q < 16 since dstSize > cSrcSize */"},{"Add":" for (n=0; n<3; n++)"},{"Add":" Dtime[n] = algoTime[Q][n].tableTime + (algoTime[Q][n].decode256Time * D256);"},{"Add":""},{"Add":" Dtime[1] += Dtime[1] >> 4; Dtime[2] += Dtime[2] >> 3; /* advantage to algorithms using less memory, for cache eviction */"},{"Add":""},{"Add":" if (Dtime[1] < Dtime[0]) algoNb = 1;"},{"Add":""},{"Add":" return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);"},{"Add":""},{"Add":" //return HUF_decompress4X2(dst, dstSize, cSrc, cSrcSize); /* multi-streams single-symbol decoding */"},{"Add":" //return HUF_decompress4X4(dst, dstSize, cSrc, cSrcSize); /* multi-streams double-symbols decoding */"},{"Add":" //return HUF_decompress4X6(dst, dstSize, cSrc, cSrcSize); /* multi-streams quad-symbols decoding */"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"#endif /* ZSTD_CCOMMON_H_MODULE */"},{"Add":""},{"Add":""},{"Add":"/*"},{"Add":" zstd - decompression module fo v0.4 legacy format"},{"Add":" Copyright (C) 2015-2016, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - zstd source repository : https://github.com/Cyan4973/zstd"},{"Add":" - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"*/"},{"Add":""},{"Add":"/* ***************************************************************"},{"Add":"* Tuning parameters"},{"Add":"*****************************************************************/"},{"Add":"/*!"},{"Add":" * HEAPMODE :"},{"Add":" * Select how default decompression function ZSTD_decompress() will allocate memory,"},{"Add":" * in memory stack (0), or in memory heap (1, requires malloc())"},{"Add":" */"},{"Add":"#ifndef ZSTD_HEAPMODE"},{"Add":"# define ZSTD_HEAPMODE 1"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* *******************************************************"},{"Add":"* Includes"},{"Add":"*********************************************************/"},{"Add":"#include /* calloc */"},{"Add":"#include /* memcpy, memmove */"},{"Add":"#include /* debug : printf */"},{"Add":""},{"Add":""},{"Add":"/* *******************************************************"},{"Add":"* Compiler specifics"},{"Add":"*********************************************************/"},{"Add":"#ifdef _MSC_VER /* Visual Studio */"},{"Add":"# include /* For Visual 2005 */"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"# pragma warning(disable : 4324) /* disable: C4324: padded structure */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Local types"},{"Add":"***************************************/"},{"Add":"typedef struct"},{"Add":"{"},{"Add":" blockType_t blockType;"},{"Add":" U32 origSize;"},{"Add":"} blockProperties_t;"},{"Add":""},{"Add":""},{"Add":"/* *******************************************************"},{"Add":"* Memory operations"},{"Add":"**********************************************************/"},{"Add":"static void ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Error Management"},{"Add":"***************************************/"},{"Add":""},{"Add":"/*! ZSTD_isError"},{"Add":"* tells if a return value is an error code */"},{"Add":"static unsigned ZSTD_isError(size_t code) { return ERR_isError(code); }"},{"Add":""},{"Add":""},{"Add":"/* *************************************************************"},{"Add":"* Context management"},{"Add":"***************************************************************/"},{"Add":"typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,"},{"Add":" ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock } ZSTD_dStage;"},{"Add":""},{"Add":"struct ZSTDv04_Dctx_s"},{"Add":"{"},{"Add":" U32 LLTable[FSE_DTABLE_SIZE_U32(LLFSELog)];"},{"Add":" U32 OffTable[FSE_DTABLE_SIZE_U32(OffFSELog)];"},{"Add":" U32 MLTable[FSE_DTABLE_SIZE_U32(MLFSELog)];"},{"Add":" const void* previousDstEnd;"},{"Add":" const void* base;"},{"Add":" const void* vBase;"},{"Add":" const void* dictEnd;"},{"Add":" size_t expected;"},{"Add":" size_t headerSize;"},{"Add":" ZSTD_parameters params;"},{"Add":" blockType_t bType;"},{"Add":" ZSTD_dStage stage;"},{"Add":" const BYTE* litPtr;"},{"Add":" size_t litSize;"},{"Add":" BYTE litBuffer[BLOCKSIZE + 8 /* margin for wildcopy */];"},{"Add":" BYTE headerBuffer[ZSTD_frameHeaderSize_max];"},{"Add":"}; /* typedef'd to ZSTD_DCtx within \"zstd_static.h\" */"},{"Add":""},{"Add":"static size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx)"},{"Add":"{"},{"Add":" dctx->expected = ZSTD_frameHeaderSize_min;"},{"Add":" dctx->stage = ZSTDds_getFrameHeaderSize;"},{"Add":" dctx->previousDstEnd = NULL;"},{"Add":" dctx->base = NULL;"},{"Add":" dctx->vBase = NULL;"},{"Add":" dctx->dictEnd = NULL;"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"static ZSTD_DCtx* ZSTD_createDCtx(void)"},{"Add":"{"},{"Add":" ZSTD_DCtx* dctx = (ZSTD_DCtx*)malloc(sizeof(ZSTD_DCtx));"},{"Add":" if (dctx==NULL) return NULL;"},{"Add":" ZSTD_resetDCtx(dctx);"},{"Add":" return dctx;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)"},{"Add":"{"},{"Add":" free(dctx);"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/* *************************************************************"},{"Add":"* Decompression section"},{"Add":"***************************************************************/"},{"Add":"/** ZSTD_decodeFrameHeader_Part1"},{"Add":"* decode the 1st part of the Frame Header, which tells Frame Header size."},{"Add":"* srcSize must be == ZSTD_frameHeaderSize_min"},{"Add":"* @return : the full size of the Frame Header */"},{"Add":"static size_t ZSTD_decodeFrameHeader_Part1(ZSTD_DCtx* zc, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" U32 magicNumber;"},{"Add":" if (srcSize != ZSTD_frameHeaderSize_min) return ERROR(srcSize_wrong);"},{"Add":" magicNumber = MEM_readLE32(src);"},{"Add":" if (magicNumber != ZSTD_MAGICNUMBER) return ERROR(prefix_unknown);"},{"Add":" zc->headerSize = ZSTD_frameHeaderSize_min;"},{"Add":" return zc->headerSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTD_getFrameParams(ZSTD_parameters* params, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" U32 magicNumber;"},{"Add":" if (srcSize < ZSTD_frameHeaderSize_min) return ZSTD_frameHeaderSize_max;"},{"Add":" magicNumber = MEM_readLE32(src);"},{"Add":" if (magicNumber != ZSTD_MAGICNUMBER) return ERROR(prefix_unknown);"},{"Add":" memset(params, 0, sizeof(*params));"},{"Add":" params->windowLog = (((const BYTE*)src)[4] & 15) + ZSTD_WINDOWLOG_ABSOLUTEMIN;"},{"Add":" if ((((const BYTE*)src)[4] >> 4) != 0) return ERROR(frameParameter_unsupported); /* reserved bits */"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"/** ZSTD_decodeFrameHeader_Part2"},{"Add":"* decode the full Frame Header"},{"Add":"* srcSize must be the size provided by ZSTD_decodeFrameHeader_Part1"},{"Add":"* @return : 0, or an error code, which can be tested using ZSTD_isError() */"},{"Add":"static size_t ZSTD_decodeFrameHeader_Part2(ZSTD_DCtx* zc, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" size_t result;"},{"Add":" if (srcSize != zc->headerSize) return ERROR(srcSize_wrong);"},{"Add":" result = ZSTD_getFrameParams(&(zc->params), src, srcSize);"},{"Add":" if ((MEM_32bits()) && (zc->params.windowLog > 25)) return ERROR(frameParameter_unsupported);"},{"Add":" return result;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)"},{"Add":"{"},{"Add":" const BYTE* const in = (const BYTE* const)src;"},{"Add":" BYTE headerFlags;"},{"Add":" U32 cSize;"},{"Add":""},{"Add":" if (srcSize < 3) return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" headerFlags = *in;"},{"Add":" cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);"},{"Add":""},{"Add":" bpPtr->blockType = (blockType_t)(headerFlags >> 6);"},{"Add":" bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;"},{"Add":""},{"Add":" if (bpPtr->blockType == bt_end) return 0;"},{"Add":" if (bpPtr->blockType == bt_rle) return 1;"},{"Add":" return cSize;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZSTD_copyRawBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall);"},{"Add":" if (srcSize > 0) {"},{"Add":" memcpy(dst, src, srcSize);"},{"Add":" }"},{"Add":" return srcSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/** ZSTD_decompressLiterals"},{"Add":" @return : nb of bytes read from src, or an error code*/"},{"Add":"static size_t ZSTD_decompressLiterals(void* dst, size_t* maxDstSizePtr,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":""},{"Add":" const size_t litSize = (MEM_readLE32(src) & 0x1FFFFF) >> 2; /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */"},{"Add":" const size_t litCSize = (MEM_readLE32(ip+2) & 0xFFFFFF) >> 5; /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */"},{"Add":""},{"Add":" if (litSize > *maxDstSizePtr) return ERROR(corruption_detected);"},{"Add":" if (litCSize + 5 > srcSize) return ERROR(corruption_detected);"},{"Add":""},{"Add":" if (HUF_isError(HUF_decompress(dst, litSize, ip+5, litCSize))) return ERROR(corruption_detected);"},{"Add":""},{"Add":" *maxDstSizePtr = litSize;"},{"Add":" return litCSize + 5;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/** ZSTD_decodeLiteralsBlock"},{"Add":" @return : nb of bytes read from src (< srcSize ) */"},{"Add":"static size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,"},{"Add":" const void* src, size_t srcSize) /* note : srcSize < BLOCKSIZE */"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE*) src;"},{"Add":""},{"Add":" /* any compressed block with literals segment must be at least this size */"},{"Add":" if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);"},{"Add":""},{"Add":" switch(*istart & 3)"},{"Add":" {"},{"Add":" /* compressed */"},{"Add":" case 0:"},{"Add":" {"},{"Add":" size_t litSize = BLOCKSIZE;"},{"Add":" const size_t readSize = ZSTD_decompressLiterals(dctx->litBuffer, &litSize, src, srcSize);"},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" memset(dctx->litBuffer + dctx->litSize, 0, 8);"},{"Add":" return readSize; /* works if it's an error too */"},{"Add":" }"},{"Add":" case IS_RAW:"},{"Add":" {"},{"Add":" const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2; /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */"},{"Add":" if (litSize > srcSize-11) /* risk of reading too far with wildcopy */"},{"Add":" {"},{"Add":" if (litSize > BLOCKSIZE) return ERROR(corruption_detected);"},{"Add":" if (litSize > srcSize-3) return ERROR(corruption_detected);"},{"Add":" memcpy(dctx->litBuffer, istart, litSize);"},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" memset(dctx->litBuffer + dctx->litSize, 0, 8);"},{"Add":" return litSize+3;"},{"Add":" }"},{"Add":" /* direct reference into compressed stream */"},{"Add":" dctx->litPtr = istart+3;"},{"Add":" dctx->litSize = litSize;"},{"Add":" return litSize+3; }"},{"Add":" case IS_RLE:"},{"Add":" {"},{"Add":" const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2; /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */"},{"Add":" if (litSize > BLOCKSIZE) return ERROR(corruption_detected);"},{"Add":" memset(dctx->litBuffer, istart[3], litSize + 8);"},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" return 4;"},{"Add":" }"},{"Add":" default:"},{"Add":" return ERROR(corruption_detected); /* forbidden nominal case */"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr,"},{"Add":" FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE* const)src;"},{"Add":" const BYTE* ip = istart;"},{"Add":" const BYTE* const iend = istart + srcSize;"},{"Add":" U32 LLtype, Offtype, MLtype;"},{"Add":" U32 LLlog, Offlog, MLlog;"},{"Add":" size_t dumpsLength;"},{"Add":""},{"Add":" /* check */"},{"Add":" if (srcSize < 5) return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" /* SeqHead */"},{"Add":" *nbSeq = MEM_readLE16(ip); ip+=2;"},{"Add":" LLtype = *ip >> 6;"},{"Add":" Offtype = (*ip >> 4) & 3;"},{"Add":" MLtype = (*ip >> 2) & 3;"},{"Add":" if (*ip & 2)"},{"Add":" {"},{"Add":" dumpsLength = ip[2];"},{"Add":" dumpsLength += ip[1] << 8;"},{"Add":" ip += 3;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" dumpsLength = ip[1];"},{"Add":" dumpsLength += (ip[0] & 1) << 8;"},{"Add":" ip += 2;"},{"Add":" }"},{"Add":" *dumpsPtr = ip;"},{"Add":" ip += dumpsLength;"},{"Add":" *dumpsLengthPtr = dumpsLength;"},{"Add":""},{"Add":" /* check */"},{"Add":" if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are \"raw\", hence no header, but at least xxLog bits per type */"},{"Add":""},{"Add":" /* sequences */"},{"Add":" {"},{"Add":" S16 norm[MaxML+1]; /* assumption : MaxML >= MaxLL >= MaxOff */"},{"Add":" size_t headerSize;"},{"Add":""},{"Add":" /* Build DTables */"},{"Add":" switch(LLtype)"},{"Add":" {"},{"Add":" case bt_rle :"},{"Add":" LLlog = 0;"},{"Add":" FSE_buildDTable_rle(DTableLL, *ip++); break;"},{"Add":" case bt_raw :"},{"Add":" LLlog = LLbits;"},{"Add":" FSE_buildDTable_raw(DTableLL, LLbits); break;"},{"Add":" default :"},{"Add":" { U32 max = MaxLL;"},{"Add":" headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip);"},{"Add":" if (FSE_isError(headerSize)) return ERROR(GENERIC);"},{"Add":" if (LLlog > LLFSELog) return ERROR(corruption_detected);"},{"Add":" ip += headerSize;"},{"Add":" FSE_buildDTable(DTableLL, norm, max, LLlog);"},{"Add":" } }"},{"Add":""},{"Add":" switch(Offtype)"},{"Add":" {"},{"Add":" case bt_rle :"},{"Add":" Offlog = 0;"},{"Add":" if (ip > iend-2) return ERROR(srcSize_wrong); /* min : \"raw\", hence no header, but at least xxLog bits */"},{"Add":" FSE_buildDTable_rle(DTableOffb, *ip++ & MaxOff); /* if *ip > MaxOff, data is corrupted */"},{"Add":" break;"},{"Add":" case bt_raw :"},{"Add":" Offlog = Offbits;"},{"Add":" FSE_buildDTable_raw(DTableOffb, Offbits); break;"},{"Add":" default :"},{"Add":" { U32 max = MaxOff;"},{"Add":" headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip);"},{"Add":" if (FSE_isError(headerSize)) return ERROR(GENERIC);"},{"Add":" if (Offlog > OffFSELog) return ERROR(corruption_detected);"},{"Add":" ip += headerSize;"},{"Add":" FSE_buildDTable(DTableOffb, norm, max, Offlog);"},{"Add":" } }"},{"Add":""},{"Add":" switch(MLtype)"},{"Add":" {"},{"Add":" case bt_rle :"},{"Add":" MLlog = 0;"},{"Add":" if (ip > iend-2) return ERROR(srcSize_wrong); /* min : \"raw\", hence no header, but at least xxLog bits */"},{"Add":" FSE_buildDTable_rle(DTableML, *ip++); break;"},{"Add":" case bt_raw :"},{"Add":" MLlog = MLbits;"},{"Add":" FSE_buildDTable_raw(DTableML, MLbits); break;"},{"Add":" default :"},{"Add":" { U32 max = MaxML;"},{"Add":" headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip);"},{"Add":" if (FSE_isError(headerSize)) return ERROR(GENERIC);"},{"Add":" if (MLlog > MLFSELog) return ERROR(corruption_detected);"},{"Add":" ip += headerSize;"},{"Add":" FSE_buildDTable(DTableML, norm, max, MLlog);"},{"Add":" } } }"},{"Add":""},{"Add":" return ip-istart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"typedef struct {"},{"Add":" size_t litLength;"},{"Add":" size_t offset;"},{"Add":" size_t matchLength;"},{"Add":"} seq_t;"},{"Add":""},{"Add":"typedef struct {"},{"Add":" BIT_DStream_t DStream;"},{"Add":" FSE_DState_t stateLL;"},{"Add":" FSE_DState_t stateOffb;"},{"Add":" FSE_DState_t stateML;"},{"Add":" size_t prevOffset;"},{"Add":" const BYTE* dumps;"},{"Add":" const BYTE* dumpsEnd;"},{"Add":"} seqState_t;"},{"Add":""},{"Add":""},{"Add":"static void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState)"},{"Add":"{"},{"Add":" size_t litLength;"},{"Add":" size_t prevOffset;"},{"Add":" size_t offset;"},{"Add":" size_t matchLength;"},{"Add":" const BYTE* dumps = seqState->dumps;"},{"Add":" const BYTE* const de = seqState->dumpsEnd;"},{"Add":""},{"Add":" /* Literal length */"},{"Add":" litLength = FSE_decodeSymbol(&(seqState->stateLL), &(seqState->DStream));"},{"Add":" prevOffset = litLength ? seq->offset : seqState->prevOffset;"},{"Add":" if (litLength == MaxLL) {"},{"Add":" const U32 add = dumps= de) { dumps = de-1; } /* late correction, to avoid read overflow (data is now corrupted anyway) */"},{"Add":" }"},{"Add":""},{"Add":" /* Offset */"},{"Add":" { static const U32 offsetPrefix[MaxOff+1] = {"},{"Add":" 1 /*fake*/, 1, 2, 4, 8, 16, 32, 64, 128, 256,"},{"Add":" 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,"},{"Add":" 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, /*fake*/ 1, 1, 1, 1, 1 };"},{"Add":" U32 offsetCode, nbBits;"},{"Add":" offsetCode = FSE_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream)); /* <= maxOff, by table construction */"},{"Add":" if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));"},{"Add":" nbBits = offsetCode - 1;"},{"Add":" if (offsetCode==0) nbBits = 0; /* cmove */"},{"Add":" offset = offsetPrefix[offsetCode] + BIT_readBits(&(seqState->DStream), nbBits);"},{"Add":" if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));"},{"Add":" if (offsetCode==0) offset = prevOffset; /* cmove */"},{"Add":" if (offsetCode | !litLength) seqState->prevOffset = seq->offset; /* cmove */"},{"Add":" }"},{"Add":""},{"Add":" /* MatchLength */"},{"Add":" matchLength = FSE_decodeSymbol(&(seqState->stateML), &(seqState->DStream));"},{"Add":" if (matchLength == MaxML) {"},{"Add":" const U32 add = dumps= de) { dumps = de-1; } /* late correction, to avoid read overflow (data is now corrupted anyway) */"},{"Add":" }"},{"Add":" matchLength += MINMATCH;"},{"Add":""},{"Add":" /* save result */"},{"Add":" seq->litLength = litLength;"},{"Add":" seq->offset = offset;"},{"Add":" seq->matchLength = matchLength;"},{"Add":" seqState->dumps = dumps;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTD_execSequence(BYTE* op,"},{"Add":" BYTE* const oend, seq_t sequence,"},{"Add":" const BYTE** litPtr, const BYTE* const litLimit,"},{"Add":" const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)"},{"Add":"{"},{"Add":" static const int dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 }; /* added */"},{"Add":" static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 }; /* subtracted */"},{"Add":" BYTE* const oLitEnd = op + sequence.litLength;"},{"Add":" const size_t sequenceLength = sequence.litLength + sequence.matchLength;"},{"Add":" BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */"},{"Add":" BYTE* const oend_8 = oend-8;"},{"Add":" const BYTE* const litEnd = *litPtr + sequence.litLength;"},{"Add":" const BYTE* match = oLitEnd - sequence.offset;"},{"Add":""},{"Add":" /* check */"},{"Add":" if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of 8 from oend */"},{"Add":" if (oMatchEnd > oend) return ERROR(dstSize_tooSmall); /* overwrite beyond dst buffer */"},{"Add":" if (litEnd > litLimit) return ERROR(corruption_detected); /* risk read beyond lit buffer */"},{"Add":""},{"Add":" /* copy Literals */"},{"Add":" ZSTD_wildcopy(op, *litPtr, sequence.litLength); /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */"},{"Add":" op = oLitEnd;"},{"Add":" *litPtr = litEnd; /* update for next sequence */"},{"Add":""},{"Add":" /* copy Match */"},{"Add":" if (sequence.offset > (size_t)(oLitEnd - base))"},{"Add":" {"},{"Add":" /* offset beyond prefix */"},{"Add":" if (sequence.offset > (size_t)(oLitEnd - vBase))"},{"Add":" return ERROR(corruption_detected);"},{"Add":" match = dictEnd - (base-match);"},{"Add":" if (match + sequence.matchLength <= dictEnd)"},{"Add":" {"},{"Add":" memmove(oLitEnd, match, sequence.matchLength);"},{"Add":" return sequenceLength;"},{"Add":" }"},{"Add":" /* span extDict & currentPrefixSegment */"},{"Add":" {"},{"Add":" size_t length1 = dictEnd - match;"},{"Add":" memmove(oLitEnd, match, length1);"},{"Add":" op = oLitEnd + length1;"},{"Add":" sequence.matchLength -= length1;"},{"Add":" match = base;"},{"Add":" if (op > oend_8 || sequence.matchLength < MINMATCH) {"},{"Add":" while (op < oMatchEnd) *op++ = *match++;"},{"Add":" return sequenceLength;"},{"Add":" }"},{"Add":" }"},{"Add":" }"},{"Add":" /* Requirement: op <= oend_8 */"},{"Add":""},{"Add":" /* match within prefix */"},{"Add":" if (sequence.offset < 8) {"},{"Add":" /* close range match, overlap */"},{"Add":" const int sub2 = dec64table[sequence.offset];"},{"Add":" op[0] = match[0];"},{"Add":" op[1] = match[1];"},{"Add":" op[2] = match[2];"},{"Add":" op[3] = match[3];"},{"Add":" match += dec32table[sequence.offset];"},{"Add":" ZSTD_copy4(op+4, match);"},{"Add":" match -= sub2;"},{"Add":" } else {"},{"Add":" ZSTD_copy8(op, match);"},{"Add":" }"},{"Add":" op += 8; match += 8;"},{"Add":""},{"Add":" if (oMatchEnd > oend-(16-MINMATCH))"},{"Add":" {"},{"Add":" if (op < oend_8)"},{"Add":" {"},{"Add":" ZSTD_wildcopy(op, match, oend_8 - op);"},{"Add":" match += oend_8 - op;"},{"Add":" op = oend_8;"},{"Add":" }"},{"Add":" while (op < oMatchEnd) *op++ = *match++;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8); /* works even if matchLength < 8, but must be signed */"},{"Add":" }"},{"Add":" return sequenceLength;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTD_decompressSequences("},{"Add":" ZSTD_DCtx* dctx,"},{"Add":" void* dst, size_t maxDstSize,"},{"Add":" const void* seqStart, size_t seqSize)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)seqStart;"},{"Add":" const BYTE* const iend = ip + seqSize;"},{"Add":" BYTE* const ostart = (BYTE* const)dst;"},{"Add":" BYTE* op = ostart;"},{"Add":" BYTE* const oend = ostart + maxDstSize;"},{"Add":" size_t errorCode, dumpsLength;"},{"Add":" const BYTE* litPtr = dctx->litPtr;"},{"Add":" const BYTE* const litEnd = litPtr + dctx->litSize;"},{"Add":" int nbSeq;"},{"Add":" const BYTE* dumps;"},{"Add":" U32* DTableLL = dctx->LLTable;"},{"Add":" U32* DTableML = dctx->MLTable;"},{"Add":" U32* DTableOffb = dctx->OffTable;"},{"Add":" const BYTE* const base = (const BYTE*) (dctx->base);"},{"Add":" const BYTE* const vBase = (const BYTE*) (dctx->vBase);"},{"Add":" const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);"},{"Add":""},{"Add":" /* Build Decoding Tables */"},{"Add":" errorCode = ZSTD_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength,"},{"Add":" DTableLL, DTableML, DTableOffb,"},{"Add":" ip, iend-ip);"},{"Add":" if (ZSTD_isError(errorCode)) return errorCode;"},{"Add":" ip += errorCode;"},{"Add":""},{"Add":" /* Regen sequences */"},{"Add":" {"},{"Add":" seq_t sequence;"},{"Add":" seqState_t seqState;"},{"Add":""},{"Add":" memset(&sequence, 0, sizeof(sequence));"},{"Add":" sequence.offset = 4;"},{"Add":" seqState.dumps = dumps;"},{"Add":" seqState.dumpsEnd = dumps + dumpsLength;"},{"Add":" seqState.prevOffset = 4;"},{"Add":" errorCode = BIT_initDStream(&(seqState.DStream), ip, iend-ip);"},{"Add":" if (ERR_isError(errorCode)) return ERROR(corruption_detected);"},{"Add":" FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);"},{"Add":" FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);"},{"Add":" FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);"},{"Add":""},{"Add":" for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && nbSeq ; )"},{"Add":" {"},{"Add":" size_t oneSeqSize;"},{"Add":" nbSeq--;"},{"Add":" ZSTD_decodeSequence(&sequence, &seqState);"},{"Add":" oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litEnd, base, vBase, dictEnd);"},{"Add":" if (ZSTD_isError(oneSeqSize)) return oneSeqSize;"},{"Add":" op += oneSeqSize;"},{"Add":" }"},{"Add":""},{"Add":" /* check if reached exact end */"},{"Add":" if ( !BIT_endOfDStream(&(seqState.DStream)) ) return ERROR(corruption_detected); /* DStream should be entirely and exactly consumed; otherwise data is corrupted */"},{"Add":""},{"Add":" /* last literal segment */"},{"Add":" {"},{"Add":" size_t lastLLSize = litEnd - litPtr;"},{"Add":" if (litPtr > litEnd) return ERROR(corruption_detected);"},{"Add":" if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall);"},{"Add":" if (lastLLSize > 0) {"},{"Add":" if (op != litPtr) memcpy(op, litPtr, lastLLSize);"},{"Add":" op += lastLLSize;"},{"Add":" }"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" return op-ostart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst)"},{"Add":"{"},{"Add":" if (dst != dctx->previousDstEnd) /* not contiguous */"},{"Add":" {"},{"Add":" dctx->dictEnd = dctx->previousDstEnd;"},{"Add":" dctx->vBase = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));"},{"Add":" dctx->base = dst;"},{"Add":" dctx->previousDstEnd = dst;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,"},{"Add":" void* dst, size_t maxDstSize,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" /* blockType == blockCompressed */"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":" size_t litCSize;"},{"Add":""},{"Add":" if (srcSize > BLOCKSIZE) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* Decode literals sub-block */"},{"Add":" litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize);"},{"Add":" if (ZSTD_isError(litCSize)) return litCSize;"},{"Add":" ip += litCSize;"},{"Add":" srcSize -= litCSize;"},{"Add":""},{"Add":" return ZSTD_decompressSequences(dctx, dst, maxDstSize, ip, srcSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTD_decompress_usingDict(ZSTD_DCtx* ctx,"},{"Add":" void* dst, size_t maxDstSize,"},{"Add":" const void* src, size_t srcSize,"},{"Add":" const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":" const BYTE* iend = ip + srcSize;"},{"Add":" BYTE* const ostart = (BYTE* const)dst;"},{"Add":" BYTE* op = ostart;"},{"Add":" BYTE* const oend = ostart + maxDstSize;"},{"Add":" size_t remainingSize = srcSize;"},{"Add":" blockProperties_t blockProperties;"},{"Add":""},{"Add":" /* init */"},{"Add":" ZSTD_resetDCtx(ctx);"},{"Add":" if (dict)"},{"Add":" {"},{"Add":" ZSTD_decompress_insertDictionary(ctx, dict, dictSize);"},{"Add":" ctx->dictEnd = ctx->previousDstEnd;"},{"Add":" ctx->vBase = (const char*)dst - ((const char*)(ctx->previousDstEnd) - (const char*)(ctx->base));"},{"Add":" ctx->base = dst;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" ctx->vBase = ctx->base = ctx->dictEnd = dst;"},{"Add":" }"},{"Add":""},{"Add":" /* Frame Header */"},{"Add":" {"},{"Add":" size_t frameHeaderSize;"},{"Add":" if (srcSize < ZSTD_frameHeaderSize_min+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);"},{"Add":" frameHeaderSize = ZSTD_decodeFrameHeader_Part1(ctx, src, ZSTD_frameHeaderSize_min);"},{"Add":" if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize;"},{"Add":" if (srcSize < frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);"},{"Add":" ip += frameHeaderSize; remainingSize -= frameHeaderSize;"},{"Add":" frameHeaderSize = ZSTD_decodeFrameHeader_Part2(ctx, src, frameHeaderSize);"},{"Add":" if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize;"},{"Add":" }"},{"Add":""},{"Add":" /* Loop on each block */"},{"Add":" while (1)"},{"Add":" {"},{"Add":" size_t decodedSize=0;"},{"Add":" size_t cBlockSize = ZSTD_getcBlockSize(ip, iend-ip, &blockProperties);"},{"Add":" if (ZSTD_isError(cBlockSize)) return cBlockSize;"},{"Add":""},{"Add":" ip += ZSTD_blockHeaderSize;"},{"Add":" remainingSize -= ZSTD_blockHeaderSize;"},{"Add":" if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" switch(blockProperties.blockType)"},{"Add":" {"},{"Add":" case bt_compressed:"},{"Add":" decodedSize = ZSTD_decompressBlock_internal(ctx, op, oend-op, ip, cBlockSize);"},{"Add":" break;"},{"Add":" case bt_raw :"},{"Add":" decodedSize = ZSTD_copyRawBlock(op, oend-op, ip, cBlockSize);"},{"Add":" break;"},{"Add":" case bt_rle :"},{"Add":" return ERROR(GENERIC); /* not yet supported */"},{"Add":" break;"},{"Add":" case bt_end :"},{"Add":" /* end of frame */"},{"Add":" if (remainingSize) return ERROR(srcSize_wrong);"},{"Add":" break;"},{"Add":" default:"},{"Add":" return ERROR(GENERIC); /* impossible */"},{"Add":" }"},{"Add":" if (cBlockSize == 0) break; /* bt_end */"},{"Add":""},{"Add":" if (ZSTD_isError(decodedSize)) return decodedSize;"},{"Add":" op += decodedSize;"},{"Add":" ip += cBlockSize;"},{"Add":" remainingSize -= cBlockSize;"},{"Add":" }"},{"Add":""},{"Add":" return op-ostart;"},{"Add":"}"},{"Add":""},{"Add":"/* ZSTD_errorFrameSizeInfoLegacy() :"},{"Add":" assumes `cSize` and `dBound` are _not_ NULL */"},{"Add":"static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)"},{"Add":"{"},{"Add":" *cSize = ret;"},{"Add":" *dBound = ZSTD_CONTENTSIZE_ERROR;"},{"Add":"}"},{"Add":""},{"Add":"void ZSTDv04_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cSize, unsigned long long* dBound)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":" size_t remainingSize = srcSize;"},{"Add":" size_t nbBlocks = 0;"},{"Add":" blockProperties_t blockProperties;"},{"Add":""},{"Add":" /* Frame Header */"},{"Add":" if (srcSize < ZSTD_frameHeaderSize_min) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));"},{"Add":" return;"},{"Add":" }"},{"Add":" if (MEM_readLE32(src) != ZSTD_MAGICNUMBER) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(prefix_unknown));"},{"Add":" return;"},{"Add":" }"},{"Add":" ip += ZSTD_frameHeaderSize_min; remainingSize -= ZSTD_frameHeaderSize_min;"},{"Add":""},{"Add":" /* Loop on each block */"},{"Add":" while (1)"},{"Add":" {"},{"Add":" size_t cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties);"},{"Add":" if (ZSTD_isError(cBlockSize)) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, cBlockSize);"},{"Add":" return;"},{"Add":" }"},{"Add":""},{"Add":" ip += ZSTD_blockHeaderSize;"},{"Add":" remainingSize -= ZSTD_blockHeaderSize;"},{"Add":" if (cBlockSize > remainingSize) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));"},{"Add":" return;"},{"Add":" }"},{"Add":""},{"Add":" if (cBlockSize == 0) break; /* bt_end */"},{"Add":""},{"Add":" ip += cBlockSize;"},{"Add":" remainingSize -= cBlockSize;"},{"Add":" nbBlocks++;"},{"Add":" }"},{"Add":""},{"Add":" *cSize = ip - (const BYTE*)src;"},{"Add":" *dBound = nbBlocks * BLOCKSIZE;"},{"Add":"}"},{"Add":""},{"Add":"/* ******************************"},{"Add":"* Streaming Decompression API"},{"Add":"********************************/"},{"Add":"static size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx)"},{"Add":"{"},{"Add":" return dctx->expected;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZSTD_decompressContinue(ZSTD_DCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" /* Sanity check */"},{"Add":" if (srcSize != ctx->expected) return ERROR(srcSize_wrong);"},{"Add":" ZSTD_checkContinuity(ctx, dst);"},{"Add":""},{"Add":" /* Decompress : frame header; part 1 */"},{"Add":" switch (ctx->stage)"},{"Add":" {"},{"Add":" case ZSTDds_getFrameHeaderSize :"},{"Add":" /* get frame header size */"},{"Add":" if (srcSize != ZSTD_frameHeaderSize_min) return ERROR(srcSize_wrong); /* impossible */"},{"Add":" ctx->headerSize = ZSTD_decodeFrameHeader_Part1(ctx, src, ZSTD_frameHeaderSize_min);"},{"Add":" if (ZSTD_isError(ctx->headerSize)) return ctx->headerSize;"},{"Add":" memcpy(ctx->headerBuffer, src, ZSTD_frameHeaderSize_min);"},{"Add":" if (ctx->headerSize > ZSTD_frameHeaderSize_min) return ERROR(GENERIC); /* impossible */"},{"Add":" ctx->expected = 0; /* not necessary to copy more */"},{"Add":" /* fallthrough */"},{"Add":" case ZSTDds_decodeFrameHeader:"},{"Add":" /* get frame header */"},{"Add":" { size_t const result = ZSTD_decodeFrameHeader_Part2(ctx, ctx->headerBuffer, ctx->headerSize);"},{"Add":" if (ZSTD_isError(result)) return result;"},{"Add":" ctx->expected = ZSTD_blockHeaderSize;"},{"Add":" ctx->stage = ZSTDds_decodeBlockHeader;"},{"Add":" return 0;"},{"Add":" }"},{"Add":" case ZSTDds_decodeBlockHeader:"},{"Add":" /* Decode block header */"},{"Add":" { blockProperties_t bp;"},{"Add":" size_t const blockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);"},{"Add":" if (ZSTD_isError(blockSize)) return blockSize;"},{"Add":" if (bp.blockType == bt_end)"},{"Add":" {"},{"Add":" ctx->expected = 0;"},{"Add":" ctx->stage = ZSTDds_getFrameHeaderSize;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" ctx->expected = blockSize;"},{"Add":" ctx->bType = bp.blockType;"},{"Add":" ctx->stage = ZSTDds_decompressBlock;"},{"Add":" }"},{"Add":" return 0;"},{"Add":" }"},{"Add":" case ZSTDds_decompressBlock:"},{"Add":" {"},{"Add":" /* Decompress : block content */"},{"Add":" size_t rSize;"},{"Add":" switch(ctx->bType)"},{"Add":" {"},{"Add":" case bt_compressed:"},{"Add":" rSize = ZSTD_decompressBlock_internal(ctx, dst, maxDstSize, src, srcSize);"},{"Add":" break;"},{"Add":" case bt_raw :"},{"Add":" rSize = ZSTD_copyRawBlock(dst, maxDstSize, src, srcSize);"},{"Add":" break;"},{"Add":" case bt_rle :"},{"Add":" return ERROR(GENERIC); /* not yet handled */"},{"Add":" break;"},{"Add":" case bt_end : /* should never happen (filtered at phase 1) */"},{"Add":" rSize = 0;"},{"Add":" break;"},{"Add":" default:"},{"Add":" return ERROR(GENERIC);"},{"Add":" }"},{"Add":" ctx->stage = ZSTDds_decodeBlockHeader;"},{"Add":" ctx->expected = ZSTD_blockHeaderSize;"},{"Add":" ctx->previousDstEnd = (char*)dst + rSize;"},{"Add":" return rSize;"},{"Add":" }"},{"Add":" default:"},{"Add":" return ERROR(GENERIC); /* impossible */"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static void ZSTD_decompress_insertDictionary(ZSTD_DCtx* ctx, const void* dict, size_t dictSize)"},{"Add":"{"},{"Add":" ctx->dictEnd = ctx->previousDstEnd;"},{"Add":" ctx->vBase = (const char*)dict - ((const char*)(ctx->previousDstEnd) - (const char*)(ctx->base));"},{"Add":" ctx->base = dict;"},{"Add":" ctx->previousDstEnd = (const char*)dict + dictSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*"},{"Add":" Buffered version of Zstd compression library"},{"Add":" Copyright (C) 2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - zstd source repository : https://github.com/Cyan4973/zstd"},{"Add":" - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"*/"},{"Add":""},{"Add":"/* The objects defined into this file should be considered experimental."},{"Add":" * They are not labelled stable, as their prototype may change in the future."},{"Add":" * You can use them for tests, provide feedback, or if you can endure risk of future changes."},{"Add":" */"},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Includes"},{"Add":"***************************************/"},{"Add":"#include "},{"Add":""},{"Add":""},{"Add":"/** ************************************************"},{"Add":"* Streaming decompression"},{"Add":"*"},{"Add":"* A ZBUFF_DCtx object is required to track streaming operation."},{"Add":"* Use ZBUFF_createDCtx() and ZBUFF_freeDCtx() to create/release resources."},{"Add":"* Use ZBUFF_decompressInit() to start a new decompression operation."},{"Add":"* ZBUFF_DCtx objects can be reused multiple times."},{"Add":"*"},{"Add":"* Use ZBUFF_decompressContinue() repetitively to consume your input."},{"Add":"* *srcSizePtr and *maxDstSizePtr can be any size."},{"Add":"* The function will report how many bytes were read or written by modifying *srcSizePtr and *maxDstSizePtr."},{"Add":"* Note that it may not consume the entire input, in which case it's up to the caller to call again the function with remaining input."},{"Add":"* The content of dst will be overwritten (up to *maxDstSizePtr) at each function call, so save its content if it matters or change dst ."},{"Add":"* return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency)"},{"Add":"* or 0 when a frame is completely decoded"},{"Add":"* or an error code, which can be tested using ZBUFF_isError()."},{"Add":"*"},{"Add":"* Hint : recommended buffer sizes (not compulsory)"},{"Add":"* output : 128 KB block size is the internal unit, it ensures it's always possible to write a full block when it's decoded."},{"Add":"* input : just follow indications from ZBUFF_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 ."},{"Add":"* **************************************************/"},{"Add":""},{"Add":"typedef enum { ZBUFFds_init, ZBUFFds_readHeader, ZBUFFds_loadHeader, ZBUFFds_decodeHeader,"},{"Add":" ZBUFFds_read, ZBUFFds_load, ZBUFFds_flush } ZBUFF_dStage;"},{"Add":""},{"Add":"/* *** Resource management *** */"},{"Add":""},{"Add":"#define ZSTD_frameHeaderSize_max 5 /* too magical, should come from reference */"},{"Add":"struct ZBUFFv04_DCtx_s {"},{"Add":" ZSTD_DCtx* zc;"},{"Add":" ZSTD_parameters params;"},{"Add":" char* inBuff;"},{"Add":" size_t inBuffSize;"},{"Add":" size_t inPos;"},{"Add":" char* outBuff;"},{"Add":" size_t outBuffSize;"},{"Add":" size_t outStart;"},{"Add":" size_t outEnd;"},{"Add":" size_t hPos;"},{"Add":" const char* dict;"},{"Add":" size_t dictSize;"},{"Add":" ZBUFF_dStage stage;"},{"Add":" unsigned char headerBuffer[ZSTD_frameHeaderSize_max];"},{"Add":"}; /* typedef'd to ZBUFF_DCtx within \"zstd_buffered.h\" */"},{"Add":""},{"Add":"typedef ZBUFFv04_DCtx ZBUFF_DCtx;"},{"Add":""},{"Add":""},{"Add":"static ZBUFF_DCtx* ZBUFF_createDCtx(void)"},{"Add":"{"},{"Add":" ZBUFF_DCtx* zbc = (ZBUFF_DCtx*)malloc(sizeof(ZBUFF_DCtx));"},{"Add":" if (zbc==NULL) return NULL;"},{"Add":" memset(zbc, 0, sizeof(*zbc));"},{"Add":" zbc->zc = ZSTD_createDCtx();"},{"Add":" zbc->stage = ZBUFFds_init;"},{"Add":" return zbc;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZBUFF_freeDCtx(ZBUFF_DCtx* zbc)"},{"Add":"{"},{"Add":" if (zbc==NULL) return 0; /* support free on null */"},{"Add":" ZSTD_freeDCtx(zbc->zc);"},{"Add":" free(zbc->inBuff);"},{"Add":" free(zbc->outBuff);"},{"Add":" free(zbc);"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/* *** Initialization *** */"},{"Add":""},{"Add":"static size_t ZBUFF_decompressInit(ZBUFF_DCtx* zbc)"},{"Add":"{"},{"Add":" zbc->stage = ZBUFFds_readHeader;"},{"Add":" zbc->hPos = zbc->inPos = zbc->outStart = zbc->outEnd = zbc->dictSize = 0;"},{"Add":" return ZSTD_resetDCtx(zbc->zc);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZBUFF_decompressWithDictionary(ZBUFF_DCtx* zbc, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" zbc->dict = (const char*)src;"},{"Add":" zbc->dictSize = srcSize;"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZBUFF_limitCopy(void* dst, size_t maxDstSize, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" size_t length = MIN(maxDstSize, srcSize);"},{"Add":" if (length > 0) {"},{"Add":" memcpy(dst, src, length);"},{"Add":" }"},{"Add":" return length;"},{"Add":"}"},{"Add":""},{"Add":"/* *** Decompression *** */"},{"Add":""},{"Add":"static size_t ZBUFF_decompressContinue(ZBUFF_DCtx* zbc, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr)"},{"Add":"{"},{"Add":" const char* const istart = (const char*)src;"},{"Add":" const char* ip = istart;"},{"Add":" const char* const iend = istart + *srcSizePtr;"},{"Add":" char* const ostart = (char*)dst;"},{"Add":" char* op = ostart;"},{"Add":" char* const oend = ostart + *maxDstSizePtr;"},{"Add":" U32 notDone = 1;"},{"Add":""},{"Add":" DEBUGLOG(5, \"ZBUFF_decompressContinue\");"},{"Add":" while (notDone)"},{"Add":" {"},{"Add":" switch(zbc->stage)"},{"Add":" {"},{"Add":""},{"Add":" case ZBUFFds_init :"},{"Add":" DEBUGLOG(5, \"ZBUFF_decompressContinue: stage==ZBUFFds_init => ERROR(init_missing)\");"},{"Add":" return ERROR(init_missing);"},{"Add":""},{"Add":" case ZBUFFds_readHeader :"},{"Add":" /* read header from src */"},{"Add":" { size_t const headerSize = ZSTD_getFrameParams(&(zbc->params), src, *srcSizePtr);"},{"Add":" if (ZSTD_isError(headerSize)) return headerSize;"},{"Add":" if (headerSize) {"},{"Add":" /* not enough input to decode header : tell how many bytes would be necessary */"},{"Add":" memcpy(zbc->headerBuffer+zbc->hPos, src, *srcSizePtr);"},{"Add":" zbc->hPos += *srcSizePtr;"},{"Add":" *maxDstSizePtr = 0;"},{"Add":" zbc->stage = ZBUFFds_loadHeader;"},{"Add":" return headerSize - zbc->hPos;"},{"Add":" }"},{"Add":" zbc->stage = ZBUFFds_decodeHeader;"},{"Add":" break;"},{"Add":" }"},{"Add":""},{"Add":" case ZBUFFds_loadHeader:"},{"Add":" /* complete header from src */"},{"Add":" { size_t headerSize = ZBUFF_limitCopy("},{"Add":" zbc->headerBuffer + zbc->hPos, ZSTD_frameHeaderSize_max - zbc->hPos,"},{"Add":" src, *srcSizePtr);"},{"Add":" zbc->hPos += headerSize;"},{"Add":" ip += headerSize;"},{"Add":" headerSize = ZSTD_getFrameParams(&(zbc->params), zbc->headerBuffer, zbc->hPos);"},{"Add":" if (ZSTD_isError(headerSize)) return headerSize;"},{"Add":" if (headerSize) {"},{"Add":" /* not enough input to decode header : tell how many bytes would be necessary */"},{"Add":" *maxDstSizePtr = 0;"},{"Add":" return headerSize - zbc->hPos;"},{"Add":" } }"},{"Add":" /* intentional fallthrough */"},{"Add":""},{"Add":" case ZBUFFds_decodeHeader:"},{"Add":" /* apply header to create / resize buffers */"},{"Add":" { size_t const neededOutSize = (size_t)1 << zbc->params.windowLog;"},{"Add":" size_t const neededInSize = BLOCKSIZE; /* a block is never > BLOCKSIZE */"},{"Add":" if (zbc->inBuffSize < neededInSize) {"},{"Add":" free(zbc->inBuff);"},{"Add":" zbc->inBuffSize = neededInSize;"},{"Add":" zbc->inBuff = (char*)malloc(neededInSize);"},{"Add":" if (zbc->inBuff == NULL) return ERROR(memory_allocation);"},{"Add":" }"},{"Add":" if (zbc->outBuffSize < neededOutSize) {"},{"Add":" free(zbc->outBuff);"},{"Add":" zbc->outBuffSize = neededOutSize;"},{"Add":" zbc->outBuff = (char*)malloc(neededOutSize);"},{"Add":" if (zbc->outBuff == NULL) return ERROR(memory_allocation);"},{"Add":" } }"},{"Add":" if (zbc->dictSize)"},{"Add":" ZSTD_decompress_insertDictionary(zbc->zc, zbc->dict, zbc->dictSize);"},{"Add":" if (zbc->hPos) {"},{"Add":" /* some data already loaded into headerBuffer : transfer into inBuff */"},{"Add":" memcpy(zbc->inBuff, zbc->headerBuffer, zbc->hPos);"},{"Add":" zbc->inPos = zbc->hPos;"},{"Add":" zbc->hPos = 0;"},{"Add":" zbc->stage = ZBUFFds_load;"},{"Add":" break;"},{"Add":" }"},{"Add":" zbc->stage = ZBUFFds_read;"},{"Add":"\t\t/* fall-through */"},{"Add":" case ZBUFFds_read:"},{"Add":" {"},{"Add":" size_t neededInSize = ZSTD_nextSrcSizeToDecompress(zbc->zc);"},{"Add":" if (neededInSize==0) /* end of frame */"},{"Add":" {"},{"Add":" zbc->stage = ZBUFFds_init;"},{"Add":" notDone = 0;"},{"Add":" break;"},{"Add":" }"},{"Add":" if ((size_t)(iend-ip) >= neededInSize)"},{"Add":" {"},{"Add":" /* directly decode from src */"},{"Add":" size_t decodedSize = ZSTD_decompressContinue(zbc->zc,"},{"Add":" zbc->outBuff + zbc->outStart, zbc->outBuffSize - zbc->outStart,"},{"Add":" ip, neededInSize);"},{"Add":" if (ZSTD_isError(decodedSize)) return decodedSize;"},{"Add":" ip += neededInSize;"},{"Add":" if (!decodedSize) break; /* this was just a header */"},{"Add":" zbc->outEnd = zbc->outStart + decodedSize;"},{"Add":" zbc->stage = ZBUFFds_flush;"},{"Add":" break;"},{"Add":" }"},{"Add":" if (ip==iend) { notDone = 0; break; } /* no more input */"},{"Add":" zbc->stage = ZBUFFds_load;"},{"Add":" }"},{"Add":"\t /* fall-through */"},{"Add":" case ZBUFFds_load:"},{"Add":" {"},{"Add":" size_t neededInSize = ZSTD_nextSrcSizeToDecompress(zbc->zc);"},{"Add":" size_t toLoad = neededInSize - zbc->inPos; /* should always be <= remaining space within inBuff */"},{"Add":" size_t loadedSize;"},{"Add":" if (toLoad > zbc->inBuffSize - zbc->inPos) return ERROR(corruption_detected); /* should never happen */"},{"Add":" loadedSize = ZBUFF_limitCopy(zbc->inBuff + zbc->inPos, toLoad, ip, iend-ip);"},{"Add":" ip += loadedSize;"},{"Add":" zbc->inPos += loadedSize;"},{"Add":" if (loadedSize < toLoad) { notDone = 0; break; } /* not enough input, wait for more */"},{"Add":" {"},{"Add":" size_t decodedSize = ZSTD_decompressContinue(zbc->zc,"},{"Add":" zbc->outBuff + zbc->outStart, zbc->outBuffSize - zbc->outStart,"},{"Add":" zbc->inBuff, neededInSize);"},{"Add":" if (ZSTD_isError(decodedSize)) return decodedSize;"},{"Add":" zbc->inPos = 0; /* input is consumed */"},{"Add":" if (!decodedSize) { zbc->stage = ZBUFFds_read; break; } /* this was just a header */"},{"Add":" zbc->outEnd = zbc->outStart + decodedSize;"},{"Add":" zbc->stage = ZBUFFds_flush;"},{"Add":" /* ZBUFFds_flush follows */"},{"Add":" }"},{"Add":" }"},{"Add":"\t /* fall-through */"},{"Add":" case ZBUFFds_flush:"},{"Add":" {"},{"Add":" size_t toFlushSize = zbc->outEnd - zbc->outStart;"},{"Add":" size_t flushedSize = ZBUFF_limitCopy(op, oend-op, zbc->outBuff + zbc->outStart, toFlushSize);"},{"Add":" op += flushedSize;"},{"Add":" zbc->outStart += flushedSize;"},{"Add":" if (flushedSize == toFlushSize)"},{"Add":" {"},{"Add":" zbc->stage = ZBUFFds_read;"},{"Add":" if (zbc->outStart + BLOCKSIZE > zbc->outBuffSize)"},{"Add":" zbc->outStart = zbc->outEnd = 0;"},{"Add":" break;"},{"Add":" }"},{"Add":" /* cannot flush everything */"},{"Add":" notDone = 0;"},{"Add":" break;"},{"Add":" }"},{"Add":" default: return ERROR(GENERIC); /* impossible */"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" *srcSizePtr = ip-istart;"},{"Add":" *maxDstSizePtr = op-ostart;"},{"Add":""},{"Add":" {"},{"Add":" size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zbc->zc);"},{"Add":" if (nextSrcSizeHint > 3) nextSrcSizeHint+= 3; /* get the next block header while at it */"},{"Add":" nextSrcSizeHint -= zbc->inPos; /* already loaded*/"},{"Add":" return nextSrcSizeHint;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Tool functions"},{"Add":"***************************************/"},{"Add":"unsigned ZBUFFv04_isError(size_t errorCode) { return ERR_isError(errorCode); }"},{"Add":"const char* ZBUFFv04_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }"},{"Add":""},{"Add":"size_t ZBUFFv04_recommendedDInSize() { return BLOCKSIZE + 3; }"},{"Add":"size_t ZBUFFv04_recommendedDOutSize() { return BLOCKSIZE; }"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*- ========================================================================= -*/"},{"Add":""},{"Add":"/* final wrapping stage */"},{"Add":""},{"Add":"size_t ZSTDv04_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" return ZSTD_decompress_usingDict(dctx, dst, maxDstSize, src, srcSize, NULL, 0);"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTDv04_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":"#if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE==1)"},{"Add":" size_t regenSize;"},{"Add":" ZSTD_DCtx* dctx = ZSTD_createDCtx();"},{"Add":" if (dctx==NULL) return ERROR(memory_allocation);"},{"Add":" regenSize = ZSTDv04_decompressDCtx(dctx, dst, maxDstSize, src, srcSize);"},{"Add":" ZSTD_freeDCtx(dctx);"},{"Add":" return regenSize;"},{"Add":"#else"},{"Add":" ZSTD_DCtx dctx;"},{"Add":" return ZSTDv04_decompressDCtx(&dctx, dst, maxDstSize, src, srcSize);"},{"Add":"#endif"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTDv04_resetDCtx(ZSTDv04_Dctx* dctx) { return ZSTD_resetDCtx(dctx); }"},{"Add":""},{"Add":"size_t ZSTDv04_nextSrcSizeToDecompress(ZSTDv04_Dctx* dctx)"},{"Add":"{"},{"Add":" return ZSTD_nextSrcSizeToDecompress(dctx);"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTDv04_decompressContinue(ZSTDv04_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" return ZSTD_decompressContinue(dctx, dst, maxDstSize, src, srcSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"ZBUFFv04_DCtx* ZBUFFv04_createDCtx(void) { return ZBUFF_createDCtx(); }"},{"Add":"size_t ZBUFFv04_freeDCtx(ZBUFFv04_DCtx* dctx) { return ZBUFF_freeDCtx(dctx); }"},{"Add":""},{"Add":"size_t ZBUFFv04_decompressInit(ZBUFFv04_DCtx* dctx) { return ZBUFF_decompressInit(dctx); }"},{"Add":"size_t ZBUFFv04_decompressWithDictionary(ZBUFFv04_DCtx* dctx, const void* src, size_t srcSize)"},{"Add":"{ return ZBUFF_decompressWithDictionary(dctx, src, srcSize); }"},{"Add":""},{"Add":"size_t ZBUFFv04_decompressContinue(ZBUFFv04_DCtx* dctx, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr)"},{"Add":"{"},{"Add":" DEBUGLOG(5, \"ZBUFFv04_decompressContinue\");"},{"Add":" return ZBUFF_decompressContinue(dctx, dst, maxDstSizePtr, src, srcSizePtr);"},{"Add":"}"},{"Add":""},{"Add":"ZSTD_DCtx* ZSTDv04_createDCtx(void) { return ZSTD_createDCtx(); }"},{"Add":"size_t ZSTDv04_freeDCtx(ZSTD_DCtx* dctx) { return ZSTD_freeDCtx(dctx); }"}]}},{"FileAdd":{"meta":{"basename":"zstd_v03.h","metadata":0},"context":[{"change":0,"pos":140938}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) 2016-2021, Yann Collet, Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":""},{"Add":"#ifndef ZSTD_V03_H_298734209782"},{"Add":"#define ZSTD_V03_H_298734209782"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Includes"},{"Add":"***************************************/"},{"Add":"#include /* size_t */"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Simple one-step function"},{"Add":"***************************************/"},{"Add":"/**"},{"Add":"ZSTDv03_decompress() : decompress ZSTD frames compliant with v0.3.x format"},{"Add":" compressedSize : is the exact source size"},{"Add":" maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated."},{"Add":" It must be equal or larger than originalSize, otherwise decompression will fail."},{"Add":" return : the number of bytes decompressed into destination buffer (originalSize)"},{"Add":" or an errorCode if it fails (which can be tested using ZSTDv01_isError())"},{"Add":"*/"},{"Add":"size_t ZSTDv03_decompress( void* dst, size_t maxOriginalSize,"},{"Add":" const void* src, size_t compressedSize);"},{"Add":""},{"Add":" /**"},{"Add":" ZSTDv03_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.3.x format"},{"Add":" srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'"},{"Add":" cSize (output parameter) : the number of bytes that would be read to decompress this frame"},{"Add":" or an error code if it fails (which can be tested using ZSTDv01_isError())"},{"Add":" dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame"},{"Add":" or ZSTD_CONTENTSIZE_ERROR if an error occurs"},{"Add":""},{"Add":" note : assumes `cSize` and `dBound` are _not_ NULL."},{"Add":" */"},{"Add":" void ZSTDv03_findFrameSizeInfoLegacy(const void *src, size_t srcSize,"},{"Add":" size_t* cSize, unsigned long long* dBound);"},{"Add":""},{"Add":" /**"},{"Add":"ZSTDv03_isError() : tells if the result of ZSTDv03_decompress() is an error"},{"Add":"*/"},{"Add":"unsigned ZSTDv03_isError(size_t code);"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Advanced functions"},{"Add":"***************************************/"},{"Add":"typedef struct ZSTDv03_Dctx_s ZSTDv03_Dctx;"},{"Add":"ZSTDv03_Dctx* ZSTDv03_createDCtx(void);"},{"Add":"size_t ZSTDv03_freeDCtx(ZSTDv03_Dctx* dctx);"},{"Add":""},{"Add":"size_t ZSTDv03_decompressDCtx(void* ctx,"},{"Add":" void* dst, size_t maxOriginalSize,"},{"Add":" const void* src, size_t compressedSize);"},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Streaming functions"},{"Add":"***************************************/"},{"Add":"size_t ZSTDv03_resetDCtx(ZSTDv03_Dctx* dctx);"},{"Add":""},{"Add":"size_t ZSTDv03_nextSrcSizeToDecompress(ZSTDv03_Dctx* dctx);"},{"Add":"size_t ZSTDv03_decompressContinue(ZSTDv03_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);"},{"Add":"/**"},{"Add":" Use above functions alternatively."},{"Add":" ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue()."},{"Add":" ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block."},{"Add":" Result is the number of bytes regenerated within 'dst'."},{"Add":" It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header."},{"Add":"*/"},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Prefix - version detection"},{"Add":"***************************************/"},{"Add":"#define ZSTDv03_magicNumber 0xFD2FB523 /* v0.3 */"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* ZSTD_V03_H_298734209782 */"}]}},{"FileAdd":{"meta":{"basename":"zstd_v03.c","metadata":0},"context":[{"change":0,"pos":140938}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) 2016-2021, Yann Collet, Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":""},{"Add":""},{"Add":"#include /* size_t, ptrdiff_t */"},{"Add":"#include \"zstd_v03.h\""},{"Add":"#include \"../common/error_private.h\""},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* Compiler-specific"},{"Add":"******************************************/"},{"Add":"#if defined(_MSC_VER) /* Visual Studio */"},{"Add":"# include /* _byteswap_ulong */"},{"Add":"# include /* _byteswap_* */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/* ******************************************************************"},{"Add":" mem.h"},{"Add":" low-level memory access routines"},{"Add":" Copyright (C) 2013-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":"#ifndef MEM_H_MODULE"},{"Add":"#define MEM_H_MODULE"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"/******************************************"},{"Add":"* Includes"},{"Add":"******************************************/"},{"Add":"#include /* size_t, ptrdiff_t */"},{"Add":"#include /* memcpy */"},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* Compiler-specific"},{"Add":"******************************************/"},{"Add":"#if defined(__GNUC__)"},{"Add":"# define MEM_STATIC static __attribute__((unused))"},{"Add":"#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)"},{"Add":"# define MEM_STATIC static inline"},{"Add":"#elif defined(_MSC_VER)"},{"Add":"# define MEM_STATIC static __inline"},{"Add":"#else"},{"Add":"# define MEM_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Basic Types"},{"Add":"*****************************************************************/"},{"Add":"#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)"},{"Add":"# if defined(_AIX)"},{"Add":"# include "},{"Add":"# else"},{"Add":"# include /* intptr_t */"},{"Add":"# endif"},{"Add":" typedef uint8_t BYTE;"},{"Add":" typedef uint16_t U16;"},{"Add":" typedef int16_t S16;"},{"Add":" typedef uint32_t U32;"},{"Add":" typedef int32_t S32;"},{"Add":" typedef uint64_t U64;"},{"Add":" typedef int64_t S64;"},{"Add":"#else"},{"Add":" typedef unsigned char BYTE;"},{"Add":" typedef unsigned short U16;"},{"Add":" typedef signed short S16;"},{"Add":" typedef unsigned int U32;"},{"Add":" typedef signed int S32;"},{"Add":" typedef unsigned long long U64;"},{"Add":" typedef signed long long S64;"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Memory I/O"},{"Add":"*****************************************************************/"},{"Add":"/* MEM_FORCE_MEMORY_ACCESS"},{"Add":" * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable."},{"Add":" * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal."},{"Add":" * The below switch allow to select different access method for improved performance."},{"Add":" * Method 0 (default) : use `memcpy()`. Safe and portable."},{"Add":" * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable)."},{"Add":" * This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`."},{"Add":" * Method 2 : direct access. This method is portable but violate C standard."},{"Add":" * It can generate buggy code on targets generating assembly depending on alignment."},{"Add":" * But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)"},{"Add":" * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details."},{"Add":" * Prefer these methods in priority order (0 > 1 > 2)"},{"Add":" */"},{"Add":"#ifndef MEM_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */"},{"Add":"# if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )"},{"Add":"# define MEM_FORCE_MEMORY_ACCESS 2"},{"Add":"# elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \\"},{"Add":" (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))"},{"Add":"# define MEM_FORCE_MEMORY_ACCESS 1"},{"Add":"# endif"},{"Add":"#endif"},{"Add":""},{"Add":"MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; }"},{"Add":"MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; }"},{"Add":""},{"Add":"MEM_STATIC unsigned MEM_isLittleEndian(void)"},{"Add":"{"},{"Add":" const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */"},{"Add":" return one.c[0];"},{"Add":"}"},{"Add":""},{"Add":"#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)"},{"Add":""},{"Add":"/* violates C standard on structure alignment."},{"Add":"Only use if no other choice to achieve best performance on target platform */"},{"Add":"MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }"},{"Add":"MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }"},{"Add":"MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }"},{"Add":""},{"Add":"#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)"},{"Add":""},{"Add":"/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */"},{"Add":"/* currently only defined for gcc and icc */"},{"Add":"typedef union { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign;"},{"Add":""},{"Add":"MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }"},{"Add":"MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }"},{"Add":"MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }"},{"Add":""},{"Add":"#else"},{"Add":""},{"Add":"/* default method, safe and standard."},{"Add":" can sometimes prove slower */"},{"Add":""},{"Add":"MEM_STATIC U16 MEM_read16(const void* memPtr)"},{"Add":"{"},{"Add":" U16 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_read32(const void* memPtr)"},{"Add":"{"},{"Add":" U32 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U64 MEM_read64(const void* memPtr)"},{"Add":"{"},{"Add":" U64 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value)"},{"Add":"{"},{"Add":" memcpy(memPtr, &value, sizeof(value));"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"#endif /* MEM_FORCE_MEMORY_ACCESS */"},{"Add":""},{"Add":""},{"Add":"MEM_STATIC U16 MEM_readLE16(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read16(memPtr);"},{"Add":" else"},{"Add":" {"},{"Add":" const BYTE* p = (const BYTE*)memPtr;"},{"Add":" return (U16)(p[0] + (p[1]<<8));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" {"},{"Add":" MEM_write16(memPtr, val);"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" BYTE* p = (BYTE*)memPtr;"},{"Add":" p[0] = (BYTE)val;"},{"Add":" p[1] = (BYTE)(val>>8);"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_readLE24(const void* memPtr)"},{"Add":"{"},{"Add":" return MEM_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_readLE32(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read32(memPtr);"},{"Add":" else"},{"Add":" {"},{"Add":" const BYTE* p = (const BYTE*)memPtr;"},{"Add":" return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U64 MEM_readLE64(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read64(memPtr);"},{"Add":" else"},{"Add":" {"},{"Add":" const BYTE* p = (const BYTE*)memPtr;"},{"Add":" return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)"},{"Add":" + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"MEM_STATIC size_t MEM_readLEST(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_32bits())"},{"Add":" return (size_t)MEM_readLE32(memPtr);"},{"Add":" else"},{"Add":" return (size_t)MEM_readLE64(memPtr);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* MEM_H_MODULE */"},{"Add":""},{"Add":""},{"Add":"/* ******************************************************************"},{"Add":" bitstream"},{"Add":" Part of NewGen Entropy library"},{"Add":" header file (to include)"},{"Add":" Copyright (C) 2013-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":"#ifndef BITSTREAM_H_MODULE"},{"Add":"#define BITSTREAM_H_MODULE"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*"},{"Add":"* This API consists of small unitary functions, which highly benefit from being inlined."},{"Add":"* Since link-time-optimization is not available for all compilers,"},{"Add":"* these functions are defined into a .h to be included."},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/**********************************************"},{"Add":"* bitStream decompression API (read backward)"},{"Add":"**********************************************/"},{"Add":"typedef struct"},{"Add":"{"},{"Add":" size_t bitContainer;"},{"Add":" unsigned bitsConsumed;"},{"Add":" const char* ptr;"},{"Add":" const char* start;"},{"Add":"} BIT_DStream_t;"},{"Add":""},{"Add":"typedef enum { BIT_DStream_unfinished = 0,"},{"Add":" BIT_DStream_endOfBuffer = 1,"},{"Add":" BIT_DStream_completed = 2,"},{"Add":" BIT_DStream_overflow = 3 } BIT_DStream_status; /* result of BIT_reloadDStream() */"},{"Add":" /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */"},{"Add":""},{"Add":"MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);"},{"Add":"MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);"},{"Add":"MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);"},{"Add":"MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* unsafe API"},{"Add":"******************************************/"},{"Add":"MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);"},{"Add":"/* faster, but works only if nbBits >= 1 */"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Helper functions"},{"Add":"****************************************************************/"},{"Add":"MEM_STATIC unsigned BIT_highbit32 (U32 val)"},{"Add":"{"},{"Add":"# if defined(_MSC_VER) /* Visual */"},{"Add":" unsigned long r=0;"},{"Add":" _BitScanReverse ( &r, val );"},{"Add":" return (unsigned) r;"},{"Add":"# elif defined(__GNUC__) && (__GNUC__ >= 3) /* Use GCC Intrinsic */"},{"Add":" return __builtin_clz (val) ^ 31;"},{"Add":"# else /* Software version */"},{"Add":" static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };"},{"Add":" U32 v = val;"},{"Add":" unsigned r;"},{"Add":" v |= v >> 1;"},{"Add":" v |= v >> 2;"},{"Add":" v |= v >> 4;"},{"Add":" v |= v >> 8;"},{"Add":" v |= v >> 16;"},{"Add":" r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];"},{"Add":" return r;"},{"Add":"# endif"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/**********************************************************"},{"Add":"* bitStream decoding"},{"Add":"**********************************************************/"},{"Add":""},{"Add":"/*!BIT_initDStream"},{"Add":"* Initialize a BIT_DStream_t."},{"Add":"* @bitD : a pointer to an already allocated BIT_DStream_t structure"},{"Add":"* @srcBuffer must point at the beginning of a bitStream"},{"Add":"* @srcSize must be the exact size of the bitStream"},{"Add":"* @result : size of stream (== srcSize) or an errorCode if a problem is detected"},{"Add":"*/"},{"Add":"MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)"},{"Add":"{"},{"Add":" if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }"},{"Add":""},{"Add":" if (srcSize >= sizeof(size_t)) /* normal case */"},{"Add":" {"},{"Add":" U32 contain32;"},{"Add":" bitD->start = (const char*)srcBuffer;"},{"Add":" bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(size_t);"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr);"},{"Add":" contain32 = ((const BYTE*)srcBuffer)[srcSize-1];"},{"Add":" if (contain32 == 0) return ERROR(GENERIC); /* endMark not present */"},{"Add":" bitD->bitsConsumed = 8 - BIT_highbit32(contain32);"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" U32 contain32;"},{"Add":" bitD->start = (const char*)srcBuffer;"},{"Add":" bitD->ptr = bitD->start;"},{"Add":" bitD->bitContainer = *(const BYTE*)(bitD->start);"},{"Add":" switch(srcSize)"},{"Add":" {"},{"Add":" case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16);"},{"Add":" /* fallthrough */"},{"Add":" case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);"},{"Add":" /* fallthrough */"},{"Add":" case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);"},{"Add":" /* fallthrough */"},{"Add":" case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24;"},{"Add":" /* fallthrough */"},{"Add":" case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16;"},{"Add":" /* fallthrough */"},{"Add":" case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) << 8;"},{"Add":" /* fallthrough */"},{"Add":" default:;"},{"Add":" }"},{"Add":" contain32 = ((const BYTE*)srcBuffer)[srcSize-1];"},{"Add":" if (contain32 == 0) return ERROR(GENERIC); /* endMark not present */"},{"Add":" bitD->bitsConsumed = 8 - BIT_highbit32(contain32);"},{"Add":" bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8;"},{"Add":" }"},{"Add":""},{"Add":" return srcSize;"},{"Add":"}"},{"Add":"MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;"},{"Add":" return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);"},{"Add":"}"},{"Add":""},{"Add":"/*! BIT_lookBitsFast :"},{"Add":"* unsafe version; only works only if nbBits >= 1 */"},{"Add":"MEM_STATIC size_t BIT_lookBitsFast(BIT_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;"},{"Add":" return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" bitD->bitsConsumed += nbBits;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" size_t value = BIT_lookBits(bitD, nbBits);"},{"Add":" BIT_skipBits(bitD, nbBits);"},{"Add":" return value;"},{"Add":"}"},{"Add":""},{"Add":"/*!BIT_readBitsFast :"},{"Add":"* unsafe version; only works only if nbBits >= 1 */"},{"Add":"MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" size_t value = BIT_lookBitsFast(bitD, nbBits);"},{"Add":" BIT_skipBits(bitD, nbBits);"},{"Add":" return value;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)"},{"Add":"{"},{"Add":" if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* should never happen */"},{"Add":" return BIT_DStream_overflow;"},{"Add":""},{"Add":" if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer))"},{"Add":" {"},{"Add":" bitD->ptr -= bitD->bitsConsumed >> 3;"},{"Add":" bitD->bitsConsumed &= 7;"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr);"},{"Add":" return BIT_DStream_unfinished;"},{"Add":" }"},{"Add":" if (bitD->ptr == bitD->start)"},{"Add":" {"},{"Add":" if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;"},{"Add":" return BIT_DStream_completed;"},{"Add":" }"},{"Add":" {"},{"Add":" U32 nbBytes = bitD->bitsConsumed >> 3;"},{"Add":" BIT_DStream_status result = BIT_DStream_unfinished;"},{"Add":" if (bitD->ptr - nbBytes < bitD->start)"},{"Add":" {"},{"Add":" nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */"},{"Add":" result = BIT_DStream_endOfBuffer;"},{"Add":" }"},{"Add":" bitD->ptr -= nbBytes;"},{"Add":" bitD->bitsConsumed -= nbBytes*8;"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD) */"},{"Add":" return result;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"/*! BIT_endOfDStream"},{"Add":"* @return Tells if DStream has reached its exact end"},{"Add":"*/"},{"Add":"MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)"},{"Add":"{"},{"Add":" return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));"},{"Add":"}"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* BITSTREAM_H_MODULE */"},{"Add":"/* ******************************************************************"},{"Add":" Error codes and messages"},{"Add":" Copyright (C) 2013-2015, Yann Collet"},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":"#ifndef ERROR_H_MODULE"},{"Add":"#define ERROR_H_MODULE"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* Compiler-specific"},{"Add":"******************************************/"},{"Add":"#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)"},{"Add":"# define ERR_STATIC static inline"},{"Add":"#elif defined(_MSC_VER)"},{"Add":"# define ERR_STATIC static __inline"},{"Add":"#elif defined(__GNUC__)"},{"Add":"# define ERR_STATIC static __attribute__((unused))"},{"Add":"#else"},{"Add":"# define ERR_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* Error Management"},{"Add":"******************************************/"},{"Add":"#define PREFIX(name) ZSTD_error_##name"},{"Add":""},{"Add":"#define ERROR(name) (size_t)-PREFIX(name)"},{"Add":""},{"Add":"#define ERROR_LIST(ITEM) \\"},{"Add":" ITEM(PREFIX(No_Error)) ITEM(PREFIX(GENERIC)) \\"},{"Add":" ITEM(PREFIX(dstSize_tooSmall)) ITEM(PREFIX(srcSize_wrong)) \\"},{"Add":" ITEM(PREFIX(prefix_unknown)) ITEM(PREFIX(corruption_detected)) \\"},{"Add":" ITEM(PREFIX(tableLog_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooSmall)) \\"},{"Add":" ITEM(PREFIX(maxCode))"},{"Add":""},{"Add":"#define ERROR_GENERATE_ENUM(ENUM) ENUM,"},{"Add":"typedef enum { ERROR_LIST(ERROR_GENERATE_ENUM) } ERR_codes; /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */"},{"Add":""},{"Add":"#define ERROR_CONVERTTOSTRING(STRING) #STRING,"},{"Add":"#define ERROR_GENERATE_STRING(EXPR) ERROR_CONVERTTOSTRING(EXPR)"},{"Add":"static const char* ERR_strings[] = { ERROR_LIST(ERROR_GENERATE_STRING) };"},{"Add":""},{"Add":"ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }"},{"Add":""},{"Add":"ERR_STATIC const char* ERR_getErrorName(size_t code)"},{"Add":"{"},{"Add":" static const char* codeError = \"Unspecified error code\";"},{"Add":" if (ERR_isError(code)) return ERR_strings[-(int)(code)];"},{"Add":" return codeError;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* ERROR_H_MODULE */"},{"Add":"/*"},{"Add":"Constructor and Destructor of type FSE_CTable"},{"Add":" Note that its size depends on 'tableLog' and 'maxSymbolValue' */"},{"Add":"typedef unsigned FSE_CTable; /* don't allocate that. It's just a way to be more restrictive than void* */"},{"Add":"typedef unsigned FSE_DTable; /* don't allocate that. It's just a way to be more restrictive than void* */"},{"Add":""},{"Add":""},{"Add":"/* ******************************************************************"},{"Add":" FSE : Finite State Entropy coder"},{"Add":" header file for static linking (only)"},{"Add":" Copyright (C) 2013-2015, Yann Collet"},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* Static allocation"},{"Add":"******************************************/"},{"Add":"/* FSE buffer bounds */"},{"Add":"#define FSE_NCOUNTBOUND 512"},{"Add":"#define FSE_BLOCKBOUND(size) (size + (size>>7))"},{"Add":"#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size)) /* Macro version, useful for static allocation */"},{"Add":""},{"Add":"/* You can statically allocate FSE CTable/DTable as a table of unsigned using below macro */"},{"Add":"#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2))"},{"Add":"#define FSE_DTABLE_SIZE_U32(maxTableLog) (1 + (1<= 1 (otherwise, result will be corrupted) */"},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* Implementation of inline functions"},{"Add":"******************************************/"},{"Add":""},{"Add":"/* decompression */"},{"Add":""},{"Add":"typedef struct {"},{"Add":" U16 tableLog;"},{"Add":" U16 fastMode;"},{"Add":"} FSE_DTableHeader; /* sizeof U32 */"},{"Add":""},{"Add":"typedef struct"},{"Add":"{"},{"Add":" unsigned short newState;"},{"Add":" unsigned char symbol;"},{"Add":" unsigned char nbBits;"},{"Add":"} FSE_decode_t; /* size == U32 */"},{"Add":""},{"Add":"MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)"},{"Add":"{"},{"Add":" FSE_DTableHeader DTableH;"},{"Add":" memcpy(&DTableH, dt, sizeof(DTableH));"},{"Add":" DStatePtr->state = BIT_readBits(bitD, DTableH.tableLog);"},{"Add":" BIT_reloadDStream(bitD);"},{"Add":" DStatePtr->table = dt + 1;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)"},{"Add":"{"},{"Add":" const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];"},{"Add":" const U32 nbBits = DInfo.nbBits;"},{"Add":" BYTE symbol = DInfo.symbol;"},{"Add":" size_t lowBits = BIT_readBits(bitD, nbBits);"},{"Add":""},{"Add":" DStatePtr->state = DInfo.newState + lowBits;"},{"Add":" return symbol;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)"},{"Add":"{"},{"Add":" const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];"},{"Add":" const U32 nbBits = DInfo.nbBits;"},{"Add":" BYTE symbol = DInfo.symbol;"},{"Add":" size_t lowBits = BIT_readBitsFast(bitD, nbBits);"},{"Add":""},{"Add":" DStatePtr->state = DInfo.newState + lowBits;"},{"Add":" return symbol;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)"},{"Add":"{"},{"Add":" return DStatePtr->state == 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":"/* ******************************************************************"},{"Add":" Huff0 : Huffman coder, part of New Generation Entropy library"},{"Add":" header file for static linking (only)"},{"Add":" Copyright (C) 2013-2015, Yann Collet"},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"/******************************************"},{"Add":"* Static allocation macros"},{"Add":"******************************************/"},{"Add":"/* Huff0 buffer bounds */"},{"Add":"#define HUF_CTABLEBOUND 129"},{"Add":"#define HUF_BLOCKBOUND(size) (size + (size>>8) + 8) /* only true if incompressible pre-filtered with fast heuristic */"},{"Add":"#define HUF_COMPRESSBOUND(size) (HUF_CTABLEBOUND + HUF_BLOCKBOUND(size)) /* Macro version, useful for static allocation */"},{"Add":""},{"Add":"/* static allocation of Huff0's DTable */"},{"Add":"#define HUF_DTABLE_SIZE(maxTableLog) (1 + (1< /* size_t */"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Version"},{"Add":"***************************************/"},{"Add":"#define ZSTD_VERSION_MAJOR 0 /* for breaking interface changes */"},{"Add":"#define ZSTD_VERSION_MINOR 2 /* for new (non-breaking) interface capabilities */"},{"Add":"#define ZSTD_VERSION_RELEASE 2 /* for tweaks, bug-fixes, or development */"},{"Add":"#define ZSTD_VERSION_NUMBER (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Advanced functions"},{"Add":"***************************************/"},{"Add":"typedef struct ZSTD_CCtx_s ZSTD_CCtx; /* incomplete type */"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":"/*"},{"Add":" zstd - standard compression library"},{"Add":" Header File for static linking only"},{"Add":" Copyright (C) 2014-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - zstd source repository : https://github.com/Cyan4973/zstd"},{"Add":" - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"*/"},{"Add":""},{"Add":"/* The objects defined into this file should be considered experimental."},{"Add":" * They are not labelled stable, as their prototype may change in the future."},{"Add":" * You can use them for tests, provide feedback, or if you can endure risk of future changes."},{"Add":" */"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Streaming functions"},{"Add":"***************************************/"},{"Add":""},{"Add":"typedef struct ZSTD_DCtx_s ZSTD_DCtx;"},{"Add":""},{"Add":"/*"},{"Add":" Use above functions alternatively."},{"Add":" ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue()."},{"Add":" ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block."},{"Add":" Result is the number of bytes regenerated within 'dst'."},{"Add":" It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header."},{"Add":"*/"},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Prefix - version detection"},{"Add":"***************************************/"},{"Add":"#define ZSTD_magicNumber 0xFD2FB523 /* v0.3 */"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":"/* ******************************************************************"},{"Add":" FSE : Finite State Entropy coder"},{"Add":" Copyright (C) 2013-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":""},{"Add":"#ifndef FSE_COMMONDEFS_ONLY"},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Tuning parameters"},{"Add":"****************************************************************/"},{"Add":"/* MEMORY_USAGE :"},{"Add":"* Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)"},{"Add":"* Increasing memory usage improves compression ratio"},{"Add":"* Reduced memory usage can improve speed, due to cache effect"},{"Add":"* Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */"},{"Add":"#define FSE_MAX_MEMORY_USAGE 14"},{"Add":"#define FSE_DEFAULT_MEMORY_USAGE 13"},{"Add":""},{"Add":"/* FSE_MAX_SYMBOL_VALUE :"},{"Add":"* Maximum symbol value authorized."},{"Add":"* Required for proper stack allocation */"},{"Add":"#define FSE_MAX_SYMBOL_VALUE 255"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* template functions type & suffix"},{"Add":"****************************************************************/"},{"Add":"#define FSE_FUNCTION_TYPE BYTE"},{"Add":"#define FSE_FUNCTION_EXTENSION"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Byte symbol type"},{"Add":"****************************************************************/"},{"Add":"#endif /* !FSE_COMMONDEFS_ONLY */"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Compiler specifics"},{"Add":"****************************************************************/"},{"Add":"#ifdef _MSC_VER /* Visual Studio */"},{"Add":"# define FORCE_INLINE static __forceinline"},{"Add":"# include /* For Visual 2005 */"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"# pragma warning(disable : 4214) /* disable: C4214: non-int bitfields */"},{"Add":"#else"},{"Add":"# if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */"},{"Add":"# ifdef __GNUC__"},{"Add":"# define FORCE_INLINE static inline __attribute__((always_inline))"},{"Add":"# else"},{"Add":"# define FORCE_INLINE static inline"},{"Add":"# endif"},{"Add":"# else"},{"Add":"# define FORCE_INLINE static"},{"Add":"# endif /* __STDC_VERSION__ */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Includes"},{"Add":"****************************************************************/"},{"Add":"#include /* malloc, free, qsort */"},{"Add":"#include /* memcpy, memset */"},{"Add":"#include /* printf (debug) */"},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Constants"},{"Add":"*****************************************************************/"},{"Add":"#define FSE_MAX_TABLELOG (FSE_MAX_MEMORY_USAGE-2)"},{"Add":"#define FSE_MAX_TABLESIZE (1U< FSE_TABLELOG_ABSOLUTE_MAX"},{"Add":"#error \"FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported\""},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Error Management"},{"Add":"****************************************************************/"},{"Add":"#define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Complex types"},{"Add":"****************************************************************/"},{"Add":"typedef U32 DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Templates"},{"Add":"****************************************************************/"},{"Add":"/*"},{"Add":" designed to be included"},{"Add":" for type-specific functions (template emulation in C)"},{"Add":" Objective is to write these functions only once, for improved maintenance"},{"Add":"*/"},{"Add":""},{"Add":"/* safety checks */"},{"Add":"#ifndef FSE_FUNCTION_EXTENSION"},{"Add":"# error \"FSE_FUNCTION_EXTENSION must be defined\""},{"Add":"#endif"},{"Add":"#ifndef FSE_FUNCTION_TYPE"},{"Add":"# error \"FSE_FUNCTION_TYPE must be defined\""},{"Add":"#endif"},{"Add":""},{"Add":"/* Function names */"},{"Add":"#define FSE_CAT(X,Y) X##Y"},{"Add":"#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)"},{"Add":"#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)"},{"Add":""},{"Add":""},{"Add":"/* Function templates */"},{"Add":""},{"Add":"#define FSE_DECODE_TYPE FSE_decode_t"},{"Add":""},{"Add":"static U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; }"},{"Add":""},{"Add":"static size_t FSE_buildDTable"},{"Add":"(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)"},{"Add":"{"},{"Add":" void* ptr = dt+1;"},{"Add":" FSE_DTableHeader DTableH;"},{"Add":" FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*)ptr;"},{"Add":" const U32 tableSize = 1 << tableLog;"},{"Add":" const U32 tableMask = tableSize-1;"},{"Add":" const U32 step = FSE_tableStep(tableSize);"},{"Add":" U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1];"},{"Add":" U32 position = 0;"},{"Add":" U32 highThreshold = tableSize-1;"},{"Add":" const S16 largeLimit= (S16)(1 << (tableLog-1));"},{"Add":" U32 noLarge = 1;"},{"Add":" U32 s;"},{"Add":""},{"Add":" /* Sanity Checks */"},{"Add":" if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);"},{"Add":" if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);"},{"Add":""},{"Add":" /* Init, lay down lowprob symbols */"},{"Add":" DTableH.tableLog = (U16)tableLog;"},{"Add":" for (s=0; s<=maxSymbolValue; s++)"},{"Add":" {"},{"Add":" if (normalizedCounter[s]==-1)"},{"Add":" {"},{"Add":" tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;"},{"Add":" symbolNext[s] = 1;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" if (normalizedCounter[s] >= largeLimit) noLarge=0;"},{"Add":" symbolNext[s] = normalizedCounter[s];"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" /* Spread symbols */"},{"Add":" for (s=0; s<=maxSymbolValue; s++)"},{"Add":" {"},{"Add":" int i;"},{"Add":" for (i=0; i highThreshold) position = (position + step) & tableMask; /* lowprob area */"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" if (position!=0) return ERROR(GENERIC); /* position must reach all cells once, otherwise normalizedCounter is incorrect */"},{"Add":""},{"Add":" /* Build Decoding table */"},{"Add":" {"},{"Add":" U32 i;"},{"Add":" for (i=0; i FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);"},{"Add":" bitStream >>= 4;"},{"Add":" bitCount = 4;"},{"Add":" *tableLogPtr = nbBits;"},{"Add":" remaining = (1<1) && (charnum<=*maxSVPtr))"},{"Add":" {"},{"Add":" if (previous0)"},{"Add":" {"},{"Add":" unsigned n0 = charnum;"},{"Add":" while ((bitStream & 0xFFFF) == 0xFFFF)"},{"Add":" {"},{"Add":" n0+=24;"},{"Add":" if (ip < iend-5)"},{"Add":" {"},{"Add":" ip+=2;"},{"Add":" bitStream = MEM_readLE32(ip) >> bitCount;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" bitStream >>= 16;"},{"Add":" bitCount+=16;"},{"Add":" }"},{"Add":" }"},{"Add":" while ((bitStream & 3) == 3)"},{"Add":" {"},{"Add":" n0+=3;"},{"Add":" bitStream>>=2;"},{"Add":" bitCount+=2;"},{"Add":" }"},{"Add":" n0 += bitStream & 3;"},{"Add":" bitCount += 2;"},{"Add":" if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);"},{"Add":" while (charnum < n0) normalizedCounter[charnum++] = 0;"},{"Add":" if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))"},{"Add":" {"},{"Add":" ip += bitCount>>3;"},{"Add":" bitCount &= 7;"},{"Add":" bitStream = MEM_readLE32(ip) >> bitCount;"},{"Add":" }"},{"Add":" else"},{"Add":" bitStream >>= 2;"},{"Add":" }"},{"Add":" {"},{"Add":" const short max = (short)((2*threshold-1)-remaining);"},{"Add":" short count;"},{"Add":""},{"Add":" if ((bitStream & (threshold-1)) < (U32)max)"},{"Add":" {"},{"Add":" count = (short)(bitStream & (threshold-1));"},{"Add":" bitCount += nbBits-1;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" count = (short)(bitStream & (2*threshold-1));"},{"Add":" if (count >= threshold) count -= max;"},{"Add":" bitCount += nbBits;"},{"Add":" }"},{"Add":""},{"Add":" count--; /* extra accuracy */"},{"Add":" remaining -= FSE_abs(count);"},{"Add":" normalizedCounter[charnum++] = count;"},{"Add":" previous0 = !count;"},{"Add":" while (remaining < threshold)"},{"Add":" {"},{"Add":" nbBits--;"},{"Add":" threshold >>= 1;"},{"Add":" }"},{"Add":""},{"Add":" {"},{"Add":" if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))"},{"Add":" {"},{"Add":" ip += bitCount>>3;"},{"Add":" bitCount &= 7;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" bitCount -= (int)(8 * (iend - 4 - ip));"},{"Add":" ip = iend - 4;"},{"Add":" }"},{"Add":" bitStream = MEM_readLE32(ip) >> (bitCount & 31);"},{"Add":" }"},{"Add":" }"},{"Add":" }"},{"Add":" if (remaining != 1) return ERROR(GENERIC);"},{"Add":" *maxSVPtr = charnum-1;"},{"Add":""},{"Add":" ip += (bitCount+7)>>3;"},{"Add":" if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong);"},{"Add":" return ip-istart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*********************************************************"},{"Add":"* Decompression (Byte symbols)"},{"Add":"*********************************************************/"},{"Add":"static size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)"},{"Add":"{"},{"Add":" void* ptr = dt;"},{"Add":" FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;"},{"Add":" FSE_decode_t* const cell = (FSE_decode_t*)(ptr) + 1;"},{"Add":""},{"Add":" DTableH->tableLog = 0;"},{"Add":" DTableH->fastMode = 0;"},{"Add":""},{"Add":" cell->newState = 0;"},{"Add":" cell->symbol = symbolValue;"},{"Add":" cell->nbBits = 0;"},{"Add":""},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)"},{"Add":"{"},{"Add":" void* ptr = dt;"},{"Add":" FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;"},{"Add":" FSE_decode_t* const dinfo = (FSE_decode_t*)(ptr) + 1;"},{"Add":" const unsigned tableSize = 1 << nbBits;"},{"Add":" const unsigned tableMask = tableSize - 1;"},{"Add":" const unsigned maxSymbolValue = tableMask;"},{"Add":" unsigned s;"},{"Add":""},{"Add":" /* Sanity checks */"},{"Add":" if (nbBits < 1) return ERROR(GENERIC); /* min size */"},{"Add":""},{"Add":" /* Build Decoding Table */"},{"Add":" DTableH->tableLog = (U16)nbBits;"},{"Add":" DTableH->fastMode = 1;"},{"Add":" for (s=0; s<=maxSymbolValue; s++)"},{"Add":" {"},{"Add":" dinfo[s].newState = 0;"},{"Add":" dinfo[s].symbol = (BYTE)s;"},{"Add":" dinfo[s].nbBits = (BYTE)nbBits;"},{"Add":" }"},{"Add":""},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"FORCE_INLINE size_t FSE_decompress_usingDTable_generic("},{"Add":" void* dst, size_t maxDstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const FSE_DTable* dt, const unsigned fast)"},{"Add":"{"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* op = ostart;"},{"Add":" BYTE* const omax = op + maxDstSize;"},{"Add":" BYTE* const olimit = omax-3;"},{"Add":""},{"Add":" BIT_DStream_t bitD;"},{"Add":" FSE_DState_t state1;"},{"Add":" FSE_DState_t state2;"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" /* Init */"},{"Add":" errorCode = BIT_initDStream(&bitD, cSrc, cSrcSize); /* replaced last arg by maxCompressed Size */"},{"Add":" if (FSE_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" FSE_initDState(&state1, &bitD, dt);"},{"Add":" FSE_initDState(&state2, &bitD, dt);"},{"Add":""},{"Add":"#define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD)"},{"Add":""},{"Add":" /* 4 symbols per loop */"},{"Add":" for ( ; (BIT_reloadDStream(&bitD)==BIT_DStream_unfinished) && (op sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" BIT_reloadDStream(&bitD);"},{"Add":""},{"Add":" op[1] = FSE_GETSYMBOL(&state2);"},{"Add":""},{"Add":" if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" { if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } }"},{"Add":""},{"Add":" op[2] = FSE_GETSYMBOL(&state1);"},{"Add":""},{"Add":" if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" BIT_reloadDStream(&bitD);"},{"Add":""},{"Add":" op[3] = FSE_GETSYMBOL(&state2);"},{"Add":" }"},{"Add":""},{"Add":" /* tail */"},{"Add":" /* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */"},{"Add":" while (1)"},{"Add":" {"},{"Add":" if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) )"},{"Add":" break;"},{"Add":""},{"Add":" *op++ = FSE_GETSYMBOL(&state1);"},{"Add":""},{"Add":" if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) )"},{"Add":" break;"},{"Add":""},{"Add":" *op++ = FSE_GETSYMBOL(&state2);"},{"Add":" }"},{"Add":""},{"Add":" /* end ? */"},{"Add":" if (BIT_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2))"},{"Add":" return op-ostart;"},{"Add":""},{"Add":" if (op==omax) return ERROR(dstSize_tooSmall); /* dst buffer is full, but cSrc unfinished */"},{"Add":""},{"Add":" return ERROR(corruption_detected);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const FSE_DTable* dt)"},{"Add":"{"},{"Add":" FSE_DTableHeader DTableH;"},{"Add":" memcpy(&DTableH, dt, sizeof(DTableH));"},{"Add":""},{"Add":" /* select fast mode (static) */"},{"Add":" if (DTableH.fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);"},{"Add":" return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t FSE_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE*)cSrc;"},{"Add":" const BYTE* ip = istart;"},{"Add":" short counting[FSE_MAX_SYMBOL_VALUE+1];"},{"Add":" DTable_max_t dt; /* Static analyzer seems unable to understand this table will be properly initialized later */"},{"Add":" unsigned tableLog;"},{"Add":" unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" if (cSrcSize<2) return ERROR(srcSize_wrong); /* too small input size */"},{"Add":""},{"Add":" /* normal FSE decoding mode */"},{"Add":" errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);"},{"Add":" if (FSE_isError(errorCode)) return errorCode;"},{"Add":" if (errorCode >= cSrcSize) return ERROR(srcSize_wrong); /* too small input size */"},{"Add":" ip += errorCode;"},{"Add":" cSrcSize -= errorCode;"},{"Add":""},{"Add":" errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog);"},{"Add":" if (FSE_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" /* always return, even if it is an error code */"},{"Add":" return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"#endif /* FSE_COMMONDEFS_ONLY */"},{"Add":"/* ******************************************************************"},{"Add":" Huff0 : Huffman coder, part of New Generation Entropy library"},{"Add":" Copyright (C) 2013-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - FSE+Huff0 source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Compiler specifics"},{"Add":"****************************************************************/"},{"Add":"#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)"},{"Add":"/* inline is defined */"},{"Add":"#elif defined(_MSC_VER)"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"# define inline __inline"},{"Add":"#else"},{"Add":"# define inline /* disable inline */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Includes"},{"Add":"****************************************************************/"},{"Add":"#include /* malloc, free, qsort */"},{"Add":"#include /* memcpy, memset */"},{"Add":"#include /* printf (debug) */"},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Error Management"},{"Add":"****************************************************************/"},{"Add":"#define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */"},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* Helper functions"},{"Add":"******************************************/"},{"Add":"static unsigned HUF_isError(size_t code) { return ERR_isError(code); }"},{"Add":""},{"Add":"#define HUF_ABSOLUTEMAX_TABLELOG 16 /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */"},{"Add":"#define HUF_MAX_TABLELOG 12 /* max configured tableLog (for static allocation); can be modified up to HUF_ABSOLUTEMAX_TABLELOG */"},{"Add":"#define HUF_DEFAULT_TABLELOG HUF_MAX_TABLELOG /* tableLog by default, when not specified */"},{"Add":"#define HUF_MAX_SYMBOL_VALUE 255"},{"Add":"#if (HUF_MAX_TABLELOG > HUF_ABSOLUTEMAX_TABLELOG)"},{"Add":"# error \"HUF_MAX_TABLELOG is too large !\""},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*********************************************************"},{"Add":"* Huff0 : Huffman block decompression"},{"Add":"*********************************************************/"},{"Add":"typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX2; /* single-symbol decoding */"},{"Add":""},{"Add":"typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX4; /* double-symbols decoding */"},{"Add":""},{"Add":"typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;"},{"Add":""},{"Add":"/*! HUF_readStats"},{"Add":" Read compact Huffman tree, saved by HUF_writeCTable"},{"Add":" @huffWeight : destination buffer"},{"Add":" @return : size read from `src`"},{"Add":"*/"},{"Add":"static size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,"},{"Add":" U32* nbSymbolsPtr, U32* tableLogPtr,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" U32 weightTotal;"},{"Add":" U32 tableLog;"},{"Add":" const BYTE* ip = (const BYTE*) src;"},{"Add":" size_t iSize;"},{"Add":" size_t oSize;"},{"Add":" U32 n;"},{"Add":""},{"Add":" if (!srcSize) return ERROR(srcSize_wrong);"},{"Add":" iSize = ip[0];"},{"Add":" //memset(huffWeight, 0, hwSize); /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" if (iSize >= 128) /* special header */"},{"Add":" {"},{"Add":" if (iSize >= (242)) /* RLE */"},{"Add":" {"},{"Add":" static int l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };"},{"Add":" oSize = l[iSize-242];"},{"Add":" memset(huffWeight, 1, hwSize);"},{"Add":" iSize = 0;"},{"Add":" }"},{"Add":" else /* Incompressible */"},{"Add":" {"},{"Add":" oSize = iSize - 127;"},{"Add":" iSize = ((oSize+1)/2);"},{"Add":" if (iSize+1 > srcSize) return ERROR(srcSize_wrong);"},{"Add":" if (oSize >= hwSize) return ERROR(corruption_detected);"},{"Add":" ip += 1;"},{"Add":" for (n=0; n> 4;"},{"Add":" huffWeight[n+1] = ip[n/2] & 15;"},{"Add":" }"},{"Add":" }"},{"Add":" }"},{"Add":" else /* header compressed with FSE (normal case) */"},{"Add":" {"},{"Add":" if (iSize+1 > srcSize) return ERROR(srcSize_wrong);"},{"Add":" oSize = FSE_decompress(huffWeight, hwSize-1, ip+1, iSize); /* max (hwSize-1) values decoded, as last one is implied */"},{"Add":" if (FSE_isError(oSize)) return oSize;"},{"Add":" }"},{"Add":""},{"Add":" /* collect weight stats */"},{"Add":" memset(rankStats, 0, (HUF_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32));"},{"Add":" weightTotal = 0;"},{"Add":" for (n=0; n= HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);"},{"Add":" rankStats[huffWeight[n]]++;"},{"Add":" weightTotal += (1 << huffWeight[n]) >> 1;"},{"Add":" }"},{"Add":" if (weightTotal == 0) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* get last non-null symbol weight (implied, total must be 2^n) */"},{"Add":" tableLog = BIT_highbit32(weightTotal) + 1;"},{"Add":" if (tableLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);"},{"Add":" {"},{"Add":" U32 total = 1 << tableLog;"},{"Add":" U32 rest = total - weightTotal;"},{"Add":" U32 verif = 1 << BIT_highbit32(rest);"},{"Add":" U32 lastWeight = BIT_highbit32(rest) + 1;"},{"Add":" if (verif != rest) return ERROR(corruption_detected); /* last value must be a clean power of 2 */"},{"Add":" huffWeight[oSize] = (BYTE)lastWeight;"},{"Add":" rankStats[lastWeight]++;"},{"Add":" }"},{"Add":""},{"Add":" /* check tree construction validity */"},{"Add":" if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected); /* by construction : at least 2 elts of rank 1, must be even */"},{"Add":""},{"Add":" /* results */"},{"Add":" *nbSymbolsPtr = (U32)(oSize+1);"},{"Add":" *tableLogPtr = tableLog;"},{"Add":" return iSize+1;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/**************************/"},{"Add":"/* single-symbol decoding */"},{"Add":"/**************************/"},{"Add":""},{"Add":"static size_t HUF_readDTableX2 (U16* DTable, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1];"},{"Add":" U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1]; /* large enough for values from 0 to 16 */"},{"Add":" U32 tableLog = 0;"},{"Add":" const BYTE* ip = (const BYTE*) src;"},{"Add":" size_t iSize = ip[0];"},{"Add":" U32 nbSymbols = 0;"},{"Add":" U32 n;"},{"Add":" U32 nextRankStart;"},{"Add":" void* ptr = DTable+1;"},{"Add":" HUF_DEltX2* const dt = (HUF_DEltX2*)(ptr);"},{"Add":""},{"Add":" HUF_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(U16)); /* if compilation fails here, assertion is false */"},{"Add":" //memset(huffWeight, 0, sizeof(huffWeight)); /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" iSize = HUF_readStats(huffWeight, HUF_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);"},{"Add":" if (HUF_isError(iSize)) return iSize;"},{"Add":""},{"Add":" /* check result */"},{"Add":" if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge); /* DTable is too small */"},{"Add":" DTable[0] = (U16)tableLog; /* maybe should separate sizeof DTable, as allocated, from used size of DTable, in case of DTable re-use */"},{"Add":""},{"Add":" /* Prepare ranks */"},{"Add":" nextRankStart = 0;"},{"Add":" for (n=1; n<=tableLog; n++)"},{"Add":" {"},{"Add":" U32 current = nextRankStart;"},{"Add":" nextRankStart += (rankVal[n] << (n-1));"},{"Add":" rankVal[n] = current;"},{"Add":" }"},{"Add":""},{"Add":" /* fill DTable */"},{"Add":" for (n=0; n> 1;"},{"Add":" U32 i;"},{"Add":" HUF_DEltX2 D;"},{"Add":" D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);"},{"Add":" for (i = rankVal[w]; i < rankVal[w] + length; i++)"},{"Add":" dt[i] = D;"},{"Add":" rankVal[w] += length;"},{"Add":" }"},{"Add":""},{"Add":" return iSize;"},{"Add":"}"},{"Add":""},{"Add":"static BYTE HUF_decodeSymbolX2(BIT_DStream_t* Dstream, const HUF_DEltX2* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" const size_t val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */"},{"Add":" const BYTE c = dt[val].byte;"},{"Add":" BIT_skipBits(Dstream, dt[val].nbBits);"},{"Add":" return c;"},{"Add":"}"},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \\"},{"Add":" *ptr++ = HUF_decodeSymbolX2(DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \\"},{"Add":" HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)"},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits()) \\"},{"Add":" HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)"},{"Add":""},{"Add":"static inline size_t HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX2* const dt, const U32 dtLog)"},{"Add":"{"},{"Add":" BYTE* const pStart = p;"},{"Add":""},{"Add":" /* up to 4 symbols at a time */"},{"Add":" while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-4))"},{"Add":" {"},{"Add":" HUF_DECODE_SYMBOLX2_2(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX2_1(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX2_2(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":" }"},{"Add":""},{"Add":" /* closer to the end */"},{"Add":" while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd))"},{"Add":" HUF_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":""},{"Add":" /* no more data to retrieve from bitstream, hence no need to reload */"},{"Add":" while (p < pEnd)"},{"Add":" HUF_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":""},{"Add":" return pEnd-pStart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t HUF_decompress4X2_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const U16* DTable)"},{"Add":"{"},{"Add":" if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */"},{"Add":""},{"Add":" {"},{"Add":" const BYTE* const istart = (const BYTE*) cSrc;"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* const oend = ostart + dstSize;"},{"Add":""},{"Add":" const void* ptr = DTable;"},{"Add":" const HUF_DEltX2* const dt = ((const HUF_DEltX2*)ptr) +1;"},{"Add":" const U32 dtLog = DTable[0];"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" /* Init */"},{"Add":" BIT_DStream_t bitD1;"},{"Add":" BIT_DStream_t bitD2;"},{"Add":" BIT_DStream_t bitD3;"},{"Add":" BIT_DStream_t bitD4;"},{"Add":" const size_t length1 = MEM_readLE16(istart);"},{"Add":" const size_t length2 = MEM_readLE16(istart+2);"},{"Add":" const size_t length3 = MEM_readLE16(istart+4);"},{"Add":" size_t length4;"},{"Add":" const BYTE* const istart1 = istart + 6; /* jumpTable */"},{"Add":" const BYTE* const istart2 = istart1 + length1;"},{"Add":" const BYTE* const istart3 = istart2 + length2;"},{"Add":" const BYTE* const istart4 = istart3 + length3;"},{"Add":" const size_t segmentSize = (dstSize+3) / 4;"},{"Add":" BYTE* const opStart2 = ostart + segmentSize;"},{"Add":" BYTE* const opStart3 = opStart2 + segmentSize;"},{"Add":" BYTE* const opStart4 = opStart3 + segmentSize;"},{"Add":" BYTE* op1 = ostart;"},{"Add":" BYTE* op2 = opStart2;"},{"Add":" BYTE* op3 = opStart3;"},{"Add":" BYTE* op4 = opStart4;"},{"Add":" U32 endSignal;"},{"Add":""},{"Add":" length4 = cSrcSize - (length1 + length2 + length3 + 6);"},{"Add":" if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */"},{"Add":" errorCode = BIT_initDStream(&bitD1, istart1, length1);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD2, istart2, length2);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD3, istart3, length3);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD4, istart4, length4);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" /* 16-32 symbols per loop (4-8 symbols per stream) */"},{"Add":" endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);"},{"Add":" for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )"},{"Add":" {"},{"Add":" HUF_DECODE_SYMBOLX2_2(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX2_1(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX2_1(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX2_1(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX2_1(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX2_0(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX2_0(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX2_0(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX2_0(op4, &bitD4);"},{"Add":""},{"Add":" endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);"},{"Add":" }"},{"Add":""},{"Add":" /* check corruption */"},{"Add":" if (op1 > opStart2) return ERROR(corruption_detected);"},{"Add":" if (op2 > opStart3) return ERROR(corruption_detected);"},{"Add":" if (op3 > opStart4) return ERROR(corruption_detected);"},{"Add":" /* note : op4 supposed already verified within main loop */"},{"Add":""},{"Add":" /* finish bitStreams one by one */"},{"Add":" HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);"},{"Add":" HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);"},{"Add":" HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);"},{"Add":" HUF_decodeStreamX2(op4, &bitD4, oend, dt, dtLog);"},{"Add":""},{"Add":" /* check */"},{"Add":" endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);"},{"Add":" if (!endSignal) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* decoded size */"},{"Add":" return dstSize;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_MAX_TABLELOG);"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" errorCode = HUF_readDTableX2 (DTable, cSrc, cSrcSize);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += errorCode;"},{"Add":" cSrcSize -= errorCode;"},{"Add":""},{"Add":" return HUF_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/***************************/"},{"Add":"/* double-symbols decoding */"},{"Add":"/***************************/"},{"Add":""},{"Add":"static void HUF_fillDTableX4Level2(HUF_DEltX4* DTable, U32 sizeLog, const U32 consumed,"},{"Add":" const U32* rankValOrigin, const int minWeight,"},{"Add":" const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,"},{"Add":" U32 nbBitsBaseline, U16 baseSeq)"},{"Add":"{"},{"Add":" HUF_DEltX4 DElt;"},{"Add":" U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];"},{"Add":" U32 s;"},{"Add":""},{"Add":" /* get pre-calculated rankVal */"},{"Add":" memcpy(rankVal, rankValOrigin, sizeof(rankVal));"},{"Add":""},{"Add":" /* fill skipped values */"},{"Add":" if (minWeight>1)"},{"Add":" {"},{"Add":" U32 i, skipSize = rankVal[minWeight];"},{"Add":" MEM_writeLE16(&(DElt.sequence), baseSeq);"},{"Add":" DElt.nbBits = (BYTE)(consumed);"},{"Add":" DElt.length = 1;"},{"Add":" for (i = 0; i < skipSize; i++)"},{"Add":" DTable[i] = DElt;"},{"Add":" }"},{"Add":""},{"Add":" /* fill DTable */"},{"Add":" for (s=0; s= 1 */"},{"Add":""},{"Add":" rankVal[weight] += length;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"typedef U32 rankVal_t[HUF_ABSOLUTEMAX_TABLELOG][HUF_ABSOLUTEMAX_TABLELOG + 1];"},{"Add":""},{"Add":"static void HUF_fillDTableX4(HUF_DEltX4* DTable, const U32 targetLog,"},{"Add":" const sortedSymbol_t* sortedList, const U32 sortedListSize,"},{"Add":" const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,"},{"Add":" const U32 nbBitsBaseline)"},{"Add":"{"},{"Add":" U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];"},{"Add":" const int scaleLog = nbBitsBaseline - targetLog; /* note : targetLog >= srcLog, hence scaleLog <= 1 */"},{"Add":" const U32 minBits = nbBitsBaseline - maxWeight;"},{"Add":" U32 s;"},{"Add":""},{"Add":" memcpy(rankVal, rankValOrigin, sizeof(rankVal));"},{"Add":""},{"Add":" /* fill DTable */"},{"Add":" for (s=0; s= minBits) /* enough room for a second symbol */"},{"Add":" {"},{"Add":" U32 sortedRank;"},{"Add":" int minWeight = nbBits + scaleLog;"},{"Add":" if (minWeight < 1) minWeight = 1;"},{"Add":" sortedRank = rankStart[minWeight];"},{"Add":" HUF_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,"},{"Add":" rankValOrigin[nbBits], minWeight,"},{"Add":" sortedList+sortedRank, sortedListSize-sortedRank,"},{"Add":" nbBitsBaseline, symbol);"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" U32 i;"},{"Add":" const U32 end = start + length;"},{"Add":" HUF_DEltX4 DElt;"},{"Add":""},{"Add":" MEM_writeLE16(&(DElt.sequence), symbol);"},{"Add":" DElt.nbBits = (BYTE)(nbBits);"},{"Add":" DElt.length = 1;"},{"Add":" for (i = start; i < end; i++)"},{"Add":" DTable[i] = DElt;"},{"Add":" }"},{"Add":" rankVal[weight] += length;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"static size_t HUF_readDTableX4 (U32* DTable, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" BYTE weightList[HUF_MAX_SYMBOL_VALUE + 1];"},{"Add":" sortedSymbol_t sortedSymbol[HUF_MAX_SYMBOL_VALUE + 1];"},{"Add":" U32 rankStats[HUF_ABSOLUTEMAX_TABLELOG + 1] = { 0 };"},{"Add":" U32 rankStart0[HUF_ABSOLUTEMAX_TABLELOG + 2] = { 0 };"},{"Add":" U32* const rankStart = rankStart0+1;"},{"Add":" rankVal_t rankVal;"},{"Add":" U32 tableLog, maxW, sizeOfSort, nbSymbols;"},{"Add":" const U32 memLog = DTable[0];"},{"Add":" const BYTE* ip = (const BYTE*) src;"},{"Add":" size_t iSize = ip[0];"},{"Add":" void* ptr = DTable;"},{"Add":" HUF_DEltX4* const dt = ((HUF_DEltX4*)ptr) + 1;"},{"Add":""},{"Add":" HUF_STATIC_ASSERT(sizeof(HUF_DEltX4) == sizeof(U32)); /* if compilation fails here, assertion is false */"},{"Add":" if (memLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);"},{"Add":" //memset(weightList, 0, sizeof(weightList)); /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" iSize = HUF_readStats(weightList, HUF_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);"},{"Add":" if (HUF_isError(iSize)) return iSize;"},{"Add":""},{"Add":" /* check result */"},{"Add":" if (tableLog > memLog) return ERROR(tableLog_tooLarge); /* DTable can't fit code depth */"},{"Add":""},{"Add":" /* find maxWeight */"},{"Add":" for (maxW = tableLog; rankStats[maxW]==0; maxW--)"},{"Add":" { if (!maxW) return ERROR(GENERIC); } /* necessarily finds a solution before maxW==0 */"},{"Add":""},{"Add":" /* Get start index of each weight */"},{"Add":" {"},{"Add":" U32 w, nextRankStart = 0;"},{"Add":" for (w=1; w<=maxW; w++)"},{"Add":" {"},{"Add":" U32 current = nextRankStart;"},{"Add":" nextRankStart += rankStats[w];"},{"Add":" rankStart[w] = current;"},{"Add":" }"},{"Add":" rankStart[0] = nextRankStart; /* put all 0w symbols at the end of sorted list*/"},{"Add":" sizeOfSort = nextRankStart;"},{"Add":" }"},{"Add":""},{"Add":" /* sort symbols by weight */"},{"Add":" {"},{"Add":" U32 s;"},{"Add":" for (s=0; s> consumed;"},{"Add":" }"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" HUF_fillDTableX4(dt, memLog,"},{"Add":" sortedSymbol, sizeOfSort,"},{"Add":" rankStart0, rankVal, maxW,"},{"Add":" tableLog+1);"},{"Add":""},{"Add":" return iSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static U32 HUF_decodeSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" const size_t val = BIT_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */"},{"Add":" memcpy(op, dt+val, 2);"},{"Add":" BIT_skipBits(DStream, dt[val].nbBits);"},{"Add":" return dt[val].length;"},{"Add":"}"},{"Add":""},{"Add":"static U32 HUF_decodeLastSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" const size_t val = BIT_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */"},{"Add":" memcpy(op, dt+val, 1);"},{"Add":" if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits);"},{"Add":" else"},{"Add":" {"},{"Add":" if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8))"},{"Add":" {"},{"Add":" BIT_skipBits(DStream, dt[val].nbBits);"},{"Add":" if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))"},{"Add":" DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8); /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */"},{"Add":" }"},{"Add":" }"},{"Add":" return 1;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \\"},{"Add":" ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \\"},{"Add":" ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits()) \\"},{"Add":" ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"static inline size_t HUF_decodeStreamX4(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const HUF_DEltX4* const dt, const U32 dtLog)"},{"Add":"{"},{"Add":" BYTE* const pStart = p;"},{"Add":""},{"Add":" /* up to 8 symbols at a time */"},{"Add":" while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd-7))"},{"Add":" {"},{"Add":" HUF_DECODE_SYMBOLX4_2(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX4_1(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX4_2(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX4_0(p, bitDPtr);"},{"Add":" }"},{"Add":""},{"Add":" /* closer to the end */"},{"Add":" while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-2))"},{"Add":" HUF_DECODE_SYMBOLX4_0(p, bitDPtr);"},{"Add":""},{"Add":" while (p <= pEnd-2)"},{"Add":" HUF_DECODE_SYMBOLX4_0(p, bitDPtr); /* no need to reload : reached the end of DStream */"},{"Add":""},{"Add":" if (p < pEnd)"},{"Add":" p += HUF_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);"},{"Add":""},{"Add":" return p-pStart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"static size_t HUF_decompress4X4_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const U32* DTable)"},{"Add":"{"},{"Add":" if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */"},{"Add":""},{"Add":" {"},{"Add":" const BYTE* const istart = (const BYTE*) cSrc;"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* const oend = ostart + dstSize;"},{"Add":""},{"Add":" const void* ptr = DTable;"},{"Add":" const HUF_DEltX4* const dt = ((const HUF_DEltX4*)ptr) +1;"},{"Add":" const U32 dtLog = DTable[0];"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" /* Init */"},{"Add":" BIT_DStream_t bitD1;"},{"Add":" BIT_DStream_t bitD2;"},{"Add":" BIT_DStream_t bitD3;"},{"Add":" BIT_DStream_t bitD4;"},{"Add":" const size_t length1 = MEM_readLE16(istart);"},{"Add":" const size_t length2 = MEM_readLE16(istart+2);"},{"Add":" const size_t length3 = MEM_readLE16(istart+4);"},{"Add":" size_t length4;"},{"Add":" const BYTE* const istart1 = istart + 6; /* jumpTable */"},{"Add":" const BYTE* const istart2 = istart1 + length1;"},{"Add":" const BYTE* const istart3 = istart2 + length2;"},{"Add":" const BYTE* const istart4 = istart3 + length3;"},{"Add":" const size_t segmentSize = (dstSize+3) / 4;"},{"Add":" BYTE* const opStart2 = ostart + segmentSize;"},{"Add":" BYTE* const opStart3 = opStart2 + segmentSize;"},{"Add":" BYTE* const opStart4 = opStart3 + segmentSize;"},{"Add":" BYTE* op1 = ostart;"},{"Add":" BYTE* op2 = opStart2;"},{"Add":" BYTE* op3 = opStart3;"},{"Add":" BYTE* op4 = opStart4;"},{"Add":" U32 endSignal;"},{"Add":""},{"Add":" length4 = cSrcSize - (length1 + length2 + length3 + 6);"},{"Add":" if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */"},{"Add":" errorCode = BIT_initDStream(&bitD1, istart1, length1);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD2, istart2, length2);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD3, istart3, length3);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD4, istart4, length4);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" /* 16-32 symbols per loop (4-8 symbols per stream) */"},{"Add":" endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);"},{"Add":" for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )"},{"Add":" {"},{"Add":" HUF_DECODE_SYMBOLX4_2(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX4_1(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX4_1(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX4_1(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX4_1(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX4_0(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX4_0(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX4_0(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX4_0(op4, &bitD4);"},{"Add":""},{"Add":" endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);"},{"Add":" }"},{"Add":""},{"Add":" /* check corruption */"},{"Add":" if (op1 > opStart2) return ERROR(corruption_detected);"},{"Add":" if (op2 > opStart3) return ERROR(corruption_detected);"},{"Add":" if (op3 > opStart4) return ERROR(corruption_detected);"},{"Add":" /* note : op4 supposed already verified within main loop */"},{"Add":""},{"Add":" /* finish bitStreams one by one */"},{"Add":" HUF_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);"},{"Add":" HUF_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);"},{"Add":" HUF_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);"},{"Add":" HUF_decodeStreamX4(op4, &bitD4, oend, dt, dtLog);"},{"Add":""},{"Add":" /* check */"},{"Add":" endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);"},{"Add":" if (!endSignal) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* decoded size */"},{"Add":" return dstSize;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUF_CREATE_STATIC_DTABLEX4(DTable, HUF_MAX_TABLELOG);"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":""},{"Add":" size_t hSize = HUF_readDTableX4 (DTable, cSrc, cSrcSize);"},{"Add":" if (HUF_isError(hSize)) return hSize;"},{"Add":" if (hSize >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += hSize;"},{"Add":" cSrcSize -= hSize;"},{"Add":""},{"Add":" return HUF_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/**********************************/"},{"Add":"/* Generic decompression selector */"},{"Add":"/**********************************/"},{"Add":""},{"Add":"typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;"},{"Add":"static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] ="},{"Add":"{"},{"Add":" /* single, double, quad */"},{"Add":" {{0,0}, {1,1}, {2,2}}, /* Q==0 : impossible */"},{"Add":" {{0,0}, {1,1}, {2,2}}, /* Q==1 : impossible */"},{"Add":" {{ 38,130}, {1313, 74}, {2151, 38}}, /* Q == 2 : 12-18% */"},{"Add":" {{ 448,128}, {1353, 74}, {2238, 41}}, /* Q == 3 : 18-25% */"},{"Add":" {{ 556,128}, {1353, 74}, {2238, 47}}, /* Q == 4 : 25-32% */"},{"Add":" {{ 714,128}, {1418, 74}, {2436, 53}}, /* Q == 5 : 32-38% */"},{"Add":" {{ 883,128}, {1437, 74}, {2464, 61}}, /* Q == 6 : 38-44% */"},{"Add":" {{ 897,128}, {1515, 75}, {2622, 68}}, /* Q == 7 : 44-50% */"},{"Add":" {{ 926,128}, {1613, 75}, {2730, 75}}, /* Q == 8 : 50-56% */"},{"Add":" {{ 947,128}, {1729, 77}, {3359, 77}}, /* Q == 9 : 56-62% */"},{"Add":" {{1107,128}, {2083, 81}, {4006, 84}}, /* Q ==10 : 62-69% */"},{"Add":" {{1177,128}, {2379, 87}, {4785, 88}}, /* Q ==11 : 69-75% */"},{"Add":" {{1242,128}, {2415, 93}, {5155, 84}}, /* Q ==12 : 75-81% */"},{"Add":" {{1349,128}, {2644,106}, {5260,106}}, /* Q ==13 : 81-87% */"},{"Add":" {{1455,128}, {2422,124}, {4174,124}}, /* Q ==14 : 87-93% */"},{"Add":" {{ 722,128}, {1891,145}, {1936,146}}, /* Q ==15 : 93-99% */"},{"Add":"};"},{"Add":""},{"Add":"typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);"},{"Add":""},{"Add":"static size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" static const decompressionAlgo decompress[3] = { HUF_decompress4X2, HUF_decompress4X4, NULL };"},{"Add":" /* estimate decompression time */"},{"Add":" U32 Q;"},{"Add":" const U32 D256 = (U32)(dstSize >> 8);"},{"Add":" U32 Dtime[3];"},{"Add":" U32 algoNb = 0;"},{"Add":" int n;"},{"Add":""},{"Add":" /* validation checks */"},{"Add":" if (dstSize == 0) return ERROR(dstSize_tooSmall);"},{"Add":" if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */"},{"Add":" if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */"},{"Add":" if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */"},{"Add":""},{"Add":" /* decoder timing evaluation */"},{"Add":" Q = (U32)(cSrcSize * 16 / dstSize); /* Q < 16 since dstSize > cSrcSize */"},{"Add":" for (n=0; n<3; n++)"},{"Add":" Dtime[n] = algoTime[Q][n].tableTime + (algoTime[Q][n].decode256Time * D256);"},{"Add":""},{"Add":" Dtime[1] += Dtime[1] >> 4; Dtime[2] += Dtime[2] >> 3; /* advantage to algorithms using less memory, for cache eviction */"},{"Add":""},{"Add":" if (Dtime[1] < Dtime[0]) algoNb = 1;"},{"Add":""},{"Add":" return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);"},{"Add":""},{"Add":" //return HUF_decompress4X2(dst, dstSize, cSrc, cSrcSize); /* multi-streams single-symbol decoding */"},{"Add":" //return HUF_decompress4X4(dst, dstSize, cSrc, cSrcSize); /* multi-streams double-symbols decoding */"},{"Add":" //return HUF_decompress4X6(dst, dstSize, cSrc, cSrcSize); /* multi-streams quad-symbols decoding */"},{"Add":"}"},{"Add":"/*"},{"Add":" zstd - standard compression library"},{"Add":" Copyright (C) 2014-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - zstd source repository : https://github.com/Cyan4973/zstd"},{"Add":" - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"*/"},{"Add":""},{"Add":"/* ***************************************************************"},{"Add":"* Tuning parameters"},{"Add":"*****************************************************************/"},{"Add":"/*!"},{"Add":"* MEMORY_USAGE :"},{"Add":"* Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)"},{"Add":"* Increasing memory usage improves compression ratio"},{"Add":"* Reduced memory usage can improve speed, due to cache effect"},{"Add":"*/"},{"Add":"#define ZSTD_MEMORY_USAGE 17"},{"Add":""},{"Add":"/*!"},{"Add":" * HEAPMODE :"},{"Add":" * Select how default compression functions will allocate memory for their hash table,"},{"Add":" * in memory stack (0, fastest), or in memory heap (1, requires malloc())"},{"Add":" * Note that compression context is fairly large, as a consequence heap memory is recommended."},{"Add":" */"},{"Add":"#ifndef ZSTD_HEAPMODE"},{"Add":"# define ZSTD_HEAPMODE 1"},{"Add":"#endif /* ZSTD_HEAPMODE */"},{"Add":""},{"Add":"/*!"},{"Add":"* LEGACY_SUPPORT :"},{"Add":"* decompressor can decode older formats (starting from Zstd 0.1+)"},{"Add":"*/"},{"Add":"#ifndef ZSTD_LEGACY_SUPPORT"},{"Add":"# define ZSTD_LEGACY_SUPPORT 1"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* *******************************************************"},{"Add":"* Includes"},{"Add":"*********************************************************/"},{"Add":"#include /* calloc */"},{"Add":"#include /* memcpy, memmove */"},{"Add":"#include /* debug : printf */"},{"Add":""},{"Add":""},{"Add":"/* *******************************************************"},{"Add":"* Compiler specifics"},{"Add":"*********************************************************/"},{"Add":"#ifdef __AVX2__"},{"Add":"# include /* AVX2 intrinsics */"},{"Add":"#endif"},{"Add":""},{"Add":"#ifdef _MSC_VER /* Visual Studio */"},{"Add":"# include /* For Visual 2005 */"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"# pragma warning(disable : 4324) /* disable: C4324: padded structure */"},{"Add":"#else"},{"Add":"# define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* *******************************************************"},{"Add":"* Constants"},{"Add":"*********************************************************/"},{"Add":"#define HASH_LOG (ZSTD_MEMORY_USAGE - 2)"},{"Add":"#define HASH_TABLESIZE (1 << HASH_LOG)"},{"Add":"#define HASH_MASK (HASH_TABLESIZE - 1)"},{"Add":""},{"Add":"#define KNUTH 2654435761"},{"Add":""},{"Add":"#define BIT7 128"},{"Add":"#define BIT6 64"},{"Add":"#define BIT5 32"},{"Add":"#define BIT4 16"},{"Add":"#define BIT1 2"},{"Add":"#define BIT0 1"},{"Add":""},{"Add":"#define KB *(1 <<10)"},{"Add":"#define MB *(1 <<20)"},{"Add":"#define GB *(1U<<30)"},{"Add":""},{"Add":"#define BLOCKSIZE (128 KB) /* define, for static allocation */"},{"Add":"#define MIN_SEQUENCES_SIZE (2 /*seqNb*/ + 2 /*dumps*/ + 3 /*seqTables*/ + 1 /*bitStream*/)"},{"Add":"#define MIN_CBLOCK_SIZE (3 /*litCSize*/ + MIN_SEQUENCES_SIZE)"},{"Add":"#define IS_RAW BIT0"},{"Add":"#define IS_RLE BIT1"},{"Add":""},{"Add":"#define WORKPLACESIZE (BLOCKSIZE*3)"},{"Add":"#define MINMATCH 4"},{"Add":"#define MLbits 7"},{"Add":"#define LLbits 6"},{"Add":"#define Offbits 5"},{"Add":"#define MaxML ((1<blockType = (blockType_t)(headerFlags >> 6);"},{"Add":" bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;"},{"Add":""},{"Add":" if (bpPtr->blockType == bt_end) return 0;"},{"Add":" if (bpPtr->blockType == bt_rle) return 1;"},{"Add":" return cSize;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZSTD_copyUncompressedBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall);"},{"Add":" if (srcSize > 0) {"},{"Add":" memcpy(dst, src, srcSize);"},{"Add":" }"},{"Add":" return srcSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/** ZSTD_decompressLiterals"},{"Add":" @return : nb of bytes read from src, or an error code*/"},{"Add":"static size_t ZSTD_decompressLiterals(void* dst, size_t* maxDstSizePtr,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":""},{"Add":" const size_t litSize = (MEM_readLE32(src) & 0x1FFFFF) >> 2; /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */"},{"Add":" const size_t litCSize = (MEM_readLE32(ip+2) & 0xFFFFFF) >> 5; /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */"},{"Add":""},{"Add":" if (litSize > *maxDstSizePtr) return ERROR(corruption_detected);"},{"Add":" if (litCSize + 5 > srcSize) return ERROR(corruption_detected);"},{"Add":""},{"Add":" if (HUF_isError(HUF_decompress(dst, litSize, ip+5, litCSize))) return ERROR(corruption_detected);"},{"Add":""},{"Add":" *maxDstSizePtr = litSize;"},{"Add":" return litCSize + 5;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/** ZSTD_decodeLiteralsBlock"},{"Add":" @return : nb of bytes read from src (< srcSize )*/"},{"Add":"static size_t ZSTD_decodeLiteralsBlock(void* ctx,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" ZSTD_DCtx* dctx = (ZSTD_DCtx*)ctx;"},{"Add":" const BYTE* const istart = (const BYTE* const)src;"},{"Add":""},{"Add":" /* any compressed block with literals segment must be at least this size */"},{"Add":" if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);"},{"Add":""},{"Add":" switch(*istart & 3)"},{"Add":" {"},{"Add":" default:"},{"Add":" case 0:"},{"Add":" {"},{"Add":" size_t litSize = BLOCKSIZE;"},{"Add":" const size_t readSize = ZSTD_decompressLiterals(dctx->litBuffer, &litSize, src, srcSize);"},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" memset(dctx->litBuffer + dctx->litSize, 0, 8);"},{"Add":" return readSize; /* works if it's an error too */"},{"Add":" }"},{"Add":" case IS_RAW:"},{"Add":" {"},{"Add":" const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2; /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */"},{"Add":" if (litSize > srcSize-11) /* risk of reading too far with wildcopy */"},{"Add":" {"},{"Add":" if (litSize > BLOCKSIZE) return ERROR(corruption_detected);"},{"Add":" if (litSize > srcSize-3) return ERROR(corruption_detected);"},{"Add":" memcpy(dctx->litBuffer, istart, litSize);"},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" memset(dctx->litBuffer + dctx->litSize, 0, 8);"},{"Add":" return litSize+3;"},{"Add":" }"},{"Add":" /* direct reference into compressed stream */"},{"Add":" dctx->litPtr = istart+3;"},{"Add":" dctx->litSize = litSize;"},{"Add":" return litSize+3;"},{"Add":" }"},{"Add":" case IS_RLE:"},{"Add":" {"},{"Add":" const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2; /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */"},{"Add":" if (litSize > BLOCKSIZE) return ERROR(corruption_detected);"},{"Add":" memset(dctx->litBuffer, istart[3], litSize + 8);"},{"Add":" dctx->litPtr = dctx->litBuffer;"},{"Add":" dctx->litSize = litSize;"},{"Add":" return 4;"},{"Add":" }"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr,"},{"Add":" FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE* const)src;"},{"Add":" const BYTE* ip = istart;"},{"Add":" const BYTE* const iend = istart + srcSize;"},{"Add":" U32 LLtype, Offtype, MLtype;"},{"Add":" U32 LLlog, Offlog, MLlog;"},{"Add":" size_t dumpsLength;"},{"Add":""},{"Add":" /* check */"},{"Add":" if (srcSize < 5) return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" /* SeqHead */"},{"Add":" *nbSeq = MEM_readLE16(ip); ip+=2;"},{"Add":" LLtype = *ip >> 6;"},{"Add":" Offtype = (*ip >> 4) & 3;"},{"Add":" MLtype = (*ip >> 2) & 3;"},{"Add":" if (*ip & 2)"},{"Add":" {"},{"Add":" dumpsLength = ip[2];"},{"Add":" dumpsLength += ip[1] << 8;"},{"Add":" ip += 3;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" dumpsLength = ip[1];"},{"Add":" dumpsLength += (ip[0] & 1) << 8;"},{"Add":" ip += 2;"},{"Add":" }"},{"Add":" *dumpsPtr = ip;"},{"Add":" ip += dumpsLength;"},{"Add":" *dumpsLengthPtr = dumpsLength;"},{"Add":""},{"Add":" /* check */"},{"Add":" if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are \"raw\", hence no header, but at least xxLog bits per type */"},{"Add":""},{"Add":" /* sequences */"},{"Add":" {"},{"Add":" S16 norm[MaxML+1]; /* assumption : MaxML >= MaxLL and MaxOff */"},{"Add":" size_t headerSize;"},{"Add":""},{"Add":" /* Build DTables */"},{"Add":" switch(LLtype)"},{"Add":" {"},{"Add":" case bt_rle :"},{"Add":" LLlog = 0;"},{"Add":" FSE_buildDTable_rle(DTableLL, *ip++); break;"},{"Add":" case bt_raw :"},{"Add":" LLlog = LLbits;"},{"Add":" FSE_buildDTable_raw(DTableLL, LLbits); break;"},{"Add":" default :"},{"Add":" { U32 max = MaxLL;"},{"Add":" headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip);"},{"Add":" if (FSE_isError(headerSize)) return ERROR(GENERIC);"},{"Add":" if (LLlog > LLFSELog) return ERROR(corruption_detected);"},{"Add":" ip += headerSize;"},{"Add":" FSE_buildDTable(DTableLL, norm, max, LLlog);"},{"Add":" } }"},{"Add":""},{"Add":" switch(Offtype)"},{"Add":" {"},{"Add":" case bt_rle :"},{"Add":" Offlog = 0;"},{"Add":" if (ip > iend-2) return ERROR(srcSize_wrong); /* min : \"raw\", hence no header, but at least xxLog bits */"},{"Add":" FSE_buildDTable_rle(DTableOffb, *ip++ & MaxOff); /* if *ip > MaxOff, data is corrupted */"},{"Add":" break;"},{"Add":" case bt_raw :"},{"Add":" Offlog = Offbits;"},{"Add":" FSE_buildDTable_raw(DTableOffb, Offbits); break;"},{"Add":" default :"},{"Add":" { U32 max = MaxOff;"},{"Add":" headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip);"},{"Add":" if (FSE_isError(headerSize)) return ERROR(GENERIC);"},{"Add":" if (Offlog > OffFSELog) return ERROR(corruption_detected);"},{"Add":" ip += headerSize;"},{"Add":" FSE_buildDTable(DTableOffb, norm, max, Offlog);"},{"Add":" } }"},{"Add":""},{"Add":" switch(MLtype)"},{"Add":" {"},{"Add":" case bt_rle :"},{"Add":" MLlog = 0;"},{"Add":" if (ip > iend-2) return ERROR(srcSize_wrong); /* min : \"raw\", hence no header, but at least xxLog bits */"},{"Add":" FSE_buildDTable_rle(DTableML, *ip++); break;"},{"Add":" case bt_raw :"},{"Add":" MLlog = MLbits;"},{"Add":" FSE_buildDTable_raw(DTableML, MLbits); break;"},{"Add":" default :"},{"Add":" { U32 max = MaxML;"},{"Add":" headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip);"},{"Add":" if (FSE_isError(headerSize)) return ERROR(GENERIC);"},{"Add":" if (MLlog > MLFSELog) return ERROR(corruption_detected);"},{"Add":" ip += headerSize;"},{"Add":" FSE_buildDTable(DTableML, norm, max, MLlog);"},{"Add":" } } }"},{"Add":""},{"Add":" return ip-istart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"typedef struct {"},{"Add":" size_t litLength;"},{"Add":" size_t offset;"},{"Add":" size_t matchLength;"},{"Add":"} seq_t;"},{"Add":""},{"Add":"typedef struct {"},{"Add":" BIT_DStream_t DStream;"},{"Add":" FSE_DState_t stateLL;"},{"Add":" FSE_DState_t stateOffb;"},{"Add":" FSE_DState_t stateML;"},{"Add":" size_t prevOffset;"},{"Add":" const BYTE* dumps;"},{"Add":" const BYTE* dumpsEnd;"},{"Add":"} seqState_t;"},{"Add":""},{"Add":""},{"Add":"static void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState)"},{"Add":"{"},{"Add":" size_t litLength;"},{"Add":" size_t prevOffset;"},{"Add":" size_t offset;"},{"Add":" size_t matchLength;"},{"Add":" const BYTE* dumps = seqState->dumps;"},{"Add":" const BYTE* const de = seqState->dumpsEnd;"},{"Add":""},{"Add":" /* Literal length */"},{"Add":" litLength = FSE_decodeSymbol(&(seqState->stateLL), &(seqState->DStream));"},{"Add":" prevOffset = litLength ? seq->offset : seqState->prevOffset;"},{"Add":" seqState->prevOffset = seq->offset;"},{"Add":" if (litLength == MaxLL)"},{"Add":" {"},{"Add":" const U32 add = dumps= de) dumps = de-1; /* late correction, to avoid read overflow (data is now corrupted anyway) */"},{"Add":" }"},{"Add":""},{"Add":" /* Offset */"},{"Add":" {"},{"Add":" static const size_t offsetPrefix[MaxOff+1] = { /* note : size_t faster than U32 */"},{"Add":" 1 /*fake*/, 1, 2, 4, 8, 16, 32, 64, 128, 256,"},{"Add":" 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,"},{"Add":" 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, /*fake*/ 1, 1, 1, 1, 1 };"},{"Add":" U32 offsetCode, nbBits;"},{"Add":" offsetCode = FSE_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream)); /* <= maxOff, by table construction */"},{"Add":" if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));"},{"Add":" nbBits = offsetCode - 1;"},{"Add":" if (offsetCode==0) nbBits = 0; /* cmove */"},{"Add":" offset = offsetPrefix[offsetCode] + BIT_readBits(&(seqState->DStream), nbBits);"},{"Add":" if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));"},{"Add":" if (offsetCode==0) offset = prevOffset; /* cmove */"},{"Add":" }"},{"Add":""},{"Add":" /* MatchLength */"},{"Add":" matchLength = FSE_decodeSymbol(&(seqState->stateML), &(seqState->DStream));"},{"Add":" if (matchLength == MaxML)"},{"Add":" {"},{"Add":" const U32 add = dumps= de) dumps = de-1; /* late correction, to avoid read overflow (data is now corrupted anyway) */"},{"Add":" }"},{"Add":" matchLength += MINMATCH;"},{"Add":""},{"Add":" /* save result */"},{"Add":" seq->litLength = litLength;"},{"Add":" seq->offset = offset;"},{"Add":" seq->matchLength = matchLength;"},{"Add":" seqState->dumps = dumps;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTD_execSequence(BYTE* op,"},{"Add":" seq_t sequence,"},{"Add":" const BYTE** litPtr, const BYTE* const litLimit,"},{"Add":" BYTE* const base, BYTE* const oend)"},{"Add":"{"},{"Add":" static const int dec32table[] = {0, 1, 2, 1, 4, 4, 4, 4}; /* added */"},{"Add":" static const int dec64table[] = {8, 8, 8, 7, 8, 9,10,11}; /* subtracted */"},{"Add":" const BYTE* const ostart = op;"},{"Add":" BYTE* const oLitEnd = op + sequence.litLength;"},{"Add":" BYTE* const oMatchEnd = op + sequence.litLength + sequence.matchLength; /* risk : address space overflow (32-bits) */"},{"Add":" BYTE* const oend_8 = oend-8;"},{"Add":" const BYTE* const litEnd = *litPtr + sequence.litLength;"},{"Add":""},{"Add":" /* checks */"},{"Add":" if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of 8 from oend */"},{"Add":" if (oMatchEnd > oend) return ERROR(dstSize_tooSmall); /* overwrite beyond dst buffer */"},{"Add":" if (litEnd > litLimit) return ERROR(corruption_detected); /* overRead beyond lit buffer */"},{"Add":""},{"Add":" /* copy Literals */"},{"Add":" ZSTD_wildcopy(op, *litPtr, sequence.litLength); /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */"},{"Add":" op = oLitEnd;"},{"Add":" *litPtr = litEnd; /* update for next sequence */"},{"Add":""},{"Add":" /* copy Match */"},{"Add":" {"},{"Add":" const BYTE* match = op - sequence.offset;"},{"Add":""},{"Add":" /* check */"},{"Add":" if (sequence.offset > (size_t)op) return ERROR(corruption_detected); /* address space overflow test (this test seems kept by clang optimizer) */"},{"Add":" //if (match > op) return ERROR(corruption_detected); /* address space overflow test (is clang optimizer removing this test ?) */"},{"Add":" if (match < base) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* close range match, overlap */"},{"Add":" if (sequence.offset < 8)"},{"Add":" {"},{"Add":" const int dec64 = dec64table[sequence.offset];"},{"Add":" op[0] = match[0];"},{"Add":" op[1] = match[1];"},{"Add":" op[2] = match[2];"},{"Add":" op[3] = match[3];"},{"Add":" match += dec32table[sequence.offset];"},{"Add":" ZSTD_copy4(op+4, match);"},{"Add":" match -= dec64;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" ZSTD_copy8(op, match);"},{"Add":" }"},{"Add":" op += 8; match += 8;"},{"Add":""},{"Add":" if (oMatchEnd > oend-(16-MINMATCH))"},{"Add":" {"},{"Add":" if (op < oend_8)"},{"Add":" {"},{"Add":" ZSTD_wildcopy(op, match, oend_8 - op);"},{"Add":" match += oend_8 - op;"},{"Add":" op = oend_8;"},{"Add":" }"},{"Add":" while (op < oMatchEnd) *op++ = *match++;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8); /* works even if matchLength < 8 */"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" return oMatchEnd - ostart;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZSTD_decompressSequences("},{"Add":" void* ctx,"},{"Add":" void* dst, size_t maxDstSize,"},{"Add":" const void* seqStart, size_t seqSize)"},{"Add":"{"},{"Add":" ZSTD_DCtx* dctx = (ZSTD_DCtx*)ctx;"},{"Add":" const BYTE* ip = (const BYTE*)seqStart;"},{"Add":" const BYTE* const iend = ip + seqSize;"},{"Add":" BYTE* const ostart = (BYTE* const)dst;"},{"Add":" BYTE* op = ostart;"},{"Add":" BYTE* const oend = ostart + maxDstSize;"},{"Add":" size_t errorCode, dumpsLength;"},{"Add":" const BYTE* litPtr = dctx->litPtr;"},{"Add":" const BYTE* const litEnd = litPtr + dctx->litSize;"},{"Add":" int nbSeq;"},{"Add":" const BYTE* dumps;"},{"Add":" U32* DTableLL = dctx->LLTable;"},{"Add":" U32* DTableML = dctx->MLTable;"},{"Add":" U32* DTableOffb = dctx->OffTable;"},{"Add":" BYTE* const base = (BYTE*) (dctx->base);"},{"Add":""},{"Add":" /* Build Decoding Tables */"},{"Add":" errorCode = ZSTD_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength,"},{"Add":" DTableLL, DTableML, DTableOffb,"},{"Add":" ip, iend-ip);"},{"Add":" if (ZSTD_isError(errorCode)) return errorCode;"},{"Add":" ip += errorCode;"},{"Add":""},{"Add":" /* Regen sequences */"},{"Add":" {"},{"Add":" seq_t sequence;"},{"Add":" seqState_t seqState;"},{"Add":""},{"Add":" memset(&sequence, 0, sizeof(sequence));"},{"Add":" seqState.dumps = dumps;"},{"Add":" seqState.dumpsEnd = dumps + dumpsLength;"},{"Add":" seqState.prevOffset = sequence.offset = 4;"},{"Add":" errorCode = BIT_initDStream(&(seqState.DStream), ip, iend-ip);"},{"Add":" if (ERR_isError(errorCode)) return ERROR(corruption_detected);"},{"Add":" FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);"},{"Add":" FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);"},{"Add":" FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);"},{"Add":""},{"Add":" for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (nbSeq>0) ; )"},{"Add":" {"},{"Add":" size_t oneSeqSize;"},{"Add":" nbSeq--;"},{"Add":" ZSTD_decodeSequence(&sequence, &seqState);"},{"Add":" oneSeqSize = ZSTD_execSequence(op, sequence, &litPtr, litEnd, base, oend);"},{"Add":" if (ZSTD_isError(oneSeqSize)) return oneSeqSize;"},{"Add":" op += oneSeqSize;"},{"Add":" }"},{"Add":""},{"Add":" /* check if reached exact end */"},{"Add":" if ( !BIT_endOfDStream(&(seqState.DStream)) ) return ERROR(corruption_detected); /* requested too much : data is corrupted */"},{"Add":" if (nbSeq<0) return ERROR(corruption_detected); /* requested too many sequences : data is corrupted */"},{"Add":""},{"Add":" /* last literal segment */"},{"Add":" {"},{"Add":" size_t lastLLSize = litEnd - litPtr;"},{"Add":" if (litPtr > litEnd) return ERROR(corruption_detected);"},{"Add":" if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall);"},{"Add":" if (lastLLSize > 0) {"},{"Add":" if (op != litPtr) memmove(op, litPtr, lastLLSize);"},{"Add":" op += lastLLSize;"},{"Add":" }"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" return op-ostart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTD_decompressBlock("},{"Add":" void* ctx,"},{"Add":" void* dst, size_t maxDstSize,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" /* blockType == blockCompressed */"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":""},{"Add":" /* Decode literals sub-block */"},{"Add":" size_t litCSize = ZSTD_decodeLiteralsBlock(ctx, src, srcSize);"},{"Add":" if (ZSTD_isError(litCSize)) return litCSize;"},{"Add":" ip += litCSize;"},{"Add":" srcSize -= litCSize;"},{"Add":""},{"Add":" return ZSTD_decompressSequences(ctx, dst, maxDstSize, ip, srcSize);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t ZSTD_decompressDCtx(void* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":" const BYTE* iend = ip + srcSize;"},{"Add":" BYTE* const ostart = (BYTE* const)dst;"},{"Add":" BYTE* op = ostart;"},{"Add":" BYTE* const oend = ostart + maxDstSize;"},{"Add":" size_t remainingSize = srcSize;"},{"Add":" U32 magicNumber;"},{"Add":" blockProperties_t blockProperties;"},{"Add":""},{"Add":" /* Frame Header */"},{"Add":" if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);"},{"Add":" magicNumber = MEM_readLE32(src);"},{"Add":" if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown);"},{"Add":" ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize;"},{"Add":""},{"Add":" /* Loop on each block */"},{"Add":" while (1)"},{"Add":" {"},{"Add":" size_t decodedSize=0;"},{"Add":" size_t cBlockSize = ZSTD_getcBlockSize(ip, iend-ip, &blockProperties);"},{"Add":" if (ZSTD_isError(cBlockSize)) return cBlockSize;"},{"Add":""},{"Add":" ip += ZSTD_blockHeaderSize;"},{"Add":" remainingSize -= ZSTD_blockHeaderSize;"},{"Add":" if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);"},{"Add":""},{"Add":" switch(blockProperties.blockType)"},{"Add":" {"},{"Add":" case bt_compressed:"},{"Add":" decodedSize = ZSTD_decompressBlock(ctx, op, oend-op, ip, cBlockSize);"},{"Add":" break;"},{"Add":" case bt_raw :"},{"Add":" decodedSize = ZSTD_copyUncompressedBlock(op, oend-op, ip, cBlockSize);"},{"Add":" break;"},{"Add":" case bt_rle :"},{"Add":" return ERROR(GENERIC); /* not yet supported */"},{"Add":" break;"},{"Add":" case bt_end :"},{"Add":" /* end of frame */"},{"Add":" if (remainingSize) return ERROR(srcSize_wrong);"},{"Add":" break;"},{"Add":" default:"},{"Add":" return ERROR(GENERIC); /* impossible */"},{"Add":" }"},{"Add":" if (cBlockSize == 0) break; /* bt_end */"},{"Add":""},{"Add":" if (ZSTD_isError(decodedSize)) return decodedSize;"},{"Add":" op += decodedSize;"},{"Add":" ip += cBlockSize;"},{"Add":" remainingSize -= cBlockSize;"},{"Add":" }"},{"Add":""},{"Add":" return op-ostart;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZSTD_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" ZSTD_DCtx ctx;"},{"Add":" ctx.base = dst;"},{"Add":" return ZSTD_decompressDCtx(&ctx, dst, maxDstSize, src, srcSize);"},{"Add":"}"},{"Add":""},{"Add":"/* ZSTD_errorFrameSizeInfoLegacy() :"},{"Add":" assumes `cSize` and `dBound` are _not_ NULL */"},{"Add":"MEM_STATIC void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)"},{"Add":"{"},{"Add":" *cSize = ret;"},{"Add":" *dBound = ZSTD_CONTENTSIZE_ERROR;"},{"Add":"}"},{"Add":""},{"Add":"void ZSTDv03_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cSize, unsigned long long* dBound)"},{"Add":"{"},{"Add":" const BYTE* ip = (const BYTE*)src;"},{"Add":" size_t remainingSize = srcSize;"},{"Add":" size_t nbBlocks = 0;"},{"Add":" U32 magicNumber;"},{"Add":" blockProperties_t blockProperties;"},{"Add":""},{"Add":" /* Frame Header */"},{"Add":" if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));"},{"Add":" return;"},{"Add":" }"},{"Add":" magicNumber = MEM_readLE32(src);"},{"Add":" if (magicNumber != ZSTD_magicNumber) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(prefix_unknown));"},{"Add":" return;"},{"Add":" }"},{"Add":" ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize;"},{"Add":""},{"Add":" /* Loop on each block */"},{"Add":" while (1)"},{"Add":" {"},{"Add":" size_t cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties);"},{"Add":" if (ZSTD_isError(cBlockSize)) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, cBlockSize);"},{"Add":" return;"},{"Add":" }"},{"Add":""},{"Add":" ip += ZSTD_blockHeaderSize;"},{"Add":" remainingSize -= ZSTD_blockHeaderSize;"},{"Add":" if (cBlockSize > remainingSize) {"},{"Add":" ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));"},{"Add":" return;"},{"Add":" }"},{"Add":""},{"Add":" if (cBlockSize == 0) break; /* bt_end */"},{"Add":""},{"Add":" ip += cBlockSize;"},{"Add":" remainingSize -= cBlockSize;"},{"Add":" nbBlocks++;"},{"Add":" }"},{"Add":""},{"Add":" *cSize = ip - (const BYTE*)src;"},{"Add":" *dBound = nbBlocks * BLOCKSIZE;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*******************************"},{"Add":"* Streaming Decompression API"},{"Add":"*******************************/"},{"Add":""},{"Add":"static size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx)"},{"Add":"{"},{"Add":" dctx->expected = ZSTD_frameHeaderSize;"},{"Add":" dctx->phase = 0;"},{"Add":" dctx->previousDstEnd = NULL;"},{"Add":" dctx->base = NULL;"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"static ZSTD_DCtx* ZSTD_createDCtx(void)"},{"Add":"{"},{"Add":" ZSTD_DCtx* dctx = (ZSTD_DCtx*)malloc(sizeof(ZSTD_DCtx));"},{"Add":" if (dctx==NULL) return NULL;"},{"Add":" ZSTD_resetDCtx(dctx);"},{"Add":" return dctx;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)"},{"Add":"{"},{"Add":" free(dctx);"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx)"},{"Add":"{"},{"Add":" return dctx->expected;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZSTD_decompressContinue(ZSTD_DCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" /* Sanity check */"},{"Add":" if (srcSize != ctx->expected) return ERROR(srcSize_wrong);"},{"Add":" if (dst != ctx->previousDstEnd) /* not contiguous */"},{"Add":" ctx->base = dst;"},{"Add":""},{"Add":" /* Decompress : frame header */"},{"Add":" if (ctx->phase == 0)"},{"Add":" {"},{"Add":" /* Check frame magic header */"},{"Add":" U32 magicNumber = MEM_readLE32(src);"},{"Add":" if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown);"},{"Add":" ctx->phase = 1;"},{"Add":" ctx->expected = ZSTD_blockHeaderSize;"},{"Add":" return 0;"},{"Add":" }"},{"Add":""},{"Add":" /* Decompress : block header */"},{"Add":" if (ctx->phase == 1)"},{"Add":" {"},{"Add":" blockProperties_t bp;"},{"Add":" size_t blockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);"},{"Add":" if (ZSTD_isError(blockSize)) return blockSize;"},{"Add":" if (bp.blockType == bt_end)"},{"Add":" {"},{"Add":" ctx->expected = 0;"},{"Add":" ctx->phase = 0;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" ctx->expected = blockSize;"},{"Add":" ctx->bType = bp.blockType;"},{"Add":" ctx->phase = 2;"},{"Add":" }"},{"Add":""},{"Add":" return 0;"},{"Add":" }"},{"Add":""},{"Add":" /* Decompress : block content */"},{"Add":" {"},{"Add":" size_t rSize;"},{"Add":" switch(ctx->bType)"},{"Add":" {"},{"Add":" case bt_compressed:"},{"Add":" rSize = ZSTD_decompressBlock(ctx, dst, maxDstSize, src, srcSize);"},{"Add":" break;"},{"Add":" case bt_raw :"},{"Add":" rSize = ZSTD_copyUncompressedBlock(dst, maxDstSize, src, srcSize);"},{"Add":" break;"},{"Add":" case bt_rle :"},{"Add":" return ERROR(GENERIC); /* not yet handled */"},{"Add":" break;"},{"Add":" case bt_end : /* should never happen (filtered at phase 1) */"},{"Add":" rSize = 0;"},{"Add":" break;"},{"Add":" default:"},{"Add":" return ERROR(GENERIC);"},{"Add":" }"},{"Add":" ctx->phase = 1;"},{"Add":" ctx->expected = ZSTD_blockHeaderSize;"},{"Add":" ctx->previousDstEnd = (void*)( ((char*)dst) + rSize);"},{"Add":" return rSize;"},{"Add":" }"},{"Add":""},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/* wrapper layer */"},{"Add":""},{"Add":"unsigned ZSTDv03_isError(size_t code)"},{"Add":"{"},{"Add":" return ZSTD_isError(code);"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTDv03_decompress( void* dst, size_t maxOriginalSize,"},{"Add":" const void* src, size_t compressedSize)"},{"Add":"{"},{"Add":" return ZSTD_decompress(dst, maxOriginalSize, src, compressedSize);"},{"Add":"}"},{"Add":""},{"Add":"ZSTDv03_Dctx* ZSTDv03_createDCtx(void)"},{"Add":"{"},{"Add":" return (ZSTDv03_Dctx*)ZSTD_createDCtx();"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTDv03_freeDCtx(ZSTDv03_Dctx* dctx)"},{"Add":"{"},{"Add":" return ZSTD_freeDCtx((ZSTD_DCtx*)dctx);"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTDv03_resetDCtx(ZSTDv03_Dctx* dctx)"},{"Add":"{"},{"Add":" return ZSTD_resetDCtx((ZSTD_DCtx*)dctx);"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTDv03_nextSrcSizeToDecompress(ZSTDv03_Dctx* dctx)"},{"Add":"{"},{"Add":" return ZSTD_nextSrcSizeToDecompress((ZSTD_DCtx*)dctx);"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTDv03_decompressContinue(ZSTDv03_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" return ZSTD_decompressContinue((ZSTD_DCtx*)dctx, dst, maxDstSize, src, srcSize);"},{"Add":"}"}]}},{"FileAdd":{"meta":{"basename":"zstd_v02.h","metadata":0},"context":[{"change":0,"pos":140938}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) 2016-2021, Yann Collet, Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":""},{"Add":"#ifndef ZSTD_V02_H_4174539423"},{"Add":"#define ZSTD_V02_H_4174539423"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Includes"},{"Add":"***************************************/"},{"Add":"#include /* size_t */"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Simple one-step function"},{"Add":"***************************************/"},{"Add":"/**"},{"Add":"ZSTDv02_decompress() : decompress ZSTD frames compliant with v0.2.x format"},{"Add":" compressedSize : is the exact source size"},{"Add":" maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated."},{"Add":" It must be equal or larger than originalSize, otherwise decompression will fail."},{"Add":" return : the number of bytes decompressed into destination buffer (originalSize)"},{"Add":" or an errorCode if it fails (which can be tested using ZSTDv01_isError())"},{"Add":"*/"},{"Add":"size_t ZSTDv02_decompress( void* dst, size_t maxOriginalSize,"},{"Add":" const void* src, size_t compressedSize);"},{"Add":""},{"Add":" /**"},{"Add":" ZSTDv02_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.2.x format"},{"Add":" srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'"},{"Add":" cSize (output parameter) : the number of bytes that would be read to decompress this frame"},{"Add":" or an error code if it fails (which can be tested using ZSTDv01_isError())"},{"Add":" dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame"},{"Add":" or ZSTD_CONTENTSIZE_ERROR if an error occurs"},{"Add":""},{"Add":" note : assumes `cSize` and `dBound` are _not_ NULL."},{"Add":" */"},{"Add":"void ZSTDv02_findFrameSizeInfoLegacy(const void *src, size_t srcSize,"},{"Add":" size_t* cSize, unsigned long long* dBound);"},{"Add":""},{"Add":"/**"},{"Add":"ZSTDv02_isError() : tells if the result of ZSTDv02_decompress() is an error"},{"Add":"*/"},{"Add":"unsigned ZSTDv02_isError(size_t code);"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Advanced functions"},{"Add":"***************************************/"},{"Add":"typedef struct ZSTDv02_Dctx_s ZSTDv02_Dctx;"},{"Add":"ZSTDv02_Dctx* ZSTDv02_createDCtx(void);"},{"Add":"size_t ZSTDv02_freeDCtx(ZSTDv02_Dctx* dctx);"},{"Add":""},{"Add":"size_t ZSTDv02_decompressDCtx(void* ctx,"},{"Add":" void* dst, size_t maxOriginalSize,"},{"Add":" const void* src, size_t compressedSize);"},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Streaming functions"},{"Add":"***************************************/"},{"Add":"size_t ZSTDv02_resetDCtx(ZSTDv02_Dctx* dctx);"},{"Add":""},{"Add":"size_t ZSTDv02_nextSrcSizeToDecompress(ZSTDv02_Dctx* dctx);"},{"Add":"size_t ZSTDv02_decompressContinue(ZSTDv02_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);"},{"Add":"/**"},{"Add":" Use above functions alternatively."},{"Add":" ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue()."},{"Add":" ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block."},{"Add":" Result is the number of bytes regenerated within 'dst'."},{"Add":" It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header."},{"Add":"*/"},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Prefix - version detection"},{"Add":"***************************************/"},{"Add":"#define ZSTDv02_magicNumber 0xFD2FB522 /* v0.2 */"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* ZSTD_V02_H_4174539423 */"}]}},{"FileAdd":{"meta":{"basename":"zstd_v02.c","metadata":0},"context":[{"change":0,"pos":140938}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) 2016-2021, Yann Collet, Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":""},{"Add":""},{"Add":"#include /* size_t, ptrdiff_t */"},{"Add":"#include \"zstd_v02.h\""},{"Add":"#include \"../common/error_private.h\""},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* Compiler-specific"},{"Add":"******************************************/"},{"Add":"#if defined(_MSC_VER) /* Visual Studio */"},{"Add":"# include /* _byteswap_ulong */"},{"Add":"# include /* _byteswap_* */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* ******************************************************************"},{"Add":" mem.h"},{"Add":" low-level memory access routines"},{"Add":" Copyright (C) 2013-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":"#ifndef MEM_H_MODULE"},{"Add":"#define MEM_H_MODULE"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"/******************************************"},{"Add":"* Includes"},{"Add":"******************************************/"},{"Add":"#include /* size_t, ptrdiff_t */"},{"Add":"#include /* memcpy */"},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* Compiler-specific"},{"Add":"******************************************/"},{"Add":"#if defined(__GNUC__)"},{"Add":"# define MEM_STATIC static __attribute__((unused))"},{"Add":"#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)"},{"Add":"# define MEM_STATIC static inline"},{"Add":"#elif defined(_MSC_VER)"},{"Add":"# define MEM_STATIC static __inline"},{"Add":"#else"},{"Add":"# define MEM_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Basic Types"},{"Add":"*****************************************************************/"},{"Add":"#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)"},{"Add":"# if defined(_AIX)"},{"Add":"# include "},{"Add":"# else"},{"Add":"# include /* intptr_t */"},{"Add":"# endif"},{"Add":" typedef uint8_t BYTE;"},{"Add":" typedef uint16_t U16;"},{"Add":" typedef int16_t S16;"},{"Add":" typedef uint32_t U32;"},{"Add":" typedef int32_t S32;"},{"Add":" typedef uint64_t U64;"},{"Add":" typedef int64_t S64;"},{"Add":"#else"},{"Add":" typedef unsigned char BYTE;"},{"Add":" typedef unsigned short U16;"},{"Add":" typedef signed short S16;"},{"Add":" typedef unsigned int U32;"},{"Add":" typedef signed int S32;"},{"Add":" typedef unsigned long long U64;"},{"Add":" typedef signed long long S64;"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Memory I/O"},{"Add":"*****************************************************************/"},{"Add":"/* MEM_FORCE_MEMORY_ACCESS"},{"Add":" * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable."},{"Add":" * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal."},{"Add":" * The below switch allow to select different access method for improved performance."},{"Add":" * Method 0 (default) : use `memcpy()`. Safe and portable."},{"Add":" * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable)."},{"Add":" * This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`."},{"Add":" * Method 2 : direct access. This method is portable but violate C standard."},{"Add":" * It can generate buggy code on targets generating assembly depending on alignment."},{"Add":" * But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)"},{"Add":" * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details."},{"Add":" * Prefer these methods in priority order (0 > 1 > 2)"},{"Add":" */"},{"Add":"#ifndef MEM_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */"},{"Add":"# if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )"},{"Add":"# define MEM_FORCE_MEMORY_ACCESS 2"},{"Add":"# elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \\"},{"Add":" (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))"},{"Add":"# define MEM_FORCE_MEMORY_ACCESS 1"},{"Add":"# endif"},{"Add":"#endif"},{"Add":""},{"Add":"MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; }"},{"Add":"MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; }"},{"Add":""},{"Add":"MEM_STATIC unsigned MEM_isLittleEndian(void)"},{"Add":"{"},{"Add":" const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */"},{"Add":" return one.c[0];"},{"Add":"}"},{"Add":""},{"Add":"#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)"},{"Add":""},{"Add":"/* violates C standard on structure alignment."},{"Add":"Only use if no other choice to achieve best performance on target platform */"},{"Add":"MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }"},{"Add":"MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }"},{"Add":"MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }"},{"Add":""},{"Add":"#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)"},{"Add":""},{"Add":"/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */"},{"Add":"/* currently only defined for gcc and icc */"},{"Add":"typedef union { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign;"},{"Add":""},{"Add":"MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }"},{"Add":"MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }"},{"Add":"MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }"},{"Add":""},{"Add":"#else"},{"Add":""},{"Add":"/* default method, safe and standard."},{"Add":" can sometimes prove slower */"},{"Add":""},{"Add":"MEM_STATIC U16 MEM_read16(const void* memPtr)"},{"Add":"{"},{"Add":" U16 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_read32(const void* memPtr)"},{"Add":"{"},{"Add":" U32 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U64 MEM_read64(const void* memPtr)"},{"Add":"{"},{"Add":" U64 val; memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value)"},{"Add":"{"},{"Add":" memcpy(memPtr, &value, sizeof(value));"},{"Add":"}"},{"Add":""},{"Add":"#endif /* MEM_FORCE_MEMORY_ACCESS */"},{"Add":""},{"Add":""},{"Add":"MEM_STATIC U16 MEM_readLE16(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read16(memPtr);"},{"Add":" else"},{"Add":" {"},{"Add":" const BYTE* p = (const BYTE*)memPtr;"},{"Add":" return (U16)(p[0] + (p[1]<<8));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" {"},{"Add":" MEM_write16(memPtr, val);"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" BYTE* p = (BYTE*)memPtr;"},{"Add":" p[0] = (BYTE)val;"},{"Add":" p[1] = (BYTE)(val>>8);"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_readLE24(const void* memPtr)"},{"Add":"{"},{"Add":" return MEM_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_readLE32(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read32(memPtr);"},{"Add":" else"},{"Add":" {"},{"Add":" const BYTE* p = (const BYTE*)memPtr;"},{"Add":" return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"MEM_STATIC U64 MEM_readLE64(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read64(memPtr);"},{"Add":" else"},{"Add":" {"},{"Add":" const BYTE* p = (const BYTE*)memPtr;"},{"Add":" return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)"},{"Add":" + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"MEM_STATIC size_t MEM_readLEST(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_32bits())"},{"Add":" return (size_t)MEM_readLE32(memPtr);"},{"Add":" else"},{"Add":" return (size_t)MEM_readLE64(memPtr);"},{"Add":"}"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* MEM_H_MODULE */"},{"Add":""},{"Add":""},{"Add":"/* ******************************************************************"},{"Add":" bitstream"},{"Add":" Part of NewGen Entropy library"},{"Add":" header file (to include)"},{"Add":" Copyright (C) 2013-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":"#ifndef BITSTREAM_H_MODULE"},{"Add":"#define BITSTREAM_H_MODULE"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*"},{"Add":"* This API consists of small unitary functions, which highly benefit from being inlined."},{"Add":"* Since link-time-optimization is not available for all compilers,"},{"Add":"* these functions are defined into a .h to be included."},{"Add":"*/"},{"Add":""},{"Add":""},{"Add":"/**********************************************"},{"Add":"* bitStream decompression API (read backward)"},{"Add":"**********************************************/"},{"Add":"typedef struct"},{"Add":"{"},{"Add":" size_t bitContainer;"},{"Add":" unsigned bitsConsumed;"},{"Add":" const char* ptr;"},{"Add":" const char* start;"},{"Add":"} BIT_DStream_t;"},{"Add":""},{"Add":"typedef enum { BIT_DStream_unfinished = 0,"},{"Add":" BIT_DStream_endOfBuffer = 1,"},{"Add":" BIT_DStream_completed = 2,"},{"Add":" BIT_DStream_overflow = 3 } BIT_DStream_status; /* result of BIT_reloadDStream() */"},{"Add":" /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */"},{"Add":""},{"Add":"MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);"},{"Add":"MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);"},{"Add":"MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);"},{"Add":"MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);"},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* unsafe API"},{"Add":"******************************************/"},{"Add":"MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);"},{"Add":"/* faster, but works only if nbBits >= 1 */"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Helper functions"},{"Add":"****************************************************************/"},{"Add":"MEM_STATIC unsigned BIT_highbit32 (U32 val)"},{"Add":"{"},{"Add":"# if defined(_MSC_VER) /* Visual */"},{"Add":" unsigned long r=0;"},{"Add":" _BitScanReverse ( &r, val );"},{"Add":" return (unsigned) r;"},{"Add":"# elif defined(__GNUC__) && (__GNUC__ >= 3) /* Use GCC Intrinsic */"},{"Add":" return __builtin_clz (val) ^ 31;"},{"Add":"# else /* Software version */"},{"Add":" static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };"},{"Add":" U32 v = val;"},{"Add":" unsigned r;"},{"Add":" v |= v >> 1;"},{"Add":" v |= v >> 2;"},{"Add":" v |= v >> 4;"},{"Add":" v |= v >> 8;"},{"Add":" v |= v >> 16;"},{"Add":" r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];"},{"Add":" return r;"},{"Add":"# endif"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/**********************************************************"},{"Add":"* bitStream decoding"},{"Add":"**********************************************************/"},{"Add":""},{"Add":"/*!BIT_initDStream"},{"Add":"* Initialize a BIT_DStream_t."},{"Add":"* @bitD : a pointer to an already allocated BIT_DStream_t structure"},{"Add":"* @srcBuffer must point at the beginning of a bitStream"},{"Add":"* @srcSize must be the exact size of the bitStream"},{"Add":"* @result : size of stream (== srcSize) or an errorCode if a problem is detected"},{"Add":"*/"},{"Add":"MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)"},{"Add":"{"},{"Add":" if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }"},{"Add":""},{"Add":" if (srcSize >= sizeof(size_t)) /* normal case */"},{"Add":" {"},{"Add":" U32 contain32;"},{"Add":" bitD->start = (const char*)srcBuffer;"},{"Add":" bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(size_t);"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr);"},{"Add":" contain32 = ((const BYTE*)srcBuffer)[srcSize-1];"},{"Add":" if (contain32 == 0) return ERROR(GENERIC); /* endMark not present */"},{"Add":" bitD->bitsConsumed = 8 - BIT_highbit32(contain32);"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" U32 contain32;"},{"Add":" bitD->start = (const char*)srcBuffer;"},{"Add":" bitD->ptr = bitD->start;"},{"Add":" bitD->bitContainer = *(const BYTE*)(bitD->start);"},{"Add":" switch(srcSize)"},{"Add":" {"},{"Add":" case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16);"},{"Add":" /* fallthrough */"},{"Add":" case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);"},{"Add":" /* fallthrough */"},{"Add":" case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);"},{"Add":" /* fallthrough */"},{"Add":" case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24;"},{"Add":" /* fallthrough */"},{"Add":" case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16;"},{"Add":" /* fallthrough */"},{"Add":" case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) << 8;"},{"Add":" /* fallthrough */"},{"Add":" default:;"},{"Add":" }"},{"Add":" contain32 = ((const BYTE*)srcBuffer)[srcSize-1];"},{"Add":" if (contain32 == 0) return ERROR(GENERIC); /* endMark not present */"},{"Add":" bitD->bitsConsumed = 8 - BIT_highbit32(contain32);"},{"Add":" bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8;"},{"Add":" }"},{"Add":""},{"Add":" return srcSize;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;"},{"Add":" return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);"},{"Add":"}"},{"Add":""},{"Add":"/*! BIT_lookBitsFast :"},{"Add":"* unsafe version; only works only if nbBits >= 1 */"},{"Add":"MEM_STATIC size_t BIT_lookBitsFast(BIT_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;"},{"Add":" return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" bitD->bitsConsumed += nbBits;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" size_t value = BIT_lookBits(bitD, nbBits);"},{"Add":" BIT_skipBits(bitD, nbBits);"},{"Add":" return value;"},{"Add":"}"},{"Add":""},{"Add":"/*!BIT_readBitsFast :"},{"Add":"* unsafe version; only works only if nbBits >= 1 */"},{"Add":"MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)"},{"Add":"{"},{"Add":" size_t value = BIT_lookBitsFast(bitD, nbBits);"},{"Add":" BIT_skipBits(bitD, nbBits);"},{"Add":" return value;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)"},{"Add":"{"},{"Add":" if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* should never happen */"},{"Add":" return BIT_DStream_overflow;"},{"Add":""},{"Add":" if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer))"},{"Add":" {"},{"Add":" bitD->ptr -= bitD->bitsConsumed >> 3;"},{"Add":" bitD->bitsConsumed &= 7;"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr);"},{"Add":" return BIT_DStream_unfinished;"},{"Add":" }"},{"Add":" if (bitD->ptr == bitD->start)"},{"Add":" {"},{"Add":" if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;"},{"Add":" return BIT_DStream_completed;"},{"Add":" }"},{"Add":" {"},{"Add":" U32 nbBytes = bitD->bitsConsumed >> 3;"},{"Add":" BIT_DStream_status result = BIT_DStream_unfinished;"},{"Add":" if (bitD->ptr - nbBytes < bitD->start)"},{"Add":" {"},{"Add":" nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */"},{"Add":" result = BIT_DStream_endOfBuffer;"},{"Add":" }"},{"Add":" bitD->ptr -= nbBytes;"},{"Add":" bitD->bitsConsumed -= nbBytes*8;"},{"Add":" bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD) */"},{"Add":" return result;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"/*! BIT_endOfDStream"},{"Add":"* @return Tells if DStream has reached its exact end"},{"Add":"*/"},{"Add":"MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)"},{"Add":"{"},{"Add":" return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));"},{"Add":"}"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* BITSTREAM_H_MODULE */"},{"Add":"/* ******************************************************************"},{"Add":" Error codes and messages"},{"Add":" Copyright (C) 2013-2015, Yann Collet"},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":"#ifndef ERROR_H_MODULE"},{"Add":"#define ERROR_H_MODULE"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* Compiler-specific"},{"Add":"******************************************/"},{"Add":"#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)"},{"Add":"# define ERR_STATIC static inline"},{"Add":"#elif defined(_MSC_VER)"},{"Add":"# define ERR_STATIC static __inline"},{"Add":"#elif defined(__GNUC__)"},{"Add":"# define ERR_STATIC static __attribute__((unused))"},{"Add":"#else"},{"Add":"# define ERR_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* Error Management"},{"Add":"******************************************/"},{"Add":"#define PREFIX(name) ZSTD_error_##name"},{"Add":""},{"Add":"#define ERROR(name) (size_t)-PREFIX(name)"},{"Add":""},{"Add":"#define ERROR_LIST(ITEM) \\"},{"Add":" ITEM(PREFIX(No_Error)) ITEM(PREFIX(GENERIC)) \\"},{"Add":" ITEM(PREFIX(dstSize_tooSmall)) ITEM(PREFIX(srcSize_wrong)) \\"},{"Add":" ITEM(PREFIX(prefix_unknown)) ITEM(PREFIX(corruption_detected)) \\"},{"Add":" ITEM(PREFIX(tableLog_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooSmall)) \\"},{"Add":" ITEM(PREFIX(maxCode))"},{"Add":""},{"Add":"#define ERROR_GENERATE_ENUM(ENUM) ENUM,"},{"Add":"typedef enum { ERROR_LIST(ERROR_GENERATE_ENUM) } ERR_codes; /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */"},{"Add":""},{"Add":"#define ERROR_CONVERTTOSTRING(STRING) #STRING,"},{"Add":"#define ERROR_GENERATE_STRING(EXPR) ERROR_CONVERTTOSTRING(EXPR)"},{"Add":"static const char* ERR_strings[] = { ERROR_LIST(ERROR_GENERATE_STRING) };"},{"Add":""},{"Add":"ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }"},{"Add":""},{"Add":"ERR_STATIC const char* ERR_getErrorName(size_t code)"},{"Add":"{"},{"Add":" static const char* codeError = \"Unspecified error code\";"},{"Add":" if (ERR_isError(code)) return ERR_strings[-(int)(code)];"},{"Add":" return codeError;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* ERROR_H_MODULE */"},{"Add":"/*"},{"Add":"Constructor and Destructor of type FSE_CTable"},{"Add":" Note that its size depends on 'tableLog' and 'maxSymbolValue' */"},{"Add":"typedef unsigned FSE_CTable; /* don't allocate that. It's just a way to be more restrictive than void* */"},{"Add":"typedef unsigned FSE_DTable; /* don't allocate that. It's just a way to be more restrictive than void* */"},{"Add":""},{"Add":""},{"Add":"/* ******************************************************************"},{"Add":" FSE : Finite State Entropy coder"},{"Add":" header file for static linking (only)"},{"Add":" Copyright (C) 2013-2015, Yann Collet"},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* Static allocation"},{"Add":"******************************************/"},{"Add":"/* FSE buffer bounds */"},{"Add":"#define FSE_NCOUNTBOUND 512"},{"Add":"#define FSE_BLOCKBOUND(size) (size + (size>>7))"},{"Add":"#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size)) /* Macro version, useful for static allocation */"},{"Add":""},{"Add":"/* You can statically allocate FSE CTable/DTable as a table of unsigned using below macro */"},{"Add":"#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2))"},{"Add":"#define FSE_DTABLE_SIZE_U32(maxTableLog) (1 + (1<= 1 (otherwise, result will be corrupted) */"},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* Implementation of inline functions"},{"Add":"******************************************/"},{"Add":""},{"Add":"/* decompression */"},{"Add":""},{"Add":"typedef struct {"},{"Add":" U16 tableLog;"},{"Add":" U16 fastMode;"},{"Add":"} FSE_DTableHeader; /* sizeof U32 */"},{"Add":""},{"Add":"typedef struct"},{"Add":"{"},{"Add":" unsigned short newState;"},{"Add":" unsigned char symbol;"},{"Add":" unsigned char nbBits;"},{"Add":"} FSE_decode_t; /* size == U32 */"},{"Add":""},{"Add":"MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)"},{"Add":"{"},{"Add":" FSE_DTableHeader DTableH;"},{"Add":" memcpy(&DTableH, dt, sizeof(DTableH));"},{"Add":" DStatePtr->state = BIT_readBits(bitD, DTableH.tableLog);"},{"Add":" BIT_reloadDStream(bitD);"},{"Add":" DStatePtr->table = dt + 1;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)"},{"Add":"{"},{"Add":" const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];"},{"Add":" const U32 nbBits = DInfo.nbBits;"},{"Add":" BYTE symbol = DInfo.symbol;"},{"Add":" size_t lowBits = BIT_readBits(bitD, nbBits);"},{"Add":""},{"Add":" DStatePtr->state = DInfo.newState + lowBits;"},{"Add":" return symbol;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)"},{"Add":"{"},{"Add":" const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];"},{"Add":" const U32 nbBits = DInfo.nbBits;"},{"Add":" BYTE symbol = DInfo.symbol;"},{"Add":" size_t lowBits = BIT_readBitsFast(bitD, nbBits);"},{"Add":""},{"Add":" DStatePtr->state = DInfo.newState + lowBits;"},{"Add":" return symbol;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)"},{"Add":"{"},{"Add":" return DStatePtr->state == 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":"/* ******************************************************************"},{"Add":" Huff0 : Huffman coder, part of New Generation Entropy library"},{"Add":" header file for static linking (only)"},{"Add":" Copyright (C) 2013-2015, Yann Collet"},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"/******************************************"},{"Add":"* Static allocation macros"},{"Add":"******************************************/"},{"Add":"/* Huff0 buffer bounds */"},{"Add":"#define HUF_CTABLEBOUND 129"},{"Add":"#define HUF_BLOCKBOUND(size) (size + (size>>8) + 8) /* only true if incompressible pre-filtered with fast heuristic */"},{"Add":"#define HUF_COMPRESSBOUND(size) (HUF_CTABLEBOUND + HUF_BLOCKBOUND(size)) /* Macro version, useful for static allocation */"},{"Add":""},{"Add":"/* static allocation of Huff0's DTable */"},{"Add":"#define HUF_DTABLE_SIZE(maxTableLog) (1 + (1< /* size_t */"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Version"},{"Add":"***************************************/"},{"Add":"#define ZSTD_VERSION_MAJOR 0 /* for breaking interface changes */"},{"Add":"#define ZSTD_VERSION_MINOR 2 /* for new (non-breaking) interface capabilities */"},{"Add":"#define ZSTD_VERSION_RELEASE 2 /* for tweaks, bug-fixes, or development */"},{"Add":"#define ZSTD_VERSION_NUMBER (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)"},{"Add":""},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Advanced functions"},{"Add":"***************************************/"},{"Add":"typedef struct ZSTD_CCtx_s ZSTD_CCtx; /* incomplete type */"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":"/*"},{"Add":" zstd - standard compression library"},{"Add":" Header File for static linking only"},{"Add":" Copyright (C) 2014-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - zstd source repository : https://github.com/Cyan4973/zstd"},{"Add":" - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"*/"},{"Add":""},{"Add":"/* The objects defined into this file should be considered experimental."},{"Add":" * They are not labelled stable, as their prototype may change in the future."},{"Add":" * You can use them for tests, provide feedback, or if you can endure risk of future changes."},{"Add":" */"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Streaming functions"},{"Add":"***************************************/"},{"Add":""},{"Add":"typedef struct ZSTD_DCtx_s ZSTD_DCtx;"},{"Add":""},{"Add":"/*"},{"Add":" Use above functions alternatively."},{"Add":" ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue()."},{"Add":" ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block."},{"Add":" Result is the number of bytes regenerated within 'dst'."},{"Add":" It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header."},{"Add":"*/"},{"Add":""},{"Add":"/* *************************************"},{"Add":"* Prefix - version detection"},{"Add":"***************************************/"},{"Add":"#define ZSTD_magicNumber 0xFD2FB522 /* v0.2 (current)*/"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":"/* ******************************************************************"},{"Add":" FSE : Finite State Entropy coder"},{"Add":" Copyright (C) 2013-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":""},{"Add":"#ifndef FSE_COMMONDEFS_ONLY"},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Tuning parameters"},{"Add":"****************************************************************/"},{"Add":"/* MEMORY_USAGE :"},{"Add":"* Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)"},{"Add":"* Increasing memory usage improves compression ratio"},{"Add":"* Reduced memory usage can improve speed, due to cache effect"},{"Add":"* Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */"},{"Add":"#define FSE_MAX_MEMORY_USAGE 14"},{"Add":"#define FSE_DEFAULT_MEMORY_USAGE 13"},{"Add":""},{"Add":"/* FSE_MAX_SYMBOL_VALUE :"},{"Add":"* Maximum symbol value authorized."},{"Add":"* Required for proper stack allocation */"},{"Add":"#define FSE_MAX_SYMBOL_VALUE 255"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* template functions type & suffix"},{"Add":"****************************************************************/"},{"Add":"#define FSE_FUNCTION_TYPE BYTE"},{"Add":"#define FSE_FUNCTION_EXTENSION"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Byte symbol type"},{"Add":"****************************************************************/"},{"Add":"#endif /* !FSE_COMMONDEFS_ONLY */"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Compiler specifics"},{"Add":"****************************************************************/"},{"Add":"#ifdef _MSC_VER /* Visual Studio */"},{"Add":"# define FORCE_INLINE static __forceinline"},{"Add":"# include /* For Visual 2005 */"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"# pragma warning(disable : 4214) /* disable: C4214: non-int bitfields */"},{"Add":"#else"},{"Add":"# if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */"},{"Add":"# ifdef __GNUC__"},{"Add":"# define FORCE_INLINE static inline __attribute__((always_inline))"},{"Add":"# else"},{"Add":"# define FORCE_INLINE static inline"},{"Add":"# endif"},{"Add":"# else"},{"Add":"# define FORCE_INLINE static"},{"Add":"# endif /* __STDC_VERSION__ */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Includes"},{"Add":"****************************************************************/"},{"Add":"#include /* malloc, free, qsort */"},{"Add":"#include /* memcpy, memset */"},{"Add":"#include /* printf (debug) */"},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Constants"},{"Add":"*****************************************************************/"},{"Add":"#define FSE_MAX_TABLELOG (FSE_MAX_MEMORY_USAGE-2)"},{"Add":"#define FSE_MAX_TABLESIZE (1U< FSE_TABLELOG_ABSOLUTE_MAX"},{"Add":"#error \"FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported\""},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Error Management"},{"Add":"****************************************************************/"},{"Add":"#define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Complex types"},{"Add":"****************************************************************/"},{"Add":"typedef U32 DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Templates"},{"Add":"****************************************************************/"},{"Add":"/*"},{"Add":" designed to be included"},{"Add":" for type-specific functions (template emulation in C)"},{"Add":" Objective is to write these functions only once, for improved maintenance"},{"Add":"*/"},{"Add":""},{"Add":"/* safety checks */"},{"Add":"#ifndef FSE_FUNCTION_EXTENSION"},{"Add":"# error \"FSE_FUNCTION_EXTENSION must be defined\""},{"Add":"#endif"},{"Add":"#ifndef FSE_FUNCTION_TYPE"},{"Add":"# error \"FSE_FUNCTION_TYPE must be defined\""},{"Add":"#endif"},{"Add":""},{"Add":"/* Function names */"},{"Add":"#define FSE_CAT(X,Y) X##Y"},{"Add":"#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)"},{"Add":"#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)"},{"Add":""},{"Add":""},{"Add":"/* Function templates */"},{"Add":""},{"Add":"#define FSE_DECODE_TYPE FSE_decode_t"},{"Add":""},{"Add":"static U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; }"},{"Add":""},{"Add":"static size_t FSE_buildDTable"},{"Add":"(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)"},{"Add":"{"},{"Add":" void* ptr = dt+1;"},{"Add":" FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*)ptr;"},{"Add":" FSE_DTableHeader DTableH;"},{"Add":" const U32 tableSize = 1 << tableLog;"},{"Add":" const U32 tableMask = tableSize-1;"},{"Add":" const U32 step = FSE_tableStep(tableSize);"},{"Add":" U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1];"},{"Add":" U32 position = 0;"},{"Add":" U32 highThreshold = tableSize-1;"},{"Add":" const S16 largeLimit= (S16)(1 << (tableLog-1));"},{"Add":" U32 noLarge = 1;"},{"Add":" U32 s;"},{"Add":""},{"Add":" /* Sanity Checks */"},{"Add":" if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);"},{"Add":" if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);"},{"Add":""},{"Add":" /* Init, lay down lowprob symbols */"},{"Add":" DTableH.tableLog = (U16)tableLog;"},{"Add":" for (s=0; s<=maxSymbolValue; s++)"},{"Add":" {"},{"Add":" if (normalizedCounter[s]==-1)"},{"Add":" {"},{"Add":" tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;"},{"Add":" symbolNext[s] = 1;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" if (normalizedCounter[s] >= largeLimit) noLarge=0;"},{"Add":" symbolNext[s] = normalizedCounter[s];"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" /* Spread symbols */"},{"Add":" for (s=0; s<=maxSymbolValue; s++)"},{"Add":" {"},{"Add":" int i;"},{"Add":" for (i=0; i highThreshold) position = (position + step) & tableMask; /* lowprob area */"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" if (position!=0) return ERROR(GENERIC); /* position must reach all cells once, otherwise normalizedCounter is incorrect */"},{"Add":""},{"Add":" /* Build Decoding table */"},{"Add":" {"},{"Add":" U32 i;"},{"Add":" for (i=0; i FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);"},{"Add":" bitStream >>= 4;"},{"Add":" bitCount = 4;"},{"Add":" *tableLogPtr = nbBits;"},{"Add":" remaining = (1<1) && (charnum<=*maxSVPtr))"},{"Add":" {"},{"Add":" if (previous0)"},{"Add":" {"},{"Add":" unsigned n0 = charnum;"},{"Add":" while ((bitStream & 0xFFFF) == 0xFFFF)"},{"Add":" {"},{"Add":" n0+=24;"},{"Add":" if (ip < iend-5)"},{"Add":" {"},{"Add":" ip+=2;"},{"Add":" bitStream = MEM_readLE32(ip) >> bitCount;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" bitStream >>= 16;"},{"Add":" bitCount+=16;"},{"Add":" }"},{"Add":" }"},{"Add":" while ((bitStream & 3) == 3)"},{"Add":" {"},{"Add":" n0+=3;"},{"Add":" bitStream>>=2;"},{"Add":" bitCount+=2;"},{"Add":" }"},{"Add":" n0 += bitStream & 3;"},{"Add":" bitCount += 2;"},{"Add":" if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);"},{"Add":" while (charnum < n0) normalizedCounter[charnum++] = 0;"},{"Add":" if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))"},{"Add":" {"},{"Add":" ip += bitCount>>3;"},{"Add":" bitCount &= 7;"},{"Add":" bitStream = MEM_readLE32(ip) >> bitCount;"},{"Add":" }"},{"Add":" else"},{"Add":" bitStream >>= 2;"},{"Add":" }"},{"Add":" {"},{"Add":" const short max = (short)((2*threshold-1)-remaining);"},{"Add":" short count;"},{"Add":""},{"Add":" if ((bitStream & (threshold-1)) < (U32)max)"},{"Add":" {"},{"Add":" count = (short)(bitStream & (threshold-1));"},{"Add":" bitCount += nbBits-1;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" count = (short)(bitStream & (2*threshold-1));"},{"Add":" if (count >= threshold) count -= max;"},{"Add":" bitCount += nbBits;"},{"Add":" }"},{"Add":""},{"Add":" count--; /* extra accuracy */"},{"Add":" remaining -= FSE_abs(count);"},{"Add":" normalizedCounter[charnum++] = count;"},{"Add":" previous0 = !count;"},{"Add":" while (remaining < threshold)"},{"Add":" {"},{"Add":" nbBits--;"},{"Add":" threshold >>= 1;"},{"Add":" }"},{"Add":""},{"Add":" {"},{"Add":" if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))"},{"Add":" {"},{"Add":" ip += bitCount>>3;"},{"Add":" bitCount &= 7;"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" bitCount -= (int)(8 * (iend - 4 - ip));"},{"Add":" ip = iend - 4;"},{"Add":" }"},{"Add":" bitStream = MEM_readLE32(ip) >> (bitCount & 31);"},{"Add":" }"},{"Add":" }"},{"Add":" }"},{"Add":" if (remaining != 1) return ERROR(GENERIC);"},{"Add":" *maxSVPtr = charnum-1;"},{"Add":""},{"Add":" ip += (bitCount+7)>>3;"},{"Add":" if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong);"},{"Add":" return ip-istart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/*********************************************************"},{"Add":"* Decompression (Byte symbols)"},{"Add":"*********************************************************/"},{"Add":"static size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)"},{"Add":"{"},{"Add":" void* ptr = dt;"},{"Add":" FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;"},{"Add":" FSE_decode_t* const cell = (FSE_decode_t*)(ptr) + 1; /* because dt is unsigned */"},{"Add":""},{"Add":" DTableH->tableLog = 0;"},{"Add":" DTableH->fastMode = 0;"},{"Add":""},{"Add":" cell->newState = 0;"},{"Add":" cell->symbol = symbolValue;"},{"Add":" cell->nbBits = 0;"},{"Add":""},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)"},{"Add":"{"},{"Add":" void* ptr = dt;"},{"Add":" FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;"},{"Add":" FSE_decode_t* const dinfo = (FSE_decode_t*)(ptr) + 1; /* because dt is unsigned */"},{"Add":" const unsigned tableSize = 1 << nbBits;"},{"Add":" const unsigned tableMask = tableSize - 1;"},{"Add":" const unsigned maxSymbolValue = tableMask;"},{"Add":" unsigned s;"},{"Add":""},{"Add":" /* Sanity checks */"},{"Add":" if (nbBits < 1) return ERROR(GENERIC); /* min size */"},{"Add":""},{"Add":" /* Build Decoding Table */"},{"Add":" DTableH->tableLog = (U16)nbBits;"},{"Add":" DTableH->fastMode = 1;"},{"Add":" for (s=0; s<=maxSymbolValue; s++)"},{"Add":" {"},{"Add":" dinfo[s].newState = 0;"},{"Add":" dinfo[s].symbol = (BYTE)s;"},{"Add":" dinfo[s].nbBits = (BYTE)nbBits;"},{"Add":" }"},{"Add":""},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"FORCE_INLINE size_t FSE_decompress_usingDTable_generic("},{"Add":" void* dst, size_t maxDstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const FSE_DTable* dt, const unsigned fast)"},{"Add":"{"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* op = ostart;"},{"Add":" BYTE* const omax = op + maxDstSize;"},{"Add":" BYTE* const olimit = omax-3;"},{"Add":""},{"Add":" BIT_DStream_t bitD;"},{"Add":" FSE_DState_t state1;"},{"Add":" FSE_DState_t state2;"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" /* Init */"},{"Add":" errorCode = BIT_initDStream(&bitD, cSrc, cSrcSize); /* replaced last arg by maxCompressed Size */"},{"Add":" if (FSE_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" FSE_initDState(&state1, &bitD, dt);"},{"Add":" FSE_initDState(&state2, &bitD, dt);"},{"Add":""},{"Add":"#define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD)"},{"Add":""},{"Add":" /* 4 symbols per loop */"},{"Add":" for ( ; (BIT_reloadDStream(&bitD)==BIT_DStream_unfinished) && (op sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" BIT_reloadDStream(&bitD);"},{"Add":""},{"Add":" op[1] = FSE_GETSYMBOL(&state2);"},{"Add":""},{"Add":" if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" { if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } }"},{"Add":""},{"Add":" op[2] = FSE_GETSYMBOL(&state1);"},{"Add":""},{"Add":" if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */"},{"Add":" BIT_reloadDStream(&bitD);"},{"Add":""},{"Add":" op[3] = FSE_GETSYMBOL(&state2);"},{"Add":" }"},{"Add":""},{"Add":" /* tail */"},{"Add":" /* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */"},{"Add":" while (1)"},{"Add":" {"},{"Add":" if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) )"},{"Add":" break;"},{"Add":""},{"Add":" *op++ = FSE_GETSYMBOL(&state1);"},{"Add":""},{"Add":" if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) )"},{"Add":" break;"},{"Add":""},{"Add":" *op++ = FSE_GETSYMBOL(&state2);"},{"Add":" }"},{"Add":""},{"Add":" /* end ? */"},{"Add":" if (BIT_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2))"},{"Add":" return op-ostart;"},{"Add":""},{"Add":" if (op==omax) return ERROR(dstSize_tooSmall); /* dst buffer is full, but cSrc unfinished */"},{"Add":""},{"Add":" return ERROR(corruption_detected);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const FSE_DTable* dt)"},{"Add":"{"},{"Add":" FSE_DTableHeader DTableH;"},{"Add":" memcpy(&DTableH, dt, sizeof(DTableH));"},{"Add":""},{"Add":" /* select fast mode (static) */"},{"Add":" if (DTableH.fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);"},{"Add":" return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t FSE_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" const BYTE* const istart = (const BYTE*)cSrc;"},{"Add":" const BYTE* ip = istart;"},{"Add":" short counting[FSE_MAX_SYMBOL_VALUE+1];"},{"Add":" DTable_max_t dt; /* Static analyzer seems unable to understand this table will be properly initialized later */"},{"Add":" unsigned tableLog;"},{"Add":" unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" if (cSrcSize<2) return ERROR(srcSize_wrong); /* too small input size */"},{"Add":""},{"Add":" /* normal FSE decoding mode */"},{"Add":" errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);"},{"Add":" if (FSE_isError(errorCode)) return errorCode;"},{"Add":" if (errorCode >= cSrcSize) return ERROR(srcSize_wrong); /* too small input size */"},{"Add":" ip += errorCode;"},{"Add":" cSrcSize -= errorCode;"},{"Add":""},{"Add":" errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog);"},{"Add":" if (FSE_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" /* always return, even if it is an error code */"},{"Add":" return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"#endif /* FSE_COMMONDEFS_ONLY */"},{"Add":"/* ******************************************************************"},{"Add":" Huff0 : Huffman coder, part of New Generation Entropy library"},{"Add":" Copyright (C) 2013-2015, Yann Collet."},{"Add":""},{"Add":" BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)"},{"Add":""},{"Add":" Redistribution and use in source and binary forms, with or without"},{"Add":" modification, are permitted provided that the following conditions are"},{"Add":" met:"},{"Add":""},{"Add":" * Redistributions of source code must retain the above copyright"},{"Add":" notice, this list of conditions and the following disclaimer."},{"Add":" * Redistributions in binary form must reproduce the above"},{"Add":" copyright notice, this list of conditions and the following disclaimer"},{"Add":" in the documentation and/or other materials provided with the"},{"Add":" distribution."},{"Add":""},{"Add":" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"},{"Add":" \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT"},{"Add":" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR"},{"Add":" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT"},{"Add":" OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,"},{"Add":" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT"},{"Add":" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"},{"Add":" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY"},{"Add":" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT"},{"Add":" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE"},{"Add":" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":" You can contact the author at :"},{"Add":" - FSE+Huff0 source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" - Public forum : https://groups.google.com/forum/#!forum/lz4c"},{"Add":"****************************************************************** */"},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Compiler specifics"},{"Add":"****************************************************************/"},{"Add":"#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)"},{"Add":"/* inline is defined */"},{"Add":"#elif defined(_MSC_VER)"},{"Add":"# define inline __inline"},{"Add":"#else"},{"Add":"# define inline /* disable inline */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"#ifdef _MSC_VER /* Visual Studio */"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Includes"},{"Add":"****************************************************************/"},{"Add":"#include /* malloc, free, qsort */"},{"Add":"#include /* memcpy, memset */"},{"Add":"#include /* printf (debug) */"},{"Add":""},{"Add":"/****************************************************************"},{"Add":"* Error Management"},{"Add":"****************************************************************/"},{"Add":"#define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */"},{"Add":""},{"Add":""},{"Add":"/******************************************"},{"Add":"* Helper functions"},{"Add":"******************************************/"},{"Add":"static unsigned HUF_isError(size_t code) { return ERR_isError(code); }"},{"Add":""},{"Add":"#define HUF_ABSOLUTEMAX_TABLELOG 16 /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */"},{"Add":"#define HUF_MAX_TABLELOG 12 /* max configured tableLog (for static allocation); can be modified up to HUF_ABSOLUTEMAX_TABLELOG */"},{"Add":"#define HUF_DEFAULT_TABLELOG HUF_MAX_TABLELOG /* tableLog by default, when not specified */"},{"Add":"#define HUF_MAX_SYMBOL_VALUE 255"},{"Add":"#if (HUF_MAX_TABLELOG > HUF_ABSOLUTEMAX_TABLELOG)"},{"Add":"# error \"HUF_MAX_TABLELOG is too large !\""},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":""},{"Add":"/*********************************************************"},{"Add":"* Huff0 : Huffman block decompression"},{"Add":"*********************************************************/"},{"Add":"typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX2; /* single-symbol decoding */"},{"Add":""},{"Add":"typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX4; /* double-symbols decoding */"},{"Add":""},{"Add":"typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;"},{"Add":""},{"Add":"/*! HUF_readStats"},{"Add":" Read compact Huffman tree, saved by HUF_writeCTable"},{"Add":" @huffWeight : destination buffer"},{"Add":" @return : size read from `src`"},{"Add":"*/"},{"Add":"static size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,"},{"Add":" U32* nbSymbolsPtr, U32* tableLogPtr,"},{"Add":" const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" U32 weightTotal;"},{"Add":" U32 tableLog;"},{"Add":" const BYTE* ip = (const BYTE*) src;"},{"Add":" size_t iSize;"},{"Add":" size_t oSize;"},{"Add":" U32 n;"},{"Add":""},{"Add":" if (!srcSize) return ERROR(srcSize_wrong);"},{"Add":" iSize = ip[0];"},{"Add":" //memset(huffWeight, 0, hwSize); /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" if (iSize >= 128) /* special header */"},{"Add":" {"},{"Add":" if (iSize >= (242)) /* RLE */"},{"Add":" {"},{"Add":" static int l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };"},{"Add":" oSize = l[iSize-242];"},{"Add":" memset(huffWeight, 1, hwSize);"},{"Add":" iSize = 0;"},{"Add":" }"},{"Add":" else /* Incompressible */"},{"Add":" {"},{"Add":" oSize = iSize - 127;"},{"Add":" iSize = ((oSize+1)/2);"},{"Add":" if (iSize+1 > srcSize) return ERROR(srcSize_wrong);"},{"Add":" if (oSize >= hwSize) return ERROR(corruption_detected);"},{"Add":" ip += 1;"},{"Add":" for (n=0; n> 4;"},{"Add":" huffWeight[n+1] = ip[n/2] & 15;"},{"Add":" }"},{"Add":" }"},{"Add":" }"},{"Add":" else /* header compressed with FSE (normal case) */"},{"Add":" {"},{"Add":" if (iSize+1 > srcSize) return ERROR(srcSize_wrong);"},{"Add":" oSize = FSE_decompress(huffWeight, hwSize-1, ip+1, iSize); /* max (hwSize-1) values decoded, as last one is implied */"},{"Add":" if (FSE_isError(oSize)) return oSize;"},{"Add":" }"},{"Add":""},{"Add":" /* collect weight stats */"},{"Add":" memset(rankStats, 0, (HUF_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32));"},{"Add":" weightTotal = 0;"},{"Add":" for (n=0; n= HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);"},{"Add":" rankStats[huffWeight[n]]++;"},{"Add":" weightTotal += (1 << huffWeight[n]) >> 1;"},{"Add":" }"},{"Add":" if (weightTotal == 0) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* get last non-null symbol weight (implied, total must be 2^n) */"},{"Add":" tableLog = BIT_highbit32(weightTotal) + 1;"},{"Add":" if (tableLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);"},{"Add":" {"},{"Add":" U32 total = 1 << tableLog;"},{"Add":" U32 rest = total - weightTotal;"},{"Add":" U32 verif = 1 << BIT_highbit32(rest);"},{"Add":" U32 lastWeight = BIT_highbit32(rest) + 1;"},{"Add":" if (verif != rest) return ERROR(corruption_detected); /* last value must be a clean power of 2 */"},{"Add":" huffWeight[oSize] = (BYTE)lastWeight;"},{"Add":" rankStats[lastWeight]++;"},{"Add":" }"},{"Add":""},{"Add":" /* check tree construction validity */"},{"Add":" if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected); /* by construction : at least 2 elts of rank 1, must be even */"},{"Add":""},{"Add":" /* results */"},{"Add":" *nbSymbolsPtr = (U32)(oSize+1);"},{"Add":" *tableLogPtr = tableLog;"},{"Add":" return iSize+1;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/**************************/"},{"Add":"/* single-symbol decoding */"},{"Add":"/**************************/"},{"Add":""},{"Add":"static size_t HUF_readDTableX2 (U16* DTable, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1];"},{"Add":" U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1]; /* large enough for values from 0 to 16 */"},{"Add":" U32 tableLog = 0;"},{"Add":" const BYTE* ip = (const BYTE*) src;"},{"Add":" size_t iSize = ip[0];"},{"Add":" U32 nbSymbols = 0;"},{"Add":" U32 n;"},{"Add":" U32 nextRankStart;"},{"Add":" void* ptr = DTable+1;"},{"Add":" HUF_DEltX2* const dt = (HUF_DEltX2*)ptr;"},{"Add":""},{"Add":" HUF_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(U16)); /* if compilation fails here, assertion is false */"},{"Add":" //memset(huffWeight, 0, sizeof(huffWeight)); /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" iSize = HUF_readStats(huffWeight, HUF_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);"},{"Add":" if (HUF_isError(iSize)) return iSize;"},{"Add":""},{"Add":" /* check result */"},{"Add":" if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge); /* DTable is too small */"},{"Add":" DTable[0] = (U16)tableLog; /* maybe should separate sizeof DTable, as allocated, from used size of DTable, in case of DTable re-use */"},{"Add":""},{"Add":" /* Prepare ranks */"},{"Add":" nextRankStart = 0;"},{"Add":" for (n=1; n<=tableLog; n++)"},{"Add":" {"},{"Add":" U32 current = nextRankStart;"},{"Add":" nextRankStart += (rankVal[n] << (n-1));"},{"Add":" rankVal[n] = current;"},{"Add":" }"},{"Add":""},{"Add":" /* fill DTable */"},{"Add":" for (n=0; n> 1;"},{"Add":" U32 i;"},{"Add":" HUF_DEltX2 D;"},{"Add":" D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);"},{"Add":" for (i = rankVal[w]; i < rankVal[w] + length; i++)"},{"Add":" dt[i] = D;"},{"Add":" rankVal[w] += length;"},{"Add":" }"},{"Add":""},{"Add":" return iSize;"},{"Add":"}"},{"Add":""},{"Add":"static BYTE HUF_decodeSymbolX2(BIT_DStream_t* Dstream, const HUF_DEltX2* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" const size_t val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */"},{"Add":" const BYTE c = dt[val].byte;"},{"Add":" BIT_skipBits(Dstream, dt[val].nbBits);"},{"Add":" return c;"},{"Add":"}"},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \\"},{"Add":" *ptr++ = HUF_decodeSymbolX2(DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \\"},{"Add":" HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)"},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits()) \\"},{"Add":" HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)"},{"Add":""},{"Add":"static inline size_t HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX2* const dt, const U32 dtLog)"},{"Add":"{"},{"Add":" BYTE* const pStart = p;"},{"Add":""},{"Add":" /* up to 4 symbols at a time */"},{"Add":" while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-4))"},{"Add":" {"},{"Add":" HUF_DECODE_SYMBOLX2_2(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX2_1(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX2_2(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":" }"},{"Add":""},{"Add":" /* closer to the end */"},{"Add":" while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd))"},{"Add":" HUF_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":""},{"Add":" /* no more data to retrieve from bitstream, hence no need to reload */"},{"Add":" while (p < pEnd)"},{"Add":" HUF_DECODE_SYMBOLX2_0(p, bitDPtr);"},{"Add":""},{"Add":" return pEnd-pStart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t HUF_decompress4X2_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const U16* DTable)"},{"Add":"{"},{"Add":" if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */"},{"Add":""},{"Add":" {"},{"Add":" const BYTE* const istart = (const BYTE*) cSrc;"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* const oend = ostart + dstSize;"},{"Add":""},{"Add":" const void* ptr = DTable;"},{"Add":" const HUF_DEltX2* const dt = ((const HUF_DEltX2*)ptr) +1;"},{"Add":" const U32 dtLog = DTable[0];"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" /* Init */"},{"Add":" BIT_DStream_t bitD1;"},{"Add":" BIT_DStream_t bitD2;"},{"Add":" BIT_DStream_t bitD3;"},{"Add":" BIT_DStream_t bitD4;"},{"Add":" const size_t length1 = MEM_readLE16(istart);"},{"Add":" const size_t length2 = MEM_readLE16(istart+2);"},{"Add":" const size_t length3 = MEM_readLE16(istart+4);"},{"Add":" size_t length4;"},{"Add":" const BYTE* const istart1 = istart + 6; /* jumpTable */"},{"Add":" const BYTE* const istart2 = istart1 + length1;"},{"Add":" const BYTE* const istart3 = istart2 + length2;"},{"Add":" const BYTE* const istart4 = istart3 + length3;"},{"Add":" const size_t segmentSize = (dstSize+3) / 4;"},{"Add":" BYTE* const opStart2 = ostart + segmentSize;"},{"Add":" BYTE* const opStart3 = opStart2 + segmentSize;"},{"Add":" BYTE* const opStart4 = opStart3 + segmentSize;"},{"Add":" BYTE* op1 = ostart;"},{"Add":" BYTE* op2 = opStart2;"},{"Add":" BYTE* op3 = opStart3;"},{"Add":" BYTE* op4 = opStart4;"},{"Add":" U32 endSignal;"},{"Add":""},{"Add":" length4 = cSrcSize - (length1 + length2 + length3 + 6);"},{"Add":" if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */"},{"Add":" errorCode = BIT_initDStream(&bitD1, istart1, length1);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD2, istart2, length2);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD3, istart3, length3);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD4, istart4, length4);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" /* 16-32 symbols per loop (4-8 symbols per stream) */"},{"Add":" endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);"},{"Add":" for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )"},{"Add":" {"},{"Add":" HUF_DECODE_SYMBOLX2_2(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX2_1(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX2_1(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX2_1(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX2_1(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX2_2(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX2_0(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX2_0(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX2_0(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX2_0(op4, &bitD4);"},{"Add":""},{"Add":" endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);"},{"Add":" }"},{"Add":""},{"Add":" /* check corruption */"},{"Add":" if (op1 > opStart2) return ERROR(corruption_detected);"},{"Add":" if (op2 > opStart3) return ERROR(corruption_detected);"},{"Add":" if (op3 > opStart4) return ERROR(corruption_detected);"},{"Add":" /* note : op4 supposed already verified within main loop */"},{"Add":""},{"Add":" /* finish bitStreams one by one */"},{"Add":" HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);"},{"Add":" HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);"},{"Add":" HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);"},{"Add":" HUF_decodeStreamX2(op4, &bitD4, oend, dt, dtLog);"},{"Add":""},{"Add":" /* check */"},{"Add":" endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);"},{"Add":" if (!endSignal) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* decoded size */"},{"Add":" return dstSize;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_MAX_TABLELOG);"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" errorCode = HUF_readDTableX2 (DTable, cSrc, cSrcSize);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += errorCode;"},{"Add":" cSrcSize -= errorCode;"},{"Add":""},{"Add":" return HUF_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/***************************/"},{"Add":"/* double-symbols decoding */"},{"Add":"/***************************/"},{"Add":""},{"Add":"static void HUF_fillDTableX4Level2(HUF_DEltX4* DTable, U32 sizeLog, const U32 consumed,"},{"Add":" const U32* rankValOrigin, const int minWeight,"},{"Add":" const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,"},{"Add":" U32 nbBitsBaseline, U16 baseSeq)"},{"Add":"{"},{"Add":" HUF_DEltX4 DElt;"},{"Add":" U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];"},{"Add":" U32 s;"},{"Add":""},{"Add":" /* get pre-calculated rankVal */"},{"Add":" memcpy(rankVal, rankValOrigin, sizeof(rankVal));"},{"Add":""},{"Add":" /* fill skipped values */"},{"Add":" if (minWeight>1)"},{"Add":" {"},{"Add":" U32 i, skipSize = rankVal[minWeight];"},{"Add":" MEM_writeLE16(&(DElt.sequence), baseSeq);"},{"Add":" DElt.nbBits = (BYTE)(consumed);"},{"Add":" DElt.length = 1;"},{"Add":" for (i = 0; i < skipSize; i++)"},{"Add":" DTable[i] = DElt;"},{"Add":" }"},{"Add":""},{"Add":" /* fill DTable */"},{"Add":" for (s=0; s= 1 */"},{"Add":""},{"Add":" rankVal[weight] += length;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"typedef U32 rankVal_t[HUF_ABSOLUTEMAX_TABLELOG][HUF_ABSOLUTEMAX_TABLELOG + 1];"},{"Add":""},{"Add":"static void HUF_fillDTableX4(HUF_DEltX4* DTable, const U32 targetLog,"},{"Add":" const sortedSymbol_t* sortedList, const U32 sortedListSize,"},{"Add":" const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,"},{"Add":" const U32 nbBitsBaseline)"},{"Add":"{"},{"Add":" U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];"},{"Add":" const int scaleLog = nbBitsBaseline - targetLog; /* note : targetLog >= srcLog, hence scaleLog <= 1 */"},{"Add":" const U32 minBits = nbBitsBaseline - maxWeight;"},{"Add":" U32 s;"},{"Add":""},{"Add":" memcpy(rankVal, rankValOrigin, sizeof(rankVal));"},{"Add":""},{"Add":" /* fill DTable */"},{"Add":" for (s=0; s= minBits) /* enough room for a second symbol */"},{"Add":" {"},{"Add":" U32 sortedRank;"},{"Add":" int minWeight = nbBits + scaleLog;"},{"Add":" if (minWeight < 1) minWeight = 1;"},{"Add":" sortedRank = rankStart[minWeight];"},{"Add":" HUF_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,"},{"Add":" rankValOrigin[nbBits], minWeight,"},{"Add":" sortedList+sortedRank, sortedListSize-sortedRank,"},{"Add":" nbBitsBaseline, symbol);"},{"Add":" }"},{"Add":" else"},{"Add":" {"},{"Add":" U32 i;"},{"Add":" const U32 end = start + length;"},{"Add":" HUF_DEltX4 DElt;"},{"Add":""},{"Add":" MEM_writeLE16(&(DElt.sequence), symbol);"},{"Add":" DElt.nbBits = (BYTE)(nbBits);"},{"Add":" DElt.length = 1;"},{"Add":" for (i = start; i < end; i++)"},{"Add":" DTable[i] = DElt;"},{"Add":" }"},{"Add":" rankVal[weight] += length;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"static size_t HUF_readDTableX4 (U32* DTable, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" BYTE weightList[HUF_MAX_SYMBOL_VALUE + 1];"},{"Add":" sortedSymbol_t sortedSymbol[HUF_MAX_SYMBOL_VALUE + 1];"},{"Add":" U32 rankStats[HUF_ABSOLUTEMAX_TABLELOG + 1] = { 0 };"},{"Add":" U32 rankStart0[HUF_ABSOLUTEMAX_TABLELOG + 2] = { 0 };"},{"Add":" U32* const rankStart = rankStart0+1;"},{"Add":" rankVal_t rankVal;"},{"Add":" U32 tableLog, maxW, sizeOfSort, nbSymbols;"},{"Add":" const U32 memLog = DTable[0];"},{"Add":" const BYTE* ip = (const BYTE*) src;"},{"Add":" size_t iSize = ip[0];"},{"Add":" void* ptr = DTable;"},{"Add":" HUF_DEltX4* const dt = ((HUF_DEltX4*)ptr) + 1;"},{"Add":""},{"Add":" HUF_STATIC_ASSERT(sizeof(HUF_DEltX4) == sizeof(U32)); /* if compilation fails here, assertion is false */"},{"Add":" if (memLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);"},{"Add":" //memset(weightList, 0, sizeof(weightList)); /* is not necessary, even though some analyzer complain ... */"},{"Add":""},{"Add":" iSize = HUF_readStats(weightList, HUF_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);"},{"Add":" if (HUF_isError(iSize)) return iSize;"},{"Add":""},{"Add":" /* check result */"},{"Add":" if (tableLog > memLog) return ERROR(tableLog_tooLarge); /* DTable can't fit code depth */"},{"Add":""},{"Add":" /* find maxWeight */"},{"Add":" for (maxW = tableLog; rankStats[maxW]==0; maxW--)"},{"Add":" {if (!maxW) return ERROR(GENERIC); } /* necessarily finds a solution before maxW==0 */"},{"Add":""},{"Add":" /* Get start index of each weight */"},{"Add":" {"},{"Add":" U32 w, nextRankStart = 0;"},{"Add":" for (w=1; w<=maxW; w++)"},{"Add":" {"},{"Add":" U32 current = nextRankStart;"},{"Add":" nextRankStart += rankStats[w];"},{"Add":" rankStart[w] = current;"},{"Add":" }"},{"Add":" rankStart[0] = nextRankStart; /* put all 0w symbols at the end of sorted list*/"},{"Add":" sizeOfSort = nextRankStart;"},{"Add":" }"},{"Add":""},{"Add":" /* sort symbols by weight */"},{"Add":" {"},{"Add":" U32 s;"},{"Add":" for (s=0; s> consumed;"},{"Add":" }"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" HUF_fillDTableX4(dt, memLog,"},{"Add":" sortedSymbol, sizeOfSort,"},{"Add":" rankStart0, rankVal, maxW,"},{"Add":" tableLog+1);"},{"Add":""},{"Add":" return iSize;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static U32 HUF_decodeSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" const size_t val = BIT_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */"},{"Add":" memcpy(op, dt+val, 2);"},{"Add":" BIT_skipBits(DStream, dt[val].nbBits);"},{"Add":" return dt[val].length;"},{"Add":"}"},{"Add":""},{"Add":"static U32 HUF_decodeLastSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)"},{"Add":"{"},{"Add":" const size_t val = BIT_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */"},{"Add":" memcpy(op, dt+val, 1);"},{"Add":" if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits);"},{"Add":" else"},{"Add":" {"},{"Add":" if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8))"},{"Add":" {"},{"Add":" BIT_skipBits(DStream, dt[val].nbBits);"},{"Add":" if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))"},{"Add":" DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8); /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */"},{"Add":" }"},{"Add":" }"},{"Add":" return 1;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \\"},{"Add":" ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \\"},{"Add":" ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"#define HUF_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \\"},{"Add":" if (MEM_64bits()) \\"},{"Add":" ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)"},{"Add":""},{"Add":"static inline size_t HUF_decodeStreamX4(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const HUF_DEltX4* const dt, const U32 dtLog)"},{"Add":"{"},{"Add":" BYTE* const pStart = p;"},{"Add":""},{"Add":" /* up to 8 symbols at a time */"},{"Add":" while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd-7))"},{"Add":" {"},{"Add":" HUF_DECODE_SYMBOLX4_2(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX4_1(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX4_2(p, bitDPtr);"},{"Add":" HUF_DECODE_SYMBOLX4_0(p, bitDPtr);"},{"Add":" }"},{"Add":""},{"Add":" /* closer to the end */"},{"Add":" while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-2))"},{"Add":" HUF_DECODE_SYMBOLX4_0(p, bitDPtr);"},{"Add":""},{"Add":" while (p <= pEnd-2)"},{"Add":" HUF_DECODE_SYMBOLX4_0(p, bitDPtr); /* no need to reload : reached the end of DStream */"},{"Add":""},{"Add":" if (p < pEnd)"},{"Add":" p += HUF_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);"},{"Add":""},{"Add":" return p-pStart;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":""},{"Add":"static size_t HUF_decompress4X4_usingDTable("},{"Add":" void* dst, size_t dstSize,"},{"Add":" const void* cSrc, size_t cSrcSize,"},{"Add":" const U32* DTable)"},{"Add":"{"},{"Add":" if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */"},{"Add":""},{"Add":" {"},{"Add":" const BYTE* const istart = (const BYTE*) cSrc;"},{"Add":" BYTE* const ostart = (BYTE*) dst;"},{"Add":" BYTE* const oend = ostart + dstSize;"},{"Add":""},{"Add":" const void* ptr = DTable;"},{"Add":" const HUF_DEltX4* const dt = ((const HUF_DEltX4*)ptr) +1;"},{"Add":" const U32 dtLog = DTable[0];"},{"Add":" size_t errorCode;"},{"Add":""},{"Add":" /* Init */"},{"Add":" BIT_DStream_t bitD1;"},{"Add":" BIT_DStream_t bitD2;"},{"Add":" BIT_DStream_t bitD3;"},{"Add":" BIT_DStream_t bitD4;"},{"Add":" const size_t length1 = MEM_readLE16(istart);"},{"Add":" const size_t length2 = MEM_readLE16(istart+2);"},{"Add":" const size_t length3 = MEM_readLE16(istart+4);"},{"Add":" size_t length4;"},{"Add":" const BYTE* const istart1 = istart + 6; /* jumpTable */"},{"Add":" const BYTE* const istart2 = istart1 + length1;"},{"Add":" const BYTE* const istart3 = istart2 + length2;"},{"Add":" const BYTE* const istart4 = istart3 + length3;"},{"Add":" const size_t segmentSize = (dstSize+3) / 4;"},{"Add":" BYTE* const opStart2 = ostart + segmentSize;"},{"Add":" BYTE* const opStart3 = opStart2 + segmentSize;"},{"Add":" BYTE* const opStart4 = opStart3 + segmentSize;"},{"Add":" BYTE* op1 = ostart;"},{"Add":" BYTE* op2 = opStart2;"},{"Add":" BYTE* op3 = opStart3;"},{"Add":" BYTE* op4 = opStart4;"},{"Add":" U32 endSignal;"},{"Add":""},{"Add":" length4 = cSrcSize - (length1 + length2 + length3 + 6);"},{"Add":" if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */"},{"Add":" errorCode = BIT_initDStream(&bitD1, istart1, length1);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD2, istart2, length2);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD3, istart3, length3);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":" errorCode = BIT_initDStream(&bitD4, istart4, length4);"},{"Add":" if (HUF_isError(errorCode)) return errorCode;"},{"Add":""},{"Add":" /* 16-32 symbols per loop (4-8 symbols per stream) */"},{"Add":" endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);"},{"Add":" for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )"},{"Add":" {"},{"Add":" HUF_DECODE_SYMBOLX4_2(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX4_1(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX4_1(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX4_1(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX4_1(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX4_2(op4, &bitD4);"},{"Add":" HUF_DECODE_SYMBOLX4_0(op1, &bitD1);"},{"Add":" HUF_DECODE_SYMBOLX4_0(op2, &bitD2);"},{"Add":" HUF_DECODE_SYMBOLX4_0(op3, &bitD3);"},{"Add":" HUF_DECODE_SYMBOLX4_0(op4, &bitD4);"},{"Add":""},{"Add":" endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);"},{"Add":" }"},{"Add":""},{"Add":" /* check corruption */"},{"Add":" if (op1 > opStart2) return ERROR(corruption_detected);"},{"Add":" if (op2 > opStart3) return ERROR(corruption_detected);"},{"Add":" if (op3 > opStart4) return ERROR(corruption_detected);"},{"Add":" /* note : op4 supposed already verified within main loop */"},{"Add":""},{"Add":" /* finish bitStreams one by one */"},{"Add":" HUF_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);"},{"Add":" HUF_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);"},{"Add":" HUF_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);"},{"Add":" HUF_decodeStreamX4(op4, &bitD4, oend, dt, dtLog);"},{"Add":""},{"Add":" /* check */"},{"Add":" endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);"},{"Add":" if (!endSignal) return ERROR(corruption_detected);"},{"Add":""},{"Add":" /* decoded size */"},{"Add":" return dstSize;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)"},{"Add":"{"},{"Add":" HUF_CREATE_STATIC_DTABLEX4(DTable, HUF_MAX_TABLELOG);"},{"Add":" const BYTE* ip = (const BYTE*) cSrc;"},{"Add":""},{"Add":" size_t hSize = HUF_readDTableX4 (DTable, cSrc, cSrcSize);"},{"Add":" if (HUF_isError(hSize)) return hSize;"},{"Add":" if (hSize >= cSrcSize) return ERROR(srcSize_wrong);"},{"Add":" ip += hSize;"},{"Add":" cSrcSize -= hSize;"},{"Add":""},{"Add":" return HUF_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"/**********************************/"},{"Add":"/* quad-symbol decoding */"},{"Add":"/**********************************/"},{"Add":"typedef struct { BYTE nbBits; BYTE nbBytes; } HUF_DDescX6;"},{"Add":"typedef union { BYTE byte[4]; U32 sequence; } HUF_DSeqX6;"},{"Add":""},{"Add":"/* recursive, up to level 3; may benefit from

…

Dependencies

Change contents