### zpipe.c Header and Version History

Source: https://zlib.net/zlib_how.html

This is the header and version history for the zpipe.c example program, which demonstrates zlib's inflate() and deflate() functions.

```c
**
/* zpipe.c: example of proper use of zlib's inflate() and deflate()
   Not copyrighted -- provided to the public domain
   Version 1.5  11 February 2026  Mark Adler */

/* Version history:
   1.0  30 Oct 2004  First version
   1.1   8 Nov 2004  Add void casting for unused return values
                     Use switch statement for inflate() return values
   1.2   9 Nov 2004  Add assertions to document zlib guarantees
   1.3   6 Apr 2005  Remove incorrect assertion in inf()
   1.4  11 Dec 2005  Add hack to avoid MSDOS end-of-file conversions
                     Avoid some compiler warnings for input and output buffers
   1.5  11 Feb 2026  Use underscores for Windows POSIX names
 **
```

--------------------------------

### Simple File Compression Example

Source: https://zlib.net/nelson

Demonstrates how to use the ZlibEngine class to compress a file. Ensure the zlibengn.h header is included and a ZlibEngine object is constructed before calling the compress method.

```cpp
#include <zlibengn.h>

int foo()
{
    ZlibEngine engine;
    return engine.compress( "INPUT.DAT", "INPUT.DA_");
}
```

--------------------------------

### Compression Loop

Source: https://zlib.net/zlib_how.html

Starts a do-while loop to compress data in chunks until the end of the source file is reached.

```c
**
    /* compress until end of file */
    do {
**
```

--------------------------------

### Get ZLIB Version Information

Source: https://zlib.net/manual.html

Defines the current version string and numerical version of the zlib library.

```c
#define ZLIB_VERSION "1.3.1"
#define ZLIB_VERNUM 0x1310

```

--------------------------------

### CRC Arithmetic Division Example

Source: https://zlib.net/crc_v3.txt

Provides a detailed worked example of division in CRC arithmetic. The process relies on a weak definition of magnitude based on the highest set bit's position.

```text
            1100001010
       _______________
10011 ) 11010110110000
        10011,,.,,....
        -----,,.,,....
         10011,.,,....
         10011,.,,....
         -----,.,,....
          00001.,,....
          00000.,,....
          -----.,,....
           00010,,....
           00000,,....
           -----,,....
            00101,....
            00000,....
            -----,....
             01011....
             00000....
             -----
              10110...
              10011...
              ----...
               01010..
               00000..
               ----..
                10100.
                10011.
                ----.
                 01110
                 00000
                 -----
                  1110 = Remainder
```

--------------------------------

### Get zlib Error Message

Source: https://zlib.net/manual.html

Retrieves a string describing the error code returned by zlib functions. No setup is required.

```c
ZEXTERN const char   * ZEXPORT zError(int);
```

--------------------------------

### Example of Highly Compressible Data

Source: https://zlib.net/feldspar.html

This snippet shows a sample string that is highly compressible due to repeated sequences.

```plaintext
        Blah blah blah blah blah!


```

--------------------------------

### Get Zlib Version Function Signature

Source: https://zlib.net/manual.html

Declaration of the zlibVersion function, which returns the version string of the zlib library.

```c
ZEXTERN const char * ZEXPORT zlibVersion(void);
```

--------------------------------

### Process Input with Deflate

Source: https://zlib.net/zlib_how.html

This is a placeholder comment indicating the start of a loop to process input data using the deflate function until the output buffer is full or the compression is finished.

```c
/* run deflate() on input until output buffer not full, finish
           compression if all of source has been read in */
        do {
```

--------------------------------

### CRC Arithmetic Addition Example

Source: https://zlib.net/crc_v3.txt

Demonstrates addition in CRC arithmetic, where each bit position is XORed without carries. This is equivalent to standard binary addition without the carry operation.

```text
        10011011
       +11001010
        --------
        01010001
        --------
```

--------------------------------

### Initialize Compression Stream and Read Input

Source: https://zlib.net/zlib_how.html

Reads data from the source file into an input buffer and sets up the zlib stream for compression. Handles potential read errors by cleaning up the zlib state.

