官方手册 :
http://www.zlib.net/manual.html
参考连接 :
http://blog.csdn.net/zhoudaxia/article/details/8039519
http://www.oschina.net/code/snippet_65636_22542
http://blog.163.com/bh_binghu/blog/static/94553512011626102054571/
请多多支持以上作者…
另外,推荐下载源码同步学习.
研究了好久的zlib,今天终于可以拿得出手了.这里分享一下使用的经验.
基础数据结构
z_stream : 压缩算法,压缩程度以及输入输出buffer和长度等都保存在这里,可以理解为压缩上下文.
常用的函数
deflateInit : 参数比较少,里面的实现其实是调用的deflateInit2
deflateInit2 : 压缩初始化的基础函数,有很多参数,下面会重点介绍
deflate : 压缩函数.
deflateEnd : 压缩完成以后,释放空间,但是注意,仅仅是释放deflateInit中申请的空间,自己申请的空间还是需要自己释放.
inflateInit : 解压初始化函数,内部调用的inflateInit2.
inflateInit2 : 解压初始化的基础函数.后面重点介绍.
infalte : 解压函数
inflateEnd : 同deflateEnd作用类似.
compress : 全部附加选项默认压缩,内部调用compress2
compress2 : 带level的压缩方式.
uncompress : 解压缩.
压缩函数介绍
deflateInit2 :
函数原型为 : int ZEXPORT deflateInit2(z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy)
z_stream :
这个是压缩上下文,你在调用deflateInit2之前首先要做的就是初始化这个结构体,很简单,个里面的三个回调赋值就行了.连官方给出的例子也是置成NULL.所以这里直接这样初始化,strm.zalloc = NULL; strm.zfree = NULL; strm.opaque = NULL.
level :
这个参数目前可选值有四个(好吧,在我看来,有两个没啥用嘛),如下:
Z_NO_COMPRESSION : 不压缩
Z_BEST_SPEED : 速度优先,可以理解为最低限度的压缩.
Z_BEST_COMPRESSION : 压缩优先,但是速度会有些慢.
Z_DEFAULT_COMPRESSION : 没仔细看源码.compress里面用的就是这个选项.
method
: 就压缩嘛,所以选项就只有Z_DEFLATED
windowBits
: 这个选项可就有点复杂了,也很重要,取值与压缩方式如下:
* -(15 ~ 8) : 纯deflate压缩
* 15 ~ 8 : 带zlib头和尾
* > 16 : 带gzip头和尾
所以,无论是zlib的压缩还是gzip的压缩,再或者是纯deflate流,zlib都能搞定.验证方式 :
1. zlib的话可以使用命令 cat 压缩文件名 | zlib-deflate -uncompress验证(家里的电脑没有这个命令,忘记什么包里面的了.)
2. 如果是纯deflate的压缩数据,只能字节写解压的代码.注意调用inflateInit2的时候这个值要对应.
3. 如果是gzip的方式,就直接用gunzip验证.
memLevel
: 目前只有一个选项,MAX_MEM_LEVEL,无非是运行过程中对内存使用的限制.
strategy
: 直接给默认就行Z_DEFAULT_STRATEGY.
deflate :
函数原型 : ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
strm : 这个参数就是上面调用了deflateInit2初始化过后的变量.调用deflate之前,需要为它指定四个成员.
strm.next_in = 你的待压缩数据
strm.next_out = 压缩以后数据存储的buffer
strm.avail_in = 待压缩数据的长度
strm.avail_out = 压缩数据存储buffer的长度.
这个next_out 没有固定的长度,并不是说因为是压缩,压缩以后的数据一定比原来的短,所以就可以少给,一般建议起码给到next_in的长度.
flush : 没有用过别的选项,
Z_NO_FLUSH : 如果是一个大文件,没有办法一次加载进内存,那么这个选项就派上用场了.它告诉zlib我还会再给你数据的.
这个参数对应的deflate的返回值是Z_OK.
Z_FINISH : 这个标记才是告诉zlib,我没有数据了,这次是最后一个.
这个参数对应的deflate的返回值是Z_STREAM_END
deflateEnd
:
上面的描述已经足够清楚,它没有更多的作用了.
compress2
:
函数原型 : ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, int level));
如果你看了它的内部实现,就会知道,这其实就是上面三个函数的封装.供使用者偷懒用的,谁不喜欢一步到位呢.不过要明确它的缺点 :
a) 它的确很方便,但是却限制了所有的可能性,因为它只能压缩一次,也就是说内部直接调用的Z_FINISH
b) 不要觉得保存的是压缩的数据就给小buffer,有一篇博客给出的值是输入buffer的四倍.这个亏我是吃过的,前几天用这个函数,给了输入buffer的大小,我觉得足够了.但是始终返回Z_BUF_ERROR.后来看到那篇博客才恍然大悟.
解压函数介绍
有压缩自然也得有解压,并且都是一一对应的.
inflateInit2
: 初始化
函数原型 : inflateInit2(z_streamp strm, int windowBits)
strm
: 和deflate一样,初始化三个回调以后即可.有的参考文档说还需要初始化第四个选项,具体记不清哪个了.不过我试过以后发现貌似不用.
windownBits
: 含义和deflateInit2一样,而且一定要对应起来.
inflate
: 解压
函数原型 : ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
strm
: 四个参数.
strm.next_in = 你的待解压数据
strm.next_out = 解压以后数据存储的buffer
strm.avail_in = 待解压数据的长度
strm.avail_out = 解压数据存储buffer的长度.
flush
: 和deflate一样,如果是Z_NO_FLUSH说明还有数据没有解压,如果是Z_FINISH说明这是最后一包待解压数据.
inflateEnd
: 释放上面两步骤里面申请的资源.
uncompress
:
函数原型 : Z
EXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
const Bytef *source, uLong sourceLen));
dest : 解压以后的数据存在这里
destLen : dest 大小
source : 待解压数据buffer
sourceLen : 待解压数据长度
其实这个函数就是简单封装了inflateInit, inflate, inflateEnd.同样,这个函数只适合单独解压场景,不适合需要多次传入的场景.
关于返回值
现在看来,除了deflate和inflate成功会有两个返回值以外,其他的函数返回值成功的话都是Z_OK.
如果 flush == Z_NO_FLUSH, 这两个函数返回值是Z_OK
如果flush == Z_FINISH, 这两个函数的返回值是Z_STREAM_END
一定要区分.
一个简单的例子
这个例子太像官方提供的例子了.不过还是贴出来,加了几句注释,希望能够帮助理解.
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <zlib.h>
#include <time.h>
#include <errno.h>
#include <assert.h>
#define READ_LEN 8192
// gzip头
#define GZIP_MAGIC "\037\213" /* Magic header for gzip files, 1F 8B */
// 目前只有这种压缩方式
#define DEFLATED 8
// 标记压缩为快速还是高质量
#define FAST 4
#define SLOW 2
// gzip格式
// (u16)MAGIC + (u8)DEFLATE + (u8)flag + (u32)time + (u8)deflate_flag + (u8)OS_CODE
int main(int argc, char **argv)
{
if (argc < 3)
{
printf("usage : %s src_file dst_file\n", argv[1]);
return -1;
}
int ret = 0;
int rfd = 0;
uint64_t read_len = 0;
char *read_buf = NULL;
int wfd = 0;
uint64_t write_len = 0;
char *write_buf = NULL;
rfd = open(argv[1], O_RDONLY);
if (-1 == rfd)
{
perror("\n");
return -1;
}
wfd = open(argv[2], O_RDWR | O_CREAT | O_TRUNC, 0666);
if (wfd < 0)
{
perror("\n");
return -1;
}
read_buf = (char *)malloc(READ_LEN);
if (NULL == read_buf)
{
return -1;
}
write_len = READ_LEN * 4;
write_buf = (char *)malloc(write_len);
if (NULL == write_buf)
{
return -1;
}
uint8_t *ptr = (uint8_t*)write_buf;
z_stream stream;
stream.zalloc = NULL;
stream.zfree = NULL;
stream.opaque = NULL;
deflateInit2(&stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, MAX_WBITS + 16, 8, Z_DEFAULT_STRATEGY);
AGAIN:
while ((read_len = read(rfd, read_buf, READ_LEN)) >= 0)
{
int flush = Z_NO_FLUSH;
if (read_len == 0)
{
flush = Z_FINISH;
}
stream.next_in = (uint8_t*)read_buf;
stream.avail_in = read_len;
do
{
write_len = 4 * READ_LEN;
stream.next_out = (uint8_t*)write_buf;
stream.avail_out = write_len;
ret = deflate(&stream, flush);
if (flush == Z_NO_FLUSH && ret != Z_OK)
{
goto ERROR;
}
if (flush == Z_FINISH && ret != Z_STREAM_END)
{
goto ERROR;
}
int avail = 4 * READ_LEN - stream.avail_out;
write(wfd, write_buf, avail);
}while (stream.avail_out == 0); // 如果avail_out不够用了,说明输入的buffer还有没有压缩的部分,那么要继续压缩.
// 如果输入长度不是0,说明压缩不完整,可以直接退出.
assert(stream.avail_in == 0);
if (read_len == 0)
{
break;
}
}
if (read_len < 0)
{
if (errno == EINTR)
{
goto AGAIN;
}
}
return 0;
ERROR:
deflateEnd(&stream);
close(rfd);
close(wfd);
return -1;
}这段代码,我使用的是gzip的压缩方式,所以如果要解压,不需要在单独写一份代码了.只要gunzip命令就可以验证程序是否正常.
后记 :
关于三种压缩格式的区分.
deflate : 说他是压缩格式有点不确切,其实它就是压缩的核心算法.
zlib : zlib header + deflate + zlib tailer
gzip : gzip header + deflate + gzip tailer
另外我封装了一套单buffer的压缩和解压函数.也放在这里,有需要的同学可以参考一下.
compress.h
#ifndef MYZIP_H
#include <unistd.h>
#include <stdint.h>
#include <zlib.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef z_streamp PZSTREAM;
typedef z_stream ZSTREAM;
/* ===========================================================================
* 指定压缩(解压)类型
* 官方文档提到 :
* -(15 ~ 8) : raw deflate压缩
* 15 ~ 8 : 带zlib头和尾
* > 16 : 带gzip头和尾
*/
typedef enum
{
E_ZIP_RAW = -MAX_WBITS,
E_ZIP_ZLIB = MAX_WBITS,
E_ZIP_GZIP = MAX_WBITS + 16
} zip_type;
// 压缩回调函数
typedef void (*flate_cb)(void *buf, int len);
/******************************************************************************
** 执行deflate压缩
** NOTE : 1. 这组函数仅仅适用于小buffer
2. 在调用deflate_beg之前,需要自己初始化strm
3. 如果deflating失败,要执行deflate_end释放资源
4. 明确一点,deflate_end只做了stream内部资源释放工作,如果stream是动态分配的,需要自己free
******************************************************************************/
int deflate_beg(PZSTREAM strm, zip_type type);
int deflating(PZSTREAM strm, uint8_t *inbuf, uint32_t in_len, uint8_t *outbuf, uint32_t *out_len);
int deflate_end(PZSTREAM strm);
/******************************************************************************
** 执行inflate解压
** NOTE : 1. 这组函数仅仅适用于小buffer
2. 在调用inflate_beg之前,需要自己初始化strm
3. 如果inflating失败,要执行inflate_end释放资源
4. 明确一点,inflate_end只做了stream内部资源释放工作,如果stream是动态分配的,需要自己free
******************************************************************************/
int inflate_beg(PZSTREAM strm, zip_type type);
int inflating(PZSTREAM strm, uint8_t *inbuf, uint32_t in_len, uint8_t *outbuf, uint32_t *outlen);
int inflate_end(PZSTREAM strm);
#ifdef __cplusplus
}
#endif
#endifcompress.c
#include <unistd.h>
#include "compress.h"
/// strm需要在传入之前自己初始化
int deflate_beg(PZSTREAM strm, zip_type type)
{
int ret = 0;
int window_bits;
if (NULL == strm)
{
goto ERROR;
}
strm->zalloc = Z_NULL;
strm->zfree = Z_NULL;
strm->opaque = Z_NULL;
strm->next_in = Z_NULL;
strm->avail_in = 0;
window_bits = (int)type;
ret = deflateInit2(strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, window_bits, 8, Z_DEFAULT_STRATEGY);
if (ret != Z_OK)
{
goto ERROR;
}
return 0;
ERROR:
return -1;
}
int deflating(PZSTREAM strm, uint8_t *inbuf, uint32_t in_len, uint8_t *outbuf, uint32_t *out_len)
{
int ret = 0;
if (NULL == strm || NULL == inbuf || NULL == outbuf || NULL == out_len)
{
goto ERROR;
}
ret = deflateReset(strm);
if (ret != Z_OK)
{
goto ERROR;
}
strm->next_in = inbuf;
strm->avail_in = in_len;
strm->next_out = outbuf;
strm->avail_out = *out_len;
// 此函数的应用场景都是小buffer场景,所以这里inbuf的传入都是完整需要压缩的,
// 所以这里直接调用Z_FINISH
ret = deflate(strm, Z_FINISH);
if (ret != Z_STREAM_END)
{
goto ERROR;
}
*out_len = strm->total_out;
return 0;
ERROR:
return -1;
}
int deflate_end(PZSTREAM strm)
{
int ret = 0;
ret = deflateEnd(strm);
if (ret != Z_OK)
{
goto ERROR;
}
return 0;
ERROR:
return -1;
}
int inflate_beg(PZSTREAM strm, zip_type type)
{
int ret = 0;
int window_bits = 0;
if (NULL == strm)
{
goto ERROR;
}
strm->zalloc = (alloc_func)0;
strm->zfree = (free_func)0;
strm->opaque = (voidpf)0;
window_bits = (int)type;
ret = inflateInit2(strm, window_bits);
if (ret != Z_OK)
{
goto ERROR;
}
return 0;
ERROR:
return -1;
}
int inflating(PZSTREAM strm, uint8_t *inbuf, uint32_t in_len, uint8_t *outbuf, uint32_t *outlen)
{
int ret = 0;
if (NULL == strm || NULL == inbuf || NULL == outbuf || NULL == outlen)
{
goto ERROR;
}
ret = inflateReset(strm);
if (ret != Z_OK)
{
goto ERROR;
}
strm->next_in = inbuf;
strm->avail_in = in_len;
strm->next_out = outbuf;
strm->avail_out = *outlen;
ret = inflate(strm, Z_FINISH);
if (Z_STREAM_END != ret)
{
goto ERROR;
}
*outlen = strm->total_out;
return 0;
ERROR:
return -1;
}
int inflate_end(PZSTREAM strm)
{
int ret = 0;
ret = inflateEnd(strm);
if (ret != Z_OK)
{
goto ERROR;
}
return 0;
ERROR:
return -1;
}