zlib數(shù)據(jù)壓縮庫

zlib 軟件包包含 zlib 庫，很多程序中的壓縮或者解壓縮函數(shù)都會用到這個庫。zlib 適用于數(shù)據(jù)壓縮的函式庫，幾乎適用于任何計算器硬件和操作系統(tǒng)。

特性：

• 數(shù)據(jù)頭(header)

zlib 能使用一個 gzip 數(shù)據(jù)頭、zlib 數(shù)據(jù)頭或者不使用數(shù)據(jù)頭壓縮數(shù)據(jù)。

通常情況下，數(shù)據(jù)壓縮使用 zlib 數(shù)據(jù)頭，因為這提供錯誤數(shù)據(jù)檢測。當數(shù)據(jù)不使用數(shù)據(jù)頭寫入時，結(jié)果是沒有任何錯誤檢測的原始 DEFLATE 數(shù)據(jù)，那么解壓縮軟件的調(diào)用者不知道壓縮數(shù)據(jù)在什么地方結(jié)束。

gzip 數(shù)據(jù)頭比 zlib 數(shù)據(jù)頭要大，因為它保存了文件名和其他文件系統(tǒng)信息，事實上這是廣泛使用的gzip文件的數(shù)據(jù)頭格式。注意 zlib 函式庫本身不能創(chuàng)建一個 gzip 文件，但是它相當輕松的通過把壓縮數(shù)據(jù)寫入到一個有 gzip 文件頭的文件中。

• 算法

zlib 僅支持一個 LZ77 的變種算法，DEFLATE 的算法。

這個算法使用很少的系統(tǒng)資源，對各種數(shù)據(jù)提供很好的壓縮效果。這也是在ZIP檔案中無一例外的使用這個算法。（盡管zip文件格式也支持幾種其他的算法）。

看起來zlib格式將不會被擴展使用任何其他算法，盡管數(shù)據(jù)頭可以有這種可能性。

• 使用資源

函數(shù)庫提供了對處理器和內(nèi)存使用控制的能力

不同的壓縮級別數(shù)值可以指示不同的壓縮執(zhí)行速度。

還有內(nèi)存控制管理的功能。這在一些諸如嵌入式系統(tǒng)這樣內(nèi)存有限制的環(huán)境中是有用的。

• 策略

壓縮可以針對特定類型的數(shù)據(jù)進行優(yōu)化

如果你總是使用 zlib 庫壓縮壓縮特定類型的數(shù)據(jù)，那么可以使用有針對性的策略可以提高壓縮效率和性能。例如，如果你的數(shù)據(jù)包含很長的重復數(shù)據(jù)，那么可以用 RLE（運行長度編碼）策略，可能會有更好的結(jié)果。

對于一般的數(shù)據(jù)，默認的策略是首選。

• 錯誤處理

錯誤可以被發(fā)現(xiàn)和跳過

數(shù)據(jù)混亂可以被檢測（只要數(shù)據(jù)和zlib或者gzip數(shù)據(jù)頭一起被寫入－參見上面）

此外，如果全刷新點（full-flush points）被寫入到壓縮后的數(shù)據(jù)流中，那么錯誤數(shù)據(jù)是可以被跳過的，并且解壓縮將重新同步到下個全刷新點。（錯誤數(shù)據(jù)的無錯恢復被提供）。全刷新點技術(shù)對于在不可靠的通道上的大數(shù)據(jù)流是很有用的，一些過去的數(shù)據(jù)丟失是不重要的（例如多媒體數(shù)據(jù)），但是建立太多的全刷新點會極大的影響速度和壓縮。

• 數(shù)據(jù)長度

對于壓縮和解壓縮，沒有數(shù)據(jù)長度的限制

重復調(diào)用庫函數(shù)允許處理無限的數(shù)據(jù)塊。一些輔助代碼（計數(shù)變量）可能會溢出，但是不影響實際的壓縮和解壓縮。

當壓縮一個長（無限）數(shù)據(jù)流時，最好寫入全刷新點。

使用范例

以下代碼可直接用于解壓 HTTP gzip

#include <stdlib.h>

#include <string.h>

#include <errno.h>

#include <zlib.h>

/* Compress data */

int zcompress(Bytef *data, uLong ndata,

Bytef *zdata, uLong *nzdata)

{

z_stream c_stream;

int err = 0;

if(data && ndata > 0)

{

c_stream.zalloc = (alloc_func)0;

c_stream.zfree = (free_func)0;

c_stream.opaque = (voidpf)0;

if(deflateInit(&c_stream, Z_DEFAULT_COMPRESSION) != Z_OK) return -1;

c_stream.next_in = data;

c_stream.avail_in = ndata;

c_stream.next_out = zdata;

c_stream.avail_out = *nzdata;

while (c_stream.avail_in != 0 && c_stream.total_out < *nzdata)

{

if(deflate(&c_stream, Z_NO_FLUSH) != Z_OK) return -1;

}

if(c_stream.avail_in != 0) return c_stream.avail_in;

for (;;) {

if((err = deflate(&c_stream, Z_FINISH)) == Z_STREAM_END) break;

if(err != Z_OK) return -1;

}

if(deflateEnd(&c_stream) != Z_OK) return -1;

*nzdata = c_stream.total_out;

return 0;

}

return -1;

}

/* Compress gzip data */

int gzcompress(Bytef *data, uLong ndata,

Bytef *zdata, uLong *nzdata)