```c
strm.avail_in = fread(in, 1, CHUNK, source);
        if (ferror(source)) {
            (void)deflateEnd(&strm);
            return Z_ERRNO;
        }
        flush = feof(source) ? Z_FINISH : Z_NO_FLUSH;
        strm.next_in = in;
```

--------------------------------

### Initialize Deflate Compression with Advanced Options

Source: https://zlib.net/manual.html

Use deflateInit2 to initialize compression with specific method, window size, memory allocation, and strategy. Supports zlib, gzip, or raw deflate output.

```c
ZEXTERN int ZEXPORT deflateInit2(z_streamp strm,
                                 int  level,
                                 int  method,
                                 int  windowBits,
                                 int  memLevel,
                                 int  strategy);
```

--------------------------------

### Get Current CRC Value

Source: https://zlib.net/crc_v3.txt

Returns the CRC value for the message bytes processed so far.

```APIDOC
## cm_crc

### Description
Returns the CRC value for the message bytes processed so far. If the CRC is a 16-bit value, it will be in the bottom 16 bits.

### Method
ulong

### Parameters
- **p_cm** (p_cm_t) - Pointer to the CRC model instance.

### Endpoint
N/A (Function Call)
```

--------------------------------

### Get current offset in a gzip file

Source: https://zlib.net/manual.html

Retrieves the current offset within the uncompressed gzip stream.

```c
ZEXTERN z_off_t ZEXPORT gzoffset(gzFile file);

```

--------------------------------

### Initialize inflateBack with custom window

Source: https://zlib.net/manual.html

Initializes the inflateBack function, which allows for custom inflation routines. Requires a stream, window bits for compression format, and a window buffer.

```c
ZEXTERN int ZEXPORT inflateBackInit(z_streamp strm, int windowBits,
                                    unsigned char FAR *window);
```

--------------------------------

### Initialize inflate with window bits

Source: https://zlib.net/manual.html

Use inflateInit2 to initialize the inflate state, specifying window bits for history buffer size. Supports raw deflate, zlib, and gzip formats.

```c
ZEXTERN int ZEXPORT inflateInit2(z_streamp strm, int windowBits);
```

--------------------------------

### deflateInit

Source: https://zlib.net/manual.html

Initializes the `z_stream` structure for compression. It sets up the compression level and other parameters required for the `deflate` function.

```APIDOC
## deflateInit

### Description
Initializes the `z_stream` structure for compression. It sets up the compression level and other parameters required for the `deflate` function.

### Function Signature
```c
ZEXTERN int ZEXPORT deflateInit(z_streamp strm, int level);
```

### Parameters
#### Path Parameters
- **strm** (z_streamp) - A pointer to the `z_stream` structure to be initialized.
- **level** (int) - The compression level. Must be `Z_DEFAULT_COMPRESSION`, or between 0 and 9. 0 gives no compression, 1 gives best speed, 9 gives best compression. `Z_DEFAULT_COMPRESSION` is a compromise.

### Return Value
- **Z_OK**: Success.
- **Z_MEM_ERROR**: Not enough memory.
- **Z_STREAM_ERROR**: Invalid compression level.
- **Z_VERSION_ERROR**: `zlib_version` is incompatible with `ZLIB_VERSION`.

### Notes
- This function does not perform compression; it only initializes the stream structure.
- The `msg` field in the `z_stream` structure will be set to null if there is no error.
```

--------------------------------

### Initialize inflateBack

Source: https://zlib.net/manual.html

Must be called first to allocate and initialize the internal state with the user-provided window buffer.

```c
ZEXTERN int ZEXPORT inflateBackInit(z_streamp strm, int windowBits, unsigned char FAR *window);
```

--------------------------------

### Get CRC Table

Source: https://zlib.net/manual.html

Returns a pointer to the CRC table used by zlib. This is a constant table and does not require any initialization.

```c
ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table(void);
```

--------------------------------

### Include Standard Libraries

Source: https://zlib.net/zlib_how.html

Includes standard C libraries for input/output, string manipulation, and assertions, along with the zlib library header.

```c
**
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "zlib.h"
**
```

--------------------------------

### Get inflate dictionary

Source: https://zlib.net/manual.html

Use inflateGetDictionary to retrieve the dictionary that was used by inflate. This is useful for debugging or if the dictionary needs to be reused.

