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 = 8;
pub const ZSTD_VERSION_NUMBER: u32 = 10408;
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 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;
}
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;
}