pub const _LIBC_LIMITS_H_: u32 = 1;
pub const _FEATURES_H: u32 = 1;
pub const _DEFAULT_SOURCE: u32 = 1;
pub const __GLIBC_USE_ISOC2X: u32 = 0;
pub const __USE_ISOC11: u32 = 1;
pub const __USE_ISOC99: u32 = 1;
pub const __USE_ISOC95: u32 = 1;
pub const __USE_POSIX_IMPLICITLY: u32 = 1;
pub const _POSIX_SOURCE: u32 = 1;
pub const _POSIX_C_SOURCE: u32 = 200809;
pub const __USE_POSIX: u32 = 1;
pub const __USE_POSIX2: u32 = 1;
pub const __USE_POSIX199309: u32 = 1;
pub const __USE_POSIX199506: u32 = 1;
pub const __USE_XOPEN2K: u32 = 1;
pub const __USE_XOPEN2K8: u32 = 1;
pub const _ATFILE_SOURCE: u32 = 1;
pub const __USE_MISC: u32 = 1;
pub const __USE_ATFILE: u32 = 1;
pub const __USE_FORTIFY_LEVEL: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
pub const _STDC_PREDEF_H: u32 = 1;
pub const __STDC_IEC_559__: u32 = 1;
pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
pub const __STDC_ISO_10646__: u32 = 201706;
pub const __GNU_LIBRARY__: u32 = 6;
pub const __GLIBC__: u32 = 2;
pub const __GLIBC_MINOR__: u32 = 32;
pub const _SYS_CDEFS_H: u32 = 1;
pub const __glibc_c99_flexarr_available: u32 = 1;
pub const __WORDSIZE: u32 = 64;
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
pub const __SYSCALL_WORDSIZE: u32 = 64;
pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
pub const __HAVE_GENERIC_SELECTION: u32 = 1;
pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
pub const MB_LEN_MAX: u32 = 16;
pub const _BITS_POSIX1_LIM_H: u32 = 1;
pub const _POSIX_AIO_LISTIO_MAX: u32 = 2;
pub const _POSIX_AIO_MAX: u32 = 1;
pub const _POSIX_ARG_MAX: u32 = 4096;
pub const _POSIX_CHILD_MAX: u32 = 25;
pub const _POSIX_DELAYTIMER_MAX: u32 = 32;
pub const _POSIX_HOST_NAME_MAX: u32 = 255;
pub const _POSIX_LINK_MAX: u32 = 8;
pub const _POSIX_LOGIN_NAME_MAX: u32 = 9;
pub const _POSIX_MAX_CANON: u32 = 255;
pub const _POSIX_MAX_INPUT: u32 = 255;
pub const _POSIX_MQ_OPEN_MAX: u32 = 8;
pub const _POSIX_MQ_PRIO_MAX: u32 = 32;
pub const _POSIX_NAME_MAX: u32 = 14;
pub const _POSIX_NGROUPS_MAX: u32 = 8;
pub const _POSIX_OPEN_MAX: u32 = 20;
pub const _POSIX_PATH_MAX: u32 = 256;
pub const _POSIX_PIPE_BUF: u32 = 512;
pub const _POSIX_RE_DUP_MAX: u32 = 255;
pub const _POSIX_RTSIG_MAX: u32 = 8;
pub const _POSIX_SEM_NSEMS_MAX: u32 = 256;
pub const _POSIX_SEM_VALUE_MAX: u32 = 32767;
pub const _POSIX_SIGQUEUE_MAX: u32 = 32;
pub const _POSIX_SSIZE_MAX: u32 = 32767;
pub const _POSIX_STREAM_MAX: u32 = 8;
pub const _POSIX_SYMLINK_MAX: u32 = 255;
pub const _POSIX_SYMLOOP_MAX: u32 = 8;
pub const _POSIX_TIMER_MAX: u32 = 32;
pub const _POSIX_TTY_NAME_MAX: u32 = 9;
pub const _POSIX_TZNAME_MAX: u32 = 6;
pub const _POSIX_CLOCKRES_MIN: u32 = 20000000;
pub const NR_OPEN: u32 = 1024;
pub const NGROUPS_MAX: u32 = 65536;
pub const ARG_MAX: u32 = 131072;
pub const LINK_MAX: u32 = 127;
pub const MAX_CANON: u32 = 255;
pub const MAX_INPUT: u32 = 255;
pub const NAME_MAX: u32 = 255;
pub const PATH_MAX: u32 = 4096;
pub const PIPE_BUF: u32 = 4096;
pub const XATTR_NAME_MAX: u32 = 255;
pub const XATTR_SIZE_MAX: u32 = 65536;
pub const XATTR_LIST_MAX: u32 = 65536;
pub const RTSIG_MAX: u32 = 32;
pub const _POSIX_THREAD_KEYS_MAX: u32 = 128;
pub const PTHREAD_KEYS_MAX: u32 = 1024;
pub const _POSIX_THREAD_DESTRUCTOR_ITERATIONS: u32 = 4;
pub const PTHREAD_DESTRUCTOR_ITERATIONS: u32 = 4;
pub const _POSIX_THREAD_THREADS_MAX: u32 = 64;
pub const AIO_PRIO_DELTA_MAX: u32 = 20;
pub const PTHREAD_STACK_MIN: u32 = 16384;
pub const DELAYTIMER_MAX: u32 = 2147483647;
pub const TTY_NAME_MAX: u32 = 32;
pub const LOGIN_NAME_MAX: u32 = 256;
pub const HOST_NAME_MAX: u32 = 64;
pub const MQ_PRIO_MAX: u32 = 32768;
pub const SEM_VALUE_MAX: u32 = 2147483647;
pub const _BITS_POSIX2_LIM_H: u32 = 1;
pub const _POSIX2_BC_BASE_MAX: u32 = 99;
pub const _POSIX2_BC_DIM_MAX: u32 = 2048;
pub const _POSIX2_BC_SCALE_MAX: u32 = 99;
pub const _POSIX2_BC_STRING_MAX: u32 = 1000;
pub const _POSIX2_COLL_WEIGHTS_MAX: u32 = 2;
pub const _POSIX2_EXPR_NEST_MAX: u32 = 32;
pub const _POSIX2_LINE_MAX: u32 = 2048;
pub const _POSIX2_RE_DUP_MAX: u32 = 255;
pub const _POSIX2_CHARCLASS_NAME_MAX: u32 = 14;
pub const BC_BASE_MAX: u32 = 99;
pub const BC_DIM_MAX: u32 = 2048;
pub const BC_SCALE_MAX: u32 = 99;
pub const BC_STRING_MAX: u32 = 1000;
pub const COLL_WEIGHTS_MAX: u32 = 255;
pub const EXPR_NEST_MAX: u32 = 32;
pub const LINE_MAX: u32 = 2048;
pub const CHARCLASS_NAME_MAX: u32 = 2048;
pub const RE_DUP_MAX: u32 = 32767;
pub const ZSTD_VERSION_MAJOR: u32 = 1;
pub const ZSTD_VERSION_MINOR: u32 = 4;
pub const ZSTD_VERSION_RELEASE: u32 = 7;
pub const ZSTD_VERSION_NUMBER: u32 = 10407;
pub const ZSTD_CLEVEL_DEFAULT: u32 = 3;
pub const ZSTD_MAGICNUMBER: u32 = 4247762216;
pub const ZSTD_MAGIC_DICTIONARY: u32 = 3962610743;
pub const ZSTD_MAGIC_SKIPPABLE_START: u32 = 407710288;
pub const ZSTD_MAGIC_SKIPPABLE_MASK: u32 = 4294967280;
pub const ZSTD_BLOCKSIZELOG_MAX: u32 = 17;
pub const ZSTD_BLOCKSIZE_MAX: u32 = 131072;
pub const ZSTD_CONTENTSIZE_UNKNOWN: i32 = -1;
pub const ZSTD_CONTENTSIZE_ERROR: i32 = -2;
pub const ZSTD_FRAMEHEADERSIZE_MAX: u32 = 18;
pub const ZSTD_SKIPPABLEHEADERSIZE: u32 = 8;
pub const ZSTD_WINDOWLOG_MAX_32: u32 = 30;
pub const ZSTD_WINDOWLOG_MAX_64: u32 = 31;
pub const ZSTD_WINDOWLOG_MIN: u32 = 10;
pub const ZSTD_HASHLOG_MIN: u32 = 6;
pub const ZSTD_CHAINLOG_MAX_32: u32 = 29;
pub const ZSTD_CHAINLOG_MAX_64: u32 = 30;
pub const ZSTD_CHAINLOG_MIN: u32 = 6;
pub const ZSTD_SEARCHLOG_MIN: u32 = 1;
pub const ZSTD_MINMATCH_MAX: u32 = 7;
pub const ZSTD_MINMATCH_MIN: u32 = 3;
pub const ZSTD_TARGETLENGTH_MAX: u32 = 131072;
pub const ZSTD_TARGETLENGTH_MIN: u32 = 0;
pub const ZSTD_OVERLAPLOG_MIN: u32 = 0;
pub const ZSTD_OVERLAPLOG_MAX: u32 = 9;
pub const ZSTD_WINDOWLOG_LIMIT_DEFAULT: u32 = 27;
pub const ZSTD_LDM_HASHLOG_MIN: u32 = 6;
pub const ZSTD_LDM_MINMATCH_MIN: u32 = 4;
pub const ZSTD_LDM_MINMATCH_MAX: u32 = 4096;
pub const ZSTD_LDM_BUCKETSIZELOG_MIN: u32 = 1;
pub const ZSTD_LDM_BUCKETSIZELOG_MAX: u32 = 8;
pub const ZSTD_LDM_HASHRATELOG_MIN: u32 = 0;
pub const ZSTD_TARGETCBLOCKSIZE_MIN: u32 = 64;
pub const ZSTD_TARGETCBLOCKSIZE_MAX: u32 = 131072;
pub const ZSTD_SRCSIZEHINT_MIN: u32 = 0;
pub const ZSTD_HASHLOG3_MAX: u32 = 17;
pub const ZDICT_CONTENTSIZE_MIN: u32 = 128;
pub const ZDICT_DICTSIZE_MIN: u32 = 256;
pub const _STRING_H: u32 = 1;
pub const _BITS_TYPES_LOCALE_T_H: u32 = 1;
pub const _BITS_TYPES___LOCALE_T_H: u32 = 1;
pub const _STRINGS_H: u32 = 1;
pub const ZSTDMT_NBWORKERS_MAX: u32 = 200;
pub type wchar_t = libc::c_int;
extern "C" {
#[doc = " ZSTD_versionNumber() :"]
#[doc = " Return runtime library version, the value is (MAJOR*100*100 + MINOR*100 + RELEASE)."]
pub fn ZSTD_versionNumber() -> libc::c_uint;
}
extern "C" {
#[doc = " ZSTD_versionString() :"]
#[doc = " Return runtime library version, like \"1.4.5\". Requires v1.3.0+."]
pub fn ZSTD_versionString() -> *const libc::c_char;
}
extern "C" {
#[doc = " Simple API"]
#[doc = " Compresses `src` content as a single zstd compressed frame into already allocated `dst`."]
#[doc = " Hint : compression runs faster if `dstCapacity` >= `ZSTD_compressBound(srcSize)`."]
#[doc = " @return : compressed size written into `dst` (<= `dstCapacity),"]
#[doc = " or an error code if it fails (which can be tested using ZSTD_isError())."]
pub fn ZSTD_compress(
dst: *mut libc::c_void,
dstCapacity: usize,
src: *const libc::c_void,
srcSize: usize,
compressionLevel: libc::c_int,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_decompress() :"]
#[doc = " `compressedSize` : must be the _exact_ size of some number of compressed and/or skippable frames."]
#[doc = " `dstCapacity` is an upper bound of originalSize to regenerate."]
#[doc = " If user cannot imply a maximum upper bound, it's better to use streaming mode to decompress data."]
#[doc = " @return : the number of bytes decompressed into `dst` (<= `dstCapacity`),"]
#[doc = " or an errorCode if it fails (which can be tested using ZSTD_isError())."]
pub fn ZSTD_decompress(
dst: *mut libc::c_void,
dstCapacity: usize,
src: *const libc::c_void,
compressedSize: usize,
) -> usize;
}
extern "C" {
pub fn ZSTD_getFrameContentSize(
src: *const libc::c_void,
srcSize: usize,
) -> libc::c_ulonglong;
}
extern "C" {
#[doc = " ZSTD_getDecompressedSize() :"]
#[doc = " NOTE: This function is now obsolete, in favor of ZSTD_getFrameContentSize()."]
#[doc = " Both functions work the same way, but ZSTD_getDecompressedSize() blends"]
#[doc = " \"empty\", \"unknown\" and \"error\" results to the same return value (0),"]
#[doc = " while ZSTD_getFrameContentSize() gives them separate return values."]
#[doc = " @return : decompressed size of `src` frame content _if known and not empty_, 0 otherwise."]
pub fn ZSTD_getDecompressedSize(
src: *const libc::c_void,
srcSize: usize,
) -> libc::c_ulonglong;
}
extern "C" {
#[doc = " ZSTD_findFrameCompressedSize() :"]
#[doc = " `src` should point to the start of a ZSTD frame or skippable frame."]
#[doc = " `srcSize` must be >= first frame size"]
#[doc = " @return : the compressed size of the first frame starting at `src`,"]
#[doc = " suitable to pass as `srcSize` to `ZSTD_decompress` or similar,"]
#[doc = " or an error code if input is invalid"]
pub fn ZSTD_findFrameCompressedSize(
src: *const libc::c_void,
srcSize: usize,
) -> usize;
}
extern "C" {
pub fn ZSTD_compressBound(srcSize: usize) -> usize;
}
extern "C" {
pub fn ZSTD_isError(code: usize) -> libc::c_uint;
}
extern "C" {
pub fn ZSTD_getErrorName(code: usize) -> *const libc::c_char;
}
extern "C" {
pub fn ZSTD_minCLevel() -> libc::c_int;
}
extern "C" {
pub fn ZSTD_maxCLevel() -> libc::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_CCtx_s {
_unused: [u8; 0],
}
#[doc = " Explicit context"]
pub type ZSTD_CCtx = ZSTD_CCtx_s;
extern "C" {
pub fn ZSTD_createCCtx() -> *mut ZSTD_CCtx;
}
extern "C" {
pub fn ZSTD_freeCCtx(cctx: *mut ZSTD_CCtx) -> usize;
}
extern "C" {
#[doc = " ZSTD_compressCCtx() :"]
#[doc = " Same as ZSTD_compress(), using an explicit ZSTD_CCtx."]
#[doc = " Important : in order to behave similarly to `ZSTD_compress()`,"]
#[doc = " this function compresses at requested compression level,"]
#[doc = " __ignoring any other parameter__ ."]
#[doc = " If any advanced parameter was set using the advanced API,"]
#[doc = " they will all be reset. Only `compressionLevel` remains."]
pub fn ZSTD_compressCCtx(
cctx: *mut ZSTD_CCtx,
dst: *mut libc::c_void,
dstCapacity: usize,
src: *const libc::c_void,
srcSize: usize,
compressionLevel: libc::c_int,
) -> usize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_DCtx_s {
_unused: [u8; 0],
}
pub type ZSTD_DCtx = ZSTD_DCtx_s;
extern "C" {
pub fn ZSTD_createDCtx() -> *mut ZSTD_DCtx;
}
extern "C" {
pub fn ZSTD_freeDCtx(dctx: *mut ZSTD_DCtx) -> usize;
}
extern "C" {
#[doc = " ZSTD_decompressDCtx() :"]
#[doc = " Same as ZSTD_decompress(),"]
#[doc = " requires an allocated ZSTD_DCtx."]
#[doc = " Compatible with sticky parameters."]
pub fn ZSTD_decompressDCtx(
dctx: *mut ZSTD_DCtx,
dst: *mut libc::c_void,
dstCapacity: usize,
src: *const libc::c_void,
srcSize: usize,
) -> usize;
}
#[repr(u32)]
#[doc = " Advanced compression API"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ZSTD_strategy {
ZSTD_fast = 1,
ZSTD_dfast = 2,
ZSTD_greedy = 3,
ZSTD_lazy = 4,
ZSTD_lazy2 = 5,
ZSTD_btlazy2 = 6,
ZSTD_btopt = 7,
ZSTD_btultra = 8,
ZSTD_btultra2 = 9,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ZSTD_cParameter {
ZSTD_c_compressionLevel = 100,
ZSTD_c_windowLog = 101,
ZSTD_c_hashLog = 102,
ZSTD_c_chainLog = 103,
ZSTD_c_searchLog = 104,
ZSTD_c_minMatch = 105,
ZSTD_c_targetLength = 106,
ZSTD_c_strategy = 107,
ZSTD_c_enableLongDistanceMatching = 160,
ZSTD_c_ldmHashLog = 161,
ZSTD_c_ldmMinMatch = 162,
ZSTD_c_ldmBucketSizeLog = 163,
ZSTD_c_ldmHashRateLog = 164,
ZSTD_c_contentSizeFlag = 200,
ZSTD_c_checksumFlag = 201,
ZSTD_c_dictIDFlag = 202,
ZSTD_c_nbWorkers = 400,
ZSTD_c_jobSize = 401,
ZSTD_c_overlapLog = 402,
ZSTD_c_experimentalParam1 = 500,
ZSTD_c_experimentalParam2 = 10,
ZSTD_c_experimentalParam3 = 1000,
ZSTD_c_experimentalParam4 = 1001,
ZSTD_c_experimentalParam5 = 1002,
ZSTD_c_experimentalParam6 = 1003,
ZSTD_c_experimentalParam7 = 1004,
ZSTD_c_experimentalParam8 = 1005,
ZSTD_c_experimentalParam9 = 1006,
ZSTD_c_experimentalParam10 = 1007,
ZSTD_c_experimentalParam11 = 1008,
ZSTD_c_experimentalParam12 = 1009,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_bounds {
pub error: usize,
pub lowerBound: libc::c_int,
pub upperBound: libc::c_int,
}
#[test]
fn bindgen_test_layout_ZSTD_bounds() {
assert_eq!(
::core::mem::size_of::<ZSTD_bounds>(),
16usize,
concat!("Size of: ", stringify!(ZSTD_bounds))
);
assert_eq!(
::core::mem::align_of::<ZSTD_bounds>(),
8usize,
concat!("Alignment of ", stringify!(ZSTD_bounds))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_bounds>())).error as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_bounds),
"::",
stringify!(error)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_bounds>())).lowerBound as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_bounds),
"::",
stringify!(lowerBound)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_bounds>())).upperBound as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_bounds),
"::",
stringify!(upperBound)
)
);
}
extern "C" {
#[doc = " ZSTD_cParam_getBounds() :"]
#[doc = " All parameters must belong to an interval with lower and upper bounds,"]
#[doc = " otherwise they will either trigger an error or be automatically clamped."]
#[doc = " @return : a structure, ZSTD_bounds, which contains"]
#[doc = " - an error status field, which must be tested using ZSTD_isError()"]
#[doc = " - lower and upper bounds, both inclusive"]
pub fn ZSTD_cParam_getBounds(cParam: ZSTD_cParameter) -> ZSTD_bounds;
}
extern "C" {
#[doc = " ZSTD_CCtx_setParameter() :"]
#[doc = " Set one compression parameter, selected by enum ZSTD_cParameter."]
#[doc = " All parameters have valid bounds. Bounds can be queried using ZSTD_cParam_getBounds()."]
#[doc = " Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter)."]
#[doc = " Setting a parameter is generally only possible during frame initialization (before starting compression)."]
#[doc = " Exception : when using multi-threading mode (nbWorkers >= 1),"]
#[doc = " the following parameters can be updated _during_ compression (within same frame):"]
#[doc = " => compressionLevel, hashLog, chainLog, searchLog, minMatch, targetLength and strategy."]
#[doc = " new parameters will be active for next job only (after a flush())."]
#[doc = " @return : an error code (which can be tested using ZSTD_isError())."]
pub fn ZSTD_CCtx_setParameter(
cctx: *mut ZSTD_CCtx,
param: ZSTD_cParameter,
value: libc::c_int,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_CCtx_setPledgedSrcSize() :"]
#[doc = " Total input data size to be compressed as a single frame."]
#[doc = " Value will be written in frame header, unless if explicitly forbidden using ZSTD_c_contentSizeFlag."]
#[doc = " This value will also be controlled at end of frame, and trigger an error if not respected."]
#[doc = " @result : 0, or an error code (which can be tested with ZSTD_isError())."]
#[doc = " Note 1 : pledgedSrcSize==0 actually means zero, aka an empty frame."]
#[doc = " In order to mean \"unknown content size\", pass constant ZSTD_CONTENTSIZE_UNKNOWN."]
#[doc = " ZSTD_CONTENTSIZE_UNKNOWN is default value for any new frame."]
#[doc = " Note 2 : pledgedSrcSize is only valid once, for the next frame."]
#[doc = " It's discarded at the end of the frame, and replaced by ZSTD_CONTENTSIZE_UNKNOWN."]
#[doc = " Note 3 : Whenever all input data is provided and consumed in a single round,"]
#[doc = " for example with ZSTD_compress2(),"]
#[doc = " or invoking immediately ZSTD_compressStream2(,,,ZSTD_e_end),"]
#[doc = " this value is automatically overridden by srcSize instead."]
pub fn ZSTD_CCtx_setPledgedSrcSize(
cctx: *mut ZSTD_CCtx,
pledgedSrcSize: libc::c_ulonglong,
) -> usize;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ZSTD_ResetDirective {
ZSTD_reset_session_only = 1,
ZSTD_reset_parameters = 2,
ZSTD_reset_session_and_parameters = 3,
}
extern "C" {
#[doc = " ZSTD_CCtx_reset() :"]
#[doc = " There are 2 different things that can be reset, independently or jointly :"]
#[doc = " - The session : will stop compressing current frame, and make CCtx ready to start a new one."]
#[doc = " Useful after an error, or to interrupt any ongoing compression."]
#[doc = " Any internal data not yet flushed is cancelled."]
#[doc = " Compression parameters and dictionary remain unchanged."]
#[doc = " They will be used to compress next frame."]
#[doc = " Resetting session never fails."]
#[doc = " - The parameters : changes all parameters back to \"default\"."]
#[doc = " This removes any reference to any dictionary too."]
#[doc = " Parameters can only be changed between 2 sessions (i.e. no compression is currently ongoing)"]
#[doc = " otherwise the reset fails, and function returns an error value (which can be tested using ZSTD_isError())"]
#[doc = " - Both : similar to resetting the session, followed by resetting parameters."]
pub fn ZSTD_CCtx_reset(
cctx: *mut ZSTD_CCtx,
reset: ZSTD_ResetDirective,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_compress2() :"]
#[doc = " Behave the same as ZSTD_compressCCtx(), but compression parameters are set using the advanced API."]
#[doc = " ZSTD_compress2() always starts a new frame."]
#[doc = " Should cctx hold data from a previously unfinished frame, everything about it is forgotten."]
#[doc = " - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()"]
#[doc = " - The function is always blocking, returns when compression is completed."]
#[doc = " Hint : compression runs faster if `dstCapacity` >= `ZSTD_compressBound(srcSize)`."]
#[doc = " @return : compressed size written into `dst` (<= `dstCapacity),"]
#[doc = " or an error code if it fails (which can be tested using ZSTD_isError())."]
pub fn ZSTD_compress2(
cctx: *mut ZSTD_CCtx,
dst: *mut libc::c_void,
dstCapacity: usize,
src: *const libc::c_void,
srcSize: usize,
) -> usize;
}
#[repr(u32)]
#[doc = " Advanced decompression API"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ZSTD_dParameter {
ZSTD_d_windowLogMax = 100,
ZSTD_d_experimentalParam1 = 1000,
ZSTD_d_experimentalParam2 = 1001,
ZSTD_d_experimentalParam3 = 1002,
}
extern "C" {
#[doc = " ZSTD_dParam_getBounds() :"]
#[doc = " All parameters must belong to an interval with lower and upper bounds,"]
#[doc = " otherwise they will either trigger an error or be automatically clamped."]
#[doc = " @return : a structure, ZSTD_bounds, which contains"]
#[doc = " - an error status field, which must be tested using ZSTD_isError()"]
#[doc = " - both lower and upper bounds, inclusive"]
pub fn ZSTD_dParam_getBounds(dParam: ZSTD_dParameter) -> ZSTD_bounds;
}
extern "C" {
#[doc = " ZSTD_DCtx_setParameter() :"]
#[doc = " Set one compression parameter, selected by enum ZSTD_dParameter."]
#[doc = " All parameters have valid bounds. Bounds can be queried using ZSTD_dParam_getBounds()."]
#[doc = " Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter)."]
#[doc = " Setting a parameter is only possible during frame initialization (before starting decompression)."]
#[doc = " @return : 0, or an error code (which can be tested using ZSTD_isError())."]
pub fn ZSTD_DCtx_setParameter(
dctx: *mut ZSTD_DCtx,
param: ZSTD_dParameter,
value: libc::c_int,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_DCtx_reset() :"]
#[doc = " Return a DCtx to clean state."]
#[doc = " Session and parameters can be reset jointly or separately."]
#[doc = " Parameters can only be reset when no active frame is being decompressed."]
#[doc = " @return : 0, or an error code, which can be tested with ZSTD_isError()"]
pub fn ZSTD_DCtx_reset(
dctx: *mut ZSTD_DCtx,
reset: ZSTD_ResetDirective,
) -> usize;
}
#[doc = " Streaming"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_inBuffer_s {
#[doc = "< start of input buffer"]
pub src: *const libc::c_void,
#[doc = "< size of input buffer"]
pub size: usize,
#[doc = "< position where reading stopped. Will be updated. Necessarily 0 <= pos <= size"]
pub pos: usize,
}
#[test]
fn bindgen_test_layout_ZSTD_inBuffer_s() {
assert_eq!(
::core::mem::size_of::<ZSTD_inBuffer_s>(),
24usize,
concat!("Size of: ", stringify!(ZSTD_inBuffer_s))
);
assert_eq!(
::core::mem::align_of::<ZSTD_inBuffer_s>(),
8usize,
concat!("Alignment of ", stringify!(ZSTD_inBuffer_s))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_inBuffer_s>())).src as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_inBuffer_s),
"::",
stringify!(src)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_inBuffer_s>())).size as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_inBuffer_s),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_inBuffer_s>())).pos as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_inBuffer_s),
"::",
stringify!(pos)
)
);
}
#[doc = " Streaming"]
pub type ZSTD_inBuffer = ZSTD_inBuffer_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_outBuffer_s {
#[doc = "< start of output buffer"]
pub dst: *mut libc::c_void,
#[doc = "< size of output buffer"]
pub size: usize,
#[doc = "< position where writing stopped. Will be updated. Necessarily 0 <= pos <= size"]
pub pos: usize,
}
#[test]
fn bindgen_test_layout_ZSTD_outBuffer_s() {
assert_eq!(
::core::mem::size_of::<ZSTD_outBuffer_s>(),
24usize,
concat!("Size of: ", stringify!(ZSTD_outBuffer_s))
);
assert_eq!(
::core::mem::align_of::<ZSTD_outBuffer_s>(),
8usize,
concat!("Alignment of ", stringify!(ZSTD_outBuffer_s))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_outBuffer_s>())).dst as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_outBuffer_s),
"::",
stringify!(dst)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_outBuffer_s>())).size as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_outBuffer_s),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_outBuffer_s>())).pos as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_outBuffer_s),
"::",
stringify!(pos)
)
);
}
pub type ZSTD_outBuffer = ZSTD_outBuffer_s;
pub type ZSTD_CStream = ZSTD_CCtx;
extern "C" {
pub fn ZSTD_createCStream() -> *mut ZSTD_CStream;
}
extern "C" {
pub fn ZSTD_freeCStream(zcs: *mut ZSTD_CStream) -> usize;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ZSTD_EndDirective {
ZSTD_e_continue = 0,
ZSTD_e_flush = 1,
ZSTD_e_end = 2,
}
extern "C" {
#[doc = " ZSTD_compressStream2() :"]
#[doc = " Behaves about the same as ZSTD_compressStream, with additional control on end directive."]
#[doc = " - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()"]
#[doc = " - Compression parameters cannot be changed once compression is started (save a list of exceptions in multi-threading mode)"]
#[doc = " - output->pos must be <= dstCapacity, input->pos must be <= srcSize"]
#[doc = " - output->pos and input->pos will be updated. They are guaranteed to remain below their respective limit."]
#[doc = " - endOp must be a valid directive"]
#[doc = " - When nbWorkers==0 (default), function is blocking : it completes its job before returning to caller."]
#[doc = " - 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,"]
#[doc = " and then immediately returns, just indicating that there is some data remaining to be flushed."]
#[doc = " The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte."]
#[doc = " - Exception : if the first call requests a ZSTD_e_end directive and provides enough dstCapacity, the function delegates to ZSTD_compress2() which is always blocking."]
#[doc = " - @return provides a minimum amount of data remaining to be flushed from internal buffers"]
#[doc = " or an error code, which can be tested using ZSTD_isError()."]
#[doc = " if @return != 0, flush is not fully completed, there is still some data left within internal buffers."]
#[doc = " This is useful for ZSTD_e_flush, since in this case more flushes are necessary to empty all buffers."]
#[doc = " For ZSTD_e_end, @return == 0 when internal buffers are fully flushed and frame is completed."]
#[doc = " - after a ZSTD_e_end directive, if internal buffer is not fully flushed (@return != 0),"]
#[doc = " only ZSTD_e_end or ZSTD_e_flush operations are allowed."]
#[doc = " Before starting a new compression job, or changing compression parameters,"]
#[doc = " it is required to fully flush internal buffers."]
pub fn ZSTD_compressStream2(
cctx: *mut ZSTD_CCtx,
output: *mut ZSTD_outBuffer,
input: *mut ZSTD_inBuffer,
endOp: ZSTD_EndDirective,
) -> usize;
}
extern "C" {
pub fn ZSTD_CStreamInSize() -> usize;
}
extern "C" {
pub fn ZSTD_CStreamOutSize() -> usize;
}
extern "C" {
#[doc = " Equivalent to:"]
#[doc = ""]
#[doc = " ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);"]
#[doc = " ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any)"]
#[doc = " ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);"]
pub fn ZSTD_initCStream(
zcs: *mut ZSTD_CStream,
compressionLevel: libc::c_int,
) -> usize;
}
extern "C" {
#[doc = " Alternative for ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue)."]
#[doc = " NOTE: The return value is different. ZSTD_compressStream() returns a hint for"]
#[doc = " the next read size (if non-zero and not an error). ZSTD_compressStream2()"]
#[doc = " returns the minimum nb of bytes left to flush (if non-zero and not an error)."]
pub fn ZSTD_compressStream(
zcs: *mut ZSTD_CStream,
output: *mut ZSTD_outBuffer,
input: *mut ZSTD_inBuffer,
) -> usize;
}
extern "C" {
#[doc = " Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_flush)."]
pub fn ZSTD_flushStream(
zcs: *mut ZSTD_CStream,
output: *mut ZSTD_outBuffer,
) -> usize;
}
extern "C" {
#[doc = " Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_end)."]
pub fn ZSTD_endStream(
zcs: *mut ZSTD_CStream,
output: *mut ZSTD_outBuffer,
) -> usize;
}
pub type ZSTD_DStream = ZSTD_DCtx;
extern "C" {
pub fn ZSTD_createDStream() -> *mut ZSTD_DStream;
}
extern "C" {
pub fn ZSTD_freeDStream(zds: *mut ZSTD_DStream) -> usize;
}
extern "C" {
pub fn ZSTD_initDStream(zds: *mut ZSTD_DStream) -> usize;
}
extern "C" {
pub fn ZSTD_decompressStream(
zds: *mut ZSTD_DStream,
output: *mut ZSTD_outBuffer,
input: *mut ZSTD_inBuffer,
) -> usize;
}
extern "C" {
pub fn ZSTD_DStreamInSize() -> usize;
}
extern "C" {
pub fn ZSTD_DStreamOutSize() -> usize;
}
extern "C" {
#[doc = " Simple dictionary API"]
#[doc = " Compression at an explicit compression level using a Dictionary."]
#[doc = " A dictionary can be any arbitrary data segment (also called a prefix),"]
#[doc = " or a buffer with specified information (see dictBuilder/zdict.h)."]
#[doc = " Note : This function loads the dictionary, resulting in significant startup delay."]
#[doc = " It's intended for a dictionary used only once."]
#[doc = " Note 2 : When `dict == NULL || dictSize < 8` no dictionary is used."]
pub fn ZSTD_compress_usingDict(
ctx: *mut ZSTD_CCtx,
dst: *mut libc::c_void,
dstCapacity: usize,
src: *const libc::c_void,
srcSize: usize,
dict: *const libc::c_void,
dictSize: usize,
compressionLevel: libc::c_int,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_decompress_usingDict() :"]
#[doc = " Decompression using a known Dictionary."]
#[doc = " Dictionary must be identical to the one used during compression."]
#[doc = " Note : This function loads the dictionary, resulting in significant startup delay."]
#[doc = " It's intended for a dictionary used only once."]
#[doc = " Note : When `dict == NULL || dictSize < 8` no dictionary is used."]
pub fn ZSTD_decompress_usingDict(
dctx: *mut ZSTD_DCtx,
dst: *mut libc::c_void,
dstCapacity: usize,
src: *const libc::c_void,
srcSize: usize,
dict: *const libc::c_void,
dictSize: usize,
) -> usize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_CDict_s {
_unused: [u8; 0],
}
#[doc = " Bulk processing dictionary API"]
pub type ZSTD_CDict = ZSTD_CDict_s;
extern "C" {
#[doc = " ZSTD_createCDict() :"]
#[doc = " When compressing multiple messages or blocks using the same dictionary,"]
#[doc = " it's recommended to digest the dictionary only once, since it's a costly operation."]
#[doc = " ZSTD_createCDict() will create a state from digesting a dictionary."]
#[doc = " The resulting state can be used for future compression operations with very limited startup cost."]
#[doc = " ZSTD_CDict can be created once and shared by multiple threads concurrently, since its usage is read-only."]
#[doc = " @dictBuffer can be released after ZSTD_CDict creation, because its content is copied within CDict."]
#[doc = " Note 1 : Consider experimental function `ZSTD_createCDict_byReference()` if you prefer to not duplicate @dictBuffer content."]
#[doc = " Note 2 : A ZSTD_CDict can be created from an empty @dictBuffer,"]
#[doc = " in which case the only thing that it transports is the @compressionLevel."]
#[doc = " This can be useful in a pipeline featuring ZSTD_compress_usingCDict() exclusively,"]
#[doc = " expecting a ZSTD_CDict parameter with any data, including those without a known dictionary."]
pub fn ZSTD_createCDict(
dictBuffer: *const libc::c_void,
dictSize: usize,
compressionLevel: libc::c_int,
) -> *mut ZSTD_CDict;
}
extern "C" {
#[doc = " ZSTD_freeCDict() :"]
#[doc = " Function frees memory allocated by ZSTD_createCDict()."]
pub fn ZSTD_freeCDict(CDict: *mut ZSTD_CDict) -> usize;
}
extern "C" {
#[doc = " ZSTD_compress_usingCDict() :"]
#[doc = " Compression using a digested Dictionary."]
#[doc = " Recommended when same dictionary is used multiple times."]
#[doc = " Note : compression level is _decided at dictionary creation time_,"]
#[doc = " and frame parameters are hardcoded (dictID=yes, contentSize=yes, checksum=no)"]
pub fn ZSTD_compress_usingCDict(
cctx: *mut ZSTD_CCtx,
dst: *mut libc::c_void,
dstCapacity: usize,
src: *const libc::c_void,
srcSize: usize,
cdict: *const ZSTD_CDict,
) -> usize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_DDict_s {
_unused: [u8; 0],
}
pub type ZSTD_DDict = ZSTD_DDict_s;
extern "C" {
#[doc = " ZSTD_createDDict() :"]
#[doc = " Create a digested dictionary, ready to start decompression operation without startup delay."]
#[doc = " dictBuffer can be released after DDict creation, as its content is copied inside DDict."]
pub fn ZSTD_createDDict(
dictBuffer: *const libc::c_void,
dictSize: usize,
) -> *mut ZSTD_DDict;
}
extern "C" {
#[doc = " ZSTD_freeDDict() :"]
#[doc = " Function frees memory allocated with ZSTD_createDDict()"]
pub fn ZSTD_freeDDict(ddict: *mut ZSTD_DDict) -> usize;
}
extern "C" {
#[doc = " ZSTD_decompress_usingDDict() :"]
#[doc = " Decompression using a digested Dictionary."]
#[doc = " Recommended when same dictionary is used multiple times."]
pub fn ZSTD_decompress_usingDDict(
dctx: *mut ZSTD_DCtx,
dst: *mut libc::c_void,
dstCapacity: usize,
src: *const libc::c_void,
srcSize: usize,
ddict: *const ZSTD_DDict,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_getDictID_fromDict() :"]
#[doc = " Provides the dictID stored within dictionary."]
#[doc = " if @return == 0, the dictionary is not conformant with Zstandard specification."]
#[doc = " It can still be loaded, but as a content-only dictionary."]
pub fn ZSTD_getDictID_fromDict(
dict: *const libc::c_void,
dictSize: usize,
) -> libc::c_uint;
}
extern "C" {
#[doc = " ZSTD_getDictID_fromDDict() :"]
#[doc = " Provides the dictID of the dictionary loaded into `ddict`."]
#[doc = " If @return == 0, the dictionary is not conformant to Zstandard specification, or empty."]
#[doc = " Non-conformant dictionaries can still be loaded, but as content-only dictionaries."]
pub fn ZSTD_getDictID_fromDDict(ddict: *const ZSTD_DDict) -> libc::c_uint;
}
extern "C" {
#[doc = " ZSTD_getDictID_fromFrame() :"]
#[doc = " Provides the dictID required to decompressed the frame stored within `src`."]
#[doc = " If @return == 0, the dictID could not be decoded."]
#[doc = " This could for one of the following reasons :"]
#[doc = " - The frame does not require a dictionary to be decoded (most common case)."]
#[doc = " - The frame was built with dictID intentionally removed. Whatever dictionary is necessary is a hidden information."]
#[doc = " Note : this use case also happens when using a non-conformant dictionary."]
#[doc = " - `srcSize` is too small, and as a result, the frame header could not be decoded (only possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`)."]
#[doc = " - This is not a Zstandard frame."]
#[doc = " When identifying the exact failure cause, it's possible to use ZSTD_getFrameHeader(), which will provide a more precise error code."]
pub fn ZSTD_getDictID_fromFrame(
src: *const libc::c_void,
srcSize: usize,
) -> libc::c_uint;
}
extern "C" {
#[doc = " ZSTD_CCtx_loadDictionary() :"]
#[doc = " Create an internal CDict from `dict` buffer."]
#[doc = " Decompression will have to use same dictionary."]
#[doc = " @result : 0, or an error code (which can be tested with ZSTD_isError())."]
#[doc = " Special: Loading a NULL (or 0-size) dictionary invalidates previous dictionary,"]
#[doc = " meaning \"return to no-dictionary mode\"."]
#[doc = " Note 1 : Dictionary is sticky, it will be used for all future compressed frames."]
#[doc = " To return to \"no-dictionary\" situation, load a NULL dictionary (or reset parameters)."]
#[doc = " Note 2 : Loading a dictionary involves building tables."]
#[doc = " It's also a CPU consuming operation, with non-negligible impact on latency."]
#[doc = " Tables are dependent on compression parameters, and for this reason,"]
#[doc = " compression parameters can no longer be changed after loading a dictionary."]
#[doc = " Note 3 :`dict` content will be copied internally."]
#[doc = " Use experimental ZSTD_CCtx_loadDictionary_byReference() to reference content instead."]
#[doc = " In such a case, dictionary buffer must outlive its users."]
#[doc = " Note 4 : Use ZSTD_CCtx_loadDictionary_advanced()"]
#[doc = " to precisely select how dictionary content must be interpreted."]
pub fn ZSTD_CCtx_loadDictionary(
cctx: *mut ZSTD_CCtx,
dict: *const libc::c_void,
dictSize: usize,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_CCtx_refCDict() :"]
#[doc = " Reference a prepared dictionary, to be used for all next compressed frames."]
#[doc = " Note that compression parameters are enforced from within CDict,"]
#[doc = " and supersede any compression parameter previously set within CCtx."]
#[doc = " The parameters ignored are labled as \"superseded-by-cdict\" in the ZSTD_cParameter enum docs."]
#[doc = " The ignored parameters will be used again if the CCtx is returned to no-dictionary mode."]
#[doc = " The dictionary will remain valid for future compressed frames using same CCtx."]
#[doc = " @result : 0, or an error code (which can be tested with ZSTD_isError())."]
#[doc = " Special : Referencing a NULL CDict means \"return to no-dictionary mode\"."]
#[doc = " Note 1 : Currently, only one dictionary can be managed."]
#[doc = " Referencing a new dictionary effectively \"discards\" any previous one."]
#[doc = " Note 2 : CDict is just referenced, its lifetime must outlive its usage within CCtx."]
pub fn ZSTD_CCtx_refCDict(
cctx: *mut ZSTD_CCtx,
cdict: *const ZSTD_CDict,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_CCtx_refPrefix() :"]
#[doc = " Reference a prefix (single-usage dictionary) for next compressed frame."]
#[doc = " A prefix is **only used once**. Tables are discarded at end of frame (ZSTD_e_end)."]
#[doc = " Decompression will need same prefix to properly regenerate data."]
#[doc = " Compressing with a prefix is similar in outcome as performing a diff and compressing it,"]
#[doc = " but performs much faster, especially during decompression (compression speed is tunable with compression level)."]
#[doc = " @result : 0, or an error code (which can be tested with ZSTD_isError())."]
#[doc = " Special: Adding any prefix (including NULL) invalidates any previous prefix or dictionary"]
#[doc = " Note 1 : Prefix buffer is referenced. It **must** outlive compression."]
#[doc = " Its content must remain unmodified during compression."]
#[doc = " Note 2 : If the intention is to diff some large src data blob with some prior version of itself,"]
#[doc = " ensure that the window size is large enough to contain the entire source."]
#[doc = " See ZSTD_c_windowLog."]
#[doc = " Note 3 : Referencing a prefix involves building tables, which are dependent on compression parameters."]
#[doc = " It's a CPU consuming operation, with non-negligible impact on latency."]
#[doc = " If there is a need to use the same prefix multiple times, consider loadDictionary instead."]
#[doc = " Note 4 : By default, the prefix is interpreted as raw content (ZSTD_dct_rawContent)."]
#[doc = " Use experimental ZSTD_CCtx_refPrefix_advanced() to alter dictionary interpretation."]
pub fn ZSTD_CCtx_refPrefix(
cctx: *mut ZSTD_CCtx,
prefix: *const libc::c_void,
prefixSize: usize,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_DCtx_loadDictionary() :"]
#[doc = " Create an internal DDict from dict buffer,"]
#[doc = " to be used to decompress next frames."]
#[doc = " The dictionary remains valid for all future frames, until explicitly invalidated."]
#[doc = " @result : 0, or an error code (which can be tested with ZSTD_isError())."]
#[doc = " Special : Adding a NULL (or 0-size) dictionary invalidates any previous dictionary,"]
#[doc = " meaning \"return to no-dictionary mode\"."]
#[doc = " Note 1 : Loading a dictionary involves building tables,"]
#[doc = " which has a non-negligible impact on CPU usage and latency."]
#[doc = " It's recommended to \"load once, use many times\", to amortize the cost"]
#[doc = " Note 2 :`dict` content will be copied internally, so `dict` can be released after loading."]
#[doc = " Use ZSTD_DCtx_loadDictionary_byReference() to reference dictionary content instead."]
#[doc = " Note 3 : Use ZSTD_DCtx_loadDictionary_advanced() to take control of"]
#[doc = " how dictionary content is loaded and interpreted."]
pub fn ZSTD_DCtx_loadDictionary(
dctx: *mut ZSTD_DCtx,
dict: *const libc::c_void,
dictSize: usize,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_DCtx_refDDict() :"]
#[doc = " Reference a prepared dictionary, to be used to decompress next frames."]
#[doc = " The dictionary remains active for decompression of future frames using same DCtx."]
#[doc = " @result : 0, or an error code (which can be tested with ZSTD_isError())."]
#[doc = " Note 1 : Currently, only one dictionary can be managed."]
#[doc = " Referencing a new dictionary effectively \"discards\" any previous one."]
#[doc = " Special: referencing a NULL DDict means \"return to no-dictionary mode\"."]
#[doc = " Note 2 : DDict is just referenced, its lifetime must outlive its usage from DCtx."]
pub fn ZSTD_DCtx_refDDict(
dctx: *mut ZSTD_DCtx,
ddict: *const ZSTD_DDict,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_DCtx_refPrefix() :"]
#[doc = " Reference a prefix (single-usage dictionary) to decompress next frame."]
#[doc = " This is the reverse operation of ZSTD_CCtx_refPrefix(),"]
#[doc = " and must use the same prefix as the one used during compression."]
#[doc = " Prefix is **only used once**. Reference is discarded at end of frame."]
#[doc = " End of frame is reached when ZSTD_decompressStream() returns 0."]
#[doc = " @result : 0, or an error code (which can be tested with ZSTD_isError())."]
#[doc = " Note 1 : Adding any prefix (including NULL) invalidates any previously set prefix or dictionary"]
#[doc = " Note 2 : Prefix buffer is referenced. It **must** outlive decompression."]
#[doc = " Prefix buffer must remain unmodified up to the end of frame,"]
#[doc = " reached when ZSTD_decompressStream() returns 0."]
#[doc = " Note 3 : By default, the prefix is treated as raw content (ZSTD_dct_rawContent)."]
#[doc = " Use ZSTD_CCtx_refPrefix_advanced() to alter dictMode (Experimental section)"]
#[doc = " Note 4 : Referencing a raw content prefix has almost no cpu nor memory cost."]
#[doc = " A full dictionary is more costly, as it requires building tables."]
pub fn ZSTD_DCtx_refPrefix(
dctx: *mut ZSTD_DCtx,
prefix: *const libc::c_void,
prefixSize: usize,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_sizeof_*() :"]
#[doc = " These functions give the _current_ memory usage of selected object."]
#[doc = " Note that object memory usage can evolve (increase or decrease) over time."]
pub fn ZSTD_sizeof_CCtx(cctx: *const ZSTD_CCtx) -> usize;
}
extern "C" {
pub fn ZSTD_sizeof_DCtx(dctx: *const ZSTD_DCtx) -> usize;
}
extern "C" {
pub fn ZSTD_sizeof_CStream(zcs: *const ZSTD_CStream) -> usize;
}
extern "C" {
pub fn ZSTD_sizeof_DStream(zds: *const ZSTD_DStream) -> usize;
}
extern "C" {
pub fn ZSTD_sizeof_CDict(cdict: *const ZSTD_CDict) -> usize;
}
extern "C" {
pub fn ZSTD_sizeof_DDict(ddict: *const ZSTD_DDict) -> usize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_CCtx_params_s {
_unused: [u8; 0],
}
pub type ZSTD_CCtx_params = ZSTD_CCtx_params_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_Sequence {
pub offset: libc::c_uint,
pub litLength: libc::c_uint,
pub matchLength: libc::c_uint,
pub rep: libc::c_uint,
}
#[test]
fn bindgen_test_layout_ZSTD_Sequence() {
assert_eq!(
::core::mem::size_of::<ZSTD_Sequence>(),
16usize,
concat!("Size of: ", stringify!(ZSTD_Sequence))
);
assert_eq!(
::core::mem::align_of::<ZSTD_Sequence>(),
4usize,
concat!("Alignment of ", stringify!(ZSTD_Sequence))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_Sequence>())).offset as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_Sequence),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_Sequence>())).litLength as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_Sequence),
"::",
stringify!(litLength)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_Sequence>())).matchLength as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_Sequence),
"::",
stringify!(matchLength)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_Sequence>())).rep as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_Sequence),
"::",
stringify!(rep)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_compressionParameters {
#[doc = "< largest match distance : larger == more compression, more memory needed during decompression"]
pub windowLog: libc::c_uint,
#[doc = "< fully searched segment : larger == more compression, slower, more memory (useless for fast)"]
pub chainLog: libc::c_uint,
#[doc = "< dispatch table : larger == faster, more memory"]
pub hashLog: libc::c_uint,
#[doc = "< nb of searches : larger == more compression, slower"]
pub searchLog: libc::c_uint,
#[doc = "< match length searched : larger == faster decompression, sometimes less compression"]
pub minMatch: libc::c_uint,
#[doc = "< acceptable match size for optimal parser (only) : larger == more compression, slower"]
pub targetLength: libc::c_uint,
#[doc = "< see ZSTD_strategy definition above"]
pub strategy: ZSTD_strategy,
}
#[test]
fn bindgen_test_layout_ZSTD_compressionParameters() {
assert_eq!(
::core::mem::size_of::<ZSTD_compressionParameters>(),
28usize,
concat!("Size of: ", stringify!(ZSTD_compressionParameters))
);
assert_eq!(
::core::mem::align_of::<ZSTD_compressionParameters>(),
4usize,
concat!("Alignment of ", stringify!(ZSTD_compressionParameters))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_compressionParameters>())).windowLog
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_compressionParameters),
"::",
stringify!(windowLog)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_compressionParameters>())).chainLog
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_compressionParameters),
"::",
stringify!(chainLog)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_compressionParameters>())).hashLog
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_compressionParameters),
"::",
stringify!(hashLog)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_compressionParameters>())).searchLog
as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_compressionParameters),
"::",
stringify!(searchLog)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_compressionParameters>())).minMatch
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_compressionParameters),
"::",
stringify!(minMatch)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_compressionParameters>()))
.targetLength as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_compressionParameters),
"::",
stringify!(targetLength)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_compressionParameters>())).strategy
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_compressionParameters),
"::",
stringify!(strategy)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_frameParameters {
#[doc = "< 1: content size will be in frame header (when known)"]
pub contentSizeFlag: libc::c_int,
#[doc = "< 1: generate a 32-bits checksum using XXH64 algorithm at end of frame, for error detection"]
pub checksumFlag: libc::c_int,
#[doc = "< 1: no dictID will be saved into frame header (dictID is only useful for dictionary compression)"]
pub noDictIDFlag: libc::c_int,
}
#[test]
fn bindgen_test_layout_ZSTD_frameParameters() {
assert_eq!(
::core::mem::size_of::<ZSTD_frameParameters>(),
12usize,
concat!("Size of: ", stringify!(ZSTD_frameParameters))
);
assert_eq!(
::core::mem::align_of::<ZSTD_frameParameters>(),
4usize,
concat!("Alignment of ", stringify!(ZSTD_frameParameters))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_frameParameters>())).contentSizeFlag
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_frameParameters),
"::",
stringify!(contentSizeFlag)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_frameParameters>())).checksumFlag
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_frameParameters),
"::",
stringify!(checksumFlag)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_frameParameters>())).noDictIDFlag
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_frameParameters),
"::",
stringify!(noDictIDFlag)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_parameters {
pub cParams: ZSTD_compressionParameters,
pub fParams: ZSTD_frameParameters,
}
#[test]
fn bindgen_test_layout_ZSTD_parameters() {
assert_eq!(
::core::mem::size_of::<ZSTD_parameters>(),
40usize,
concat!("Size of: ", stringify!(ZSTD_parameters))
);
assert_eq!(
::core::mem::align_of::<ZSTD_parameters>(),
4usize,
concat!("Alignment of ", stringify!(ZSTD_parameters))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_parameters>())).cParams as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_parameters),
"::",
stringify!(cParams)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_parameters>())).fParams as *const _
as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_parameters),
"::",
stringify!(fParams)
)
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ZSTD_dictContentType_e {
ZSTD_dct_auto = 0,
ZSTD_dct_rawContent = 1,
ZSTD_dct_fullDict = 2,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ZSTD_dictLoadMethod_e {
#[doc = "< Copy dictionary content internally"]
ZSTD_dlm_byCopy = 0,
#[doc = "< Reference dictionary content -- the dictionary buffer must outlive its users."]
ZSTD_dlm_byRef = 1,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ZSTD_format_e {
ZSTD_f_zstd1 = 0,
ZSTD_f_zstd1_magicless = 1,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ZSTD_forceIgnoreChecksum_e {
ZSTD_d_validateChecksum = 0,
ZSTD_d_ignoreChecksum = 1,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ZSTD_dictAttachPref_e {
ZSTD_dictDefaultAttach = 0,
ZSTD_dictForceAttach = 1,
ZSTD_dictForceCopy = 2,
ZSTD_dictForceLoad = 3,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ZSTD_literalCompressionMode_e {
#[doc = "< Automatically determine the compression mode based on the compression level."]
#[doc = " Negative compression levels will be uncompressed, and positive compression"]
#[doc = " levels will be compressed."]
ZSTD_lcm_auto = 0,
#[doc = "< Always attempt Huffman compression. Uncompressed literals will still be"]
#[doc = " emitted if Huffman compression is not profitable."]
ZSTD_lcm_huffman = 1,
#[doc = "< Always emit uncompressed literals."]
ZSTD_lcm_uncompressed = 2,
}
extern "C" {
#[doc = " ZSTD_findDecompressedSize() :"]
#[doc = " `src` should point to the start of a series of ZSTD encoded and/or skippable frames"]
#[doc = " `srcSize` must be the _exact_ size of this series"]
#[doc = " (i.e. there should be a frame boundary at `src + srcSize`)"]
#[doc = " @return : - decompressed size of all data in all successive frames"]
#[doc = " - if the decompressed size cannot be determined: ZSTD_CONTENTSIZE_UNKNOWN"]
#[doc = " - if an error occurred: ZSTD_CONTENTSIZE_ERROR"]
#[doc = ""]
#[doc = " note 1 : decompressed size is an optional field, that may not be present, especially in streaming mode."]
#[doc = " When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size."]
#[doc = " In which case, it's necessary to use streaming mode to decompress data."]
#[doc = " note 2 : decompressed size is always present when compression is done with ZSTD_compress()"]
#[doc = " note 3 : decompressed size can be very large (64-bits value),"]
#[doc = " potentially larger than what local system can handle as a single memory segment."]
#[doc = " In which case, it's necessary to use streaming mode to decompress data."]
#[doc = " note 4 : If source is untrusted, decompressed size could be wrong or intentionally modified."]
#[doc = " Always ensure result fits within application's authorized limits."]
#[doc = " Each application can set its own limits."]
#[doc = " note 5 : ZSTD_findDecompressedSize handles multiple frames, and so it must traverse the input to"]
#[doc = " read each contained frame header. This is fast as most of the data is skipped,"]
#[doc = " however it does mean that all frame data must be present and valid."]
pub fn ZSTD_findDecompressedSize(
src: *const libc::c_void,
srcSize: usize,
) -> libc::c_ulonglong;
}
extern "C" {
#[doc = " ZSTD_decompressBound() :"]
#[doc = " `src` should point to the start of a series of ZSTD encoded and/or skippable frames"]
#[doc = " `srcSize` must be the _exact_ size of this series"]
#[doc = " (i.e. there should be a frame boundary at `src + srcSize`)"]
#[doc = " @return : - upper-bound for the decompressed size of all data in all successive frames"]
#[doc = " - if an error occured: ZSTD_CONTENTSIZE_ERROR"]
#[doc = ""]
#[doc = " note 1 : an error can occur if `src` contains an invalid or incorrectly formatted frame."]
#[doc = " note 2 : the upper-bound is exact when the decompressed size field is available in every ZSTD encoded frame of `src`."]
#[doc = " in this case, `ZSTD_findDecompressedSize` and `ZSTD_decompressBound` return the same value."]
#[doc = " note 3 : when the decompressed size field isn't available, the upper-bound for that frame is calculated by:"]
#[doc = " upper-bound = # blocks * min(128 KB, Window_Size)"]
pub fn ZSTD_decompressBound(
src: *const libc::c_void,
srcSize: usize,
) -> libc::c_ulonglong;
}
extern "C" {
#[doc = " ZSTD_frameHeaderSize() :"]
#[doc = " srcSize must be >= ZSTD_FRAMEHEADERSIZE_PREFIX."]
#[doc = " @return : size of the Frame Header,"]
#[doc = " or an error code (if srcSize is too small)"]
pub fn ZSTD_frameHeaderSize(
src: *const libc::c_void,
srcSize: usize,
) -> usize;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ZSTD_sequenceFormat_e {
ZSTD_sf_noBlockDelimiters = 0,
ZSTD_sf_explicitBlockDelimiters = 1,
}
extern "C" {
#[doc = " ZSTD_generateSequences() :"]
#[doc = " Generate sequences using ZSTD_compress2, given a source buffer."]
#[doc = ""]
#[doc = " Each block will end with a dummy sequence"]
#[doc = " with offset == 0, matchLength == 0, and litLength == length of last literals."]
#[doc = " litLength may be == 0, and if so, then the sequence of (of: 0 ml: 0 ll: 0)"]
#[doc = " simply acts as a block delimiter."]
#[doc = ""]
#[doc = " zc can be used to insert custom compression params."]
#[doc = " This function invokes ZSTD_compress2"]
#[doc = ""]
#[doc = " The output of this function can be fed into ZSTD_compressSequences() with CCtx"]
#[doc = " setting of ZSTD_c_blockDelimiters as ZSTD_sf_explicitBlockDelimiters"]
#[doc = " @return : number of sequences generated"]
pub fn ZSTD_generateSequences(
zc: *mut ZSTD_CCtx,
outSeqs: *mut ZSTD_Sequence,
outSeqsSize: usize,
src: *const libc::c_void,
srcSize: usize,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_mergeBlockDelimiters() :"]
#[doc = " Given an array of ZSTD_Sequence, remove all sequences that represent block delimiters/last literals"]
#[doc = " by merging them into into the literals of the next sequence."]
#[doc = ""]
#[doc = " As such, the final generated result has no explicit representation of block boundaries,"]
#[doc = " and the final last literals segment is not represented in the sequences."]
#[doc = ""]
#[doc = " The output of this function can be fed into ZSTD_compressSequences() with CCtx"]
#[doc = " setting of ZSTD_c_blockDelimiters as ZSTD_sf_noBlockDelimiters"]
#[doc = " @return : number of sequences left after merging"]
pub fn ZSTD_mergeBlockDelimiters(
sequences: *mut ZSTD_Sequence,
seqsSize: usize,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_compressSequences() :"]
#[doc = " Compress an array of ZSTD_Sequence, generated from the original source buffer, into dst."]
#[doc = " If a dictionary is included, then the cctx should reference the dict. (see: ZSTD_CCtx_refCDict(), ZSTD_CCtx_loadDictionary(), etc.)"]
#[doc = " The entire source is compressed into a single frame."]
#[doc = ""]
#[doc = " The compression behavior changes based on cctx params. In particular:"]
#[doc = " If ZSTD_c_blockDelimiters == ZSTD_sf_noBlockDelimiters, the array of ZSTD_Sequence is expected to contain"]
#[doc = " no block delimiters (defined in ZSTD_Sequence). Block boundaries are roughly determined based on"]
#[doc = " the block size derived from the cctx, and sequences may be split. This is the default setting."]
#[doc = ""]
#[doc = " If ZSTD_c_blockDelimiters == ZSTD_sf_explicitBlockDelimiters, the array of ZSTD_Sequence is expected to contain"]
#[doc = " block delimiters (defined in ZSTD_Sequence). Behavior is undefined if no block delimiters are provided."]
#[doc = ""]
#[doc = " If ZSTD_c_validateSequences == 0, this function will blindly accept the sequences provided. Invalid sequences cause undefined"]
#[doc = " behavior. If ZSTD_c_validateSequences == 1, then if sequence is invalid (see doc/zstd_compression_format.md for"]
#[doc = " specifics regarding offset/matchlength requirements) then the function will bail out and return an error."]
#[doc = ""]
#[doc = " In addition to the two adjustable experimental params, there are other important cctx params."]
#[doc = " - ZSTD_c_minMatch MUST be set as less than or equal to the smallest match generated by the match finder. It has a minimum value of ZSTD_MINMATCH_MIN."]
#[doc = " - ZSTD_c_compressionLevel accordingly adjusts the strength of the entropy coder, as it would in typical compression."]
#[doc = " - ZSTD_c_windowLog affects offset validation: this function will return an error at higher debug levels if a provided offset"]
#[doc = " is larger than what the spec allows for a given window log and dictionary (if present). See: doc/zstd_compression_format.md"]
#[doc = ""]
#[doc = " Note: Repcodes are, as of now, always re-calculated within this function, so ZSTD_Sequence::rep is unused."]
#[doc = " Note 2: Once we integrate ability to ingest repcodes, the explicit block delims mode must respect those repcodes exactly,"]
#[doc = " and cannot emit an RLE block that disagrees with the repcode history"]
#[doc = " @return : final compressed size or a ZSTD error."]
pub fn ZSTD_compressSequences(
cctx: *mut ZSTD_CCtx,
dst: *mut libc::c_void,
dstSize: usize,
inSeqs: *const ZSTD_Sequence,
inSeqsSize: usize,
src: *const libc::c_void,
srcSize: usize,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_estimate*() :"]
#[doc = " These functions make it possible to estimate memory usage"]
#[doc = " of a future {D,C}Ctx, before its creation."]
#[doc = ""]
#[doc = " ZSTD_estimateCCtxSize() will provide a memory budget large enough"]
#[doc = " for any compression level up to selected one."]
#[doc = " Note : Unlike ZSTD_estimateCStreamSize*(), this estimate"]
#[doc = " does not include space for a window buffer."]
#[doc = " Therefore, the estimation is only guaranteed for single-shot compressions, not streaming."]
#[doc = " The estimate will assume the input may be arbitrarily large,"]
#[doc = " which is the worst case."]
#[doc = ""]
#[doc = " When srcSize can be bound by a known and rather \"small\" value,"]
#[doc = " this fact can be used to provide a tighter estimation"]
#[doc = " because the CCtx compression context will need less memory."]
#[doc = " This tighter estimation can be provided by more advanced functions"]
#[doc = " ZSTD_estimateCCtxSize_usingCParams(), which can be used in tandem with ZSTD_getCParams(),"]
#[doc = " and ZSTD_estimateCCtxSize_usingCCtxParams(), which can be used in tandem with ZSTD_CCtxParams_setParameter()."]
#[doc = " Both can be used to estimate memory using custom compression parameters and arbitrary srcSize limits."]
#[doc = ""]
#[doc = " Note 2 : only single-threaded compression is supported."]
#[doc = " ZSTD_estimateCCtxSize_usingCCtxParams() will return an error code if ZSTD_c_nbWorkers is >= 1."]
pub fn ZSTD_estimateCCtxSize(compressionLevel: libc::c_int) -> usize;
}
extern "C" {
pub fn ZSTD_estimateCCtxSize_usingCParams(
cParams: ZSTD_compressionParameters,
) -> usize;
}
extern "C" {
pub fn ZSTD_estimateCCtxSize_usingCCtxParams(
params: *const ZSTD_CCtx_params,
) -> usize;
}
extern "C" {
pub fn ZSTD_estimateDCtxSize() -> usize;
}
extern "C" {
#[doc = " ZSTD_estimateCStreamSize() :"]
#[doc = " ZSTD_estimateCStreamSize() will provide a budget large enough for any compression level up to selected one."]
#[doc = " It will also consider src size to be arbitrarily \"large\", which is worst case."]
#[doc = " If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation."]
#[doc = " ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel."]
#[doc = " ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParams_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_c_nbWorkers is >= 1."]
#[doc = " Note : CStream size estimation is only correct for single-threaded compression."]
#[doc = " ZSTD_DStream memory budget depends on window Size."]
#[doc = " This information can be passed manually, using ZSTD_estimateDStreamSize,"]
#[doc = " or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame();"]
#[doc = " Note : if streaming is init with function ZSTD_init?Stream_usingDict(),"]
#[doc = " an internal ?Dict will be created, which additional size is not estimated here."]
#[doc = " In this case, get total size by adding ZSTD_estimate?DictSize"]
pub fn ZSTD_estimateCStreamSize(compressionLevel: libc::c_int) -> usize;
}
extern "C" {
pub fn ZSTD_estimateCStreamSize_usingCParams(
cParams: ZSTD_compressionParameters,
) -> usize;
}
extern "C" {
pub fn ZSTD_estimateCStreamSize_usingCCtxParams(
params: *const ZSTD_CCtx_params,
) -> usize;
}
extern "C" {
pub fn ZSTD_estimateDStreamSize(windowSize: usize) -> usize;
}
extern "C" {
pub fn ZSTD_estimateDStreamSize_fromFrame(
src: *const libc::c_void,
srcSize: usize,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_estimate?DictSize() :"]
#[doc = " ZSTD_estimateCDictSize() will bet that src size is relatively \"small\", and content is copied, like ZSTD_createCDict()."]
#[doc = " ZSTD_estimateCDictSize_advanced() makes it possible to control compression parameters precisely, like ZSTD_createCDict_advanced()."]
#[doc = " Note : dictionaries created by reference (`ZSTD_dlm_byRef`) are logically smaller."]
pub fn ZSTD_estimateCDictSize(
dictSize: usize,
compressionLevel: libc::c_int,
) -> usize;
}
extern "C" {
pub fn ZSTD_estimateCDictSize_advanced(
dictSize: usize,
cParams: ZSTD_compressionParameters,
dictLoadMethod: ZSTD_dictLoadMethod_e,
) -> usize;
}
extern "C" {
pub fn ZSTD_estimateDDictSize(
dictSize: usize,
dictLoadMethod: ZSTD_dictLoadMethod_e,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_initStatic*() :"]
#[doc = " Initialize an object using a pre-allocated fixed-size buffer."]
#[doc = " workspace: The memory area to emplace the object into."]
#[doc = " Provided pointer *must be 8-bytes aligned*."]
#[doc = " Buffer must outlive object."]
#[doc = " workspaceSize: Use ZSTD_estimate*Size() to determine"]
#[doc = " how large workspace must be to support target scenario."]
#[doc = " @return : pointer to object (same address as workspace, just different type),"]
#[doc = " or NULL if error (size too small, incorrect alignment, etc.)"]
#[doc = " Note : zstd will never resize nor malloc() when using a static buffer."]
#[doc = " If the object requires more memory than available,"]
#[doc = " zstd will just error out (typically ZSTD_error_memory_allocation)."]
#[doc = " Note 2 : there is no corresponding \"free\" function."]
#[doc = " Since workspace is allocated externally, it must be freed externally too."]
#[doc = " Note 3 : cParams : use ZSTD_getCParams() to convert a compression level"]
#[doc = " into its associated cParams."]
#[doc = " Limitation 1 : currently not compatible with internal dictionary creation, triggered by"]
#[doc = " ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict()."]
#[doc = " Limitation 2 : static cctx currently not compatible with multi-threading."]
#[doc = " Limitation 3 : static dctx is incompatible with legacy support."]
pub fn ZSTD_initStaticCCtx(
workspace: *mut libc::c_void,
workspaceSize: usize,
) -> *mut ZSTD_CCtx;
}
extern "C" {
pub fn ZSTD_initStaticCStream(
workspace: *mut libc::c_void,
workspaceSize: usize,
) -> *mut ZSTD_CStream;
}
extern "C" {
pub fn ZSTD_initStaticDCtx(
workspace: *mut libc::c_void,
workspaceSize: usize,
) -> *mut ZSTD_DCtx;
}
extern "C" {
pub fn ZSTD_initStaticDStream(
workspace: *mut libc::c_void,
workspaceSize: usize,
) -> *mut ZSTD_DStream;
}
extern "C" {
pub fn ZSTD_initStaticCDict(
workspace: *mut libc::c_void,
workspaceSize: usize,
dict: *const libc::c_void,
dictSize: usize,
dictLoadMethod: ZSTD_dictLoadMethod_e,
dictContentType: ZSTD_dictContentType_e,
cParams: ZSTD_compressionParameters,
) -> *const ZSTD_CDict;
}
extern "C" {
pub fn ZSTD_initStaticDDict(
workspace: *mut libc::c_void,
workspaceSize: usize,
dict: *const libc::c_void,
dictSize: usize,
dictLoadMethod: ZSTD_dictLoadMethod_e,
dictContentType: ZSTD_dictContentType_e,
) -> *const ZSTD_DDict;
}
#[doc = " Custom memory allocation :"]
#[doc = " These prototypes make it possible to pass your own allocation/free functions."]
#[doc = " ZSTD_customMem is provided at creation time, using ZSTD_create*_advanced() variants listed below."]
#[doc = " All allocation/free operations will be completed using these custom variants instead of regular <stdlib.h> ones."]
pub type ZSTD_allocFunction = ::core::option::Option<
unsafe extern "C" fn(
opaque: *mut libc::c_void,
size: usize,
) -> *mut libc::c_void,
>;
pub type ZSTD_freeFunction = ::core::option::Option<
unsafe extern "C" fn(
opaque: *mut libc::c_void,
address: *mut libc::c_void,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_customMem {
pub customAlloc: ZSTD_allocFunction,
pub customFree: ZSTD_freeFunction,
pub opaque: *mut libc::c_void,
}
#[test]
fn bindgen_test_layout_ZSTD_customMem() {
assert_eq!(
::core::mem::size_of::<ZSTD_customMem>(),
24usize,
concat!("Size of: ", stringify!(ZSTD_customMem))
);
assert_eq!(
::core::mem::align_of::<ZSTD_customMem>(),
8usize,
concat!("Alignment of ", stringify!(ZSTD_customMem))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_customMem>())).customAlloc as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_customMem),
"::",
stringify!(customAlloc)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_customMem>())).customFree as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_customMem),
"::",
stringify!(customFree)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_customMem>())).opaque as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_customMem),
"::",
stringify!(opaque)
)
);
}
extern "C" {
pub static ZSTD_defaultCMem: ZSTD_customMem;
}
extern "C" {
pub fn ZSTD_createCCtx_advanced(
customMem: ZSTD_customMem,
) -> *mut ZSTD_CCtx;
}
extern "C" {
pub fn ZSTD_createCStream_advanced(
customMem: ZSTD_customMem,
) -> *mut ZSTD_CStream;
}
extern "C" {
pub fn ZSTD_createDCtx_advanced(
customMem: ZSTD_customMem,
) -> *mut ZSTD_DCtx;
}
extern "C" {
pub fn ZSTD_createDStream_advanced(
customMem: ZSTD_customMem,
) -> *mut ZSTD_DStream;
}
extern "C" {
pub fn ZSTD_createCDict_advanced(
dict: *const libc::c_void,
dictSize: usize,
dictLoadMethod: ZSTD_dictLoadMethod_e,
dictContentType: ZSTD_dictContentType_e,
cParams: ZSTD_compressionParameters,
customMem: ZSTD_customMem,
) -> *mut ZSTD_CDict;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct POOL_ctx_s {
_unused: [u8; 0],
}
pub type ZSTD_threadPool = POOL_ctx_s;
extern "C" {
pub fn ZSTD_createThreadPool(numThreads: usize) -> *mut ZSTD_threadPool;
}
extern "C" {
pub fn ZSTD_freeThreadPool(pool: *mut ZSTD_threadPool);
}
extern "C" {
pub fn ZSTD_CCtx_refThreadPool(
cctx: *mut ZSTD_CCtx,
pool: *mut ZSTD_threadPool,
) -> usize;
}
extern "C" {
pub fn ZSTD_createCDict_advanced2(
dict: *const libc::c_void,
dictSize: usize,
dictLoadMethod: ZSTD_dictLoadMethod_e,
dictContentType: ZSTD_dictContentType_e,
cctxParams: *const ZSTD_CCtx_params,
customMem: ZSTD_customMem,
) -> *mut ZSTD_CDict;
}
extern "C" {
pub fn ZSTD_createDDict_advanced(
dict: *const libc::c_void,
dictSize: usize,
dictLoadMethod: ZSTD_dictLoadMethod_e,
dictContentType: ZSTD_dictContentType_e,
customMem: ZSTD_customMem,
) -> *mut ZSTD_DDict;
}
extern "C" {
#[doc = " ZSTD_createCDict_byReference() :"]
#[doc = " Create a digested dictionary for compression"]
#[doc = " Dictionary content is just referenced, not duplicated."]
#[doc = " As a consequence, `dictBuffer` **must** outlive CDict,"]
#[doc = " and its content must remain unmodified throughout the lifetime of CDict."]
#[doc = " note: equivalent to ZSTD_createCDict_advanced(), with dictLoadMethod==ZSTD_dlm_byRef"]
pub fn ZSTD_createCDict_byReference(
dictBuffer: *const libc::c_void,
dictSize: usize,
compressionLevel: libc::c_int,
) -> *mut ZSTD_CDict;
}
extern "C" {
#[doc = " ZSTD_getDictID_fromCDict() :"]
#[doc = " Provides the dictID of the dictionary loaded into `cdict`."]
#[doc = " If @return == 0, the dictionary is not conformant to Zstandard specification, or empty."]
#[doc = " Non-conformant dictionaries can still be loaded, but as content-only dictionaries."]
pub fn ZSTD_getDictID_fromCDict(cdict: *const ZSTD_CDict) -> libc::c_uint;
}
extern "C" {
#[doc = " ZSTD_getCParams() :"]
#[doc = " @return ZSTD_compressionParameters structure for a selected compression level and estimated srcSize."]
#[doc = " `estimatedSrcSize` value is optional, select 0 if not known"]
pub fn ZSTD_getCParams(
compressionLevel: libc::c_int,
estimatedSrcSize: libc::c_ulonglong,
dictSize: usize,
) -> ZSTD_compressionParameters;
}
extern "C" {
#[doc = " ZSTD_getParams() :"]
#[doc = " same as ZSTD_getCParams(), but @return a full `ZSTD_parameters` object instead of sub-component `ZSTD_compressionParameters`."]
#[doc = " All fields of `ZSTD_frameParameters` are set to default : contentSize=1, checksum=0, noDictID=0"]
pub fn ZSTD_getParams(
compressionLevel: libc::c_int,
estimatedSrcSize: libc::c_ulonglong,
dictSize: usize,
) -> ZSTD_parameters;
}
extern "C" {
#[doc = " ZSTD_checkCParams() :"]
#[doc = " Ensure param values remain within authorized range."]
#[doc = " @return 0 on success, or an error code (can be checked with ZSTD_isError())"]
pub fn ZSTD_checkCParams(params: ZSTD_compressionParameters) -> usize;
}
extern "C" {
#[doc = " ZSTD_adjustCParams() :"]
#[doc = " optimize params for a given `srcSize` and `dictSize`."]
#[doc = " `srcSize` can be unknown, in which case use ZSTD_CONTENTSIZE_UNKNOWN."]
#[doc = " `dictSize` must be `0` when there is no dictionary."]
#[doc = " cPar can be invalid : all parameters will be clamped within valid range in the @return struct."]
#[doc = " This function never fails (wide contract)"]
pub fn ZSTD_adjustCParams(
cPar: ZSTD_compressionParameters,
srcSize: libc::c_ulonglong,
dictSize: usize,
) -> ZSTD_compressionParameters;
}
extern "C" {
#[doc = " ZSTD_compress_advanced() :"]
#[doc = " Note : this function is now DEPRECATED."]
#[doc = " It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_setParameter() and other parameter setters."]
#[doc = " This prototype will be marked as deprecated and generate compilation warning on reaching v1.5.x"]
pub fn ZSTD_compress_advanced(
cctx: *mut ZSTD_CCtx,
dst: *mut libc::c_void,
dstCapacity: usize,
src: *const libc::c_void,
srcSize: usize,
dict: *const libc::c_void,
dictSize: usize,
params: ZSTD_parameters,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_compress_usingCDict_advanced() :"]
#[doc = " Note : this function is now REDUNDANT."]
#[doc = " It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_loadDictionary() and other parameter setters."]
#[doc = " This prototype will be marked as deprecated and generate compilation warning in some future version"]
pub fn ZSTD_compress_usingCDict_advanced(
cctx: *mut ZSTD_CCtx,
dst: *mut libc::c_void,
dstCapacity: usize,
src: *const libc::c_void,
srcSize: usize,
cdict: *const ZSTD_CDict,
fParams: ZSTD_frameParameters,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_CCtx_loadDictionary_byReference() :"]
#[doc = " Same as ZSTD_CCtx_loadDictionary(), but dictionary content is referenced, instead of being copied into CCtx."]
#[doc = " It saves some memory, but also requires that `dict` outlives its usage within `cctx`"]
pub fn ZSTD_CCtx_loadDictionary_byReference(
cctx: *mut ZSTD_CCtx,
dict: *const libc::c_void,
dictSize: usize,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_CCtx_loadDictionary_advanced() :"]
#[doc = " Same as ZSTD_CCtx_loadDictionary(), but gives finer control over"]
#[doc = " how to load the dictionary (by copy ? by reference ?)"]
#[doc = " and how to interpret it (automatic ? force raw mode ? full mode only ?)"]
pub fn ZSTD_CCtx_loadDictionary_advanced(
cctx: *mut ZSTD_CCtx,
dict: *const libc::c_void,
dictSize: usize,
dictLoadMethod: ZSTD_dictLoadMethod_e,
dictContentType: ZSTD_dictContentType_e,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_CCtx_refPrefix_advanced() :"]
#[doc = " Same as ZSTD_CCtx_refPrefix(), but gives finer control over"]
#[doc = " how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?)"]
pub fn ZSTD_CCtx_refPrefix_advanced(
cctx: *mut ZSTD_CCtx,
prefix: *const libc::c_void,
prefixSize: usize,
dictContentType: ZSTD_dictContentType_e,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_CCtx_getParameter() :"]
#[doc = " Get the requested compression parameter value, selected by enum ZSTD_cParameter,"]
#[doc = " and store it into int* value."]
#[doc = " @return : 0, or an error code (which can be tested with ZSTD_isError())."]
pub fn ZSTD_CCtx_getParameter(
cctx: *mut ZSTD_CCtx,
param: ZSTD_cParameter,
value: *mut libc::c_int,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_CCtx_params :"]
#[doc = " Quick howto :"]
#[doc = " - ZSTD_createCCtxParams() : Create a ZSTD_CCtx_params structure"]
#[doc = " - ZSTD_CCtxParams_setParameter() : Push parameters one by one into"]
#[doc = " an existing ZSTD_CCtx_params structure."]
#[doc = " This is similar to"]
#[doc = " ZSTD_CCtx_setParameter()."]
#[doc = " - ZSTD_CCtx_setParametersUsingCCtxParams() : Apply parameters to"]
#[doc = " an existing CCtx."]
#[doc = " These parameters will be applied to"]
#[doc = " all subsequent frames."]
#[doc = " - ZSTD_compressStream2() : Do compression using the CCtx."]
#[doc = " - ZSTD_freeCCtxParams() : Free the memory."]
#[doc = ""]
#[doc = " This can be used with ZSTD_estimateCCtxSize_advanced_usingCCtxParams()"]
#[doc = " for static allocation of CCtx for single-threaded compression."]
pub fn ZSTD_createCCtxParams() -> *mut ZSTD_CCtx_params;
}
extern "C" {
pub fn ZSTD_freeCCtxParams(params: *mut ZSTD_CCtx_params) -> usize;
}
extern "C" {
#[doc = " ZSTD_CCtxParams_reset() :"]
#[doc = " Reset params to default values."]
pub fn ZSTD_CCtxParams_reset(params: *mut ZSTD_CCtx_params) -> usize;
}
extern "C" {
#[doc = " ZSTD_CCtxParams_init() :"]
#[doc = " Initializes the compression parameters of cctxParams according to"]
#[doc = " compression level. All other parameters are reset to their default values."]
pub fn ZSTD_CCtxParams_init(
cctxParams: *mut ZSTD_CCtx_params,
compressionLevel: libc::c_int,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_CCtxParams_init_advanced() :"]
#[doc = " Initializes the compression and frame parameters of cctxParams according to"]
#[doc = " params. All other parameters are reset to their default values."]
pub fn ZSTD_CCtxParams_init_advanced(
cctxParams: *mut ZSTD_CCtx_params,
params: ZSTD_parameters,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_CCtxParams_setParameter() :"]
#[doc = " Similar to ZSTD_CCtx_setParameter."]
#[doc = " Set one compression parameter, selected by enum ZSTD_cParameter."]
#[doc = " Parameters must be applied to a ZSTD_CCtx using"]
#[doc = " ZSTD_CCtx_setParametersUsingCCtxParams()."]
#[doc = " @result : a code representing success or failure (which can be tested with"]
#[doc = " ZSTD_isError())."]
pub fn ZSTD_CCtxParams_setParameter(
params: *mut ZSTD_CCtx_params,
param: ZSTD_cParameter,
value: libc::c_int,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_CCtxParams_getParameter() :"]
#[doc = " Similar to ZSTD_CCtx_getParameter."]
#[doc = " Get the requested value of one compression parameter, selected by enum ZSTD_cParameter."]
#[doc = " @result : 0, or an error code (which can be tested with ZSTD_isError())."]
pub fn ZSTD_CCtxParams_getParameter(
params: *mut ZSTD_CCtx_params,
param: ZSTD_cParameter,
value: *mut libc::c_int,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_CCtx_setParametersUsingCCtxParams() :"]
#[doc = " Apply a set of ZSTD_CCtx_params to the compression context."]
#[doc = " This can be done even after compression is started,"]
#[doc = " if nbWorkers==0, this will have no impact until a new compression is started."]
#[doc = " if nbWorkers>=1, new parameters will be picked up at next job,"]
#[doc = " with a few restrictions (windowLog, pledgedSrcSize, nbWorkers, jobSize, and overlapLog are not updated)."]
pub fn ZSTD_CCtx_setParametersUsingCCtxParams(
cctx: *mut ZSTD_CCtx,
params: *const ZSTD_CCtx_params,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_compressStream2_simpleArgs() :"]
#[doc = " Same as ZSTD_compressStream2(),"]
#[doc = " but using only integral types as arguments."]
#[doc = " This variant might be helpful for binders from dynamic languages"]
#[doc = " which have troubles handling structures containing memory pointers."]
pub fn ZSTD_compressStream2_simpleArgs(
cctx: *mut ZSTD_CCtx,
dst: *mut libc::c_void,
dstCapacity: usize,
dstPos: *mut usize,
src: *const libc::c_void,
srcSize: usize,
srcPos: *mut usize,
endOp: ZSTD_EndDirective,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_isFrame() :"]
#[doc = " Tells if the content of `buffer` starts with a valid Frame Identifier."]
#[doc = " Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0."]
#[doc = " Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled."]
#[doc = " Note 3 : Skippable Frame Identifiers are considered valid."]
pub fn ZSTD_isFrame(
buffer: *const libc::c_void,
size: usize,
) -> libc::c_uint;
}
extern "C" {
#[doc = " ZSTD_createDDict_byReference() :"]
#[doc = " Create a digested dictionary, ready to start decompression operation without startup delay."]
#[doc = " Dictionary content is referenced, and therefore stays in dictBuffer."]
#[doc = " It is important that dictBuffer outlives DDict,"]
#[doc = " it must remain read accessible throughout the lifetime of DDict"]
pub fn ZSTD_createDDict_byReference(
dictBuffer: *const libc::c_void,
dictSize: usize,
) -> *mut ZSTD_DDict;
}
extern "C" {
#[doc = " ZSTD_DCtx_loadDictionary_byReference() :"]
#[doc = " Same as ZSTD_DCtx_loadDictionary(),"]
#[doc = " but references `dict` content instead of copying it into `dctx`."]
#[doc = " This saves memory if `dict` remains around.,"]
#[doc = " However, it's imperative that `dict` remains accessible (and unmodified) while being used, so it must outlive decompression."]
pub fn ZSTD_DCtx_loadDictionary_byReference(
dctx: *mut ZSTD_DCtx,
dict: *const libc::c_void,
dictSize: usize,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_DCtx_loadDictionary_advanced() :"]
#[doc = " Same as ZSTD_DCtx_loadDictionary(),"]
#[doc = " but gives direct control over"]
#[doc = " how to load the dictionary (by copy ? by reference ?)"]
#[doc = " and how to interpret it (automatic ? force raw mode ? full mode only ?)."]
pub fn ZSTD_DCtx_loadDictionary_advanced(
dctx: *mut ZSTD_DCtx,
dict: *const libc::c_void,
dictSize: usize,
dictLoadMethod: ZSTD_dictLoadMethod_e,
dictContentType: ZSTD_dictContentType_e,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_DCtx_refPrefix_advanced() :"]
#[doc = " Same as ZSTD_DCtx_refPrefix(), but gives finer control over"]
#[doc = " how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?)"]
pub fn ZSTD_DCtx_refPrefix_advanced(
dctx: *mut ZSTD_DCtx,
prefix: *const libc::c_void,
prefixSize: usize,
dictContentType: ZSTD_dictContentType_e,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_DCtx_setMaxWindowSize() :"]
#[doc = " Refuses allocating internal buffers for frames requiring a window size larger than provided limit."]
#[doc = " This protects a decoder context from reserving too much memory for itself (potential attack scenario)."]
#[doc = " This parameter is only useful in streaming mode, since no internal buffer is allocated in single-pass mode."]
#[doc = " By default, a decompression context accepts all window sizes <= (1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT)"]
#[doc = " @return : 0, or an error code (which can be tested using ZSTD_isError())."]
pub fn ZSTD_DCtx_setMaxWindowSize(
dctx: *mut ZSTD_DCtx,
maxWindowSize: usize,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_DCtx_getParameter() :"]
#[doc = " Get the requested decompression parameter value, selected by enum ZSTD_dParameter,"]
#[doc = " and store it into int* value."]
#[doc = " @return : 0, or an error code (which can be tested with ZSTD_isError())."]
pub fn ZSTD_DCtx_getParameter(
dctx: *mut ZSTD_DCtx,
param: ZSTD_dParameter,
value: *mut libc::c_int,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_DCtx_setFormat() :"]
#[doc = " Instruct the decoder context about what kind of data to decode next."]
#[doc = " This instruction is mandatory to decode data without a fully-formed header,"]
#[doc = " such ZSTD_f_zstd1_magicless for example."]
#[doc = " @return : 0, or an error code (which can be tested using ZSTD_isError())."]
pub fn ZSTD_DCtx_setFormat(
dctx: *mut ZSTD_DCtx,
format: ZSTD_format_e,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_decompressStream_simpleArgs() :"]
#[doc = " Same as ZSTD_decompressStream(),"]
#[doc = " but using only integral types as arguments."]
#[doc = " This can be helpful for binders from dynamic languages"]
#[doc = " which have troubles handling structures containing memory pointers."]
pub fn ZSTD_decompressStream_simpleArgs(
dctx: *mut ZSTD_DCtx,
dst: *mut libc::c_void,
dstCapacity: usize,
dstPos: *mut usize,
src: *const libc::c_void,
srcSize: usize,
srcPos: *mut usize,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_initCStream_srcSize() :"]
#[doc = " This function is deprecated, and equivalent to:"]
#[doc = " ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);"]
#[doc = " ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any)"]
#[doc = " ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);"]
#[doc = " ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);"]
#[doc = ""]
#[doc = " pledgedSrcSize must be correct. If it is not known at init time, use"]
#[doc = " ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs,"]
#[doc = " \"0\" also disables frame content size field. It may be enabled in the future."]
#[doc = " Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"]
pub fn ZSTD_initCStream_srcSize(
zcs: *mut ZSTD_CStream,
compressionLevel: libc::c_int,
pledgedSrcSize: libc::c_ulonglong,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_initCStream_usingDict() :"]
#[doc = " This function is deprecated, and is equivalent to:"]
#[doc = " ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);"]
#[doc = " ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);"]
#[doc = " ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);"]
#[doc = ""]
#[doc = " Creates of an internal CDict (incompatible with static CCtx), except if"]
#[doc = " dict == NULL or dictSize < 8, in which case no dict is used."]
#[doc = " Note: dict is loaded with ZSTD_dct_auto (treated as a full zstd dictionary if"]
#[doc = " it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy."]
#[doc = " Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"]
pub fn ZSTD_initCStream_usingDict(
zcs: *mut ZSTD_CStream,
dict: *const libc::c_void,
dictSize: usize,
compressionLevel: libc::c_int,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_initCStream_advanced() :"]
#[doc = " This function is deprecated, and is approximately equivalent to:"]
#[doc = " ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);"]
#[doc = " // Pseudocode: Set each zstd parameter and leave the rest as-is."]
#[doc = " for ((param, value) : params) {"]
#[doc = " ZSTD_CCtx_setParameter(zcs, param, value);"]
#[doc = " }"]
#[doc = " ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);"]
#[doc = " ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);"]
#[doc = ""]
#[doc = " dict is loaded with ZSTD_dct_auto and ZSTD_dlm_byCopy."]
#[doc = " pledgedSrcSize must be correct."]
#[doc = " If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN."]
#[doc = " Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"]
pub fn ZSTD_initCStream_advanced(
zcs: *mut ZSTD_CStream,
dict: *const libc::c_void,
dictSize: usize,
params: ZSTD_parameters,
pledgedSrcSize: libc::c_ulonglong,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_initCStream_usingCDict() :"]
#[doc = " This function is deprecated, and equivalent to:"]
#[doc = " ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);"]
#[doc = " ZSTD_CCtx_refCDict(zcs, cdict);"]
#[doc = ""]
#[doc = " note : cdict will just be referenced, and must outlive compression session"]
#[doc = " Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"]
pub fn ZSTD_initCStream_usingCDict(
zcs: *mut ZSTD_CStream,
cdict: *const ZSTD_CDict,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_initCStream_usingCDict_advanced() :"]
#[doc = " This function is DEPRECATED, and is approximately equivalent to:"]
#[doc = " ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);"]
#[doc = " // Pseudocode: Set each zstd frame parameter and leave the rest as-is."]
#[doc = " for ((fParam, value) : fParams) {"]
#[doc = " ZSTD_CCtx_setParameter(zcs, fParam, value);"]
#[doc = " }"]
#[doc = " ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);"]
#[doc = " ZSTD_CCtx_refCDict(zcs, cdict);"]
#[doc = ""]
#[doc = " same as ZSTD_initCStream_usingCDict(), with control over frame parameters."]
#[doc = " pledgedSrcSize must be correct. If srcSize is not known at init time, use"]
#[doc = " value ZSTD_CONTENTSIZE_UNKNOWN."]
#[doc = " Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"]
pub fn ZSTD_initCStream_usingCDict_advanced(
zcs: *mut ZSTD_CStream,
cdict: *const ZSTD_CDict,
fParams: ZSTD_frameParameters,
pledgedSrcSize: libc::c_ulonglong,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_resetCStream() :"]
#[doc = " This function is deprecated, and is equivalent to:"]
#[doc = " ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);"]
#[doc = " ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);"]
#[doc = ""]
#[doc = " start a new frame, using same parameters from previous frame."]
#[doc = " This is typically useful to skip dictionary loading stage, since it will re-use it in-place."]
#[doc = " Note that zcs must be init at least once before using ZSTD_resetCStream()."]
#[doc = " If pledgedSrcSize is not known at reset time, use macro ZSTD_CONTENTSIZE_UNKNOWN."]
#[doc = " If pledgedSrcSize > 0, its value must be correct, as it will be written in header, and controlled at the end."]
#[doc = " For the time being, pledgedSrcSize==0 is interpreted as \"srcSize unknown\" for compatibility with older programs,"]
#[doc = " but it will change to mean \"empty\" in future version, so use macro ZSTD_CONTENTSIZE_UNKNOWN instead."]
#[doc = " @return : 0, or an error code (which can be tested using ZSTD_isError())"]
#[doc = " Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"]
pub fn ZSTD_resetCStream(
zcs: *mut ZSTD_CStream,
pledgedSrcSize: libc::c_ulonglong,
) -> usize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_frameProgression {
pub ingested: libc::c_ulonglong,
pub consumed: libc::c_ulonglong,
pub produced: libc::c_ulonglong,
pub flushed: libc::c_ulonglong,
pub currentJobID: libc::c_uint,
pub nbActiveWorkers: libc::c_uint,
}
#[test]
fn bindgen_test_layout_ZSTD_frameProgression() {
assert_eq!(
::core::mem::size_of::<ZSTD_frameProgression>(),
40usize,
concat!("Size of: ", stringify!(ZSTD_frameProgression))
);
assert_eq!(
::core::mem::align_of::<ZSTD_frameProgression>(),
8usize,
concat!("Alignment of ", stringify!(ZSTD_frameProgression))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_frameProgression>())).ingested
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_frameProgression),
"::",
stringify!(ingested)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_frameProgression>())).consumed
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_frameProgression),
"::",
stringify!(consumed)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_frameProgression>())).produced
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_frameProgression),
"::",
stringify!(produced)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_frameProgression>())).flushed
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_frameProgression),
"::",
stringify!(flushed)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_frameProgression>())).currentJobID
as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_frameProgression),
"::",
stringify!(currentJobID)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_frameProgression>())).nbActiveWorkers
as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_frameProgression),
"::",
stringify!(nbActiveWorkers)
)
);
}
extern "C" {
pub fn ZSTD_getFrameProgression(
cctx: *const ZSTD_CCtx,
) -> ZSTD_frameProgression;
}
extern "C" {
#[doc = " ZSTD_toFlushNow() :"]
#[doc = " Tell how many bytes are ready to be flushed immediately."]
#[doc = " Useful for multithreading scenarios (nbWorkers >= 1)."]
#[doc = " Probe the oldest active job, defined as oldest job not yet entirely flushed,"]
#[doc = " and check its output buffer."]
#[doc = " @return : amount of data stored in oldest job and ready to be flushed immediately."]
#[doc = " if @return == 0, it means either :"]
#[doc = " + there is no active job (could be checked with ZSTD_frameProgression()), or"]
#[doc = " + oldest job is still actively compressing data,"]
#[doc = " but everything it has produced has also been flushed so far,"]
#[doc = " therefore flush speed is limited by production speed of oldest job"]
#[doc = " irrespective of the speed of concurrent (and newer) jobs."]
pub fn ZSTD_toFlushNow(cctx: *mut ZSTD_CCtx) -> usize;
}
extern "C" {
#[doc = " This function is deprecated, and is equivalent to:"]
#[doc = ""]
#[doc = " ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);"]
#[doc = " ZSTD_DCtx_loadDictionary(zds, dict, dictSize);"]
#[doc = ""]
#[doc = " note: no dictionary will be used if dict == NULL or dictSize < 8"]
#[doc = " Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"]
pub fn ZSTD_initDStream_usingDict(
zds: *mut ZSTD_DStream,
dict: *const libc::c_void,
dictSize: usize,
) -> usize;
}
extern "C" {
#[doc = " This function is deprecated, and is equivalent to:"]
#[doc = ""]
#[doc = " ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);"]
#[doc = " ZSTD_DCtx_refDDict(zds, ddict);"]
#[doc = ""]
#[doc = " note : ddict is referenced, it must outlive decompression session"]
#[doc = " Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"]
pub fn ZSTD_initDStream_usingDDict(
zds: *mut ZSTD_DStream,
ddict: *const ZSTD_DDict,
) -> usize;
}
extern "C" {
#[doc = " This function is deprecated, and is equivalent to:"]
#[doc = ""]
#[doc = " ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);"]
#[doc = ""]
#[doc = " re-use decompression parameters from previous init; saves dictionary loading"]
#[doc = " Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x"]
pub fn ZSTD_resetDStream(zds: *mut ZSTD_DStream) -> usize;
}
extern "C" {
#[doc = "Buffer-less streaming compression (synchronous mode)"]
#[doc = ""]
#[doc = "A ZSTD_CCtx object is required to track streaming operations."]
#[doc = "Use ZSTD_createCCtx() / ZSTD_freeCCtx() to manage resource."]
#[doc = "ZSTD_CCtx object can be re-used multiple times within successive compression operations."]
#[doc = ""]
#[doc = "Start by initializing a context."]
#[doc = "Use ZSTD_compressBegin(), or ZSTD_compressBegin_usingDict() for dictionary compression,"]
#[doc = "or ZSTD_compressBegin_advanced(), for finer parameter control."]
#[doc = "It's also possible to duplicate a reference context which has already been initialized, using ZSTD_copyCCtx()"]
#[doc = ""]
#[doc = "Then, consume your input using ZSTD_compressContinue()."]
#[doc = "There are some important considerations to keep in mind when using this advanced function :"]
#[doc = "- ZSTD_compressContinue() has no internal buffer. It uses externally provided buffers only."]
#[doc = "- Interface is synchronous : input is consumed entirely and produces 1+ compressed blocks."]
#[doc = "- Caller must ensure there is enough space in `dst` to store compressed data under worst case scenario."]
#[doc = "Worst case evaluation is provided by ZSTD_compressBound()."]
#[doc = "ZSTD_compressContinue() doesn't guarantee recover after a failed compression."]
#[doc = "- ZSTD_compressContinue() presumes prior input ***is still accessible and unmodified*** (up to maximum distance size, see WindowLog)."]
#[doc = "It remembers all previous contiguous blocks, plus one separated memory segment (which can itself consists of multiple contiguous blocks)"]
#[doc = "- ZSTD_compressContinue() detects that prior input has been overwritten when `src` buffer overlaps."]
#[doc = "In which case, it will \"discard\" the relevant memory section from its history."]
#[doc = ""]
#[doc = "Finish a frame with ZSTD_compressEnd(), which will write the last block(s) and optional checksum."]
#[doc = "It's possible to use srcSize==0, in which case, it will write a final empty block to end the frame."]
#[doc = "Without last block mark, frames are considered unfinished (hence corrupted) by compliant decoders."]
#[doc = ""]
#[doc = "`ZSTD_CCtx` object can be re-used (ZSTD_compressBegin()) to compress again."]
pub fn ZSTD_compressBegin(
cctx: *mut ZSTD_CCtx,
compressionLevel: libc::c_int,
) -> usize;
}
extern "C" {
pub fn ZSTD_compressBegin_usingDict(
cctx: *mut ZSTD_CCtx,
dict: *const libc::c_void,
dictSize: usize,
compressionLevel: libc::c_int,
) -> usize;
}
extern "C" {
pub fn ZSTD_compressBegin_advanced(
cctx: *mut ZSTD_CCtx,
dict: *const libc::c_void,
dictSize: usize,
params: ZSTD_parameters,
pledgedSrcSize: libc::c_ulonglong,
) -> usize;
}
extern "C" {
pub fn ZSTD_compressBegin_usingCDict(
cctx: *mut ZSTD_CCtx,
cdict: *const ZSTD_CDict,
) -> usize;
}
extern "C" {
pub fn ZSTD_compressBegin_usingCDict_advanced(
cctx: *mut ZSTD_CCtx,
cdict: *const ZSTD_CDict,
fParams: ZSTD_frameParameters,
pledgedSrcSize: libc::c_ulonglong,
) -> usize;
}
extern "C" {
pub fn ZSTD_copyCCtx(
cctx: *mut ZSTD_CCtx,
preparedCCtx: *const ZSTD_CCtx,
pledgedSrcSize: libc::c_ulonglong,
) -> usize;
}
extern "C" {
pub fn ZSTD_compressContinue(
cctx: *mut ZSTD_CCtx,
dst: *mut libc::c_void,
dstCapacity: usize,
src: *const libc::c_void,
srcSize: usize,
) -> usize;
}
extern "C" {
pub fn ZSTD_compressEnd(
cctx: *mut ZSTD_CCtx,
dst: *mut libc::c_void,
dstCapacity: usize,
src: *const libc::c_void,
srcSize: usize,
) -> usize;
}
#[repr(u32)]
#[doc = "Buffer-less streaming decompression (synchronous mode)"]
#[doc = ""]
#[doc = "A ZSTD_DCtx object is required to track streaming operations."]
#[doc = "Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it."]
#[doc = "A ZSTD_DCtx object can be re-used multiple times."]
#[doc = ""]
#[doc = "First typical operation is to retrieve frame parameters, using ZSTD_getFrameHeader()."]
#[doc = "Frame header is extracted from the beginning of compressed frame, so providing only the frame's beginning is enough."]
#[doc = "Data fragment must be large enough to ensure successful decoding."]
#[doc = "`ZSTD_frameHeaderSize_max` bytes is guaranteed to always be large enough."]
#[doc = "@result : 0 : successful decoding, the `ZSTD_frameHeader` structure is correctly filled."]
#[doc = ">0 : `srcSize` is too small, please provide at least @result bytes on next attempt."]
#[doc = "errorCode, which can be tested using ZSTD_isError()."]
#[doc = ""]
#[doc = "It fills a ZSTD_frameHeader structure with important information to correctly decode the frame,"]
#[doc = "such as the dictionary ID, content size, or maximum back-reference distance (`windowSize`)."]
#[doc = "Note that these values could be wrong, either because of data corruption, or because a 3rd party deliberately spoofs false information."]
#[doc = "As a consequence, check that values remain within valid application range."]
#[doc = "For example, do not allocate memory blindly, check that `windowSize` is within expectation."]
#[doc = "Each application can set its own limits, depending on local restrictions."]
#[doc = "For extended interoperability, it is recommended to support `windowSize` of at least 8 MB."]
#[doc = ""]
#[doc = "ZSTD_decompressContinue() needs previous data blocks during decompression, up to `windowSize` bytes."]
#[doc = "ZSTD_decompressContinue() is very sensitive to contiguity,"]
#[doc = "if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place,"]
#[doc = "or that previous contiguous segment is large enough to properly handle maximum back-reference distance."]
#[doc = "There are multiple ways to guarantee this condition."]
#[doc = ""]
#[doc = "The most memory efficient way is to use a round buffer of sufficient size."]
#[doc = "Sufficient size is determined by invoking ZSTD_decodingBufferSize_min(),"]
#[doc = "which can @return an error code if required value is too large for current system (in 32-bits mode)."]
#[doc = "In a round buffer methodology, ZSTD_decompressContinue() decompresses each block next to previous one,"]
#[doc = "up to the moment there is not enough room left in the buffer to guarantee decoding another full block,"]
#[doc = "which maximum size is provided in `ZSTD_frameHeader` structure, field `blockSizeMax`."]
#[doc = "At which point, decoding can resume from the beginning of the buffer."]
#[doc = "Note that already decoded data stored in the buffer should be flushed before being overwritten."]
#[doc = ""]
#[doc = "There are alternatives possible, for example using two or more buffers of size `windowSize` each, though they consume more memory."]
#[doc = ""]
#[doc = "Finally, if you control the compression process, you can also ignore all buffer size rules,"]
#[doc = "as long as the encoder and decoder progress in \"lock-step\","]
#[doc = "aka use exactly the same buffer sizes, break contiguity at the same place, etc."]
#[doc = ""]
#[doc = "Once buffers are setup, start decompression, with ZSTD_decompressBegin()."]
#[doc = "If decompression requires a dictionary, use ZSTD_decompressBegin_usingDict() or ZSTD_decompressBegin_usingDDict()."]
#[doc = ""]
#[doc = "Then use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively."]
#[doc = "ZSTD_nextSrcSizeToDecompress() tells how many bytes to provide as 'srcSize' to ZSTD_decompressContinue()."]
#[doc = "ZSTD_decompressContinue() requires this _exact_ amount of bytes, or it will fail."]
#[doc = ""]
#[doc = "@result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity)."]
#[doc = "It can be zero : it just means ZSTD_decompressContinue() has decoded some metadata item."]
#[doc = "It can also be an error code, which can be tested with ZSTD_isError()."]
#[doc = ""]
#[doc = "A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero."]
#[doc = "Context can then be reset to start a new decompression."]
#[doc = ""]
#[doc = "Note : it's possible to know if next input to present is a header or a block, using ZSTD_nextInputType()."]
#[doc = "This information is not required to properly decode a frame."]
#[doc = ""]
#[doc = "== Special case : skippable frames =="]
#[doc = ""]
#[doc = "Skippable frames allow integration of user-defined data into a flow of concatenated frames."]
#[doc = "Skippable frames will be ignored (skipped) by decompressor."]
#[doc = "The format of skippable frames is as follows :"]
#[doc = "a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F"]
#[doc = "b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits"]
#[doc = "c) Frame Content - any content (User Data) of length equal to Frame Size"]
#[doc = "For skippable frames ZSTD_getFrameHeader() returns zfhPtr->frameType==ZSTD_skippableFrame."]
#[doc = "For skippable frames ZSTD_decompressContinue() always returns 0 : it only skips the content."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ZSTD_frameType_e {
ZSTD_frame = 0,
ZSTD_skippableFrame = 1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_frameHeader {
pub frameContentSize: libc::c_ulonglong,
pub windowSize: libc::c_ulonglong,
pub blockSizeMax: libc::c_uint,
pub frameType: ZSTD_frameType_e,
pub headerSize: libc::c_uint,
pub dictID: libc::c_uint,
pub checksumFlag: libc::c_uint,
}
#[test]
fn bindgen_test_layout_ZSTD_frameHeader() {
assert_eq!(
::core::mem::size_of::<ZSTD_frameHeader>(),
40usize,
concat!("Size of: ", stringify!(ZSTD_frameHeader))
);
assert_eq!(
::core::mem::align_of::<ZSTD_frameHeader>(),
8usize,
concat!("Alignment of ", stringify!(ZSTD_frameHeader))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_frameHeader>())).frameContentSize
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_frameHeader),
"::",
stringify!(frameContentSize)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_frameHeader>())).windowSize
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_frameHeader),
"::",
stringify!(windowSize)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_frameHeader>())).blockSizeMax
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_frameHeader),
"::",
stringify!(blockSizeMax)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_frameHeader>())).frameType as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_frameHeader),
"::",
stringify!(frameType)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_frameHeader>())).headerSize
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_frameHeader),
"::",
stringify!(headerSize)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_frameHeader>())).dictID as *const _
as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_frameHeader),
"::",
stringify!(dictID)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZSTD_frameHeader>())).checksumFlag
as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_frameHeader),
"::",
stringify!(checksumFlag)
)
);
}
extern "C" {
#[doc = " ZSTD_getFrameHeader() :"]
#[doc = " decode Frame Header, or requires larger `srcSize`."]
#[doc = " @return : 0, `zfhPtr` is correctly filled,"]
#[doc = " >0, `srcSize` is too small, value is wanted `srcSize` amount,"]
#[doc = " or an error code, which can be tested using ZSTD_isError()"]
pub fn ZSTD_getFrameHeader(
zfhPtr: *mut ZSTD_frameHeader,
src: *const libc::c_void,
srcSize: usize,
) -> usize;
}
extern "C" {
#[doc = " ZSTD_getFrameHeader_advanced() :"]
#[doc = " same as ZSTD_getFrameHeader(),"]
#[doc = " with added capability to select a format (like ZSTD_f_zstd1_magicless)"]
pub fn ZSTD_getFrameHeader_advanced(
zfhPtr: *mut ZSTD_frameHeader,
src: *const libc::c_void,
srcSize: usize,
format: ZSTD_format_e,
) -> usize;
}
extern "C" {
pub fn ZSTD_decodingBufferSize_min(
windowSize: libc::c_ulonglong,
frameContentSize: libc::c_ulonglong,
) -> usize;
}
extern "C" {
pub fn ZSTD_decompressBegin(dctx: *mut ZSTD_DCtx) -> usize;
}
extern "C" {
pub fn ZSTD_decompressBegin_usingDict(
dctx: *mut ZSTD_DCtx,
dict: *const libc::c_void,
dictSize: usize,
) -> usize;
}
extern "C" {
pub fn ZSTD_decompressBegin_usingDDict(
dctx: *mut ZSTD_DCtx,
ddict: *const ZSTD_DDict,
) -> usize;
}
extern "C" {
pub fn ZSTD_nextSrcSizeToDecompress(dctx: *mut ZSTD_DCtx) -> usize;
}
extern "C" {
pub fn ZSTD_decompressContinue(
dctx: *mut ZSTD_DCtx,
dst: *mut libc::c_void,
dstCapacity: usize,
src: *const libc::c_void,
srcSize: usize,
) -> usize;
}
extern "C" {
pub fn ZSTD_copyDCtx(dctx: *mut ZSTD_DCtx, preparedDCtx: *const ZSTD_DCtx);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ZSTD_nextInputType_e {
ZSTDnit_frameHeader = 0,
ZSTDnit_blockHeader = 1,
ZSTDnit_block = 2,
ZSTDnit_lastBlock = 3,
ZSTDnit_checksum = 4,
ZSTDnit_skippableFrame = 5,
}
extern "C" {
pub fn ZSTD_nextInputType(dctx: *mut ZSTD_DCtx) -> ZSTD_nextInputType_e;
}
extern "C" {
#[doc = "Block functions produce and decode raw zstd blocks, without frame metadata."]
#[doc = "Frame metadata cost is typically ~12 bytes, which can be non-negligible for very small blocks (< 100 bytes)."]
#[doc = "But users will have to take in charge needed metadata to regenerate data, such as compressed and content sizes."]
#[doc = ""]
#[doc = "A few rules to respect :"]
#[doc = "- Compressing and decompressing require a context structure"]
#[doc = "+ Use ZSTD_createCCtx() and ZSTD_createDCtx()"]
#[doc = "- It is necessary to init context before starting"]
#[doc = "+ compression : any ZSTD_compressBegin*() variant, including with dictionary"]
#[doc = "+ decompression : any ZSTD_decompressBegin*() variant, including with dictionary"]
#[doc = "+ copyCCtx() and copyDCtx() can be used too"]
#[doc = "- Block size is limited, it must be <= ZSTD_getBlockSize() <= ZSTD_BLOCKSIZE_MAX == 128 KB"]
#[doc = "+ If input is larger than a block size, it's necessary to split input data into multiple blocks"]
#[doc = "+ For inputs larger than a single block, consider using regular ZSTD_compress() instead."]
#[doc = "Frame metadata is not that costly, and quickly becomes negligible as source size grows larger than a block."]
#[doc = "- When a block is considered not compressible enough, ZSTD_compressBlock() result will be 0 (zero) !"]
#[doc = "===> In which case, nothing is produced into `dst` !"]
#[doc = "+ User __must__ test for such outcome and deal directly with uncompressed data"]
#[doc = "+ A block cannot be declared incompressible if ZSTD_compressBlock() return value was != 0."]
#[doc = "Doing so would mess up with statistics history, leading to potential data corruption."]
#[doc = "+ ZSTD_decompressBlock() _doesn't accept uncompressed data as input_ !!"]
#[doc = "+ In case of multiple successive blocks, should some of them be uncompressed,"]
#[doc = "decoder must be informed of their existence in order to follow proper history."]
#[doc = "Use ZSTD_insertBlock() for such a case."]
pub fn ZSTD_getBlockSize(cctx: *const ZSTD_CCtx) -> usize;
}
extern "C" {
pub fn ZSTD_compressBlock(
cctx: *mut ZSTD_CCtx,
dst: *mut libc::c_void,
dstCapacity: usize,
src: *const libc::c_void,
srcSize: usize,
) -> usize;
}
extern "C" {
pub fn ZSTD_decompressBlock(
dctx: *mut ZSTD_DCtx,
dst: *mut libc::c_void,
dstCapacity: usize,
src: *const libc::c_void,
srcSize: usize,
) -> usize;
}
extern "C" {
pub fn ZSTD_insertBlock(
dctx: *mut ZSTD_DCtx,
blockStart: *const libc::c_void,
blockSize: usize,
) -> usize;
}
extern "C" {
#[doc = " ZDICT_trainFromBuffer():"]
#[doc = " Train a dictionary from an array of samples."]
#[doc = " Redirect towards ZDICT_optimizeTrainFromBuffer_fastCover() single-threaded, with d=8, steps=4,"]
#[doc = " f=20, and accel=1."]
#[doc = " Samples must be stored concatenated in a single flat buffer `samplesBuffer`,"]
#[doc = " supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order."]
#[doc = " The resulting dictionary will be saved into `dictBuffer`."]
#[doc = " @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)"]
#[doc = " or an error code, which can be tested with ZDICT_isError()."]
#[doc = " Note: Dictionary training will fail if there are not enough samples to construct a"]
#[doc = " dictionary, or if most of the samples are too small (< 8 bytes being the lower limit)."]
#[doc = " If dictionary training fails, you should use zstd without a dictionary, as the dictionary"]
#[doc = " would've been ineffective anyways. If you believe your samples would benefit from a dictionary"]
#[doc = " please open an issue with details, and we can look into it."]
#[doc = " Note: ZDICT_trainFromBuffer()'s memory usage is about 6 MB."]
#[doc = " Tips: In general, a reasonable dictionary has a size of ~ 100 KB."]
#[doc = " It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`."]
#[doc = " In general, it's recommended to provide a few thousands samples, though this can vary a lot."]
#[doc = " It's recommended that total size of all samples be about ~x100 times the target size of dictionary."]
pub fn ZDICT_trainFromBuffer(
dictBuffer: *mut libc::c_void,
dictBufferCapacity: usize,
samplesBuffer: *const libc::c_void,
samplesSizes: *const usize,
nbSamples: libc::c_uint,
) -> usize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZDICT_params_t {
pub compressionLevel: libc::c_int,
pub notificationLevel: libc::c_uint,
pub dictID: libc::c_uint,
}
#[test]
fn bindgen_test_layout_ZDICT_params_t() {
assert_eq!(
::core::mem::size_of::<ZDICT_params_t>(),
12usize,
concat!("Size of: ", stringify!(ZDICT_params_t))
);
assert_eq!(
::core::mem::align_of::<ZDICT_params_t>(),
4usize,
concat!("Alignment of ", stringify!(ZDICT_params_t))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_params_t>())).compressionLevel
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_params_t),
"::",
stringify!(compressionLevel)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_params_t>())).notificationLevel
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_params_t),
"::",
stringify!(notificationLevel)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_params_t>())).dictID as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_params_t),
"::",
stringify!(dictID)
)
);
}
extern "C" {
#[doc = " ZDICT_finalizeDictionary():"]
#[doc = " Given a custom content as a basis for dictionary, and a set of samples,"]
#[doc = " finalize dictionary by adding headers and statistics according to the zstd"]
#[doc = " dictionary format."]
#[doc = ""]
#[doc = " Samples must be stored concatenated in a flat buffer `samplesBuffer`,"]
#[doc = " supplied with an array of sizes `samplesSizes`, providing the size of each"]
#[doc = " sample in order. The samples are used to construct the statistics, so they"]
#[doc = " should be representative of what you will compress with this dictionary."]
#[doc = ""]
#[doc = " The compression level can be set in `parameters`. You should pass the"]
#[doc = " compression level you expect to use in production. The statistics for each"]
#[doc = " compression level differ, so tuning the dictionary for the compression level"]
#[doc = " can help quite a bit."]
#[doc = ""]
#[doc = " You can set an explicit dictionary ID in `parameters`, or allow us to pick"]
#[doc = " a random dictionary ID for you, but we can't guarantee no collisions."]
#[doc = ""]
#[doc = " The dstDictBuffer and the dictContent may overlap, and the content will be"]
#[doc = " appended to the end of the header. If the header + the content doesn't fit in"]
#[doc = " maxDictSize the beginning of the content is truncated to make room, since it"]
#[doc = " is presumed that the most profitable content is at the end of the dictionary,"]
#[doc = " since that is the cheapest to reference."]
#[doc = ""]
#[doc = " `dictContentSize` must be >= ZDICT_CONTENTSIZE_MIN bytes."]
#[doc = " `maxDictSize` must be >= max(dictContentSize, ZSTD_DICTSIZE_MIN)."]
#[doc = ""]
#[doc = " @return: size of dictionary stored into `dstDictBuffer` (<= `maxDictSize`),"]
#[doc = " or an error code, which can be tested by ZDICT_isError()."]
#[doc = " Note: ZDICT_finalizeDictionary() will push notifications into stderr if"]
#[doc = " instructed to, using notificationLevel>0."]
#[doc = " NOTE: This function currently may fail in several edge cases including:"]
#[doc = " * Not enough samples"]
#[doc = " * Samples are uncompressible"]
#[doc = " * Samples are all exactly the same"]
pub fn ZDICT_finalizeDictionary(
dstDictBuffer: *mut libc::c_void,
maxDictSize: usize,
dictContent: *const libc::c_void,
dictContentSize: usize,
samplesBuffer: *const libc::c_void,
samplesSizes: *const usize,
nbSamples: libc::c_uint,
parameters: ZDICT_params_t,
) -> usize;
}
extern "C" {
pub fn ZDICT_getDictID(
dictBuffer: *const libc::c_void,
dictSize: usize,
) -> libc::c_uint;
}
extern "C" {
pub fn ZDICT_getDictHeaderSize(
dictBuffer: *const libc::c_void,
dictSize: usize,
) -> usize;
}
extern "C" {
pub fn ZDICT_isError(errorCode: usize) -> libc::c_uint;
}
extern "C" {
pub fn ZDICT_getErrorName(errorCode: usize) -> *const libc::c_char;
}
#[doc = " ZDICT_cover_params_t:"]
#[doc = " k and d are the only required parameters."]
#[doc = " For others, value 0 means default."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZDICT_cover_params_t {
pub k: libc::c_uint,
pub d: libc::c_uint,
pub steps: libc::c_uint,
pub nbThreads: libc::c_uint,
pub splitPoint: f64,
pub shrinkDict: libc::c_uint,
pub shrinkDictMaxRegression: libc::c_uint,
pub zParams: ZDICT_params_t,
}
#[test]
fn bindgen_test_layout_ZDICT_cover_params_t() {
assert_eq!(
::core::mem::size_of::<ZDICT_cover_params_t>(),
48usize,
concat!("Size of: ", stringify!(ZDICT_cover_params_t))
);
assert_eq!(
::core::mem::align_of::<ZDICT_cover_params_t>(),
8usize,
concat!("Alignment of ", stringify!(ZDICT_cover_params_t))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_cover_params_t>())).k as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_cover_params_t),
"::",
stringify!(k)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_cover_params_t>())).d as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_cover_params_t),
"::",
stringify!(d)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_cover_params_t>())).steps as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_cover_params_t),
"::",
stringify!(steps)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_cover_params_t>())).nbThreads
as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_cover_params_t),
"::",
stringify!(nbThreads)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_cover_params_t>())).splitPoint
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_cover_params_t),
"::",
stringify!(splitPoint)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_cover_params_t>())).shrinkDict
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_cover_params_t),
"::",
stringify!(shrinkDict)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_cover_params_t>()))
.shrinkDictMaxRegression as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_cover_params_t),
"::",
stringify!(shrinkDictMaxRegression)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_cover_params_t>())).zParams
as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_cover_params_t),
"::",
stringify!(zParams)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZDICT_fastCover_params_t {
pub k: libc::c_uint,
pub d: libc::c_uint,
pub f: libc::c_uint,
pub steps: libc::c_uint,
pub nbThreads: libc::c_uint,
pub splitPoint: f64,
pub accel: libc::c_uint,
pub shrinkDict: libc::c_uint,
pub shrinkDictMaxRegression: libc::c_uint,
pub zParams: ZDICT_params_t,
}
#[test]
fn bindgen_test_layout_ZDICT_fastCover_params_t() {
assert_eq!(
::core::mem::size_of::<ZDICT_fastCover_params_t>(),
56usize,
concat!("Size of: ", stringify!(ZDICT_fastCover_params_t))
);
assert_eq!(
::core::mem::align_of::<ZDICT_fastCover_params_t>(),
8usize,
concat!("Alignment of ", stringify!(ZDICT_fastCover_params_t))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_fastCover_params_t>())).k as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_fastCover_params_t),
"::",
stringify!(k)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_fastCover_params_t>())).d as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_fastCover_params_t),
"::",
stringify!(d)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_fastCover_params_t>())).f as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_fastCover_params_t),
"::",
stringify!(f)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_fastCover_params_t>())).steps
as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_fastCover_params_t),
"::",
stringify!(steps)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_fastCover_params_t>())).nbThreads
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_fastCover_params_t),
"::",
stringify!(nbThreads)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_fastCover_params_t>())).splitPoint
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_fastCover_params_t),
"::",
stringify!(splitPoint)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_fastCover_params_t>())).accel
as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_fastCover_params_t),
"::",
stringify!(accel)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_fastCover_params_t>())).shrinkDict
as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_fastCover_params_t),
"::",
stringify!(shrinkDict)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_fastCover_params_t>()))
.shrinkDictMaxRegression as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_fastCover_params_t),
"::",
stringify!(shrinkDictMaxRegression)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_fastCover_params_t>())).zParams
as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_fastCover_params_t),
"::",
stringify!(zParams)
)
);
}
extern "C" {
#[doc = " ZDICT_trainFromBuffer_cover():"]
#[doc = " Train a dictionary from an array of samples using the COVER algorithm."]
#[doc = " Samples must be stored concatenated in a single flat buffer `samplesBuffer`,"]
#[doc = " supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order."]
#[doc = " The resulting dictionary will be saved into `dictBuffer`."]
#[doc = " @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)"]
#[doc = " or an error code, which can be tested with ZDICT_isError()."]
#[doc = " See ZDICT_trainFromBuffer() for details on failure modes."]
#[doc = " Note: ZDICT_trainFromBuffer_cover() requires about 9 bytes of memory for each input byte."]
#[doc = " Tips: In general, a reasonable dictionary has a size of ~ 100 KB."]
#[doc = " It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`."]
#[doc = " In general, it's recommended to provide a few thousands samples, though this can vary a lot."]
#[doc = " It's recommended that total size of all samples be about ~x100 times the target size of dictionary."]
pub fn ZDICT_trainFromBuffer_cover(
dictBuffer: *mut libc::c_void,
dictBufferCapacity: usize,
samplesBuffer: *const libc::c_void,
samplesSizes: *const usize,
nbSamples: libc::c_uint,
parameters: ZDICT_cover_params_t,
) -> usize;
}
extern "C" {
#[doc = " ZDICT_optimizeTrainFromBuffer_cover():"]
#[doc = " The same requirements as above hold for all the parameters except `parameters`."]
#[doc = " This function tries many parameter combinations and picks the best parameters."]
#[doc = " `*parameters` is filled with the best parameters found,"]
#[doc = " dictionary constructed with those parameters is stored in `dictBuffer`."]
#[doc = ""]
#[doc = " All of the parameters d, k, steps are optional."]
#[doc = " If d is non-zero then we don't check multiple values of d, otherwise we check d = {6, 8}."]
#[doc = " if steps is zero it defaults to its default value."]
#[doc = " If k is non-zero then we don't check multiple values of k, otherwise we check steps values in [50, 2000]."]
#[doc = ""]
#[doc = " @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)"]
#[doc = " or an error code, which can be tested with ZDICT_isError()."]
#[doc = " On success `*parameters` contains the parameters selected."]
#[doc = " See ZDICT_trainFromBuffer() for details on failure modes."]
#[doc = " Note: ZDICT_optimizeTrainFromBuffer_cover() requires about 8 bytes of memory for each input byte and additionally another 5 bytes of memory for each byte of memory for each thread."]
pub fn ZDICT_optimizeTrainFromBuffer_cover(
dictBuffer: *mut libc::c_void,
dictBufferCapacity: usize,
samplesBuffer: *const libc::c_void,
samplesSizes: *const usize,
nbSamples: libc::c_uint,
parameters: *mut ZDICT_cover_params_t,
) -> usize;
}
extern "C" {
#[doc = " ZDICT_trainFromBuffer_fastCover():"]
#[doc = " Train a dictionary from an array of samples using a modified version of COVER algorithm."]
#[doc = " Samples must be stored concatenated in a single flat buffer `samplesBuffer`,"]
#[doc = " supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order."]
#[doc = " d and k are required."]
#[doc = " All other parameters are optional, will use default values if not provided"]
#[doc = " The resulting dictionary will be saved into `dictBuffer`."]
#[doc = " @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)"]
#[doc = " or an error code, which can be tested with ZDICT_isError()."]
#[doc = " See ZDICT_trainFromBuffer() for details on failure modes."]
#[doc = " Note: ZDICT_trainFromBuffer_fastCover() requires 6 * 2^f bytes of memory."]
#[doc = " Tips: In general, a reasonable dictionary has a size of ~ 100 KB."]
#[doc = " It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`."]
#[doc = " In general, it's recommended to provide a few thousands samples, though this can vary a lot."]
#[doc = " It's recommended that total size of all samples be about ~x100 times the target size of dictionary."]
pub fn ZDICT_trainFromBuffer_fastCover(
dictBuffer: *mut libc::c_void,
dictBufferCapacity: usize,
samplesBuffer: *const libc::c_void,
samplesSizes: *const usize,
nbSamples: libc::c_uint,
parameters: ZDICT_fastCover_params_t,
) -> usize;
}
extern "C" {
#[doc = " ZDICT_optimizeTrainFromBuffer_fastCover():"]
#[doc = " The same requirements as above hold for all the parameters except `parameters`."]
#[doc = " This function tries many parameter combinations (specifically, k and d combinations)"]
#[doc = " and picks the best parameters. `*parameters` is filled with the best parameters found,"]
#[doc = " dictionary constructed with those parameters is stored in `dictBuffer`."]
#[doc = " All of the parameters d, k, steps, f, and accel are optional."]
#[doc = " If d is non-zero then we don't check multiple values of d, otherwise we check d = {6, 8}."]
#[doc = " if steps is zero it defaults to its default value."]
#[doc = " If k is non-zero then we don't check multiple values of k, otherwise we check steps values in [50, 2000]."]
#[doc = " If f is zero, default value of 20 is used."]
#[doc = " If accel is zero, default value of 1 is used."]
#[doc = ""]
#[doc = " @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)"]
#[doc = " or an error code, which can be tested with ZDICT_isError()."]
#[doc = " On success `*parameters` contains the parameters selected."]
#[doc = " See ZDICT_trainFromBuffer() for details on failure modes."]
#[doc = " Note: ZDICT_optimizeTrainFromBuffer_fastCover() requires about 6 * 2^f bytes of memory for each thread."]
pub fn ZDICT_optimizeTrainFromBuffer_fastCover(
dictBuffer: *mut libc::c_void,
dictBufferCapacity: usize,
samplesBuffer: *const libc::c_void,
samplesSizes: *const usize,
nbSamples: libc::c_uint,
parameters: *mut ZDICT_fastCover_params_t,
) -> usize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZDICT_legacy_params_t {
pub selectivityLevel: libc::c_uint,
pub zParams: ZDICT_params_t,
}
#[test]
fn bindgen_test_layout_ZDICT_legacy_params_t() {
assert_eq!(
::core::mem::size_of::<ZDICT_legacy_params_t>(),
16usize,
concat!("Size of: ", stringify!(ZDICT_legacy_params_t))
);
assert_eq!(
::core::mem::align_of::<ZDICT_legacy_params_t>(),
4usize,
concat!("Alignment of ", stringify!(ZDICT_legacy_params_t))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_legacy_params_t>())).selectivityLevel
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_legacy_params_t),
"::",
stringify!(selectivityLevel)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ZDICT_legacy_params_t>())).zParams
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZDICT_legacy_params_t),
"::",
stringify!(zParams)
)
);
}
extern "C" {
#[doc = " ZDICT_trainFromBuffer_legacy():"]
#[doc = " Train a dictionary from an array of samples."]
#[doc = " Samples must be stored concatenated in a single flat buffer `samplesBuffer`,"]
#[doc = " supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order."]
#[doc = " The resulting dictionary will be saved into `dictBuffer`."]
#[doc = " `parameters` is optional and can be provided with values set to 0 to mean \"default\"."]
#[doc = " @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)"]
#[doc = " or an error code, which can be tested with ZDICT_isError()."]
#[doc = " See ZDICT_trainFromBuffer() for details on failure modes."]
#[doc = " Tips: In general, a reasonable dictionary has a size of ~ 100 KB."]
#[doc = " It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`."]
#[doc = " In general, it's recommended to provide a few thousands samples, though this can vary a lot."]
#[doc = " It's recommended that total size of all samples be about ~x100 times the target size of dictionary."]
#[doc = " Note: ZDICT_trainFromBuffer_legacy() will send notifications into stderr if instructed to, using notificationLevel>0."]
pub fn ZDICT_trainFromBuffer_legacy(
dictBuffer: *mut libc::c_void,
dictBufferCapacity: usize,
samplesBuffer: *const libc::c_void,
samplesSizes: *const usize,
nbSamples: libc::c_uint,
parameters: ZDICT_legacy_params_t,
) -> usize;
}
extern "C" {
pub fn ZDICT_addEntropyTablesFromBuffer(
dictBuffer: *mut libc::c_void,
dictContentSize: usize,
dictBufferCapacity: usize,
samplesBuffer: *const libc::c_void,
samplesSizes: *const usize,
nbSamples: libc::c_uint,
) -> usize;
}
extern "C" {
pub fn memcpy(
__dest: *mut libc::c_void,
__src: *const libc::c_void,
__n: libc::c_ulong,
) -> *mut libc::c_void;
}
extern "C" {
pub fn memmove(
__dest: *mut libc::c_void,
__src: *const libc::c_void,
__n: libc::c_ulong,
) -> *mut libc::c_void;
}
extern "C" {
pub fn memccpy(
__dest: *mut libc::c_void,
__src: *const libc::c_void,
__c: libc::c_int,
__n: libc::c_ulong,
) -> *mut libc::c_void;
}
extern "C" {
pub fn memset(
__s: *mut libc::c_void,
__c: libc::c_int,
__n: libc::c_ulong,
) -> *mut libc::c_void;
}
extern "C" {
pub fn memcmp(
__s1: *const libc::c_void,
__s2: *const libc::c_void,
__n: libc::c_ulong,
) -> libc::c_int;
}
extern "C" {
pub fn memchr(
__s: *const libc::c_void,
__c: libc::c_int,
__n: libc::c_ulong,
) -> *mut libc::c_void;
}
extern "C" {
pub fn strcpy(
__dest: *mut libc::c_char,
__src: *const libc::c_char,
) -> *mut libc::c_char;
}
extern "C" {
pub fn strncpy(
__dest: *mut libc::c_char,
__src: *const libc::c_char,
__n: libc::c_ulong,
) -> *mut libc::c_char;
}
extern "C" {
pub fn strcat(
__dest: *mut libc::c_char,
__src: *const libc::c_char,
) -> *mut libc::c_char;
}
extern "C" {
pub fn strncat(
__dest: *mut libc::c_char,
__src: *const libc::c_char,
__n: libc::c_ulong,
) -> *mut libc::c_char;
}
extern "C" {
pub fn strcmp(
__s1: *const libc::c_char,
__s2: *const libc::c_char,
) -> libc::c_int;
}
extern "C" {
pub fn strncmp(
__s1: *const libc::c_char,
__s2: *const libc::c_char,
__n: libc::c_ulong,
) -> libc::c_int;
}
extern "C" {
pub fn strcoll(
__s1: *const libc::c_char,
__s2: *const libc::c_char,
) -> libc::c_int;
}
extern "C" {
pub fn strxfrm(
__dest: *mut libc::c_char,
__src: *const libc::c_char,
__n: libc::c_ulong,
) -> libc::c_ulong;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __locale_struct {
pub __locales: [*mut __locale_data; 13usize],
pub __ctype_b: *const libc::c_ushort,
pub __ctype_tolower: *const libc::c_int,
pub __ctype_toupper: *const libc::c_int,
pub __names: [*const libc::c_char; 13usize],
}
#[test]
fn bindgen_test_layout___locale_struct() {
assert_eq!(
::core::mem::size_of::<__locale_struct>(),
232usize,
concat!("Size of: ", stringify!(__locale_struct))
);
assert_eq!(
::core::mem::align_of::<__locale_struct>(),
8usize,
concat!("Alignment of ", stringify!(__locale_struct))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<__locale_struct>())).__locales as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__locale_struct),
"::",
stringify!(__locales)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<__locale_struct>())).__ctype_b as *const _
as usize
},
104usize,
concat!(
"Offset of field: ",
stringify!(__locale_struct),
"::",
stringify!(__ctype_b)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<__locale_struct>())).__ctype_tolower
as *const _ as usize
},
112usize,
concat!(
"Offset of field: ",
stringify!(__locale_struct),
"::",
stringify!(__ctype_tolower)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<__locale_struct>())).__ctype_toupper
as *const _ as usize
},
120usize,
concat!(
"Offset of field: ",
stringify!(__locale_struct),
"::",
stringify!(__ctype_toupper)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<__locale_struct>())).__names as *const _
as usize
},
128usize,
concat!(
"Offset of field: ",
stringify!(__locale_struct),
"::",
stringify!(__names)
)
);
}
pub type __locale_t = *mut __locale_struct;
pub type locale_t = __locale_t;
extern "C" {
pub fn strcoll_l(
__s1: *const libc::c_char,
__s2: *const libc::c_char,
__l: locale_t,
) -> libc::c_int;
}
extern "C" {
pub fn strxfrm_l(
__dest: *mut libc::c_char,
__src: *const libc::c_char,
__n: usize,
__l: locale_t,
) -> usize;
}
extern "C" {
pub fn strdup(__s: *const libc::c_char) -> *mut libc::c_char;
}
extern "C" {
pub fn strndup(
__string: *const libc::c_char,
__n: libc::c_ulong,
) -> *mut libc::c_char;
}
extern "C" {
pub fn strchr(
__s: *const libc::c_char,
__c: libc::c_int,
) -> *mut libc::c_char;
}
extern "C" {
pub fn strrchr(
__s: *const libc::c_char,
__c: libc::c_int,
) -> *mut libc::c_char;
}
extern "C" {
pub fn strcspn(
__s: *const libc::c_char,
__reject: *const libc::c_char,
) -> libc::c_ulong;
}
extern "C" {
pub fn strspn(
__s: *const libc::c_char,
__accept: *const libc::c_char,
) -> libc::c_ulong;
}
extern "C" {
pub fn strpbrk(
__s: *const libc::c_char,
__accept: *const libc::c_char,
) -> *mut libc::c_char;
}
extern "C" {
pub fn strstr(
__haystack: *const libc::c_char,
__needle: *const libc::c_char,
) -> *mut libc::c_char;
}
extern "C" {
pub fn strtok(
__s: *mut libc::c_char,
__delim: *const libc::c_char,
) -> *mut libc::c_char;
}
extern "C" {
pub fn __strtok_r(
__s: *mut libc::c_char,
__delim: *const libc::c_char,
__save_ptr: *mut *mut libc::c_char,
) -> *mut libc::c_char;
}
extern "C" {
pub fn strtok_r(
__s: *mut libc::c_char,
__delim: *const libc::c_char,
__save_ptr: *mut *mut libc::c_char,
) -> *mut libc::c_char;
}
extern "C" {
pub fn strlen(__s: *const libc::c_char) -> libc::c_ulong;
}
extern "C" {
pub fn strnlen(__string: *const libc::c_char, __maxlen: usize) -> usize;
}
extern "C" {
pub fn strerror(__errnum: libc::c_int) -> *mut libc::c_char;
}
extern "C" {
#[link_name = "\u{1}__xpg_strerror_r"]
pub fn strerror_r(
__errnum: libc::c_int,
__buf: *mut libc::c_char,
__buflen: usize,
) -> libc::c_int;
}
extern "C" {
pub fn strerror_l(
__errnum: libc::c_int,
__l: locale_t,
) -> *mut libc::c_char;
}
extern "C" {
pub fn bcmp(
__s1: *const libc::c_void,
__s2: *const libc::c_void,
__n: libc::c_ulong,
) -> libc::c_int;
}
extern "C" {
pub fn bcopy(
__src: *const libc::c_void,
__dest: *mut libc::c_void,
__n: usize,
);
}
extern "C" {
pub fn bzero(__s: *mut libc::c_void, __n: libc::c_ulong);
}
extern "C" {
pub fn index(
__s: *const libc::c_char,
__c: libc::c_int,
) -> *mut libc::c_char;
}
extern "C" {
pub fn rindex(
__s: *const libc::c_char,
__c: libc::c_int,
) -> *mut libc::c_char;
}
extern "C" {
pub fn ffs(__i: libc::c_int) -> libc::c_int;
}
extern "C" {
pub fn ffsl(__l: libc::c_long) -> libc::c_int;
}
extern "C" {
pub fn ffsll(__ll: libc::c_longlong) -> libc::c_int;
}
extern "C" {
pub fn strcasecmp(
__s1: *const libc::c_char,
__s2: *const libc::c_char,
) -> libc::c_int;
}
extern "C" {
pub fn strncasecmp(
__s1: *const libc::c_char,
__s2: *const libc::c_char,
__n: libc::c_ulong,
) -> libc::c_int;
}
extern "C" {
pub fn strcasecmp_l(
__s1: *const libc::c_char,
__s2: *const libc::c_char,
__loc: locale_t,
) -> libc::c_int;
}
extern "C" {
pub fn strncasecmp_l(
__s1: *const libc::c_char,
__s2: *const libc::c_char,
__n: usize,
__loc: locale_t,
) -> libc::c_int;
}
extern "C" {
pub fn explicit_bzero(__s: *mut libc::c_void, __n: usize);
}
extern "C" {
pub fn strsep(
__stringp: *mut *mut libc::c_char,
__delim: *const libc::c_char,
) -> *mut libc::c_char;
}
extern "C" {
pub fn strsignal(__sig: libc::c_int) -> *mut libc::c_char;
}
extern "C" {
pub fn __stpcpy(
__dest: *mut libc::c_char,
__src: *const libc::c_char,
) -> *mut libc::c_char;
}
extern "C" {
pub fn stpcpy(
__dest: *mut libc::c_char,
__src: *const libc::c_char,
) -> *mut libc::c_char;
}
extern "C" {
pub fn __stpncpy(
__dest: *mut libc::c_char,
__src: *const libc::c_char,
__n: usize,
) -> *mut libc::c_char;
}
extern "C" {
pub fn stpncpy(
__dest: *mut libc::c_char,
__src: *const libc::c_char,
__n: libc::c_ulong,
) -> *mut libc::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTDMT_CCtx_s {
_unused: [u8; 0],
}
pub type ZSTDMT_CCtx = ZSTDMT_CCtx_s;
extern "C" {
pub fn ZSTDMT_createCCtx_advanced(
nbWorkers: libc::c_uint,
cMem: ZSTD_customMem,
pool: *mut ZSTD_threadPool,
) -> *mut ZSTDMT_CCtx;
}
extern "C" {
pub fn ZSTDMT_freeCCtx(mtctx: *mut ZSTDMT_CCtx) -> usize;
}
extern "C" {
pub fn ZSTDMT_sizeof_CCtx(mtctx: *mut ZSTDMT_CCtx) -> usize;
}
extern "C" {
pub fn ZSTDMT_nextInputSizeHint(mtctx: *const ZSTDMT_CCtx) -> usize;
}
extern "C" {
#[doc = " ZSTDMT_initCStream_internal() :"]
#[doc = " Private use only. Init streaming operation."]
#[doc = " expects params to be valid."]
#[doc = " must receive dict, or cdict, or none, but not both."]
#[doc = " @return : 0, or an error code"]
pub fn ZSTDMT_initCStream_internal(
zcs: *mut ZSTDMT_CCtx,
dict: *const libc::c_void,
dictSize: usize,
dictContentType: ZSTD_dictContentType_e,
cdict: *const ZSTD_CDict,
params: ZSTD_CCtx_params,
pledgedSrcSize: libc::c_ulonglong,
) -> usize;
}
extern "C" {
#[doc = " ZSTDMT_compressStream_generic() :"]
#[doc = " Combines ZSTDMT_compressStream() with optional ZSTDMT_flushStream() or ZSTDMT_endStream()"]
#[doc = " depending on flush directive."]
#[doc = " @return : minimum amount of data still to be flushed"]
#[doc = " 0 if fully flushed"]
#[doc = " or an error code"]
#[doc = " note : needs to be init using any ZSTD_initCStream*() variant"]
pub fn ZSTDMT_compressStream_generic(
mtctx: *mut ZSTDMT_CCtx,
output: *mut ZSTD_outBuffer,
input: *mut ZSTD_inBuffer,
endOp: ZSTD_EndDirective,
) -> usize;
}
extern "C" {
#[doc = " ZSTDMT_toFlushNow()"]
#[doc = " Tell how many bytes are ready to be flushed immediately."]
#[doc = " Probe the oldest active job (not yet entirely flushed) and check its output buffer."]
#[doc = " If return 0, it means there is no active job,"]
#[doc = " or, it means oldest job is still active, but everything produced has been flushed so far,"]
#[doc = " therefore flushing is limited by speed of oldest job."]
pub fn ZSTDMT_toFlushNow(mtctx: *mut ZSTDMT_CCtx) -> usize;
}
extern "C" {
#[doc = " ZSTDMT_updateCParams_whileCompressing() :"]
#[doc = " Updates only a selected set of compression parameters, to remain compatible with current frame."]
#[doc = " New parameters will be applied to next compression job."]
pub fn ZSTDMT_updateCParams_whileCompressing(
mtctx: *mut ZSTDMT_CCtx,
cctxParams: *const ZSTD_CCtx_params,
);
}
extern "C" {
#[doc = " ZSTDMT_getFrameProgression():"]
#[doc = " tells how much data has been consumed (input) and produced (output) for current frame."]
#[doc = " able to count progression inside worker threads."]
pub fn ZSTDMT_getFrameProgression(
mtctx: *mut ZSTDMT_CCtx,
) -> ZSTD_frameProgression;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __locale_data {
pub _address: u8,
}