1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447
/* 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); }