zlib——compress.c文件分析

本是古典何须时尚 2022-12-08 01:36 97阅读 0赞

下面代码是上一篇博客所讲的zpipe.c，主要用于和compress.c文件进行对比。

#include <stdio.h>
    #include <string.h>
    #include <assert.h>
    #include "zlib.h"
    #if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__)
    # include <fcntl.h>
    # include <io.h>
    # define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
    #else
    # define SET_BINARY_MODE(file)
    #endif
    #define CHUNK 16384
    /* Compress from file source to file dest until EOF on source. def() returns Z_OK on success, Z_MEM_ERROR if memory could not be allocated for processing, Z_STREAM_ERROR if an invalid compression level is supplied, Z_VERSION_ERROR if the version of zlib.h and the version of the library linked do not match, or Z_ERRNO if there is an error reading or writing the files. */
    int def(FILE *source, FILE *dest, int level)
    { 
        int ret, flush;
        unsigned have;
        z_stream strm;
        unsigned char in[CHUNK];
        unsigned char out[CHUNK];
        /* 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;
        /* compress until end of file */
        do { 
            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;
            /* run deflate() on input until output buffer not full, finish compression if all of source has been read in */
            do { 
                strm.avail_out = CHUNK;
                strm.next_out = out;
                ret = deflate(&strm, flush);    /* no bad return value */
                assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
                have = CHUNK - strm.avail_out;
                if (fwrite(out, 1, have, dest) != have || ferror(dest)) { 
                    (void)deflateEnd(&strm);
                    return Z_ERRNO;
                }
            } while (strm.avail_out == 0);
            assert(strm.avail_in == 0);     /* all input will be used */
            /* done when last data in file processed */
        } while (flush != Z_FINISH);
        assert(ret == Z_STREAM_END);        /* stream will be complete */
    
        /* clean up and return */
        (void)deflateEnd(&strm);
        return Z_OK;
    }
    
    /* Decompress from file source to file dest until stream ends or EOF. inf() returns Z_OK on success, Z_MEM_ERROR if memory could not be allocated for processing, Z_DATA_ERROR if the deflate data is invalid or incomplete, Z_VERSION_ERROR if the version of zlib.h and the version of the library linked do not match, or Z_ERRNO if there is an error reading or writing the files. */
    int inf(FILE *source, FILE *dest)
    { 
        int ret;
        unsigned have;
        z_stream strm;
        unsigned char in[CHUNK];
        unsigned char out[CHUNK];
        /* 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;
        /* decompress until deflate stream ends or end of file */
        do { 
            strm.avail_in = fread(in, 1, CHUNK, source);
            if (ferror(source)) { 
                (void)inflateEnd(&strm);
                return Z_ERRNO;
            }
            if (strm.avail_in == 0)
                break;
            strm.next_in = in;
            /* run inflate() on input until output buffer not full */
            do { 
                strm.avail_out = CHUNK;
                strm.next_out = out;
                ret = inflate(&strm, Z_NO_FLUSH);
                assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
                switch (ret) { 
                case Z_NEED_DICT:
                    ret = Z_DATA_ERROR;     /* and fall through */
                case Z_DATA_ERROR:
                case Z_MEM_ERROR:
                    (void)inflateEnd(&strm);
                    return ret;
                }
                have = CHUNK - strm.avail_out;
                if (fwrite(out, 1, have, dest) != have || ferror(dest)) { 
                    (void)inflateEnd(&strm);
                    return Z_ERRNO;
                }
            } while (strm.avail_out == 0);
            /* done when inflate() says it's done */
        } while (ret != Z_STREAM_END);
        /* clean up and return */
        (void)inflateEnd(&strm);
        return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR;
    }
    
    /* report a zlib or i/o error */
    void zerr(int ret)
    { 
        fputs("zpipe: ", stderr);
        switch (ret) { 
        case Z_ERRNO:
            if (ferror(stdin))
                fputs("error reading stdin\n", stderr);
            if (ferror(stdout))
                fputs("error writing stdout\n", stderr);
            break;
        case Z_STREAM_ERROR:
            fputs("invalid compression level\n", stderr);
            break;
        case Z_DATA_ERROR:
            fputs("invalid or incomplete deflate data\n", stderr);
            break;
        case Z_MEM_ERROR:
            fputs("out of memory\n", stderr);
            break;
        case Z_VERSION_ERROR:
            fputs("zlib version mismatch!\n", stderr);
        }
    }
    
    /* compress or decompress from stdin to stdout */
    int main(int argc, char **argv)
    { 
        int ret;
        /* avoid end-of-line conversions */
        SET_BINARY_MODE(stdin);
        SET_BINARY_MODE(stdout);
        /* do compression if no arguments */
        if (argc == 1) { 
            ret = def(stdin, stdout, Z_DEFAULT_COMPRESSION);
            if (ret != Z_OK)
                zerr(ret);
            return ret;
        }
        /* do decompression if -d specified */
        else if (argc == 2 && strcmp(argv[1], "-d") == 0) { 
            ret = inf(stdin, stdout);
            if (ret != Z_OK)
                zerr(ret);
            return ret;
        }
        /* otherwise, report usage */
        else { 
            fputs("zpipe usage: zpipe [-d] < source > dest\n", stderr);
            return 1;
        }
    }