{

z_stream c_stream;

int err = 0;

if(data && ndata > 0)

{

c_stream.zalloc = (alloc_func)0;

c_stream.zfree = (free_func)0;

c_stream.opaque = (voidpf)0;

if(deflateInit2(&c_stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,

-MAX_WBITS, 8, Z_DEFAULT_STRATEGY) != Z_OK) return -1;

c_stream.next_in = data;

c_stream.avail_in = ndata;

c_stream.next_out = zdata;

c_stream.avail_out = *nzdata;

while (c_stream.avail_in != 0 && c_stream.total_out < *nzdata)

{

if(deflate(&c_stream, Z_NO_FLUSH) != Z_OK) return -1;

}

if(c_stream.avail_in != 0) return c_stream.avail_in;

for (;;) {

if((err = deflate(&c_stream, Z_FINISH)) == Z_STREAM_END) break;

if(err != Z_OK) return -1;

}

if(deflateEnd(&c_stream) != Z_OK) return -1;

*nzdata = c_stream.total_out;

return 0;

}

return -1;

}

/* Uncompress data */

int zdecompress(Byte *zdata, uLong nzdata,

Byte *data, uLong *ndata)

{

int err = 0;

z_stream d_stream; /* decompression stream */

d_stream.zalloc = (alloc_func)0;

d_stream.zfree = (free_func)0;

d_stream.opaque = (voidpf)0;

d_stream.next_in = zdata;

d_stream.avail_in = 0;

d_stream.next_out = data;

if(inflateInit(&d_stream) != Z_OK) return -1;

while (d_stream.total_out < *ndata && d_stream.total_in < nzdata) {

d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */

if((err = inflate(&d_stream, Z_NO_FLUSH)) == Z_STREAM_END) break;

if(err != Z_OK) return -1;

}

if(inflateEnd(&d_stream) != Z_OK) return -1;

*ndata = d_stream.total_out;

return 0;

}

/* HTTP gzip decompress */

int httpgzdecompress(Byte *zdata, uLong nzdata,

Byte *data, uLong *ndata)

{

int err = 0;

z_stream d_stream = {0}; /* decompression stream */

static char dummy_head[2] =

{

0x8 + 0x7 * 0x10,

(((0x8 + 0x7 * 0x10) * 0x100 + 30) / 31 * 31) & 0xFF,

};

d_stream.zalloc = (alloc_func)0;

d_stream.zfree = (free_func)0;

d_stream.opaque = (voidpf)0;

d_stream.next_in = zdata;

d_stream.avail_in = 0;

d_stream.next_out = data;

if(inflateInit2(&d_stream, 47) != Z_OK) return -1;

while (d_stream.total_out < *ndata && d_stream.total_in < nzdata) {

d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */

if((err = inflate(&d_stream, Z_NO_FLUSH)) == Z_STREAM_END) break;

if(err != Z_OK )

{

if(err == Z_DATA_ERROR)

{

d_stream.next_in = (Bytef*) dummy_head;

d_stream.avail_in = sizeof(dummy_head);

if((err = inflate(&d_stream, Z_NO_FLUSH)) != Z_OK)

{

return -1;

}

}

else return -1;

}

}

if(inflateEnd(&d_stream) != Z_OK) return -1;

*ndata = d_stream.total_out;

return 0;

}

/* Uncompress gzip data */

int gzdecompress(Byte *zdata, uLong nzdata,

Byte *data, uLong *ndata)

{

int err = 0;

z_stream d_stream = {0}; /* decompression stream */

static char dummy_head[2] =

{

0x8 + 0x7 * 0x10,

(((0x8 + 0x7 * 0x10) * 0x100 + 30) / 31 * 31) & 0xFF,

};

d_stream.zalloc = (alloc_func)0;

d_stream.zfree = (free_func)0;

d_stream.opaque = (voidpf)0;

d_stream.next_in = zdata;

d_stream.avail_in = 0;

d_stream.next_out = data;

if(inflateInit2(&d_stream, -MAX_WBITS) != Z_OK) return -1;

//if(inflateInit2(&d_stream, 47) != Z_OK) return -1;

while (d_stream.total_out < *ndata && d_stream.total_in < nzdata) {

d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */

if((err = inflate(&d_stream, Z_NO_FLUSH)) == Z_STREAM_END) break;

if(err != Z_OK )

{

if(err == Z_DATA_ERROR)

{

d_stream.next_in = (Bytef*) dummy_head;

d_stream.avail_in = sizeof(dummy_head);

if((err = inflate(&d_stream, Z_NO_FLUSH)) != Z_OK)

{

return -1;

}

}

else return -1;

}

}

if(inflateEnd(&d_stream) != Z_OK) return -1;

*ndata = d_stream.total_out;

return 0;

}

#ifdef _DEBUG_ZSTREAM

#define BUF_SIZE 65535

int main()

{

char *data = "kjdalkfjdflkjdlkfjdklfjdlkfjlkdjflkdjflddajfkdjfkdfaskf;ldsfk;ldakf;ldskfl;dskf;ld";

uLong ndata = strlen(data);

Bytef zdata[BUF_SIZE];

uLong nzdata = BUF_SIZE;

Bytef odata[BUF_SIZE];

uLong nodata = BUF_SIZE;

memset(zdata, 0, BUF_SIZE);

//if(zcompress((Bytef *)data, ndata, zdata, &nzdata) == 0)

if(gzcompress((Bytef *)data, ndata, zdata, &nzdata) == 0)

{

fprintf(stdout, "nzdata:%d %s\n", nzdata, zdata);

memset(odata, 0, BUF_SIZE);

//if(zdecompress(zdata, ndata, odata, &nodata) == 0)

if(gzdecompress(zdata, ndata, odata, &nodata) == 0)

{

fprintf(stdout, "%d %s\n", nodata, odata);

}

}

}

#endif