```c
ZEXTERN int ZEXPORT inflateGetDictionary(z_streamp strm,
                                         Bytef *dictionary,
                                         uInt  *dictLength);
```

--------------------------------

### zlib Inf: Initialization variables

Source: https://zlib.net/zlib_how.html

Sets up the necessary variables for the `inf()` decompression function, including the z_stream structure and buffers for input and output data.

```c
    int ret;
    unsigned have;
    z_stream strm;
    unsigned char in[CHUNK];
    unsigned char out[CHUNK];

```

--------------------------------

### Get Inflate Codes Used

Source: https://zlib.net/manual.html

Returns the number of Huffman codes used during the inflate process. This can be useful for analyzing compression efficiency.

```c
ZEXTERN unsigned long  ZEXPORT inflateCodesUsed(z_streamp);
```

--------------------------------

### First Step in Huffman Tree Construction

Source: https://zlib.net/feldspar.html

Illustrates the initial step of combining the two elements with the lowest weights (D and E) into a parent node, forming the first branches of the Huffman tree.

```text
     ( )
  0 /   \ 1
   D     E

```

--------------------------------

### Custom ZlibEngine with Progress Feedback

Source: https://zlib.net/nelson

This snippet shows how to derive a custom class from ZlibEngine to implement a progress reporting function. The 'progress' method displays the completion percentage and allows for user interruption.

```cpp
class MyZlibEngine : public ZlibEngine {
    public :
        void progress( int percent )
        {
            printf( "%3d%%\b\b\b\b", percent );
            if ( kbhit() ) {
                getch();
                m_AbortFlag = 1;
            }
        } 
};
```

--------------------------------

### CRC Arithmetic Subtraction Example

Source: https://zlib.net/crc_v3.txt

Illustrates subtraction in CRC arithmetic, which is identical to addition and equivalent to the XOR operation. It involves a 'wraparound' for 0-1 cases.

```text
        10011011
       -11001010
        --------
        01010001
        --------
```

--------------------------------

### File Compression Implementation

Source: https://zlib.net/nelson

This code snippet demonstrates the process of compressing data from an input file to an output file using zlib's deflate function. It handles buffer management and repeated calls to deflate until all input is processed.

```c
z_stream z;
char input_buffer[ 1024 ];
char output_buffer[ 1024 ];
FILE *fin;
FILE *fout;
int status;
/*
 * Setup code for your specific problem
 */
    z.avail_in = 0;
    z.next_out = output_buffer;
    z.avail_out = 1024;
    for ( ; ; ) {
        if ( z.avail_in == 0 ) {
            z.next_in = input_buffer;
            z.avail_in = fread( input_buffer, 1, 1024, fin );
        }
        if ( z.avail_in == 0 )
             break;
        status = deflate( &z, Z_NO_FLUSH );
        int count = 1024 - z.avail_out;
        if ( count )
            fwrite ( output_buffer, 1, count, fout );
        z.next_out = output_buffer;
        z.avail_out = 1024;
    }
}
```

--------------------------------

### Get current position in a gzip file

Source: https://zlib.net/manual.html

Returns the current offset location within the uncompressed stream. Equivalent to gzseek(file, 0L, SEEK_CUR).

```c
ZEXTERN z_off_t ZEXPORT gztell(gzFile file);

```

--------------------------------

### Initialize Inflate Stream with Window Bits

Source: https://zlib.net/manual.html

Initializes the inflate stream, specifying the window size. This is a crucial step before decompressing data.

```c
ZEXTERN int ZEXPORT inflateInit2(z_streamp strm,
                                 int  windowBits);
```

--------------------------------

### Get Zlib Compile Flags

Source: https://zlib.net/manual.html

Returns a value representing compile-time flags that affect zlib's behavior, such as type sizes and enabled features.

```c
ZEXTERN uLong ZEXPORT zlibCompileFlags(void);
```

--------------------------------

### Initial Element Weights for Huffman Coding

Source: https://zlib.net/feldspar.html

This table shows the initial elements and their associated weights (frequencies) used as input for the Huffman coding algorithm.

```text
    A    16
    B    32
    C    32
    D     8
    E     8

```

--------------------------------

### zlib Deflate: Clean up and return

