deps/libchdr/deps/zstd-1.5.5/lib/decompress/zstd_decompress.c

   1 /*
   2  * Copyright (c) Meta Platforms, Inc. and affiliates.
   3  * All rights reserved.
   4  *
   5  * This source code is licensed under both the BSD-style license (found in the
   6  * LICENSE file in the root directory of this source tree) and the GPLv2 (found
   7  * in the COPYING file in the root directory of this source tree).
   8  * You may select, at your option, one of the above-listed licenses.
   9  */
  10
  11
  12 /* ***************************************************************
  13 *  Tuning parameters
  14 *****************************************************************/
  15 /*!
  16  * HEAPMODE :
  17  * Select how default decompression function ZSTD_decompress() allocates its context,
  18  * on stack (0), or into heap (1, default; requires malloc()).
  19  * Note that functions with explicit context such as ZSTD_decompressDCtx() are unaffected.
  20  */
  21 #ifndef ZSTD_HEAPMODE
  22 #  define ZSTD_HEAPMODE 1
  23 #endif
  24
  25 /*!
  26 *  LEGACY_SUPPORT :
  27 *  if set to 1+, ZSTD_decompress() can decode older formats (v0.1+)
  28 */
  29 #ifndef ZSTD_LEGACY_SUPPORT
  30 #  define ZSTD_LEGACY_SUPPORT 0
  31 #endif
  32
  33 /*!
  34  *  MAXWINDOWSIZE_DEFAULT :
  35  *  maximum window size accepted by DStream __by default__.
  36  *  Frames requiring more memory will be rejected.
  37  *  It's possible to set a different limit using ZSTD_DCtx_setMaxWindowSize().
  38  */
  39 #ifndef ZSTD_MAXWINDOWSIZE_DEFAULT
  40 #  define ZSTD_MAXWINDOWSIZE_DEFAULT (((U32)1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT) + 1)
  41 #endif
  42
  43 /*!
  44  *  NO_FORWARD_PROGRESS_MAX :
  45  *  maximum allowed nb of calls to ZSTD_decompressStream()
  46  *  without any forward progress
  47  *  (defined as: no byte read from input, and no byte flushed to output)
  48  *  before triggering an error.
  49  */
  50 #ifndef ZSTD_NO_FORWARD_PROGRESS_MAX
  51 #  define ZSTD_NO_FORWARD_PROGRESS_MAX 16
  52 #endif
  53
  54
  55 /*-*******************************************************
  56 *  Dependencies
  57 *********************************************************/
  58 #include "../common/allocations.h"  /* ZSTD_customMalloc, ZSTD_customCalloc, ZSTD_customFree */
  59 #include "../common/zstd_deps.h"   /* ZSTD_memcpy, ZSTD_memmove, ZSTD_memset */
  60 #include "../common/mem.h"         /* low level memory routines */
  61 #define FSE_STATIC_LINKING_ONLY
  62 #include "../common/fse.h"
  63 #include "../common/huf.h"
  64 #include "../common/xxhash.h" /* XXH64_reset, XXH64_update, XXH64_digest, XXH64 */
  65 #include "../common/zstd_internal.h"  /* blockProperties_t */
  66 #include "zstd_decompress_internal.h"   /* ZSTD_DCtx */
  67 #include "zstd_ddict.h"  /* ZSTD_DDictDictContent */
  68 #include "zstd_decompress_block.h"   /* ZSTD_decompressBlock_internal */
  69 #include "../common/bits.h"  /* ZSTD_highbit32 */
  70
  71 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
  72 #  include "../legacy/zstd_legacy.h"
  73 #endif
  74
  75
  76
  77 /*************************************
  78  * Multiple DDicts Hashset internals *
  79  *************************************/
  80
  81 #define DDICT_HASHSET_MAX_LOAD_FACTOR_COUNT_MULT 4
  82 #define DDICT_HASHSET_MAX_LOAD_FACTOR_SIZE_MULT 3  /* These two constants represent SIZE_MULT/COUNT_MULT load factor without using a float.
  83                                                     * Currently, that means a 0.75 load factor.
  84                                                     * So, if count * COUNT_MULT / size * SIZE_MULT != 0, then we've exceeded
  85                                                     * the load factor of the ddict hash set.
  86                                                     */
  87
  88 #define DDICT_HASHSET_TABLE_BASE_SIZE 64
  89 #define DDICT_HASHSET_RESIZE_FACTOR 2
  90
  91 /* Hash function to determine starting position of dict insertion within the table
  92  * Returns an index between [0, hashSet->ddictPtrTableSize]
  93  */
  94 static size_t ZSTD_DDictHashSet_getIndex(const ZSTD_DDictHashSet* hashSet, U32 dictID) {
  95     const U64 hash = XXH64(&dictID, sizeof(U32), 0);
  96     /* DDict ptr table size is a multiple of 2, use size - 1 as mask to get index within [0, hashSet->ddictPtrTableSize) */
  97     return hash & (hashSet->ddictPtrTableSize - 1);
  98 }
  99
 100 /* Adds DDict to a hashset without resizing it.
 101  * If inserting a DDict with a dictID that already exists in the set, replaces the one in the set.
 102  * Returns 0 if successful, or a zstd error code if something went wrong.
 103  */
 104 static size_t ZSTD_DDictHashSet_emplaceDDict(ZSTD_DDictHashSet* hashSet, const ZSTD_DDict* ddict) {
 105     const U32 dictID = ZSTD_getDictID_fromDDict(ddict);
 106     size_t idx = ZSTD_DDictHashSet_getIndex(hashSet, dictID);
 107     const size_t idxRangeMask = hashSet->ddictPtrTableSize - 1;
 108     RETURN_ERROR_IF(hashSet->ddictPtrCount == hashSet->ddictPtrTableSize, GENERIC, "Hash set is full!");
 109     DEBUGLOG(4, "Hashed index: for dictID: %u is %zu", dictID, idx);
 110     while (hashSet->ddictPtrTable[idx] != NULL) {
 111         /* Replace existing ddict if inserting ddict with same dictID */
 112         if (ZSTD_getDictID_fromDDict(hashSet->ddictPtrTable[idx]) == dictID) {
 113             DEBUGLOG(4, "DictID already exists, replacing rather than adding");
 114             hashSet->ddictPtrTable[idx] = ddict;
 115             return 0;
 116         }
 117         idx &= idxRangeMask;
 118         idx++;
 119     }
 120     DEBUGLOG(4, "Final idx after probing for dictID %u is: %zu", dictID, idx);
 121     hashSet->ddictPtrTable[idx] = ddict;
 122     hashSet->ddictPtrCount++;
 123     return 0;
 124 }
 125
 126 /* Expands hash table by factor of DDICT_HASHSET_RESIZE_FACTOR and
 127  * rehashes all values, allocates new table, frees old table.
 128  * Returns 0 on success, otherwise a zstd error code.
 129  */
 130 static size_t ZSTD_DDictHashSet_expand(ZSTD_DDictHashSet* hashSet, ZSTD_customMem customMem) {
 131     size_t newTableSize = hashSet->ddictPtrTableSize * DDICT_HASHSET_RESIZE_FACTOR;
 132     const ZSTD_DDict** newTable = (const ZSTD_DDict**)ZSTD_customCalloc(sizeof(ZSTD_DDict*) * newTableSize, customMem);
 133     const ZSTD_DDict** oldTable = hashSet->ddictPtrTable;
 134     size_t oldTableSize = hashSet->ddictPtrTableSize;
 135     size_t i;
 136
 137     DEBUGLOG(4, "Expanding DDict hash table! Old size: %zu new size: %zu", oldTableSize, newTableSize);
 138     RETURN_ERROR_IF(!newTable, memory_allocation, "Expanded hashset allocation failed!");
 139     hashSet->ddictPtrTable = newTable;
 140     hashSet->ddictPtrTableSize = newTableSize;
 141     hashSet->ddictPtrCount = 0;
 142     for (i = 0; i < oldTableSize; ++i) {
 143         if (oldTable[i] != NULL) {
 144             FORWARD_IF_ERROR(ZSTD_DDictHashSet_emplaceDDict(hashSet, oldTable[i]), "");
 145         }
 146     }
 147     ZSTD_customFree((void*)oldTable, customMem);
 148     DEBUGLOG(4, "Finished re-hash");
 149     return 0;
 150 }
 151
 152 /* Fetches a DDict with the given dictID
 153  * Returns the ZSTD_DDict* with the requested dictID. If it doesn't exist, then returns NULL.
 154  */
 155 static const ZSTD_DDict* ZSTD_DDictHashSet_getDDict(ZSTD_DDictHashSet* hashSet, U32 dictID) {
 156     size_t idx = ZSTD_DDictHashSet_getIndex(hashSet, dictID);
 157     const size_t idxRangeMask = hashSet->ddictPtrTableSize - 1;
 158     DEBUGLOG(4, "Hashed index: for dictID: %u is %zu", dictID, idx);
 159     for (;;) {
 160         size_t currDictID = ZSTD_getDictID_fromDDict(hashSet->ddictPtrTable[idx]);
 161         if (currDictID == dictID || currDictID == 0) {
 162             /* currDictID == 0 implies a NULL ddict entry */
 163             break;
 164         } else {
 165             idx &= idxRangeMask;    /* Goes to start of table when we reach the end */
 166             idx++;
 167         }
 168     }
 169     DEBUGLOG(4, "Final idx after probing for dictID %u is: %zu", dictID, idx);
 170     return hashSet->ddictPtrTable[idx];
 171 }
 172
 173 /* Allocates space for and returns a ddict hash set
 174  * The hash set's ZSTD_DDict* table has all values automatically set to NULL to begin with.
 175  * Returns NULL if allocation failed.
 176  */
 177 static ZSTD_DDictHashSet* ZSTD_createDDictHashSet(ZSTD_customMem customMem) {
 178     ZSTD_DDictHashSet* ret = (ZSTD_DDictHashSet*)ZSTD_customMalloc(sizeof(ZSTD_DDictHashSet), customMem);
 179     DEBUGLOG(4, "Allocating new hash set");
 180     if (!ret)
 181         return NULL;
 182     ret->ddictPtrTable = (const ZSTD_DDict**)ZSTD_customCalloc(DDICT_HASHSET_TABLE_BASE_SIZE * sizeof(ZSTD_DDict*), customMem);
 183     if (!ret->ddictPtrTable) {
 184         ZSTD_customFree(ret, customMem);
 185         return NULL;
 186     }
 187     ret->ddictPtrTableSize = DDICT_HASHSET_TABLE_BASE_SIZE;
 188     ret->ddictPtrCount = 0;
 189     return ret;
 190 }
 191
 192 /* Frees the table of ZSTD_DDict* within a hashset, then frees the hashset itself.
 193  * Note: The ZSTD_DDict* within the table are NOT freed.
 194  */
 195 static void ZSTD_freeDDictHashSet(ZSTD_DDictHashSet* hashSet, ZSTD_customMem customMem) {
 196     DEBUGLOG(4, "Freeing ddict hash set");
 197     if (hashSet && hashSet->ddictPtrTable) {
 198         ZSTD_customFree((void*)hashSet->ddictPtrTable, customMem);
 199     }
 200     if (hashSet) {
 201         ZSTD_customFree(hashSet, customMem);
 202     }
 203 }
 204
 205 /* Public function: Adds a DDict into the ZSTD_DDictHashSet, possibly triggering a resize of the hash set.
 206  * Returns 0 on success, or a ZSTD error.
 207  */
 208 static size_t ZSTD_DDictHashSet_addDDict(ZSTD_DDictHashSet* hashSet, const ZSTD_DDict* ddict, ZSTD_customMem customMem) {
 209     DEBUGLOG(4, "Adding dict ID: %u to hashset with - Count: %zu Tablesize: %zu", ZSTD_getDictID_fromDDict(ddict), hashSet->ddictPtrCount, hashSet->ddictPtrTableSize);
 210     if (hashSet->ddictPtrCount * DDICT_HASHSET_MAX_LOAD_FACTOR_COUNT_MULT / hashSet->ddictPtrTableSize * DDICT_HASHSET_MAX_LOAD_FACTOR_SIZE_MULT != 0) {
 211         FORWARD_IF_ERROR(ZSTD_DDictHashSet_expand(hashSet, customMem), "");
 212     }
 213     FORWARD_IF_ERROR(ZSTD_DDictHashSet_emplaceDDict(hashSet, ddict), "");
 214     return 0;
 215 }
 216
 217 /*-*************************************************************
 218 *   Context management
 219 ***************************************************************/
 220 size_t ZSTD_sizeof_DCtx (const ZSTD_DCtx* dctx)
 221 {
 222     if (dctx==NULL) return 0;   /* support sizeof NULL */
 223     return sizeof(*dctx)
 224            + ZSTD_sizeof_DDict(dctx->ddictLocal)
 225            + dctx->inBuffSize + dctx->outBuffSize;
 226 }
 227
 228 size_t ZSTD_estimateDCtxSize(void) { return sizeof(ZSTD_DCtx); }
 229
 230
 231 static size_t ZSTD_startingInputLength(ZSTD_format_e format)
 232 {
 233     size_t const startingInputLength = ZSTD_FRAMEHEADERSIZE_PREFIX(format);
 234     /* only supports formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless */
 235     assert( (format == ZSTD_f_zstd1) || (format == ZSTD_f_zstd1_magicless) );
 236     return startingInputLength;
 237 }
 238
 239 static void ZSTD_DCtx_resetParameters(ZSTD_DCtx* dctx)
 240 {
 241     assert(dctx->streamStage == zdss_init);
 242     dctx->format = ZSTD_f_zstd1;
 243     dctx->maxWindowSize = ZSTD_MAXWINDOWSIZE_DEFAULT;
 244     dctx->outBufferMode = ZSTD_bm_buffered;
 245     dctx->forceIgnoreChecksum = ZSTD_d_validateChecksum;
 246     dctx->refMultipleDDicts = ZSTD_rmd_refSingleDDict;
 247     dctx->disableHufAsm = 0;
 248 }
 249
 250 static void ZSTD_initDCtx_internal(ZSTD_DCtx* dctx)
 251 {
 252     dctx->staticSize  = 0;
 253     dctx->ddict       = NULL;
 254     dctx->ddictLocal  = NULL;
 255     dctx->dictEnd     = NULL;
 256     dctx->ddictIsCold = 0;
 257     dctx->dictUses = ZSTD_dont_use;
 258     dctx->inBuff      = NULL;
 259     dctx->inBuffSize  = 0;
 260     dctx->outBuffSize = 0;
 261     dctx->streamStage = zdss_init;
 262 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
 263     dctx->legacyContext = NULL;
 264     dctx->previousLegacyVersion = 0;
 265 #endif
 266     dctx->noForwardProgress = 0;
 267     dctx->oversizedDuration = 0;
 268 #if DYNAMIC_BMI2
 269     dctx->bmi2 = ZSTD_cpuSupportsBmi2();
 270 #endif
 271     dctx->ddictSet = NULL;
 272     ZSTD_DCtx_resetParameters(dctx);
 273 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
 274     dctx->dictContentEndForFuzzing = NULL;
 275 #endif
 276 }
 277
 278 ZSTD_DCtx* ZSTD_initStaticDCtx(void *workspace, size_t workspaceSize)
 279 {
 280     ZSTD_DCtx* const dctx = (ZSTD_DCtx*) workspace;
 281
 282     if ((size_t)workspace & 7) return NULL;  /* 8-aligned */
 283     if (workspaceSize < sizeof(ZSTD_DCtx)) return NULL;  /* minimum size */
 284
 285     ZSTD_initDCtx_internal(dctx);
 286     dctx->staticSize = workspaceSize;
 287     dctx->inBuff = (char*)(dctx+1);
 288     return dctx;
 289 }
 290
 291 static ZSTD_DCtx* ZSTD_createDCtx_internal(ZSTD_customMem customMem) {
 292     if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;
 293
 294     {   ZSTD_DCtx* const dctx = (ZSTD_DCtx*)ZSTD_customMalloc(sizeof(*dctx), customMem);
 295         if (!dctx) return NULL;
 296         dctx->customMem = customMem;
 297         ZSTD_initDCtx_internal(dctx);
 298         return dctx;
 299     }
 300 }
 301
 302 ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem)
 303 {
 304     return ZSTD_createDCtx_internal(customMem);
 305 }
 306
 307 ZSTD_DCtx* ZSTD_createDCtx(void)
 308 {
 309     DEBUGLOG(3, "ZSTD_createDCtx");
 310     return ZSTD_createDCtx_internal(ZSTD_defaultCMem);
 311 }
 312
 313 static void ZSTD_clearDict(ZSTD_DCtx* dctx)
 314 {
 315     ZSTD_freeDDict(dctx->ddictLocal);
 316     dctx->ddictLocal = NULL;
 317     dctx->ddict = NULL;
 318     dctx->dictUses = ZSTD_dont_use;
 319 }
 320
 321 size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
 322 {
 323     if (dctx==NULL) return 0;   /* support free on NULL */
 324     RETURN_ERROR_IF(dctx->staticSize, memory_allocation, "not compatible with static DCtx");
 325     {   ZSTD_customMem const cMem = dctx->customMem;
 326         ZSTD_clearDict(dctx);
 327         ZSTD_customFree(dctx->inBuff, cMem);
 328         dctx->inBuff = NULL;
 329 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
 330         if (dctx->legacyContext)
 331             ZSTD_freeLegacyStreamContext(dctx->legacyContext, dctx->previousLegacyVersion);
 332 #endif
 333         if (dctx->ddictSet) {
 334             ZSTD_freeDDictHashSet(dctx->ddictSet, cMem);
 335             dctx->ddictSet = NULL;
 336         }
 337         ZSTD_customFree(dctx, cMem);
 338         return 0;
 339     }
 340 }
 341
 342 /* no longer useful */
 343 void ZSTD_copyDCtx(ZSTD_DCtx* dstDCtx, const ZSTD_DCtx* srcDCtx)
 344 {
 345     size_t const toCopy = (size_t)((char*)(&dstDCtx->inBuff) - (char*)dstDCtx);
 346     ZSTD_memcpy(dstDCtx, srcDCtx, toCopy);  /* no need to copy workspace */
 347 }
 348
 349 /* Given a dctx with a digested frame params, re-selects the correct ZSTD_DDict based on
 350  * the requested dict ID from the frame. If there exists a reference to the correct ZSTD_DDict, then
 351  * accordingly sets the ddict to be used to decompress the frame.
 352  *
 353  * If no DDict is found, then no action is taken, and the ZSTD_DCtx::ddict remains as-is.
 354  *
 355  * ZSTD_d_refMultipleDDicts must be enabled for this function to be called.
 356  */
 357 static void ZSTD_DCtx_selectFrameDDict(ZSTD_DCtx* dctx) {
 358     assert(dctx->refMultipleDDicts && dctx->ddictSet);
 359     DEBUGLOG(4, "Adjusting DDict based on requested dict ID from frame");
 360     if (dctx->ddict) {
 361         const ZSTD_DDict* frameDDict = ZSTD_DDictHashSet_getDDict(dctx->ddictSet, dctx->fParams.dictID);
 362         if (frameDDict) {
 363             DEBUGLOG(4, "DDict found!");
 364             ZSTD_clearDict(dctx);
 365             dctx->dictID = dctx->fParams.dictID;
 366             dctx->ddict = frameDDict;
 367             dctx->dictUses = ZSTD_use_indefinitely;
 368         }
 369     }
 370 }
 371
 372
 373 /*-*************************************************************
 374  *   Frame header decoding
 375  ***************************************************************/
 376
 377 /*! ZSTD_isFrame() :
 378  *  Tells if the content of `buffer` starts with a valid Frame Identifier.
 379  *  Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
 380  *  Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled.
 381  *  Note 3 : Skippable Frame Identifiers are considered valid. */
 382 unsigned ZSTD_isFrame(const void* buffer, size_t size)
 383 {
 384     if (size < ZSTD_FRAMEIDSIZE) return 0;
 385     {   U32 const magic = MEM_readLE32(buffer);
 386         if (magic == ZSTD_MAGICNUMBER) return 1;
 387         if ((magic & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) return 1;
 388     }
 389 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
 390     if (ZSTD_isLegacy(buffer, size)) return 1;
 391 #endif
 392     return 0;
 393 }
 394
 395 /*! ZSTD_isSkippableFrame() :
 396  *  Tells if the content of `buffer` starts with a valid Frame Identifier for a skippable frame.
 397  *  Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
 398  */
 399 unsigned ZSTD_isSkippableFrame(const void* buffer, size_t size)
 400 {
 401     if (size < ZSTD_FRAMEIDSIZE) return 0;
 402     {   U32 const magic = MEM_readLE32(buffer);
 403         if ((magic & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) return 1;
 404     }
 405     return 0;
 406 }
 407
 408 /** ZSTD_frameHeaderSize_internal() :
 409  *  srcSize must be large enough to reach header size fields.
 410  *  note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless.
 411  * @return : size of the Frame Header
 412  *           or an error code, which can be tested with ZSTD_isError() */
 413 static size_t ZSTD_frameHeaderSize_internal(const void* src, size_t srcSize, ZSTD_format_e format)
 414 {
 415     size_t const minInputSize = ZSTD_startingInputLength(format);
 416     RETURN_ERROR_IF(srcSize < minInputSize, srcSize_wrong, "");
 417
 418     {   BYTE const fhd = ((const BYTE*)src)[minInputSize-1];
 419         U32 const dictID= fhd & 3;
 420         U32 const singleSegment = (fhd >> 5) & 1;
 421         U32 const fcsId = fhd >> 6;
 422         return minInputSize + !singleSegment
 423              + ZSTD_did_fieldSize[dictID] + ZSTD_fcs_fieldSize[fcsId]
 424              + (singleSegment && !fcsId);
 425     }
 426 }
 427
 428 /** ZSTD_frameHeaderSize() :
 429  *  srcSize must be >= ZSTD_frameHeaderSize_prefix.
 430  * @return : size of the Frame Header,
 431  *           or an error code (if srcSize is too small) */
 432 size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize)
 433 {
 434     return ZSTD_frameHeaderSize_internal(src, srcSize, ZSTD_f_zstd1);
 435 }
 436
 437
 438 /** ZSTD_getFrameHeader_advanced() :
 439  *  decode Frame Header, or require larger `srcSize`.
 440  *  note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless
 441  * @return : 0, `zfhPtr` is correctly filled,
 442  *          >0, `srcSize` is too small, value is wanted `srcSize` amount,
 443 **           or an error code, which can be tested using ZSTD_isError() */
 444 size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format)
 445 {
 446     const BYTE* ip = (const BYTE*)src;
 447     size_t const minInputSize = ZSTD_startingInputLength(format);
 448
 449     DEBUGLOG(5, "ZSTD_getFrameHeader_advanced: minInputSize = %zu, srcSize = %zu", minInputSize, srcSize);
 450
 451     if (srcSize > 0) {
 452         /* note : technically could be considered an assert(), since it's an invalid entry */
 453         RETURN_ERROR_IF(src==NULL, GENERIC, "invalid parameter : src==NULL, but srcSize>0");
 454     }
 455     if (srcSize < minInputSize) {
 456         if (srcSize > 0 && format != ZSTD_f_zstd1_magicless) {
 457             /* when receiving less than @minInputSize bytes,
 458              * control these bytes at least correspond to a supported magic number
 459              * in order to error out early if they don't.
 460             **/
 461             size_t const toCopy = MIN(4, srcSize);
 462             unsigned char hbuf[4]; MEM_writeLE32(hbuf, ZSTD_MAGICNUMBER);
 463             assert(src != NULL);
 464             ZSTD_memcpy(hbuf, src, toCopy);
 465             if ( MEM_readLE32(hbuf) != ZSTD_MAGICNUMBER ) {
 466                 /* not a zstd frame : let's check if it's a skippable frame */
 467                 MEM_writeLE32(hbuf, ZSTD_MAGIC_SKIPPABLE_START);
 468                 ZSTD_memcpy(hbuf, src, toCopy);
 469                 if ((MEM_readLE32(hbuf) & ZSTD_MAGIC_SKIPPABLE_MASK) != ZSTD_MAGIC_SKIPPABLE_START) {
 470                     RETURN_ERROR(prefix_unknown,
 471                                 "first bytes don't correspond to any supported magic number");
 472         }   }   }
 473         return minInputSize;
 474     }
 475
 476     ZSTD_memset(zfhPtr, 0, sizeof(*zfhPtr));   /* not strictly necessary, but static analyzers may not understand that zfhPtr will be read only if return value is zero, since they are 2 different signals */
 477     if ( (format != ZSTD_f_zstd1_magicless)
 478       && (MEM_readLE32(src) != ZSTD_MAGICNUMBER) ) {
 479         if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
 480             /* skippable frame */
 481             if (srcSize < ZSTD_SKIPPABLEHEADERSIZE)
 482                 return ZSTD_SKIPPABLEHEADERSIZE; /* magic number + frame length */
 483             ZSTD_memset(zfhPtr, 0, sizeof(*zfhPtr));
 484             zfhPtr->frameContentSize = MEM_readLE32((const char *)src + ZSTD_FRAMEIDSIZE);
 485             zfhPtr->frameType = ZSTD_skippableFrame;
 486             return 0;
 487         }
 488         RETURN_ERROR(prefix_unknown, "");
 489     }
 490
 491     /* ensure there is enough `srcSize` to fully read/decode frame header */
 492     {   size_t const fhsize = ZSTD_frameHeaderSize_internal(src, srcSize, format);
 493         if (srcSize < fhsize) return fhsize;
 494         zfhPtr->headerSize = (U32)fhsize;
 495     }
 496
 497     {   BYTE const fhdByte = ip[minInputSize-1];
 498         size_t pos = minInputSize;
 499         U32 const dictIDSizeCode = fhdByte&3;
 500         U32 const checksumFlag = (fhdByte>>2)&1;
 501         U32 const singleSegment = (fhdByte>>5)&1;
 502         U32 const fcsID = fhdByte>>6;
 503         U64 windowSize = 0;
 504         U32 dictID = 0;
 505         U64 frameContentSize = ZSTD_CONTENTSIZE_UNKNOWN;
 506         RETURN_ERROR_IF((fhdByte & 0x08) != 0, frameParameter_unsupported,
 507                         "reserved bits, must be zero");
 508
 509         if (!singleSegment) {
 510             BYTE const wlByte = ip[pos++];
 511             U32 const windowLog = (wlByte >> 3) + ZSTD_WINDOWLOG_ABSOLUTEMIN;
 512             RETURN_ERROR_IF(windowLog > ZSTD_WINDOWLOG_MAX, frameParameter_windowTooLarge, "");
 513             windowSize = (1ULL << windowLog);
 514             windowSize += (windowSize >> 3) * (wlByte&7);
 515         }
 516         switch(dictIDSizeCode)
 517         {
 518             default:
 519                 assert(0);  /* impossible */
 520                 ZSTD_FALLTHROUGH;
 521             case 0 : break;
 522             case 1 : dictID = ip[pos]; pos++; break;
 523             case 2 : dictID = MEM_readLE16(ip+pos); pos+=2; break;
 524             case 3 : dictID = MEM_readLE32(ip+pos); pos+=4; break;
 525         }
 526         switch(fcsID)
 527         {
 528             default:
 529                 assert(0);  /* impossible */
 530                 ZSTD_FALLTHROUGH;
 531             case 0 : if (singleSegment) frameContentSize = ip[pos]; break;
 532             case 1 : frameContentSize = MEM_readLE16(ip+pos)+256; break;
 533             case 2 : frameContentSize = MEM_readLE32(ip+pos); break;
 534             case 3 : frameContentSize = MEM_readLE64(ip+pos); break;
 535         }
 536         if (singleSegment) windowSize = frameContentSize;
 537
 538         zfhPtr->frameType = ZSTD_frame;
 539         zfhPtr->frameContentSize = frameContentSize;
 540         zfhPtr->windowSize = windowSize;
 541         zfhPtr->blockSizeMax = (unsigned) MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
 542         zfhPtr->dictID = dictID;
 543         zfhPtr->checksumFlag = checksumFlag;
 544     }
 545     return 0;
 546 }
 547
 548 /** ZSTD_getFrameHeader() :
 549  *  decode Frame Header, or require larger `srcSize`.
 550  *  note : this function does not consume input, it only reads it.
 551  * @return : 0, `zfhPtr` is correctly filled,
 552  *          >0, `srcSize` is too small, value is wanted `srcSize` amount,
 553  *           or an error code, which can be tested using ZSTD_isError() */
 554 size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize)
 555 {
 556     return ZSTD_getFrameHeader_advanced(zfhPtr, src, srcSize, ZSTD_f_zstd1);
 557 }
 558
 559 /** ZSTD_getFrameContentSize() :
 560  *  compatible with legacy mode
 561  * @return : decompressed size of the single frame pointed to be `src` if known, otherwise
 562  *         - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined
 563  *         - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small) */
 564 unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize)
 565 {
 566 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
 567     if (ZSTD_isLegacy(src, srcSize)) {
 568         unsigned long long const ret = ZSTD_getDecompressedSize_legacy(src, srcSize);
 569         return ret == 0 ? ZSTD_CONTENTSIZE_UNKNOWN : ret;
 570     }
 571 #endif
 572     {   ZSTD_frameHeader zfh;
 573         if (ZSTD_getFrameHeader(&zfh, src, srcSize) != 0)
 574             return ZSTD_CONTENTSIZE_ERROR;
 575         if (zfh.frameType == ZSTD_skippableFrame) {
 576             return 0;
 577         } else {
 578             return zfh.frameContentSize;
 579     }   }
 580 }
 581
 582 static size_t readSkippableFrameSize(void const* src, size_t srcSize)
 583 {
 584     size_t const skippableHeaderSize = ZSTD_SKIPPABLEHEADERSIZE;
 585     U32 sizeU32;
 586
 587     RETURN_ERROR_IF(srcSize < ZSTD_SKIPPABLEHEADERSIZE, srcSize_wrong, "");
 588
 589     sizeU32 = MEM_readLE32((BYTE const*)src + ZSTD_FRAMEIDSIZE);
 590     RETURN_ERROR_IF((U32)(sizeU32 + ZSTD_SKIPPABLEHEADERSIZE) < sizeU32,
 591                     frameParameter_unsupported, "");
 592     {   size_t const skippableSize = skippableHeaderSize + sizeU32;
 593         RETURN_ERROR_IF(skippableSize > srcSize, srcSize_wrong, "");
 594         return skippableSize;
 595     }
 596 }
 597
 598 /*! ZSTD_readSkippableFrame() :
 599  * Retrieves content of a skippable frame, and writes it to dst buffer.
 600  *
 601  * The parameter magicVariant will receive the magicVariant that was supplied when the frame was written,
 602  * i.e. magicNumber - ZSTD_MAGIC_SKIPPABLE_START.  This can be NULL if the caller is not interested
 603  * in the magicVariant.
 604  *
 605  * Returns an error if destination buffer is not large enough, or if this is not a valid skippable frame.
 606  *
 607  * @return : number of bytes written or a ZSTD error.
 608  */
 609 size_t ZSTD_readSkippableFrame(void* dst, size_t dstCapacity,
 610                                unsigned* magicVariant,  /* optional, can be NULL */
 611                          const void* src, size_t srcSize)
 612 {
 613     RETURN_ERROR_IF(srcSize < ZSTD_SKIPPABLEHEADERSIZE, srcSize_wrong, "");
 614
 615     {   U32 const magicNumber = MEM_readLE32(src);
 616         size_t skippableFrameSize = readSkippableFrameSize(src, srcSize);
 617         size_t skippableContentSize = skippableFrameSize - ZSTD_SKIPPABLEHEADERSIZE;
 618
 619         /* check input validity */
 620         RETURN_ERROR_IF(!ZSTD_isSkippableFrame(src, srcSize), frameParameter_unsupported, "");
 621         RETURN_ERROR_IF(skippableFrameSize < ZSTD_SKIPPABLEHEADERSIZE || skippableFrameSize > srcSize, srcSize_wrong, "");
 622         RETURN_ERROR_IF(skippableContentSize > dstCapacity, dstSize_tooSmall, "");
 623
 624         /* deliver payload */
 625         if (skippableContentSize > 0  && dst != NULL)
 626             ZSTD_memcpy(dst, (const BYTE *)src + ZSTD_SKIPPABLEHEADERSIZE, skippableContentSize);
 627         if (magicVariant != NULL)
 628             *magicVariant = magicNumber - ZSTD_MAGIC_SKIPPABLE_START;
 629         return skippableContentSize;
 630     }
 631 }
 632
 633 /** ZSTD_findDecompressedSize() :
 634  *  `srcSize` must be the exact length of some number of ZSTD compressed and/or
 635  *      skippable frames
 636  *  note: compatible with legacy mode
 637  * @return : decompressed size of the frames contained */
 638 unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize)
 639 {
 640     unsigned long long totalDstSize = 0;
 641
 642     while (srcSize >= ZSTD_startingInputLength(ZSTD_f_zstd1)) {
 643         U32 const magicNumber = MEM_readLE32(src);
 644
 645         if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
 646             size_t const skippableSize = readSkippableFrameSize(src, srcSize);
 647             if (ZSTD_isError(skippableSize)) return ZSTD_CONTENTSIZE_ERROR;
 648             assert(skippableSize <= srcSize);
 649
 650             src = (const BYTE *)src + skippableSize;
 651             srcSize -= skippableSize;
 652             continue;
 653         }
 654
 655         {   unsigned long long const fcs = ZSTD_getFrameContentSize(src, srcSize);
 656             if (fcs >= ZSTD_CONTENTSIZE_ERROR) return fcs;
 657
 658             if (totalDstSize + fcs < totalDstSize)
 659                 return ZSTD_CONTENTSIZE_ERROR; /* check for overflow */
 660             totalDstSize += fcs;
 661         }
 662         /* skip to next frame */
 663         {   size_t const frameSrcSize = ZSTD_findFrameCompressedSize(src, srcSize);
 664             if (ZSTD_isError(frameSrcSize)) return ZSTD_CONTENTSIZE_ERROR;
 665             assert(frameSrcSize <= srcSize);
 666
 667             src = (const BYTE *)src + frameSrcSize;
 668             srcSize -= frameSrcSize;
 669         }
 670     }  /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */
 671
 672     if (srcSize) return ZSTD_CONTENTSIZE_ERROR;
 673
 674     return totalDstSize;
 675 }
 676
 677 /** ZSTD_getDecompressedSize() :
 678  *  compatible with legacy mode
 679  * @return : decompressed size if known, 0 otherwise
 680              note : 0 can mean any of the following :
 681                    - frame content is empty
 682                    - decompressed size field is not present in frame header
 683                    - frame header unknown / not supported
 684                    - frame header not complete (`srcSize` too small) */
 685 unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize)
 686 {
 687     unsigned long long const ret = ZSTD_getFrameContentSize(src, srcSize);
 688     ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_ERROR < ZSTD_CONTENTSIZE_UNKNOWN);
 689     return (ret >= ZSTD_CONTENTSIZE_ERROR) ? 0 : ret;
 690 }
 691
 692
 693 /** ZSTD_decodeFrameHeader() :
 694  * `headerSize` must be the size provided by ZSTD_frameHeaderSize().
 695  * If multiple DDict references are enabled, also will choose the correct DDict to use.
 696  * @return : 0 if success, or an error code, which can be tested using ZSTD_isError() */
 697 static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* dctx, const void* src, size_t headerSize)
 698 {
 699     size_t const result = ZSTD_getFrameHeader_advanced(&(dctx->fParams), src, headerSize, dctx->format);
 700     if (ZSTD_isError(result)) return result;    /* invalid header */
 701     RETURN_ERROR_IF(result>0, srcSize_wrong, "headerSize too small");
 702
 703     /* Reference DDict requested by frame if dctx references multiple ddicts */
 704     if (dctx->refMultipleDDicts == ZSTD_rmd_refMultipleDDicts && dctx->ddictSet) {
 705         ZSTD_DCtx_selectFrameDDict(dctx);
 706     }
 707
 708 #ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
 709     /* Skip the dictID check in fuzzing mode, because it makes the search
 710      * harder.
 711      */
 712     RETURN_ERROR_IF(dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID),
 713                     dictionary_wrong, "");
 714 #endif
 715     dctx->validateChecksum = (dctx->fParams.checksumFlag && !dctx->forceIgnoreChecksum) ? 1 : 0;
 716     if (dctx->validateChecksum) XXH64_reset(&dctx->xxhState, 0);
 717     dctx->processedCSize += headerSize;
 718     return 0;
 719 }
 720
 721 static ZSTD_frameSizeInfo ZSTD_errorFrameSizeInfo(size_t ret)
 722 {
 723     ZSTD_frameSizeInfo frameSizeInfo;
 724     frameSizeInfo.compressedSize = ret;
 725     frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR;
 726     return frameSizeInfo;
 727 }
 728
 729 static ZSTD_frameSizeInfo ZSTD_findFrameSizeInfo(const void* src, size_t srcSize)
 730 {
 731     ZSTD_frameSizeInfo frameSizeInfo;
 732     ZSTD_memset(&frameSizeInfo, 0, sizeof(ZSTD_frameSizeInfo));
 733
 734 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
 735     if (ZSTD_isLegacy(src, srcSize))
 736         return ZSTD_findFrameSizeInfoLegacy(src, srcSize);
 737 #endif
 738
 739     if ((srcSize >= ZSTD_SKIPPABLEHEADERSIZE)
 740         && (MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
 741         frameSizeInfo.compressedSize = readSkippableFrameSize(src, srcSize);
 742         assert(ZSTD_isError(frameSizeInfo.compressedSize) ||
 743                frameSizeInfo.compressedSize <= srcSize);
 744         return frameSizeInfo;
 745     } else {
 746         const BYTE* ip = (const BYTE*)src;
 747         const BYTE* const ipstart = ip;
 748         size_t remainingSize = srcSize;
 749         size_t nbBlocks = 0;
 750         ZSTD_frameHeader zfh;
 751
 752         /* Extract Frame Header */
 753         {   size_t const ret = ZSTD_getFrameHeader(&zfh, src, srcSize);
 754             if (ZSTD_isError(ret))
 755                 return ZSTD_errorFrameSizeInfo(ret);
 756             if (ret > 0)
 757                 return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
 758         }
 759
 760         ip += zfh.headerSize;
 761         remainingSize -= zfh.headerSize;
 762
 763         /* Iterate over each block */
 764         while (1) {
 765             blockProperties_t blockProperties;
 766             size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties);
 767             if (ZSTD_isError(cBlockSize))
 768                 return ZSTD_errorFrameSizeInfo(cBlockSize);
 769
 770             if (ZSTD_blockHeaderSize + cBlockSize > remainingSize)
 771                 return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
 772
 773             ip += ZSTD_blockHeaderSize + cBlockSize;
 774             remainingSize -= ZSTD_blockHeaderSize + cBlockSize;
 775             nbBlocks++;
 776
 777             if (blockProperties.lastBlock) break;
 778         }
 779
 780         /* Final frame content checksum */
 781         if (zfh.checksumFlag) {
 782             if (remainingSize < 4)
 783                 return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
 784             ip += 4;
 785         }
 786
 787         frameSizeInfo.nbBlocks = nbBlocks;
 788         frameSizeInfo.compressedSize = (size_t)(ip - ipstart);
 789         frameSizeInfo.decompressedBound = (zfh.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN)
 790                                         ? zfh.frameContentSize
 791                                         : (unsigned long long)nbBlocks * zfh.blockSizeMax;
 792         return frameSizeInfo;
 793     }
 794 }
 795
 796 /** ZSTD_findFrameCompressedSize() :
 797  *  compatible with legacy mode
 798  *  `src` must point to the start of a ZSTD frame, ZSTD legacy frame, or skippable frame
 799  *  `srcSize` must be at least as large as the frame contained
 800  *  @return : the compressed size of the frame starting at `src` */
 801 size_t ZSTD_findFrameCompressedSize(const void *src, size_t srcSize)
 802 {
 803     ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize);
 804     return frameSizeInfo.compressedSize;
 805 }
 806
 807 /** ZSTD_decompressBound() :
 808  *  compatible with legacy mode
 809  *  `src` must point to the start of a ZSTD frame or a skippeable frame
 810  *  `srcSize` must be at least as large as the frame contained
 811  *  @return : the maximum decompressed size of the compressed source
 812  */
 813 unsigned long long ZSTD_decompressBound(const void* src, size_t srcSize)
 814 {
 815     unsigned long long bound = 0;
 816     /* Iterate over each frame */
 817     while (srcSize > 0) {
 818         ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize);
 819         size_t const compressedSize = frameSizeInfo.compressedSize;
 820         unsigned long long const decompressedBound = frameSizeInfo.decompressedBound;
 821         if (ZSTD_isError(compressedSize) || decompressedBound == ZSTD_CONTENTSIZE_ERROR)
 822             return ZSTD_CONTENTSIZE_ERROR;
 823         assert(srcSize >= compressedSize);
 824         src = (const BYTE*)src + compressedSize;
 825         srcSize -= compressedSize;
 826         bound += decompressedBound;
 827     }
 828     return bound;
 829 }
 830
 831 size_t ZSTD_decompressionMargin(void const* src, size_t srcSize)
 832 {
 833     size_t margin = 0;
 834     unsigned maxBlockSize = 0;
 835
 836     /* Iterate over each frame */
 837     while (srcSize > 0) {
 838         ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize);
 839         size_t const compressedSize = frameSizeInfo.compressedSize;
 840         unsigned long long const decompressedBound = frameSizeInfo.decompressedBound;
 841         ZSTD_frameHeader zfh;
 842
 843         FORWARD_IF_ERROR(ZSTD_getFrameHeader(&zfh, src, srcSize), "");
 844         if (ZSTD_isError(compressedSize) || decompressedBound == ZSTD_CONTENTSIZE_ERROR)
 845             return ERROR(corruption_detected);
 846
 847         if (zfh.frameType == ZSTD_frame) {
 848             /* Add the frame header to our margin */
 849             margin += zfh.headerSize;
 850             /* Add the checksum to our margin */
 851             margin += zfh.checksumFlag ? 4 : 0;
 852             /* Add 3 bytes per block */
 853             margin += 3 * frameSizeInfo.nbBlocks;
 854
 855             /* Compute the max block size */
 856             maxBlockSize = MAX(maxBlockSize, zfh.blockSizeMax);
 857         } else {
 858             assert(zfh.frameType == ZSTD_skippableFrame);
 859             /* Add the entire skippable frame size to our margin. */
 860             margin += compressedSize;
 861         }
 862
 863         assert(srcSize >= compressedSize);
 864         src = (const BYTE*)src + compressedSize;
 865         srcSize -= compressedSize;
 866     }
 867
 868     /* Add the max block size back to the margin. */
 869     margin += maxBlockSize;
 870
 871     return margin;
 872 }
 873
 874 /*-*************************************************************
 875  *   Frame decoding
 876  ***************************************************************/
 877
 878 /** ZSTD_insertBlock() :
 879  *  insert `src` block into `dctx` history. Useful to track uncompressed blocks. */
 880 size_t ZSTD_insertBlock(ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize)
 881 {
 882     DEBUGLOG(5, "ZSTD_insertBlock: %u bytes", (unsigned)blockSize);
 883     ZSTD_checkContinuity(dctx, blockStart, blockSize);
 884     dctx->previousDstEnd = (const char*)blockStart + blockSize;
 885     return blockSize;
 886 }
 887
 888
 889 static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity,
 890                           const void* src, size_t srcSize)
 891 {
 892     DEBUGLOG(5, "ZSTD_copyRawBlock");
 893     RETURN_ERROR_IF(srcSize > dstCapacity, dstSize_tooSmall, "");
 894     if (dst == NULL) {
 895         if (srcSize == 0) return 0;
 896         RETURN_ERROR(dstBuffer_null, "");
 897     }
 898     ZSTD_memmove(dst, src, srcSize);
 899     return srcSize;
 900 }
 901
 902 static size_t ZSTD_setRleBlock(void* dst, size_t dstCapacity,
 903                                BYTE b,
 904                                size_t regenSize)
 905 {
 906     RETURN_ERROR_IF(regenSize > dstCapacity, dstSize_tooSmall, "");
 907     if (dst == NULL) {
 908         if (regenSize == 0) return 0;
 909         RETURN_ERROR(dstBuffer_null, "");
 910     }
 911     ZSTD_memset(dst, b, regenSize);
 912     return regenSize;
 913 }
 914
 915 static void ZSTD_DCtx_trace_end(ZSTD_DCtx const* dctx, U64 uncompressedSize, U64 compressedSize, unsigned streaming)
 916 {
 917 #if ZSTD_TRACE
 918     if (dctx->traceCtx && ZSTD_trace_decompress_end != NULL) {
 919         ZSTD_Trace trace;
 920         ZSTD_memset(&trace, 0, sizeof(trace));
 921         trace.version = ZSTD_VERSION_NUMBER;
 922         trace.streaming = streaming;
 923         if (dctx->ddict) {
 924             trace.dictionaryID = ZSTD_getDictID_fromDDict(dctx->ddict);
 925             trace.dictionarySize = ZSTD_DDict_dictSize(dctx->ddict);
 926             trace.dictionaryIsCold = dctx->ddictIsCold;
 927         }
 928         trace.uncompressedSize = (size_t)uncompressedSize;
 929         trace.compressedSize = (size_t)compressedSize;
 930         trace.dctx = dctx;
 931         ZSTD_trace_decompress_end(dctx->traceCtx, &trace);
 932     }
 933 #else
 934     (void)dctx;
 935     (void)uncompressedSize;
 936     (void)compressedSize;
 937     (void)streaming;
 938 #endif
 939 }
 940
 941
 942 /*! ZSTD_decompressFrame() :
 943  * @dctx must be properly initialized
 944  *  will update *srcPtr and *srcSizePtr,
 945  *  to make *srcPtr progress by one frame. */
 946 static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
 947                                    void* dst, size_t dstCapacity,
 948                              const void** srcPtr, size_t *srcSizePtr)
 949 {
 950     const BYTE* const istart = (const BYTE*)(*srcPtr);
 951     const BYTE* ip = istart;
 952     BYTE* const ostart = (BYTE*)dst;
 953     BYTE* const oend = dstCapacity != 0 ? ostart + dstCapacity : ostart;
 954     BYTE* op = ostart;
 955     size_t remainingSrcSize = *srcSizePtr;
 956
 957     DEBUGLOG(4, "ZSTD_decompressFrame (srcSize:%i)", (int)*srcSizePtr);
 958
 959     /* check */
 960     RETURN_ERROR_IF(
 961         remainingSrcSize < ZSTD_FRAMEHEADERSIZE_MIN(dctx->format)+ZSTD_blockHeaderSize,
 962         srcSize_wrong, "");
 963
 964     /* Frame Header */
 965     {   size_t const frameHeaderSize = ZSTD_frameHeaderSize_internal(
 966                 ip, ZSTD_FRAMEHEADERSIZE_PREFIX(dctx->format), dctx->format);
 967         if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize;
 968         RETURN_ERROR_IF(remainingSrcSize < frameHeaderSize+ZSTD_blockHeaderSize,
 969                         srcSize_wrong, "");
 970         FORWARD_IF_ERROR( ZSTD_decodeFrameHeader(dctx, ip, frameHeaderSize) , "");
 971         ip += frameHeaderSize; remainingSrcSize -= frameHeaderSize;
 972     }
 973
 974     /* Loop on each block */
 975     while (1) {
 976         BYTE* oBlockEnd = oend;
 977         size_t decodedSize;
 978         blockProperties_t blockProperties;
 979         size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSrcSize, &blockProperties);
 980         if (ZSTD_isError(cBlockSize)) return cBlockSize;
 981
 982         ip += ZSTD_blockHeaderSize;
 983         remainingSrcSize -= ZSTD_blockHeaderSize;
 984         RETURN_ERROR_IF(cBlockSize > remainingSrcSize, srcSize_wrong, "");
 985
 986         if (ip >= op && ip < oBlockEnd) {
 987             /* We are decompressing in-place. Limit the output pointer so that we
 988              * don't overwrite the block that we are currently reading. This will
 989              * fail decompression if the input & output pointers aren't spaced
 990              * far enough apart.
 991              *
 992              * This is important to set, even when the pointers are far enough
 993              * apart, because ZSTD_decompressBlock_internal() can decide to store
 994              * literals in the output buffer, after the block it is decompressing.
 995              * Since we don't want anything to overwrite our input, we have to tell
 996              * ZSTD_decompressBlock_internal to never write past ip.
 997              *
 998              * See ZSTD_allocateLiteralsBuffer() for reference.
 999              */
1000             oBlockEnd = op + (ip - op);
1001         }
1002
1003         switch(blockProperties.blockType)
1004         {
1005         case bt_compressed:
1006             decodedSize = ZSTD_decompressBlock_internal(dctx, op, (size_t)(oBlockEnd-op), ip, cBlockSize, /* frame */ 1, not_streaming);
1007             break;
1008         case bt_raw :
1009             /* Use oend instead of oBlockEnd because this function is safe to overlap. It uses memmove. */
1010             decodedSize = ZSTD_copyRawBlock(op, (size_t)(oend-op), ip, cBlockSize);
1011             break;
1012         case bt_rle :
1013             decodedSize = ZSTD_setRleBlock(op, (size_t)(oBlockEnd-op), *ip, blockProperties.origSize);
1014             break;
1015         case bt_reserved :
1016         default:
1017             RETURN_ERROR(corruption_detected, "invalid block type");
1018         }
1019
1020         if (ZSTD_isError(decodedSize)) return decodedSize;
1021         if (dctx->validateChecksum)
1022             XXH64_update(&dctx->xxhState, op, decodedSize);
1023         if (decodedSize != 0)
1024             op += decodedSize;
1025         assert(ip != NULL);
1026         ip += cBlockSize;
1027         remainingSrcSize -= cBlockSize;
1028         if (blockProperties.lastBlock) break;
1029     }
1030
1031     if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) {
1032         RETURN_ERROR_IF((U64)(op-ostart) != dctx->fParams.frameContentSize,
1033                         corruption_detected, "");
1034     }
1035     if (dctx->fParams.checksumFlag) { /* Frame content checksum verification */
1036         RETURN_ERROR_IF(remainingSrcSize<4, checksum_wrong, "");
1037         if (!dctx->forceIgnoreChecksum) {
1038             U32 const checkCalc = (U32)XXH64_digest(&dctx->xxhState);
1039             U32 checkRead;
1040             checkRead = MEM_readLE32(ip);
1041             RETURN_ERROR_IF(checkRead != checkCalc, checksum_wrong, "");
1042         }
1043         ip += 4;
1044         remainingSrcSize -= 4;
1045     }
1046     ZSTD_DCtx_trace_end(dctx, (U64)(op-ostart), (U64)(ip-istart), /* streaming */ 0);
1047     /* Allow caller to get size read */
1048     DEBUGLOG(4, "ZSTD_decompressFrame: decompressed frame of size %zi, consuming %zi bytes of input", op-ostart, ip - (const BYTE*)*srcPtr);
1049     *srcPtr = ip;
1050     *srcSizePtr = remainingSrcSize;
1051     return (size_t)(op-ostart);
1052 }
1053
1054 static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
1055                                         void* dst, size_t dstCapacity,
1056                                   const void* src, size_t srcSize,
1057                                   const void* dict, size_t dictSize,
1058                                   const ZSTD_DDict* ddict)
1059 {
1060     void* const dststart = dst;
1061     int moreThan1Frame = 0;
1062
1063     DEBUGLOG(5, "ZSTD_decompressMultiFrame");
1064     assert(dict==NULL || ddict==NULL);  /* either dict or ddict set, not both */
1065
1066     if (ddict) {
1067         dict = ZSTD_DDict_dictContent(ddict);
1068         dictSize = ZSTD_DDict_dictSize(ddict);
1069     }
1070
1071     while (srcSize >= ZSTD_startingInputLength(dctx->format)) {
1072
1073 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
1074         if (ZSTD_isLegacy(src, srcSize)) {
1075             size_t decodedSize;
1076             size_t const frameSize = ZSTD_findFrameCompressedSizeLegacy(src, srcSize);
1077             if (ZSTD_isError(frameSize)) return frameSize;
1078             RETURN_ERROR_IF(dctx->staticSize, memory_allocation,
1079                 "legacy support is not compatible with static dctx");
1080
1081             decodedSize = ZSTD_decompressLegacy(dst, dstCapacity, src, frameSize, dict, dictSize);
1082             if (ZSTD_isError(decodedSize)) return decodedSize;
1083
1084             assert(decodedSize <= dstCapacity);
1085             dst = (BYTE*)dst + decodedSize;
1086             dstCapacity -= decodedSize;
1087
1088             src = (const BYTE*)src + frameSize;
1089             srcSize -= frameSize;
1090
1091             continue;
1092         }
1093 #endif
1094
1095         if (srcSize >= 4) {
1096             U32 const magicNumber = MEM_readLE32(src);
1097             DEBUGLOG(5, "reading magic number %08X", (unsigned)magicNumber);
1098             if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
1099                 /* skippable frame detected : skip it */
1100                 size_t const skippableSize = readSkippableFrameSize(src, srcSize);
1101                 FORWARD_IF_ERROR(skippableSize, "invalid skippable frame");
1102                 assert(skippableSize <= srcSize);
1103
1104                 src = (const BYTE *)src + skippableSize;
1105                 srcSize -= skippableSize;
1106                 continue; /* check next frame */
1107         }   }
1108
1109         if (ddict) {
1110             /* we were called from ZSTD_decompress_usingDDict */
1111             FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(dctx, ddict), "");
1112         } else {
1113             /* this will initialize correctly with no dict if dict == NULL, so
1114              * use this in all cases but ddict */
1115             FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDict(dctx, dict, dictSize), "");
1116         }
1117         ZSTD_checkContinuity(dctx, dst, dstCapacity);
1118
1119         {   const size_t res = ZSTD_decompressFrame(dctx, dst, dstCapacity,
1120                                                     &src, &srcSize);
1121             RETURN_ERROR_IF(
1122                 (ZSTD_getErrorCode(res) == ZSTD_error_prefix_unknown)
1123              && (moreThan1Frame==1),
1124                 srcSize_wrong,
1125                 "At least one frame successfully completed, "
1126                 "but following bytes are garbage: "
1127                 "it's more likely to be a srcSize error, "
1128                 "specifying more input bytes than size of frame(s). "
1129                 "Note: one could be unlucky, it might be a corruption error instead, "
1130                 "happening right at the place where we expect zstd magic bytes. "
1131                 "But this is _much_ less likely than a srcSize field error.");
1132             if (ZSTD_isError(res)) return res;
1133             assert(res <= dstCapacity);
1134             if (res != 0)
1135                 dst = (BYTE*)dst + res;
1136             dstCapacity -= res;
1137         }
1138         moreThan1Frame = 1;
1139     }  /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */
1140
1141     RETURN_ERROR_IF(srcSize, srcSize_wrong, "input not entirely consumed");
1142
1143     return (size_t)((BYTE*)dst - (BYTE*)dststart);
1144 }
1145
1146 size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,
1147                                  void* dst, size_t dstCapacity,
1148                            const void* src, size_t srcSize,
1149                            const void* dict, size_t dictSize)
1150 {
1151     return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, dict, dictSize, NULL);
1152 }
1153
1154
1155 static ZSTD_DDict const* ZSTD_getDDict(ZSTD_DCtx* dctx)
1156 {
1157     switch (dctx->dictUses) {
1158     default:
1159         assert(0 /* Impossible */);
1160         ZSTD_FALLTHROUGH;
1161     case ZSTD_dont_use:
1162         ZSTD_clearDict(dctx);
1163         return NULL;
1164     case ZSTD_use_indefinitely:
1165         return dctx->ddict;
1166     case ZSTD_use_once:
1167         dctx->dictUses = ZSTD_dont_use;
1168         return dctx->ddict;
1169     }
1170 }
1171
1172 size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
1173 {
1174     return ZSTD_decompress_usingDDict(dctx, dst, dstCapacity, src, srcSize, ZSTD_getDDict(dctx));
1175 }
1176
1177
1178 size_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
1179 {
1180 #if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE>=1)
1181     size_t regenSize;
1182     ZSTD_DCtx* const dctx =  ZSTD_createDCtx_internal(ZSTD_defaultCMem);
1183     RETURN_ERROR_IF(dctx==NULL, memory_allocation, "NULL pointer!");
1184     regenSize = ZSTD_decompressDCtx(dctx, dst, dstCapacity, src, srcSize);
1185     ZSTD_freeDCtx(dctx);
1186     return regenSize;
1187 #else   /* stack mode */
1188     ZSTD_DCtx dctx;
1189     ZSTD_initDCtx_internal(&dctx);
1190     return ZSTD_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);
1191 #endif
1192 }
1193
1194
1195 /*-**************************************
1196 *   Advanced Streaming Decompression API
1197 *   Bufferless and synchronous
1198 ****************************************/
1199 size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx) { return dctx->expected; }
1200
1201 /**
1202  * Similar to ZSTD_nextSrcSizeToDecompress(), but when a block input can be streamed, we
1203  * allow taking a partial block as the input. Currently only raw uncompressed blocks can
1204  * be streamed.
1205  *
1206  * For blocks that can be streamed, this allows us to reduce the latency until we produce
1207  * output, and avoid copying the input.
1208  *
1209  * @param inputSize - The total amount of input that the caller currently has.
1210  */
1211 static size_t ZSTD_nextSrcSizeToDecompressWithInputSize(ZSTD_DCtx* dctx, size_t inputSize) {
1212     if (!(dctx->stage == ZSTDds_decompressBlock || dctx->stage == ZSTDds_decompressLastBlock))
1213         return dctx->expected;
1214     if (dctx->bType != bt_raw)
1215         return dctx->expected;
1216     return BOUNDED(1, inputSize, dctx->expected);
1217 }
1218
1219 ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx) {
1220     switch(dctx->stage)
1221     {
1222     default:   /* should not happen */
1223         assert(0);
1224         ZSTD_FALLTHROUGH;
1225     case ZSTDds_getFrameHeaderSize:
1226         ZSTD_FALLTHROUGH;
1227     case ZSTDds_decodeFrameHeader:
1228         return ZSTDnit_frameHeader;
1229     case ZSTDds_decodeBlockHeader:
1230         return ZSTDnit_blockHeader;
1231     case ZSTDds_decompressBlock:
1232         return ZSTDnit_block;
1233     case ZSTDds_decompressLastBlock:
1234         return ZSTDnit_lastBlock;
1235     case ZSTDds_checkChecksum:
1236         return ZSTDnit_checksum;
1237     case ZSTDds_decodeSkippableHeader:
1238         ZSTD_FALLTHROUGH;
1239     case ZSTDds_skipFrame:
1240         return ZSTDnit_skippableFrame;
1241     }
1242 }
1243
1244 static int ZSTD_isSkipFrame(ZSTD_DCtx* dctx) { return dctx->stage == ZSTDds_skipFrame; }
1245
1246 /** ZSTD_decompressContinue() :
1247  *  srcSize : must be the exact nb of bytes expected (see ZSTD_nextSrcSizeToDecompress())
1248  *  @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity)
1249  *            or an error code, which can be tested using ZSTD_isError() */
1250 size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
1251 {
1252     DEBUGLOG(5, "ZSTD_decompressContinue (srcSize:%u)", (unsigned)srcSize);
1253     /* Sanity check */
1254     RETURN_ERROR_IF(srcSize != ZSTD_nextSrcSizeToDecompressWithInputSize(dctx, srcSize), srcSize_wrong, "not allowed");
1255     ZSTD_checkContinuity(dctx, dst, dstCapacity);
1256
1257     dctx->processedCSize += srcSize;
1258
1259     switch (dctx->stage)
1260     {
1261     case ZSTDds_getFrameHeaderSize :
1262         assert(src != NULL);
1263         if (dctx->format == ZSTD_f_zstd1) {  /* allows header */
1264             assert(srcSize >= ZSTD_FRAMEIDSIZE);  /* to read skippable magic number */
1265             if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {        /* skippable frame */
1266                 ZSTD_memcpy(dctx->headerBuffer, src, srcSize);
1267                 dctx->expected = ZSTD_SKIPPABLEHEADERSIZE - srcSize;  /* remaining to load to get full skippable frame header */
1268                 dctx->stage = ZSTDds_decodeSkippableHeader;
1269                 return 0;
1270         }   }
1271         dctx->headerSize = ZSTD_frameHeaderSize_internal(src, srcSize, dctx->format);
1272         if (ZSTD_isError(dctx->headerSize)) return dctx->headerSize;
1273         ZSTD_memcpy(dctx->headerBuffer, src, srcSize);
1274         dctx->expected = dctx->headerSize - srcSize;
1275         dctx->stage = ZSTDds_decodeFrameHeader;
1276         return 0;
1277
1278     case ZSTDds_decodeFrameHeader:
1279         assert(src != NULL);
1280         ZSTD_memcpy(dctx->headerBuffer + (dctx->headerSize - srcSize), src, srcSize);
1281         FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize), "");
1282         dctx->expected = ZSTD_blockHeaderSize;
1283         dctx->stage = ZSTDds_decodeBlockHeader;
1284         return 0;
1285
1286     case ZSTDds_decodeBlockHeader:
1287         {   blockProperties_t bp;
1288             size_t const cBlockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);
1289             if (ZSTD_isError(cBlockSize)) return cBlockSize;
1290             RETURN_ERROR_IF(cBlockSize > dctx->fParams.blockSizeMax, corruption_detected, "Block Size Exceeds Maximum");
1291             dctx->expected = cBlockSize;
1292             dctx->bType = bp.blockType;
1293             dctx->rleSize = bp.origSize;
1294             if (cBlockSize) {
1295                 dctx->stage = bp.lastBlock ? ZSTDds_decompressLastBlock : ZSTDds_decompressBlock;
1296                 return 0;
1297             }
1298             /* empty block */
1299             if (bp.lastBlock) {
1300                 if (dctx->fParams.checksumFlag) {
1301                     dctx->expected = 4;
1302                     dctx->stage = ZSTDds_checkChecksum;
1303                 } else {
1304                     dctx->expected = 0; /* end of frame */
1305                     dctx->stage = ZSTDds_getFrameHeaderSize;
1306                 }
1307             } else {
1308                 dctx->expected = ZSTD_blockHeaderSize;  /* jump to next header */
1309                 dctx->stage = ZSTDds_decodeBlockHeader;
1310             }
1311             return 0;
1312         }
1313
1314     case ZSTDds_decompressLastBlock:
1315     case ZSTDds_decompressBlock:
1316         DEBUGLOG(5, "ZSTD_decompressContinue: case ZSTDds_decompressBlock");
1317         {   size_t rSize;
1318             switch(dctx->bType)
1319             {
1320             case bt_compressed:
1321                 DEBUGLOG(5, "ZSTD_decompressContinue: case bt_compressed");
1322                 rSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 1, is_streaming);
1323                 dctx->expected = 0;  /* Streaming not supported */
1324                 break;
1325             case bt_raw :
1326                 assert(srcSize <= dctx->expected);
1327                 rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize);
1328                 FORWARD_IF_ERROR(rSize, "ZSTD_copyRawBlock failed");
1329                 assert(rSize == srcSize);
1330                 dctx->expected -= rSize;
1331                 break;
1332             case bt_rle :
1333                 rSize = ZSTD_setRleBlock(dst, dstCapacity, *(const BYTE*)src, dctx->rleSize);
1334                 dctx->expected = 0;  /* Streaming not supported */
1335                 break;
1336             case bt_reserved :   /* should never happen */
1337             default:
1338                 RETURN_ERROR(corruption_detected, "invalid block type");
1339             }
1340             FORWARD_IF_ERROR(rSize, "");
1341             RETURN_ERROR_IF(rSize > dctx->fParams.blockSizeMax, corruption_detected, "Decompressed Block Size Exceeds Maximum");
1342             DEBUGLOG(5, "ZSTD_decompressContinue: decoded size from block : %u", (unsigned)rSize);
1343             dctx->decodedSize += rSize;
1344             if (dctx->validateChecksum) XXH64_update(&dctx->xxhState, dst, rSize);
1345             dctx->previousDstEnd = (char*)dst + rSize;
1346
1347             /* Stay on the same stage until we are finished streaming the block. */
1348             if (dctx->expected > 0) {
1349                 return rSize;
1350             }
1351
1352             if (dctx->stage == ZSTDds_decompressLastBlock) {   /* end of frame */
1353                 DEBUGLOG(4, "ZSTD_decompressContinue: decoded size from frame : %u", (unsigned)dctx->decodedSize);
1354                 RETURN_ERROR_IF(
1355                     dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
1356                  && dctx->decodedSize != dctx->fParams.frameContentSize,
1357                     corruption_detected, "");
1358                 if (dctx->fParams.checksumFlag) {  /* another round for frame checksum */
1359                     dctx->expected = 4;
1360                     dctx->stage = ZSTDds_checkChecksum;
1361                 } else {
1362                     ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, /* streaming */ 1);
1363                     dctx->expected = 0;   /* ends here */
1364                     dctx->stage = ZSTDds_getFrameHeaderSize;
1365                 }
1366             } else {
1367                 dctx->stage = ZSTDds_decodeBlockHeader;
1368                 dctx->expected = ZSTD_blockHeaderSize;
1369             }
1370             return rSize;
1371         }
1372
1373     case ZSTDds_checkChecksum:
1374         assert(srcSize == 4);  /* guaranteed by dctx->expected */
1375         {
1376             if (dctx->validateChecksum) {
1377                 U32 const h32 = (U32)XXH64_digest(&dctx->xxhState);
1378                 U32 const check32 = MEM_readLE32(src);
1379                 DEBUGLOG(4, "ZSTD_decompressContinue: checksum : calculated %08X :: %08X read", (unsigned)h32, (unsigned)check32);
1380                 RETURN_ERROR_IF(check32 != h32, checksum_wrong, "");
1381             }
1382             ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, /* streaming */ 1);
1383             dctx->expected = 0;
1384             dctx->stage = ZSTDds_getFrameHeaderSize;
1385             return 0;
1386         }
1387
1388     case ZSTDds_decodeSkippableHeader:
1389         assert(src != NULL);
1390         assert(srcSize <= ZSTD_SKIPPABLEHEADERSIZE);
1391         ZSTD_memcpy(dctx->headerBuffer + (ZSTD_SKIPPABLEHEADERSIZE - srcSize), src, srcSize);   /* complete skippable header */
1392         dctx->expected = MEM_readLE32(dctx->headerBuffer + ZSTD_FRAMEIDSIZE);   /* note : dctx->expected can grow seriously large, beyond local buffer size */
1393         dctx->stage = ZSTDds_skipFrame;
1394         return 0;
1395
1396     case ZSTDds_skipFrame:
1397         dctx->expected = 0;
1398         dctx->stage = ZSTDds_getFrameHeaderSize;
1399         return 0;
1400
1401     default:
1402         assert(0);   /* impossible */
1403         RETURN_ERROR(GENERIC, "impossible to reach");   /* some compilers require default to do something */
1404     }
1405 }
1406
1407
1408 static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1409 {
1410     dctx->dictEnd = dctx->previousDstEnd;
1411     dctx->virtualStart = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));
1412     dctx->prefixStart = dict;
1413     dctx->previousDstEnd = (const char*)dict + dictSize;
1414 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
1415     dctx->dictContentBeginForFuzzing = dctx->prefixStart;
1416     dctx->dictContentEndForFuzzing = dctx->previousDstEnd;
1417 #endif
1418     return 0;
1419 }
1420
1421 /*! ZSTD_loadDEntropy() :
1422  *  dict : must point at beginning of a valid zstd dictionary.
1423  * @return : size of entropy tables read */
1424 size_t
1425 ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
1426                   const void* const dict, size_t const dictSize)
1427 {
1428     const BYTE* dictPtr = (const BYTE*)dict;
1429     const BYTE* const dictEnd = dictPtr + dictSize;
1430
1431     RETURN_ERROR_IF(dictSize <= 8, dictionary_corrupted, "dict is too small");
1432     assert(MEM_readLE32(dict) == ZSTD_MAGIC_DICTIONARY);   /* dict must be valid */
1433     dictPtr += 8;   /* skip header = magic + dictID */
1434
1435     ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, OFTable) == offsetof(ZSTD_entropyDTables_t, LLTable) + sizeof(entropy->LLTable));
1436     ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, MLTable) == offsetof(ZSTD_entropyDTables_t, OFTable) + sizeof(entropy->OFTable));
1437     ZSTD_STATIC_ASSERT(sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable) >= HUF_DECOMPRESS_WORKSPACE_SIZE);
1438     {   void* const workspace = &entropy->LLTable;   /* use fse tables as temporary workspace; implies fse tables are grouped together */
1439         size_t const workspaceSize = sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable);
1440 #ifdef HUF_FORCE_DECOMPRESS_X1
1441         /* in minimal huffman, we always use X1 variants */
1442         size_t const hSize = HUF_readDTableX1_wksp(entropy->hufTable,
1443                                                 dictPtr, dictEnd - dictPtr,
1444                                                 workspace, workspaceSize, /* flags */ 0);
1445 #else
1446         size_t const hSize = HUF_readDTableX2_wksp(entropy->hufTable,
1447                                                 dictPtr, (size_t)(dictEnd - dictPtr),
1448                                                 workspace, workspaceSize, /* flags */ 0);
1449 #endif
1450         RETURN_ERROR_IF(HUF_isError(hSize), dictionary_corrupted, "");
1451         dictPtr += hSize;
1452     }
1453
1454     {   short offcodeNCount[MaxOff+1];
1455         unsigned offcodeMaxValue = MaxOff, offcodeLog;
1456         size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, (size_t)(dictEnd-dictPtr));
1457         RETURN_ERROR_IF(FSE_isError(offcodeHeaderSize), dictionary_corrupted, "");
1458         RETURN_ERROR_IF(offcodeMaxValue > MaxOff, dictionary_corrupted, "");
1459         RETURN_ERROR_IF(offcodeLog > OffFSELog, dictionary_corrupted, "");
1460         ZSTD_buildFSETable( entropy->OFTable,
1461                             offcodeNCount, offcodeMaxValue,
1462                             OF_base, OF_bits,
1463                             offcodeLog,
1464                             entropy->workspace, sizeof(entropy->workspace),
1465                             /* bmi2 */0);
1466         dictPtr += offcodeHeaderSize;
1467     }
1468
1469     {   short matchlengthNCount[MaxML+1];
1470         unsigned matchlengthMaxValue = MaxML, matchlengthLog;
1471         size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, (size_t)(dictEnd-dictPtr));
1472         RETURN_ERROR_IF(FSE_isError(matchlengthHeaderSize), dictionary_corrupted, "");
1473         RETURN_ERROR_IF(matchlengthMaxValue > MaxML, dictionary_corrupted, "");
1474         RETURN_ERROR_IF(matchlengthLog > MLFSELog, dictionary_corrupted, "");
1475         ZSTD_buildFSETable( entropy->MLTable,
1476                             matchlengthNCount, matchlengthMaxValue,
1477                             ML_base, ML_bits,
1478                             matchlengthLog,
1479                             entropy->workspace, sizeof(entropy->workspace),
1480                             /* bmi2 */ 0);
1481         dictPtr += matchlengthHeaderSize;
1482     }
1483
1484     {   short litlengthNCount[MaxLL+1];
1485         unsigned litlengthMaxValue = MaxLL, litlengthLog;
1486         size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, (size_t)(dictEnd-dictPtr));
1487         RETURN_ERROR_IF(FSE_isError(litlengthHeaderSize), dictionary_corrupted, "");
1488         RETURN_ERROR_IF(litlengthMaxValue > MaxLL, dictionary_corrupted, "");
1489         RETURN_ERROR_IF(litlengthLog > LLFSELog, dictionary_corrupted, "");
1490         ZSTD_buildFSETable( entropy->LLTable,
1491                             litlengthNCount, litlengthMaxValue,
1492                             LL_base, LL_bits,
1493                             litlengthLog,
1494                             entropy->workspace, sizeof(entropy->workspace),
1495                             /* bmi2 */ 0);
1496         dictPtr += litlengthHeaderSize;
1497     }
1498
1499     RETURN_ERROR_IF(dictPtr+12 > dictEnd, dictionary_corrupted, "");
1500     {   int i;
1501         size_t const dictContentSize = (size_t)(dictEnd - (dictPtr+12));
1502         for (i=0; i<3; i++) {
1503             U32 const rep = MEM_readLE32(dictPtr); dictPtr += 4;
1504             RETURN_ERROR_IF(rep==0 || rep > dictContentSize,
1505                             dictionary_corrupted, "");
1506             entropy->rep[i] = rep;
1507     }   }
1508
1509     return (size_t)(dictPtr - (const BYTE*)dict);
1510 }
1511
1512 static size_t ZSTD_decompress_insertDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1513 {
1514     if (dictSize < 8) return ZSTD_refDictContent(dctx, dict, dictSize);
1515     {   U32 const magic = MEM_readLE32(dict);
1516         if (magic != ZSTD_MAGIC_DICTIONARY) {
1517             return ZSTD_refDictContent(dctx, dict, dictSize);   /* pure content mode */
1518     }   }
1519     dctx->dictID = MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);
1520
1521     /* load entropy tables */
1522     {   size_t const eSize = ZSTD_loadDEntropy(&dctx->entropy, dict, dictSize);
1523         RETURN_ERROR_IF(ZSTD_isError(eSize), dictionary_corrupted, "");
1524         dict = (const char*)dict + eSize;
1525         dictSize -= eSize;
1526     }
1527     dctx->litEntropy = dctx->fseEntropy = 1;
1528
1529     /* reference dictionary content */
1530     return ZSTD_refDictContent(dctx, dict, dictSize);
1531 }
1532
1533 size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx)
1534 {
1535     assert(dctx != NULL);
1536 #if ZSTD_TRACE
1537     dctx->traceCtx = (ZSTD_trace_decompress_begin != NULL) ? ZSTD_trace_decompress_begin(dctx) : 0;
1538 #endif
1539     dctx->expected = ZSTD_startingInputLength(dctx->format);  /* dctx->format must be properly set */
1540     dctx->stage = ZSTDds_getFrameHeaderSize;
1541     dctx->processedCSize = 0;
1542     dctx->decodedSize = 0;
1543     dctx->previousDstEnd = NULL;
1544     dctx->prefixStart = NULL;
1545     dctx->virtualStart = NULL;
1546     dctx->dictEnd = NULL;
1547     dctx->entropy.hufTable[0] = (HUF_DTable)((ZSTD_HUFFDTABLE_CAPACITY_LOG)*0x1000001);  /* cover both little and big endian */
1548     dctx->litEntropy = dctx->fseEntropy = 0;
1549     dctx->dictID = 0;
1550     dctx->bType = bt_reserved;
1551     ZSTD_STATIC_ASSERT(sizeof(dctx->entropy.rep) == sizeof(repStartValue));
1552     ZSTD_memcpy(dctx->entropy.rep, repStartValue, sizeof(repStartValue));  /* initial repcodes */
1553     dctx->LLTptr = dctx->entropy.LLTable;
1554     dctx->MLTptr = dctx->entropy.MLTable;
1555     dctx->OFTptr = dctx->entropy.OFTable;
1556     dctx->HUFptr = dctx->entropy.hufTable;
1557     return 0;
1558 }
1559
1560 size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1561 {
1562     FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , "");
1563     if (dict && dictSize)
1564         RETURN_ERROR_IF(
1565             ZSTD_isError(ZSTD_decompress_insertDictionary(dctx, dict, dictSize)),
1566             dictionary_corrupted, "");
1567     return 0;
1568 }
1569
1570
1571 /* ======   ZSTD_DDict   ====== */
1572
1573 size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
1574 {
1575     DEBUGLOG(4, "ZSTD_decompressBegin_usingDDict");
1576     assert(dctx != NULL);
1577     if (ddict) {
1578         const char* const dictStart = (const char*)ZSTD_DDict_dictContent(ddict);
1579         size_t const dictSize = ZSTD_DDict_dictSize(ddict);
1580         const void* const dictEnd = dictStart + dictSize;
1581         dctx->ddictIsCold = (dctx->dictEnd != dictEnd);
1582         DEBUGLOG(4, "DDict is %s",
1583                     dctx->ddictIsCold ? "~cold~" : "hot!");
1584     }
1585     FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , "");
1586     if (ddict) {   /* NULL ddict is equivalent to no dictionary */
1587         ZSTD_copyDDictParameters(dctx, ddict);
1588     }
1589     return 0;
1590 }
1591
1592 /*! ZSTD_getDictID_fromDict() :
1593  *  Provides the dictID stored within dictionary.
1594  *  if @return == 0, the dictionary is not conformant with Zstandard specification.
1595  *  It can still be loaded, but as a content-only dictionary. */
1596 unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize)
1597 {
1598     if (dictSize < 8) return 0;
1599     if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) return 0;
1600     return MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);
1601 }
1602
1603 /*! ZSTD_getDictID_fromFrame() :
1604  *  Provides the dictID required to decompress frame stored within `src`.
1605  *  If @return == 0, the dictID could not be decoded.
1606  *  This could for one of the following reasons :
1607  *  - The frame does not require a dictionary (most common case).
1608  *  - The frame was built with dictID intentionally removed.
1609  *    Needed dictionary is a hidden piece of information.
1610  *    Note : this use case also happens when using a non-conformant dictionary.
1611  *  - `srcSize` is too small, and as a result, frame header could not be decoded.
1612  *    Note : possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`.
1613  *  - This is not a Zstandard frame.
1614  *  When identifying the exact failure cause, it's possible to use
1615  *  ZSTD_getFrameHeader(), which will provide a more precise error code. */
1616 unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize)
1617 {
1618     ZSTD_frameHeader zfp = { 0, 0, 0, ZSTD_frame, 0, 0, 0, 0, 0 };
1619     size_t const hError = ZSTD_getFrameHeader(&zfp, src, srcSize);
1620     if (ZSTD_isError(hError)) return 0;
1621     return zfp.dictID;
1622 }
1623
1624
1625 /*! ZSTD_decompress_usingDDict() :
1626 *   Decompression using a pre-digested Dictionary
1627 *   Use dictionary without significant overhead. */
1628 size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx,
1629                                   void* dst, size_t dstCapacity,
1630                             const void* src, size_t srcSize,
1631                             const ZSTD_DDict* ddict)
1632 {
1633     /* pass content and size in case legacy frames are encountered */
1634     return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize,
1635                                      NULL, 0,
1636                                      ddict);
1637 }
1638
1639
1640 /*=====================================
1641 *   Streaming decompression
1642 *====================================*/
1643
1644 ZSTD_DStream* ZSTD_createDStream(void)
1645 {
1646     DEBUGLOG(3, "ZSTD_createDStream");
1647     return ZSTD_createDCtx_internal(ZSTD_defaultCMem);
1648 }
1649
1650 ZSTD_DStream* ZSTD_initStaticDStream(void *workspace, size_t workspaceSize)
1651 {
1652     return ZSTD_initStaticDCtx(workspace, workspaceSize);
1653 }
1654
1655 ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem)
1656 {
1657     return ZSTD_createDCtx_internal(customMem);
1658 }
1659
1660 size_t ZSTD_freeDStream(ZSTD_DStream* zds)
1661 {
1662     return ZSTD_freeDCtx(zds);
1663 }
1664
1665
1666 /* ***  Initialization  *** */
1667
1668 size_t ZSTD_DStreamInSize(void)  { return ZSTD_BLOCKSIZE_MAX + ZSTD_blockHeaderSize; }
1669 size_t ZSTD_DStreamOutSize(void) { return ZSTD_BLOCKSIZE_MAX; }
1670
1671 size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx,
1672                                    const void* dict, size_t dictSize,
1673                                          ZSTD_dictLoadMethod_e dictLoadMethod,
1674                                          ZSTD_dictContentType_e dictContentType)
1675 {
1676     RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1677     ZSTD_clearDict(dctx);
1678     if (dict && dictSize != 0) {
1679         dctx->ddictLocal = ZSTD_createDDict_advanced(dict, dictSize, dictLoadMethod, dictContentType, dctx->customMem);
1680         RETURN_ERROR_IF(dctx->ddictLocal == NULL, memory_allocation, "NULL pointer!");
1681         dctx->ddict = dctx->ddictLocal;
1682         dctx->dictUses = ZSTD_use_indefinitely;
1683     }
1684     return 0;
1685 }
1686
1687 size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1688 {
1689     return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto);
1690 }
1691
1692 size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1693 {
1694     return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto);
1695 }
1696
1697 size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType)
1698 {
1699     FORWARD_IF_ERROR(ZSTD_DCtx_loadDictionary_advanced(dctx, prefix, prefixSize, ZSTD_dlm_byRef, dictContentType), "");
1700     dctx->dictUses = ZSTD_use_once;
1701     return 0;
1702 }
1703
1704 size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize)
1705 {
1706     return ZSTD_DCtx_refPrefix_advanced(dctx, prefix, prefixSize, ZSTD_dct_rawContent);
1707 }
1708
1709
1710 /* ZSTD_initDStream_usingDict() :
1711  * return : expected size, aka ZSTD_startingInputLength().
1712  * this function cannot fail */
1713 size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize)
1714 {
1715     DEBUGLOG(4, "ZSTD_initDStream_usingDict");
1716     FORWARD_IF_ERROR( ZSTD_DCtx_reset(zds, ZSTD_reset_session_only) , "");
1717     FORWARD_IF_ERROR( ZSTD_DCtx_loadDictionary(zds, dict, dictSize) , "");
1718     return ZSTD_startingInputLength(zds->format);
1719 }
1720
1721 /* note : this variant can't fail */
1722 size_t ZSTD_initDStream(ZSTD_DStream* zds)
1723 {
1724     DEBUGLOG(4, "ZSTD_initDStream");
1725     FORWARD_IF_ERROR(ZSTD_DCtx_reset(zds, ZSTD_reset_session_only), "");
1726     FORWARD_IF_ERROR(ZSTD_DCtx_refDDict(zds, NULL), "");
1727     return ZSTD_startingInputLength(zds->format);
1728 }
1729
1730 /* ZSTD_initDStream_usingDDict() :
1731  * ddict will just be referenced, and must outlive decompression session
1732  * this function cannot fail */
1733 size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* dctx, const ZSTD_DDict* ddict)
1734 {
1735     DEBUGLOG(4, "ZSTD_initDStream_usingDDict");
1736     FORWARD_IF_ERROR( ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only) , "");
1737     FORWARD_IF_ERROR( ZSTD_DCtx_refDDict(dctx, ddict) , "");
1738     return ZSTD_startingInputLength(dctx->format);
1739 }
1740
1741 /* ZSTD_resetDStream() :
1742  * return : expected size, aka ZSTD_startingInputLength().
1743  * this function cannot fail */
1744 size_t ZSTD_resetDStream(ZSTD_DStream* dctx)
1745 {
1746     DEBUGLOG(4, "ZSTD_resetDStream");
1747     FORWARD_IF_ERROR(ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only), "");
1748     return ZSTD_startingInputLength(dctx->format);
1749 }
1750
1751
1752 size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
1753 {
1754     RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1755     ZSTD_clearDict(dctx);
1756     if (ddict) {
1757         dctx->ddict = ddict;
1758         dctx->dictUses = ZSTD_use_indefinitely;
1759         if (dctx->refMultipleDDicts == ZSTD_rmd_refMultipleDDicts) {
1760             if (dctx->ddictSet == NULL) {
1761                 dctx->ddictSet = ZSTD_createDDictHashSet(dctx->customMem);
1762                 if (!dctx->ddictSet) {
1763                     RETURN_ERROR(memory_allocation, "Failed to allocate memory for hash set!");
1764                 }
1765             }
1766             assert(!dctx->staticSize);  /* Impossible: ddictSet cannot have been allocated if static dctx */
1767             FORWARD_IF_ERROR(ZSTD_DDictHashSet_addDDict(dctx->ddictSet, ddict, dctx->customMem), "");
1768         }
1769     }
1770     return 0;
1771 }
1772
1773 /* ZSTD_DCtx_setMaxWindowSize() :
1774  * note : no direct equivalence in ZSTD_DCtx_setParameter,
1775  * since this version sets windowSize, and the other sets windowLog */
1776 size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize)
1777 {
1778     ZSTD_bounds const bounds = ZSTD_dParam_getBounds(ZSTD_d_windowLogMax);
1779     size_t const min = (size_t)1 << bounds.lowerBound;
1780     size_t const max = (size_t)1 << bounds.upperBound;
1781     RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1782     RETURN_ERROR_IF(maxWindowSize < min, parameter_outOfBound, "");
1783     RETURN_ERROR_IF(maxWindowSize > max, parameter_outOfBound, "");
1784     dctx->maxWindowSize = maxWindowSize;
1785     return 0;
1786 }
1787
1788 size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format)
1789 {
1790     return ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, (int)format);
1791 }
1792
1793 ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam)
1794 {
1795     ZSTD_bounds bounds = { 0, 0, 0 };
1796     switch(dParam) {
1797         case ZSTD_d_windowLogMax:
1798             bounds.lowerBound = ZSTD_WINDOWLOG_ABSOLUTEMIN;
1799             bounds.upperBound = ZSTD_WINDOWLOG_MAX;
1800             return bounds;
1801         case ZSTD_d_format:
1802             bounds.lowerBound = (int)ZSTD_f_zstd1;
1803             bounds.upperBound = (int)ZSTD_f_zstd1_magicless;
1804             ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless);
1805             return bounds;
1806         case ZSTD_d_stableOutBuffer:
1807             bounds.lowerBound = (int)ZSTD_bm_buffered;
1808             bounds.upperBound = (int)ZSTD_bm_stable;
1809             return bounds;
1810         case ZSTD_d_forceIgnoreChecksum:
1811             bounds.lowerBound = (int)ZSTD_d_validateChecksum;
1812             bounds.upperBound = (int)ZSTD_d_ignoreChecksum;
1813             return bounds;
1814         case ZSTD_d_refMultipleDDicts:
1815             bounds.lowerBound = (int)ZSTD_rmd_refSingleDDict;
1816             bounds.upperBound = (int)ZSTD_rmd_refMultipleDDicts;
1817             return bounds;
1818         case ZSTD_d_disableHuffmanAssembly:
1819             bounds.lowerBound = 0;
1820             bounds.upperBound = 1;
1821             return bounds;
1822
1823         default:;
1824     }
1825     bounds.error = ERROR(parameter_unsupported);
1826     return bounds;
1827 }
1828
1829 /* ZSTD_dParam_withinBounds:
1830  * @return 1 if value is within dParam bounds,
1831  * 0 otherwise */
1832 static int ZSTD_dParam_withinBounds(ZSTD_dParameter dParam, int value)
1833 {
1834     ZSTD_bounds const bounds = ZSTD_dParam_getBounds(dParam);
1835     if (ZSTD_isError(bounds.error)) return 0;
1836     if (value < bounds.lowerBound) return 0;
1837     if (value > bounds.upperBound) return 0;
1838     return 1;
1839 }
1840
1841 #define CHECK_DBOUNDS(p,v) {                \
1842     RETURN_ERROR_IF(!ZSTD_dParam_withinBounds(p, v), parameter_outOfBound, ""); \
1843 }
1844
1845 size_t ZSTD_DCtx_getParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int* value)
1846 {
1847     switch (param) {
1848         case ZSTD_d_windowLogMax:
1849             *value = (int)ZSTD_highbit32((U32)dctx->maxWindowSize);
1850             return 0;
1851         case ZSTD_d_format:
1852             *value = (int)dctx->format;
1853             return 0;
1854         case ZSTD_d_stableOutBuffer:
1855             *value = (int)dctx->outBufferMode;
1856             return 0;
1857         case ZSTD_d_forceIgnoreChecksum:
1858             *value = (int)dctx->forceIgnoreChecksum;
1859             return 0;
1860         case ZSTD_d_refMultipleDDicts:
1861             *value = (int)dctx->refMultipleDDicts;
1862             return 0;
1863         case ZSTD_d_disableHuffmanAssembly:
1864             *value = (int)dctx->disableHufAsm;
1865             return 0;
1866         default:;
1867     }
1868     RETURN_ERROR(parameter_unsupported, "");
1869 }
1870
1871 size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter dParam, int value)
1872 {
1873     RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1874     switch(dParam) {
1875         case ZSTD_d_windowLogMax:
1876             if (value == 0) value = ZSTD_WINDOWLOG_LIMIT_DEFAULT;
1877             CHECK_DBOUNDS(ZSTD_d_windowLogMax, value);
1878             dctx->maxWindowSize = ((size_t)1) << value;
1879             return 0;
1880         case ZSTD_d_format:
1881             CHECK_DBOUNDS(ZSTD_d_format, value);
1882             dctx->format = (ZSTD_format_e)value;
1883             return 0;
1884         case ZSTD_d_stableOutBuffer:
1885             CHECK_DBOUNDS(ZSTD_d_stableOutBuffer, value);
1886             dctx->outBufferMode = (ZSTD_bufferMode_e)value;
1887             return 0;
1888         case ZSTD_d_forceIgnoreChecksum:
1889             CHECK_DBOUNDS(ZSTD_d_forceIgnoreChecksum, value);
1890             dctx->forceIgnoreChecksum = (ZSTD_forceIgnoreChecksum_e)value;
1891             return 0;
1892         case ZSTD_d_refMultipleDDicts:
1893             CHECK_DBOUNDS(ZSTD_d_refMultipleDDicts, value);
1894             if (dctx->staticSize != 0) {
1895                 RETURN_ERROR(parameter_unsupported, "Static dctx does not support multiple DDicts!");
1896             }
1897             dctx->refMultipleDDicts = (ZSTD_refMultipleDDicts_e)value;
1898             return 0;
1899         case ZSTD_d_disableHuffmanAssembly:
1900             CHECK_DBOUNDS(ZSTD_d_disableHuffmanAssembly, value);
1901             dctx->disableHufAsm = value != 0;
1902             return 0;
1903         default:;
1904     }
1905     RETURN_ERROR(parameter_unsupported, "");
1906 }
1907
1908 size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset)
1909 {
1910     if ( (reset == ZSTD_reset_session_only)
1911       || (reset == ZSTD_reset_session_and_parameters) ) {
1912         dctx->streamStage = zdss_init;
1913         dctx->noForwardProgress = 0;
1914     }
1915     if ( (reset == ZSTD_reset_parameters)
1916       || (reset == ZSTD_reset_session_and_parameters) ) {
1917         RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1918         ZSTD_clearDict(dctx);
1919         ZSTD_DCtx_resetParameters(dctx);
1920     }
1921     return 0;
1922 }
1923
1924
1925 size_t ZSTD_sizeof_DStream(const ZSTD_DStream* dctx)
1926 {
1927     return ZSTD_sizeof_DCtx(dctx);
1928 }
1929
1930 size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize)
1931 {
1932     size_t const blockSize = (size_t) MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
1933     /* space is needed to store the litbuffer after the output of a given block without stomping the extDict of a previous run, as well as to cover both windows against wildcopy*/
1934     unsigned long long const neededRBSize = windowSize + blockSize + ZSTD_BLOCKSIZE_MAX + (WILDCOPY_OVERLENGTH * 2);
1935     unsigned long long const neededSize = MIN(frameContentSize, neededRBSize);
1936     size_t const minRBSize = (size_t) neededSize;
1937     RETURN_ERROR_IF((unsigned long long)minRBSize != neededSize,
1938                     frameParameter_windowTooLarge, "");
1939     return minRBSize;
1940 }
1941
1942 size_t ZSTD_estimateDStreamSize(size_t windowSize)
1943 {
1944     size_t const blockSize = MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
1945     size_t const inBuffSize = blockSize;  /* no block can be larger */
1946     size_t const outBuffSize = ZSTD_decodingBufferSize_min(windowSize, ZSTD_CONTENTSIZE_UNKNOWN);
1947     return ZSTD_estimateDCtxSize() + inBuffSize + outBuffSize;
1948 }
1949
1950 size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize)
1951 {
1952     U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX;   /* note : should be user-selectable, but requires an additional parameter (or a dctx) */
1953     ZSTD_frameHeader zfh;
1954     size_t const err = ZSTD_getFrameHeader(&zfh, src, srcSize);
1955     if (ZSTD_isError(err)) return err;
1956     RETURN_ERROR_IF(err>0, srcSize_wrong, "");
1957     RETURN_ERROR_IF(zfh.windowSize > windowSizeMax,
1958                     frameParameter_windowTooLarge, "");
1959     return ZSTD_estimateDStreamSize((size_t)zfh.windowSize);
1960 }
1961
1962
1963 /* *****   Decompression   ***** */
1964
1965 static int ZSTD_DCtx_isOverflow(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize)
1966 {
1967     return (zds->inBuffSize + zds->outBuffSize) >= (neededInBuffSize + neededOutBuffSize) * ZSTD_WORKSPACETOOLARGE_FACTOR;
1968 }
1969
1970 static void ZSTD_DCtx_updateOversizedDuration(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize)
1971 {
1972     if (ZSTD_DCtx_isOverflow(zds, neededInBuffSize, neededOutBuffSize))
1973         zds->oversizedDuration++;
1974     else
1975         zds->oversizedDuration = 0;
1976 }
1977
1978 static int ZSTD_DCtx_isOversizedTooLong(ZSTD_DStream* zds)
1979 {
1980     return zds->oversizedDuration >= ZSTD_WORKSPACETOOLARGE_MAXDURATION;
1981 }
1982
1983 /* Checks that the output buffer hasn't changed if ZSTD_obm_stable is used. */
1984 static size_t ZSTD_checkOutBuffer(ZSTD_DStream const* zds, ZSTD_outBuffer const* output)
1985 {
1986     ZSTD_outBuffer const expect = zds->expectedOutBuffer;
1987     /* No requirement when ZSTD_obm_stable is not enabled. */
1988     if (zds->outBufferMode != ZSTD_bm_stable)
1989         return 0;
1990     /* Any buffer is allowed in zdss_init, this must be the same for every other call until
1991      * the context is reset.
1992      */
1993     if (zds->streamStage == zdss_init)
1994         return 0;
1995     /* The buffer must match our expectation exactly. */
1996     if (expect.dst == output->dst && expect.pos == output->pos && expect.size == output->size)
1997         return 0;
1998     RETURN_ERROR(dstBuffer_wrong, "ZSTD_d_stableOutBuffer enabled but output differs!");
1999 }
2000
2001 /* Calls ZSTD_decompressContinue() with the right parameters for ZSTD_decompressStream()
2002  * and updates the stage and the output buffer state. This call is extracted so it can be
2003  * used both when reading directly from the ZSTD_inBuffer, and in buffered input mode.
2004  * NOTE: You must break after calling this function since the streamStage is modified.
2005  */
2006 static size_t ZSTD_decompressContinueStream(
2007             ZSTD_DStream* zds, char** op, char* oend,
2008             void const* src, size_t srcSize) {
2009     int const isSkipFrame = ZSTD_isSkipFrame(zds);
2010     if (zds->outBufferMode == ZSTD_bm_buffered) {
2011         size_t const dstSize = isSkipFrame ? 0 : zds->outBuffSize - zds->outStart;
2012         size_t const decodedSize = ZSTD_decompressContinue(zds,
2013                 zds->outBuff + zds->outStart, dstSize, src, srcSize);
2014         FORWARD_IF_ERROR(decodedSize, "");
2015         if (!decodedSize && !isSkipFrame) {
2016             zds->streamStage = zdss_read;
2017         } else {
2018             zds->outEnd = zds->outStart + decodedSize;
2019             zds->streamStage = zdss_flush;
2020         }
2021     } else {
2022         /* Write directly into the output buffer */
2023         size_t const dstSize = isSkipFrame ? 0 : (size_t)(oend - *op);
2024         size_t const decodedSize = ZSTD_decompressContinue(zds, *op, dstSize, src, srcSize);
2025         FORWARD_IF_ERROR(decodedSize, "");
2026         *op += decodedSize;
2027         /* Flushing is not needed. */
2028         zds->streamStage = zdss_read;
2029         assert(*op <= oend);
2030         assert(zds->outBufferMode == ZSTD_bm_stable);
2031     }
2032     return 0;
2033 }
2034
2035 size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
2036 {
2037     const char* const src = (const char*)input->src;
2038     const char* const istart = input->pos != 0 ? src + input->pos : src;
2039     const char* const iend = input->size != 0 ? src + input->size : src;
2040     const char* ip = istart;
2041     char* const dst = (char*)output->dst;
2042     char* const ostart = output->pos != 0 ? dst + output->pos : dst;
2043     char* const oend = output->size != 0 ? dst + output->size : dst;
2044     char* op = ostart;
2045     U32 someMoreWork = 1;
2046
2047     DEBUGLOG(5, "ZSTD_decompressStream");
2048     RETURN_ERROR_IF(
2049         input->pos > input->size,
2050         srcSize_wrong,
2051         "forbidden. in: pos: %u   vs size: %u",
2052         (U32)input->pos, (U32)input->size);
2053     RETURN_ERROR_IF(
2054         output->pos > output->size,
2055         dstSize_tooSmall,
2056         "forbidden. out: pos: %u   vs size: %u",
2057         (U32)output->pos, (U32)output->size);
2058     DEBUGLOG(5, "input size : %u", (U32)(input->size - input->pos));
2059     FORWARD_IF_ERROR(ZSTD_checkOutBuffer(zds, output), "");
2060
2061     while (someMoreWork) {
2062         switch(zds->streamStage)
2063         {
2064         case zdss_init :
2065             DEBUGLOG(5, "stage zdss_init => transparent reset ");
2066             zds->streamStage = zdss_loadHeader;
2067             zds->lhSize = zds->inPos = zds->outStart = zds->outEnd = 0;
2068 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
2069             zds->legacyVersion = 0;
2070 #endif
2071             zds->hostageByte = 0;
2072             zds->expectedOutBuffer = *output;
2073             ZSTD_FALLTHROUGH;
2074
2075         case zdss_loadHeader :
2076             DEBUGLOG(5, "stage zdss_loadHeader (srcSize : %u)", (U32)(iend - ip));
2077 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
2078             if (zds->legacyVersion) {
2079                 RETURN_ERROR_IF(zds->staticSize, memory_allocation,
2080                     "legacy support is incompatible with static dctx");
2081                 {   size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, zds->legacyVersion, output, input);
2082                     if (hint==0) zds->streamStage = zdss_init;
2083                     return hint;
2084             }   }
2085 #endif
2086             {   size_t const hSize = ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format);
2087                 if (zds->refMultipleDDicts && zds->ddictSet) {
2088                     ZSTD_DCtx_selectFrameDDict(zds);
2089                 }
2090                 if (ZSTD_isError(hSize)) {
2091 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
2092                     U32 const legacyVersion = ZSTD_isLegacy(istart, iend-istart);
2093                     if (legacyVersion) {
2094                         ZSTD_DDict const* const ddict = ZSTD_getDDict(zds);
2095                         const void* const dict = ddict ? ZSTD_DDict_dictContent(ddict) : NULL;
2096                         size_t const dictSize = ddict ? ZSTD_DDict_dictSize(ddict) : 0;
2097                         DEBUGLOG(5, "ZSTD_decompressStream: detected legacy version v0.%u", legacyVersion);
2098                         RETURN_ERROR_IF(zds->staticSize, memory_allocation,
2099                             "legacy support is incompatible with static dctx");
2100                         FORWARD_IF_ERROR(ZSTD_initLegacyStream(&zds->legacyContext,
2101                                     zds->previousLegacyVersion, legacyVersion,
2102                                     dict, dictSize), "");
2103                         zds->legacyVersion = zds->previousLegacyVersion = legacyVersion;
2104                         {   size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, legacyVersion, output, input);
2105                             if (hint==0) zds->streamStage = zdss_init;   /* or stay in stage zdss_loadHeader */
2106                             return hint;
2107                     }   }
2108 #endif
2109                     return hSize;   /* error */
2110                 }
2111                 if (hSize != 0) {   /* need more input */
2112                     size_t const toLoad = hSize - zds->lhSize;   /* if hSize!=0, hSize > zds->lhSize */
2113                     size_t const remainingInput = (size_t)(iend-ip);
2114                     assert(iend >= ip);
2115                     if (toLoad > remainingInput) {   /* not enough input to load full header */
2116                         if (remainingInput > 0) {
2117                             ZSTD_memcpy(zds->headerBuffer + zds->lhSize, ip, remainingInput);
2118                             zds->lhSize += remainingInput;
2119                         }
2120                         input->pos = input->size;
2121                         /* check first few bytes */
2122                         FORWARD_IF_ERROR(
2123                             ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format),
2124                             "First few bytes detected incorrect" );
2125                         /* return hint input size */
2126                         return (MAX((size_t)ZSTD_FRAMEHEADERSIZE_MIN(zds->format), hSize) - zds->lhSize) + ZSTD_blockHeaderSize;   /* remaining header bytes + next block header */
2127                     }
2128                     assert(ip != NULL);
2129                     ZSTD_memcpy(zds->headerBuffer + zds->lhSize, ip, toLoad); zds->lhSize = hSize; ip += toLoad;
2130                     break;
2131             }   }
2132
2133             /* check for single-pass mode opportunity */
2134             if (zds->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
2135                 && zds->fParams.frameType != ZSTD_skippableFrame
2136                 && (U64)(size_t)(oend-op) >= zds->fParams.frameContentSize) {
2137                 size_t const cSize = ZSTD_findFrameCompressedSize(istart, (size_t)(iend-istart));
2138                 if (cSize <= (size_t)(iend-istart)) {
2139                     /* shortcut : using single-pass mode */
2140                     size_t const decompressedSize = ZSTD_decompress_usingDDict(zds, op, (size_t)(oend-op), istart, cSize, ZSTD_getDDict(zds));
2141                     if (ZSTD_isError(decompressedSize)) return decompressedSize;
2142                     DEBUGLOG(4, "shortcut to single-pass ZSTD_decompress_usingDDict()")
2143                     assert(istart != NULL);
2144                     ip = istart + cSize;
2145                     op = op ? op + decompressedSize : op; /* can occur if frameContentSize = 0 (empty frame) */
2146                     zds->expected = 0;
2147                     zds->streamStage = zdss_init;
2148                     someMoreWork = 0;
2149                     break;
2150             }   }
2151
2152             /* Check output buffer is large enough for ZSTD_odm_stable. */
2153             if (zds->outBufferMode == ZSTD_bm_stable
2154                 && zds->fParams.frameType != ZSTD_skippableFrame
2155                 && zds->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
2156                 && (U64)(size_t)(oend-op) < zds->fParams.frameContentSize) {
2157                 RETURN_ERROR(dstSize_tooSmall, "ZSTD_obm_stable passed but ZSTD_outBuffer is too small");
2158             }
2159
2160             /* Consume header (see ZSTDds_decodeFrameHeader) */
2161             DEBUGLOG(4, "Consume header");
2162             FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(zds, ZSTD_getDDict(zds)), "");
2163
2164             if ((MEM_readLE32(zds->headerBuffer) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {  /* skippable frame */
2165                 zds->expected = MEM_readLE32(zds->headerBuffer + ZSTD_FRAMEIDSIZE);
2166                 zds->stage = ZSTDds_skipFrame;
2167             } else {
2168                 FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(zds, zds->headerBuffer, zds->lhSize), "");
2169                 zds->expected = ZSTD_blockHeaderSize;
2170                 zds->stage = ZSTDds_decodeBlockHeader;
2171             }
2172
2173             /* control buffer memory usage */
2174             DEBUGLOG(4, "Control max memory usage (%u KB <= max %u KB)",
2175                         (U32)(zds->fParams.windowSize >>10),
2176                         (U32)(zds->maxWindowSize >> 10) );
2177             zds->fParams.windowSize = MAX(zds->fParams.windowSize, 1U << ZSTD_WINDOWLOG_ABSOLUTEMIN);
2178             RETURN_ERROR_IF(zds->fParams.windowSize > zds->maxWindowSize,
2179                             frameParameter_windowTooLarge, "");
2180
2181             /* Adapt buffer sizes to frame header instructions */
2182             {   size_t const neededInBuffSize = MAX(zds->fParams.blockSizeMax, 4 /* frame checksum */);
2183                 size_t const neededOutBuffSize = zds->outBufferMode == ZSTD_bm_buffered
2184                         ? ZSTD_decodingBufferSize_min(zds->fParams.windowSize, zds->fParams.frameContentSize)
2185                         : 0;
2186
2187                 ZSTD_DCtx_updateOversizedDuration(zds, neededInBuffSize, neededOutBuffSize);
2188
2189                 {   int const tooSmall = (zds->inBuffSize < neededInBuffSize) || (zds->outBuffSize < neededOutBuffSize);
2190                     int const tooLarge = ZSTD_DCtx_isOversizedTooLong(zds);
2191
2192                     if (tooSmall || tooLarge) {
2193                         size_t const bufferSize = neededInBuffSize + neededOutBuffSize;
2194                         DEBUGLOG(4, "inBuff  : from %u to %u",
2195                                     (U32)zds->inBuffSize, (U32)neededInBuffSize);
2196                         DEBUGLOG(4, "outBuff : from %u to %u",
2197                                     (U32)zds->outBuffSize, (U32)neededOutBuffSize);
2198                         if (zds->staticSize) {  /* static DCtx */
2199                             DEBUGLOG(4, "staticSize : %u", (U32)zds->staticSize);
2200                             assert(zds->staticSize >= sizeof(ZSTD_DCtx));  /* controlled at init */
2201                             RETURN_ERROR_IF(
2202                                 bufferSize > zds->staticSize - sizeof(ZSTD_DCtx),
2203                                 memory_allocation, "");
2204                         } else {
2205                             ZSTD_customFree(zds->inBuff, zds->customMem);
2206                             zds->inBuffSize = 0;
2207                             zds->outBuffSize = 0;
2208                             zds->inBuff = (char*)ZSTD_customMalloc(bufferSize, zds->customMem);
2209                             RETURN_ERROR_IF(zds->inBuff == NULL, memory_allocation, "");
2210                         }
2211                         zds->inBuffSize = neededInBuffSize;
2212                         zds->outBuff = zds->inBuff + zds->inBuffSize;
2213                         zds->outBuffSize = neededOutBuffSize;
2214             }   }   }
2215             zds->streamStage = zdss_read;
2216             ZSTD_FALLTHROUGH;
2217
2218         case zdss_read:
2219             DEBUGLOG(5, "stage zdss_read");
2220             {   size_t const neededInSize = ZSTD_nextSrcSizeToDecompressWithInputSize(zds, (size_t)(iend - ip));
2221                 DEBUGLOG(5, "neededInSize = %u", (U32)neededInSize);
2222                 if (neededInSize==0) {  /* end of frame */
2223                     zds->streamStage = zdss_init;
2224                     someMoreWork = 0;
2225                     break;
2226                 }
2227                 if ((size_t)(iend-ip) >= neededInSize) {  /* decode directly from src */
2228                     FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, ip, neededInSize), "");
2229                     assert(ip != NULL);
2230                     ip += neededInSize;
2231                     /* Function modifies the stage so we must break */
2232                     break;
2233             }   }
2234             if (ip==iend) { someMoreWork = 0; break; }   /* no more input */
2235             zds->streamStage = zdss_load;
2236             ZSTD_FALLTHROUGH;
2237
2238         case zdss_load:
2239             {   size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zds);
2240                 size_t const toLoad = neededInSize - zds->inPos;
2241                 int const isSkipFrame = ZSTD_isSkipFrame(zds);
2242                 size_t loadedSize;
2243                 /* At this point we shouldn't be decompressing a block that we can stream. */
2244                 assert(neededInSize == ZSTD_nextSrcSizeToDecompressWithInputSize(zds, (size_t)(iend - ip)));
2245                 if (isSkipFrame) {
2246                     loadedSize = MIN(toLoad, (size_t)(iend-ip));
2247                 } else {
2248                     RETURN_ERROR_IF(toLoad > zds->inBuffSize - zds->inPos,
2249                                     corruption_detected,
2250                                     "should never happen");
2251                     loadedSize = ZSTD_limitCopy(zds->inBuff + zds->inPos, toLoad, ip, (size_t)(iend-ip));
2252                 }
2253                 if (loadedSize != 0) {
2254                     /* ip may be NULL */
2255                     ip += loadedSize;
2256                     zds->inPos += loadedSize;
2257                 }
2258                 if (loadedSize < toLoad) { someMoreWork = 0; break; }   /* not enough input, wait for more */
2259
2260                 /* decode loaded input */
2261                 zds->inPos = 0;   /* input is consumed */
2262                 FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, zds->inBuff, neededInSize), "");
2263                 /* Function modifies the stage so we must break */
2264                 break;
2265             }
2266         case zdss_flush:
2267             {
2268                 size_t const toFlushSize = zds->outEnd - zds->outStart;
2269                 size_t const flushedSize = ZSTD_limitCopy(op, (size_t)(oend-op), zds->outBuff + zds->outStart, toFlushSize);
2270
2271                 op = op ? op + flushedSize : op;
2272
2273                 zds->outStart += flushedSize;
2274                 if (flushedSize == toFlushSize) {  /* flush completed */
2275                     zds->streamStage = zdss_read;
2276                     if ( (zds->outBuffSize < zds->fParams.frameContentSize)
2277                         && (zds->outStart + zds->fParams.blockSizeMax > zds->outBuffSize) ) {
2278                         DEBUGLOG(5, "restart filling outBuff from beginning (left:%i, needed:%u)",
2279                                 (int)(zds->outBuffSize - zds->outStart),
2280                                 (U32)zds->fParams.blockSizeMax);
2281                         zds->outStart = zds->outEnd = 0;
2282                     }
2283                     break;
2284             }   }
2285             /* cannot complete flush */
2286             someMoreWork = 0;
2287             break;
2288
2289         default:
2290             assert(0);    /* impossible */
2291             RETURN_ERROR(GENERIC, "impossible to reach");   /* some compilers require default to do something */
2292     }   }
2293
2294     /* result */
2295     input->pos = (size_t)(ip - (const char*)(input->src));
2296     output->pos = (size_t)(op - (char*)(output->dst));
2297
2298     /* Update the expected output buffer for ZSTD_obm_stable. */
2299     zds->expectedOutBuffer = *output;
2300
2301     if ((ip==istart) && (op==ostart)) {  /* no forward progress */
2302         zds->noForwardProgress ++;
2303         if (zds->noForwardProgress >= ZSTD_NO_FORWARD_PROGRESS_MAX) {
2304             RETURN_ERROR_IF(op==oend, noForwardProgress_destFull, "");
2305             RETURN_ERROR_IF(ip==iend, noForwardProgress_inputEmpty, "");
2306             assert(0);
2307         }
2308     } else {
2309         zds->noForwardProgress = 0;
2310     }
2311     {   size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zds);
2312         if (!nextSrcSizeHint) {   /* frame fully decoded */
2313             if (zds->outEnd == zds->outStart) {  /* output fully flushed */
2314                 if (zds->hostageByte) {
2315                     if (input->pos >= input->size) {
2316                         /* can't release hostage (not present) */
2317                         zds->streamStage = zdss_read;
2318                         return 1;
2319                     }
2320                     input->pos++;  /* release hostage */
2321                 }   /* zds->hostageByte */
2322                 return 0;
2323             }  /* zds->outEnd == zds->outStart */
2324             if (!zds->hostageByte) { /* output not fully flushed; keep last byte as hostage; will be released when all output is flushed */
2325                 input->pos--;   /* note : pos > 0, otherwise, impossible to finish reading last block */
2326                 zds->hostageByte=1;
2327             }
2328             return 1;
2329         }  /* nextSrcSizeHint==0 */
2330         nextSrcSizeHint += ZSTD_blockHeaderSize * (ZSTD_nextInputType(zds) == ZSTDnit_block);   /* preload header of next block */
2331         assert(zds->inPos <= nextSrcSizeHint);
2332         nextSrcSizeHint -= zds->inPos;   /* part already loaded*/
2333         return nextSrcSizeHint;
2334     }
2335 }
2336
2337 size_t ZSTD_decompressStream_simpleArgs (
2338                             ZSTD_DCtx* dctx,
2339                             void* dst, size_t dstCapacity, size_t* dstPos,
2340                       const void* src, size_t srcSize, size_t* srcPos)
2341 {
2342     ZSTD_outBuffer output;
2343     ZSTD_inBuffer  input;
2344     output.dst = dst;
2345     output.size = dstCapacity;
2346     output.pos = *dstPos;
2347     input.src = src;
2348     input.size = srcSize;
2349     input.pos = *srcPos;
2350     {   size_t const cErr = ZSTD_decompressStream(dctx, &output, &input);
2351         *dstPos = output.pos;
2352         *srcPos = input.pos;
2353         return cErr;
2354     }
2355 }