pub type size_t = ::std::os::raw::c_ulong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type FILE = _IO_FILE;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_marker {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_codecvt {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_wide_data {
_unused: [u8; 0],
}
pub type _IO_lock_t = ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_FILE {
pub _flags: ::std::os::raw::c_int,
pub _IO_read_ptr: *mut ::std::os::raw::c_char,
pub _IO_read_end: *mut ::std::os::raw::c_char,
pub _IO_read_base: *mut ::std::os::raw::c_char,
pub _IO_write_base: *mut ::std::os::raw::c_char,
pub _IO_write_ptr: *mut ::std::os::raw::c_char,
pub _IO_write_end: *mut ::std::os::raw::c_char,
pub _IO_buf_base: *mut ::std::os::raw::c_char,
pub _IO_buf_end: *mut ::std::os::raw::c_char,
pub _IO_save_base: *mut ::std::os::raw::c_char,
pub _IO_backup_base: *mut ::std::os::raw::c_char,
pub _IO_save_end: *mut ::std::os::raw::c_char,
pub _markers: *mut _IO_marker,
pub _chain: *mut _IO_FILE,
pub _fileno: ::std::os::raw::c_int,
pub _flags2: ::std::os::raw::c_int,
pub _old_offset: __off_t,
pub _cur_column: ::std::os::raw::c_ushort,
pub _vtable_offset: ::std::os::raw::c_schar,
pub _shortbuf: [::std::os::raw::c_char; 1usize],
pub _lock: *mut _IO_lock_t,
pub _offset: __off64_t,
pub _codecvt: *mut _IO_codecvt,
pub _wide_data: *mut _IO_wide_data,
pub _freeres_list: *mut _IO_FILE,
pub _freeres_buf: *mut ::std::os::raw::c_void,
pub __pad5: size_t,
pub _mode: ::std::os::raw::c_int,
pub _unused2: [::std::os::raw::c_char; 20usize],
}
#[test]
fn bindgen_test_layout__IO_FILE() {
assert_eq!(
::std::mem::size_of::<_IO_FILE>(),
216usize,
concat!("Size of: ", stringify!(_IO_FILE))
);
assert_eq!(
::std::mem::align_of::<_IO_FILE>(),
8usize,
concat!("Alignment of ", stringify!(_IO_FILE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_ptr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_end as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_base as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_base as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_ptr as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_end as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_base as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_end as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_base as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_backup_base as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_backup_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_end as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._markers as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_markers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._chain as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_chain)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._fileno as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_fileno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags2 as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._old_offset as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_old_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._cur_column as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_cur_column)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._vtable_offset as *const _ as usize },
130usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_vtable_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._shortbuf as *const _ as usize },
131usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_shortbuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._lock as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_lock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._offset as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._codecvt as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_codecvt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._wide_data as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_wide_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_list as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_list)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_buf as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_buf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad5 as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(__pad5)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._mode as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._unused2 as *const _ as usize },
196usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_unused2)
)
);
}
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 ::std::os::raw::c_void,
dstCapacity: size_t,
src: *const ::std::os::raw::c_void,
srcSize: size_t,
compressionLevel: ::std::os::raw::c_int,
) -> size_t;
}
extern "C" {
pub fn ZSTD_isError(code: size_t) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn ZSTD_getErrorName(code: size_t) -> *const ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_CCtx_s {
_unused: [u8; 0],
}
#[doc = " Explicit context"]
pub type ZSTD_CCtx = ZSTD_CCtx_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_DCtx_s {
_unused: [u8; 0],
}
pub type ZSTD_DCtx = ZSTD_DCtx_s;
#[doc = " Streaming"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_inBuffer_s {
#[doc = "< start of input buffer"]
pub src: *const ::std::os::raw::c_void,
#[doc = "< size of input buffer"]
pub size: size_t,
#[doc = "< position where reading stopped. Will be updated. Necessarily 0 <= pos <= size"]
pub pos: size_t,
}
#[test]
fn bindgen_test_layout_ZSTD_inBuffer_s() {
assert_eq!(
::std::mem::size_of::<ZSTD_inBuffer_s>(),
24usize,
concat!("Size of: ", stringify!(ZSTD_inBuffer_s))
);
assert_eq!(
::std::mem::align_of::<ZSTD_inBuffer_s>(),
8usize,
concat!("Alignment of ", stringify!(ZSTD_inBuffer_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZSTD_inBuffer_s>())).src as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_inBuffer_s),
"::",
stringify!(src)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZSTD_inBuffer_s>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_inBuffer_s),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::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 ::std::os::raw::c_void,
#[doc = "< size of output buffer"]
pub size: size_t,
#[doc = "< position where writing stopped. Will be updated. Necessarily 0 <= pos <= size"]
pub pos: size_t,
}
#[test]
fn bindgen_test_layout_ZSTD_outBuffer_s() {
assert_eq!(
::std::mem::size_of::<ZSTD_outBuffer_s>(),
24usize,
concat!("Size of: ", stringify!(ZSTD_outBuffer_s))
);
assert_eq!(
::std::mem::align_of::<ZSTD_outBuffer_s>(),
8usize,
concat!("Alignment of ", stringify!(ZSTD_outBuffer_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZSTD_outBuffer_s>())).dst as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_outBuffer_s),
"::",
stringify!(dst)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZSTD_outBuffer_s>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_outBuffer_s),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::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) -> size_t;
}
pub const ZSTD_EndDirective_ZSTD_e_continue: ZSTD_EndDirective = 0;
pub const ZSTD_EndDirective_ZSTD_e_flush: ZSTD_EndDirective = 1;
pub const ZSTD_EndDirective_ZSTD_e_end: ZSTD_EndDirective = 2;
pub type ZSTD_EndDirective = ::std::os::raw::c_uint;
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 = " - When nbWorkers==0 (default), function is blocking : it completes its job before returning to caller."]
#[doc = " - When nbWorkers>=1, function is non-blocking : it just acquires a copy of input, and distributes jobs to internal worker threads, flush 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,
) -> size_t;
}
extern "C" {
pub fn ZSTD_CStreamInSize() -> size_t;
}
extern "C" {
pub fn ZSTD_CStreamOutSize() -> size_t;
}
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: ::std::os::raw::c_int,
) -> size_t;
}
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,
) -> size_t;
}
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) -> size_t;
}
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) -> size_t;
}
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) -> size_t;
}
extern "C" {
pub fn ZSTD_initDStream(zds: *mut ZSTD_DStream) -> size_t;
}
extern "C" {
pub fn ZSTD_decompressStream(
zds: *mut ZSTD_DStream,
output: *mut ZSTD_outBuffer,
input: *mut ZSTD_inBuffer,
) -> size_t;
}
extern "C" {
pub fn ZSTD_DStreamOutSize() -> size_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_seekable_CStream_s {
_unused: [u8; 0],
}
pub type ZSTD_seekable_CStream = ZSTD_seekable_CStream_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_seekable_s {
_unused: [u8; 0],
}
pub type ZSTD_seekable = ZSTD_seekable_s;
extern "C" {
pub fn ZSTD_seekable_createCStream() -> *mut ZSTD_seekable_CStream;
}
extern "C" {
pub fn ZSTD_seekable_freeCStream(zcs: *mut ZSTD_seekable_CStream) -> size_t;
}
extern "C" {
pub fn ZSTD_seekable_initCStream(
zcs: *mut ZSTD_seekable_CStream,
compressionLevel: ::std::os::raw::c_int,
checksumFlag: ::std::os::raw::c_int,
maxFrameSize: ::std::os::raw::c_uint,
) -> size_t;
}
extern "C" {
pub fn ZSTD_seekable_compressStream(
zcs: *mut ZSTD_seekable_CStream,
output: *mut ZSTD_outBuffer,
input: *mut ZSTD_inBuffer,
) -> size_t;
}
extern "C" {
pub fn ZSTD_seekable_endStream(
zcs: *mut ZSTD_seekable_CStream,
output: *mut ZSTD_outBuffer,
) -> size_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_frameLog_s {
_unused: [u8; 0],
}
pub type ZSTD_frameLog = ZSTD_frameLog_s;
extern "C" {
pub fn ZSTD_seekable_createFrameLog(checksumFlag: ::std::os::raw::c_int) -> *mut ZSTD_frameLog;
}
extern "C" {
pub fn ZSTD_seekable_freeFrameLog(fl: *mut ZSTD_frameLog) -> size_t;
}
extern "C" {
pub fn ZSTD_seekable_logFrame(
fl: *mut ZSTD_frameLog,
compressedSize: ::std::os::raw::c_uint,
decompressedSize: ::std::os::raw::c_uint,
checksum: ::std::os::raw::c_uint,
) -> size_t;
}
extern "C" {
pub fn ZSTD_seekable_writeSeekTable(
fl: *mut ZSTD_frameLog,
output: *mut ZSTD_outBuffer,
) -> size_t;
}
extern "C" {
pub fn ZSTD_seekable_create() -> *mut ZSTD_seekable;
}
extern "C" {
pub fn ZSTD_seekable_free(zs: *mut ZSTD_seekable) -> size_t;
}
extern "C" {
pub fn ZSTD_seekable_initBuff(
zs: *mut ZSTD_seekable,
src: *const ::std::os::raw::c_void,
srcSize: size_t,
) -> size_t;
}
extern "C" {
pub fn ZSTD_seekable_initFile(zs: *mut ZSTD_seekable, src: *mut FILE) -> size_t;
}
extern "C" {
pub fn ZSTD_seekable_decompress(
zs: *mut ZSTD_seekable,
dst: *mut ::std::os::raw::c_void,
dstSize: size_t,
offset: ::std::os::raw::c_ulonglong,
) -> size_t;
}
extern "C" {
pub fn ZSTD_seekable_decompressFrame(
zs: *mut ZSTD_seekable,
dst: *mut ::std::os::raw::c_void,
dstSize: size_t,
frameIndex: ::std::os::raw::c_uint,
) -> size_t;
}
extern "C" {
pub fn ZSTD_seekable_getNumFrames(zs: *mut ZSTD_seekable) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn ZSTD_seekable_getFrameCompressedOffset(
zs: *mut ZSTD_seekable,
frameIndex: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn ZSTD_seekable_getFrameDecompressedOffset(
zs: *mut ZSTD_seekable,
frameIndex: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn ZSTD_seekable_getFrameCompressedSize(
zs: *mut ZSTD_seekable,
frameIndex: ::std::os::raw::c_uint,
) -> size_t;
}
extern "C" {
pub fn ZSTD_seekable_getFrameDecompressedSize(
zs: *mut ZSTD_seekable,
frameIndex: ::std::os::raw::c_uint,
) -> size_t;
}
extern "C" {
pub fn ZSTD_seekable_offsetToFrameIndex(
zs: *mut ZSTD_seekable,
offset: ::std::os::raw::c_ulonglong,
) -> ::std::os::raw::c_uint;
}
pub type ZSTD_seekable_read = ::std::option::Option<
unsafe extern "C" fn(
opaque: *mut ::std::os::raw::c_void,
buffer: *mut ::std::os::raw::c_void,
n: size_t,
) -> ::std::os::raw::c_int,
>;
pub type ZSTD_seekable_seek = ::std::option::Option<
unsafe extern "C" fn(
opaque: *mut ::std::os::raw::c_void,
offset: ::std::os::raw::c_longlong,
origin: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_seekable_customFile {
pub opaque: *mut ::std::os::raw::c_void,
pub read: ZSTD_seekable_read,
pub seek: ZSTD_seekable_seek,
}
#[test]
fn bindgen_test_layout_ZSTD_seekable_customFile() {
assert_eq!(
::std::mem::size_of::<ZSTD_seekable_customFile>(),
24usize,
concat!("Size of: ", stringify!(ZSTD_seekable_customFile))
);
assert_eq!(
::std::mem::align_of::<ZSTD_seekable_customFile>(),
8usize,
concat!("Alignment of ", stringify!(ZSTD_seekable_customFile))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZSTD_seekable_customFile>())).opaque as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_seekable_customFile),
"::",
stringify!(opaque)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZSTD_seekable_customFile>())).read as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_seekable_customFile),
"::",
stringify!(read)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZSTD_seekable_customFile>())).seek as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ZSTD_seekable_customFile),
"::",
stringify!(seek)
)
);
}
extern "C" {
pub fn ZSTD_seekable_initAdvanced(
zs: *mut ZSTD_seekable,
src: ZSTD_seekable_customFile,
) -> size_t;
}