/* automatically generated by rust-bindgen */

pub const BLOSC_VERSION_MAJOR: u32 = 1;
pub const BLOSC_VERSION_MINOR: u32 = 14;
pub const BLOSC_VERSION_RELEASE: u32 = 2;
pub const BLOSC_VERSION_STRING: &'static [u8; 7usize] = b"1.14.2\0";
pub const BLOSC_VERSION_REVISION: &'static [u8; 6usize] = b"$Rev$\0";
pub const BLOSC_VERSION_DATE: &'static [u8; 22usize] = b"$Date:: 2018-03-16 #$\0";
pub const BLOSCLZ_VERSION_STRING: &'static [u8; 6usize] = b"1.1.0\0";
pub const BLOSC_VERSION_FORMAT: u32 = 2;
pub const BLOSC_MIN_HEADER_LENGTH: u32 = 16;
pub const BLOSC_MAX_OVERHEAD: u32 = 16;
pub const BLOSC_MAX_BUFFERSIZE: u32 = 2147483631;
pub const BLOSC_MAX_TYPESIZE: u32 = 255;
pub const BLOSC_MAX_THREADS: u32 = 256;
pub const BLOSC_NOSHUFFLE: u32 = 0;
pub const BLOSC_SHUFFLE: u32 = 1;
pub const BLOSC_BITSHUFFLE: u32 = 2;
pub const BLOSC_DOSHUFFLE: u32 = 1;
pub const BLOSC_MEMCPYED: u32 = 2;
pub const BLOSC_DOBITSHUFFLE: u32 = 4;
pub const BLOSC_BLOSCLZ: u32 = 0;
pub const BLOSC_LZ4: u32 = 1;
pub const BLOSC_LZ4HC: u32 = 2;
pub const BLOSC_SNAPPY: u32 = 3;
pub const BLOSC_ZLIB: u32 = 4;
pub const BLOSC_ZSTD: u32 = 5;
pub const BLOSC_BLOSCLZ_COMPNAME: &'static [u8; 8usize] = b"blosclz\0";
pub const BLOSC_LZ4_COMPNAME: &'static [u8; 4usize] = b"lz4\0";
pub const BLOSC_LZ4HC_COMPNAME: &'static [u8; 6usize] = b"lz4hc\0";
pub const BLOSC_SNAPPY_COMPNAME: &'static [u8; 7usize] = b"snappy\0";
pub const BLOSC_ZLIB_COMPNAME: &'static [u8; 5usize] = b"zlib\0";
pub const BLOSC_ZSTD_COMPNAME: &'static [u8; 5usize] = b"zstd\0";
pub const BLOSC_BLOSCLZ_LIB: u32 = 0;
pub const BLOSC_LZ4_LIB: u32 = 1;
pub const BLOSC_SNAPPY_LIB: u32 = 2;
pub const BLOSC_ZLIB_LIB: u32 = 3;
pub const BLOSC_ZSTD_LIB: u32 = 4;
pub const BLOSC_BLOSCLZ_LIBNAME: &'static [u8; 8usize] = b"BloscLZ\0";
pub const BLOSC_LZ4_LIBNAME: &'static [u8; 4usize] = b"LZ4\0";
pub const BLOSC_SNAPPY_LIBNAME: &'static [u8; 7usize] = b"Snappy\0";
pub const BLOSC_ZLIB_LIBNAME: &'static [u8; 5usize] = b"Zlib\0";
pub const BLOSC_ZSTD_LIBNAME: &'static [u8; 5usize] = b"Zstd\0";
pub const BLOSC_BLOSCLZ_FORMAT: u32 = 0;
pub const BLOSC_LZ4_FORMAT: u32 = 1;
pub const BLOSC_LZ4HC_FORMAT: u32 = 1;
pub const BLOSC_SNAPPY_FORMAT: u32 = 2;
pub const BLOSC_ZLIB_FORMAT: u32 = 3;
pub const BLOSC_ZSTD_FORMAT: u32 = 4;
pub const BLOSC_BLOSCLZ_VERSION_FORMAT: u32 = 1;
pub const BLOSC_LZ4_VERSION_FORMAT: u32 = 1;
pub const BLOSC_LZ4HC_VERSION_FORMAT: u32 = 1;
pub const BLOSC_SNAPPY_VERSION_FORMAT: u32 = 1;
pub const BLOSC_ZLIB_VERSION_FORMAT: u32 = 1;
pub const BLOSC_ZSTD_VERSION_FORMAT: u32 = 1;
pub const BLOSC_ALWAYS_SPLIT: u32 = 1;
pub const BLOSC_NEVER_SPLIT: u32 = 2;
pub const BLOSC_AUTO_SPLIT: u32 = 3;
pub const BLOSC_FORWARD_COMPAT_SPLIT: u32 = 4;
extern "C" {
    /// Initialize the Blosc library environment.
    ///
    /// You must call this previous to any other Blosc call, unless you want
    /// Blosc to be used simultaneously in a multi-threaded environment, in
    /// which case you should *exclusively* use the
    /// blosc_compress_ctx()/blosc_decompress_ctx() pair (see below).
    pub fn blosc_init();
}
extern "C" {
    /// Destroy the Blosc library environment.
    ///
    /// You must call this after to you are done with all the Blosc calls,
    /// unless you have not used blosc_init() before (see blosc_init()
    /// above).
    pub fn blosc_destroy();
}
extern "C" {
    /// Compress a block of data in the `src` buffer and returns the size of
    /// the compressed block.  The size of `src` buffer is specified by
    /// `nbytes`.  There is not a minimum for `src` buffer size (`nbytes`).
    ///
    /// `clevel` is the desired compression level and must be a number
    /// between 0 (no compression) and 9 (maximum compression).
    ///
    /// `doshuffle` specifies whether the shuffle compression filters
    /// should be applied or not.  BLOSC_NOSHUFFLE means not applying it,
    /// BLOSC_SHUFFLE means applying it at a byte level and BLOSC_BITSHUFFLE
    /// at a bit level (slower but may achieve better entropy alignment).
    ///
    /// `typesize` is the number of bytes for the atomic type in binary
    /// `src` buffer.  This is mainly useful for the shuffle filters.
    /// For implementation reasons, only a 1 < `typesize` < 256 will allow the
    /// shuffle filter to work.  When `typesize` is not in this range, shuffle
    /// will be silently disabled.
    ///
    /// The `dest` buffer must have at least the size of `destsize`.  Blosc
    /// guarantees that if you set `destsize` to, at least,
    /// (`nbytes` + BLOSC_MAX_OVERHEAD), the compression will always succeed.
    /// The `src` buffer and the `dest` buffer can not overlap.
    ///
    /// Compression is memory safe and guaranteed not to write the `dest`
    /// buffer beyond what is specified in `destsize`.
    ///
    /// If `src` buffer cannot be compressed into `destsize`, the return
    /// value is zero and you should discard the contents of the `dest`
    /// buffer.
    ///
    /// A negative return value means that an internal error happened.  This
    /// should never happen.  If you see this, please report it back
    /// together with the buffer data causing this and compression settings.
    ///
    /// Environment variables
    /// ---------------------
    ///
    /// blosc_compress() honors different environment variables to control
    /// internal parameters without the need of doing that programatically.
    /// Here are the ones supported:
    ///
    /// BLOSC_CLEVEL=(INTEGER): This will overwrite the `clevel` parameter
    /// before the compression process starts.
    ///
    /// BLOSC_SHUFFLE=[NOSHUFFLE | SHUFFLE | BITSHUFFLE]: This will
    /// overwrite the `doshuffle` parameter before the compression process
    /// starts.
    ///
    /// BLOSC_TYPESIZE=(INTEGER): This will overwrite the `typesize`
    /// parameter before the compression process starts.
    ///
    /// BLOSC_COMPRESSOR=[BLOSCLZ | LZ4 | LZ4HC | SNAPPY | ZLIB]: This will
    /// call blosc_set_compressor(BLOSC_COMPRESSOR) before the compression
    /// process starts.
    ///
    /// BLOSC_NTHREADS=(INTEGER): This will call
    /// blosc_set_nthreads(BLOSC_NTHREADS) before the compression process
    /// starts.
    ///
    /// BLOSC_BLOCKSIZE=(INTEGER): This will call
    /// blosc_set_blocksize(BLOSC_BLOCKSIZE) before the compression process
    /// starts.  *NOTE:* The blocksize is a critical parameter with
    /// important restrictions in the allowed values, so use this with care.
    ///
    /// BLOSC_NOLOCK=(ANY VALUE): This will call blosc_compress_ctx() under
    /// the hood, with the `compressor`, `blocksize` and
    /// `numinternalthreads` parameters set to the same as the last calls to
    /// blosc_set_compressor(), blosc_set_blocksize() and
    /// blosc_set_nthreads().  BLOSC_CLEVEL, BLOSC_SHUFFLE, BLOSC_TYPESIZE
    /// environment vars will also be honored.
    ///
    /// BLOSC_SPLITMODE=[ FORWARD_COMPAT | AUTO | ALWAYS | NEVER ]:
    /// This will call blosc_set_splitmode() with the different supported values.
    /// See blosc_set_splitmode() docstrings for more info on each mode.
    pub fn blosc_compress(
        clevel: ::std::os::raw::c_int,
        doshuffle: ::std::os::raw::c_int,
        typesize: usize,
        nbytes: usize,
        src: *const ::std::os::raw::c_void,
        dest: *mut ::std::os::raw::c_void,
        destsize: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Context interface to blosc compression. This does not require a call
    /// to blosc_init() and can be called from multithreaded applications
    /// without the global lock being used, so allowing Blosc be executed
    /// simultaneously in those scenarios.
    ///
    /// It uses the same parameters than the blosc_compress() function plus:
    ///
    /// `compressor`: the string representing the type of compressor to use.
    ///
    /// `blocksize`: the requested size of the compressed blocks.  If 0, an
    /// automatic blocksize will be used.
    ///
    /// `numinternalthreads`: the number of threads to use internally.
    ///
    /// A negative return value means that an internal error happened.  This
    /// should never happen.  If you see this, please report it back
    /// together with the buffer data causing this and compression settings.
    pub fn blosc_compress_ctx(
        clevel: ::std::os::raw::c_int,
        doshuffle: ::std::os::raw::c_int,
        typesize: usize,
        nbytes: usize,
        src: *const ::std::os::raw::c_void,
        dest: *mut ::std::os::raw::c_void,
        destsize: usize,
        compressor: *const ::std::os::raw::c_char,
        blocksize: usize,
        numinternalthreads: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Decompress a block of compressed data in `src`, put the result in
    /// `dest` and returns the size of the decompressed block.
    ///
    /// The `src` buffer and the `dest` buffer can not overlap.
    ///
    /// Decompression is memory safe and guaranteed not to write the `dest`
    /// buffer beyond what is specified in `destsize`.
    ///
    /// If an error occurs, e.g. the compressed data is corrupted or the
    /// output buffer is not large enough, then 0 (zero) or a negative value
    /// will be returned instead.
    ///
    /// Environment variables
    /// ---------------------
    ///
    /// blosc_decompress() honors different environment variables to control
    /// internal parameters without the need of doing that programatically.
    /// Here are the ones supported:
    ///
    /// BLOSC_NTHREADS=(INTEGER): This will call
    /// blosc_set_nthreads(BLOSC_NTHREADS) before the proper decompression
    /// process starts.
    ///
    /// BLOSC_NOLOCK=(ANY VALUE): This will call blosc_decompress_ctx()
    /// under the hood, with the `numinternalthreads` parameter set to the
    /// same value as the last call to blosc_set_nthreads().
    pub fn blosc_decompress(
        src: *const ::std::os::raw::c_void,
        dest: *mut ::std::os::raw::c_void,
        destsize: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Context interface to blosc decompression. This does not require a
    /// call to blosc_init() and can be called from multithreaded
    /// applications without the global lock being used, so allowing Blosc
    /// be executed simultaneously in those scenarios.
    ///
    /// It uses the same parameters than the blosc_decompress() function plus:
    ///
    /// `numinternalthreads`: number of threads to use internally.
    ///
    /// Decompression is memory safe and guaranteed not to write the `dest`
    /// buffer more than what is specified in `destsize`.
    ///
    /// If an error occurs, e.g. the compressed data is corrupted or the
    /// output buffer is not large enough, then 0 (zero) or a negative value
    /// will be returned instead.
    pub fn blosc_decompress_ctx(
        src: *const ::std::os::raw::c_void,
        dest: *mut ::std::os::raw::c_void,
        destsize: usize,
        numinternalthreads: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Get `nitems` (of typesize size) in `src` buffer starting in `start`.
    /// The items are returned in `dest` buffer, which has to have enough
    /// space for storing all items.
    ///
    /// Returns the number of bytes copied to `dest` or a negative value if
    /// some error happens.
    pub fn blosc_getitem(
        src: *const ::std::os::raw::c_void,
        start: ::std::os::raw::c_int,
        nitems: ::std::os::raw::c_int,
        dest: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Returns the current number of threads that are used for
    /// compression/decompression.
    pub fn blosc_get_nthreads() -> ::std::os::raw::c_int;
}
extern "C" {
    /// Initialize a pool of threads for compression/decompression.  If
    /// `nthreads` is 1, then the serial version is chosen and a possible
    /// previous existing pool is ended.  If this is not called, `nthreads`
    /// is set to 1 internally.
    ///
    /// Returns the previous number of threads.
    pub fn blosc_set_nthreads(nthreads: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Returns the current compressor that is being used for compression.
    pub fn blosc_get_compressor() -> *const ::std::os::raw::c_char;
}
extern "C" {
    /// Select the compressor to be used.  The supported ones are "blosclz",
    /// "lz4", "lz4hc", "snappy", "zlib" and "ztsd".  If this function is not
    /// called, then "blosclz" will be used by default.
    ///
    /// In case the compressor is not recognized, or there is not support
    /// for it in this build, it returns a -1.  Else it returns the code for
    /// the compressor (>=0).
    pub fn blosc_set_compressor(compname: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Get the `compname` associated with the `compcode`.
    ///
    /// If the compressor code is not recognized, or there is not support
    /// for it in this build, -1 is returned.  Else, the compressor code is
    /// returned.
    pub fn blosc_compcode_to_compname(
        compcode: ::std::os::raw::c_int,
        compname: *mut *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Return the compressor code associated with the compressor name.
    ///
    /// If the compressor name is not recognized, or there is not support
    /// for it in this build, -1 is returned instead.
    pub fn blosc_compname_to_compcode(
        compname: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Get a list of compressors supported in the current build.  The
    /// returned value is a string with a concatenation of "blosclz", "lz4",
    /// "lz4hc", "snappy", "zlib" or "zstd "separated by commas, depending
    /// on which ones are present in the build.
    ///
    /// This function does not leak, so you should not free() the returned
    /// list.
    ///
    /// This function should always succeed.
    pub fn blosc_list_compressors() -> *const ::std::os::raw::c_char;
}
extern "C" {
    /// Return the version of the C-Blosc library in string format.
    ///
    /// Useful for dynamic libraries.
    pub fn blosc_get_version_string() -> *const ::std::os::raw::c_char;
}
extern "C" {
    /// Get info from compression libraries included in the current build.
    /// In `compname` you pass the compressor name that you want info from.
    ///
    /// In `complib` and `version` you get a pointer to the compressor
    /// library name and the version in string format respectively.  After
    /// using the name and version, you should free() them so as to avoid
    /// leaks.
    ///
    /// If the compressor is supported, it returns the code for the library
    /// (>=0).  If it is not supported, this function returns -1.
    pub fn blosc_get_complib_info(
        compname: *const ::std::os::raw::c_char,
        complib: *mut *mut ::std::os::raw::c_char,
        version: *mut *mut ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Free possible memory temporaries and thread resources.  Use this
    /// when you are not going to use Blosc for a long while.  In case of
    /// problems releasing the resources, it returns a negative number, else
    /// it returns 0.
    pub fn blosc_free_resources() -> ::std::os::raw::c_int;
}
extern "C" {
    /// Return information about a compressed buffer, namely the number of
    /// uncompressed bytes (`nbytes`) and compressed (`cbytes`).  It also
    /// returns the `blocksize` (which is used internally for doing the
    /// compression by blocks).
    ///
    /// You only need to pass the first BLOSC_MIN_HEADER_LENGTH bytes of a
    /// compressed buffer for this call to work.
    ///
    /// If the format is not supported by the library, all output arguments will be
    /// filled with zeros.
    pub fn blosc_cbuffer_sizes(
        cbuffer: *const ::std::os::raw::c_void,
        nbytes: *mut usize,
        cbytes: *mut usize,
        blocksize: *mut usize,
    );
}
extern "C" {
    /// Return meta-information about a compressed buffer, namely the type size
    /// (`typesize`), as well as some internal `flags`.
    ///
    /// The `flags` is a set of bits, where the used ones are:
    /// bit 0: whether the shuffle filter has been applied or not
    /// bit 1: whether the internal buffer is a pure memcpy or not
    /// bit 2: whether the bit shuffle filter has been applied or not
    ///
    /// You can use the `BLOSC_DOSHUFFLE`, `BLOSC_DOBITSHUFFLE` and
    /// `BLOSC_MEMCPYED` symbols for extracting the interesting bits
    /// (e.g. ``flags & BLOSC_DOSHUFFLE`` says whether the buffer is
    /// byte-shuffled or not).
    ///
    /// You only need to pass the first BLOSC_MIN_HEADER_LENGTH bytes of a
    /// compressed buffer for this call to work.
    ///
    /// If the format is not supported by the library, all output arguments will be
    /// filled with zeros.
    pub fn blosc_cbuffer_metainfo(
        cbuffer: *const ::std::os::raw::c_void,
        typesize: *mut usize,
        flags: *mut ::std::os::raw::c_int,
    );
}
extern "C" {
    /// Return information about a compressed buffer, namely the internal
    /// Blosc format version (`version`) and the format for the internal
    /// compressor used (`compversion`).
    ///
    /// This function should always succeed.
    pub fn blosc_cbuffer_versions(
        cbuffer: *const ::std::os::raw::c_void,
        version: *mut ::std::os::raw::c_int,
        compversion: *mut ::std::os::raw::c_int,
    );
}
extern "C" {
    /// Return the compressor library/format used in a compressed buffer.
    ///
    /// This function should always succeed.
    pub fn blosc_cbuffer_complib(
        cbuffer: *const ::std::os::raw::c_void,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    /// Get the internal blocksize to be used during compression.  0 means
    /// that an automatic blocksize is computed internally (the default).
    pub fn blosc_get_blocksize() -> ::std::os::raw::c_int;
}
extern "C" {
    /// Force the use of a specific blocksize.  If 0, an automatic
    /// blocksize will be used (the default).
    ///
    /// The blocksize is a critical parameter with important restrictions in
    /// the allowed values, so use this with care.
    pub fn blosc_set_blocksize(blocksize: usize);
}
extern "C" {
    /// Set the split mode.
    ///
    /// This function can take the next values:
    /// BLOSC_FORWARD_COMPAT_SPLIT
    /// BLOSC_AUTO_SPLIT
    /// BLOSC_NEVER_SPLIT
    /// BLOSC_ALWAYS_SPLIT
    ///
    /// BLOSC_FORWARD_COMPAT offers reasonably forward compatibility,
    /// BLOSC_AUTO_SPLIT is for nearly optimal results (based on heuristics),
    /// BLOSC_NEVER_SPLIT and BLOSC_ALWAYS_SPLIT are for the user experimenting
    /// when trying to get best compression ratios and/or speed.
    ///
    /// If not called, the default mode is BLOSC_FORWARD_COMPAT_SPLIT.
    ///
    /// This function should always succeed.
    pub fn blosc_set_splitmode(splitmode: ::std::os::raw::c_int);
}