Source: https://zlib.net/zlib_how.html

A simple snippet showing the cleanup process after deflate operations using deflateEnd() and returning Z_OK on success.

```c
    /* clean up and return */
    (void)deflateEnd(&strm);
    return Z_OK;
```

--------------------------------

### Get gzip error information

Source: https://zlib.net/manual.html

Retrieves the error number and a descriptive string for the last error that occurred. The returned string should not be modified and may be invalidated by future calls.

```c
ZEXTERN const char * ZEXPORT gzerror(gzFile file, int *errnum);

```

--------------------------------

### Perform custom inflation with inflateBack

Source: https://zlib.net/manual.html

Performs inflation using custom input and output functions. This is useful for integrating zlib decompression with custom data handling or storage.

```c
typedef unsigned (*in_func)(void FAR *, z_const unsigned char FAR * FAR *);
typedef int (*out_func)(void FAR *, unsigned char FAR *, unsigned);

ZEXTERN int ZEXPORT inflateBack(z_streamp strm,
                                in_func in, void FAR *in_desc,
                                out_func out, void FAR *out_desc);
```

--------------------------------

### CRC Arithmetic Multiplication Example

Source: https://zlib.net/crc_v3.txt

Shows the process of multiplication in CRC arithmetic. It involves shifting and summing the multiplicand based on the bits of the multiplier, using CRC addition for the summation.

```text
        1101
      x 1011
        ----
        1101
       1101.
      0000..
     1101...
     -------
     1111111  Note: The sum uses CRC addition
     -------
```

--------------------------------

### Initialize Deflate Compression

Source: https://zlib.net/manual.html

Initializes the deflate compression stream. The compression level must be between 0 and 9, or Z_DEFAULT_COMPRESSION. Returns Z_OK on success, or an error code like Z_MEM_ERROR or Z_STREAM_ERROR.

```c
ZEXTERN int ZEXPORT deflateInit(z_streamp strm, int level);
```

--------------------------------

### gzopen

Source: https://zlib.net/manual.html

Opens a gzip file for reading or writing. It can handle compressed and uncompressed files, and supports append mode. Returns NULL on failure.

```APIDOC
## gzopen

### Description
Opens a gzip file specified by 'path' with the given 'mode'. Supports reading ('r'), writing ('w'), and appending ('a') compressed or uncompressed data. The mode can include flags like '9' for compression level, 'f' for filtering, 'h' for header, 'R' for raw deflate, 'F' for no header, 'T' for text mode, and 'x' for exclusive creation. Reading automatically detects gzip headers. Appending adds a new gzip stream to the end of the file.

### Method
`gzopen(const char *path, const char *mode)`

### Parameters
- **path** (const char *) - The path to the file.
- **mode** (const char *) - The mode in which to open the file (e.g., "rb", "wb", "wb9", "wb6f").

### Return Value
- `gzFile` - A handle to the opened gzip file, or `NULL` if an error occurred (e.g., file not opened, insufficient memory, invalid mode). `errno` can be checked for file opening errors.
```

--------------------------------

### Get zlib Dictionary Data

Source: https://zlib.net/manual.html

Retrieves data from the zlib compression dictionary. The returned length may be less than the window size, even if more input was provided. Applications needing the last window-size bytes of input must save them externally.

```c
ZEXTERN int ZEXPORT deflateGetDictionary(z_streamp strm,
                                         Bytef *dictionary,
                                         uInt  *dictLength);
```

--------------------------------

### Get Pending Deflate Data Information

Source: https://zlib.net/manual.html

Retrieves the number of pending output bytes and bits that have been computed but not yet written to the output buffer. Useful for understanding the internal state of the deflate stream. Returns Z_OK on success or Z_STREAM_ERROR for an inconsistent stream.

```c
ZEXTERN int ZEXPORT deflatePending(z_streamp strm,
                                   unsigned *pending,
                                   int *bits);
```

--------------------------------

### Second Step in Huffman Tree Construction

Source: https://zlib.net/feldspar.html

Shows the next step where the combined node (D-E) with its summed weight is joined with another element (A) based on their weights, further building the Huffman tree.

```text
       ( )
    0 /   \ 1
    ( )    A
 0 /   \ 1
  D     E

```

