diff --git a/lib/legacy/zstd_v07.c b/lib/legacy/zstd_v07.c index cdc56288c..629db03ec 100644 --- a/lib/legacy/zstd_v07.c +++ b/lib/legacy/zstd_v07.c @@ -2,4489 +2,18 @@ * Copyright (c) Yann Collet, Meta Platforms, Inc. and affiliates. * All rights reserved. * - * This source code is licensed under both the BSD-style license (found in the + * This source code is licensed under both the BSD-style license found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). - * You may select, at your option, one of the above-listed licenses. + * You may select, at your option, one or both licenses. */ - -/*- Dependencies -*/ -#include /* size_t, ptrdiff_t */ -#include /* memcpy */ -#include /* malloc, free, qsort */ - -#ifndef XXH_STATIC_LINKING_ONLY -# define XXH_STATIC_LINKING_ONLY /* XXH64_state_t */ -#endif -#include "../common/xxhash.h" /* XXH64_* */ +#include /* size_t */ #include "zstd_v07.h" - -#define FSEv07_STATIC_LINKING_ONLY /* FSEv07_MIN_TABLELOG */ -#define HUFv07_STATIC_LINKING_ONLY /* HUFv07_TABLELOG_ABSOLUTEMAX */ -#define ZSTDv07_STATIC_LINKING_ONLY - #include "../common/compiler.h" #include "../common/error_private.h" - -#ifdef ZSTDv07_STATIC_LINKING_ONLY - -/* ==================================================================================== - * The definitions in this section are considered experimental. - * They should never be used with a dynamic library, as they may change in the future. - * They are provided for advanced usages. - * Use them only in association with static linking. - * ==================================================================================== */ - -/*--- Constants ---*/ -#define ZSTDv07_MAGIC_SKIPPABLE_START 0x184D2A50U - -#define ZSTDv07_WINDOWLOG_MAX_32 25 -#define ZSTDv07_WINDOWLOG_MAX_64 27 -#define ZSTDv07_WINDOWLOG_MAX ((U32)(MEM_32bits() ? ZSTDv07_WINDOWLOG_MAX_32 : ZSTDv07_WINDOWLOG_MAX_64)) -#define ZSTDv07_WINDOWLOG_MIN 18 -#define ZSTDv07_CHAINLOG_MAX (ZSTDv07_WINDOWLOG_MAX+1) -#define ZSTDv07_CHAINLOG_MIN 4 -#define ZSTDv07_HASHLOG_MAX ZSTDv07_WINDOWLOG_MAX -#define ZSTDv07_HASHLOG_MIN 12 -#define ZSTDv07_HASHLOG3_MAX 17 -#define ZSTDv07_SEARCHLOG_MAX (ZSTDv07_WINDOWLOG_MAX-1) -#define ZSTDv07_SEARCHLOG_MIN 1 -#define ZSTDv07_SEARCHLENGTH_MAX 7 -#define ZSTDv07_SEARCHLENGTH_MIN 3 -#define ZSTDv07_TARGETLENGTH_MIN 4 -#define ZSTDv07_TARGETLENGTH_MAX 999 - -#define ZSTDv07_FRAMEHEADERSIZE_MAX 18 /* for static allocation */ -static const size_t ZSTDv07_frameHeaderSize_min = 5; -static const size_t ZSTDv07_frameHeaderSize_max = ZSTDv07_FRAMEHEADERSIZE_MAX; -static const size_t ZSTDv07_skippableHeaderSize = 8; /* magic number + skippable frame length */ - - -/* custom memory allocation functions */ -typedef void* (*ZSTDv07_allocFunction) (void* opaque, size_t size); -typedef void (*ZSTDv07_freeFunction) (void* opaque, void* address); -typedef struct { ZSTDv07_allocFunction customAlloc; ZSTDv07_freeFunction customFree; void* opaque; } ZSTDv07_customMem; - - -/*--- Advanced Decompression functions ---*/ - -/*! ZSTDv07_estimateDCtxSize() : - * Gives the potential amount of memory allocated to create a ZSTDv07_DCtx */ -ZSTDLIBv07_API size_t ZSTDv07_estimateDCtxSize(void); - -/*! ZSTDv07_createDCtx_advanced() : - * Create a ZSTD decompression context using external alloc and free functions */ -ZSTDLIBv07_API ZSTDv07_DCtx* ZSTDv07_createDCtx_advanced(ZSTDv07_customMem customMem); - -/*! ZSTDv07_sizeofDCtx() : - * Gives the amount of memory used by a given ZSTDv07_DCtx */ -ZSTDLIBv07_API size_t ZSTDv07_sizeofDCtx(const ZSTDv07_DCtx* dctx); - - -/* ****************************************************************** -* Buffer-less streaming functions (synchronous mode) -********************************************************************/ - -ZSTDLIBv07_API size_t ZSTDv07_decompressBegin(ZSTDv07_DCtx* dctx); -ZSTDLIBv07_API size_t ZSTDv07_decompressBegin_usingDict(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize); -ZSTDLIBv07_API void ZSTDv07_copyDCtx(ZSTDv07_DCtx* dctx, const ZSTDv07_DCtx* preparedDCtx); - -ZSTDLIBv07_API size_t ZSTDv07_nextSrcSizeToDecompress(ZSTDv07_DCtx* dctx); -ZSTDLIBv07_API size_t ZSTDv07_decompressContinue(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); - -/* - Buffer-less streaming decompression (synchronous mode) - - A ZSTDv07_DCtx object is required to track streaming operations. - Use ZSTDv07_createDCtx() / ZSTDv07_freeDCtx() to manage it. - A ZSTDv07_DCtx object can be re-used multiple times. - - First optional operation is to retrieve frame parameters, using ZSTDv07_getFrameParams(), which doesn't consume the input. - It can provide the minimum size of rolling buffer required to properly decompress data (`windowSize`), - and optionally the final size of uncompressed content. - (Note : content size is an optional info that may not be present. 0 means : content size unknown) - Frame parameters are extracted from the beginning of compressed frame. - 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) - If `srcSize` is too small for operation to succeed, function will return the minimum size it requires to produce a result. - Result : 0 when successful, it means the ZSTDv07_frameParams structure has been filled. - >0 : means there is not enough data into `src`. Provides the expected size to successfully decode header. - errorCode, which can be tested using ZSTDv07_isError() - - Start decompression, with ZSTDv07_decompressBegin() or ZSTDv07_decompressBegin_usingDict(). - Alternatively, you can copy a prepared context, using ZSTDv07_copyDCtx(). - - Then use ZSTDv07_nextSrcSizeToDecompress() and ZSTDv07_decompressContinue() alternatively. - ZSTDv07_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTDv07_decompressContinue(). - ZSTDv07_decompressContinue() requires this exact amount of bytes, or it will fail. - - @result of ZSTDv07_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity). - It can be zero, which is not an error; it just means ZSTDv07_decompressContinue() has decoded some header. - - ZSTDv07_decompressContinue() needs previous data blocks during decompression, up to `windowSize`. - They should preferably be located contiguously, prior to current block. - Alternatively, a round buffer of sufficient size is also possible. Sufficient size is determined by frame parameters. - ZSTDv07_decompressContinue() is very sensitive to contiguity, - if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place, - or that previous contiguous segment is large enough to properly handle maximum back-reference. - - A frame is fully decoded when ZSTDv07_nextSrcSizeToDecompress() returns zero. - Context can then be reset to start a new decompression. - - - == Special case : skippable frames == - - Skippable frames allow the integration of user-defined data into a flow of concatenated frames. - Skippable frames will be ignored (skipped) by a decompressor. The format of skippable frame is following: - a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F - b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits - c) Frame Content - any content (User Data) of length equal to Frame Size - For skippable frames ZSTDv07_decompressContinue() always returns 0. - For skippable frames ZSTDv07_getFrameParams() returns fparamsPtr->windowLog==0 what means that a frame is skippable. - It also returns Frame Size as fparamsPtr->frameContentSize. -*/ - - -/* ************************************** -* Block functions -****************************************/ -/*! Block functions produce and decode raw zstd blocks, without frame metadata. - Frame metadata cost is typically ~18 bytes, which can be non-negligible for very small blocks (< 100 bytes). - User will have to take in charge required information to regenerate data, such as compressed and content sizes. - - A few rules to respect : - - Compressing and decompressing require a context structure - + Use ZSTDv07_createCCtx() and ZSTDv07_createDCtx() - - It is necessary to init context before starting - + compression : ZSTDv07_compressBegin() - + decompression : ZSTDv07_decompressBegin() - + variants _usingDict() are also allowed - + copyCCtx() and copyDCtx() work too - - Block size is limited, it must be <= ZSTDv07_getBlockSizeMax() - + If you need to compress more, cut data into multiple blocks - + Consider using the regular ZSTDv07_compress() instead, as frame metadata costs become negligible when source size is large. - - When a block is considered not compressible enough, ZSTDv07_compressBlock() result will be zero. - In which case, nothing is produced into `dst`. - + User must test for such outcome and deal directly with uncompressed data - + ZSTDv07_decompressBlock() doesn't accept uncompressed data as input !!! - + In case of multiple successive blocks, decoder must be informed of uncompressed block existence to follow proper history. - Use ZSTDv07_insertBlock() in such a case. -*/ - -#define ZSTDv07_BLOCKSIZE_ABSOLUTEMAX (128 * 1024) /* define, for static allocation */ -ZSTDLIBv07_API size_t ZSTDv07_decompressBlock(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); -ZSTDLIBv07_API size_t ZSTDv07_insertBlock(ZSTDv07_DCtx* dctx, const void* blockStart, size_t blockSize); /**< insert block into `dctx` history. Useful for uncompressed blocks */ - - -#endif /* ZSTDv07_STATIC_LINKING_ONLY */ - - -/* ****************************************************************** - mem.h - low-level memory access routines - Copyright (C) 2013-2015, Yann Collet. - - BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php) - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are - met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following disclaimer - in the documentation and/or other materials provided with the - distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - You can contact the author at : - - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy - - Public forum : https://groups.google.com/forum/#!forum/lz4c -****************************************************************** */ -#ifndef MEM_H_MODULE -#define MEM_H_MODULE - -#if defined (__cplusplus) -extern "C" { -#endif - -/*-**************************************** -* Compiler specifics -******************************************/ -#if defined(_MSC_VER) /* Visual Studio */ -# include /* _byteswap_ulong */ -# include /* _byteswap_* */ -#endif - - -/*-************************************************************** -* Basic Types -*****************************************************************/ -#if !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) ) -# if defined(_AIX) -# include -# else -# include /* intptr_t */ -# endif - typedef uint8_t BYTE; - typedef uint16_t U16; - typedef int16_t S16; - typedef uint32_t U32; - typedef int32_t S32; - typedef uint64_t U64; - typedef int64_t S64; -#else - typedef unsigned char BYTE; - typedef unsigned short U16; - typedef signed short S16; - typedef unsigned int U32; - typedef signed int S32; - typedef unsigned long long U64; - typedef signed long long S64; -#endif - - -/*-************************************************************** -* Memory I/O -*****************************************************************/ - -MEM_STATIC unsigned MEM_32bits(void) { return sizeof(size_t)==4; } -MEM_STATIC unsigned MEM_64bits(void) { return sizeof(size_t)==8; } - -MEM_STATIC unsigned MEM_isLittleEndian(void) -{ - const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */ - return one.c[0]; -} - -MEM_STATIC U16 MEM_read16(const void* memPtr) -{ - U16 val; memcpy(&val, memPtr, sizeof(val)); return val; -} - -MEM_STATIC U32 MEM_read32(const void* memPtr) -{ - U32 val; memcpy(&val, memPtr, sizeof(val)); return val; -} - -MEM_STATIC U64 MEM_read64(const void* memPtr) -{ - U64 val; memcpy(&val, memPtr, sizeof(val)); return val; -} - -MEM_STATIC void MEM_write16(void* memPtr, U16 value) -{ - memcpy(memPtr, &value, sizeof(value)); -} - -MEM_STATIC U32 MEM_swap32(U32 in) -{ -#if defined(_MSC_VER) /* Visual Studio */ - return _byteswap_ulong(in); -#elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403) - return __builtin_bswap32(in); -#else - return ((in << 24) & 0xff000000 ) | - ((in << 8) & 0x00ff0000 ) | - ((in >> 8) & 0x0000ff00 ) | - ((in >> 24) & 0x000000ff ); -#endif -} - -MEM_STATIC U64 MEM_swap64(U64 in) -{ -#if defined(_MSC_VER) /* Visual Studio */ - return _byteswap_uint64(in); -#elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403) - return __builtin_bswap64(in); -#else - return ((in << 56) & 0xff00000000000000ULL) | - ((in << 40) & 0x00ff000000000000ULL) | - ((in << 24) & 0x0000ff0000000000ULL) | - ((in << 8) & 0x000000ff00000000ULL) | - ((in >> 8) & 0x00000000ff000000ULL) | - ((in >> 24) & 0x0000000000ff0000ULL) | - ((in >> 40) & 0x000000000000ff00ULL) | - ((in >> 56) & 0x00000000000000ffULL); -#endif -} - - -/*=== Little endian r/w ===*/ - -MEM_STATIC U16 MEM_readLE16(const void* memPtr) -{ - if (MEM_isLittleEndian()) - return MEM_read16(memPtr); - else { - const BYTE* p = (const BYTE*)memPtr; - return (U16)(p[0] + (p[1]<<8)); - } -} - -MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val) -{ - if (MEM_isLittleEndian()) { - MEM_write16(memPtr, val); - } else { - BYTE* p = (BYTE*)memPtr; - p[0] = (BYTE)val; - p[1] = (BYTE)(val>>8); - } -} - -MEM_STATIC U32 MEM_readLE32(const void* memPtr) -{ - if (MEM_isLittleEndian()) - return MEM_read32(memPtr); - else - return MEM_swap32(MEM_read32(memPtr)); -} - - -MEM_STATIC U64 MEM_readLE64(const void* memPtr) -{ - if (MEM_isLittleEndian()) - return MEM_read64(memPtr); - else - return MEM_swap64(MEM_read64(memPtr)); -} - -MEM_STATIC size_t MEM_readLEST(const void* memPtr) -{ - if (MEM_32bits()) - return (size_t)MEM_readLE32(memPtr); - else - return (size_t)MEM_readLE64(memPtr); -} - - - -#if defined (__cplusplus) -} -#endif - -#endif /* MEM_H_MODULE */ -/* ****************************************************************** - bitstream - Part of FSE library - header file (to include) - Copyright (C) 2013-2016, Yann Collet. - - BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php) - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are - met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following disclaimer - in the documentation and/or other materials provided with the - distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - You can contact the author at : - - Source repository : https://github.com/Cyan4973/FiniteStateEntropy -****************************************************************** */ -#ifndef BITSTREAM_H_MODULE -#define BITSTREAM_H_MODULE - -#if defined (__cplusplus) -extern "C" { -#endif - - -/* -* This API consists of small unitary functions, which must be inlined for best performance. -* Since link-time-optimization is not available for all compilers, -* these functions are defined into a .h to be included. -*/ - - -/*========================================= -* Target specific -=========================================*/ -#if defined(__BMI__) && defined(__GNUC__) -# include /* support for bextr (experimental) */ -#endif - -/*-******************************************** -* bitStream decoding API (read backward) -**********************************************/ -typedef struct -{ - size_t bitContainer; - unsigned bitsConsumed; - const char* ptr; - const char* start; -} BITv07_DStream_t; - -typedef enum { BITv07_DStream_unfinished = 0, - BITv07_DStream_endOfBuffer = 1, - BITv07_DStream_completed = 2, - BITv07_DStream_overflow = 3 } BITv07_DStream_status; /* result of BITv07_reloadDStream() */ - /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */ - -MEM_STATIC size_t BITv07_initDStream(BITv07_DStream_t* bitD, const void* srcBuffer, size_t srcSize); -MEM_STATIC size_t BITv07_readBits(BITv07_DStream_t* bitD, unsigned nbBits); -MEM_STATIC BITv07_DStream_status BITv07_reloadDStream(BITv07_DStream_t* bitD); -MEM_STATIC unsigned BITv07_endOfDStream(const BITv07_DStream_t* bitD); - - - -/*-**************************************** -* unsafe API -******************************************/ -MEM_STATIC size_t BITv07_readBitsFast(BITv07_DStream_t* bitD, unsigned nbBits); -/* faster, but works only if nbBits >= 1 */ - - - -/*-************************************************************** -* Internal functions -****************************************************************/ -MEM_STATIC unsigned BITv07_highbit32 (U32 val) -{ -# if defined(_MSC_VER) /* Visual */ - unsigned long r; - return _BitScanReverse(&r, val) ? (unsigned)r : 0; -# elif defined(__GNUC__) && (__GNUC__ >= 3) /* Use GCC Intrinsic */ - return __builtin_clz (val) ^ 31; -# else /* Software version */ - 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 }; - U32 v = val; - v |= v >> 1; - v |= v >> 2; - v |= v >> 4; - v |= v >> 8; - v |= v >> 16; - return DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27]; -# endif -} - - - -/*-******************************************************** -* bitStream decoding -**********************************************************/ -/*! BITv07_initDStream() : -* Initialize a BITv07_DStream_t. -* `bitD` : a pointer to an already allocated BITv07_DStream_t structure. -* `srcSize` must be the *exact* size of the bitStream, in bytes. -* @return : size of stream (== srcSize) or an errorCode if a problem is detected -*/ -MEM_STATIC size_t BITv07_initDStream(BITv07_DStream_t* bitD, const void* srcBuffer, size_t srcSize) -{ - if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); } - - if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */ - bitD->start = (const char*)srcBuffer; - bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer); - bitD->bitContainer = MEM_readLEST(bitD->ptr); - { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; - bitD->bitsConsumed = lastByte ? 8 - BITv07_highbit32(lastByte) : 0; - if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ } - } else { - bitD->start = (const char*)srcBuffer; - bitD->ptr = bitD->start; - bitD->bitContainer = *(const BYTE*)(bitD->start); - switch(srcSize) - { - case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);/* fall-through */ - case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);/* fall-through */ - case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);/* fall-through */ - case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24; /* fall-through */ - case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16; /* fall-through */ - case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) << 8; /* fall-through */ - default: break; - } - { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; - bitD->bitsConsumed = lastByte ? 8 - BITv07_highbit32(lastByte) : 0; - if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ } - bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8; - } - - return srcSize; -} - - - MEM_STATIC size_t BITv07_lookBits(const BITv07_DStream_t* bitD, U32 nbBits) -{ - U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1; - return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask); -} - -/*! BITv07_lookBitsFast() : -* unsafe version; only works if nbBits >= 1 */ -MEM_STATIC size_t BITv07_lookBitsFast(const BITv07_DStream_t* bitD, U32 nbBits) -{ - U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1; - return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask); -} - -MEM_STATIC void BITv07_skipBits(BITv07_DStream_t* bitD, U32 nbBits) -{ - bitD->bitsConsumed += nbBits; -} - -MEM_STATIC size_t BITv07_readBits(BITv07_DStream_t* bitD, U32 nbBits) -{ - size_t const value = BITv07_lookBits(bitD, nbBits); - BITv07_skipBits(bitD, nbBits); - return value; -} - -/*! BITv07_readBitsFast() : -* unsafe version; only works if nbBits >= 1 */ -MEM_STATIC size_t BITv07_readBitsFast(BITv07_DStream_t* bitD, U32 nbBits) -{ - size_t const value = BITv07_lookBitsFast(bitD, nbBits); - BITv07_skipBits(bitD, nbBits); - return value; -} - -MEM_STATIC BITv07_DStream_status BITv07_reloadDStream(BITv07_DStream_t* bitD) -{ - if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* should not happen => corruption detected */ - return BITv07_DStream_overflow; - - if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) { - bitD->ptr -= bitD->bitsConsumed >> 3; - bitD->bitsConsumed &= 7; - bitD->bitContainer = MEM_readLEST(bitD->ptr); - return BITv07_DStream_unfinished; - } - if (bitD->ptr == bitD->start) { - if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BITv07_DStream_endOfBuffer; - return BITv07_DStream_completed; - } - { U32 nbBytes = bitD->bitsConsumed >> 3; - BITv07_DStream_status result = BITv07_DStream_unfinished; - if (bitD->ptr - nbBytes < bitD->start) { - nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ - result = BITv07_DStream_endOfBuffer; - } - bitD->ptr -= nbBytes; - bitD->bitsConsumed -= nbBytes*8; - bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD) */ - return result; - } -} - -/*! BITv07_endOfDStream() : -* @return Tells if DStream has exactly reached its end (all bits consumed). -*/ -MEM_STATIC unsigned BITv07_endOfDStream(const BITv07_DStream_t* DStream) -{ - return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8)); -} - -#if defined (__cplusplus) -} -#endif - -#endif /* BITSTREAM_H_MODULE */ -/* ****************************************************************** - FSE : Finite State Entropy codec - Public Prototypes declaration - Copyright (C) 2013-2016, Yann Collet. - - BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php) - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are - met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following disclaimer - in the documentation and/or other materials provided with the - distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - You can contact the author at : - - Source repository : https://github.com/Cyan4973/FiniteStateEntropy -****************************************************************** */ -#ifndef FSEv07_H -#define FSEv07_H - -#if defined (__cplusplus) -extern "C" { -#endif - - - -/*-**************************************** -* FSE simple functions -******************************************/ - -/*! FSEv07_decompress(): - Decompress FSE data from buffer 'cSrc', of size 'cSrcSize', - into already allocated destination buffer 'dst', of size 'dstCapacity'. - @return : size of regenerated data (<= maxDstSize), - or an error code, which can be tested using FSEv07_isError() . - - ** Important ** : FSEv07_decompress() does not decompress non-compressible nor RLE data !!! - Why ? : making this distinction requires a header. - Header management is intentionally delegated to the user layer, which can better manage special cases. -*/ -size_t FSEv07_decompress(void* dst, size_t dstCapacity, - const void* cSrc, size_t cSrcSize); - - -/* Error Management */ -unsigned FSEv07_isError(size_t code); /* tells if a return value is an error code */ -const char* FSEv07_getErrorName(size_t code); /* provides error code string (useful for debugging) */ - - -/*-***************************************** -* FSE detailed API -******************************************/ -/*! -FSEv07_decompress() does the following: -1. read normalized counters with readNCount() -2. build decoding table 'DTable' from normalized counters -3. decode the data stream using decoding table 'DTable' - -The following API allows targeting specific sub-functions for advanced tasks. -For example, it's possible to compress several blocks using the same 'CTable', -or to save and provide normalized distribution using external method. -*/ - - -/* *** DECOMPRESSION *** */ - -/*! FSEv07_readNCount(): - Read compactly saved 'normalizedCounter' from 'rBuffer'. - @return : size read from 'rBuffer', - or an errorCode, which can be tested using FSEv07_isError(). - maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */ -size_t FSEv07_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize); - -/*! Constructor and Destructor of FSEv07_DTable. - Note that its size depends on 'tableLog' */ -typedef unsigned FSEv07_DTable; /* don't allocate that. It's just a way to be more restrictive than void* */ -FSEv07_DTable* FSEv07_createDTable(unsigned tableLog); -void FSEv07_freeDTable(FSEv07_DTable* dt); - -/*! FSEv07_buildDTable(): - Builds 'dt', which must be already allocated, using FSEv07_createDTable(). - return : 0, or an errorCode, which can be tested using FSEv07_isError() */ -size_t FSEv07_buildDTable (FSEv07_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog); - -/*! FSEv07_decompress_usingDTable(): - Decompress compressed source `cSrc` of size `cSrcSize` using `dt` - into `dst` which must be already allocated. - @return : size of regenerated data (necessarily <= `dstCapacity`), - or an errorCode, which can be tested using FSEv07_isError() */ -size_t FSEv07_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSEv07_DTable* dt); - -/*! -Tutorial : ----------- -(Note : these functions only decompress FSE-compressed blocks. - If block is uncompressed, use memcpy() instead - If block is a single repeated byte, use memset() instead ) - -The first step is to obtain the normalized frequencies of symbols. -This can be performed by FSEv07_readNCount() if it was saved using FSEv07_writeNCount(). -'normalizedCounter' must be already allocated, and have at least 'maxSymbolValuePtr[0]+1' cells of signed short. -In practice, that means it's necessary to know 'maxSymbolValue' beforehand, -or size the table to handle worst case situations (typically 256). -FSEv07_readNCount() will provide 'tableLog' and 'maxSymbolValue'. -The result of FSEv07_readNCount() is the number of bytes read from 'rBuffer'. -Note that 'rBufferSize' must be at least 4 bytes, even if useful information is less than that. -If there is an error, the function will return an error code, which can be tested using FSEv07_isError(). - -The next step is to build the decompression tables 'FSEv07_DTable' from 'normalizedCounter'. -This is performed by the function FSEv07_buildDTable(). -The space required by 'FSEv07_DTable' must be already allocated using FSEv07_createDTable(). -If there is an error, the function will return an error code, which can be tested using FSEv07_isError(). - -`FSEv07_DTable` can then be used to decompress `cSrc`, with FSEv07_decompress_usingDTable(). -`cSrcSize` must be strictly correct, otherwise decompression will fail. -FSEv07_decompress_usingDTable() result will tell how many bytes were regenerated (<=`dstCapacity`). -If there is an error, the function will return an error code, which can be tested using FSEv07_isError(). (ex: dst buffer too small) -*/ - - -#ifdef FSEv07_STATIC_LINKING_ONLY - - -/* ***************************************** -* Static allocation -*******************************************/ -/* FSE buffer bounds */ -#define FSEv07_NCOUNTBOUND 512 -#define FSEv07_BLOCKBOUND(size) (size + (size>>7)) - -/* It is possible to statically allocate FSE CTable/DTable as a table of unsigned using below macros */ -#define FSEv07_DTABLE_SIZE_U32(maxTableLog) (1 + (1<= 1 (otherwise, result will be corrupted) */ - - -/* ====== Decompression ====== */ - -typedef struct { - U16 tableLog; - U16 fastMode; -} FSEv07_DTableHeader; /* sizeof U32 */ - -typedef struct -{ - unsigned short newState; - unsigned char symbol; - unsigned char nbBits; -} FSEv07_decode_t; /* size == U32 */ - -MEM_STATIC void FSEv07_initDState(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD, const FSEv07_DTable* dt) -{ - const void* ptr = dt; - const FSEv07_DTableHeader* const DTableH = (const FSEv07_DTableHeader*)ptr; - DStatePtr->state = BITv07_readBits(bitD, DTableH->tableLog); - BITv07_reloadDStream(bitD); - DStatePtr->table = dt + 1; -} - -MEM_STATIC BYTE FSEv07_peekSymbol(const FSEv07_DState_t* DStatePtr) -{ - FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state]; - return DInfo.symbol; -} - -MEM_STATIC void FSEv07_updateState(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD) -{ - FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state]; - U32 const nbBits = DInfo.nbBits; - size_t const lowBits = BITv07_readBits(bitD, nbBits); - DStatePtr->state = DInfo.newState + lowBits; -} - -MEM_STATIC BYTE FSEv07_decodeSymbol(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD) -{ - FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state]; - U32 const nbBits = DInfo.nbBits; - BYTE const symbol = DInfo.symbol; - size_t const lowBits = BITv07_readBits(bitD, nbBits); - - DStatePtr->state = DInfo.newState + lowBits; - return symbol; -} - -/*! FSEv07_decodeSymbolFast() : - unsafe, only works if no symbol has a probability > 50% */ -MEM_STATIC BYTE FSEv07_decodeSymbolFast(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD) -{ - FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state]; - U32 const nbBits = DInfo.nbBits; - BYTE const symbol = DInfo.symbol; - size_t const lowBits = BITv07_readBitsFast(bitD, nbBits); - - DStatePtr->state = DInfo.newState + lowBits; - return symbol; -} - - - -#ifndef FSEv07_COMMONDEFS_ONLY - -/* ************************************************************** -* Tuning parameters -****************************************************************/ -/*!MEMORY_USAGE : -* Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.) -* Increasing memory usage improves compression ratio -* Reduced memory usage can improve speed, due to cache effect -* Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */ -#define FSEv07_MAX_MEMORY_USAGE 14 -#define FSEv07_DEFAULT_MEMORY_USAGE 13 - -/*!FSEv07_MAX_SYMBOL_VALUE : -* Maximum symbol value authorized. -* Required for proper stack allocation */ -#define FSEv07_MAX_SYMBOL_VALUE 255 - - -/* ************************************************************** -* template functions type & suffix -****************************************************************/ -#define FSEv07_FUNCTION_TYPE BYTE -#define FSEv07_FUNCTION_EXTENSION -#define FSEv07_DECODE_TYPE FSEv07_decode_t - - -#endif /* !FSEv07_COMMONDEFS_ONLY */ - - -/* *************************************************************** -* Constants -*****************************************************************/ -#define FSEv07_MAX_TABLELOG (FSEv07_MAX_MEMORY_USAGE-2) -#define FSEv07_MAX_TABLESIZE (1U< FSEv07_TABLELOG_ABSOLUTE_MAX -# error "FSEv07_MAX_TABLELOG > FSEv07_TABLELOG_ABSOLUTE_MAX is not supported" -#endif - -#define FSEv07_TABLESTEP(tableSize) ((tableSize>>1) + (tableSize>>3) + 3) - - -#endif /* FSEv07_STATIC_LINKING_ONLY */ - - -#if defined (__cplusplus) -} -#endif - -#endif /* FSEv07_H */ -/* ****************************************************************** - Huffman coder, part of New Generation Entropy library - header file - Copyright (C) 2013-2016, Yann Collet. - - BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php) - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are - met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following disclaimer - in the documentation and/or other materials provided with the - distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - You can contact the author at : - - Source repository : https://github.com/Cyan4973/FiniteStateEntropy -****************************************************************** */ -#ifndef HUFv07_H_298734234 -#define HUFv07_H_298734234 - -#if defined (__cplusplus) -extern "C" { -#endif - - - -/* *** simple functions *** */ -/** -HUFv07_decompress() : - Decompress HUF data from buffer 'cSrc', of size 'cSrcSize', - into already allocated buffer 'dst', of minimum size 'dstSize'. - `dstSize` : **must** be the ***exact*** size of original (uncompressed) data. - Note : in contrast with FSE, HUFv07_decompress can regenerate - RLE (cSrcSize==1) and uncompressed (cSrcSize==dstSize) data, - because it knows size to regenerate. - @return : size of regenerated data (== dstSize), - or an error code, which can be tested using HUFv07_isError() -*/ -size_t HUFv07_decompress(void* dst, size_t dstSize, - const void* cSrc, size_t cSrcSize); - - -/* **************************************** -* Tool functions -******************************************/ -#define HUFv07_BLOCKSIZE_MAX (128 * 1024) - -/* Error Management */ -unsigned HUFv07_isError(size_t code); /**< tells if a return value is an error code */ -const char* HUFv07_getErrorName(size_t code); /**< provides error code string (useful for debugging) */ - - -/* *** Advanced function *** */ - - -#ifdef HUFv07_STATIC_LINKING_ONLY - - -/* *** Constants *** */ -#define HUFv07_TABLELOG_ABSOLUTEMAX 16 /* absolute limit of HUFv07_MAX_TABLELOG. Beyond that value, code does not work */ -#define HUFv07_TABLELOG_MAX 12 /* max configured tableLog (for static allocation); can be modified up to HUFv07_ABSOLUTEMAX_TABLELOG */ -#define HUFv07_TABLELOG_DEFAULT 11 /* tableLog by default, when not specified */ -#define HUFv07_SYMBOLVALUE_MAX 255 -#if (HUFv07_TABLELOG_MAX > HUFv07_TABLELOG_ABSOLUTEMAX) -# error "HUFv07_TABLELOG_MAX is too large !" -#endif - - -/* **************************************** -* Static allocation -******************************************/ -/* HUF buffer bounds */ -#define HUFv07_BLOCKBOUND(size) (size + (size>>8) + 8) /* only true if incompressible pre-filtered with fast heuristic */ - -/* static allocation of HUF's DTable */ -typedef U32 HUFv07_DTable; -#define HUFv07_DTABLE_SIZE(maxTableLog) (1 + (1<<(maxTableLog))) -#define HUFv07_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \ - HUFv07_DTable DTable[HUFv07_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1)*0x1000001) } -#define HUFv07_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \ - HUFv07_DTable DTable[HUFv07_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog)*0x1000001) } - - -/* **************************************** -* Advanced decompression functions -******************************************/ -size_t HUFv07_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */ -size_t HUFv07_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */ - -size_t HUFv07_decompress4X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< decodes RLE and uncompressed */ -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 */ -size_t HUFv07_decompress4X2_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */ -size_t HUFv07_decompress4X4_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */ - -size_t HUFv07_decompress1X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); -size_t HUFv07_decompress1X2_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */ -size_t HUFv07_decompress1X4_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */ - - -/* **************************************** -* HUF detailed API -******************************************/ -/*! -The following API allows targeting specific sub-functions for advanced tasks. -For example, it's possible to compress several blocks using the same 'CTable', -or to save and regenerate 'CTable' using external methods. -*/ -/* FSEv07_count() : find it within "fse.h" */ - -/*! HUFv07_readStats() : - Read compact Huffman tree, saved by HUFv07_writeCTable(). - `huffWeight` is destination buffer. - @return : size read from `src` , or an error Code . - Note : Needed by HUFv07_readCTable() and HUFv07_readDTableXn() . */ -size_t HUFv07_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats, - U32* nbSymbolsPtr, U32* tableLogPtr, - const void* src, size_t srcSize); - - -/* -HUFv07_decompress() does the following: -1. select the decompression algorithm (X2, X4) based on pre-computed heuristics -2. build Huffman table from save, using HUFv07_readDTableXn() -3. decode 1 or 4 segments in parallel using HUFv07_decompressSXn_usingDTable -*/ - -/** HUFv07_selectDecoder() : -* Tells which decoder is likely to decode faster, -* based on a set of pre-determined metrics. -* @return : 0==HUFv07_decompress4X2, 1==HUFv07_decompress4X4 . -* Assumption : 0 < cSrcSize < dstSize <= 128 KB */ -U32 HUFv07_selectDecoder (size_t dstSize, size_t cSrcSize); - -size_t HUFv07_readDTableX2 (HUFv07_DTable* DTable, const void* src, size_t srcSize); -size_t HUFv07_readDTableX4 (HUFv07_DTable* DTable, const void* src, size_t srcSize); - -size_t HUFv07_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable); -size_t HUFv07_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable); -size_t HUFv07_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable); - - -/* single stream variants */ -size_t HUFv07_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /* single-symbol decoder */ -size_t HUFv07_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /* double-symbol decoder */ - -size_t HUFv07_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable); -size_t HUFv07_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable); -size_t HUFv07_decompress1X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable); - - -#endif /* HUFv07_STATIC_LINKING_ONLY */ - - -#if defined (__cplusplus) -} -#endif - -#endif /* HUFv07_H_298734234 */ -/* - Common functions of New Generation Entropy library - Copyright (C) 2016, Yann Collet. - - BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php) - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are - met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following disclaimer - in the documentation and/or other materials provided with the - distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - You can contact the author at : - - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy - - Public forum : https://groups.google.com/forum/#!forum/lz4c -*************************************************************************** */ - - - -/*-**************************************** -* FSE Error Management -******************************************/ -unsigned FSEv07_isError(size_t code) { return ERR_isError(code); } - -const char* FSEv07_getErrorName(size_t code) { return ERR_getErrorName(code); } - - -/* ************************************************************** -* HUF Error Management -****************************************************************/ -unsigned HUFv07_isError(size_t code) { return ERR_isError(code); } - -const char* HUFv07_getErrorName(size_t code) { return ERR_getErrorName(code); } - - -/*-************************************************************** -* FSE NCount encoding-decoding -****************************************************************/ -static short FSEv07_abs(short a) { return (short)(a<0 ? -a : a); } - -size_t FSEv07_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr, - const void* headerBuffer, size_t hbSize) -{ - const BYTE* const istart = (const BYTE*) headerBuffer; - const BYTE* const iend = istart + hbSize; - const BYTE* ip = istart; - int nbBits; - int remaining; - int threshold; - U32 bitStream; - int bitCount; - unsigned charnum = 0; - int previous0 = 0; - - if (hbSize < 4) return ERROR(srcSize_wrong); - bitStream = MEM_readLE32(ip); - nbBits = (bitStream & 0xF) + FSEv07_MIN_TABLELOG; /* extract tableLog */ - if (nbBits > FSEv07_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge); - bitStream >>= 4; - bitCount = 4; - *tableLogPtr = nbBits; - remaining = (1<1) && (charnum<=*maxSVPtr)) { - if (previous0) { - unsigned n0 = charnum; - while ((bitStream & 0xFFFF) == 0xFFFF) { - n0+=24; - if (ip < iend-5) { - ip+=2; - bitStream = MEM_readLE32(ip) >> bitCount; - } else { - bitStream >>= 16; - bitCount+=16; - } } - while ((bitStream & 3) == 3) { - n0+=3; - bitStream>>=2; - bitCount+=2; - } - n0 += bitStream & 3; - bitCount += 2; - if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall); - while (charnum < n0) normalizedCounter[charnum++] = 0; - if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) { - ip += bitCount>>3; - bitCount &= 7; - bitStream = MEM_readLE32(ip) >> bitCount; - } - else - bitStream >>= 2; - } - { short const max = (short)((2*threshold-1)-remaining); - short count; - - if ((bitStream & (threshold-1)) < (U32)max) { - count = (short)(bitStream & (threshold-1)); - bitCount += nbBits-1; - } else { - count = (short)(bitStream & (2*threshold-1)); - if (count >= threshold) count -= max; - bitCount += nbBits; - } - - count--; /* extra accuracy */ - remaining -= FSEv07_abs(count); - normalizedCounter[charnum++] = count; - previous0 = !count; - while (remaining < threshold) { - nbBits--; - threshold >>= 1; - } - - if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) { - ip += bitCount>>3; - bitCount &= 7; - } else { - bitCount -= (int)(8 * (iend - 4 - ip)); - ip = iend - 4; - } - bitStream = MEM_readLE32(ip) >> (bitCount & 31); - } } /* while ((remaining>1) && (charnum<=*maxSVPtr)) */ - if (remaining != 1) return ERROR(GENERIC); - *maxSVPtr = charnum-1; - - ip += (bitCount+7)>>3; - if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong); - return ip-istart; -} - - -/*! HUFv07_readStats() : - Read compact Huffman tree, saved by HUFv07_writeCTable(). - `huffWeight` is destination buffer. - @return : size read from `src` , or an error Code . - Note : Needed by HUFv07_readCTable() and HUFv07_readDTableXn() . -*/ -size_t HUFv07_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats, - U32* nbSymbolsPtr, U32* tableLogPtr, - const void* src, size_t srcSize) -{ - U32 weightTotal; - const BYTE* ip = (const BYTE*) src; - size_t iSize; - size_t oSize; - - if (!srcSize) return ERROR(srcSize_wrong); - iSize = ip[0]; - /* memset(huffWeight, 0, hwSize); */ /* is not necessary, even though some analyzer complain ... */ - - if (iSize >= 128) { /* special header */ - if (iSize >= (242)) { /* RLE */ - static U32 l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 }; - oSize = l[iSize-242]; - memset(huffWeight, 1, hwSize); - iSize = 0; - } - else { /* Incompressible */ - oSize = iSize - 127; - iSize = ((oSize+1)/2); - if (iSize+1 > srcSize) return ERROR(srcSize_wrong); - if (oSize >= hwSize) return ERROR(corruption_detected); - ip += 1; - { U32 n; - for (n=0; n> 4; - huffWeight[n+1] = ip[n/2] & 15; - } } } } - else { /* header compressed with FSE (normal case) */ - if (iSize+1 > srcSize) return ERROR(srcSize_wrong); - oSize = FSEv07_decompress(huffWeight, hwSize-1, ip+1, iSize); /* max (hwSize-1) values decoded, as last one is implied */ - if (FSEv07_isError(oSize)) return oSize; - } - - /* collect weight stats */ - memset(rankStats, 0, (HUFv07_TABLELOG_ABSOLUTEMAX + 1) * sizeof(U32)); - weightTotal = 0; - { U32 n; for (n=0; n= HUFv07_TABLELOG_ABSOLUTEMAX) return ERROR(corruption_detected); - rankStats[huffWeight[n]]++; - weightTotal += (1 << huffWeight[n]) >> 1; - } } - if (weightTotal == 0) return ERROR(corruption_detected); - - /* get last non-null symbol weight (implied, total must be 2^n) */ - { U32 const tableLog = BITv07_highbit32(weightTotal) + 1; - if (tableLog > HUFv07_TABLELOG_ABSOLUTEMAX) return ERROR(corruption_detected); - *tableLogPtr = tableLog; - /* determine last weight */ - { U32 const total = 1 << tableLog; - U32 const rest = total - weightTotal; - U32 const verif = 1 << BITv07_highbit32(rest); - U32 const lastWeight = BITv07_highbit32(rest) + 1; - if (verif != rest) return ERROR(corruption_detected); /* last value must be a clean power of 2 */ - huffWeight[oSize] = (BYTE)lastWeight; - rankStats[lastWeight]++; - } } - - /* check tree construction validity */ - if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected); /* by construction : at least 2 elts of rank 1, must be even */ - - /* results */ - *nbSymbolsPtr = (U32)(oSize+1); - return iSize+1; -} -/* ****************************************************************** - FSE : Finite State Entropy decoder - Copyright (C) 2013-2015, Yann Collet. - - BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php) - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are - met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following disclaimer - in the documentation and/or other materials provided with the - distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - You can contact the author at : - - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy - - Public forum : https://groups.google.com/forum/#!forum/lz4c -****************************************************************** */ - - -/* ************************************************************** -* Compiler specifics -****************************************************************/ -#ifdef _MSC_VER /* Visual Studio */ -# define FORCE_INLINE static __forceinline -# include /* For Visual 2005 */ -# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ -# pragma warning(disable : 4214) /* disable: C4214: non-int bitfields */ -#else -# if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */ -# ifdef __GNUC__ -# define FORCE_INLINE static inline __attribute__((always_inline)) -# else -# define FORCE_INLINE static inline -# endif -# else -# define FORCE_INLINE static -# endif /* __STDC_VERSION__ */ -#endif - - -/* ************************************************************** -* Error Management -****************************************************************/ -#define FSEv07_isError ERR_isError -#define FSEv07_STATIC_ASSERT(c) { enum { FSEv07_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */ - - -/* ************************************************************** -* Complex types -****************************************************************/ -typedef U32 DTable_max_t[FSEv07_DTABLE_SIZE_U32(FSEv07_MAX_TABLELOG)]; - - -/* ************************************************************** -* Templates -****************************************************************/ -/* - designed to be included - for type-specific functions (template emulation in C) - Objective is to write these functions only once, for improved maintenance -*/ - -/* safety checks */ -#ifndef FSEv07_FUNCTION_EXTENSION -# error "FSEv07_FUNCTION_EXTENSION must be defined" -#endif -#ifndef FSEv07_FUNCTION_TYPE -# error "FSEv07_FUNCTION_TYPE must be defined" -#endif - -/* Function names */ -#define FSEv07_CAT(X,Y) X##Y -#define FSEv07_FUNCTION_NAME(X,Y) FSEv07_CAT(X,Y) -#define FSEv07_TYPE_NAME(X,Y) FSEv07_CAT(X,Y) - - -/* Function templates */ -FSEv07_DTable* FSEv07_createDTable (unsigned tableLog) -{ - if (tableLog > FSEv07_TABLELOG_ABSOLUTE_MAX) tableLog = FSEv07_TABLELOG_ABSOLUTE_MAX; - return (FSEv07_DTable*)malloc( FSEv07_DTABLE_SIZE_U32(tableLog) * sizeof (U32) ); -} - -void FSEv07_freeDTable (FSEv07_DTable* dt) -{ - free(dt); -} - -size_t FSEv07_buildDTable(FSEv07_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog) -{ - void* const tdPtr = dt+1; /* because *dt is unsigned, 32-bits aligned on 32-bits */ - FSEv07_DECODE_TYPE* const tableDecode = (FSEv07_DECODE_TYPE*) (tdPtr); - U16 symbolNext[FSEv07_MAX_SYMBOL_VALUE+1]; - - U32 const maxSV1 = maxSymbolValue + 1; - U32 const tableSize = 1 << tableLog; - U32 highThreshold = tableSize-1; - - /* Sanity Checks */ - if (maxSymbolValue > FSEv07_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge); - if (tableLog > FSEv07_MAX_TABLELOG) return ERROR(tableLog_tooLarge); - - /* Init, lay down lowprob symbols */ - { FSEv07_DTableHeader DTableH; - DTableH.tableLog = (U16)tableLog; - DTableH.fastMode = 1; - { S16 const largeLimit= (S16)(1 << (tableLog-1)); - U32 s; - for (s=0; s= largeLimit) DTableH.fastMode=0; - symbolNext[s] = normalizedCounter[s]; - } } } - memcpy(dt, &DTableH, sizeof(DTableH)); - } - - /* Spread symbols */ - { U32 const tableMask = tableSize-1; - U32 const step = FSEv07_TABLESTEP(tableSize); - U32 s, position = 0; - for (s=0; s highThreshold) position = (position + step) & tableMask; /* lowprob area */ - } } - - if (position!=0) return ERROR(GENERIC); /* position must reach all cells once, otherwise normalizedCounter is incorrect */ - } - - /* Build Decoding table */ - { U32 u; - for (u=0; utableLog = 0; - DTableH->fastMode = 0; - - cell->newState = 0; - cell->symbol = symbolValue; - cell->nbBits = 0; - - return 0; -} - - -size_t FSEv07_buildDTable_raw (FSEv07_DTable* dt, unsigned nbBits) -{ - void* ptr = dt; - FSEv07_DTableHeader* const DTableH = (FSEv07_DTableHeader*)ptr; - void* dPtr = dt + 1; - FSEv07_decode_t* const dinfo = (FSEv07_decode_t*)dPtr; - const unsigned tableSize = 1 << nbBits; - const unsigned tableMask = tableSize - 1; - const unsigned maxSV1 = tableMask+1; - unsigned s; - - /* Sanity checks */ - if (nbBits < 1) return ERROR(GENERIC); /* min size */ - - /* Build Decoding Table */ - DTableH->tableLog = (U16)nbBits; - DTableH->fastMode = 1; - for (s=0; s sizeof(bitD.bitContainer)*8) /* This test must be static */ - BITv07_reloadDStream(&bitD); - - op[1] = FSEv07_GETSYMBOL(&state2); - - if (FSEv07_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */ - { if (BITv07_reloadDStream(&bitD) > BITv07_DStream_unfinished) { op+=2; break; } } - - op[2] = FSEv07_GETSYMBOL(&state1); - - if (FSEv07_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */ - BITv07_reloadDStream(&bitD); - - op[3] = FSEv07_GETSYMBOL(&state2); - } - - /* tail */ - /* note : BITv07_reloadDStream(&bitD) >= FSEv07_DStream_partiallyFilled; Ends at exactly BITv07_DStream_completed */ - while (1) { - if (op>(omax-2)) return ERROR(dstSize_tooSmall); - - *op++ = FSEv07_GETSYMBOL(&state1); - - if (BITv07_reloadDStream(&bitD)==BITv07_DStream_overflow) { - *op++ = FSEv07_GETSYMBOL(&state2); - break; - } - - if (op>(omax-2)) return ERROR(dstSize_tooSmall); - - *op++ = FSEv07_GETSYMBOL(&state2); - - if (BITv07_reloadDStream(&bitD)==BITv07_DStream_overflow) { - *op++ = FSEv07_GETSYMBOL(&state1); - break; - } } - - return op-ostart; -} - - -size_t FSEv07_decompress_usingDTable(void* dst, size_t originalSize, - const void* cSrc, size_t cSrcSize, - const FSEv07_DTable* dt) -{ - const void* ptr = dt; - const FSEv07_DTableHeader* DTableH = (const FSEv07_DTableHeader*)ptr; - const U32 fastMode = DTableH->fastMode; - - /* select fast mode (static) */ - if (fastMode) return FSEv07_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1); - return FSEv07_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0); -} - - -size_t FSEv07_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize) -{ - const BYTE* const istart = (const BYTE*)cSrc; - const BYTE* ip = istart; - short counting[FSEv07_MAX_SYMBOL_VALUE+1]; - DTable_max_t dt; /* Static analyzer seems unable to understand this table will be properly initialized later */ - unsigned tableLog; - unsigned maxSymbolValue = FSEv07_MAX_SYMBOL_VALUE; - - if (cSrcSize<2) return ERROR(srcSize_wrong); /* too small input size */ - - /* normal FSE decoding mode */ - { size_t const NCountLength = FSEv07_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize); - if (FSEv07_isError(NCountLength)) return NCountLength; - if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong); /* too small input size */ - ip += NCountLength; - cSrcSize -= NCountLength; - } - - { size_t const errorCode = FSEv07_buildDTable (dt, counting, maxSymbolValue, tableLog); - if (FSEv07_isError(errorCode)) return errorCode; } - - return FSEv07_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt); /* always return, even if it is an error code */ -} - - - -#endif /* FSEv07_COMMONDEFS_ONLY */ - -/* ****************************************************************** - Huffman decoder, part of New Generation Entropy library - Copyright (C) 2013-2016, Yann Collet. - - BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php) - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are - met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following disclaimer - in the documentation and/or other materials provided with the - distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - You can contact the author at : - - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy - - Public forum : https://groups.google.com/forum/#!forum/lz4c -****************************************************************** */ - -/* ************************************************************** -* Compiler specifics -****************************************************************/ -#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) -/* inline is defined */ -#elif defined(_MSC_VER) -# define inline __inline -#else -# define inline /* disable inline */ -#endif - - -#ifdef _MSC_VER /* Visual Studio */ -# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ -#endif - - - -/* ************************************************************** -* Error Management -****************************************************************/ -#define HUFv07_STATIC_ASSERT(c) { enum { HUFv07_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */ - - -/*-***************************/ -/* generic DTableDesc */ -/*-***************************/ - -typedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc; - -static DTableDesc HUFv07_getDTableDesc(const HUFv07_DTable* table) -{ - DTableDesc dtd; - memcpy(&dtd, table, sizeof(dtd)); - return dtd; -} - - -/*-***************************/ -/* single-symbol decoding */ -/*-***************************/ - -typedef struct { BYTE byte; BYTE nbBits; } HUFv07_DEltX2; /* single-symbol decoding */ - -size_t HUFv07_readDTableX2 (HUFv07_DTable* DTable, const void* src, size_t srcSize) -{ - BYTE huffWeight[HUFv07_SYMBOLVALUE_MAX + 1]; - U32 rankVal[HUFv07_TABLELOG_ABSOLUTEMAX + 1]; /* large enough for values from 0 to 16 */ - U32 tableLog = 0; - U32 nbSymbols = 0; - size_t iSize; - void* const dtPtr = DTable + 1; - HUFv07_DEltX2* const dt = (HUFv07_DEltX2*)dtPtr; - - HUFv07_STATIC_ASSERT(sizeof(DTableDesc) == sizeof(HUFv07_DTable)); - /* memset(huffWeight, 0, sizeof(huffWeight)); */ /* is not necessary, even though some analyzer complain ... */ - - iSize = HUFv07_readStats(huffWeight, HUFv07_SYMBOLVALUE_MAX + 1, rankVal, &nbSymbols, &tableLog, src, srcSize); - if (HUFv07_isError(iSize)) return iSize; - - /* Table header */ - { DTableDesc dtd = HUFv07_getDTableDesc(DTable); - if (tableLog > (U32)(dtd.maxTableLog+1)) return ERROR(tableLog_tooLarge); /* DTable too small, huffman tree cannot fit in */ - dtd.tableType = 0; - dtd.tableLog = (BYTE)tableLog; - memcpy(DTable, &dtd, sizeof(dtd)); - } - - /* Prepare ranks */ - { U32 n, nextRankStart = 0; - for (n=1; n> 1; - U32 i; - HUFv07_DEltX2 D; - D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w); - for (i = rankVal[w]; i < rankVal[w] + length; i++) - dt[i] = D; - rankVal[w] += length; - } } - - return iSize; -} - - -static BYTE HUFv07_decodeSymbolX2(BITv07_DStream_t* Dstream, const HUFv07_DEltX2* dt, const U32 dtLog) -{ - size_t const val = BITv07_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */ - BYTE const c = dt[val].byte; - BITv07_skipBits(Dstream, dt[val].nbBits); - return c; -} - -#define HUFv07_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \ - *ptr++ = HUFv07_decodeSymbolX2(DStreamPtr, dt, dtLog) - -#define HUFv07_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \ - if (MEM_64bits() || (HUFv07_TABLELOG_MAX<=12)) \ - HUFv07_DECODE_SYMBOLX2_0(ptr, DStreamPtr) - -#define HUFv07_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \ - if (MEM_64bits()) \ - HUFv07_DECODE_SYMBOLX2_0(ptr, DStreamPtr) - -static inline size_t HUFv07_decodeStreamX2(BYTE* p, BITv07_DStream_t* const bitDPtr, BYTE* const pEnd, const HUFv07_DEltX2* const dt, const U32 dtLog) -{ - BYTE* const pStart = p; - - /* up to 4 symbols at a time */ - while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p <= pEnd-4)) { - HUFv07_DECODE_SYMBOLX2_2(p, bitDPtr); - HUFv07_DECODE_SYMBOLX2_1(p, bitDPtr); - HUFv07_DECODE_SYMBOLX2_2(p, bitDPtr); - HUFv07_DECODE_SYMBOLX2_0(p, bitDPtr); - } - - /* closer to the end */ - while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p < pEnd)) - HUFv07_DECODE_SYMBOLX2_0(p, bitDPtr); - - /* no more data to retrieve from bitstream, hence no need to reload */ - while (p < pEnd) - HUFv07_DECODE_SYMBOLX2_0(p, bitDPtr); - - return pEnd-pStart; -} - -static size_t HUFv07_decompress1X2_usingDTable_internal( - void* dst, size_t dstSize, - const void* cSrc, size_t cSrcSize, - const HUFv07_DTable* DTable) -{ - BYTE* op = (BYTE*)dst; - BYTE* const oend = op + dstSize; - const void* dtPtr = DTable + 1; - const HUFv07_DEltX2* const dt = (const HUFv07_DEltX2*)dtPtr; - BITv07_DStream_t bitD; - DTableDesc const dtd = HUFv07_getDTableDesc(DTable); - U32 const dtLog = dtd.tableLog; - - { size_t const errorCode = BITv07_initDStream(&bitD, cSrc, cSrcSize); - if (HUFv07_isError(errorCode)) return errorCode; } - - HUFv07_decodeStreamX2(op, &bitD, oend, dt, dtLog); - - /* check */ - if (!BITv07_endOfDStream(&bitD)) return ERROR(corruption_detected); - - return dstSize; -} - -size_t HUFv07_decompress1X2_usingDTable( - void* dst, size_t dstSize, - const void* cSrc, size_t cSrcSize, - const HUFv07_DTable* DTable) -{ - DTableDesc dtd = HUFv07_getDTableDesc(DTable); - if (dtd.tableType != 0) return ERROR(GENERIC); - return HUFv07_decompress1X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable); -} - -size_t HUFv07_decompress1X2_DCtx (HUFv07_DTable* DCtx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) -{ - const BYTE* ip = (const BYTE*) cSrc; - - size_t const hSize = HUFv07_readDTableX2 (DCtx, cSrc, cSrcSize); - if (HUFv07_isError(hSize)) return hSize; - if (hSize >= cSrcSize) return ERROR(srcSize_wrong); - ip += hSize; cSrcSize -= hSize; - - return HUFv07_decompress1X2_usingDTable_internal (dst, dstSize, ip, cSrcSize, DCtx); -} - -size_t HUFv07_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) -{ - HUFv07_CREATE_STATIC_DTABLEX2(DTable, HUFv07_TABLELOG_MAX); - return HUFv07_decompress1X2_DCtx (DTable, dst, dstSize, cSrc, cSrcSize); -} - - -static size_t HUFv07_decompress4X2_usingDTable_internal( - void* dst, size_t dstSize, - const void* cSrc, size_t cSrcSize, - const HUFv07_DTable* DTable) -{ - /* Check */ - if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */ - - { const BYTE* const istart = (const BYTE*) cSrc; - BYTE* const ostart = (BYTE*) dst; - BYTE* const oend = ostart + dstSize; - const void* const dtPtr = DTable + 1; - const HUFv07_DEltX2* const dt = (const HUFv07_DEltX2*)dtPtr; - - /* Init */ - BITv07_DStream_t bitD1; - BITv07_DStream_t bitD2; - BITv07_DStream_t bitD3; - BITv07_DStream_t bitD4; - size_t const length1 = MEM_readLE16(istart); - size_t const length2 = MEM_readLE16(istart+2); - size_t const length3 = MEM_readLE16(istart+4); - size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6); - const BYTE* const istart1 = istart + 6; /* jumpTable */ - const BYTE* const istart2 = istart1 + length1; - const BYTE* const istart3 = istart2 + length2; - const BYTE* const istart4 = istart3 + length3; - const size_t segmentSize = (dstSize+3) / 4; - BYTE* const opStart2 = ostart + segmentSize; - BYTE* const opStart3 = opStart2 + segmentSize; - BYTE* const opStart4 = opStart3 + segmentSize; - BYTE* op1 = ostart; - BYTE* op2 = opStart2; - BYTE* op3 = opStart3; - BYTE* op4 = opStart4; - U32 endSignal; - DTableDesc const dtd = HUFv07_getDTableDesc(DTable); - U32 const dtLog = dtd.tableLog; - - if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */ - { size_t const errorCode = BITv07_initDStream(&bitD1, istart1, length1); - if (HUFv07_isError(errorCode)) return errorCode; } - { size_t const errorCode = BITv07_initDStream(&bitD2, istart2, length2); - if (HUFv07_isError(errorCode)) return errorCode; } - { size_t const errorCode = BITv07_initDStream(&bitD3, istart3, length3); - if (HUFv07_isError(errorCode)) return errorCode; } - { size_t const errorCode = BITv07_initDStream(&bitD4, istart4, length4); - if (HUFv07_isError(errorCode)) return errorCode; } - - /* 16-32 symbols per loop (4-8 symbols per stream) */ - endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_reloadDStream(&bitD4); - for ( ; (endSignal==BITv07_DStream_unfinished) && (op4<(oend-7)) ; ) { - HUFv07_DECODE_SYMBOLX2_2(op1, &bitD1); - HUFv07_DECODE_SYMBOLX2_2(op2, &bitD2); - HUFv07_DECODE_SYMBOLX2_2(op3, &bitD3); - HUFv07_DECODE_SYMBOLX2_2(op4, &bitD4); - HUFv07_DECODE_SYMBOLX2_1(op1, &bitD1); - HUFv07_DECODE_SYMBOLX2_1(op2, &bitD2); - HUFv07_DECODE_SYMBOLX2_1(op3, &bitD3); - HUFv07_DECODE_SYMBOLX2_1(op4, &bitD4); - HUFv07_DECODE_SYMBOLX2_2(op1, &bitD1); - HUFv07_DECODE_SYMBOLX2_2(op2, &bitD2); - HUFv07_DECODE_SYMBOLX2_2(op3, &bitD3); - HUFv07_DECODE_SYMBOLX2_2(op4, &bitD4); - HUFv07_DECODE_SYMBOLX2_0(op1, &bitD1); - HUFv07_DECODE_SYMBOLX2_0(op2, &bitD2); - HUFv07_DECODE_SYMBOLX2_0(op3, &bitD3); - HUFv07_DECODE_SYMBOLX2_0(op4, &bitD4); - endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_reloadDStream(&bitD4); - } - - /* check corruption */ - if (op1 > opStart2) return ERROR(corruption_detected); - if (op2 > opStart3) return ERROR(corruption_detected); - if (op3 > opStart4) return ERROR(corruption_detected); - /* note : op4 supposed already verified within main loop */ - - /* finish bitStreams one by one */ - HUFv07_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog); - HUFv07_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog); - HUFv07_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog); - HUFv07_decodeStreamX2(op4, &bitD4, oend, dt, dtLog); - - /* check */ - endSignal = BITv07_endOfDStream(&bitD1) & BITv07_endOfDStream(&bitD2) & BITv07_endOfDStream(&bitD3) & BITv07_endOfDStream(&bitD4); - if (!endSignal) return ERROR(corruption_detected); - - /* decoded size */ - return dstSize; - } -} - - -size_t HUFv07_decompress4X2_usingDTable( - void* dst, size_t dstSize, - const void* cSrc, size_t cSrcSize, - const HUFv07_DTable* DTable) -{ - DTableDesc dtd = HUFv07_getDTableDesc(DTable); - if (dtd.tableType != 0) return ERROR(GENERIC); - return HUFv07_decompress4X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable); -} - - -size_t HUFv07_decompress4X2_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) -{ - const BYTE* ip = (const BYTE*) cSrc; - - size_t const hSize = HUFv07_readDTableX2 (dctx, cSrc, cSrcSize); - if (HUFv07_isError(hSize)) return hSize; - if (hSize >= cSrcSize) return ERROR(srcSize_wrong); - ip += hSize; cSrcSize -= hSize; - - return HUFv07_decompress4X2_usingDTable_internal (dst, dstSize, ip, cSrcSize, dctx); -} - -size_t HUFv07_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) -{ - HUFv07_CREATE_STATIC_DTABLEX2(DTable, HUFv07_TABLELOG_MAX); - return HUFv07_decompress4X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize); -} - - -/* *************************/ -/* double-symbols decoding */ -/* *************************/ -typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUFv07_DEltX4; /* double-symbols decoding */ - -typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t; - -static void HUFv07_fillDTableX4Level2(HUFv07_DEltX4* DTable, U32 sizeLog, const U32 consumed, - const U32* rankValOrigin, const int minWeight, - const sortedSymbol_t* sortedSymbols, const U32 sortedListSize, - U32 nbBitsBaseline, U16 baseSeq) -{ - HUFv07_DEltX4 DElt; - U32 rankVal[HUFv07_TABLELOG_ABSOLUTEMAX + 1]; - - /* get pre-calculated rankVal */ - memcpy(rankVal, rankValOrigin, sizeof(rankVal)); - - /* fill skipped values */ - if (minWeight>1) { - U32 i, skipSize = rankVal[minWeight]; - MEM_writeLE16(&(DElt.sequence), baseSeq); - DElt.nbBits = (BYTE)(consumed); - DElt.length = 1; - for (i = 0; i < skipSize; i++) - DTable[i] = DElt; - } - - /* fill DTable */ - { U32 s; for (s=0; s= 1 */ - - rankVal[weight] += length; - }} -} - -typedef U32 rankVal_t[HUFv07_TABLELOG_ABSOLUTEMAX][HUFv07_TABLELOG_ABSOLUTEMAX + 1]; - -static void HUFv07_fillDTableX4(HUFv07_DEltX4* DTable, const U32 targetLog, - const sortedSymbol_t* sortedList, const U32 sortedListSize, - const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight, - const U32 nbBitsBaseline) -{ - U32 rankVal[HUFv07_TABLELOG_ABSOLUTEMAX + 1]; - const int scaleLog = nbBitsBaseline - targetLog; /* note : targetLog >= srcLog, hence scaleLog <= 1 */ - const U32 minBits = nbBitsBaseline - maxWeight; - U32 s; - - memcpy(rankVal, rankValOrigin, sizeof(rankVal)); - - /* fill DTable */ - for (s=0; s= minBits) { /* enough room for a second symbol */ - U32 sortedRank; - int minWeight = nbBits + scaleLog; - if (minWeight < 1) minWeight = 1; - sortedRank = rankStart[minWeight]; - HUFv07_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits, - rankValOrigin[nbBits], minWeight, - sortedList+sortedRank, sortedListSize-sortedRank, - nbBitsBaseline, symbol); - } else { - HUFv07_DEltX4 DElt; - MEM_writeLE16(&(DElt.sequence), symbol); - DElt.nbBits = (BYTE)(nbBits); - DElt.length = 1; - { U32 u; - const U32 end = start + length; - for (u = start; u < end; u++) DTable[u] = DElt; - } } - rankVal[weight] += length; - } -} - -size_t HUFv07_readDTableX4 (HUFv07_DTable* DTable, const void* src, size_t srcSize) -{ - BYTE weightList[HUFv07_SYMBOLVALUE_MAX + 1]; - sortedSymbol_t sortedSymbol[HUFv07_SYMBOLVALUE_MAX + 1]; - U32 rankStats[HUFv07_TABLELOG_ABSOLUTEMAX + 1] = { 0 }; - U32 rankStart0[HUFv07_TABLELOG_ABSOLUTEMAX + 2] = { 0 }; - U32* const rankStart = rankStart0+1; - rankVal_t rankVal; - U32 tableLog, maxW, sizeOfSort, nbSymbols; - DTableDesc dtd = HUFv07_getDTableDesc(DTable); - U32 const maxTableLog = dtd.maxTableLog; - size_t iSize; - void* dtPtr = DTable+1; /* force compiler to avoid strict-aliasing */ - HUFv07_DEltX4* const dt = (HUFv07_DEltX4*)dtPtr; - - HUFv07_STATIC_ASSERT(sizeof(HUFv07_DEltX4) == sizeof(HUFv07_DTable)); /* if compilation fails here, assertion is false */ - if (maxTableLog > HUFv07_TABLELOG_ABSOLUTEMAX) return ERROR(tableLog_tooLarge); - /* memset(weightList, 0, sizeof(weightList)); */ /* is not necessary, even though some analyzer complain ... */ - - iSize = HUFv07_readStats(weightList, HUFv07_SYMBOLVALUE_MAX + 1, rankStats, &nbSymbols, &tableLog, src, srcSize); - if (HUFv07_isError(iSize)) return iSize; - - /* check result */ - if (tableLog > maxTableLog) return ERROR(tableLog_tooLarge); /* DTable can't fit code depth */ - - /* find maxWeight */ - for (maxW = tableLog; rankStats[maxW]==0; maxW--) {} /* necessarily finds a solution before 0 */ - - /* Get start index of each weight */ - { U32 w, nextRankStart = 0; - for (w=1; w> consumed; - } } } } - - HUFv07_fillDTableX4(dt, maxTableLog, - sortedSymbol, sizeOfSort, - rankStart0, rankVal, maxW, - tableLog+1); - - dtd.tableLog = (BYTE)maxTableLog; - dtd.tableType = 1; - memcpy(DTable, &dtd, sizeof(dtd)); - return iSize; -} - - -static U32 HUFv07_decodeSymbolX4(void* op, BITv07_DStream_t* DStream, const HUFv07_DEltX4* dt, const U32 dtLog) -{ - const size_t val = BITv07_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */ - memcpy(op, dt+val, 2); - BITv07_skipBits(DStream, dt[val].nbBits); - return dt[val].length; -} - -static U32 HUFv07_decodeLastSymbolX4(void* op, BITv07_DStream_t* DStream, const HUFv07_DEltX4* dt, const U32 dtLog) -{ - const size_t val = BITv07_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */ - memcpy(op, dt+val, 1); - if (dt[val].length==1) BITv07_skipBits(DStream, dt[val].nbBits); - else { - if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) { - BITv07_skipBits(DStream, dt[val].nbBits); - if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8)) - 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 */ - } } - return 1; -} - - -#define HUFv07_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \ - ptr += HUFv07_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) - -#define HUFv07_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \ - if (MEM_64bits() || (HUFv07_TABLELOG_MAX<=12)) \ - ptr += HUFv07_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) - -#define HUFv07_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \ - if (MEM_64bits()) \ - ptr += HUFv07_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) - -static inline size_t HUFv07_decodeStreamX4(BYTE* p, BITv07_DStream_t* bitDPtr, BYTE* const pEnd, const HUFv07_DEltX4* const dt, const U32 dtLog) -{ - BYTE* const pStart = p; - - /* up to 8 symbols at a time */ - while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p < pEnd-7)) { - HUFv07_DECODE_SYMBOLX4_2(p, bitDPtr); - HUFv07_DECODE_SYMBOLX4_1(p, bitDPtr); - HUFv07_DECODE_SYMBOLX4_2(p, bitDPtr); - HUFv07_DECODE_SYMBOLX4_0(p, bitDPtr); - } - - /* closer to end : up to 2 symbols at a time */ - while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p <= pEnd-2)) - HUFv07_DECODE_SYMBOLX4_0(p, bitDPtr); - - while (p <= pEnd-2) - HUFv07_DECODE_SYMBOLX4_0(p, bitDPtr); /* no need to reload : reached the end of DStream */ - - if (p < pEnd) - p += HUFv07_decodeLastSymbolX4(p, bitDPtr, dt, dtLog); - - return p-pStart; -} - - -static size_t HUFv07_decompress1X4_usingDTable_internal( - void* dst, size_t dstSize, - const void* cSrc, size_t cSrcSize, - const HUFv07_DTable* DTable) -{ - BITv07_DStream_t bitD; - - /* Init */ - { size_t const errorCode = BITv07_initDStream(&bitD, cSrc, cSrcSize); - if (HUFv07_isError(errorCode)) return errorCode; - } - - /* decode */ - { BYTE* const ostart = (BYTE*) dst; - BYTE* const oend = ostart + dstSize; - const void* const dtPtr = DTable+1; /* force compiler to not use strict-aliasing */ - const HUFv07_DEltX4* const dt = (const HUFv07_DEltX4*)dtPtr; - DTableDesc const dtd = HUFv07_getDTableDesc(DTable); - HUFv07_decodeStreamX4(ostart, &bitD, oend, dt, dtd.tableLog); - } - - /* check */ - if (!BITv07_endOfDStream(&bitD)) return ERROR(corruption_detected); - - /* decoded size */ - return dstSize; -} - -size_t HUFv07_decompress1X4_usingDTable( - void* dst, size_t dstSize, - const void* cSrc, size_t cSrcSize, - const HUFv07_DTable* DTable) -{ - DTableDesc dtd = HUFv07_getDTableDesc(DTable); - if (dtd.tableType != 1) return ERROR(GENERIC); - return HUFv07_decompress1X4_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable); -} - -size_t HUFv07_decompress1X4_DCtx (HUFv07_DTable* DCtx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) -{ - const BYTE* ip = (const BYTE*) cSrc; - - size_t const hSize = HUFv07_readDTableX4 (DCtx, cSrc, cSrcSize); - if (HUFv07_isError(hSize)) return hSize; - if (hSize >= cSrcSize) return ERROR(srcSize_wrong); - ip += hSize; cSrcSize -= hSize; - - return HUFv07_decompress1X4_usingDTable_internal (dst, dstSize, ip, cSrcSize, DCtx); -} - -size_t HUFv07_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) -{ - HUFv07_CREATE_STATIC_DTABLEX4(DTable, HUFv07_TABLELOG_MAX); - return HUFv07_decompress1X4_DCtx(DTable, dst, dstSize, cSrc, cSrcSize); -} - -static size_t HUFv07_decompress4X4_usingDTable_internal( - void* dst, size_t dstSize, - const void* cSrc, size_t cSrcSize, - const HUFv07_DTable* DTable) -{ - if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */ - - { const BYTE* const istart = (const BYTE*) cSrc; - BYTE* const ostart = (BYTE*) dst; - BYTE* const oend = ostart + dstSize; - const void* const dtPtr = DTable+1; - const HUFv07_DEltX4* const dt = (const HUFv07_DEltX4*)dtPtr; - - /* Init */ - BITv07_DStream_t bitD1; - BITv07_DStream_t bitD2; - BITv07_DStream_t bitD3; - BITv07_DStream_t bitD4; - size_t const length1 = MEM_readLE16(istart); - size_t const length2 = MEM_readLE16(istart+2); - size_t const length3 = MEM_readLE16(istart+4); - size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6); - const BYTE* const istart1 = istart + 6; /* jumpTable */ - const BYTE* const istart2 = istart1 + length1; - const BYTE* const istart3 = istart2 + length2; - const BYTE* const istart4 = istart3 + length3; - size_t const segmentSize = (dstSize+3) / 4; - BYTE* const opStart2 = ostart + segmentSize; - BYTE* const opStart3 = opStart2 + segmentSize; - BYTE* const opStart4 = opStart3 + segmentSize; - BYTE* op1 = ostart; - BYTE* op2 = opStart2; - BYTE* op3 = opStart3; - BYTE* op4 = opStart4; - U32 endSignal; - DTableDesc const dtd = HUFv07_getDTableDesc(DTable); - U32 const dtLog = dtd.tableLog; - - if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */ - { size_t const errorCode = BITv07_initDStream(&bitD1, istart1, length1); - if (HUFv07_isError(errorCode)) return errorCode; } - { size_t const errorCode = BITv07_initDStream(&bitD2, istart2, length2); - if (HUFv07_isError(errorCode)) return errorCode; } - { size_t const errorCode = BITv07_initDStream(&bitD3, istart3, length3); - if (HUFv07_isError(errorCode)) return errorCode; } - { size_t const errorCode = BITv07_initDStream(&bitD4, istart4, length4); - if (HUFv07_isError(errorCode)) return errorCode; } - - /* 16-32 symbols per loop (4-8 symbols per stream) */ - endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_reloadDStream(&bitD4); - for ( ; (endSignal==BITv07_DStream_unfinished) && (op4<(oend-7)) ; ) { - HUFv07_DECODE_SYMBOLX4_2(op1, &bitD1); - HUFv07_DECODE_SYMBOLX4_2(op2, &bitD2); - HUFv07_DECODE_SYMBOLX4_2(op3, &bitD3); - HUFv07_DECODE_SYMBOLX4_2(op4, &bitD4); - HUFv07_DECODE_SYMBOLX4_1(op1, &bitD1); - HUFv07_DECODE_SYMBOLX4_1(op2, &bitD2); - HUFv07_DECODE_SYMBOLX4_1(op3, &bitD3); - HUFv07_DECODE_SYMBOLX4_1(op4, &bitD4); - HUFv07_DECODE_SYMBOLX4_2(op1, &bitD1); - HUFv07_DECODE_SYMBOLX4_2(op2, &bitD2); - HUFv07_DECODE_SYMBOLX4_2(op3, &bitD3); - HUFv07_DECODE_SYMBOLX4_2(op4, &bitD4); - HUFv07_DECODE_SYMBOLX4_0(op1, &bitD1); - HUFv07_DECODE_SYMBOLX4_0(op2, &bitD2); - HUFv07_DECODE_SYMBOLX4_0(op3, &bitD3); - HUFv07_DECODE_SYMBOLX4_0(op4, &bitD4); - - endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_reloadDStream(&bitD4); - } - - /* check corruption */ - if (op1 > opStart2) return ERROR(corruption_detected); - if (op2 > opStart3) return ERROR(corruption_detected); - if (op3 > opStart4) return ERROR(corruption_detected); - /* note : op4 supposed already verified within main loop */ - - /* finish bitStreams one by one */ - HUFv07_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog); - HUFv07_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog); - HUFv07_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog); - HUFv07_decodeStreamX4(op4, &bitD4, oend, dt, dtLog); - - /* check */ - { U32 const endCheck = BITv07_endOfDStream(&bitD1) & BITv07_endOfDStream(&bitD2) & BITv07_endOfDStream(&bitD3) & BITv07_endOfDStream(&bitD4); - if (!endCheck) return ERROR(corruption_detected); } - - /* decoded size */ - return dstSize; - } -} - - -size_t HUFv07_decompress4X4_usingDTable( - void* dst, size_t dstSize, - const void* cSrc, size_t cSrcSize, - const HUFv07_DTable* DTable) -{ - DTableDesc dtd = HUFv07_getDTableDesc(DTable); - if (dtd.tableType != 1) return ERROR(GENERIC); - return HUFv07_decompress4X4_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable); -} - - -size_t HUFv07_decompress4X4_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) -{ - const BYTE* ip = (const BYTE*) cSrc; - - size_t hSize = HUFv07_readDTableX4 (dctx, cSrc, cSrcSize); - if (HUFv07_isError(hSize)) return hSize; - if (hSize >= cSrcSize) return ERROR(srcSize_wrong); - ip += hSize; cSrcSize -= hSize; - - return HUFv07_decompress4X4_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx); -} - -size_t HUFv07_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) -{ - HUFv07_CREATE_STATIC_DTABLEX4(DTable, HUFv07_TABLELOG_MAX); - return HUFv07_decompress4X4_DCtx(DTable, dst, dstSize, cSrc, cSrcSize); -} - - -/* ********************************/ -/* Generic decompression selector */ -/* ********************************/ - -size_t HUFv07_decompress1X_usingDTable(void* dst, size_t maxDstSize, - const void* cSrc, size_t cSrcSize, - const HUFv07_DTable* DTable) -{ - DTableDesc const dtd = HUFv07_getDTableDesc(DTable); - return dtd.tableType ? HUFv07_decompress1X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable) : - HUFv07_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable); -} - -size_t HUFv07_decompress4X_usingDTable(void* dst, size_t maxDstSize, - const void* cSrc, size_t cSrcSize, - const HUFv07_DTable* DTable) -{ - DTableDesc const dtd = HUFv07_getDTableDesc(DTable); - return dtd.tableType ? HUFv07_decompress4X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable) : - HUFv07_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable); -} - - -typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t; -static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] = -{ - /* single, double, quad */ - {{0,0}, {1,1}, {2,2}}, /* Q==0 : impossible */ - {{0,0}, {1,1}, {2,2}}, /* Q==1 : impossible */ - {{ 38,130}, {1313, 74}, {2151, 38}}, /* Q == 2 : 12-18% */ - {{ 448,128}, {1353, 74}, {2238, 41}}, /* Q == 3 : 18-25% */ - {{ 556,128}, {1353, 74}, {2238, 47}}, /* Q == 4 : 25-32% */ - {{ 714,128}, {1418, 74}, {2436, 53}}, /* Q == 5 : 32-38% */ - {{ 883,128}, {1437, 74}, {2464, 61}}, /* Q == 6 : 38-44% */ - {{ 897,128}, {1515, 75}, {2622, 68}}, /* Q == 7 : 44-50% */ - {{ 926,128}, {1613, 75}, {2730, 75}}, /* Q == 8 : 50-56% */ - {{ 947,128}, {1729, 77}, {3359, 77}}, /* Q == 9 : 56-62% */ - {{1107,128}, {2083, 81}, {4006, 84}}, /* Q ==10 : 62-69% */ - {{1177,128}, {2379, 87}, {4785, 88}}, /* Q ==11 : 69-75% */ - {{1242,128}, {2415, 93}, {5155, 84}}, /* Q ==12 : 75-81% */ - {{1349,128}, {2644,106}, {5260,106}}, /* Q ==13 : 81-87% */ - {{1455,128}, {2422,124}, {4174,124}}, /* Q ==14 : 87-93% */ - {{ 722,128}, {1891,145}, {1936,146}}, /* Q ==15 : 93-99% */ -}; - -/** HUFv07_selectDecoder() : -* Tells which decoder is likely to decode faster, -* based on a set of pre-determined metrics. -* @return : 0==HUFv07_decompress4X2, 1==HUFv07_decompress4X4 . -* Assumption : 0 < cSrcSize < dstSize <= 128 KB */ -U32 HUFv07_selectDecoder (size_t dstSize, size_t cSrcSize) -{ - /* decoder timing evaluation */ - U32 const Q = (U32)(cSrcSize * 16 / dstSize); /* Q < 16 since dstSize > cSrcSize */ - U32 const D256 = (U32)(dstSize >> 8); - U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256); - U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256); - DTime1 += DTime1 >> 3; /* advantage to algorithm using less memory, for cache eviction */ - - return DTime1 < DTime0; -} - - -typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); - -size_t HUFv07_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) -{ - static const decompressionAlgo decompress[2] = { HUFv07_decompress4X2, HUFv07_decompress4X4 }; - - /* validation checks */ - if (dstSize == 0) return ERROR(dstSize_tooSmall); - if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */ - if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */ - if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */ - - { U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize); - return decompress[algoNb](dst, dstSize, cSrc, cSrcSize); - } - - /* return HUFv07_decompress4X2(dst, dstSize, cSrc, cSrcSize); */ /* multi-streams single-symbol decoding */ - /* return HUFv07_decompress4X4(dst, dstSize, cSrc, cSrcSize); */ /* multi-streams double-symbols decoding */ -} - -size_t HUFv07_decompress4X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) -{ - /* validation checks */ - if (dstSize == 0) return ERROR(dstSize_tooSmall); - if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */ - if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */ - if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */ - - { U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize); - return algoNb ? HUFv07_decompress4X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) : - HUFv07_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ; - } -} - -size_t HUFv07_decompress4X_hufOnly (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) -{ - /* validation checks */ - if (dstSize == 0) return ERROR(dstSize_tooSmall); - if ((cSrcSize >= dstSize) || (cSrcSize <= 1)) return ERROR(corruption_detected); /* invalid */ - - { U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize); - return algoNb ? HUFv07_decompress4X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) : - HUFv07_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ; - } -} - -size_t HUFv07_decompress1X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) -{ - /* validation checks */ - if (dstSize == 0) return ERROR(dstSize_tooSmall); - if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */ - if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */ - if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */ - - { U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize); - return algoNb ? HUFv07_decompress1X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) : - HUFv07_decompress1X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ; - } -} -/* - Common functions of Zstd compression library - Copyright (C) 2015-2016, Yann Collet. - - BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php) - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are - met: - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following disclaimer - in the documentation and/or other materials provided with the - distribution. - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - You can contact the author at : - - zstd homepage : https://facebook.github.io/zstd/ -*/ - - - -/*-**************************************** -* ZSTD Error Management -******************************************/ -/*! ZSTDv07_isError() : -* tells if a return value is an error code */ -unsigned ZSTDv07_isError(size_t code) { return ERR_isError(code); } - -/*! ZSTDv07_getErrorName() : -* provides error code string from function result (useful for debugging) */ -const char* ZSTDv07_getErrorName(size_t code) { return ERR_getErrorName(code); } - - - -/* ************************************************************** -* ZBUFF Error Management -****************************************************************/ -unsigned ZBUFFv07_isError(size_t errorCode) { return ERR_isError(errorCode); } - -const char* ZBUFFv07_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); } - - - -static void* ZSTDv07_defaultAllocFunction(void* opaque, size_t size) -{ - void* address = malloc(size); - (void)opaque; - /* printf("alloc %p, %d opaque=%p \n", address, (int)size, opaque); */ - return address; -} - -static void ZSTDv07_defaultFreeFunction(void* opaque, void* address) -{ - (void)opaque; - /* if (address) printf("free %p opaque=%p \n", address, opaque); */ - free(address); -} -/* - zstd_internal - common functions to include - Header File for include - Copyright (C) 2014-2016, Yann Collet. - - BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php) - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are - met: - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following disclaimer - in the documentation and/or other materials provided with the - distribution. - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - You can contact the author at : - - zstd homepage : https://www.zstd.net -*/ -#ifndef ZSTDv07_CCOMMON_H_MODULE -#define ZSTDv07_CCOMMON_H_MODULE - - -/*-************************************* -* Common macros -***************************************/ -#define MIN(a,b) ((a)<(b) ? (a) : (b)) -#define MAX(a,b) ((a)>(b) ? (a) : (b)) - - -/*-************************************* -* Common constants -***************************************/ -#define ZSTDv07_OPT_NUM (1<<12) -#define ZSTDv07_DICT_MAGIC 0xEC30A437 /* v0.7 */ - -#define ZSTDv07_REP_NUM 3 -#define ZSTDv07_REP_INIT ZSTDv07_REP_NUM -#define ZSTDv07_REP_MOVE (ZSTDv07_REP_NUM-1) -static const U32 repStartValue[ZSTDv07_REP_NUM] = { 1, 4, 8 }; - -#define KB *(1 <<10) -#define MB *(1 <<20) -#define GB *(1U<<30) - -#define BIT7 128 -#define BIT6 64 -#define BIT5 32 -#define BIT4 16 -#define BIT1 2 -#define BIT0 1 - -#define ZSTDv07_WINDOWLOG_ABSOLUTEMIN 10 -static const size_t ZSTDv07_fcs_fieldSize[4] = { 0, 2, 4, 8 }; -static const size_t ZSTDv07_did_fieldSize[4] = { 0, 1, 2, 4 }; - -#define ZSTDv07_BLOCKHEADERSIZE 3 /* C standard doesn't allow `static const` variable to be init using another `static const` variable */ -static const size_t ZSTDv07_blockHeaderSize = ZSTDv07_BLOCKHEADERSIZE; -typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t; - -#define MIN_SEQUENCES_SIZE 1 /* nbSeq==0 */ -#define MIN_CBLOCK_SIZE (1 /*litCSize*/ + 1 /* RLE or RAW */ + MIN_SEQUENCES_SIZE /* nbSeq==0 */) /* for a non-null block */ - -#define ZSTD_HUFFDTABLE_CAPACITY_LOG 12 -typedef enum { lbt_huffman, lbt_repeat, lbt_raw, lbt_rle } litBlockType_t; - -#define LONGNBSEQ 0x7F00 - -#define MINMATCH 3 -#define EQUAL_READ32 4 - -#define Litbits 8 -#define MaxLit ((1< /* For Visual 2005 */ -# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ -# pragma warning(disable : 4324) /* disable: C4324: padded structure */ -# pragma warning(disable : 4100) /* disable: C4100: unreferenced formal parameter */ -#endif - - -/*-************************************* -* Macros -***************************************/ -#define ZSTDv07_isError ERR_isError /* for inlining */ -#define FSEv07_isError ERR_isError -#define HUFv07_isError ERR_isError - - -/*_******************************************************* -* Memory operations -**********************************************************/ -static void ZSTDv07_copy4(void* dst, const void* src) { memcpy(dst, src, 4); } - - -/*-************************************************************* -* Context management -***************************************************************/ -typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader, - ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock, - ZSTDds_decodeSkippableHeader, ZSTDds_skipFrame } ZSTDv07_dStage; - -struct ZSTDv07_DCtx_s -{ - FSEv07_DTable LLTable[FSEv07_DTABLE_SIZE_U32(LLFSELog)]; - FSEv07_DTable OffTable[FSEv07_DTABLE_SIZE_U32(OffFSELog)]; - FSEv07_DTable MLTable[FSEv07_DTABLE_SIZE_U32(MLFSELog)]; - HUFv07_DTable hufTable[HUFv07_DTABLE_SIZE(ZSTD_HUFFDTABLE_CAPACITY_LOG)]; /* can accommodate HUFv07_decompress4X */ - const void* previousDstEnd; - const void* base; - const void* vBase; - const void* dictEnd; - size_t expected; - U32 rep[3]; - ZSTDv07_frameParams fParams; - blockType_t bType; /* used in ZSTDv07_decompressContinue(), to transfer blockType between header decoding and block decoding stages */ - ZSTDv07_dStage stage; - U32 litEntropy; - U32 fseEntropy; - XXH64_state_t xxhState; - size_t headerSize; - U32 dictID; - const BYTE* litPtr; - ZSTDv07_customMem customMem; - size_t litSize; - BYTE litBuffer[ZSTDv07_BLOCKSIZE_ABSOLUTEMAX + WILDCOPY_OVERLENGTH]; - BYTE headerBuffer[ZSTDv07_FRAMEHEADERSIZE_MAX]; -}; /* typedef'd to ZSTDv07_DCtx within "zstd_static.h" */ - -int ZSTDv07_isSkipFrame(ZSTDv07_DCtx* dctx); - -size_t ZSTDv07_sizeofDCtx (const ZSTDv07_DCtx* dctx) { return sizeof(*dctx); } - -size_t ZSTDv07_estimateDCtxSize(void) { return sizeof(ZSTDv07_DCtx); } - -size_t ZSTDv07_decompressBegin(ZSTDv07_DCtx* dctx) -{ - dctx->expected = ZSTDv07_frameHeaderSize_min; - dctx->stage = ZSTDds_getFrameHeaderSize; - dctx->previousDstEnd = NULL; - dctx->base = NULL; - dctx->vBase = NULL; - dctx->dictEnd = NULL; - dctx->hufTable[0] = (HUFv07_DTable)((ZSTD_HUFFDTABLE_CAPACITY_LOG)*0x1000001); - dctx->litEntropy = dctx->fseEntropy = 0; - dctx->dictID = 0; - { int i; for (i=0; irep[i] = repStartValue[i]; } - return 0; -} - -ZSTDv07_DCtx* ZSTDv07_createDCtx_advanced(ZSTDv07_customMem customMem) -{ - ZSTDv07_DCtx* dctx; - - if (!customMem.customAlloc && !customMem.customFree) - customMem = defaultCustomMem; - - if (!customMem.customAlloc || !customMem.customFree) - return NULL; - - dctx = (ZSTDv07_DCtx*) customMem.customAlloc(customMem.opaque, sizeof(ZSTDv07_DCtx)); - if (!dctx) return NULL; - memcpy(&dctx->customMem, &customMem, sizeof(ZSTDv07_customMem)); - ZSTDv07_decompressBegin(dctx); - return dctx; -} - -ZSTDv07_DCtx* ZSTDv07_createDCtx(void) -{ - return ZSTDv07_createDCtx_advanced(defaultCustomMem); -} - -size_t ZSTDv07_freeDCtx(ZSTDv07_DCtx* dctx) -{ - if (dctx==NULL) return 0; /* support free on NULL */ - dctx->customMem.customFree(dctx->customMem.opaque, dctx); - return 0; /* reserved as a potential error code in the future */ -} - -void ZSTDv07_copyDCtx(ZSTDv07_DCtx* dstDCtx, const ZSTDv07_DCtx* srcDCtx) -{ - memcpy(dstDCtx, srcDCtx, - sizeof(ZSTDv07_DCtx) - (ZSTDv07_BLOCKSIZE_ABSOLUTEMAX+WILDCOPY_OVERLENGTH + ZSTDv07_frameHeaderSize_max)); /* no need to copy workspace */ -} - - -/*-************************************************************* -* Decompression section -***************************************************************/ - -/* Frame format description - Frame Header - [ Block Header - Block ] - Frame End - 1) Frame Header - - 4 bytes - Magic Number : ZSTDv07_MAGICNUMBER (defined within zstd.h) - - 1 byte - Frame Descriptor - 2) Block Header - - 3 bytes, starting with a 2-bits descriptor - Uncompressed, Compressed, Frame End, unused - 3) Block - See Block Format Description - 4) Frame End - - 3 bytes, compatible with Block Header -*/ - - -/* Frame Header : - - 1 byte - FrameHeaderDescription : - bit 0-1 : dictID (0, 1, 2 or 4 bytes) - bit 2 : checksumFlag - bit 3 : reserved (must be zero) - bit 4 : reserved (unused, can be any value) - bit 5 : Single Segment (if 1, WindowLog byte is not present) - bit 6-7 : FrameContentFieldSize (0, 2, 4, or 8) - if (SkippedWindowLog && !FrameContentFieldsize) FrameContentFieldsize=1; - - Optional : WindowLog (0 or 1 byte) - bit 0-2 : octal Fractional (1/8th) - bit 3-7 : Power of 2, with 0 = 1 KB (up to 2 TB) - - Optional : dictID (0, 1, 2 or 4 bytes) - Automatic adaptation - 0 : no dictID - 1 : 1 - 255 - 2 : 256 - 65535 - 4 : all other values - - Optional : content size (0, 1, 2, 4 or 8 bytes) - 0 : unknown (fcfs==0 and swl==0) - 1 : 0-255 bytes (fcfs==0 and swl==1) - 2 : 256 - 65535+256 (fcfs==1) - 4 : 0 - 4GB-1 (fcfs==2) - 8 : 0 - 16EB-1 (fcfs==3) -*/ - - -/* Compressed Block, format description - - Block = Literal Section - Sequences Section - Prerequisite : size of (compressed) block, maximum size of regenerated data - - 1) Literal Section - - 1.1) Header : 1-5 bytes - flags: 2 bits - 00 compressed by Huff0 - 01 unused - 10 is Raw (uncompressed) - 11 is Rle - Note : using 01 => Huff0 with precomputed table ? - Note : delta map ? => compressed ? - - 1.1.1) Huff0-compressed literal block : 3-5 bytes - srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream - srcSize < 1 KB => 3 bytes (2-2-10-10) - srcSize < 16KB => 4 bytes (2-2-14-14) - else => 5 bytes (2-2-18-18) - big endian convention - - 1.1.2) Raw (uncompressed) literal block header : 1-3 bytes - size : 5 bits: (IS_RAW<<6) + (0<<4) + size - 12 bits: (IS_RAW<<6) + (2<<4) + (size>>8) - size&255 - 20 bits: (IS_RAW<<6) + (3<<4) + (size>>16) - size>>8&255 - size&255 - - 1.1.3) Rle (repeated single byte) literal block header : 1-3 bytes - size : 5 bits: (IS_RLE<<6) + (0<<4) + size - 12 bits: (IS_RLE<<6) + (2<<4) + (size>>8) - size&255 - 20 bits: (IS_RLE<<6) + (3<<4) + (size>>16) - size>>8&255 - size&255 - - 1.1.4) Huff0-compressed literal block, using precomputed CTables : 3-5 bytes - srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream - srcSize < 1 KB => 3 bytes (2-2-10-10) - srcSize < 16KB => 4 bytes (2-2-14-14) - else => 5 bytes (2-2-18-18) - big endian convention - - 1- CTable available (stored into workspace ?) - 2- Small input (fast heuristic ? Full comparison ? depend on clevel ?) - - - 1.2) Literal block content - - 1.2.1) Huff0 block, using sizes from header - See Huff0 format - - 1.2.2) Huff0 block, using prepared table - - 1.2.3) Raw content - - 1.2.4) single byte - - - 2) Sequences section - TO DO -*/ - -/** ZSTDv07_frameHeaderSize() : -* srcSize must be >= ZSTDv07_frameHeaderSize_min. -* @return : size of the Frame Header */ -static size_t ZSTDv07_frameHeaderSize(const void* src, size_t srcSize) -{ - if (srcSize < ZSTDv07_frameHeaderSize_min) return ERROR(srcSize_wrong); - { BYTE const fhd = ((const BYTE*)src)[4]; - U32 const dictID= fhd & 3; - U32 const directMode = (fhd >> 5) & 1; - U32 const fcsId = fhd >> 6; - return ZSTDv07_frameHeaderSize_min + !directMode + ZSTDv07_did_fieldSize[dictID] + ZSTDv07_fcs_fieldSize[fcsId] - + (directMode && !ZSTDv07_fcs_fieldSize[fcsId]); - } -} - - -/** ZSTDv07_getFrameParams() : -* decode Frame Header, or require larger `srcSize`. -* @return : 0, `fparamsPtr` is correctly filled, -* >0, `srcSize` is too small, result is expected `srcSize`, -* or an error code, which can be tested using ZSTDv07_isError() */ -size_t ZSTDv07_getFrameParams(ZSTDv07_frameParams* fparamsPtr, const void* src, size_t srcSize) -{ - const BYTE* ip = (const BYTE*)src; - - if (srcSize < ZSTDv07_frameHeaderSize_min) return ZSTDv07_frameHeaderSize_min; - memset(fparamsPtr, 0, sizeof(*fparamsPtr)); - if (MEM_readLE32(src) != ZSTDv07_MAGICNUMBER) { - if ((MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTDv07_MAGIC_SKIPPABLE_START) { - if (srcSize < ZSTDv07_skippableHeaderSize) return ZSTDv07_skippableHeaderSize; /* magic number + skippable frame length */ - fparamsPtr->frameContentSize = MEM_readLE32((const char *)src + 4); - fparamsPtr->windowSize = 0; /* windowSize==0 means a frame is skippable */ - return 0; - } - return ERROR(prefix_unknown); - } - - /* ensure there is enough `srcSize` to fully read/decode frame header */ - { size_t const fhsize = ZSTDv07_frameHeaderSize(src, srcSize); - if (srcSize < fhsize) return fhsize; } - - { BYTE const fhdByte = ip[4]; - size_t pos = 5; - U32 const dictIDSizeCode = fhdByte&3; - U32 const checksumFlag = (fhdByte>>2)&1; - U32 const directMode = (fhdByte>>5)&1; - U32 const fcsID = fhdByte>>6; - U32 const windowSizeMax = 1U << ZSTDv07_WINDOWLOG_MAX; - U32 windowSize = 0; - U32 dictID = 0; - U64 frameContentSize = 0; - if ((fhdByte & 0x08) != 0) /* reserved bits, which must be zero */ - return ERROR(frameParameter_unsupported); - if (!directMode) { - BYTE const wlByte = ip[pos++]; - U32 const windowLog = (wlByte >> 3) + ZSTDv07_WINDOWLOG_ABSOLUTEMIN; - if (windowLog > ZSTDv07_WINDOWLOG_MAX) - return ERROR(frameParameter_unsupported); - windowSize = (1U << windowLog); - windowSize += (windowSize >> 3) * (wlByte&7); - } - - switch(dictIDSizeCode) - { - default: /* impossible */ - case 0 : break; - case 1 : dictID = ip[pos]; pos++; break; - case 2 : dictID = MEM_readLE16(ip+pos); pos+=2; break; - case 3 : dictID = MEM_readLE32(ip+pos); pos+=4; break; - } - switch(fcsID) - { - default: /* impossible */ - case 0 : if (directMode) frameContentSize = ip[pos]; break; - case 1 : frameContentSize = MEM_readLE16(ip+pos)+256; break; - case 2 : frameContentSize = MEM_readLE32(ip+pos); break; - case 3 : frameContentSize = MEM_readLE64(ip+pos); break; - } - if (!windowSize) windowSize = (U32)frameContentSize; - if (windowSize > windowSizeMax) - return ERROR(frameParameter_unsupported); - fparamsPtr->frameContentSize = frameContentSize; - fparamsPtr->windowSize = windowSize; - fparamsPtr->dictID = dictID; - fparamsPtr->checksumFlag = checksumFlag; - } - return 0; -} - - -/** ZSTDv07_getDecompressedSize() : -* compatible with legacy mode -* @return : decompressed size if known, 0 otherwise - note : 0 can mean any of the following : - - decompressed size is not provided within frame header - - frame header unknown / not supported - - frame header not completely provided (`srcSize` too small) */ -unsigned long long ZSTDv07_getDecompressedSize(const void* src, size_t srcSize) -{ - ZSTDv07_frameParams fparams; - size_t const frResult = ZSTDv07_getFrameParams(&fparams, src, srcSize); - if (frResult!=0) return 0; - return fparams.frameContentSize; -} - - -/** ZSTDv07_decodeFrameHeader() : -* `srcSize` must be the size provided by ZSTDv07_frameHeaderSize(). -* @return : 0 if success, or an error code, which can be tested using ZSTDv07_isError() */ -static size_t ZSTDv07_decodeFrameHeader(ZSTDv07_DCtx* dctx, const void* src, size_t srcSize) -{ - size_t const result = ZSTDv07_getFrameParams(&(dctx->fParams), src, srcSize); - if (dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID)) return ERROR(dictionary_wrong); - if (dctx->fParams.checksumFlag) XXH64_reset(&dctx->xxhState, 0); - return result; -} - - -typedef struct -{ - blockType_t blockType; - U32 origSize; -} blockProperties_t; - -/*! ZSTDv07_getcBlockSize() : -* Provides the size of compressed block from block header `src` */ -static size_t ZSTDv07_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr) -{ - const BYTE* const in = (const BYTE*)src; - U32 cSize; - - if (srcSize < ZSTDv07_blockHeaderSize) return ERROR(srcSize_wrong); - - bpPtr->blockType = (blockType_t)((*in) >> 6); - cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16); - bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0; - - if (bpPtr->blockType == bt_end) return 0; - if (bpPtr->blockType == bt_rle) return 1; - return cSize; -} - - -static size_t ZSTDv07_copyRawBlock(void* dst, size_t dstCapacity, const void* src, size_t srcSize) -{ - if (srcSize > dstCapacity) return ERROR(dstSize_tooSmall); - if (srcSize > 0) { - memcpy(dst, src, srcSize); - } - return srcSize; -} - - -/*! ZSTDv07_decodeLiteralsBlock() : - @return : nb of bytes read from src (< srcSize ) */ -static size_t ZSTDv07_decodeLiteralsBlock(ZSTDv07_DCtx* dctx, - const void* src, size_t srcSize) /* note : srcSize < BLOCKSIZE */ -{ - const BYTE* const istart = (const BYTE*) src; - - if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected); - - switch((litBlockType_t)(istart[0]>> 6)) - { - case lbt_huffman: - { size_t litSize, litCSize, singleStream=0; - U32 lhSize = (istart[0] >> 4) & 3; - if (srcSize < 5) return ERROR(corruption_detected); /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for lhSize, + cSize (+nbSeq) */ - switch(lhSize) - { - case 0: case 1: default: /* note : default is impossible, since lhSize into [0..3] */ - /* 2 - 2 - 10 - 10 */ - lhSize=3; - singleStream = istart[0] & 16; - litSize = ((istart[0] & 15) << 6) + (istart[1] >> 2); - litCSize = ((istart[1] & 3) << 8) + istart[2]; - break; - case 2: - /* 2 - 2 - 14 - 14 */ - lhSize=4; - litSize = ((istart[0] & 15) << 10) + (istart[1] << 2) + (istart[2] >> 6); - litCSize = ((istart[2] & 63) << 8) + istart[3]; - break; - case 3: - /* 2 - 2 - 18 - 18 */ - lhSize=5; - litSize = ((istart[0] & 15) << 14) + (istart[1] << 6) + (istart[2] >> 2); - litCSize = ((istart[2] & 3) << 16) + (istart[3] << 8) + istart[4]; - break; - } - if (litSize > ZSTDv07_BLOCKSIZE_ABSOLUTEMAX) return ERROR(corruption_detected); - if (litCSize + lhSize > srcSize) return ERROR(corruption_detected); - - if (HUFv07_isError(singleStream ? - HUFv07_decompress1X2_DCtx(dctx->hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize) : - HUFv07_decompress4X_hufOnly (dctx->hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize) )) - return ERROR(corruption_detected); - - dctx->litPtr = dctx->litBuffer; - dctx->litSize = litSize; - dctx->litEntropy = 1; - memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH); - return litCSize + lhSize; - } - case lbt_repeat: - { size_t litSize, litCSize; - U32 lhSize = ((istart[0]) >> 4) & 3; - if (lhSize != 1) /* only case supported for now : small litSize, single stream */ - return ERROR(corruption_detected); - if (dctx->litEntropy==0) - return ERROR(dictionary_corrupted); - - /* 2 - 2 - 10 - 10 */ - lhSize=3; - litSize = ((istart[0] & 15) << 6) + (istart[1] >> 2); - litCSize = ((istart[1] & 3) << 8) + istart[2]; - if (litCSize + lhSize > srcSize) return ERROR(corruption_detected); - - { size_t const errorCode = HUFv07_decompress1X4_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->hufTable); - if (HUFv07_isError(errorCode)) return ERROR(corruption_detected); - } - dctx->litPtr = dctx->litBuffer; - dctx->litSize = litSize; - memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH); - return litCSize + lhSize; - } - case lbt_raw: - { size_t litSize; - U32 lhSize = ((istart[0]) >> 4) & 3; - switch(lhSize) - { - case 0: case 1: default: /* note : default is impossible, since lhSize into [0..3] */ - lhSize=1; - litSize = istart[0] & 31; - break; - case 2: - litSize = ((istart[0] & 15) << 8) + istart[1]; - break; - case 3: - litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2]; - break; - } - - if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) { /* risk reading beyond src buffer with wildcopy */ - if (litSize+lhSize > srcSize) return ERROR(corruption_detected); - memcpy(dctx->litBuffer, istart+lhSize, litSize); - dctx->litPtr = dctx->litBuffer; - dctx->litSize = litSize; - memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH); - return lhSize+litSize; - } - /* direct reference into compressed stream */ - dctx->litPtr = istart+lhSize; - dctx->litSize = litSize; - return lhSize+litSize; - } - case lbt_rle: - { size_t litSize; - U32 lhSize = ((istart[0]) >> 4) & 3; - switch(lhSize) - { - case 0: case 1: default: /* note : default is impossible, since lhSize into [0..3] */ - lhSize = 1; - litSize = istart[0] & 31; - break; - case 2: - litSize = ((istart[0] & 15) << 8) + istart[1]; - break; - case 3: - litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2]; - if (srcSize<4) return ERROR(corruption_detected); /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4 */ - break; - } - if (litSize > ZSTDv07_BLOCKSIZE_ABSOLUTEMAX) return ERROR(corruption_detected); - memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH); - dctx->litPtr = dctx->litBuffer; - dctx->litSize = litSize; - return lhSize+1; - } - default: - return ERROR(corruption_detected); /* impossible */ - } -} - - -/*! ZSTDv07_buildSeqTable() : - @return : nb bytes read from src, - or an error code if it fails, testable with ZSTDv07_isError() -*/ -static size_t ZSTDv07_buildSeqTable(FSEv07_DTable* DTable, U32 type, U32 max, U32 maxLog, - const void* src, size_t srcSize, - const S16* defaultNorm, U32 defaultLog, U32 flagRepeatTable) -{ - switch(type) - { - case FSEv07_ENCODING_RLE : - if (!srcSize) return ERROR(srcSize_wrong); - if ( (*(const BYTE*)src) > max) return ERROR(corruption_detected); - FSEv07_buildDTable_rle(DTable, *(const BYTE*)src); /* if *src > max, data is corrupted */ - return 1; - case FSEv07_ENCODING_RAW : - FSEv07_buildDTable(DTable, defaultNorm, max, defaultLog); - return 0; - case FSEv07_ENCODING_STATIC: - if (!flagRepeatTable) return ERROR(corruption_detected); - return 0; - default : /* impossible */ - case FSEv07_ENCODING_DYNAMIC : - { U32 tableLog; - S16 norm[MaxSeq+1]; - size_t const headerSize = FSEv07_readNCount(norm, &max, &tableLog, src, srcSize); - if (FSEv07_isError(headerSize)) return ERROR(corruption_detected); - if (tableLog > maxLog) return ERROR(corruption_detected); - FSEv07_buildDTable(DTable, norm, max, tableLog); - return headerSize; - } } -} - - -static size_t ZSTDv07_decodeSeqHeaders(int* nbSeqPtr, - FSEv07_DTable* DTableLL, FSEv07_DTable* DTableML, FSEv07_DTable* DTableOffb, U32 flagRepeatTable, - const void* src, size_t srcSize) -{ - const BYTE* const istart = (const BYTE*)src; - const BYTE* const iend = istart + srcSize; - const BYTE* ip = istart; - - /* check */ - if (srcSize < MIN_SEQUENCES_SIZE) return ERROR(srcSize_wrong); - - /* SeqHead */ - { int nbSeq = *ip++; - if (!nbSeq) { *nbSeqPtr=0; return 1; } - if (nbSeq > 0x7F) { - if (nbSeq == 0xFF) { - if (ip+2 > iend) return ERROR(srcSize_wrong); - nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2; - } else { - if (ip >= iend) return ERROR(srcSize_wrong); - nbSeq = ((nbSeq-0x80)<<8) + *ip++; - } - } - *nbSeqPtr = nbSeq; - } - - /* FSE table descriptors */ - if (ip + 4 > iend) return ERROR(srcSize_wrong); /* min : header byte + all 3 are "raw", hence no header, but at least xxLog bits per type */ - { U32 const LLtype = *ip >> 6; - U32 const OFtype = (*ip >> 4) & 3; - U32 const MLtype = (*ip >> 2) & 3; - ip++; - - /* Build DTables */ - { size_t const llhSize = ZSTDv07_buildSeqTable(DTableLL, LLtype, MaxLL, LLFSELog, ip, iend-ip, LL_defaultNorm, LL_defaultNormLog, flagRepeatTable); - if (ZSTDv07_isError(llhSize)) return ERROR(corruption_detected); - ip += llhSize; - } - { size_t const ofhSize = ZSTDv07_buildSeqTable(DTableOffb, OFtype, MaxOff, OffFSELog, ip, iend-ip, OF_defaultNorm, OF_defaultNormLog, flagRepeatTable); - if (ZSTDv07_isError(ofhSize)) return ERROR(corruption_detected); - ip += ofhSize; - } - { size_t const mlhSize = ZSTDv07_buildSeqTable(DTableML, MLtype, MaxML, MLFSELog, ip, iend-ip, ML_defaultNorm, ML_defaultNormLog, flagRepeatTable); - if (ZSTDv07_isError(mlhSize)) return ERROR(corruption_detected); - ip += mlhSize; - } } - - return ip-istart; -} - - -typedef struct { - size_t litLength; - size_t matchLength; - size_t offset; -} seq_t; - -typedef struct { - BITv07_DStream_t DStream; - FSEv07_DState_t stateLL; - FSEv07_DState_t stateOffb; - FSEv07_DState_t stateML; - size_t prevOffset[ZSTDv07_REP_INIT]; -} seqState_t; - - -static seq_t ZSTDv07_decodeSequence(seqState_t* seqState) -{ - seq_t seq; - - U32 const llCode = FSEv07_peekSymbol(&(seqState->stateLL)); - U32 const mlCode = FSEv07_peekSymbol(&(seqState->stateML)); - U32 const ofCode = FSEv07_peekSymbol(&(seqState->stateOffb)); /* <= maxOff, by table construction */ - - U32 const llBits = LL_bits[llCode]; - U32 const mlBits = ML_bits[mlCode]; - U32 const ofBits = ofCode; - U32 const totalBits = llBits+mlBits+ofBits; - - static const U32 LL_base[MaxLL+1] = { - 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 18, 20, 22, 24, 28, 32, 40, 48, 64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000, - 0x2000, 0x4000, 0x8000, 0x10000 }; - - static const U32 ML_base[MaxML+1] = { - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 37, 39, 41, 43, 47, 51, 59, 67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803, - 0x1003, 0x2003, 0x4003, 0x8003, 0x10003 }; - - static const U32 OF_base[MaxOff+1] = { - 0, 1, 1, 5, 0xD, 0x1D, 0x3D, 0x7D, - 0xFD, 0x1FD, 0x3FD, 0x7FD, 0xFFD, 0x1FFD, 0x3FFD, 0x7FFD, - 0xFFFD, 0x1FFFD, 0x3FFFD, 0x7FFFD, 0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD, - 0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD }; - - /* sequence */ - { size_t offset; - if (!ofCode) - offset = 0; - else { - offset = OF_base[ofCode] + BITv07_readBits(&(seqState->DStream), ofBits); /* <= (ZSTDv07_WINDOWLOG_MAX-1) bits */ - if (MEM_32bits()) BITv07_reloadDStream(&(seqState->DStream)); - } - - if (ofCode <= 1) { - if ((llCode == 0) & (offset <= 1)) offset = 1-offset; - if (offset) { - size_t const temp = seqState->prevOffset[offset]; - if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1]; - seqState->prevOffset[1] = seqState->prevOffset[0]; - seqState->prevOffset[0] = offset = temp; - } else { - offset = seqState->prevOffset[0]; - } - } else { - seqState->prevOffset[2] = seqState->prevOffset[1]; - seqState->prevOffset[1] = seqState->prevOffset[0]; - seqState->prevOffset[0] = offset; - } - seq.offset = offset; - } - - seq.matchLength = ML_base[mlCode] + ((mlCode>31) ? BITv07_readBits(&(seqState->DStream), mlBits) : 0); /* <= 16 bits */ - if (MEM_32bits() && (mlBits+llBits>24)) BITv07_reloadDStream(&(seqState->DStream)); - - seq.litLength = LL_base[llCode] + ((llCode>15) ? BITv07_readBits(&(seqState->DStream), llBits) : 0); /* <= 16 bits */ - if (MEM_32bits() || - (totalBits > 64 - 7 - (LLFSELog+MLFSELog+OffFSELog)) ) BITv07_reloadDStream(&(seqState->DStream)); - - /* ANS state update */ - FSEv07_updateState(&(seqState->stateLL), &(seqState->DStream)); /* <= 9 bits */ - FSEv07_updateState(&(seqState->stateML), &(seqState->DStream)); /* <= 9 bits */ - if (MEM_32bits()) BITv07_reloadDStream(&(seqState->DStream)); /* <= 18 bits */ - FSEv07_updateState(&(seqState->stateOffb), &(seqState->DStream)); /* <= 8 bits */ - - return seq; -} - - -static -size_t ZSTDv07_execSequence(BYTE* op, - BYTE* const oend, seq_t sequence, - const BYTE** litPtr, const BYTE* const litLimit, - const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd) -{ - BYTE* const oLitEnd = op + sequence.litLength; - size_t const sequenceLength = sequence.litLength + sequence.matchLength; - BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */ - BYTE* const oend_w = oend-WILDCOPY_OVERLENGTH; - const BYTE* const iLitEnd = *litPtr + sequence.litLength; - const BYTE* match = oLitEnd - sequence.offset; - - /* check */ - assert(oend >= op); - if (sequence.litLength + WILDCOPY_OVERLENGTH > (size_t)(oend - op)) return ERROR(dstSize_tooSmall); - if (sequenceLength > (size_t)(oend - op)) return ERROR(dstSize_tooSmall); - assert(litLimit >= *litPtr); - if (sequence.litLength > (size_t)(litLimit - *litPtr)) return ERROR(corruption_detected);; - - /* copy Literals */ - ZSTDv07_wildcopy(op, *litPtr, (ptrdiff_t)sequence.litLength); /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, no risk of overwrite beyond oend */ - op = oLitEnd; - *litPtr = iLitEnd; /* update for next sequence */ - - /* copy Match */ - if (sequence.offset > (size_t)(oLitEnd - base)) { - /* offset beyond prefix */ - if (sequence.offset > (size_t)(oLitEnd - vBase)) return ERROR(corruption_detected); - match = dictEnd - (base-match); - if (match + sequence.matchLength <= dictEnd) { - memmove(oLitEnd, match, sequence.matchLength); - return sequenceLength; - } - /* span extDict & currentPrefixSegment */ - { size_t const length1 = (size_t)(dictEnd - match); - memmove(oLitEnd, match, length1); - op = oLitEnd + length1; - sequence.matchLength -= length1; - match = base; - if (op > oend_w || sequence.matchLength < MINMATCH) { - while (op < oMatchEnd) *op++ = *match++; - return sequenceLength; - } - } } - /* Requirement: op <= oend_w */ - - /* match within prefix */ - if (sequence.offset < 8) { - /* close range match, overlap */ - static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 }; /* added */ - static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 }; /* subtracted */ - int const sub2 = dec64table[sequence.offset]; - op[0] = match[0]; - op[1] = match[1]; - op[2] = match[2]; - op[3] = match[3]; - match += dec32table[sequence.offset]; - ZSTDv07_copy4(op+4, match); - match -= sub2; - } else { - ZSTDv07_copy8(op, match); - } - op += 8; match += 8; - - if (oMatchEnd > oend-(16-MINMATCH)) { - if (op < oend_w) { - ZSTDv07_wildcopy(op, match, oend_w - op); - match += oend_w - op; - op = oend_w; - } - while (op < oMatchEnd) *op++ = *match++; - } else { - ZSTDv07_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8); /* works even if matchLength < 8 */ - } - return sequenceLength; -} - - -static size_t ZSTDv07_decompressSequences( - ZSTDv07_DCtx* dctx, - void* dst, size_t maxDstSize, - const void* seqStart, size_t seqSize) -{ - const BYTE* ip = (const BYTE*)seqStart; - const BYTE* const iend = ip + seqSize; - BYTE* const ostart = (BYTE*)dst; - BYTE* const oend = ostart + maxDstSize; - BYTE* op = ostart; - const BYTE* litPtr = dctx->litPtr; - const BYTE* const litEnd = litPtr + dctx->litSize; - FSEv07_DTable* DTableLL = dctx->LLTable; - FSEv07_DTable* DTableML = dctx->MLTable; - FSEv07_DTable* DTableOffb = dctx->OffTable; - const BYTE* const base = (const BYTE*) (dctx->base); - const BYTE* const vBase = (const BYTE*) (dctx->vBase); - const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd); - int nbSeq; - - /* Build Decoding Tables */ - { size_t const seqHSize = ZSTDv07_decodeSeqHeaders(&nbSeq, DTableLL, DTableML, DTableOffb, dctx->fseEntropy, ip, seqSize); - if (ZSTDv07_isError(seqHSize)) return seqHSize; - ip += seqHSize; - } - - /* Regen sequences */ - if (nbSeq) { - seqState_t seqState; - dctx->fseEntropy = 1; - { U32 i; for (i=0; irep[i]; } - { size_t const errorCode = BITv07_initDStream(&(seqState.DStream), ip, iend-ip); - if (ERR_isError(errorCode)) return ERROR(corruption_detected); } - FSEv07_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL); - FSEv07_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb); - FSEv07_initDState(&(seqState.stateML), &(seqState.DStream), DTableML); - - for ( ; (BITv07_reloadDStream(&(seqState.DStream)) <= BITv07_DStream_completed) && nbSeq ; ) { - nbSeq--; - { seq_t const sequence = ZSTDv07_decodeSequence(&seqState); - size_t const oneSeqSize = ZSTDv07_execSequence(op, oend, sequence, &litPtr, litEnd, base, vBase, dictEnd); - if (ZSTDv07_isError(oneSeqSize)) return oneSeqSize; - op += oneSeqSize; - } } - - /* check if reached exact end */ - if (nbSeq) return ERROR(corruption_detected); - /* save reps for next block */ - { U32 i; for (i=0; irep[i] = (U32)(seqState.prevOffset[i]); } - } - - /* last literal segment */ - { size_t const lastLLSize = litEnd - litPtr; - /* if (litPtr > litEnd) return ERROR(corruption_detected); */ /* too many literals already used */ - if (lastLLSize > (size_t)(oend-op)) return ERROR(dstSize_tooSmall); - if (lastLLSize > 0) { - memcpy(op, litPtr, lastLLSize); - op += lastLLSize; - } - } - - return op-ostart; -} - - -static void ZSTDv07_checkContinuity(ZSTDv07_DCtx* dctx, const void* dst) -{ - if (dst != dctx->previousDstEnd) { /* not contiguous */ - dctx->dictEnd = dctx->previousDstEnd; - dctx->vBase = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base)); - dctx->base = dst; - dctx->previousDstEnd = dst; - } -} - - -static size_t ZSTDv07_decompressBlock_internal(ZSTDv07_DCtx* dctx, - void* dst, size_t dstCapacity, - const void* src, size_t srcSize) -{ /* blockType == blockCompressed */ - const BYTE* ip = (const BYTE*)src; - - if (srcSize >= ZSTDv07_BLOCKSIZE_ABSOLUTEMAX) return ERROR(srcSize_wrong); - - /* Decode literals sub-block */ - { size_t const litCSize = ZSTDv07_decodeLiteralsBlock(dctx, src, srcSize); - if (ZSTDv07_isError(litCSize)) return litCSize; - ip += litCSize; - srcSize -= litCSize; - } - return ZSTDv07_decompressSequences(dctx, dst, dstCapacity, ip, srcSize); -} - - -size_t ZSTDv07_decompressBlock(ZSTDv07_DCtx* dctx, - void* dst, size_t dstCapacity, - const void* src, size_t srcSize) -{ - size_t dSize; - ZSTDv07_checkContinuity(dctx, dst); - dSize = ZSTDv07_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize); - dctx->previousDstEnd = (char*)dst + dSize; - return dSize; -} - - -/** ZSTDv07_insertBlock() : - insert `src` block into `dctx` history. Useful to track uncompressed blocks. */ -ZSTDLIBv07_API size_t ZSTDv07_insertBlock(ZSTDv07_DCtx* dctx, const void* blockStart, size_t blockSize) -{ - ZSTDv07_checkContinuity(dctx, blockStart); - dctx->previousDstEnd = (const char*)blockStart + blockSize; - return blockSize; -} - - -static size_t ZSTDv07_generateNxBytes(void* dst, size_t dstCapacity, BYTE byte, size_t length) -{ - if (length > dstCapacity) return ERROR(dstSize_tooSmall); - if (length > 0) { - memset(dst, byte, length); - } - return length; -} - - -/*! ZSTDv07_decompressFrame() : -* `dctx` must be properly initialized */ -static size_t ZSTDv07_decompressFrame(ZSTDv07_DCtx* dctx, - void* dst, size_t dstCapacity, - const void* src, size_t srcSize) -{ - const BYTE* ip = (const BYTE*)src; - const BYTE* const iend = ip + srcSize; - BYTE* const ostart = (BYTE*)dst; - BYTE* const oend = ostart + dstCapacity; - BYTE* op = ostart; - size_t remainingSize = srcSize; - - /* check */ - if (srcSize < ZSTDv07_frameHeaderSize_min+ZSTDv07_blockHeaderSize) return ERROR(srcSize_wrong); - - /* Frame Header */ - { size_t const frameHeaderSize = ZSTDv07_frameHeaderSize(src, ZSTDv07_frameHeaderSize_min); - if (ZSTDv07_isError(frameHeaderSize)) return frameHeaderSize; - if (srcSize < frameHeaderSize+ZSTDv07_blockHeaderSize) return ERROR(srcSize_wrong); - if (ZSTDv07_decodeFrameHeader(dctx, src, frameHeaderSize)) return ERROR(corruption_detected); - ip += frameHeaderSize; remainingSize -= frameHeaderSize; - } - - /* Loop on each block */ - while (1) { - size_t decodedSize; - blockProperties_t blockProperties; - size_t const cBlockSize = ZSTDv07_getcBlockSize(ip, iend-ip, &blockProperties); - if (ZSTDv07_isError(cBlockSize)) return cBlockSize; - - ip += ZSTDv07_blockHeaderSize; - remainingSize -= ZSTDv07_blockHeaderSize; - if (cBlockSize > remainingSize) return ERROR(srcSize_wrong); - - switch(blockProperties.blockType) - { - case bt_compressed: - decodedSize = ZSTDv07_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize); - break; - case bt_raw : - decodedSize = ZSTDv07_copyRawBlock(op, oend-op, ip, cBlockSize); - break; - case bt_rle : - decodedSize = ZSTDv07_generateNxBytes(op, oend-op, *ip, blockProperties.origSize); - break; - case bt_end : - /* end of frame */ - if (remainingSize) return ERROR(srcSize_wrong); - decodedSize = 0; - break; - default: - return ERROR(GENERIC); /* impossible */ - } - if (blockProperties.blockType == bt_end) break; /* bt_end */ - - if (ZSTDv07_isError(decodedSize)) return decodedSize; - if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, op, decodedSize); - op += decodedSize; - ip += cBlockSize; - remainingSize -= cBlockSize; - } - - return op-ostart; -} - - -/*! ZSTDv07_decompress_usingPreparedDCtx() : -* Same as ZSTDv07_decompress_usingDict, but using a reference context `preparedDCtx`, where dictionary has been loaded. -* It avoids reloading the dictionary each time. -* `preparedDCtx` must have been properly initialized using ZSTDv07_decompressBegin_usingDict(). -* Requires 2 contexts : 1 for reference (preparedDCtx), which will not be modified, and 1 to run the decompression operation (dctx) */ -static size_t ZSTDv07_decompress_usingPreparedDCtx(ZSTDv07_DCtx* dctx, const ZSTDv07_DCtx* refDCtx, - void* dst, size_t dstCapacity, - const void* src, size_t srcSize) -{ - ZSTDv07_copyDCtx(dctx, refDCtx); - ZSTDv07_checkContinuity(dctx, dst); - return ZSTDv07_decompressFrame(dctx, dst, dstCapacity, src, srcSize); -} - - -size_t ZSTDv07_decompress_usingDict(ZSTDv07_DCtx* dctx, - void* dst, size_t dstCapacity, - const void* src, size_t srcSize, - const void* dict, size_t dictSize) -{ - ZSTDv07_decompressBegin_usingDict(dctx, dict, dictSize); - ZSTDv07_checkContinuity(dctx, dst); - return ZSTDv07_decompressFrame(dctx, dst, dstCapacity, src, srcSize); -} - - -size_t ZSTDv07_decompressDCtx(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) -{ - return ZSTDv07_decompress_usingDict(dctx, dst, dstCapacity, src, srcSize, NULL, 0); -} - - -size_t ZSTDv07_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize) -{ -#if defined(ZSTDv07_HEAPMODE) && (ZSTDv07_HEAPMODE==1) - size_t regenSize; - ZSTDv07_DCtx* const dctx = ZSTDv07_createDCtx(); - if (dctx==NULL) return ERROR(memory_allocation); - regenSize = ZSTDv07_decompressDCtx(dctx, dst, dstCapacity, src, srcSize); - ZSTDv07_freeDCtx(dctx); - return regenSize; -#else /* stack mode */ - ZSTDv07_DCtx dctx; - return ZSTDv07_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize); -#endif -} - -/* ZSTD_errorFrameSizeInfoLegacy() : - assumes `cSize` and `dBound` are _not_ NULL */ -static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret) -{ - *cSize = ret; - *dBound = ZSTD_CONTENTSIZE_ERROR; -} - -void ZSTDv07_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cSize, unsigned long long* dBound) -{ - const BYTE* ip = (const BYTE*)src; - size_t remainingSize = srcSize; - size_t nbBlocks = 0; - - /* check */ - if (srcSize < ZSTDv07_frameHeaderSize_min+ZSTDv07_blockHeaderSize) { - ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong)); - return; - } - - /* Frame Header */ - { size_t const frameHeaderSize = ZSTDv07_frameHeaderSize(src, srcSize); - if (ZSTDv07_isError(frameHeaderSize)) { - ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, frameHeaderSize); - return; - } - if (MEM_readLE32(src) != ZSTDv07_MAGICNUMBER) { - ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(prefix_unknown)); - return; - } - if (srcSize < frameHeaderSize+ZSTDv07_blockHeaderSize) { - ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong)); - return; - } - ip += frameHeaderSize; remainingSize -= frameHeaderSize; - } - - /* Loop on each block */ - while (1) { - blockProperties_t blockProperties; - size_t const cBlockSize = ZSTDv07_getcBlockSize(ip, remainingSize, &blockProperties); - if (ZSTDv07_isError(cBlockSize)) { - ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, cBlockSize); - return; - } - - ip += ZSTDv07_blockHeaderSize; - remainingSize -= ZSTDv07_blockHeaderSize; - - if (blockProperties.blockType == bt_end) break; - - if (cBlockSize > remainingSize) { - ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong)); - return; - } - - ip += cBlockSize; - remainingSize -= cBlockSize; - nbBlocks++; - } - - *cSize = ip - (const BYTE*)src; - *dBound = nbBlocks * ZSTDv07_BLOCKSIZE_ABSOLUTEMAX; -} - -/*_****************************** -* Streaming Decompression API -********************************/ -size_t ZSTDv07_nextSrcSizeToDecompress(ZSTDv07_DCtx* dctx) -{ - return dctx->expected; -} - -int ZSTDv07_isSkipFrame(ZSTDv07_DCtx* dctx) -{ - return dctx->stage == ZSTDds_skipFrame; -} - -/** ZSTDv07_decompressContinue() : -* @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity) -* or an error code, which can be tested using ZSTDv07_isError() */ -size_t ZSTDv07_decompressContinue(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) -{ - /* Sanity check */ - if (srcSize != dctx->expected) return ERROR(srcSize_wrong); - if (dstCapacity) ZSTDv07_checkContinuity(dctx, dst); - - switch (dctx->stage) - { - case ZSTDds_getFrameHeaderSize : - if (srcSize != ZSTDv07_frameHeaderSize_min) return ERROR(srcSize_wrong); /* impossible */ - if ((MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTDv07_MAGIC_SKIPPABLE_START) { - memcpy(dctx->headerBuffer, src, ZSTDv07_frameHeaderSize_min); - dctx->expected = ZSTDv07_skippableHeaderSize - ZSTDv07_frameHeaderSize_min; /* magic number + skippable frame length */ - dctx->stage = ZSTDds_decodeSkippableHeader; - return 0; - } - dctx->headerSize = ZSTDv07_frameHeaderSize(src, ZSTDv07_frameHeaderSize_min); - if (ZSTDv07_isError(dctx->headerSize)) return dctx->headerSize; - memcpy(dctx->headerBuffer, src, ZSTDv07_frameHeaderSize_min); - if (dctx->headerSize > ZSTDv07_frameHeaderSize_min) { - dctx->expected = dctx->headerSize - ZSTDv07_frameHeaderSize_min; - dctx->stage = ZSTDds_decodeFrameHeader; - return 0; - } - dctx->expected = 0; /* not necessary to copy more */ - /* fall-through */ - case ZSTDds_decodeFrameHeader: - { size_t result; - memcpy(dctx->headerBuffer + ZSTDv07_frameHeaderSize_min, src, dctx->expected); - result = ZSTDv07_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize); - if (ZSTDv07_isError(result)) return result; - dctx->expected = ZSTDv07_blockHeaderSize; - dctx->stage = ZSTDds_decodeBlockHeader; - return 0; - } - case ZSTDds_decodeBlockHeader: - { blockProperties_t bp; - size_t const cBlockSize = ZSTDv07_getcBlockSize(src, ZSTDv07_blockHeaderSize, &bp); - if (ZSTDv07_isError(cBlockSize)) return cBlockSize; - if (bp.blockType == bt_end) { - if (dctx->fParams.checksumFlag) { - U64 const h64 = XXH64_digest(&dctx->xxhState); - U32 const h32 = (U32)(h64>>11) & ((1<<22)-1); - const BYTE* const ip = (const BYTE*)src; - U32 const check32 = ip[2] + (ip[1] << 8) + ((ip[0] & 0x3F) << 16); - if (check32 != h32) return ERROR(checksum_wrong); - } - dctx->expected = 0; - dctx->stage = ZSTDds_getFrameHeaderSize; - } else { - dctx->expected = cBlockSize; - dctx->bType = bp.blockType; - dctx->stage = ZSTDds_decompressBlock; - } - return 0; - } - case ZSTDds_decompressBlock: - { size_t rSize; - switch(dctx->bType) - { - case bt_compressed: - rSize = ZSTDv07_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize); - break; - case bt_raw : - rSize = ZSTDv07_copyRawBlock(dst, dstCapacity, src, srcSize); - break; - case bt_rle : - return ERROR(GENERIC); /* not yet handled */ - break; - case bt_end : /* should never happen (filtered at phase 1) */ - rSize = 0; - break; - default: - return ERROR(GENERIC); /* impossible */ - } - dctx->stage = ZSTDds_decodeBlockHeader; - dctx->expected = ZSTDv07_blockHeaderSize; - if (ZSTDv07_isError(rSize)) return rSize; - dctx->previousDstEnd = (char*)dst + rSize; - if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, dst, rSize); - return rSize; - } - case ZSTDds_decodeSkippableHeader: - { memcpy(dctx->headerBuffer + ZSTDv07_frameHeaderSize_min, src, dctx->expected); - dctx->expected = MEM_readLE32(dctx->headerBuffer + 4); - dctx->stage = ZSTDds_skipFrame; - return 0; - } - case ZSTDds_skipFrame: - { dctx->expected = 0; - dctx->stage = ZSTDds_getFrameHeaderSize; - return 0; - } - default: - return ERROR(GENERIC); /* impossible */ - } -} - - -static size_t ZSTDv07_refDictContent(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize) -{ - dctx->dictEnd = dctx->previousDstEnd; - dctx->vBase = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base)); - dctx->base = dict; - dctx->previousDstEnd = (const char*)dict + dictSize; - return 0; -} - -static size_t ZSTDv07_loadEntropy(ZSTDv07_DCtx* dctx, const void* const dict, size_t const dictSize) -{ - const BYTE* dictPtr = (const BYTE*)dict; - const BYTE* const dictEnd = dictPtr + dictSize; - - { size_t const hSize = HUFv07_readDTableX4(dctx->hufTable, dict, dictSize); - if (HUFv07_isError(hSize)) return ERROR(dictionary_corrupted); - dictPtr += hSize; - } - - { short offcodeNCount[MaxOff+1]; - U32 offcodeMaxValue=MaxOff, offcodeLog; - size_t const offcodeHeaderSize = FSEv07_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr); - if (FSEv07_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted); - if (offcodeLog > OffFSELog) return ERROR(dictionary_corrupted); - { size_t const errorCode = FSEv07_buildDTable(dctx->OffTable, offcodeNCount, offcodeMaxValue, offcodeLog); - if (FSEv07_isError(errorCode)) return ERROR(dictionary_corrupted); } - dictPtr += offcodeHeaderSize; - } - - { short matchlengthNCount[MaxML+1]; - unsigned matchlengthMaxValue = MaxML, matchlengthLog; - size_t const matchlengthHeaderSize = FSEv07_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr); - if (FSEv07_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted); - if (matchlengthLog > MLFSELog) return ERROR(dictionary_corrupted); - { size_t const errorCode = FSEv07_buildDTable(dctx->MLTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog); - if (FSEv07_isError(errorCode)) return ERROR(dictionary_corrupted); } - dictPtr += matchlengthHeaderSize; - } - - { short litlengthNCount[MaxLL+1]; - unsigned litlengthMaxValue = MaxLL, litlengthLog; - size_t const litlengthHeaderSize = FSEv07_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr); - if (FSEv07_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted); - if (litlengthLog > LLFSELog) return ERROR(dictionary_corrupted); - { size_t const errorCode = FSEv07_buildDTable(dctx->LLTable, litlengthNCount, litlengthMaxValue, litlengthLog); - if (FSEv07_isError(errorCode)) return ERROR(dictionary_corrupted); } - dictPtr += litlengthHeaderSize; - } - - if (dictPtr+12 > dictEnd) return ERROR(dictionary_corrupted); - dctx->rep[0] = MEM_readLE32(dictPtr+0); if (dctx->rep[0] == 0 || dctx->rep[0] >= dictSize) return ERROR(dictionary_corrupted); - dctx->rep[1] = MEM_readLE32(dictPtr+4); if (dctx->rep[1] == 0 || dctx->rep[1] >= dictSize) return ERROR(dictionary_corrupted); - dctx->rep[2] = MEM_readLE32(dictPtr+8); if (dctx->rep[2] == 0 || dctx->rep[2] >= dictSize) return ERROR(dictionary_corrupted); - dictPtr += 12; - - dctx->litEntropy = dctx->fseEntropy = 1; - return dictPtr - (const BYTE*)dict; -} - -static size_t ZSTDv07_decompress_insertDictionary(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize) -{ - if (dictSize < 8) return ZSTDv07_refDictContent(dctx, dict, dictSize); - { U32 const magic = MEM_readLE32(dict); - if (magic != ZSTDv07_DICT_MAGIC) { - return ZSTDv07_refDictContent(dctx, dict, dictSize); /* pure content mode */ - } } - dctx->dictID = MEM_readLE32((const char*)dict + 4); - - /* load entropy tables */ - dict = (const char*)dict + 8; - dictSize -= 8; - { size_t const eSize = ZSTDv07_loadEntropy(dctx, dict, dictSize); - if (ZSTDv07_isError(eSize)) return ERROR(dictionary_corrupted); - dict = (const char*)dict + eSize; - dictSize -= eSize; - } - - /* reference dictionary content */ - return ZSTDv07_refDictContent(dctx, dict, dictSize); -} - - -size_t ZSTDv07_decompressBegin_usingDict(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize) -{ - { size_t const errorCode = ZSTDv07_decompressBegin(dctx); - if (ZSTDv07_isError(errorCode)) return errorCode; } - - if (dict && dictSize) { - size_t const errorCode = ZSTDv07_decompress_insertDictionary(dctx, dict, dictSize); - if (ZSTDv07_isError(errorCode)) return ERROR(dictionary_corrupted); - } - - return 0; -} - - -struct ZSTDv07_DDict_s { - void* dict; - size_t dictSize; - ZSTDv07_DCtx* refContext; -}; /* typedef'd tp ZSTDv07_CDict within zstd.h */ - -static ZSTDv07_DDict* ZSTDv07_createDDict_advanced(const void* dict, size_t dictSize, ZSTDv07_customMem customMem) -{ - if (!customMem.customAlloc && !customMem.customFree) - customMem = defaultCustomMem; - - if (!customMem.customAlloc || !customMem.customFree) - return NULL; - - { ZSTDv07_DDict* const ddict = (ZSTDv07_DDict*) customMem.customAlloc(customMem.opaque, sizeof(*ddict)); - void* const dictContent = customMem.customAlloc(customMem.opaque, dictSize); - ZSTDv07_DCtx* const dctx = ZSTDv07_createDCtx_advanced(customMem); - - if (!dictContent || !ddict || !dctx) { - customMem.customFree(customMem.opaque, dictContent); - customMem.customFree(customMem.opaque, ddict); - customMem.customFree(customMem.opaque, dctx); - return NULL; - } - - memcpy(dictContent, dict, dictSize); - { size_t const errorCode = ZSTDv07_decompressBegin_usingDict(dctx, dictContent, dictSize); - if (ZSTDv07_isError(errorCode)) { - customMem.customFree(customMem.opaque, dictContent); - customMem.customFree(customMem.opaque, ddict); - customMem.customFree(customMem.opaque, dctx); - return NULL; - } } - - ddict->dict = dictContent; - ddict->dictSize = dictSize; - ddict->refContext = dctx; - return ddict; - } -} - -/*! ZSTDv07_createDDict() : -* Create a digested dictionary, ready to start decompression without startup delay. -* `dict` can be released after `ZSTDv07_DDict` creation */ -ZSTDv07_DDict* ZSTDv07_createDDict(const void* dict, size_t dictSize) -{ - ZSTDv07_customMem const allocator = { NULL, NULL, NULL }; - return ZSTDv07_createDDict_advanced(dict, dictSize, allocator); -} - -size_t ZSTDv07_freeDDict(ZSTDv07_DDict* ddict) -{ - ZSTDv07_freeFunction const cFree = ddict->refContext->customMem.customFree; - void* const opaque = ddict->refContext->customMem.opaque; - ZSTDv07_freeDCtx(ddict->refContext); - cFree(opaque, ddict->dict); - cFree(opaque, ddict); - return 0; -} - -/*! ZSTDv07_decompress_usingDDict() : -* Decompression using a pre-digested Dictionary -* Use dictionary without significant overhead. */ -ZSTDLIBv07_API size_t ZSTDv07_decompress_usingDDict(ZSTDv07_DCtx* dctx, - void* dst, size_t dstCapacity, - const void* src, size_t srcSize, - const ZSTDv07_DDict* ddict) -{ - return ZSTDv07_decompress_usingPreparedDCtx(dctx, ddict->refContext, - dst, dstCapacity, - src, srcSize); -} -/* - Buffered version of Zstd compression library - Copyright (C) 2015-2016, Yann Collet. - - BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php) - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are - met: - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following disclaimer - in the documentation and/or other materials provided with the - distribution. - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - You can contact the author at : - - zstd homepage : https://facebook.github.io/zstd/ -*/ - - - -/*-*************************************************************************** -* Streaming decompression howto -* -* A ZBUFFv07_DCtx object is required to track streaming operations. -* Use ZBUFFv07_createDCtx() and ZBUFFv07_freeDCtx() to create/release resources. -* Use ZBUFFv07_decompressInit() to start a new decompression operation, -* or ZBUFFv07_decompressInitDictionary() if decompression requires a dictionary. -* Note that ZBUFFv07_DCtx objects can be re-init multiple times. -* -* Use ZBUFFv07_decompressContinue() repetitively to consume your input. -* *srcSizePtr and *dstCapacityPtr can be any size. -* The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr. -* Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again. -* The content of @dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change @dst. -* @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency), -* or 0 when a frame is completely decoded, -* or an error code, which can be tested using ZBUFFv07_isError(). -* -* Hint : recommended buffer sizes (not compulsory) : ZBUFFv07_recommendedDInSize() and ZBUFFv07_recommendedDOutSize() -* output : ZBUFFv07_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded. -* input : ZBUFFv07_recommendedDInSize == 128KB + 3; -* just follow indications from ZBUFFv07_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 . -* *******************************************************************************/ - -typedef enum { ZBUFFds_init, ZBUFFds_loadHeader, - ZBUFFds_read, ZBUFFds_load, ZBUFFds_flush } ZBUFFv07_dStage; - -/* *** Resource management *** */ -struct ZBUFFv07_DCtx_s { - ZSTDv07_DCtx* zd; - ZSTDv07_frameParams fParams; - ZBUFFv07_dStage stage; - char* inBuff; - size_t inBuffSize; - size_t inPos; - char* outBuff; - size_t outBuffSize; - size_t outStart; - size_t outEnd; - size_t blockSize; - BYTE headerBuffer[ZSTDv07_FRAMEHEADERSIZE_MAX]; - size_t lhSize; - ZSTDv07_customMem customMem; -}; /* typedef'd to ZBUFFv07_DCtx within "zstd_buffered.h" */ - -ZSTDLIBv07_API ZBUFFv07_DCtx* ZBUFFv07_createDCtx_advanced(ZSTDv07_customMem customMem); - -ZBUFFv07_DCtx* ZBUFFv07_createDCtx(void) -{ - return ZBUFFv07_createDCtx_advanced(defaultCustomMem); -} - -ZBUFFv07_DCtx* ZBUFFv07_createDCtx_advanced(ZSTDv07_customMem customMem) -{ - ZBUFFv07_DCtx* zbd; - - if (!customMem.customAlloc && !customMem.customFree) - customMem = defaultCustomMem; - - if (!customMem.customAlloc || !customMem.customFree) - return NULL; - - zbd = (ZBUFFv07_DCtx*)customMem.customAlloc(customMem.opaque, sizeof(ZBUFFv07_DCtx)); - if (zbd==NULL) return NULL; - memset(zbd, 0, sizeof(ZBUFFv07_DCtx)); - memcpy(&zbd->customMem, &customMem, sizeof(ZSTDv07_customMem)); - zbd->zd = ZSTDv07_createDCtx_advanced(customMem); - if (zbd->zd == NULL) { ZBUFFv07_freeDCtx(zbd); return NULL; } - zbd->stage = ZBUFFds_init; - return zbd; -} - -size_t ZBUFFv07_freeDCtx(ZBUFFv07_DCtx* zbd) -{ - if (zbd==NULL) return 0; /* support free on null */ - ZSTDv07_freeDCtx(zbd->zd); - if (zbd->inBuff) zbd->customMem.customFree(zbd->customMem.opaque, zbd->inBuff); - if (zbd->outBuff) zbd->customMem.customFree(zbd->customMem.opaque, zbd->outBuff); - zbd->customMem.customFree(zbd->customMem.opaque, zbd); - return 0; -} - - -/* *** Initialization *** */ - -size_t ZBUFFv07_decompressInitDictionary(ZBUFFv07_DCtx* zbd, const void* dict, size_t dictSize) -{ - zbd->stage = ZBUFFds_loadHeader; - zbd->lhSize = zbd->inPos = zbd->outStart = zbd->outEnd = 0; - return ZSTDv07_decompressBegin_usingDict(zbd->zd, dict, dictSize); -} - -size_t ZBUFFv07_decompressInit(ZBUFFv07_DCtx* zbd) -{ - return ZBUFFv07_decompressInitDictionary(zbd, NULL, 0); -} - - -/* internal util function */ -MEM_STATIC size_t ZBUFFv07_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize) -{ - size_t const length = MIN(dstCapacity, srcSize); - if (length > 0) { - memcpy(dst, src, length); - } - return length; -} - - -/* *** Decompression *** */ - -size_t ZBUFFv07_decompressContinue(ZBUFFv07_DCtx* zbd, - void* dst, size_t* dstCapacityPtr, - const void* src, size_t* srcSizePtr) -{ - const char* const istart = (const char*)src; - const char* const iend = istart + *srcSizePtr; - const char* ip = istart; - char* const ostart = (char*)dst; - char* const oend = ostart + *dstCapacityPtr; - char* op = ostart; - U32 notDone = 1; - - while (notDone) { - switch(zbd->stage) - { - case ZBUFFds_init : - return ERROR(init_missing); - - case ZBUFFds_loadHeader : - { size_t const hSize = ZSTDv07_getFrameParams(&(zbd->fParams), zbd->headerBuffer, zbd->lhSize); - if (ZSTDv07_isError(hSize)) return hSize; - if (hSize != 0) { - size_t const toLoad = hSize - zbd->lhSize; /* if hSize!=0, hSize > zbd->lhSize */ - if (toLoad > (size_t)(iend-ip)) { /* not enough input to load full header */ - if (ip != NULL) - memcpy(zbd->headerBuffer + zbd->lhSize, ip, iend-ip); - zbd->lhSize += iend-ip; - *dstCapacityPtr = 0; - return (hSize - zbd->lhSize) + ZSTDv07_blockHeaderSize; /* remaining header bytes + next block header */ - } - memcpy(zbd->headerBuffer + zbd->lhSize, ip, toLoad); zbd->lhSize = hSize; ip += toLoad; - break; - } } - - /* Consume header */ - { size_t const h1Size = ZSTDv07_nextSrcSizeToDecompress(zbd->zd); /* == ZSTDv07_frameHeaderSize_min */ - size_t const h1Result = ZSTDv07_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer, h1Size); - if (ZSTDv07_isError(h1Result)) return h1Result; - if (h1Size < zbd->lhSize) { /* long header */ - size_t const h2Size = ZSTDv07_nextSrcSizeToDecompress(zbd->zd); - size_t const h2Result = ZSTDv07_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer+h1Size, h2Size); - if (ZSTDv07_isError(h2Result)) return h2Result; - } } - - zbd->fParams.windowSize = MAX(zbd->fParams.windowSize, 1U << ZSTDv07_WINDOWLOG_ABSOLUTEMIN); - - /* Frame header instruct buffer sizes */ - { size_t const blockSize = MIN(zbd->fParams.windowSize, ZSTDv07_BLOCKSIZE_ABSOLUTEMAX); - zbd->blockSize = blockSize; - if (zbd->inBuffSize < blockSize) { - zbd->customMem.customFree(zbd->customMem.opaque, zbd->inBuff); - zbd->inBuffSize = blockSize; - zbd->inBuff = (char*)zbd->customMem.customAlloc(zbd->customMem.opaque, blockSize); - if (zbd->inBuff == NULL) return ERROR(memory_allocation); - } - { size_t const neededOutSize = zbd->fParams.windowSize + blockSize + WILDCOPY_OVERLENGTH * 2; - if (zbd->outBuffSize < neededOutSize) { - zbd->customMem.customFree(zbd->customMem.opaque, zbd->outBuff); - zbd->outBuffSize = neededOutSize; - zbd->outBuff = (char*)zbd->customMem.customAlloc(zbd->customMem.opaque, neededOutSize); - if (zbd->outBuff == NULL) return ERROR(memory_allocation); - } } } - zbd->stage = ZBUFFds_read; - /* pass-through */ - /* fall-through */ - case ZBUFFds_read: - { size_t const neededInSize = ZSTDv07_nextSrcSizeToDecompress(zbd->zd); - if (neededInSize==0) { /* end of frame */ - zbd->stage = ZBUFFds_init; - notDone = 0; - break; - } - if ((size_t)(iend-ip) >= neededInSize) { /* decode directly from src */ - const int isSkipFrame = ZSTDv07_isSkipFrame(zbd->zd); - size_t const decodedSize = ZSTDv07_decompressContinue(zbd->zd, - zbd->outBuff + zbd->outStart, (isSkipFrame ? 0 : zbd->outBuffSize - zbd->outStart), - ip, neededInSize); - if (ZSTDv07_isError(decodedSize)) return decodedSize; - ip += neededInSize; - if (!decodedSize && !isSkipFrame) break; /* this was just a header */ - zbd->outEnd = zbd->outStart + decodedSize; - zbd->stage = ZBUFFds_flush; - break; - } - if (ip==iend) { notDone = 0; break; } /* no more input */ - zbd->stage = ZBUFFds_load; - } - /* fall-through */ - case ZBUFFds_load: - { size_t const neededInSize = ZSTDv07_nextSrcSizeToDecompress(zbd->zd); - size_t const toLoad = neededInSize - zbd->inPos; /* should always be <= remaining space within inBuff */ - size_t loadedSize; - if (toLoad > zbd->inBuffSize - zbd->inPos) return ERROR(corruption_detected); /* should never happen */ - loadedSize = ZBUFFv07_limitCopy(zbd->inBuff + zbd->inPos, toLoad, ip, iend-ip); - ip += loadedSize; - zbd->inPos += loadedSize; - if (loadedSize < toLoad) { notDone = 0; break; } /* not enough input, wait for more */ - - /* decode loaded input */ - { const int isSkipFrame = ZSTDv07_isSkipFrame(zbd->zd); - size_t const decodedSize = ZSTDv07_decompressContinue(zbd->zd, - zbd->outBuff + zbd->outStart, zbd->outBuffSize - zbd->outStart, - zbd->inBuff, neededInSize); - if (ZSTDv07_isError(decodedSize)) return decodedSize; - zbd->inPos = 0; /* input is consumed */ - if (!decodedSize && !isSkipFrame) { zbd->stage = ZBUFFds_read; break; } /* this was just a header */ - zbd->outEnd = zbd->outStart + decodedSize; - zbd->stage = ZBUFFds_flush; - /* break; */ - /* pass-through */ - } - } - /* fall-through */ - case ZBUFFds_flush: - { size_t const toFlushSize = zbd->outEnd - zbd->outStart; - size_t const flushedSize = ZBUFFv07_limitCopy(op, oend-op, zbd->outBuff + zbd->outStart, toFlushSize); - op += flushedSize; - zbd->outStart += flushedSize; - if (flushedSize == toFlushSize) { - zbd->stage = ZBUFFds_read; - if (zbd->outStart + zbd->blockSize > zbd->outBuffSize) - zbd->outStart = zbd->outEnd = 0; - break; - } - /* cannot flush everything */ - notDone = 0; - break; - } - default: return ERROR(GENERIC); /* impossible */ - } } - - /* result */ - *srcSizePtr = ip-istart; - *dstCapacityPtr = op-ostart; - { size_t nextSrcSizeHint = ZSTDv07_nextSrcSizeToDecompress(zbd->zd); - nextSrcSizeHint -= zbd->inPos; /* already loaded*/ - return nextSrcSizeHint; - } -} - - - -/* ************************************* -* Tool functions -***************************************/ -size_t ZBUFFv07_recommendedDInSize(void) { return ZSTDv07_BLOCKSIZE_ABSOLUTEMAX + ZSTDv07_blockHeaderSize /* block header size*/ ; } -size_t ZBUFFv07_recommendedDOutSize(void) { return ZSTDv07_BLOCKSIZE_ABSOLUTEMAX; } +/* Implementation moved to Rust (rust/src/legacy/zstd_v07.rs). + * The frozen v0.7 decoder, including its embedded FSE/Huff0 snapshot, frame + * state, dictionary handling, and buffered streaming context, now lives in + * Rust; this translation unit remains a declaration-only ABI shim. */ diff --git a/rust/src/legacy/mod.rs b/rust/src/legacy/mod.rs index 3fde6e531..b2086fa47 100644 --- a/rust/src/legacy/mod.rs +++ b/rust/src/legacy/mod.rs @@ -53,3 +53,6 @@ pub mod zstd_v05; #[cfg(feature = "legacy-v06")] pub mod zstd_v06; + +#[cfg(feature = "legacy-v07")] +pub mod zstd_v07; diff --git a/rust/src/legacy/zstd_v07.rs b/rust/src/legacy/zstd_v07.rs new file mode 100644 index 000000000..51e31f1ad --- /dev/null +++ b/rust/src/legacy/zstd_v07.rs @@ -0,0 +1,3964 @@ +#![allow(non_snake_case)] + +//! Frozen decoder for the zstd v0.7 format. +//! +//! `lib/legacy/zstd_v07.c` is an old, self-contained decoder. This module +//! keeps that boundary: it owns its FSE, bit-stream, and Huffman state rather +//! than depending on the current entropy implementations. The public entry +//! points below retain the C ABI and the context is deliberately malloc/free +//! allocated so C callers can continue to own an opaque `ZSTDv07_Dctx`. + +use crate::errors::{ERR_getErrorName, ERR_isError, ZstdErrorCode, ERROR}; +use std::os::raw::{c_char, c_uint, c_void}; +use std::ptr; + +const ZSTD_MAGIC_NUMBER: u32 = 0xFD2F_B527; +const ZSTD_CONTENTSIZE_ERROR: u64 = u64::MAX - 1; + +const BLOCKSIZE: usize = 128 * 1024; +const MIN_SEQUENCES_SIZE: usize = 1; +const MIN_CBLOCK_SIZE: usize = 1 + 1 + MIN_SEQUENCES_SIZE; +const MINMATCH: usize = 3; + +const MAX_ML: u32 = 52; +const MAX_LL: u32 = 35; +const MAX_OFF: u32 = 28; +const ML_FSE_LOG: u32 = 9; +const LL_FSE_LOG: u32 = 9; +const OFF_FSE_LOG: u32 = 8; + +const REPCODE_NUM: usize = 3; +const LONG_NB_SEQ: i32 = 0x7f00; + +const IS_HUF: u8 = 0; +const IS_PCH: u8 = 1; +const IS_RAW: u8 = 2; +const IS_RLE: u8 = 3; + +const FSE_ENCODING_RAW: u32 = 0; +const FSE_ENCODING_RLE: u32 = 1; +const FSE_ENCODING_STATIC: u32 = 2; +const FSE_ENCODING_DYNAMIC: u32 = 3; + +const ZSTD_DICT_MAGIC: u32 = 0xec30_a437; +const ZSTD_WINDOWLOG_ABSOLUTE_MIN: u32 = 10; +const FRAME_HEADER_SIZE_MIN: usize = 5; +const FRAME_HEADER_SIZE_MAX: usize = 18; +const BLOCK_HEADER_SIZE: usize = 3; +const WILDCOPY_OVERLENGTH: usize = 8; + +const FSE_MAX_MEMORY_USAGE: u32 = 14; +const FSE_MAX_SYMBOL_VALUE: u32 = 255; +const FSE_MAX_TABLELOG: u32 = FSE_MAX_MEMORY_USAGE - 2; +const FSE_MIN_TABLELOG: u32 = 5; +const FSE_TABLELOG_ABSOLUTE_MAX: u32 = 15; + +const HUF_MAX_SYMBOL_VALUE: usize = 255; +const HUF_MAX_TABLELOG: usize = 12; +const HUF_ABSOLUTE_MAX_TABLELOG: usize = 16; +const HUF_TABLE_SIZE_U32: usize = 1 + (1 << HUF_MAX_TABLELOG); + +type HufTableX2 = [u32; HUF_TABLE_SIZE_U32]; + +#[inline] +fn huf_max_table_log(desc: u32) -> u32 { + desc & 0xff +} + +#[inline] +fn huf_table_log(desc: u32) -> u32 { + (desc >> 16) & 0xff +} + +#[inline] +fn huf_set_table_type(desc: u32, table_type: u32) -> u32 { + (desc & !0xff00) | ((table_type & 0xff) << 8) +} + +#[inline] +fn huf_set_table_log(desc: u32, table_log: u32) -> u32 { + (desc & !0xff0000) | ((table_log & 0xff) << 16) +} + +#[inline] +fn huf_initial_desc() -> u32 { + (HUF_MAX_TABLELOG as u32) * 0x0100_0001 +} + +const BT_COMPRESSED: u32 = 0; +const BT_RAW: u32 = 1; +const BT_RLE: u32 = 2; +const BT_END: u32 = 3; + +const DSTREAM_UNFINISHED: u32 = 0; +const DSTREAM_END_OF_BUFFER: u32 = 1; +const DSTREAM_COMPLETED: u32 = 2; +const DSTREAM_TOO_FAR: u32 = 3; + +const USIZE_BITS: u32 = usize::BITS; + +const LL_BITS_TABLE: [u32; MAX_LL as usize + 1] = [ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 4, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, +]; +const ML_BITS_TABLE: [u32; MAX_ML as usize + 1] = [ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, +]; +const OF_DEFAULT_NORM: [i16; MAX_OFF as usize + 1] = [ + 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, +]; +const LL_DEFAULT_NORM: [i16; MAX_LL as usize + 1] = [ + 4, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 1, 1, 1, 1, 1, + -1, -1, -1, -1, +]; +const ML_DEFAULT_NORM: [i16; MAX_ML as usize + 1] = [ + 1, 4, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, +]; +const LL_DEFAULT_LOG: u32 = 6; +const ML_DEFAULT_LOG: u32 = 6; +const OF_DEFAULT_LOG: u32 = 5; + +#[repr(C)] +#[derive(Clone, Copy)] +struct FseDecode { + new_state: u16, + symbol: u8, + nb_bits: u8, +} + +#[repr(C)] +struct FseDTableHeader { + table_log: u16, + fast_mode: u16, +} + +#[derive(Clone, Copy)] +struct DStream { + bit_container: usize, + bits_consumed: u32, + ptr: *const u8, + start: *const u8, +} + +#[derive(Clone, Copy)] +struct FseDState { + state: usize, + table: *const FseDecode, +} + +#[inline] +fn highbit32(value: u32) -> u32 { + value.leading_zeros() ^ 31 +} + +#[inline] +unsafe fn write_le16(dst: *mut u8, value: u16) { + let bytes = value.to_le_bytes(); + ptr::copy_nonoverlapping(bytes.as_ptr(), dst, 2); +} + +#[inline] +unsafe fn zstd_copy8(dst: *mut u8, src: *const u8) { + ptr::copy(src, dst, 8); +} + +#[inline] +unsafe fn zstd_copy4(dst: *mut u8, src: *const u8) { + ptr::copy(src, dst, 4); +} + +unsafe fn zstd_wildcopy(dst: *mut u8, src: *const u8, length: isize) { + let mut op = dst; + let mut ip = src; + let end = if length >= 0 { + (dst as usize).wrapping_add(length as usize) + } else { + (dst as usize).wrapping_sub(length.wrapping_neg() as usize) + }; + loop { + zstd_copy8(op, ip); + op = op.add(8); + ip = ip.add(8); + if (op as usize) >= end { + break; + } + } +} + +#[inline] +unsafe fn read_le16(ptr: *const u8) -> u16 { + u16::from_le_bytes(std::ptr::read_unaligned(ptr as *const [u8; 2])) +} + +#[inline] +unsafe fn read_le32(ptr: *const u8) -> u32 { + u32::from_le_bytes(std::ptr::read_unaligned(ptr as *const [u8; 4])) +} + +#[inline] +unsafe fn read_le64(ptr: *const u8) -> u64 { + u64::from_le_bytes(std::ptr::read_unaligned(ptr as *const [u8; 8])) +} + +#[inline] +unsafe fn read_le_size(ptr: *const u8) -> usize { + if std::mem::size_of::() == 4 { + read_le32(ptr) as usize + } else { + u64::from_le_bytes(std::ptr::read_unaligned(ptr as *const [u8; 8])) as usize + } +} + +/* ****************************************** + * Backward bit stream (the v0.7 snapshot) + ********************************************/ + +unsafe fn init_dstream(stream: &mut DStream, src: *const u8, src_size: usize) -> usize { + let word = std::mem::size_of::(); + if src_size == 0 { + *stream = DStream { + bit_container: 0, + bits_consumed: 0, + ptr: ptr::null(), + start: ptr::null(), + }; + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + + stream.start = src; + if src_size >= word { + stream.ptr = src.add(src_size - word); + stream.bit_container = read_le_size(stream.ptr); + let end_byte = *src.add(src_size - 1) as u32; + if end_byte == 0 { + return ERROR(ZstdErrorCode::Generic); + } + stream.bits_consumed = 8 - highbit32(end_byte); + } else { + stream.ptr = src; + stream.bit_container = *src as usize; + if src_size >= 7 { + stream.bit_container += (*src.add(6) as usize) << (USIZE_BITS as usize - 16); + } + if src_size >= 6 { + stream.bit_container += (*src.add(5) as usize) << (USIZE_BITS as usize - 24); + } + if src_size >= 5 { + stream.bit_container += (*src.add(4) as usize) << (USIZE_BITS as usize - 32); + } + if src_size >= 4 { + stream.bit_container += (*src.add(3) as usize) << 24; + } + if src_size >= 3 { + stream.bit_container += (*src.add(2) as usize) << 16; + } + if src_size >= 2 { + stream.bit_container += (*src.add(1) as usize) << 8; + } + let end_byte = *src.add(src_size - 1) as u32; + if end_byte == 0 { + return ERROR(ZstdErrorCode::Generic); + } + stream.bits_consumed = 8 - highbit32(end_byte); + stream.bits_consumed += ((word - src_size) * 8) as u32; + } + src_size +} + +#[inline] +unsafe fn look_bits(stream: &DStream, nb_bits: u32) -> usize { + let mask = USIZE_BITS - 1; + ((stream.bit_container << (stream.bits_consumed & mask)) >> 1) + >> (mask.wrapping_sub(nb_bits) & mask) +} + +#[inline] +unsafe fn look_bits_fast(stream: &DStream, nb_bits: u32) -> usize { + let mask = USIZE_BITS - 1; + (stream.bit_container << (stream.bits_consumed & mask)) + >> ((mask + 1).wrapping_sub(nb_bits) & mask) +} + +#[inline] +fn skip_bits(stream: &mut DStream, nb_bits: u32) { + stream.bits_consumed = stream.bits_consumed.wrapping_add(nb_bits); +} + +#[inline] +unsafe fn read_bits(stream: &mut DStream, nb_bits: u32) -> usize { + let value = look_bits(stream, nb_bits); + skip_bits(stream, nb_bits); + value +} + +#[inline] +unsafe fn read_bits_fast(stream: &mut DStream, nb_bits: u32) -> usize { + let value = look_bits_fast(stream, nb_bits); + skip_bits(stream, nb_bits); + value +} + +unsafe fn reload_dstream(stream: &mut DStream) -> u32 { + let word = std::mem::size_of::(); + if stream.bits_consumed > (word * 8) as u32 { + return DSTREAM_TOO_FAR; + } + if (stream.ptr as usize) >= (stream.start as usize).wrapping_add(word) { + stream.ptr = stream.ptr.sub((stream.bits_consumed >> 3) as usize); + stream.bits_consumed &= 7; + stream.bit_container = read_le_size(stream.ptr); + return DSTREAM_UNFINISHED; + } + if stream.ptr == stream.start { + if stream.bits_consumed < (word * 8) as u32 { + return DSTREAM_END_OF_BUFFER; + } + return DSTREAM_COMPLETED; + } + + let mut nb_bytes = stream.bits_consumed >> 3; + let mut result = DSTREAM_UNFINISHED; + if (stream.ptr as usize).wrapping_sub(nb_bytes as usize) < stream.start as usize { + nb_bytes = (stream.ptr as usize - stream.start as usize) as u32; + result = DSTREAM_END_OF_BUFFER; + } + stream.ptr = stream.ptr.sub(nb_bytes as usize); + stream.bits_consumed -= nb_bytes * 8; + stream.bit_container = read_le_size(stream.ptr); + result +} + +#[inline] +fn end_of_dstream(stream: &DStream) -> bool { + stream.ptr == stream.start && stream.bits_consumed == USIZE_BITS +} + +/* ****************************************** + * FSE decoding + ********************************************/ + +#[inline] +fn fse_table_step(table_size: u32) -> u32 { + (table_size >> 1) + (table_size >> 3) + 3 +} + +#[allow(clippy::needless_range_loop)] +unsafe fn fse_build_dtable( + dt: &mut [u32], + normalized_counter: &[i16], + max_symbol_value: u32, + table_log: u32, +) -> usize { + if max_symbol_value > FSE_MAX_SYMBOL_VALUE { + return ERROR(ZstdErrorCode::MaxSymbolValueTooLarge); + } + if table_log > FSE_MAX_TABLELOG { + return ERROR(ZstdErrorCode::TableLogTooLarge); + } + + let table_size = 1u32 << table_log; + let table_mask = table_size - 1; + let step = fse_table_step(table_size); + let mut symbol_next = [0u16; 256]; + let table_header = dt.as_mut_ptr() as *mut FseDTableHeader; + let table_decode = dt.as_mut_ptr().add(1) as *mut FseDecode; + let mut position = 0u32; + let mut high_threshold = table_size - 1; + let large_limit = (1i32 << (table_log - 1)) as i16; + let mut no_large = 1u16; + + (*table_header).table_log = table_log as u16; + for symbol in 0..=max_symbol_value as usize { + let count = normalized_counter[symbol]; + if count == -1 { + (*table_decode.add(high_threshold as usize)).symbol = symbol as u8; + high_threshold = high_threshold.wrapping_sub(1); + symbol_next[symbol] = 1; + } else { + if count >= large_limit { + no_large = 0; + } + symbol_next[symbol] = count as u16; + } + } + + for symbol in 0..=max_symbol_value as usize { + let count = normalized_counter[symbol]; + for _ in 0..count.max(0) { + (*table_decode.add(position as usize)).symbol = symbol as u8; + position = (position + step) & table_mask; + while position > high_threshold { + position = (position + step) & table_mask; + } + } + } + if position != 0 { + return ERROR(ZstdErrorCode::Generic); + } + + for index in 0..table_size as usize { + let symbol = (*table_decode.add(index)).symbol as usize; + let next_state = symbol_next[symbol]; + symbol_next[symbol] = symbol_next[symbol].wrapping_add(1); + let nb_bits = (table_log - highbit32(next_state as u32)) as u8; + (*table_decode.add(index)).nb_bits = nb_bits; + (*table_decode.add(index)).new_state = + (((next_state as u32) << nb_bits).wrapping_sub(table_size)) as u16; + } + (*table_header).fast_mode = no_large; + 0 +} + +unsafe fn fse_read_ncount( + normalized_counter: &mut [i16; 256], + max_sv: &mut u32, + table_log: &mut u32, + header: *const u8, + header_size: usize, +) -> usize { + if header_size < 4 { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + let start = header as usize; + let end = start.wrapping_add(header_size); + let mut ip = header; + let mut char_num = 0u32; + let mut previous_zero = false; + let mut bit_stream = read_le32(ip); + let mut nb_bits = ((bit_stream & 0xF) + FSE_MIN_TABLELOG) as i32; + if nb_bits > FSE_TABLELOG_ABSOLUTE_MAX as i32 { + return ERROR(ZstdErrorCode::TableLogTooLarge); + } + bit_stream >>= 4; + let mut bit_count = 4i32; + *table_log = nb_bits as u32; + let mut remaining = (1i32 << nb_bits) + 1; + let mut threshold = 1i32 << nb_bits; + nb_bits += 1; + + while remaining > 1 && char_num <= *max_sv { + if previous_zero { + let mut n0 = char_num; + while bit_stream & 0xFFFF == 0xFFFF { + n0 += 24; + if (ip as usize) < end.wrapping_sub(5) { + ip = ip.add(2); + bit_stream = read_le32(ip) >> bit_count; + } else { + bit_stream >>= 16; + bit_count += 16; + } + } + while bit_stream & 3 == 3 { + n0 += 3; + bit_stream >>= 2; + bit_count += 2; + } + n0 += bit_stream & 3; + bit_count += 2; + if n0 > *max_sv { + return ERROR(ZstdErrorCode::MaxSymbolValueTooSmall); + } + while char_num < n0 { + normalized_counter[char_num as usize] = 0; + char_num += 1; + } + if (ip as usize) <= end.wrapping_sub(7) + || (ip as usize).wrapping_add((bit_count >> 3) as usize) <= end.wrapping_sub(4) + { + ip = ip.add((bit_count >> 3) as usize); + bit_count &= 7; + bit_stream = read_le32(ip) >> bit_count; + } else { + bit_stream >>= 2; + } + } + + let max = ((2 * threshold - 1) - remaining) as i16; + let mut count: i16; + if (bit_stream & (threshold - 1) as u32) < max as i32 as u32 { + count = (bit_stream & (threshold - 1) as u32) as u16 as i16; + bit_count += nb_bits - 1; + } else { + count = (bit_stream & (2 * threshold - 1) as u32) as u16 as i16; + if count as i32 >= threshold { + count = (count as i32 - max as i32) as i16; + } + bit_count += nb_bits; + } + count = count.wrapping_sub(1); + remaining -= (count as i32).abs(); + normalized_counter[char_num as usize] = count; + char_num += 1; + previous_zero = count == 0; + while remaining < threshold { + nb_bits -= 1; + threshold >>= 1; + } + + if (ip as usize) <= end.wrapping_sub(7) + || (ip as usize).wrapping_add((bit_count >> 3) as usize) <= end.wrapping_sub(4) + { + ip = ip.add((bit_count >> 3) as usize); + bit_count &= 7; + } else { + bit_count -= (8 * (end.wrapping_sub(4) as isize - ip as usize as isize)) as i32; + ip = (end - 4) as *const u8; + } + bit_stream = read_le32(ip) >> (bit_count & 31); + } + + if remaining != 1 { + return ERROR(ZstdErrorCode::Generic); + } + *max_sv = char_num - 1; + ip = ip.add(((bit_count + 7) >> 3) as usize); + if (ip as usize).wrapping_sub(start) > header_size { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + (ip as usize).wrapping_sub(start) +} + +unsafe fn fse_build_dtable_rle(dt: &mut [u32], symbol: u8) -> usize { + let header = dt.as_mut_ptr() as *mut FseDTableHeader; + let cell = dt.as_mut_ptr().add(1) as *mut FseDecode; + (*header).table_log = 0; + (*header).fast_mode = 0; + (*cell).new_state = 0; + (*cell).symbol = symbol; + (*cell).nb_bits = 0; + 0 +} + +unsafe fn fse_init_dstate(state: &mut FseDState, stream: &mut DStream, dt: *const u32) { + let header = dt as *const FseDTableHeader; + state.state = read_bits(stream, (*header).table_log as u32); + reload_dstream(stream); + state.table = dt.add(1) as *const FseDecode; +} + +#[inline] +unsafe fn fse_peek_symbol(state: &FseDState) -> u8 { + (*state.table.add(state.state)).symbol +} + +#[inline] +unsafe fn fse_update_state(state: &mut FseDState, stream: &mut DStream) { + let info = *state.table.add(state.state); + let low_bits = read_bits(stream, info.nb_bits as u32); + state.state = (info.new_state as usize).wrapping_add(low_bits); +} + +#[inline] +unsafe fn fse_decode_symbol(state: &mut FseDState, stream: &mut DStream, fast: bool) -> u8 { + let info = *state.table.add(state.state); + let low_bits = if fast { + read_bits_fast(stream, info.nb_bits as u32) + } else { + read_bits(stream, info.nb_bits as u32) + }; + state.state = (info.new_state as usize).wrapping_add(low_bits); + info.symbol +} + +unsafe fn fse_decompress_using_dtable( + dst: *mut u8, + max_dst_size: usize, + c_src: *const u8, + c_src_size: usize, + dt: &[u32], +) -> usize { + let header = &*(dt.as_ptr() as *const FseDTableHeader); + let fast = header.fast_mode != 0; + let start = dst; + let end_addr = (dst as usize).wrapping_add(max_dst_size); + let limit_addr = end_addr.wrapping_sub(3); + let mut op = dst; + let mut stream = DStream { + bit_container: 0, + bits_consumed: 0, + ptr: ptr::null(), + start: ptr::null(), + }; + let mut state1 = FseDState { + state: 0, + table: ptr::null(), + }; + let mut state2 = state1; + let error = init_dstream(&mut stream, c_src, c_src_size); + if ERR_isError(error) { + return error; + } + fse_init_dstate(&mut state1, &mut stream, dt.as_ptr()); + fse_init_dstate(&mut state2, &mut stream, dt.as_ptr()); + + const RELOAD_2: bool = FSE_MAX_TABLELOG * 2 + 7 > USIZE_BITS; + const RELOAD_4: bool = FSE_MAX_TABLELOG * 4 + 7 > USIZE_BITS; + while reload_dstream(&mut stream) == DSTREAM_UNFINISHED && (op as usize) < limit_addr { + *op = fse_decode_symbol(&mut state1, &mut stream, fast); + if RELOAD_2 { + reload_dstream(&mut stream); + } + *op.add(1) = fse_decode_symbol(&mut state2, &mut stream, fast); + if RELOAD_4 && reload_dstream(&mut stream) > DSTREAM_UNFINISHED { + op = op.add(2); + break; + } + *op.add(2) = fse_decode_symbol(&mut state1, &mut stream, fast); + if RELOAD_2 { + reload_dstream(&mut stream); + } + *op.add(3) = fse_decode_symbol(&mut state2, &mut stream, fast); + op = op.add(4); + } + + loop { + if reload_dstream(&mut stream) > DSTREAM_COMPLETED + || op as usize == end_addr + || (end_of_dstream(&stream) && (fast || state1.state == 0)) + { + break; + } + *op = fse_decode_symbol(&mut state1, &mut stream, fast); + op = op.add(1); + if reload_dstream(&mut stream) > DSTREAM_COMPLETED + || op as usize == end_addr + || (end_of_dstream(&stream) && (fast || state2.state == 0)) + { + break; + } + *op = fse_decode_symbol(&mut state2, &mut stream, fast); + op = op.add(1); + } + + if end_of_dstream(&stream) && state1.state == 0 && state2.state == 0 { + return (op as usize) - (start as usize); + } + if op as usize == end_addr { + return ERROR(ZstdErrorCode::DstSizeTooSmall); + } + ERROR(ZstdErrorCode::CorruptionDetected) +} + +unsafe fn fse_decompress( + dst: *mut u8, + max_dst_size: usize, + c_src: *const u8, + c_src_size: usize, +) -> usize { + if c_src_size < 2 { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + let mut counters = [0i16; 256]; + let mut max_symbol = FSE_MAX_SYMBOL_VALUE; + let mut table_log = 0; + let header_size = fse_read_ncount( + &mut counters, + &mut max_symbol, + &mut table_log, + c_src, + c_src_size, + ); + if ERR_isError(header_size) { + return header_size; + } + if header_size >= c_src_size { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + let mut table = vec![0u32; 1 + (1usize << FSE_MAX_TABLELOG)]; + let error = fse_build_dtable(&mut table, &counters, max_symbol, table_log); + if ERR_isError(error) { + return error; + } + fse_decompress_using_dtable( + dst, + max_dst_size, + c_src.add(header_size), + c_src_size - header_size, + &table, + ) +} + +/* ****************************************** + * Huffman decoding + ********************************************/ + +#[repr(C)] +#[derive(Clone, Copy)] +struct HufDEltX2 { + byte: u8, + nb_bits: u8, +} + +#[allow(clippy::manual_div_ceil)] +unsafe fn huf_read_stats( + huff_weight: &mut [u8; HUF_MAX_SYMBOL_VALUE + 1], + rank_stats: &mut [u32; HUF_ABSOLUTE_MAX_TABLELOG + 1], + nb_symbols: &mut u32, + table_log: &mut u32, + src: *const u8, + src_size: usize, +) -> usize { + if src_size == 0 { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + let mut i_size = *src as usize; + let o_size: usize; + if i_size >= 128 { + if i_size >= 242 { + const RLE_LENGTHS: [usize; 14] = [1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128]; + let index = i_size - 242; + if index >= RLE_LENGTHS.len() { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + o_size = RLE_LENGTHS[index]; + huff_weight.fill(1); + i_size = 0; + } else { + o_size = i_size - 127; + i_size = (o_size + 1) / 2; + if i_size + 1 > src_size { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + if o_size >= huff_weight.len() { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + let weights = src.add(1); + let mut n = 0; + while n < o_size { + huff_weight[n] = *weights.add(n / 2) >> 4; + if n + 1 < huff_weight.len() { + huff_weight[n + 1] = *weights.add(n / 2) & 15; + } + n += 2; + } + } + } else { + if i_size + 1 > src_size { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + let decoded = fse_decompress( + huff_weight.as_mut_ptr(), + huff_weight.len() - 1, + src.add(1), + i_size, + ); + if ERR_isError(decoded) { + return decoded; + } + o_size = decoded; + } + + rank_stats.fill(0); + let mut weight_total = 0u32; + for &weight in huff_weight.iter().take(o_size) { + if weight as usize >= HUF_ABSOLUTE_MAX_TABLELOG { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + rank_stats[weight as usize] += 1; + weight_total += (1u32 << weight) >> 1; + } + if weight_total == 0 { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + let calculated_log = highbit32(weight_total) + 1; + if calculated_log as usize > HUF_ABSOLUTE_MAX_TABLELOG { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + let total = 1u32 << calculated_log; + let rest = total - weight_total; + if rest == 0 || (1u32 << highbit32(rest)) != rest { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + let last_weight = highbit32(rest) + 1; + huff_weight[o_size] = last_weight as u8; + rank_stats[last_weight as usize] += 1; + if rank_stats[1] < 2 || (rank_stats[1] & 1) != 0 { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + *nb_symbols = (o_size + 1) as u32; + *table_log = calculated_log; + i_size + 1 +} + +#[allow(clippy::needless_range_loop)] +unsafe fn huf_read_dtable_x2(dtable: &mut HufTableX2, src: *const u8, src_size: usize) -> usize { + let mut huff_weight = [0u8; HUF_MAX_SYMBOL_VALUE + 1]; + let mut rank_val = [0u32; HUF_ABSOLUTE_MAX_TABLELOG + 1]; + let mut nb_symbols = 0u32; + let mut table_log = 0u32; + let i_size = huf_read_stats( + &mut huff_weight, + &mut rank_val, + &mut nb_symbols, + &mut table_log, + src, + src_size, + ); + if ERR_isError(i_size) { + return i_size; + } + if table_log > huf_max_table_log(dtable[0]) + 1 { + return ERROR(ZstdErrorCode::TableLogTooLarge); + } + dtable[0] = huf_set_table_log(huf_set_table_type(dtable[0], 0), table_log); + + let mut next_rank_start = 0u32; + for weight in 1..=table_log as usize { + let current = next_rank_start; + next_rank_start += rank_val[weight] << (weight - 1); + rank_val[weight] = current; + } + let cells = dtable.as_mut_ptr().add(1) as *mut HufDEltX2; + for (symbol, &weight) in huff_weight.iter().enumerate().take(nb_symbols as usize) { + let weight = weight as usize; + let length = (1u32 << weight) >> 1; + let entry = HufDEltX2 { + byte: symbol as u8, + nb_bits: (table_log + 1 - weight as u32) as u8, + }; + for index in rank_val[weight]..rank_val[weight] + length { + *cells.add(index as usize) = entry; + } + rank_val[weight] += length; + } + i_size +} + +#[inline] +unsafe fn huf_decode_symbol(stream: &mut DStream, table: *const HufDEltX2, table_log: u32) -> u8 { + let entry = *table.add(look_bits_fast(stream, table_log)); + skip_bits(stream, entry.nb_bits as u32); + entry.byte +} + +unsafe fn huf_decode_stream( + dst: *mut u8, + dst_size: usize, + stream: &mut DStream, + table: *const HufDEltX2, + table_log: u32, +) -> usize { + let start = dst; + let end = dst.add(dst_size); + let mut op = dst; + + /* The v0.7 C decoder uses a 4-symbol unrolled loop followed by a tail. + * Decoding one symbol at a time has the same state transitions and keeps + * the same stop-bit validation while remaining easy to audit. */ + while op < end { + let status = reload_dstream(stream); + if status == DSTREAM_TOO_FAR || (status == DSTREAM_COMPLETED && op < end) { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + *op = huf_decode_symbol(stream, table, table_log); + op = op.add(1); + } + if !end_of_dstream(stream) { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + (op as usize) - (start as usize) +} + +unsafe fn huf_decompress4x2_using_dtable( + dst: *mut u8, + dst_size: usize, + c_src: *const u8, + c_src_size: usize, + dtable: &HufTableX2, +) -> usize { + if c_src_size < 10 { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + let length1 = read_le16(c_src) as usize; + let length2 = read_le16(c_src.add(2)) as usize; + let length3 = read_le16(c_src.add(4)) as usize; + let payload = length1 + .checked_add(length2) + .and_then(|v| v.checked_add(length3)) + .and_then(|v| v.checked_add(6)); + let payload = match payload { + Some(value) if value <= c_src_size => value, + _ => return ERROR(ZstdErrorCode::CorruptionDetected), + }; + let length4 = c_src_size - payload; + let stream1 = c_src.add(6); + let stream2 = stream1.add(length1); + let stream3 = stream2.add(length2); + let stream4 = stream3.add(length3); + let segment = dst_size.div_ceil(4); + let starts = [ + dst, + dst.add(segment), + dst.add(segment * 2), + dst.add(segment * 3), + ]; + let sizes = [ + segment.min(dst_size), + segment.min(dst_size.saturating_sub(segment)), + segment.min(dst_size.saturating_sub(segment * 2)), + dst_size.saturating_sub(segment * 3), + ]; + let lengths = [length1, length2, length3, length4]; + let sources = [stream1, stream2, stream3, stream4]; + let table = dtable.as_ptr().add(1) as *const HufDEltX2; + let table_log = huf_table_log(dtable[0]); + for index in 0..4 { + let mut stream = DStream { + bit_container: 0, + bits_consumed: 0, + ptr: ptr::null(), + start: ptr::null(), + }; + let error = init_dstream(&mut stream, sources[index], lengths[index]); + if ERR_isError(error) { + return error; + } + let decoded = huf_decode_stream(starts[index], sizes[index], &mut stream, table, table_log); + if ERR_isError(decoded) { + return decoded; + } + } + dst_size +} + +unsafe fn huf_decompress1x2_using_dtable( + dst: *mut u8, + dst_size: usize, + c_src: *const u8, + c_src_size: usize, + dtable: &HufTableX2, +) -> usize { + let stream = DStream { + bit_container: 0, + bits_consumed: 0, + ptr: ptr::null(), + start: ptr::null(), + }; + let mut stream = stream; + let error = init_dstream(&mut stream, c_src, c_src_size); + if ERR_isError(error) { + return error; + } + let table = dtable.as_ptr().add(1) as *const HufDEltX2; + let decoded = huf_decode_stream(dst, dst_size, &mut stream, table, huf_table_log(dtable[0])); + if ERR_isError(decoded) { + return decoded; + } + if !end_of_dstream(&stream) { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + dst_size +} + +#[repr(C)] +#[derive(Clone, Copy)] +struct HufDEltX4 { + sequence: u16, + nb_bits: u8, + length: u8, +} + +#[repr(C)] +#[derive(Clone, Copy)] +struct SortedSymbol { + symbol: u8, + weight: u8, +} + +type RankVal = [[u32; HUF_ABSOLUTE_MAX_TABLELOG + 1]; HUF_ABSOLUTE_MAX_TABLELOG]; + +#[inline] +unsafe fn huf_set_dtable_x4( + dtable: *mut HufDEltX4, + index: usize, + sequence: u16, + nb_bits: u32, + length: u8, +) { + let entry = dtable.add(index); + write_le16(entry.cast::(), sequence); + (*entry).nb_bits = nb_bits as u8; + (*entry).length = length; +} + +#[allow(clippy::too_many_arguments)] +unsafe fn huf_fill_dtable_x4_level2( + dtable: *mut HufDEltX4, + size_log: u32, + consumed: u32, + rank_val_origin: &[u32; HUF_ABSOLUTE_MAX_TABLELOG + 1], + min_weight: usize, + sorted_symbols: &[SortedSymbol; HUF_MAX_SYMBOL_VALUE + 1], + sorted_start: usize, + sorted_list_size: usize, + nb_bits_baseline: u32, + base_seq: u16, +) { + let mut rank_val = *rank_val_origin; + + if min_weight > 1 { + let skip_size = rank_val[min_weight] as usize; + for index in 0..skip_size { + huf_set_dtable_x4(dtable, index, base_seq, consumed, 1); + } + } + + for item in 0..sorted_list_size { + let sorted = sorted_symbols[sorted_start + item]; + let symbol = sorted.symbol as u32; + let weight = sorted.weight as usize; + let nb_bits = nb_bits_baseline - weight as u32; + let length = 1u32 << (size_log - nb_bits); + let start = rank_val[weight] as usize; + let end = start + length as usize; + let sequence = base_seq.wrapping_add((symbol << 8) as u16); + for index in start..end { + huf_set_dtable_x4(dtable, index, sequence, nb_bits + consumed, 2); + } + rank_val[weight] = rank_val[weight].wrapping_add(length); + } +} + +#[allow(clippy::too_many_arguments)] +unsafe fn huf_fill_dtable_x4( + dtable: *mut HufDEltX4, + target_log: u32, + sorted_list: &[SortedSymbol; HUF_MAX_SYMBOL_VALUE + 1], + sorted_list_size: usize, + rank_start0: &[u32; HUF_ABSOLUTE_MAX_TABLELOG + 2], + rank_val_origin: &RankVal, + max_weight: u32, + nb_bits_baseline: u32, +) { + let mut rank_val = rank_val_origin[0]; + let scale_log = nb_bits_baseline as i32 - target_log as i32; + let min_bits = nb_bits_baseline - max_weight; + + for item in 0..sorted_list_size { + let sorted = sorted_list[item]; + let symbol = sorted.symbol as u16; + let weight = sorted.weight as usize; + let nb_bits = nb_bits_baseline - weight as u32; + let start = rank_val[weight] as usize; + let length = 1u32 << (target_log - nb_bits); + + if target_log - nb_bits >= min_bits { + let mut min_weight = nb_bits as i32 + scale_log; + if min_weight < 1 { + min_weight = 1; + } + let min_weight = min_weight as usize; + let sorted_rank = rank_start0[min_weight + 1] as usize; + huf_fill_dtable_x4_level2( + dtable.add(start), + target_log - nb_bits, + nb_bits, + &rank_val_origin[nb_bits as usize], + min_weight, + sorted_list, + sorted_rank, + sorted_list_size - sorted_rank, + nb_bits_baseline, + symbol, + ); + } else { + let end = start + length as usize; + for index in start..end { + huf_set_dtable_x4(dtable, index, symbol, nb_bits, 1); + } + } + rank_val[weight] = rank_val[weight].wrapping_add(length); + } +} + +#[allow(clippy::needless_range_loop)] +unsafe fn huf_read_dtable_x4( + dtable: &mut [u32; 1 + (1 << HUF_MAX_TABLELOG)], + src: *const u8, + src_size: usize, +) -> usize { + let mut weight_list = [0u8; HUF_MAX_SYMBOL_VALUE + 1]; + let mut sorted_symbols = [SortedSymbol { + symbol: 0, + weight: 0, + }; HUF_MAX_SYMBOL_VALUE + 1]; + let mut rank_stats = [0u32; HUF_ABSOLUTE_MAX_TABLELOG + 1]; + let mut rank_start0 = [0u32; HUF_ABSOLUTE_MAX_TABLELOG + 2]; + let mut rank_val = [[0u32; HUF_ABSOLUTE_MAX_TABLELOG + 1]; HUF_ABSOLUTE_MAX_TABLELOG]; + let mut nb_symbols = 0u32; + let mut table_log = 0u32; + let mem_log = huf_max_table_log(dtable[0]); + + if mem_log > HUF_ABSOLUTE_MAX_TABLELOG as u32 { + return ERROR(ZstdErrorCode::TableLogTooLarge); + } + + let i_size = huf_read_stats( + &mut weight_list, + &mut rank_stats, + &mut nb_symbols, + &mut table_log, + src, + src_size, + ); + if ERR_isError(i_size) { + return i_size; + } + if table_log > mem_log { + return ERROR(ZstdErrorCode::TableLogTooLarge); + } + dtable[0] = huf_set_table_log(huf_set_table_type(dtable[0], 1), table_log); + + let mut max_weight = table_log as usize; + loop { + if rank_stats[max_weight] != 0 { + break; + } + if max_weight == 0 { + return ERROR(ZstdErrorCode::Generic); + } + max_weight -= 1; + } + + let mut next_rank_start = 0u32; + for weight in 1..=max_weight { + let current = next_rank_start; + next_rank_start = next_rank_start.wrapping_add(rank_stats[weight]); + rank_start0[weight + 1] = current; + } + rank_start0[0] = next_rank_start; + let size_of_sort = next_rank_start as usize; + + for symbol in 0..nb_symbols as usize { + let weight = weight_list[symbol] as usize; + let rank = rank_start0[weight + 1] as usize; + sorted_symbols[rank] = SortedSymbol { + symbol: symbol as u8, + weight: weight as u8, + }; + rank_start0[weight + 1] = rank as u32 + 1; + } + rank_start0[1] = 0; + + let min_bits = table_log + 1 - max_weight as u32; + let rescale = (mem_log as i32 - table_log as i32) - 1; + let mut next_rank_val = 0u32; + for weight in 1..=max_weight { + let current = next_rank_val; + let shift = (weight as i32 + rescale) as u32; + next_rank_val = next_rank_val.wrapping_add(rank_stats[weight] << shift); + rank_val[0][weight] = current; + } + if min_bits <= mem_log.saturating_sub(min_bits) { + for consumed in min_bits..=mem_log - min_bits { + for weight in 1..=max_weight { + rank_val[consumed as usize][weight] = rank_val[0][weight] >> consumed; + } + } + } + + let table = dtable.as_mut_ptr().add(1) as *mut HufDEltX4; + huf_fill_dtable_x4( + table, + mem_log, + &sorted_symbols, + size_of_sort, + &rank_start0, + &rank_val, + max_weight as u32, + table_log + 1, + ); + i_size +} + +#[inline] +unsafe fn huf_decode_symbol_x4( + op: &mut *mut u8, + stream: &mut DStream, + dtable: *const HufDEltX4, + table_log: u32, +) -> u32 { + let value = look_bits_fast(stream, table_log); + let entry = dtable.add(value); + ptr::copy(entry.cast::(), *op, 2); + skip_bits(stream, (*entry).nb_bits as u32); + let length = (*entry).length as u32; + *op = (*op).add(length as usize); + length +} + +#[inline] +unsafe fn huf_decode_last_symbol_x4( + op: *mut u8, + stream: &mut DStream, + dtable: *const HufDEltX4, + table_log: u32, +) -> u32 { + let value = look_bits_fast(stream, table_log); + let entry = dtable.add(value); + *op = read_le16(entry.cast::()) as u8; + if (*entry).length == 1 { + skip_bits(stream, (*entry).nb_bits as u32); + } else if stream.bits_consumed < USIZE_BITS { + skip_bits(stream, (*entry).nb_bits as u32); + if stream.bits_consumed > USIZE_BITS { + stream.bits_consumed = USIZE_BITS; + } + } + 1 +} + +#[inline] +unsafe fn huf_decode_symbol_x4_0( + op: &mut *mut u8, + stream: &mut DStream, + dtable: *const HufDEltX4, + table_log: u32, +) { + huf_decode_symbol_x4(op, stream, dtable, table_log); +} + +#[inline] +unsafe fn huf_decode_symbol_x4_1( + op: &mut *mut u8, + stream: &mut DStream, + dtable: *const HufDEltX4, + table_log: u32, +) { + if USIZE_BITS == 64 || HUF_MAX_TABLELOG <= 12 { + huf_decode_symbol_x4(op, stream, dtable, table_log); + } +} + +#[inline] +unsafe fn huf_decode_symbol_x4_2( + op: &mut *mut u8, + stream: &mut DStream, + dtable: *const HufDEltX4, + table_log: u32, +) { + if USIZE_BITS == 64 { + huf_decode_symbol_x4(op, stream, dtable, table_log); + } +} + +unsafe fn huf_decode_stream_x4( + mut p: *mut u8, + stream: &mut DStream, + p_end: *mut u8, + dtable: *const HufDEltX4, + table_log: u32, +) -> usize { + let p_start = p; + while reload_dstream(stream) == DSTREAM_UNFINISHED + && (p as usize) < (p_end as usize).wrapping_sub(7) + { + huf_decode_symbol_x4_2(&mut p, stream, dtable, table_log); + huf_decode_symbol_x4_1(&mut p, stream, dtable, table_log); + huf_decode_symbol_x4_2(&mut p, stream, dtable, table_log); + huf_decode_symbol_x4_0(&mut p, stream, dtable, table_log); + } + while reload_dstream(stream) == DSTREAM_UNFINISHED + && (p as usize) <= (p_end as usize).wrapping_sub(2) + { + huf_decode_symbol_x4_0(&mut p, stream, dtable, table_log); + } + while (p as usize) <= (p_end as usize).wrapping_sub(2) { + huf_decode_symbol_x4_0(&mut p, stream, dtable, table_log); + } + if (p as usize) < p_end as usize { + p = p.add(huf_decode_last_symbol_x4(p, stream, dtable, table_log) as usize); + } + (p as usize).wrapping_sub(p_start as usize) +} + +unsafe fn huf_decompress4x4_using_dtable( + dst: *mut u8, + dst_size: usize, + c_src: *const u8, + c_src_size: usize, + dtable: &[u32; 1 + (1 << HUF_MAX_TABLELOG)], +) -> usize { + if c_src_size < 10 { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + let length1 = read_le16(c_src) as usize; + let length2 = read_le16(c_src.add(2)) as usize; + let length3 = read_le16(c_src.add(4)) as usize; + let total = length1 + .wrapping_add(length2) + .wrapping_add(length3) + .wrapping_add(6); + let length4 = c_src_size.wrapping_sub(total); + if length4 > c_src_size { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + + let streams = [ + c_src.add(6), + c_src.add(6 + length1), + c_src.add(6 + length1 + length2), + c_src.add(6 + length1 + length2 + length3), + ]; + let lengths = [length1, length2, length3, length4]; + let segment = dst_size.wrapping_add(3) / 4; + let starts = [ + dst, + dst.add(segment), + dst.add(segment * 2), + dst.add(segment * 3), + ]; + let sizes = [ + segment.min(dst_size), + segment.min(dst_size.saturating_sub(segment)), + segment.min(dst_size.saturating_sub(segment * 2)), + dst_size.saturating_sub(segment * 3), + ]; + let table = dtable.as_ptr().add(1) as *const HufDEltX4; + let table_log = huf_table_log(dtable[0]); + + for index in 0..4 { + let mut stream = DStream { + bit_container: 0, + bits_consumed: 0, + ptr: ptr::null(), + start: ptr::null(), + }; + let error = init_dstream(&mut stream, streams[index], lengths[index]); + if ERR_isError(error) { + return error; + } + let decoded = huf_decode_stream_x4( + starts[index], + &mut stream, + starts[index].add(sizes[index]), + table, + table_log, + ); + if decoded != sizes[index] { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + } + dst_size +} + +unsafe fn huf_decompress1x4_using_dtable( + dst: *mut u8, + dst_size: usize, + c_src: *const u8, + c_src_size: usize, + dtable: &[u32; 1 + (1 << HUF_MAX_TABLELOG)], +) -> usize { + let mut stream = DStream { + bit_container: 0, + bits_consumed: 0, + ptr: ptr::null(), + start: ptr::null(), + }; + let error = init_dstream(&mut stream, c_src, c_src_size); + if ERR_isError(error) { + return error; + } + let table = dtable.as_ptr().add(1) as *const HufDEltX4; + let decoded = huf_decode_stream_x4( + dst, + &mut stream, + dst.add(dst_size), + table, + huf_table_log(dtable[0]), + ); + if decoded != dst_size || !end_of_dstream(&stream) { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + dst_size +} + +/* ****************************************** + * v0.7 frame decoder + ********************************************/ + +const SKIPPABLE_MAGIC_START: u32 = 0x184d_2a50; +const SKIPPABLE_HEADER_SIZE: usize = 8; +const STAGE_GET_FRAME_HEADER_SIZE: u32 = 0; +const STAGE_DECODE_FRAME_HEADER: u32 = 1; +const STAGE_DECODE_BLOCK_HEADER: u32 = 2; +const STAGE_DECOMPRESS_BLOCK: u32 = 3; +const STAGE_DECODE_SKIPPABLE_HEADER: u32 = 4; +const STAGE_SKIP_FRAME: u32 = 5; + +const WINDOWLOG_MAX: u32 = if usize::BITS == 32 { 25 } else { 27 }; +const FCS_FIELD_SIZE: [usize; 4] = [0, 2, 4, 8]; +const DID_FIELD_SIZE: [usize; 4] = [0, 1, 2, 4]; + +const LL_BASE: [u32; MAX_LL as usize + 1] = [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 22, 24, 28, 32, 40, 48, 64, + 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000, 0x10000, +]; +const ML_BASE: [u32; MAX_ML as usize + 1] = [ + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 37, 39, 41, 43, 47, 51, 59, 67, 83, 99, 0x83, 0x103, 0x203, + 0x403, 0x803, 0x1003, 0x2003, 0x4003, 0x8003, 0x10003, +]; +const OF_BASE: [u32; MAX_OFF as usize + 1] = [ + 0, 1, 1, 5, 0xd, 0x1d, 0x3d, 0x7d, 0xfd, 0x1fd, 0x3fd, 0x7fd, 0xffd, 0x1ffd, 0x3ffd, 0x7ffd, + 0xfffd, 0x1fffd, 0x3fffd, 0x7fffd, 0xffffd, 0x1ffffd, 0x3ffffd, 0x7ffffd, 0xfffffd, 0x1fffffd, + 0x3fffffd, 0x7fffffd, 0xffffffd, +]; + +type AllocFunction = unsafe extern "C" fn(*mut c_void, usize) -> *mut c_void; +type FreeFunction = unsafe extern "C" fn(*mut c_void, *mut c_void); + +#[repr(C)] +#[derive(Clone, Copy)] +pub struct ZSTDv07_customMem { + pub customAlloc: Option, + pub customFree: Option, + pub opaque: *mut c_void, +} + +#[repr(C)] +#[derive(Clone, Copy)] +pub struct ZSTDv07_frameParams { + pub frameContentSize: u64, + pub windowSize: u32, + pub dictID: u32, + pub checksumFlag: u32, +} + +#[repr(C)] +#[derive(Clone, Copy)] +struct Xxh64State { + total_len: u64, + v: [u64; 4], + mem64: [u64; 4], + memsize: u32, + reserved32: u32, + reserved64: u64, +} + +const XXH_PRIME64_1: u64 = 0x9e37_79b1_85eb_ca87; +const XXH_PRIME64_2: u64 = 0xc2b2_ae3d_27d4_eb4f; +const XXH_PRIME64_3: u64 = 0x1656_67b1_9e37_79f9; +const XXH_PRIME64_4: u64 = 0x85eb_ca77_c2b2_ae63; +const XXH_PRIME64_5: u64 = 0x27d4_eb2f_1656_67c5; + +#[inline] +fn xxh_round(mut acc: u64, input: u64) -> u64 { + acc = acc.wrapping_add(input.wrapping_mul(XXH_PRIME64_2)); + acc = acc.rotate_left(31); + acc.wrapping_mul(XXH_PRIME64_1) +} + +#[inline] +fn xxh_merge_round(mut acc: u64, value: u64) -> u64 { + acc ^= xxh_round(0, value); + acc.wrapping_mul(XXH_PRIME64_1).wrapping_add(XXH_PRIME64_4) +} + +#[inline] +fn xxh_avalanche(mut hash: u64) -> u64 { + hash ^= hash >> 33; + hash = hash.wrapping_mul(XXH_PRIME64_2); + hash ^= hash >> 29; + hash = hash.wrapping_mul(XXH_PRIME64_3); + hash ^ (hash >> 32) +} + +#[inline] +unsafe fn xxh_read_le32(src: *const u8) -> u32 { + u32::from_le_bytes(ptr::read_unaligned(src.cast::<[u8; 4]>())) +} + +#[inline] +unsafe fn xxh_read_le64(src: *const u8) -> u64 { + u64::from_le_bytes(ptr::read_unaligned(src.cast::<[u8; 8]>())) +} + +#[inline] +unsafe fn xxh_process_stripe(v: &mut [u64; 4], src: *const u8) { + v[0] = xxh_round(v[0], xxh_read_le64(src)); + v[1] = xxh_round(v[1], xxh_read_le64(src.add(8))); + v[2] = xxh_round(v[2], xxh_read_le64(src.add(16))); + v[3] = xxh_round(v[3], xxh_read_le64(src.add(24))); +} + +#[inline] +unsafe fn xxh_finalize(mut hash: u64, mut src: *const u8, mut size: usize) -> u64 { + while size >= 8 { + hash ^= xxh_round(0, xxh_read_le64(src)); + hash = hash + .rotate_left(27) + .wrapping_mul(XXH_PRIME64_1) + .wrapping_add(XXH_PRIME64_4); + src = src.add(8); + size -= 8; + } + if size >= 4 { + hash ^= (xxh_read_le32(src) as u64).wrapping_mul(XXH_PRIME64_1); + hash = hash + .rotate_left(23) + .wrapping_mul(XXH_PRIME64_2) + .wrapping_add(XXH_PRIME64_3); + src = src.add(4); + size -= 4; + } + while size != 0 { + hash ^= (*src as u64).wrapping_mul(XXH_PRIME64_5); + hash = hash.rotate_left(11).wrapping_mul(XXH_PRIME64_1); + src = src.add(1); + size -= 1; + } + xxh_avalanche(hash) +} + +#[inline] +unsafe fn xxh_reset(state: &mut Xxh64State, seed: u64) { + *state = Xxh64State { + total_len: 0, + v: [ + seed.wrapping_add(XXH_PRIME64_1).wrapping_add(XXH_PRIME64_2), + seed.wrapping_add(XXH_PRIME64_2), + seed, + seed.wrapping_sub(XXH_PRIME64_1), + ], + mem64: [0; 4], + memsize: 0, + reserved32: 0, + reserved64: 0, + }; +} + +unsafe fn xxh_update(state: &mut Xxh64State, src: *const u8, size: usize) { + if size == 0 { + return; + } + state.total_len = state.total_len.wrapping_add(size as u64); + let buffered = state.memsize as usize; + if buffered + size < 32 { + ptr::copy_nonoverlapping( + src, + state.mem64.as_mut_ptr().cast::().add(buffered), + size, + ); + state.memsize += size as u32; + return; + } + + let mut offset = 0; + if buffered != 0 { + let fill = 32 - buffered; + ptr::copy_nonoverlapping( + src, + state.mem64.as_mut_ptr().cast::().add(buffered), + fill, + ); + xxh_process_stripe(&mut state.v, state.mem64.as_ptr().cast()); + offset = fill; + state.memsize = 0; + } + while offset + 32 <= size { + xxh_process_stripe(&mut state.v, src.add(offset)); + offset += 32; + } + let remaining = size - offset; + if remaining != 0 { + ptr::copy_nonoverlapping( + src.add(offset), + state.mem64.as_mut_ptr().cast::(), + remaining, + ); + state.memsize = remaining as u32; + } +} + +#[inline] +unsafe fn xxh_digest(state: &Xxh64State) -> u64 { + let mut hash = if state.total_len >= 32 { + let mut hash = state.v[0] + .rotate_left(1) + .wrapping_add(state.v[1].rotate_left(7)) + .wrapping_add(state.v[2].rotate_left(12)) + .wrapping_add(state.v[3].rotate_left(18)); + for value in state.v { + hash = xxh_merge_round(hash, value); + } + hash + } else { + state.v[2].wrapping_add(XXH_PRIME64_5) + }; + hash = hash.wrapping_add(state.total_len); + xxh_finalize(hash, state.mem64.as_ptr().cast(), state.memsize as usize) +} + +#[repr(C)] +union HufDTable { + x2: HufTableX2, + x4: [u32; HUF_TABLE_SIZE_U32], +} + +#[repr(C)] +pub struct ZSTDv07_DCtx { + ll_table: [u32; 1 + (1 << LL_FSE_LOG)], + off_table: [u32; 1 + (1 << OFF_FSE_LOG)], + ml_table: [u32; 1 + (1 << ML_FSE_LOG)], + huf_table: HufDTable, + previous_dst_end: *const u8, + base: *const u8, + v_base: *const u8, + dict_end: *const u8, + expected: usize, + rep: [u32; REPCODE_NUM], + f_params: ZSTDv07_frameParams, + b_type: u32, + stage: u32, + lit_entropy: u32, + fse_entropy: u32, + xxh_state: Xxh64State, + header_size: usize, + dict_id: u32, + lit_ptr: *const u8, + custom_mem: ZSTDv07_customMem, + lit_size: usize, + lit_buffer: [u8; BLOCKSIZE + WILDCOPY_OVERLENGTH], + header_buffer: [u8; FRAME_HEADER_SIZE_MAX], +} + +#[inline] +unsafe extern "C" fn default_alloc(_: *mut c_void, size: usize) -> *mut c_void { + libc::malloc(size) +} + +#[inline] +unsafe extern "C" fn default_free(_: *mut c_void, address: *mut c_void) { + libc::free(address) +} + +#[inline] +fn default_custom_mem() -> ZSTDv07_customMem { + ZSTDv07_customMem { + customAlloc: Some(default_alloc), + customFree: Some(default_free), + opaque: ptr::null_mut(), + } +} + +#[inline] +fn normalized_custom_mem(mut custom_mem: ZSTDv07_customMem) -> Option { + if custom_mem.customAlloc.is_none() && custom_mem.customFree.is_none() { + custom_mem = default_custom_mem(); + } + if custom_mem.customAlloc.is_none() || custom_mem.customFree.is_none() { + None + } else { + Some(custom_mem) + } +} + +#[inline] +unsafe fn frame_header_size(src: *const u8, src_size: usize) -> usize { + if src_size < FRAME_HEADER_SIZE_MIN { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + let fhd = *src.add(4); + let dict_id = (fhd & 3) as usize; + let direct_mode = ((fhd >> 5) & 1) as usize; + let fcs_id = (fhd >> 6) as usize; + FRAME_HEADER_SIZE_MIN + + (direct_mode == 0) as usize + + DID_FIELD_SIZE[dict_id] + + FCS_FIELD_SIZE[fcs_id] + + (direct_mode != 0 && FCS_FIELD_SIZE[fcs_id] == 0) as usize +} + +unsafe fn get_frame_params_impl( + f_params: &mut ZSTDv07_frameParams, + src: *const u8, + src_size: usize, +) -> usize { + if src_size < FRAME_HEADER_SIZE_MIN { + return FRAME_HEADER_SIZE_MIN; + } + *f_params = ZSTDv07_frameParams { + frameContentSize: 0, + windowSize: 0, + dictID: 0, + checksumFlag: 0, + }; + if read_le32(src) != ZSTD_MAGIC_NUMBER { + if (read_le32(src) & 0xffff_fff0) == SKIPPABLE_MAGIC_START { + if src_size < SKIPPABLE_HEADER_SIZE { + return SKIPPABLE_HEADER_SIZE; + } + f_params.frameContentSize = read_le32(src.add(4)) as u64; + return 0; + } + return ERROR(ZstdErrorCode::PrefixUnknown); + } + + let header_size = frame_header_size(src, src_size); + if ERR_isError(header_size) { + return header_size; + } + if src_size < header_size { + return header_size; + } + + let fhd = *src.add(4); + let mut pos = 5usize; + let dict_id_size_code = (fhd & 3) as usize; + let checksum_flag = ((fhd >> 2) & 1) as u32; + let direct_mode = ((fhd >> 5) & 1) != 0; + let fcs_id = (fhd >> 6) as usize; + let mut window_size = 0u32; + let mut dict_id = 0u32; + let mut frame_content_size = 0u64; + + if fhd & 0x08 != 0 { + return ERROR(ZstdErrorCode::FrameParameterUnsupported); + } + if !direct_mode { + let wl = *src.add(pos); + pos += 1; + let window_log = (wl >> 3) as u32 + ZSTD_WINDOWLOG_ABSOLUTE_MIN; + if window_log > WINDOWLOG_MAX { + return ERROR(ZstdErrorCode::FrameParameterUnsupported); + } + window_size = 1u32 << window_log; + window_size += (window_size >> 3) * u32::from(wl & 7); + } + match dict_id_size_code { + 0 => {} + 1 => { + dict_id = *src.add(pos) as u32; + pos += 1; + } + 2 => { + dict_id = read_le16(src.add(pos)) as u32; + pos += 2; + } + 3 => { + dict_id = read_le32(src.add(pos)); + pos += 4; + } + _ => unreachable!(), + } + match fcs_id { + 0 => { + if direct_mode { + frame_content_size = *src.add(pos) as u64; + } + } + 1 => frame_content_size = read_le16(src.add(pos)) as u64 + 256, + 2 => frame_content_size = read_le32(src.add(pos)) as u64, + 3 => frame_content_size = read_le64(src.add(pos)), + _ => unreachable!(), + } + if window_size == 0 { + window_size = frame_content_size as u32; + } + if window_size as u64 > (1u64 << WINDOWLOG_MAX) { + return ERROR(ZstdErrorCode::FrameParameterUnsupported); + } + f_params.frameContentSize = frame_content_size; + f_params.windowSize = window_size; + f_params.dictID = dict_id; + f_params.checksumFlag = checksum_flag; + 0 +} + +#[derive(Clone, Copy)] +struct BlockProperties { + block_type: u32, + orig_size: u32, +} + +#[inline] +unsafe fn get_block_size( + src: *const u8, + src_size: usize, + properties: &mut BlockProperties, +) -> usize { + if src_size < BLOCK_HEADER_SIZE { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + let flags = *src; + let c_size = + *src.add(2) as usize | ((*src.add(1) as usize) << 8) | (((flags as usize) & 7) << 16); + properties.block_type = (flags >> 6) as u32; + properties.orig_size = if properties.block_type == BT_RLE { + c_size as u32 + } else { + 0 + }; + if properties.block_type == BT_END { + 0 + } else if properties.block_type == BT_RLE { + 1 + } else { + c_size + } +} + +#[inline] +unsafe fn copy_raw_block( + dst: *mut u8, + dst_capacity: usize, + src: *const u8, + src_size: usize, +) -> usize { + if src_size > dst_capacity { + return ERROR(ZstdErrorCode::DstSizeTooSmall); + } + if src_size != 0 { + ptr::copy(src, dst, src_size); + } + src_size +} + +#[inline] +unsafe fn generate_n_bytes(dst: *mut u8, dst_capacity: usize, byte: u8, length: usize) -> usize { + if length > dst_capacity { + return ERROR(ZstdErrorCode::DstSizeTooSmall); + } + if length != 0 { + ptr::write_bytes(dst, byte, length); + } + length +} + +#[inline] +unsafe fn huf_select_decoder(dst_size: usize, c_src_size: usize) -> bool { + const ALGO_TIME: [[[u32; 2]; 3]; 16] = [ + [[0, 0], [1, 1], [2, 2]], + [[0, 0], [1, 1], [2, 2]], + [[38, 130], [1313, 74], [2151, 38]], + [[448, 128], [1353, 74], [2238, 41]], + [[556, 128], [1353, 74], [2238, 47]], + [[714, 128], [1418, 74], [2436, 53]], + [[883, 128], [1437, 74], [2464, 61]], + [[897, 128], [1515, 75], [2622, 68]], + [[926, 128], [1613, 75], [2730, 75]], + [[947, 128], [1729, 77], [3359, 77]], + [[1107, 128], [2083, 81], [4006, 84]], + [[1177, 128], [2379, 87], [4785, 88]], + [[1242, 128], [2415, 93], [5155, 84]], + [[1349, 128], [2644, 106], [5260, 106]], + [[1455, 128], [2422, 124], [4174, 124]], + [[722, 128], [1891, 145], [1936, 146]], + ]; + let q = c_src_size * 16 / dst_size; + let d256 = (dst_size >> 8) as u32; + let mut dtime = [0u32; 3]; + for index in 0..3 { + dtime[index] = + ALGO_TIME[q][index][0].wrapping_add(ALGO_TIME[q][index][1].wrapping_mul(d256)); + } + dtime[1] = dtime[1].wrapping_add(dtime[1] >> 3); + dtime[1] < dtime[0] +} + +unsafe fn huf_decompress1x2_dctx( + dctx: &mut ZSTDv07_DCtx, + dst: *mut u8, + dst_size: usize, + c_src: *const u8, + c_src_size: usize, +) -> usize { + let table = &mut dctx.huf_table.x2; + let header_size = huf_read_dtable_x2(table, c_src, c_src_size); + if ERR_isError(header_size) { + return header_size; + } + if header_size >= c_src_size { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + huf_decompress1x2_using_dtable( + dst, + dst_size, + c_src.add(header_size), + c_src_size - header_size, + table, + ) +} + +unsafe fn huf_decompress4_huf_only( + dctx: &mut ZSTDv07_DCtx, + dst: *mut u8, + dst_size: usize, + c_src: *const u8, + c_src_size: usize, +) -> usize { + if dst_size == 0 || c_src_size >= dst_size || c_src_size <= 1 { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + if huf_select_decoder(dst_size, c_src_size) { + let table = &mut dctx.huf_table.x4; + let header_size = huf_read_dtable_x4(table, c_src, c_src_size); + if ERR_isError(header_size) { + return header_size; + } + if header_size >= c_src_size { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + huf_decompress4x4_using_dtable( + dst, + dst_size, + c_src.add(header_size), + c_src_size - header_size, + table, + ) + } else { + let table = &mut dctx.huf_table.x2; + let header_size = huf_read_dtable_x2(table, c_src, c_src_size); + if ERR_isError(header_size) { + return header_size; + } + if header_size >= c_src_size { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + huf_decompress4x2_using_dtable( + dst, + dst_size, + c_src.add(header_size), + c_src_size - header_size, + table, + ) + } +} + +unsafe fn decode_literals_block(dctx: &mut ZSTDv07_DCtx, src: *const u8, src_size: usize) -> usize { + if src_size < MIN_CBLOCK_SIZE { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + match *src >> 6 { + IS_HUF => { + let mut lh_size = ((*src >> 4) & 3) as usize; + let literal_size; + let compressed_size; + let single_stream; + if src_size < 5 { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + match lh_size { + 0 | 1 => { + lh_size = 3; + single_stream = *src & 16 != 0; + literal_size = (((*src & 15) as usize) << 6) + ((*src.add(1) as usize) >> 2); + compressed_size = ((*src.add(1) as usize & 3) << 8) + *src.add(2) as usize; + } + 2 => { + lh_size = 4; + single_stream = false; + literal_size = (((*src & 15) as usize) << 10) + + ((*src.add(1) as usize) << 2) + + ((*src.add(2) as usize) >> 6); + compressed_size = ((*src.add(2) as usize & 63) << 8) + *src.add(3) as usize; + } + 3 => { + lh_size = 5; + single_stream = false; + literal_size = (((*src & 15) as usize) << 14) + + ((*src.add(1) as usize) << 6) + + ((*src.add(2) as usize) >> 2); + compressed_size = ((*src.add(2) as usize & 3) << 16) + + ((*src.add(3) as usize) << 8) + + *src.add(4) as usize; + } + _ => unreachable!(), + } + if literal_size > BLOCKSIZE || compressed_size + lh_size > src_size { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + let compressed = src.add(lh_size); + let literal_buffer = dctx.lit_buffer.as_mut_ptr(); + let decoded = if single_stream { + huf_decompress1x2_dctx( + dctx, + literal_buffer, + literal_size, + compressed, + compressed_size, + ) + } else { + huf_decompress4_huf_only( + dctx, + literal_buffer, + literal_size, + compressed, + compressed_size, + ) + }; + if ERR_isError(decoded) { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + dctx.lit_ptr = dctx.lit_buffer.as_ptr(); + dctx.lit_size = literal_size; + dctx.lit_entropy = 1; + dctx.lit_buffer[literal_size..literal_size + WILDCOPY_OVERLENGTH].fill(0); + compressed_size + lh_size + } + IS_PCH => { + let mut lh_size = ((*src >> 4) & 3) as usize; + if lh_size != 1 || dctx.lit_entropy == 0 { + return if lh_size != 1 { + ERROR(ZstdErrorCode::CorruptionDetected) + } else { + ERROR(ZstdErrorCode::DictionaryCorrupted) + }; + } + lh_size = 3; + let literal_size = (((*src & 15) as usize) << 6) + ((*src.add(1) as usize) >> 2); + let compressed_size = ((*src.add(1) as usize & 3) << 8) + *src.add(2) as usize; + if compressed_size + lh_size > src_size { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + let table = &dctx.huf_table.x4; + let decoded = huf_decompress1x4_using_dtable( + dctx.lit_buffer.as_mut_ptr(), + literal_size, + src.add(lh_size), + compressed_size, + table, + ); + if ERR_isError(decoded) { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + dctx.lit_ptr = dctx.lit_buffer.as_ptr(); + dctx.lit_size = literal_size; + dctx.lit_buffer[literal_size..literal_size + WILDCOPY_OVERLENGTH].fill(0); + compressed_size + lh_size + } + IS_RAW => { + let mut lh_size = ((*src >> 4) & 3) as usize; + let literal_size = match lh_size { + 0 | 1 => { + lh_size = 1; + (*src & 31) as usize + } + 2 => (((*src & 15) as usize) << 8) + *src.add(1) as usize, + 3 => { + (((*src & 15) as usize) << 16) + + ((*src.add(1) as usize) << 8) + + *src.add(2) as usize + } + _ => unreachable!(), + }; + if lh_size + literal_size + WILDCOPY_OVERLENGTH > src_size { + if lh_size + literal_size > src_size { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + ptr::copy(src.add(lh_size), dctx.lit_buffer.as_mut_ptr(), literal_size); + dctx.lit_ptr = dctx.lit_buffer.as_ptr(); + dctx.lit_size = literal_size; + dctx.lit_buffer[literal_size..literal_size + WILDCOPY_OVERLENGTH].fill(0); + lh_size + literal_size + } else { + dctx.lit_ptr = src.add(lh_size); + dctx.lit_size = literal_size; + lh_size + literal_size + } + } + IS_RLE => { + let mut lh_size = ((*src >> 4) & 3) as usize; + let literal_size = match lh_size { + 0 | 1 => { + lh_size = 1; + (*src & 31) as usize + } + 2 => (((*src & 15) as usize) << 8) + *src.add(1) as usize, + 3 => { + if src_size < 4 { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + (((*src & 15) as usize) << 16) + + ((*src.add(1) as usize) << 8) + + *src.add(2) as usize + } + _ => unreachable!(), + }; + if literal_size > BLOCKSIZE { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + dctx.lit_buffer[..literal_size + WILDCOPY_OVERLENGTH].fill(*src.add(lh_size)); + dctx.lit_ptr = dctx.lit_buffer.as_ptr(); + dctx.lit_size = literal_size; + lh_size + 1 + } + _ => ERROR(ZstdErrorCode::CorruptionDetected), + } +} + +#[allow(clippy::too_many_arguments)] +unsafe fn build_seq_table( + table: &mut [u32], + encoding: u32, + max_symbol: u32, + max_log: u32, + src: *const u8, + src_size: usize, + default_norm: &[i16], + default_log: u32, + repeat_table: bool, +) -> usize { + match encoding { + FSE_ENCODING_RLE => { + if src_size == 0 { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + if *src > max_symbol as u8 { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + fse_build_dtable_rle(table, *src); + 1 + } + FSE_ENCODING_RAW => { + let result = fse_build_dtable(table, default_norm, max_symbol, default_log); + if ERR_isError(result) { + ERROR(ZstdErrorCode::CorruptionDetected) + } else { + 0 + } + } + FSE_ENCODING_STATIC => { + if repeat_table { + 0 + } else { + ERROR(ZstdErrorCode::CorruptionDetected) + } + } + FSE_ENCODING_DYNAMIC => { + let mut norm = [0i16; 256]; + let mut max_value = max_symbol; + let mut table_log = 0; + let header_size = + fse_read_ncount(&mut norm, &mut max_value, &mut table_log, src, src_size); + if ERR_isError(header_size) || table_log > max_log { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + let result = fse_build_dtable(table, &norm, max_value, table_log); + if ERR_isError(result) { + ERROR(ZstdErrorCode::CorruptionDetected) + } else { + header_size + } + } + _ => ERROR(ZstdErrorCode::CorruptionDetected), + } +} + +unsafe fn decode_seq_headers( + dctx: &mut ZSTDv07_DCtx, + nb_sequences: &mut i32, + src: *const u8, + src_size: usize, +) -> usize { + if src_size < MIN_SEQUENCES_SIZE { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + let start = src as usize; + let end = start.wrapping_add(src_size); + let mut ip = src; + let mut nb_seq = *ip as i32; + ip = ip.add(1); + if nb_seq == 0 { + *nb_sequences = 0; + return 1; + } + if nb_seq > 0x7f { + if nb_seq == 0xff { + if (ip as usize) > end.wrapping_sub(2) { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + nb_seq = read_le16(ip) as i32 + LONG_NB_SEQ; + ip = ip.add(2); + } else { + if (ip as usize) >= end { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + nb_seq = ((nb_seq - 0x80) << 8) + *ip as i32; + ip = ip.add(1); + } + } + *nb_sequences = nb_seq; + + if (ip as usize) > end.wrapping_sub(4) { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + let descriptor = *ip; + let ll_type = (descriptor >> 6) as u32; + let off_type = ((descriptor >> 4) & 3) as u32; + let ml_type = ((descriptor >> 2) & 3) as u32; + ip = ip.add(1); + let repeat_table = dctx.fse_entropy != 0; + + let ll_size = build_seq_table( + &mut dctx.ll_table, + ll_type, + MAX_LL, + LL_FSE_LOG, + ip, + end.wrapping_sub(ip as usize), + &LL_DEFAULT_NORM, + LL_DEFAULT_LOG, + repeat_table, + ); + if ERR_isError(ll_size) { + return ll_size; + } + ip = ip.add(ll_size); + let off_size = build_seq_table( + &mut dctx.off_table, + off_type, + MAX_OFF, + OFF_FSE_LOG, + ip, + end.wrapping_sub(ip as usize), + &OF_DEFAULT_NORM, + OF_DEFAULT_LOG, + repeat_table, + ); + if ERR_isError(off_size) { + return off_size; + } + ip = ip.add(off_size); + let ml_size = build_seq_table( + &mut dctx.ml_table, + ml_type, + MAX_ML, + ML_FSE_LOG, + ip, + end.wrapping_sub(ip as usize), + &ML_DEFAULT_NORM, + ML_DEFAULT_LOG, + repeat_table, + ); + if ERR_isError(ml_size) { + return ml_size; + } + ip = ip.add(ml_size); + (ip as usize).wrapping_sub(start) +} + +#[derive(Clone, Copy)] +struct Sequence { + lit_length: usize, + match_length: usize, + offset: usize, +} + +struct SequenceState { + stream: DStream, + state_ll: FseDState, + state_off: FseDState, + state_ml: FseDState, + prev_offset: [usize; REPCODE_NUM], +} + +unsafe fn decode_sequence(state: &mut SequenceState) -> Sequence { + let ll_code = fse_peek_symbol(&state.state_ll) as usize; + let ml_code = fse_peek_symbol(&state.state_ml) as usize; + let of_code = fse_peek_symbol(&state.state_off) as usize; + let ll_bits = LL_BITS_TABLE[ll_code]; + let ml_bits = ML_BITS_TABLE[ml_code]; + let of_bits = of_code as u32; + let total_bits = ll_bits + ml_bits + of_bits; + + let mut offset = if of_code == 0 { + 0 + } else { + OF_BASE[of_code] as usize + read_bits(&mut state.stream, of_bits) + }; + if USIZE_BITS == 32 { + reload_dstream(&mut state.stream); + } + if of_code <= 1 { + if ll_code == 0 && offset <= 1 { + offset = 1 - offset; + } + if offset != 0 { + let temp = state.prev_offset[offset]; + if offset != 1 { + state.prev_offset[2] = state.prev_offset[1]; + } + state.prev_offset[1] = state.prev_offset[0]; + state.prev_offset[0] = temp; + offset = temp; + } else { + offset = state.prev_offset[0]; + } + } else { + state.prev_offset[2] = state.prev_offset[1]; + state.prev_offset[1] = state.prev_offset[0]; + state.prev_offset[0] = offset; + } + + let match_length = ML_BASE[ml_code] as usize + + if ml_code > 31 { + read_bits(&mut state.stream, ml_bits) + } else { + 0 + }; + if USIZE_BITS == 32 && ml_bits + ll_bits > 24 { + reload_dstream(&mut state.stream); + } + let lit_length = LL_BASE[ll_code] as usize + + if ll_code > 15 { + read_bits(&mut state.stream, ll_bits) + } else { + 0 + }; + if USIZE_BITS == 32 || total_bits > 64 - 7 - (LL_FSE_LOG + ML_FSE_LOG + OFF_FSE_LOG) { + reload_dstream(&mut state.stream); + } + fse_update_state(&mut state.state_ll, &mut state.stream); + fse_update_state(&mut state.state_ml, &mut state.stream); + if USIZE_BITS == 32 { + reload_dstream(&mut state.stream); + } + fse_update_state(&mut state.state_off, &mut state.stream); + + Sequence { + lit_length, + match_length, + offset, + } +} + +#[allow(clippy::too_many_arguments)] +unsafe fn exec_sequence( + mut op: *mut u8, + oend: *mut u8, + mut sequence: Sequence, + lit_ptr: &mut *const u8, + lit_limit: *const u8, + base: *const u8, + v_base: *const u8, + dict_end: *const u8, +) -> usize { + let op_addr = op as usize; + let oend_addr = oend as usize; + let o_lit_end = op_addr.wrapping_add(sequence.lit_length); + let sequence_length = sequence.lit_length.wrapping_add(sequence.match_length); + let o_match_end = op_addr.wrapping_add(sequence_length); + let oend_w = oend_addr.wrapping_sub(WILDCOPY_OVERLENGTH); + let lit_end = (*lit_ptr as usize).wrapping_add(sequence.lit_length); + let mut match_addr = o_lit_end.wrapping_sub(sequence.offset); + + if sequence.lit_length + WILDCOPY_OVERLENGTH > oend_addr.wrapping_sub(op_addr) + || sequence_length > oend_addr.wrapping_sub(op_addr) + { + return ERROR(ZstdErrorCode::DstSizeTooSmall); + } + if sequence.lit_length > (lit_limit as usize).wrapping_sub(*lit_ptr as usize) { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + + zstd_wildcopy(op, *lit_ptr, sequence.lit_length as isize); + op = o_lit_end as *mut u8; + *lit_ptr = lit_end as *const u8; + + if sequence.offset > o_lit_end.wrapping_sub(base as usize) { + if sequence.offset > o_lit_end.wrapping_sub(v_base as usize) { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + match_addr = (dict_end as usize).wrapping_sub((base as usize).wrapping_sub(match_addr)); + if match_addr.wrapping_add(sequence.match_length) <= dict_end as usize { + ptr::copy( + match_addr as *const u8, + o_lit_end as *mut u8, + sequence.match_length, + ); + return sequence_length; + } + let length1 = (dict_end as usize).wrapping_sub(match_addr); + ptr::copy(match_addr as *const u8, o_lit_end as *mut u8, length1); + op = o_lit_end.wrapping_add(length1) as *mut u8; + sequence.match_length = sequence.match_length.wrapping_sub(length1); + match_addr = base as usize; + if op as usize > oend_w || sequence.match_length < MINMATCH { + let mut out = op; + let mut m = match_addr as *const u8; + while (out as usize) < o_match_end { + *out = *m; + out = out.add(1); + m = m.add(1); + } + return sequence_length; + } + } + + if sequence.offset < 8 { + const DEC32: [usize; 8] = [0, 1, 2, 1, 4, 4, 4, 4]; + const DEC64: [usize; 8] = [8, 8, 8, 7, 8, 9, 10, 11]; + *op = *(match_addr as *const u8); + *op.add(1) = *(match_addr as *const u8).add(1); + *op.add(2) = *(match_addr as *const u8).add(2); + *op.add(3) = *(match_addr as *const u8).add(3); + zstd_copy4( + op.add(4), + (match_addr + DEC32[sequence.offset]) as *const u8, + ); + match_addr = match_addr + .wrapping_add(8) + .wrapping_sub(DEC64[sequence.offset]); + } else { + zstd_copy8(op, match_addr as *const u8); + } + op = op.add(8); + match_addr = match_addr.wrapping_add(8); + + if o_match_end > oend_addr.wrapping_sub(16 - MINMATCH) { + if (op as usize) < oend_w { + let distance = oend_w - op as usize; + zstd_wildcopy(op, match_addr as *const u8, distance as isize); + match_addr = match_addr.wrapping_add(distance); + op = oend_w as *mut u8; + } + while (op as usize) < o_match_end { + *op = *(match_addr as *const u8); + op = op.add(1); + match_addr = match_addr.wrapping_add(1); + } + } else { + zstd_wildcopy( + op, + match_addr as *const u8, + sequence.match_length as isize - 8, + ); + } + sequence_length +} + +unsafe fn decompress_sequences( + dctx: &mut ZSTDv07_DCtx, + dst: *mut u8, + dst_capacity: usize, + seq_start: *const u8, + seq_size: usize, +) -> usize { + let start = seq_start as usize; + let end = start.wrapping_add(seq_size); + let ostart = dst; + let oend = (dst as usize).wrapping_add(dst_capacity) as *mut u8; + let mut op = dst; + let mut lit_ptr = dctx.lit_ptr; + let lit_end = dctx.lit_ptr.add(dctx.lit_size); + let mut nb_seq = 0i32; + let header_size = decode_seq_headers(dctx, &mut nb_seq, seq_start, seq_size); + if ERR_isError(header_size) { + return header_size; + } + let ip = seq_start.add(header_size); + + if nb_seq != 0 { + dctx.fse_entropy = 1; + let mut state = SequenceState { + stream: DStream { + bit_container: 0, + bits_consumed: 0, + ptr: ptr::null(), + start: ptr::null(), + }, + state_ll: FseDState { + state: 0, + table: ptr::null(), + }, + state_off: FseDState { + state: 0, + table: ptr::null(), + }, + state_ml: FseDState { + state: 0, + table: ptr::null(), + }, + prev_offset: [ + dctx.rep[0] as usize, + dctx.rep[1] as usize, + dctx.rep[2] as usize, + ], + }; + let stream_size = end.wrapping_sub(ip as usize); + let init = init_dstream(&mut state.stream, ip, stream_size); + if ERR_isError(init) { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + fse_init_dstate( + &mut state.state_ll, + &mut state.stream, + dctx.ll_table.as_ptr(), + ); + fse_init_dstate( + &mut state.state_off, + &mut state.stream, + dctx.off_table.as_ptr(), + ); + fse_init_dstate( + &mut state.state_ml, + &mut state.stream, + dctx.ml_table.as_ptr(), + ); + while reload_dstream(&mut state.stream) <= DSTREAM_COMPLETED && nb_seq != 0 { + nb_seq -= 1; + let sequence = decode_sequence(&mut state); + let one_size = exec_sequence( + op, + oend, + sequence, + &mut lit_ptr, + lit_end, + dctx.base, + dctx.v_base, + dctx.dict_end, + ); + if ERR_isError(one_size) { + return one_size; + } + op = op.add(one_size); + } + /* The v0.7 C decoder only validates that the declared sequence count + * was consumed here. Its bitstream may retain padding bits, so an + * exact end-of-stream check rejects valid historical frames. */ + if nb_seq != 0 { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + dctx.rep[0] = state.prev_offset[0] as u32; + dctx.rep[1] = state.prev_offset[1] as u32; + dctx.rep[2] = state.prev_offset[2] as u32; + } + + if lit_ptr as usize > lit_end as usize { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + let last_literal_size = (lit_end as usize).wrapping_sub(lit_ptr as usize); + if last_literal_size > (oend as usize).wrapping_sub(op as usize) { + return ERROR(ZstdErrorCode::DstSizeTooSmall); + } + if last_literal_size != 0 { + ptr::copy(lit_ptr, op, last_literal_size); + op = op.add(last_literal_size); + } + (op as usize).wrapping_sub(ostart as usize) +} + +#[inline] +unsafe fn check_continuity(dctx: &mut ZSTDv07_DCtx, dst: *const u8) { + if dst != dctx.previous_dst_end { + dctx.dict_end = dctx.previous_dst_end; + let delta = (dctx.previous_dst_end as usize).wrapping_sub(dctx.base as usize); + dctx.v_base = (dst as usize).wrapping_sub(delta) as *const u8; + dctx.base = dst; + dctx.previous_dst_end = dst; + } +} + +unsafe fn decompress_block_internal( + dctx: &mut ZSTDv07_DCtx, + dst: *mut u8, + dst_capacity: usize, + src: *const u8, + src_size: usize, +) -> usize { + if src_size >= BLOCKSIZE { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + let literal_size = decode_literals_block(dctx, src, src_size); + if ERR_isError(literal_size) { + return literal_size; + } + decompress_sequences( + dctx, + dst, + dst_capacity, + src.add(literal_size), + src_size - literal_size, + ) +} + +unsafe fn decompress_frame( + dctx: &mut ZSTDv07_DCtx, + dst: *mut u8, + dst_capacity: usize, + src: *const u8, + src_size: usize, +) -> usize { + if src_size < FRAME_HEADER_SIZE_MIN + BLOCK_HEADER_SIZE { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + let mut ip = src; + let mut remaining = src_size; + let ostart = dst; + let oend = (dst as usize).wrapping_add(dst_capacity) as *mut u8; + let frame_size = frame_header_size(src, src_size); + if ERR_isError(frame_size) { + return frame_size; + } + if src_size < frame_size + BLOCK_HEADER_SIZE { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + let header_result = decode_frame_header(dctx, src, frame_size); + if ERR_isError(header_result) { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + ip = ip.add(frame_size); + remaining -= frame_size; + let mut op = dst; + + loop { + let mut properties = BlockProperties { + block_type: BT_END, + orig_size: 0, + }; + let c_block_size = get_block_size(ip, remaining, &mut properties); + if ERR_isError(c_block_size) { + return c_block_size; + } + ip = ip.add(BLOCK_HEADER_SIZE); + remaining -= BLOCK_HEADER_SIZE; + if c_block_size > remaining { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + if properties.block_type == BT_END { + if remaining != 0 { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + break; + } + let decoded_size = match properties.block_type { + BT_COMPRESSED => decompress_block_internal( + dctx, + op, + (oend as usize).wrapping_sub(op as usize), + ip, + c_block_size, + ), + BT_RAW => copy_raw_block( + op, + (oend as usize).wrapping_sub(op as usize), + ip, + c_block_size, + ), + BT_RLE => generate_n_bytes( + op, + (oend as usize).wrapping_sub(op as usize), + *ip, + properties.orig_size as usize, + ), + _ => ERROR(ZstdErrorCode::Generic), + }; + if ERR_isError(decoded_size) { + return decoded_size; + } + if dctx.f_params.checksumFlag != 0 { + xxh_update(&mut dctx.xxh_state, op, decoded_size); + } + op = op.add(decoded_size); + ip = ip.add(c_block_size); + remaining -= c_block_size; + } + (op as usize).wrapping_sub(ostart as usize) +} + +unsafe fn ref_dict_content(dctx: &mut ZSTDv07_DCtx, dict: *const u8, dict_size: usize) -> usize { + dctx.dict_end = dctx.previous_dst_end; + let delta = (dctx.previous_dst_end as usize).wrapping_sub(dctx.base as usize); + dctx.v_base = (dict as usize).wrapping_sub(delta) as *const u8; + dctx.base = dict; + dctx.previous_dst_end = (dict as usize).wrapping_add(dict_size) as *const u8; + 0 +} + +unsafe fn load_entropy(dctx: &mut ZSTDv07_DCtx, dict: *const u8, dict_size: usize) -> usize { + let dict_start = dict as usize; + let dict_end = dict_start.wrapping_add(dict_size); + let mut dict_ptr = dict; + { + let table = &mut dctx.huf_table.x4; + let h_size = huf_read_dtable_x4(table, dict_ptr, dict_size); + if ERR_isError(h_size) { + return ERROR(ZstdErrorCode::DictionaryCorrupted); + } + dict_ptr = dict_ptr.add(h_size); + } + + let mut read_entropy = |table: &mut [u32], max_value: u32, max_log: u32| -> usize { + let mut norm = [0i16; 256]; + let mut max = max_value; + let mut log = 0; + let size = fse_read_ncount( + &mut norm, + &mut max, + &mut log, + dict_ptr, + dict_end.wrapping_sub(dict_ptr as usize), + ); + if ERR_isError(size) || log > max_log { + return ERROR(ZstdErrorCode::DictionaryCorrupted); + } + let built = fse_build_dtable(table, &norm, max, log); + if ERR_isError(built) { + return ERROR(ZstdErrorCode::DictionaryCorrupted); + } + dict_ptr = dict_ptr.add(size); + 0 + }; + let result = read_entropy(&mut dctx.off_table, MAX_OFF, OFF_FSE_LOG); + if ERR_isError(result) { + return result; + } + let result = read_entropy(&mut dctx.ml_table, MAX_ML, ML_FSE_LOG); + if ERR_isError(result) { + return result; + } + let result = read_entropy(&mut dctx.ll_table, MAX_LL, LL_FSE_LOG); + if ERR_isError(result) { + return result; + } + + if dict_ptr as usize > dict_end.wrapping_sub(12) { + return ERROR(ZstdErrorCode::DictionaryCorrupted); + } + dctx.rep[0] = read_le32(dict_ptr); + dctx.rep[1] = read_le32(dict_ptr.add(4)); + dctx.rep[2] = read_le32(dict_ptr.add(8)); + if dctx + .rep + .iter() + .any(|&rep| rep == 0 || rep as usize >= dict_size) + { + return ERROR(ZstdErrorCode::DictionaryCorrupted); + } + dict_ptr = dict_ptr.add(12); + dctx.lit_entropy = 1; + dctx.fse_entropy = 1; + (dict_ptr as usize).wrapping_sub(dict_start) +} + +unsafe fn insert_dictionary( + dctx: &mut ZSTDv07_DCtx, + mut dict: *const u8, + mut dict_size: usize, +) -> usize { + if dict_size < 8 || read_le32(dict) != ZSTD_DICT_MAGIC { + return ref_dict_content(dctx, dict, dict_size); + } + dctx.dict_id = read_le32(dict.add(4)); + dict = dict.add(8); + dict_size -= 8; + let entropy_size = load_entropy(dctx, dict, dict_size); + if ERR_isError(entropy_size) { + return ERROR(ZstdErrorCode::DictionaryCorrupted); + } + dict = dict.add(entropy_size); + dict_size -= entropy_size; + ref_dict_content(dctx, dict, dict_size) +} + +unsafe fn decode_frame_header(dctx: &mut ZSTDv07_DCtx, src: *const u8, src_size: usize) -> usize { + let result = get_frame_params_impl(&mut dctx.f_params, src, src_size); + if dctx.f_params.dictID != 0 && dctx.dict_id != dctx.f_params.dictID { + return ERROR(ZstdErrorCode::DictionaryWrong); + } + if dctx.f_params.checksumFlag != 0 { + xxh_reset(&mut dctx.xxh_state, 0); + } + result +} + +#[inline] +unsafe fn decompress_begin(dctx: &mut ZSTDv07_DCtx) -> usize { + dctx.expected = FRAME_HEADER_SIZE_MIN; + dctx.stage = STAGE_GET_FRAME_HEADER_SIZE; + dctx.previous_dst_end = ptr::null(); + dctx.base = ptr::null(); + dctx.v_base = ptr::null(); + dctx.dict_end = ptr::null(); + dctx.huf_table.x2[0] = huf_initial_desc(); + dctx.lit_entropy = 0; + dctx.fse_entropy = 0; + dctx.dict_id = 0; + dctx.rep = [1, 4, 8]; + 0 +} + +unsafe fn create_dctx_advanced_impl(custom_mem: ZSTDv07_customMem) -> *mut ZSTDv07_DCtx { + let custom_mem = match normalized_custom_mem(custom_mem) { + Some(value) => value, + None => return ptr::null_mut(), + }; + let dctx = match custom_mem.customAlloc { + Some(alloc) => { + alloc(custom_mem.opaque, std::mem::size_of::()) as *mut ZSTDv07_DCtx + } + None => return ptr::null_mut(), + }; + if dctx.is_null() { + return ptr::null_mut(); + } + ptr::write_bytes(dctx.cast::(), 0, std::mem::size_of::()); + (*dctx).custom_mem = custom_mem; + decompress_begin(&mut *dctx); + dctx +} + +unsafe fn free_dctx_impl(dctx: *mut ZSTDv07_DCtx) -> usize { + if dctx.is_null() { + return 0; + } + if let Some(free) = (*dctx).custom_mem.customFree { + free((*dctx).custom_mem.opaque, dctx.cast::()); + } + 0 +} + +unsafe fn copy_dctx_impl(dst: *mut ZSTDv07_DCtx, src: *const ZSTDv07_DCtx) { + let prefix = (&(*dst).lit_buffer as *const _ as usize).wrapping_sub(dst as usize); + ptr::copy_nonoverlapping(src.cast::(), dst.cast::(), prefix); +} + +unsafe fn decompress_begin_using_dict_impl( + dctx: &mut ZSTDv07_DCtx, + dict: *const u8, + dict_size: usize, +) -> usize { + let result = decompress_begin(dctx); + if ERR_isError(result) { + return result; + } + if !dict.is_null() && dict_size != 0 { + let result = insert_dictionary(dctx, dict, dict_size); + if ERR_isError(result) { + return ERROR(ZstdErrorCode::DictionaryCorrupted); + } + } + 0 +} + +unsafe fn decompress_continue_impl( + dctx: &mut ZSTDv07_DCtx, + dst: *mut u8, + dst_capacity: usize, + src: *const u8, + src_size: usize, +) -> usize { + if src_size != dctx.expected { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + if dst_capacity != 0 { + check_continuity(dctx, dst); + } + + match dctx.stage { + STAGE_GET_FRAME_HEADER_SIZE => { + if src_size != FRAME_HEADER_SIZE_MIN { + return ERROR(ZstdErrorCode::SrcSizeWrong); + } + if (read_le32(src) & 0xffff_fff0) == SKIPPABLE_MAGIC_START { + ptr::copy_nonoverlapping( + src, + dctx.header_buffer.as_mut_ptr(), + FRAME_HEADER_SIZE_MIN, + ); + dctx.expected = SKIPPABLE_HEADER_SIZE - FRAME_HEADER_SIZE_MIN; + dctx.stage = STAGE_DECODE_SKIPPABLE_HEADER; + return 0; + } + dctx.header_size = frame_header_size(src, FRAME_HEADER_SIZE_MIN); + if ERR_isError(dctx.header_size) { + return dctx.header_size; + } + ptr::copy_nonoverlapping(src, dctx.header_buffer.as_mut_ptr(), FRAME_HEADER_SIZE_MIN); + if dctx.header_size > FRAME_HEADER_SIZE_MIN { + dctx.expected = dctx.header_size - FRAME_HEADER_SIZE_MIN; + dctx.stage = STAGE_DECODE_FRAME_HEADER; + return 0; + } + dctx.expected = 0; + // The five-byte direct header is complete. Continue as if the + // second header chunk had just been supplied. + let result = decode_frame_header(dctx, dctx.header_buffer.as_ptr(), dctx.header_size); + if ERR_isError(result) { + return result; + } + dctx.expected = BLOCK_HEADER_SIZE; + dctx.stage = STAGE_DECODE_BLOCK_HEADER; + 0 + } + STAGE_DECODE_FRAME_HEADER => { + if dctx.expected != 0 { + ptr::copy_nonoverlapping( + src, + dctx.header_buffer.as_mut_ptr().add(FRAME_HEADER_SIZE_MIN), + dctx.expected, + ); + } + let result = decode_frame_header(dctx, dctx.header_buffer.as_ptr(), dctx.header_size); + if ERR_isError(result) { + return result; + } + dctx.expected = BLOCK_HEADER_SIZE; + dctx.stage = STAGE_DECODE_BLOCK_HEADER; + 0 + } + STAGE_DECODE_BLOCK_HEADER => { + let mut properties = BlockProperties { + block_type: BT_END, + orig_size: 0, + }; + let c_block_size = get_block_size(src, BLOCK_HEADER_SIZE, &mut properties); + if ERR_isError(c_block_size) { + return c_block_size; + } + if properties.block_type == BT_END { + if dctx.f_params.checksumFlag != 0 { + let hash = xxh_digest(&dctx.xxh_state); + let expected = ((hash >> 11) as u32) & ((1 << 22) - 1); + let actual = *src.add(2) as u32 + + ((*src.add(1) as u32) << 8) + + (((*src as u32) & 0x3f) << 16); + if expected != actual { + return ERROR(ZstdErrorCode::ChecksumWrong); + } + } + dctx.expected = 0; + dctx.stage = STAGE_GET_FRAME_HEADER_SIZE; + } else { + dctx.expected = c_block_size; + dctx.b_type = properties.block_type; + dctx.stage = STAGE_DECOMPRESS_BLOCK; + } + 0 + } + STAGE_DECOMPRESS_BLOCK => { + let result = match dctx.b_type { + BT_COMPRESSED => decompress_block_internal(dctx, dst, dst_capacity, src, src_size), + BT_RAW => copy_raw_block(dst, dst_capacity, src, src_size), + BT_RLE => ERROR(ZstdErrorCode::Generic), + BT_END => 0, + _ => ERROR(ZstdErrorCode::Generic), + }; + dctx.stage = STAGE_DECODE_BLOCK_HEADER; + dctx.expected = BLOCK_HEADER_SIZE; + if ERR_isError(result) { + return result; + } + dctx.previous_dst_end = (dst as usize).wrapping_add(result) as *const u8; + if dctx.f_params.checksumFlag != 0 { + xxh_update(&mut dctx.xxh_state, dst, result); + } + result + } + STAGE_DECODE_SKIPPABLE_HEADER => { + ptr::copy_nonoverlapping( + src, + dctx.header_buffer.as_mut_ptr().add(FRAME_HEADER_SIZE_MIN), + dctx.expected, + ); + dctx.expected = read_le32(dctx.header_buffer.as_ptr().add(4)) as usize; + dctx.stage = STAGE_SKIP_FRAME; + 0 + } + STAGE_SKIP_FRAME => { + dctx.expected = 0; + dctx.stage = STAGE_GET_FRAME_HEADER_SIZE; + 0 + } + _ => ERROR(ZstdErrorCode::Generic), + } +} + +unsafe fn find_frame_size_info_impl( + src: *const u8, + src_size: usize, + c_size: *mut usize, + d_bound: *mut u64, +) { + let error = |ret: usize| unsafe { + *c_size = ret; + *d_bound = ZSTD_CONTENTSIZE_ERROR; + }; + if src_size < FRAME_HEADER_SIZE_MIN + BLOCK_HEADER_SIZE { + error(ERROR(ZstdErrorCode::SrcSizeWrong)); + return; + } + let header_size = frame_header_size(src, src_size); + if ERR_isError(header_size) { + error(header_size); + return; + } + if read_le32(src) != ZSTD_MAGIC_NUMBER { + error(ERROR(ZstdErrorCode::PrefixUnknown)); + return; + } + if src_size < header_size + BLOCK_HEADER_SIZE { + error(ERROR(ZstdErrorCode::SrcSizeWrong)); + return; + } + let mut ip = src.add(header_size); + let mut remaining = src_size - header_size; + let mut blocks = 0usize; + loop { + let mut properties = BlockProperties { + block_type: BT_END, + orig_size: 0, + }; + let c_block_size = get_block_size(ip, remaining, &mut properties); + if ERR_isError(c_block_size) { + error(c_block_size); + return; + } + ip = ip.add(BLOCK_HEADER_SIZE); + remaining -= BLOCK_HEADER_SIZE; + if properties.block_type == BT_END { + break; + } + if c_block_size > remaining { + error(ERROR(ZstdErrorCode::SrcSizeWrong)); + return; + } + ip = ip.add(c_block_size); + remaining -= c_block_size; + blocks = blocks.wrapping_add(1); + } + *c_size = (ip as usize).wrapping_sub(src as usize); + *d_bound = (blocks.wrapping_mul(BLOCKSIZE)) as u64; +} + +#[repr(C)] +pub struct ZSTDv07_DDict { + dict: *mut c_void, + dict_size: usize, + ref_context: *mut ZSTDv07_DCtx, +} + +unsafe fn create_ddict_advanced_impl( + dict: *const u8, + dict_size: usize, + custom_mem: ZSTDv07_customMem, +) -> *mut ZSTDv07_DDict { + let custom_mem = match normalized_custom_mem(custom_mem) { + Some(value) => value, + None => return ptr::null_mut(), + }; + let alloc = custom_mem.customAlloc.unwrap(); + let free = custom_mem.customFree.unwrap(); + let ddict = + alloc(custom_mem.opaque, std::mem::size_of::()) as *mut ZSTDv07_DDict; + let dict_content = alloc(custom_mem.opaque, dict_size); + let dctx = create_dctx_advanced_impl(custom_mem); + if ddict.is_null() || dict_content.is_null() || dctx.is_null() { + free(custom_mem.opaque, dict_content); + free(custom_mem.opaque, ddict.cast()); + free(custom_mem.opaque, dctx.cast()); + return ptr::null_mut(); + } + ptr::copy_nonoverlapping(dict, dict_content.cast::(), dict_size); + let result = + decompress_begin_using_dict_impl(dctx.as_mut().unwrap(), dict_content.cast(), dict_size); + if ERR_isError(result) { + free(custom_mem.opaque, dict_content); + free(custom_mem.opaque, ddict.cast()); + free(custom_mem.opaque, dctx.cast()); + return ptr::null_mut(); + } + (*ddict).dict = dict_content; + (*ddict).dict_size = dict_size; + (*ddict).ref_context = dctx; + ddict +} + +unsafe fn decompress_using_prepared_impl( + dctx: &mut ZSTDv07_DCtx, + ref_dctx: &ZSTDv07_DCtx, + dst: *mut u8, + dst_capacity: usize, + src: *const u8, + src_size: usize, +) -> usize { + copy_dctx_impl(dctx, ref_dctx); + check_continuity(dctx, dst); + decompress_frame(dctx, dst, dst_capacity, src, src_size) +} + +#[no_mangle] +pub extern "C" fn ZSTDv07_isError(code: usize) -> c_uint { + ERR_isError(code) as c_uint +} + +#[no_mangle] +pub extern "C" fn ZSTDv07_getErrorName(code: usize) -> *const c_char { + ERR_getErrorName(code) +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_estimateDCtxSize() -> usize { + std::mem::size_of::() +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_sizeofDCtx(_: *const ZSTDv07_DCtx) -> usize { + std::mem::size_of::() +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_createDCtx_advanced( + custom_mem: ZSTDv07_customMem, +) -> *mut ZSTDv07_DCtx { + create_dctx_advanced_impl(custom_mem) +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_createDCtx() -> *mut ZSTDv07_DCtx { + create_dctx_advanced_impl(default_custom_mem()) +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_freeDCtx(dctx: *mut ZSTDv07_DCtx) -> usize { + free_dctx_impl(dctx) +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_decompressBegin(dctx: *mut ZSTDv07_DCtx) -> usize { + decompress_begin(&mut *dctx) +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_copyDCtx( + dst_dctx: *mut ZSTDv07_DCtx, + src_dctx: *const ZSTDv07_DCtx, +) { + copy_dctx_impl(dst_dctx, src_dctx) +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_decompressBegin_usingDict( + dctx: *mut ZSTDv07_DCtx, + dict: *const c_void, + dict_size: usize, +) -> usize { + decompress_begin_using_dict_impl(&mut *dctx, dict.cast(), dict_size) +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_nextSrcSizeToDecompress(dctx: *const ZSTDv07_DCtx) -> usize { + (*dctx).expected +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_isSkipFrame(dctx: *const ZSTDv07_DCtx) -> i32 { + ((*dctx).stage == STAGE_SKIP_FRAME) as i32 +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_decompressContinue( + dctx: *mut ZSTDv07_DCtx, + dst: *mut c_void, + dst_capacity: usize, + src: *const c_void, + src_size: usize, +) -> usize { + decompress_continue_impl(&mut *dctx, dst.cast(), dst_capacity, src.cast(), src_size) +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_decompressBlock( + dctx: *mut ZSTDv07_DCtx, + dst: *mut c_void, + dst_capacity: usize, + src: *const c_void, + src_size: usize, +) -> usize { + let dctx = &mut *dctx; + let dst = dst.cast::(); + check_continuity(dctx, dst); + let result = decompress_block_internal(dctx, dst, dst_capacity, src.cast(), src_size); + dctx.previous_dst_end = (dst as usize).wrapping_add(result) as *const u8; + result +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_insertBlock( + dctx: *mut ZSTDv07_DCtx, + block_start: *const c_void, + block_size: usize, +) -> usize { + let dctx = &mut *dctx; + check_continuity(dctx, block_start.cast()); + dctx.previous_dst_end = (block_start as usize).wrapping_add(block_size) as *const u8; + block_size +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_getFrameParams( + f_params: *mut ZSTDv07_frameParams, + src: *const c_void, + src_size: usize, +) -> usize { + get_frame_params_impl(&mut *f_params, src.cast(), src_size) +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_getDecompressedSize(src: *const c_void, src_size: usize) -> u64 { + let mut f_params = ZSTDv07_frameParams { + frameContentSize: 0, + windowSize: 0, + dictID: 0, + checksumFlag: 0, + }; + if get_frame_params_impl(&mut f_params, src.cast(), src_size) != 0 { + 0 + } else { + f_params.frameContentSize + } +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_decompress_usingDict( + dctx: *mut ZSTDv07_DCtx, + dst: *mut c_void, + dst_capacity: usize, + src: *const c_void, + src_size: usize, + dict: *const c_void, + dict_size: usize, +) -> usize { + let dctx = &mut *dctx; + let _ = decompress_begin_using_dict_impl(dctx, dict.cast(), dict_size); + check_continuity(dctx, dst.cast()); + decompress_frame(dctx, dst.cast(), dst_capacity, src.cast(), src_size) +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_decompressDCtx( + dctx: *mut ZSTDv07_DCtx, + dst: *mut c_void, + dst_capacity: usize, + src: *const c_void, + src_size: usize, +) -> usize { + ZSTDv07_decompress_usingDict(dctx, dst, dst_capacity, src, src_size, ptr::null(), 0) +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_decompress( + dst: *mut c_void, + dst_capacity: usize, + src: *const c_void, + src_size: usize, +) -> usize { + let dctx = ZSTDv07_createDCtx(); + if dctx.is_null() { + return ERROR(ZstdErrorCode::MemoryAllocation); + } + let result = ZSTDv07_decompressDCtx(dctx, dst, dst_capacity, src, src_size); + ZSTDv07_freeDCtx(dctx); + result +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_findFrameSizeInfoLegacy( + src: *const c_void, + src_size: usize, + c_size: *mut usize, + d_bound: *mut u64, +) { + find_frame_size_info_impl(src.cast(), src_size, c_size, d_bound) +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_createDDict( + dict: *const c_void, + dict_size: usize, +) -> *mut ZSTDv07_DDict { + create_ddict_advanced_impl(dict.cast(), dict_size, default_custom_mem()) +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_createDDict_advanced( + dict: *const c_void, + dict_size: usize, + custom_mem: ZSTDv07_customMem, +) -> *mut ZSTDv07_DDict { + create_ddict_advanced_impl(dict.cast(), dict_size, custom_mem) +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_freeDDict(ddict: *mut ZSTDv07_DDict) -> usize { + let ref_context = (*ddict).ref_context; + let custom_mem = (*ref_context).custom_mem; + ZSTDv07_freeDCtx(ref_context); + if let Some(free) = custom_mem.customFree { + free(custom_mem.opaque, (*ddict).dict); + free(custom_mem.opaque, ddict.cast()); + } + 0 +} + +#[no_mangle] +pub unsafe extern "C" fn ZSTDv07_decompress_usingDDict( + dctx: *mut ZSTDv07_DCtx, + dst: *mut c_void, + dst_capacity: usize, + src: *const c_void, + src_size: usize, + ddict: *const ZSTDv07_DDict, +) -> usize { + decompress_using_prepared_impl( + &mut *dctx, + &*(*ddict).ref_context, + dst.cast(), + dst_capacity, + src.cast(), + src_size, + ) +} + +#[repr(C)] +pub struct ZBUFFv07_DCtx { + zd: *mut ZSTDv07_DCtx, + f_params: ZSTDv07_frameParams, + stage: u32, + in_buff: *mut u8, + in_buff_size: usize, + in_pos: usize, + out_buff: *mut u8, + out_buff_size: usize, + out_start: usize, + out_end: usize, + block_size: usize, + header_buffer: [u8; FRAME_HEADER_SIZE_MAX], + lh_size: usize, + custom_mem: ZSTDv07_customMem, +} + +const BUFF_STAGE_INIT: u32 = 0; +const BUFF_STAGE_LOAD_HEADER: u32 = 1; +const BUFF_STAGE_READ: u32 = 2; +const BUFF_STAGE_LOAD: u32 = 3; +const BUFF_STAGE_FLUSH: u32 = 4; + +unsafe fn buff_free_impl(zbd: *mut ZBUFFv07_DCtx) -> usize { + if zbd.is_null() { + return 0; + } + ZSTDv07_freeDCtx((*zbd).zd); + if let Some(free) = (*zbd).custom_mem.customFree { + if !(*zbd).in_buff.is_null() { + free((*zbd).custom_mem.opaque, (*zbd).in_buff.cast()); + } + if !(*zbd).out_buff.is_null() { + free((*zbd).custom_mem.opaque, (*zbd).out_buff.cast()); + } + free((*zbd).custom_mem.opaque, zbd.cast()); + } + 0 +} + +unsafe fn buff_create_advanced_impl(custom_mem: ZSTDv07_customMem) -> *mut ZBUFFv07_DCtx { + let custom_mem = match normalized_custom_mem(custom_mem) { + Some(value) => value, + None => return ptr::null_mut(), + }; + let zbd = match custom_mem.customAlloc { + Some(alloc) => { + alloc(custom_mem.opaque, std::mem::size_of::()) as *mut ZBUFFv07_DCtx + } + None => return ptr::null_mut(), + }; + if zbd.is_null() { + return ptr::null_mut(); + } + ptr::write_bytes(zbd.cast::(), 0, std::mem::size_of::()); + (*zbd).custom_mem = custom_mem; + (*zbd).zd = ZSTDv07_createDCtx_advanced(custom_mem); + if (*zbd).zd.is_null() { + buff_free_impl(zbd); + return ptr::null_mut(); + } + (*zbd).stage = BUFF_STAGE_INIT; + zbd +} + +unsafe fn buff_init_dictionary_impl( + zbd: &mut ZBUFFv07_DCtx, + dict: *const u8, + dict_size: usize, +) -> usize { + zbd.stage = BUFF_STAGE_LOAD_HEADER; + zbd.lh_size = 0; + zbd.in_pos = 0; + zbd.out_start = 0; + zbd.out_end = 0; + ZSTDv07_decompressBegin_usingDict(zbd.zd, dict.cast(), dict_size) +} + +#[inline] +unsafe fn buff_limit_copy( + dst: *mut u8, + dst_capacity: usize, + src: *const u8, + src_size: usize, +) -> usize { + let size = dst_capacity.min(src_size); + if size != 0 { + ptr::copy(src, dst, size); + } + size +} + +unsafe fn buff_decompress_continue_impl( + zbd: &mut ZBUFFv07_DCtx, + dst: *mut u8, + dst_capacity_ptr: *mut usize, + src: *const u8, + src_size_ptr: *mut usize, +) -> usize { + let input_size = *src_size_ptr; + let input_start = src as usize; + let mut ip = input_start; + let input_end = input_start.wrapping_add(input_size); + let output_start = dst as usize; + let mut op = output_start; + let output_end = output_start.wrapping_add(*dst_capacity_ptr); + let mut not_done = true; + + while not_done { + match zbd.stage { + BUFF_STAGE_INIT => return ERROR(ZstdErrorCode::InitMissing), + BUFF_STAGE_LOAD_HEADER => { + let header_size = get_frame_params_impl( + &mut zbd.f_params, + zbd.header_buffer.as_ptr(), + zbd.lh_size, + ); + if ERR_isError(header_size) { + return header_size; + } + if header_size != 0 { + let to_load = header_size - zbd.lh_size; + if to_load > input_end.wrapping_sub(ip) { + let available = input_end.wrapping_sub(ip); + if available != 0 { + ptr::copy( + ip as *const u8, + zbd.header_buffer.as_mut_ptr().add(zbd.lh_size), + available, + ); + } + zbd.lh_size += available; + *dst_capacity_ptr = 0; + return header_size - zbd.lh_size + BLOCK_HEADER_SIZE; + } + ptr::copy( + ip as *const u8, + zbd.header_buffer.as_mut_ptr().add(zbd.lh_size), + to_load, + ); + zbd.lh_size = header_size; + ip = ip.wrapping_add(to_load); + continue; + } + zbd.stage = BUFF_STAGE_READ; + + let h1_size = ZSTDv07_nextSrcSizeToDecompress(zbd.zd); + let h1_result = ZSTDv07_decompressContinue( + zbd.zd, + ptr::null_mut(), + 0, + zbd.header_buffer.as_ptr().cast(), + h1_size, + ); + if ERR_isError(h1_result) { + return h1_result; + } + if h1_size < zbd.lh_size { + let h2_size = ZSTDv07_nextSrcSizeToDecompress(zbd.zd); + let h2_result = ZSTDv07_decompressContinue( + zbd.zd, + ptr::null_mut(), + 0, + zbd.header_buffer.as_ptr().add(h1_size).cast(), + h2_size, + ); + if ERR_isError(h2_result) { + return h2_result; + } + } + + zbd.f_params.windowSize = zbd + .f_params + .windowSize + .max(1u32 << ZSTD_WINDOWLOG_ABSOLUTE_MIN); + zbd.block_size = (zbd.f_params.windowSize as usize).min(BLOCKSIZE); + let alloc = zbd.custom_mem.customAlloc.unwrap(); + let free = zbd.custom_mem.customFree.unwrap(); + if zbd.in_buff_size < zbd.block_size { + if !zbd.in_buff.is_null() { + free(zbd.custom_mem.opaque, zbd.in_buff.cast()); + } + zbd.in_buff_size = zbd.block_size; + zbd.in_buff = alloc(zbd.custom_mem.opaque, zbd.in_buff_size).cast(); + if zbd.in_buff.is_null() { + return ERROR(ZstdErrorCode::MemoryAllocation); + } + } + let needed_out_size = + zbd.f_params.windowSize as usize + zbd.block_size + WILDCOPY_OVERLENGTH * 2; + if zbd.out_buff_size < needed_out_size { + if !zbd.out_buff.is_null() { + free(zbd.custom_mem.opaque, zbd.out_buff.cast()); + } + zbd.out_buff_size = needed_out_size; + zbd.out_buff = alloc(zbd.custom_mem.opaque, needed_out_size).cast(); + if zbd.out_buff.is_null() { + return ERROR(ZstdErrorCode::MemoryAllocation); + } + } + // pass through to the read stage + } + BUFF_STAGE_READ => { + let needed = ZSTDv07_nextSrcSizeToDecompress(zbd.zd); + if needed == 0 { + zbd.stage = BUFF_STAGE_INIT; + not_done = false; + continue; + } + if input_end.wrapping_sub(ip) >= needed { + let is_skip = ZSTDv07_isSkipFrame(zbd.zd) != 0; + let decoded = ZSTDv07_decompressContinue( + zbd.zd, + zbd.out_buff.add(zbd.out_start).cast(), + if is_skip { + 0 + } else { + zbd.out_buff_size - zbd.out_start + }, + ip as *const c_void, + needed, + ); + if ERR_isError(decoded) { + return decoded; + } + ip = ip.wrapping_add(needed); + if decoded == 0 && !is_skip { + continue; + } + zbd.out_end = zbd.out_start + decoded; + zbd.stage = BUFF_STAGE_FLUSH; + continue; + } + if ip == input_end { + not_done = false; + continue; + } + zbd.stage = BUFF_STAGE_LOAD; + } + BUFF_STAGE_LOAD => { + let needed = ZSTDv07_nextSrcSizeToDecompress(zbd.zd); + let to_load = needed.wrapping_sub(zbd.in_pos); + if to_load > zbd.in_buff_size.wrapping_sub(zbd.in_pos) { + return ERROR(ZstdErrorCode::CorruptionDetected); + } + let loaded = buff_limit_copy( + zbd.in_buff.add(zbd.in_pos), + to_load, + ip as *const u8, + input_end.wrapping_sub(ip), + ); + ip = ip.wrapping_add(loaded); + zbd.in_pos += loaded; + if loaded < to_load { + not_done = false; + continue; + } + let is_skip = ZSTDv07_isSkipFrame(zbd.zd) != 0; + let decoded = ZSTDv07_decompressContinue( + zbd.zd, + zbd.out_buff.add(zbd.out_start).cast(), + zbd.out_buff_size - zbd.out_start, + zbd.in_buff.cast(), + needed, + ); + if ERR_isError(decoded) { + return decoded; + } + zbd.in_pos = 0; + if decoded == 0 && !is_skip { + zbd.stage = BUFF_STAGE_READ; + continue; + } + zbd.out_end = zbd.out_start + decoded; + zbd.stage = BUFF_STAGE_FLUSH; + } + BUFF_STAGE_FLUSH => { + let to_flush = zbd.out_end.wrapping_sub(zbd.out_start); + let flushed = buff_limit_copy( + op as *mut u8, + output_end.wrapping_sub(op), + zbd.out_buff.add(zbd.out_start), + to_flush, + ); + op = op.wrapping_add(flushed); + zbd.out_start += flushed; + if flushed == to_flush { + zbd.stage = BUFF_STAGE_READ; + if zbd.out_start + zbd.block_size > zbd.out_buff_size { + zbd.out_start = 0; + zbd.out_end = 0; + } + } else { + not_done = false; + } + } + _ => return ERROR(ZstdErrorCode::Generic), + } + } + + *src_size_ptr = ip.wrapping_sub(input_start); + *dst_capacity_ptr = op.wrapping_sub(output_start); + let next = ZSTDv07_nextSrcSizeToDecompress(zbd.zd); + next.wrapping_sub(zbd.in_pos) +} + +#[no_mangle] +pub extern "C" fn ZBUFFv07_isError(code: usize) -> c_uint { + ERR_isError(code) as c_uint +} + +#[no_mangle] +pub extern "C" fn ZBUFFv07_getErrorName(code: usize) -> *const c_char { + ERR_getErrorName(code) +} + +#[no_mangle] +pub extern "C" fn ZBUFFv07_recommendedDInSize() -> usize { + BLOCKSIZE + BLOCK_HEADER_SIZE +} + +#[no_mangle] +pub extern "C" fn ZBUFFv07_recommendedDOutSize() -> usize { + BLOCKSIZE +} + +#[no_mangle] +pub unsafe extern "C" fn ZBUFFv07_createDCtx_advanced( + custom_mem: ZSTDv07_customMem, +) -> *mut ZBUFFv07_DCtx { + buff_create_advanced_impl(custom_mem) +} + +#[no_mangle] +pub unsafe extern "C" fn ZBUFFv07_createDCtx() -> *mut ZBUFFv07_DCtx { + buff_create_advanced_impl(default_custom_mem()) +} + +#[no_mangle] +pub unsafe extern "C" fn ZBUFFv07_freeDCtx(dctx: *mut ZBUFFv07_DCtx) -> usize { + buff_free_impl(dctx) +} + +#[no_mangle] +pub unsafe extern "C" fn ZBUFFv07_decompressInitDictionary( + dctx: *mut ZBUFFv07_DCtx, + dict: *const c_void, + dict_size: usize, +) -> usize { + buff_init_dictionary_impl(&mut *dctx, dict.cast(), dict_size) +} + +#[no_mangle] +pub unsafe extern "C" fn ZBUFFv07_decompressInit(dctx: *mut ZBUFFv07_DCtx) -> usize { + buff_init_dictionary_impl(&mut *dctx, ptr::null(), 0) +} + +#[no_mangle] +pub unsafe extern "C" fn ZBUFFv07_decompressContinue( + dctx: *mut ZBUFFv07_DCtx, + dst: *mut c_void, + dst_capacity_ptr: *mut usize, + src: *const c_void, + src_size_ptr: *mut usize, +) -> usize { + buff_decompress_continue_impl( + &mut *dctx, + dst.cast(), + dst_capacity_ptr, + src.cast(), + src_size_ptr, + ) +} + +#[cfg(test)] +mod tests { + use super::*; + use std::ffi::CStr; + + fn raw_frame(payload: &[u8]) -> Vec { + assert!(payload.len() <= 255); + let mut frame = Vec::with_capacity(6 + 3 + payload.len() + 3); + frame.extend_from_slice(&ZSTD_MAGIC_NUMBER.to_le_bytes()); + frame.push(0x20); // direct mode, one-byte content-size field + frame.push(payload.len() as u8); + frame.extend_from_slice(&[ + 0x40 | (((payload.len() >> 16) & 7) as u8), + (payload.len() >> 8) as u8, + payload.len() as u8, + ]); + frame.extend_from_slice(payload); + frame.extend_from_slice(&[0xc0, 0, 0]); + frame + } + + fn rle_frame(byte: u8, size: usize) -> Vec { + assert!(size <= 255); + let mut frame = Vec::with_capacity(6 + 3 + 1 + 3); + frame.extend_from_slice(&ZSTD_MAGIC_NUMBER.to_le_bytes()); + frame.push(0x20); + frame.push(size as u8); + frame.extend_from_slice(&[0x80, 0, size as u8, byte]); + frame.extend_from_slice(&[0xc0, 0, 0]); + frame + } + + #[test] + fn raw_frame_simple_api_and_metadata() { + let payload = b"legacy-v07"; + let frame = raw_frame(payload); + let mut params = ZSTDv07_frameParams { + frameContentSize: 0, + windowSize: 0, + dictID: 0, + checksumFlag: 0, + }; + unsafe { + assert_eq!( + ZSTDv07_getFrameParams(&mut params, frame.as_ptr().cast(), 5), + 6 + ); + assert_eq!( + ZSTDv07_getFrameParams(&mut params, frame.as_ptr().cast(), frame.len()), + 0 + ); + assert_eq!(params.frameContentSize, payload.len() as u64); + assert_eq!(params.windowSize, payload.len() as u32); + assert_eq!( + ZSTDv07_getDecompressedSize(frame.as_ptr().cast(), frame.len()), + payload.len() as u64 + ); + + let mut c_size = 0usize; + let mut d_bound = 0u64; + ZSTDv07_findFrameSizeInfoLegacy( + frame.as_ptr().cast(), + frame.len(), + &mut c_size, + &mut d_bound, + ); + assert_eq!(c_size, frame.len()); + assert_eq!(d_bound, BLOCKSIZE as u64); + + let mut output = [0u8; 32]; + let decoded = ZSTDv07_decompress( + output.as_mut_ptr().cast(), + output.len(), + frame.as_ptr().cast(), + frame.len(), + ); + assert_eq!(decoded, payload.len()); + assert_eq!(&output[..decoded], payload); + } + } + + #[test] + fn raw_frame_streaming_and_buffered_lifecycle() { + let payload = b"stream-v07"; + let frame = raw_frame(payload); + unsafe { + let dctx = ZSTDv07_createDCtx(); + assert!(!dctx.is_null()); + let mut output = [0u8; 32]; + assert_eq!(ZSTDv07_nextSrcSizeToDecompress(dctx), 5); + assert_eq!( + ZSTDv07_decompressContinue(dctx, ptr::null_mut(), 0, frame.as_ptr().cast(), 5), + 0 + ); + assert_eq!(ZSTDv07_nextSrcSizeToDecompress(dctx), 1); + assert_eq!( + ZSTDv07_decompressContinue( + dctx, + ptr::null_mut(), + 0, + frame.as_ptr().add(5).cast(), + 1 + ), + 0 + ); + assert_eq!(ZSTDv07_nextSrcSizeToDecompress(dctx), 3); + assert_eq!( + ZSTDv07_decompressContinue( + dctx, + ptr::null_mut(), + 0, + frame.as_ptr().add(6).cast(), + 3 + ), + 0 + ); + assert_eq!(ZSTDv07_nextSrcSizeToDecompress(dctx), payload.len()); + assert_eq!( + ZSTDv07_decompressContinue( + dctx, + output.as_mut_ptr().cast(), + output.len(), + frame.as_ptr().add(9).cast(), + payload.len(), + ), + payload.len() + ); + assert_eq!(ZSTDv07_nextSrcSizeToDecompress(dctx), 3); + assert_eq!( + ZSTDv07_decompressContinue( + dctx, + ptr::null_mut(), + 0, + frame.as_ptr().add(9 + payload.len()).cast(), + 3 + ), + 0 + ); + assert_eq!(&output[..payload.len()], payload); + assert_eq!(ZSTDv07_freeDCtx(dctx), 0); + assert_eq!(ZSTDv07_freeDCtx(ptr::null_mut()), 0); + + let bctx = ZBUFFv07_createDCtx(); + assert!(!bctx.is_null()); + assert_eq!(ZBUFFv07_decompressInit(bctx), 0); + let mut buffered_output = [0u8; 32]; + let mut src_size = frame.len(); + let mut dst_size = buffered_output.len(); + let hint = ZBUFFv07_decompressContinue( + bctx, + buffered_output.as_mut_ptr().cast(), + &mut dst_size, + frame.as_ptr().cast(), + &mut src_size, + ); + assert_eq!(ZBUFFv07_isError(hint), 0); + assert_eq!(src_size, frame.len()); + assert_eq!(dst_size, payload.len()); + assert_eq!(&buffered_output[..dst_size], payload); + assert_eq!(ZBUFFv07_freeDCtx(bctx), 0); + assert_eq!(ZBUFFv07_freeDCtx(ptr::null_mut()), 0); + } + } + + #[test] + fn rle_frame_and_error_names() { + let frame = rle_frame(b'R', 7); + unsafe { + let mut output = [0u8; 7]; + assert_eq!( + ZSTDv07_decompress( + output.as_mut_ptr().cast(), + output.len(), + frame.as_ptr().cast(), + frame.len(), + ), + output.len() + ); + assert_eq!(&output, b"RRRRRRR"); + assert!(ZSTDv07_isError(ERROR(ZstdErrorCode::DstSizeTooSmall)) != 0); + let name = CStr::from_ptr(ZSTDv07_getErrorName(ERROR(ZstdErrorCode::DstSizeTooSmall))); + assert_eq!(name.to_bytes(), b"Destination buffer is too small"); + } + } + + #[test] + fn compressed_frame_matches_v07_reference_encoder() { + let frame: [u8; 92] = [ + 0x27, 0xb5, 0x2f, 0xfd, 0xa4, 0x40, 0x0d, 0x03, 0x00, 0x00, 0x00, 0x42, 0xa0, 0x38, + 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x20, 0x76, 0x30, 0x37, 0x20, 0x73, 0x65, 0x71, + 0x75, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, + 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, + 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x0a, 0x6c, + 0x01, 0x00, 0x58, 0xfc, 0xaf, 0x73, 0x05, 0x05, 0x00, 0x00, 0x08, 0x80, 0x01, 0x00, + 0x3d, 0x0d, 0xf2, 0x0b, 0x04, 0xd4, 0xe1, 0xcd, + ]; + let sample = b"legacy v07 sequence payload abcdefghijklmnopqrstuvwxyz\n"; + let mut expected = Vec::with_capacity(200_000); + while expected.len() < 200_000 { + expected.extend_from_slice(sample); + } + expected.truncate(200_000); + let mut output = vec![0u8; expected.len()]; + unsafe { + let decoded = ZSTDv07_decompress( + output.as_mut_ptr().cast(), + output.len(), + frame.as_ptr().cast(), + frame.len(), + ); + assert_eq!(decoded, expected.len()); + } + assert_eq!(output, expected); + + unsafe { + let bctx = ZBUFFv07_createDCtx(); + assert!(!bctx.is_null()); + assert_eq!(ZBUFFv07_decompressInit(bctx), 0); + let mut buffered_output = vec![0u8; expected.len()]; + let mut src_size = frame.len(); + let mut dst_size = buffered_output.len(); + let hint = ZBUFFv07_decompressContinue( + bctx, + buffered_output.as_mut_ptr().cast(), + &mut dst_size, + frame.as_ptr().cast(), + &mut src_size, + ); + assert_eq!(ZBUFFv07_isError(hint), 0); + assert_eq!(src_size, frame.len()); + assert_eq!(dst_size, expected.len()); + assert_eq!(buffered_output, expected); + assert_eq!(ZBUFFv07_freeDCtx(bctx), 0); + } + } + + #[test] + fn skippable_stream_consumes_payload_without_output() { + let frame: [u8; 11] = [0x50, 0x2a, 0x4d, 0x18, 3, 0, 0, 0, 1, 2, 3]; + unsafe { + let dctx = ZSTDv07_createDCtx(); + assert_eq!( + ZSTDv07_decompressContinue(dctx, ptr::null_mut(), 0, frame.as_ptr().cast(), 5), + 0 + ); + assert_eq!(ZSTDv07_isSkipFrame(dctx), 0); + assert_eq!( + ZSTDv07_decompressContinue( + dctx, + ptr::null_mut(), + 0, + frame.as_ptr().add(5).cast(), + 3 + ), + 0 + ); + assert_eq!(ZSTDv07_isSkipFrame(dctx), 1); + assert_eq!( + ZSTDv07_decompressContinue( + dctx, + ptr::null_mut(), + 0, + frame.as_ptr().add(8).cast(), + 3 + ), + 0 + ); + assert_eq!(ZSTDv07_nextSrcSizeToDecompress(dctx), 0); + ZSTDv07_freeDCtx(dctx); + } + } +}