mirror of
https://github.com/RaySollium99/picodrive.git
synced 2025-10-27 00:29:39 -04:00
240 lines
9.6 KiB
C
240 lines
9.6 KiB
C
/* zlib.h -- interface of the 'zlib' general purpose compression library
|
|
version 1.2.3, July 18th, 2005
|
|
|
|
Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler
|
|
|
|
This software is provided 'as-is', without any express or implied
|
|
warranty. In no event will the authors be held liable for any damages
|
|
arising from the use of this software.
|
|
|
|
Permission is granted to anyone to use this software for any purpose,
|
|
including commercial applications, and to alter it and redistribute it
|
|
freely, subject to the following restrictions:
|
|
|
|
1. The origin of this software must not be misrepresented; you must not
|
|
claim that you wrote the original software. If you use this software
|
|
in a product, an acknowledgment in the product documentation would be
|
|
appreciated but is not required.
|
|
2. Altered source versions must be plainly marked as such, and must not be
|
|
misrepresented as being the original software.
|
|
3. This notice may not be removed or altered from any source distribution.
|
|
|
|
Jean-loup Gailly Mark Adler
|
|
jloup@gzip.org madler@alumni.caltech.edu
|
|
|
|
|
|
The data format used by the zlib library is described by RFCs (Request for
|
|
Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt
|
|
(zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
|
|
*/
|
|
|
|
#ifndef GZIO_H
|
|
#define GZIO_H
|
|
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/*
|
|
The 'zlib' compression library provides in-memory compression and
|
|
decompression functions, including integrity checks of the uncompressed
|
|
data. This version of the library supports only one compression method
|
|
(deflation) but other algorithms will be added later and will have the same
|
|
stream interface.
|
|
|
|
Compression can be done in a single step if the buffers are large
|
|
enough (for example if an input file is mmap'ed), or can be done by
|
|
repeated calls of the compression function. In the latter case, the
|
|
application must provide more input and/or consume the output
|
|
(providing more output space) before each call.
|
|
|
|
The compressed data format used by default by the in-memory functions is
|
|
the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
|
|
around a deflate stream, which is itself documented in RFC 1951.
|
|
|
|
The library also supports reading and writing files in gzip (.gz) format
|
|
with an interface similar to that of stdio using the functions that start
|
|
with "gz". The gzip format is different from the zlib format. gzip is a
|
|
gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
|
|
|
|
This library can optionally read and write gzip streams in memory as well.
|
|
|
|
The zlib format was designed to be compact and fast for use in memory
|
|
and on communications channels. The gzip format was designed for single-
|
|
file compression on file systems, has a larger header than zlib to maintain
|
|
directory information, and uses a different, slower check method than zlib.
|
|
|
|
The library does not install any signal handler. The decoder checks
|
|
the consistency of the compressed data, so the library should never
|
|
crash even in case of corrupted input.
|
|
*/
|
|
|
|
#ifdef STDC
|
|
typedef void const *voidpc;
|
|
#else
|
|
typedef Byte const *voidpc;
|
|
#endif
|
|
|
|
|
|
/*
|
|
gzip header information passed to and from zlib routines. See RFC 1952
|
|
for more details on the meanings of these fields.
|
|
*/
|
|
typedef struct gz_header_s {
|
|
int text; /* true if compressed data believed to be text */
|
|
uLong time; /* modification time */
|
|
int xflags; /* extra flags (not used when writing a gzip file) */
|
|
int os; /* operating system */
|
|
Bytef *extra; /* pointer to extra field or Z_NULL if none */
|
|
uInt extra_len; /* extra field length (valid if extra != Z_NULL) */
|
|
uInt extra_max; /* space at extra (only when reading header) */
|
|
Bytef *name; /* pointer to zero-terminated file name or Z_NULL */
|
|
uInt name_max; /* space at name (only when reading header) */
|
|
Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */
|
|
uInt comm_max; /* space at comment (only when reading header) */
|
|
int hcrc; /* true if there was or will be a header crc */
|
|
int done; /* true when done reading gzip header (not used
|
|
when writing a gzip file) */
|
|
} gz_header;
|
|
|
|
typedef gz_header FAR *gz_headerp;
|
|
|
|
/*
|
|
The application must update next_in and avail_in when avail_in has
|
|
dropped to zero. It must update next_out and avail_out when avail_out
|
|
has dropped to zero. The application must initialize zalloc, zfree and
|
|
opaque before calling the init function. All other fields are set by the
|
|
compression library and must not be updated by the application.
|
|
|
|
The opaque value provided by the application will be passed as the first
|
|
parameter for calls of zalloc and zfree. This can be useful for custom
|
|
memory management. The compression library attaches no meaning to the
|
|
opaque value.
|
|
|
|
zalloc must return Z_NULL if there is not enough memory for the object.
|
|
If zlib is used in a multi-threaded application, zalloc and zfree must be
|
|
thread safe.
|
|
|
|
On 16-bit systems, the functions zalloc and zfree must be able to allocate
|
|
exactly 65536 bytes, but will not be required to allocate more than this
|
|
if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
|
|
pointers returned by zalloc for objects of exactly 65536 bytes *must*
|
|
have their offset normalized to zero. The default allocation function
|
|
provided by this library ensures this (see zutil.c). To reduce memory
|
|
requirements and avoid any allocation of 64K objects, at the expense of
|
|
compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
|
|
|
|
The fields total_in and total_out can be used for statistics or
|
|
progress reports. After compression, total_in holds the total size of
|
|
the uncompressed data and may be saved for use in the decompressor
|
|
(particularly if the decompressor wants to decompress everything in
|
|
a single step).
|
|
*/
|
|
|
|
/* constants */
|
|
|
|
#define Z_NO_FLUSH 0
|
|
#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
|
|
#define Z_SYNC_FLUSH 2
|
|
#define Z_FULL_FLUSH 3
|
|
#define Z_FINISH 4
|
|
#define Z_BLOCK 5
|
|
/* Allowed flush values; see deflate() and inflate() below for details */
|
|
|
|
#define Z_OK 0
|
|
#define Z_STREAM_END 1
|
|
#define Z_NEED_DICT 2
|
|
#define Z_ERRNO (-1)
|
|
#define Z_STREAM_ERROR (-2)
|
|
#define Z_DATA_ERROR (-3)
|
|
#define Z_MEM_ERROR (-4)
|
|
#define Z_BUF_ERROR (-5)
|
|
#define Z_VERSION_ERROR (-6)
|
|
/* Return codes for the compression/decompression functions. Negative
|
|
* values are errors, positive values are used for special but normal events.
|
|
*/
|
|
|
|
#define Z_NO_COMPRESSION 0
|
|
#define Z_BEST_SPEED 1
|
|
#define Z_BEST_COMPRESSION 9
|
|
#define Z_DEFAULT_COMPRESSION (-1)
|
|
/* compression levels */
|
|
|
|
#define Z_FILTERED 1
|
|
#define Z_HUFFMAN_ONLY 2
|
|
#define Z_RLE 3
|
|
#define Z_FIXED 4
|
|
#define Z_DEFAULT_STRATEGY 0
|
|
/* compression strategy; see deflateInit2() below for details */
|
|
|
|
#define Z_BINARY 0
|
|
#define Z_TEXT 1
|
|
//#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */
|
|
#define Z_UNKNOWN 2
|
|
/* Possible values of the data_type field (though see inflate()) */
|
|
|
|
#define Z_DEFLATED 8
|
|
/* The deflate compression method (the only one supported in this version) */
|
|
|
|
#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */
|
|
|
|
#define zlib_version zlibVersion()
|
|
/* for compatibility with versions < 1.0.2 */
|
|
|
|
|
|
typedef voidp gzFile;
|
|
|
|
ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
|
|
/*
|
|
Opens a gzip (.gz) file for reading or writing. The mode parameter
|
|
is as in fopen ("rb" or "wb") but can also include a compression level
|
|
("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
|
|
Huffman only compression as in "wb1h", or 'R' for run-length encoding
|
|
as in "wb1R". (See the description of deflateInit2 for more information
|
|
about the strategy parameter.)
|
|
|
|
gzopen can be used to read a file which is not in gzip format; in this
|
|
case gzread will directly read from the file without decompression.
|
|
|
|
gzopen returns NULL if the file could not be opened or if there was
|
|
insufficient memory to allocate the (de)compression state; errno
|
|
can be checked to distinguish the two cases (if errno is zero, the
|
|
zlib error is Z_MEM_ERROR). */
|
|
|
|
ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
|
|
/*
|
|
Dynamically update the compression level or strategy. See the description
|
|
of deflateInit2 for the meaning of these parameters.
|
|
gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
|
|
opened for writing.
|
|
*/
|
|
|
|
ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
|
|
/*
|
|
Reads the given number of uncompressed bytes from the compressed file.
|
|
If the input file was not in gzip format, gzread copies the given number
|
|
of bytes into the buffer.
|
|
gzread returns the number of uncompressed bytes actually read (0 for
|
|
end of file, -1 for error). */
|
|
|
|
ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
|
|
voidpc buf, unsigned len));
|
|
/*
|
|
Writes the given number of uncompressed bytes into the compressed file.
|
|
gzwrite returns the number of uncompressed bytes actually written
|
|
(0 in case of error).
|
|
*/
|
|
|
|
ZEXTERN int ZEXPORT gzclose OF((gzFile file));
|
|
/*
|
|
Flushes all pending output if necessary, closes the compressed file
|
|
and deallocates all the (de)compression state. The return value is the zlib
|
|
error number (see function gzerror below).
|
|
*/
|
|
|
|
#ifdef __cplusplus
|
|
} // extern "C"
|
|
#endif
|
|
|
|
#endif /* GZIO_H */
|