从compress.c中的compress2函数看起，其作用是将源buffer中的数据压缩放到目标buffer中。压缩level参数和deflateInit函数的level含义相同。sourceLen是源buffer中数据的字节数。destLen是目标buffer的大小，理论上需要至少比源buffer大0.1%加12字节。函数执行结束后destLen是压缩完的大小。当压缩成功则反Z\_OK，当内存不足返回Z\_MEM\_ERROR，当输出Buffer没有足够空间时返回Z\_BUF\_ERROR，当level参数非法返回Z\_STREAM\_ERROR。

/* compress.c -- compress a memory buffer */
    #define ZLIB_INTERNAL
    #include "zlib.h"
    /* =========================================================================== Compresses the source buffer into the destination buffer. The level parameter has the same meaning as in deflateInit. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size of the destination buffer, which must be at least 0.1% larger than sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the compressed buffer. compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if there was not enough room in the output buffer, Z_STREAM_ERROR if the level parameter is invalid. */
    int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
        Bytef *dest;
        uLongf *destLen;
        const Bytef *source;
        uLong sourceLen;
        int level;
    { 
        z_stream stream;
        int err;
        const uInt max = (uInt)-1;
        uLong left;
        left = *destLen;
        *destLen = 0;
        stream.zalloc = (alloc_func)0;
        stream.zfree = (free_func)0;
        stream.opaque = (voidpf)0;
    
        err = deflateInit(&stream, level);
        if (err != Z_OK) return err;
    
        stream.next_out = dest;
        stream.avail_out = 0;
        stream.next_in = (z_const Bytef *)source;
        stream.avail_in = 0;
    
        do { 
            if (stream.avail_out == 0) { 
                stream.avail_out = left > (uLong)max ? max : (uInt)left;
                left -= stream.avail_out;
            }
            if (stream.avail_in == 0) { 
                stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen;
                sourceLen -= stream.avail_in;
            }
            err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH);
        } while (err == Z_OK);
    
        *destLen = stream.total_out;
        deflateEnd(&stream);
        return err == Z_STREAM_END ? Z_OK : err;
    }
    
    int ZEXPORT compress (dest, destLen, source, sourceLen)
        Bytef *dest;
        uLongf *destLen;
        const Bytef *source;
        uLong sourceLen;
    { 
        return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
    }
    
    /* =========================================================================== If the default memLevel or windowBits for deflateInit() is changed, then this function needs to be updated. */
    uLong ZEXPORT compressBound (sourceLen)
        uLong sourceLen;
    { 
        return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
               (sourceLen >> 25) + 13;
    }