--------------------------------

### Initialize inflate stream

Source: https://zlib.net/manual.html

Initializes the inflate stream. Returns Z_OK on success, Z_MEM_ERROR for memory issues, Z_VERSION_ERROR for incompatible library versions, or Z_STREAM_ERROR for invalid parameters. Does not perform decompression; this is handled by inflate().

```c
ZEXTERN int ZEXPORT inflateInit(z_streamp strm);
```

--------------------------------

### Initialize Deflate State

Source: https://zlib.net/zlib_how.html

Initializes the zlib deflate state using deflateInit(). It checks for memory allocation errors and version mismatches between zlib.h and the linked library.

```c
**
    /* allocate deflate state */
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    ret = deflateInit(&strm, level);
    if (ret != Z_OK)
        return ret;
**
```

--------------------------------

### zlib Inf: Initialize z_stream structure

Source: https://zlib.net/zlib_how.html

Initializes the z_stream structure for decompression. It sets memory allocation functions to NULL (using zlib's defaults) and then calls inflateInit() to prepare for decompression.

```c
    /* allocate inflate state */
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    strm.avail_in = 0;
    strm.next_in = Z_NULL;
    ret = inflateInit(&strm);
    if (ret != Z_OK)
        return ret;

```

--------------------------------

### gzrewind

Source: https://zlib.net/manual.html

Resets the position of the file to the beginning.

```APIDOC
## gzrewind

### Description
Resets the position of the file to the beginning.

### Method
ZEXTERN int ZEXPORT gzrewind(gzFile file)

### Parameters
#### Path Parameters
- **file** (gzFile) - Description not provided

### Response
gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET).
```

--------------------------------

### Handling Z_BUF_ERROR in deflate() or inflate()

Source: https://zlib.net/zlib_faq.html

Verify avail_in and avail_out are non-zero. When using Z_FINISH, ensure avail_out is sufficient for pending input. Z_BUF_ERROR is not fatal and can be retried.

```text
Before making the call, make sure that `avail_in` and `avail_out` are not zero. When setting the parameter flush equal to `Z_FINISH`, also make sure that `avail_out` is big enough to allow processing all pending input. Note that a `Z_BUF_ERROR` is not fatal--another call to `deflate()` or `inflate()` can be made with more input or output space. A `Z_BUF_ERROR` may in fact be unavoidable depending on how the functions are used, since it is not possible to tell whether or not there is more output pending when `strm.avail_out` returns with zero. See http://zlib.net/zlib_how.html for a heavily annotated example.
```

--------------------------------

### Main Function for CRC Table Generator

Source: https://zlib.net/crc_v3.txt

The main function initializes the program, sets up the output file, calls the table generation function, and handles file closing and success messages. It also includes parameter checking.

```C
main ()
{
 printf("\n");
 printf("Rocksoft^tm Model CRC Algorithm Table Generation Program V1.0\n");
 printf("-------------------------------------------------------------\n");
 printf("Output file is \"%s\".\n",TB_FILE);
 chkparam();
 outfile = fopen(TB_FILE,"w"); chk_err("");
 gentable();
 if (fclose(outfile) != 0)
    chk_err("main: Couldn't close output file.");
 printf("\nSUCCESS: The table has been successfully written.\n");
}

/******************************************************************************/
/*                             End of crctable.c                              */
/******************************************************************************/
```

--------------------------------

### inflateSetDictionary

Source: https://zlib.net/manual.html

Sets a dictionary for compression. The dictionary should contain byte sequences likely to be encountered later in the data. The effectiveness depends on the data's predictability and the dictionary's structure relative to the compression window size.

```APIDOC
## inflateSetDictionary

### Description
Sets a dictionary for compression. The dictionary should contain byte sequences likely to be encountered later in the data. The effectiveness depends on the data's predictability and the dictionary's structure relative to the compression window size.

### Method
Not specified (likely a function call within the zlib library)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **dictionary** (byte sequences) - Required - The dictionary to be used for compression.
- **dictLength** (integer) - Required - The length of the dictionary.

### Request Example
None

### Response
#### Success Response
- **Z_OK** - Success

#### Response Example
None

ERROR HANDLING:
- **Z_STREAM_ERROR** - If a parameter is invalid or the stream state is inconsistent.
```

--------------------------------

### Compress Data

Source: https://zlib.net/manual.html

Compresses source data into destination buffer. Ensure sufficient space in destLen. Returns Z_OK on success.

```c
ZEXTERN int ZEXPORT compress(Bytef *dest, uLongf *destLen,
                             const Bytef *source, uLong sourceLen);

```

--------------------------------

### Open gzip File

Source: https://zlib.net/manual.html

Opens a gzip-compressed file for reading or writing. Supports various modes including append ('a'), exclusive creation ('x'), and close-on-exec ('e').

```c
** ZEXTERN gzFile ZEXPORT gzopen(const char *path, const char *mode);
**
```

--------------------------------

### Set gzip Compression Parameters

Source: https://zlib.net/manual.html

Sets the compression level and strategy for a gzip stream. Must be called after opening the file and before any write operations.

```c
** ZEXTERN int ZEXPORT gzsetparams(gzFile file, int level, int strategy);
**
```

--------------------------------

### Compress Data with Level

Source: https://zlib.net/manual.html

Compresses source data with a specified compression level. Returns Z_OK on success, or an error code for memory, buffer, or invalid level issues.

```c
ZEXTERN int ZEXPORT compress2(Bytef *dest, uLongf *destLen,
                              const Bytef *source, uLong sourceLen,
                              int level);

```

--------------------------------

### Inflate Cleanup and Return in zlib

Source: https://zlib.net/zlib_how.html

Cleans up inflate resources using inflateEnd and returns the final status, indicating success (Z_OK) or a data error (Z_DATA_ERROR).

```c
**
    /* clean up and return */
    (void)inflateEnd(&strm);
    return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR;
}
**
```

--------------------------------

### Open gzFile with Wide Characters (Windows)

Source: https://zlib.net/manual.html

Platform-specific function for Windows that opens a gzip file using wide character paths. Requires the _WIN32 preprocessor definition and not Z_SOLO.

```c
#if defined(_WIN32) && !defined(Z_SOLO)
ZEXTERN gzFile         ZEXPORT gzopen_w(const wchar_t *path,
                                        const char *mode);
#endif
```

--------------------------------

### ZlibEngine Wrapper Class Definition

Source: https://zlib.net/nelson

The ZlibEngine class definition, derived from z_stream, provides a simplified API for file compression and decompression. It includes methods for compression, decompression, and managing the user interface during the process.

```cpp
class ZlibEngine : public z_stream {
    public :
        ZlibEngine();
            int compress( const char *input,
                          const char *output,
                          int level = 6 );
        int decompress( const char *input,
                        const char *output );
        void set_abort_flag( int i ){ m_AbortFlag = i; }
    protected :
        int percent();
        int load_input();
        int flush_output();
    protected :
        virtual void progress( int percent ){};
        virtual void status( char *message ){};
    protected :
        int m_AbortFlag;
        FILE *fin;
        FILE *fout;
        long length;
        int err;
        enum { input_length = 4096 };
        unsigned char input_buffer[ input_length ];
        enum { output_length = 4096 };
        unsigned char output_buffer[ output_length ];
};
```

--------------------------------

### Perform Deflate Compression

Source: https://zlib.net/manual.html

Performs one or both actions: compressing input data from strm->next_in and updating strm->avail_in, or generating output data to strm->next_out and updating strm->avail_out. The flush parameter controls whether to force output generation.

```c
ZEXTERN int ZEXPORT deflate(z_streamp strm, int flush);
```

--------------------------------

### Tune Deflate Compression Parameters

Source: https://zlib.net/manual.html

Adjusts internal compression parameters for deflate. Call after deflateInit() or deflateInit2(). Returns Z_OK on success or Z_STREAM_ERROR for an invalid stream.

```c
ZEXTERN int ZEXPORT deflateTune(z_streamp strm,
                                int good_length,
                                int max_lazy,
                                int nice_length,
                                int max_chain);
```

--------------------------------

### Set Output Buffer for Deflate

Source: https://zlib.net/zlib_how.html

Configures the output buffer for the deflate function, setting its size and pointer.

```c
strm.avail_out = CHUNK;
            strm.next_out = out;
```

--------------------------------

### gzdopen

Source: https://zlib.net/manual.html

Opens a gzip file associated with an existing file descriptor. Similar to gzopen but operates on a file descriptor. The returned gzFile will close the file descriptor on gzclose.

```APIDOC
## gzdopen

### Description
Associates a gzip stream with an existing file descriptor 'fd' opened in the specified 'mode'. This is useful when working with file descriptors obtained from other functions like `open`, `dup`, `creat`, `pipe`, or `fileno`. The `gzFile` returned will close the file descriptor `fd` when `gzclose` is called. To keep the original file descriptor open, duplicate it first using `dup()`.

### Method
`gzdopen(int fd, const char *mode)`

### Parameters
- **fd** (int) - The file descriptor to associate with the gzip stream.
- **mode** (const char *) - The mode in which to open the file (e.g., "rb", "wb").

### Return Value
- `gzFile` - A handle to the opened gzip file, or `NULL` if an error occurred (e.g., insufficient memory, invalid mode, `fd` is -1). The validity of `fd` is checked on the next I/O operation.
```

--------------------------------

### Basic C Implementation of Table-Driven CRC

Source: https://zlib.net/crc_v3.txt

This C code snippet demonstrates the main loop of the table-driven CRC algorithm. It initializes the register, iterates through the message length, and applies the core logic involving shifts, XORs, and table lookups.

```c
r=0;
while (len--)
  {
   byte t = (r >> 24) & 0xFF;
   r = (r << 8) | *p++;
   r^=table[t];
  }
```

--------------------------------

### ZIP File Merger

Source: https://zlib.net/index.html

The `zipknit.c` utility merges multiple ZIP files into a single archive. It accepts Zip64 input and can produce Zip64 output. All compression formats are supported, and encrypted entries are passed through.

```c
zipknit.c
```

--------------------------------

### Write String to Gzip File

Source: https://zlib.net/manual.html

Writes a null-terminated string to a gzip file. Returns the number of characters written, or -1 in case of error.

```c
ZEXTERN int ZEXPORT gzputs(gzFile file, const char *s);
```

--------------------------------

### XMODEM CRC Parameters

Source: https://zlib.net/crc_v3.txt

Parameters for the XMODEM CRC algorithm.

```text
Name   : "XMODEM"
Width  : 16
Poly   : 8408
Init   : 0000
RefIn  : True
RefOut : True
XorOut : 0000
Check  : ?
```

--------------------------------

### Set zlib Compression Parameters

Source: https://zlib.net/manual.html

Adjusts the compression level and strategy for an ongoing zlib stream. This function allows dynamic tuning of compression behavior.

```c
ZEXTERN int ZEXPORT deflateParams(z_streamp strm,
                                  int level,
                                  int strategy);
```

--------------------------------

### gztell

Source: https://zlib.net/manual.html

Returns the current file position, 0-based, from the beginning of the uncompressed file.

```APIDOC
## gztell

### Description
Returns the current file position, 0-based, from the beginning of the uncompressed file.

### Method
ZEXTERN z_off_t ZEXPORT gztell(gzFile file)

### Parameters
#### Path Parameters
- **file** (gzFile) - Description not provided

### Response
gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR).
```

--------------------------------

### Variadic Print to gzFile

Source: https://zlib.net/manual.html

A variadic function to write formatted output to a gzFile, similar to printf. Requires STDC or Z_HAVE_STDARG_H and not Z_SOLO.

```c
#if defined(STDC) || defined(Z_HAVE_STDARG_H)
#  ifndef Z_SOLO
ZEXTERN int            ZEXPORTVA gzvprintf(gzFile file,
                                           const char *format,
                                           va_list va);
#  endif
#endif
```

--------------------------------

### Deflate Function Variables

Source: https://zlib.net/zlib_how.html

Initializes variables for the deflate function, including zlib stream structure, buffers for input and output data, and status tracking.

```c
**
    int ret, flush;
    unsigned have;
    z_stream strm;
    unsigned char in[CHUNK];
    unsigned char out[CHUNK];
**
```

--------------------------------

### Zlib Version Constant

Source: https://zlib.net/manual.html

Defines a constant that holds the zlib library version string.

```c
#define zlib_version zlibVersion()
```