include/linux/zstd_lib.h

165  *        or an error code if input is invalid */
372                               * ZSTD_compressStream*() consumes input and flush output if possible, but immediately gives back control to caller,
464  *  Total input data size to be compressed as a single frame.
473  *  Note 3 : Whenever all input data is provided and consumed in a single round,
587   const void* src;    /*< start of input buffer */
588   size_t size;        /*< size of input buffer */
620 *  consume input stream. The function will automatically update both `pos`
621 *  fields within `input` and `output`.
622 *  Note that the function may not consume the entire input, for example, because
623 *  the output buffer is already full, in which case `input.pos < input.size`.
624 *  The caller must check if input has been entirely consumed.
626 *  and then present again remaining input data.
630 *        consume some input, but if it can't it will wait for some, but not all,
685  *  - output->pos must be <= dstCapacity, input->pos must be <= srcSize
686  *  - output->pos and input->pos will be updated. They are guaranteed to remain below their respective limit.
689  *  - When nbWorkers>=1, function is non-blocking : it copies a portion of input, distributes jobs to internal worker threads, flush to output whatever is available,
705                                          ZSTD_inBuffer* input,
710  * They are not required : ZSTD_compressStream*() happily accepts any buffer size, for both input and output.
720  * for both input and output, to reduce the nb of roundtrips.
722 ZSTDLIB_API size_t ZSTD_CStreamInSize(void);    /*< recommended size for input buffer */
743  * Alternative for ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue).
748 ZSTDLIB_API size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
763 * @return : recommended first input size
766 *  Use ZSTD_decompressStream() repetitively to consume your input.
768 *  If `input.pos < input.size`, some input has not been consumed.
774 *  Note : with no additional input provided, amount of data flushed is necessarily <= ZSTD_BLOCKSIZE_MAX.
778 *                                the return value is a suggested next input size (just a hint for better latency)
797 ZSTDLIB_API size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
799 ZSTDLIB_API size_t ZSTD_DStreamInSize(void);    /*!< recommended size for input buffer */
1101 #define ZSTD_FRAMEHEADERSIZE_PREFIX(format) ((format) == ZSTD_f_zstd1 ? 5 : 1)   /* minimum input size required to query frame header size */
1254      *   means that the compression can search both the dictionary and input
1256      *   the compression faster per-byte of input. However, the initial copy of
1262      *   slower per input byte, because the compressor has to search two sets of
1271      *   to the input size, and the input size is fairly large to begin with.
1325  *   note 5 : ZSTD_findDecompressedSize handles multiple frames, and so it must traverse the input to
1471  *  The estimate will assume the input may be arbitrarily large,
1817  * When this flag is enabled zstd won't allocate an input window buffer,
1821  * avoid the memcpy() from the input buffer to the input window buffer.
1851  * input window buffer (see ZSTD_c_stableInBuffer).
2069  * allowing selection between ZSTD_format_e input compression formats
2087  * an input buffer large enough to fit any compressed block. This will also
2089  * If you need to avoid the input buffer allocation use the buffer-less
2279     unsigned long long ingested;   /* nb input bytes read and buffered */
2280     unsigned long long consumed;   /* nb input bytes actually compressed */
2288  * tells how much data has been ingested (read from input)
2289  * consumed (input actually compressed) and produced (output) for current frame.
2290  * Note : (ingested - consumed) is amount of input data buffered internally, not yet compressed.
2365   Then, consume your input using ZSTD_compressContinue().
2368   - Interface is synchronous : input is consumed entirely and produces 1+ compressed blocks.
2372   - ZSTD_compressContinue() presumes prior input ***is still accessible and unmodified*** (up to maximum distance size, see WindowLog).
2374   - ZSTD_compressContinue() detects that prior input has been overwritten when `src` buffer overlaps.
2456   Note : it's possible to know if next input to present is a header or a block, using ZSTD_nextInputType().
2488 ZSTDLIB_STATIC_API size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize);   /*< doesn't consume input */
2527       + If input is larger than a block size, it's necessary to split input data into multiple blocks