zip压缩算法分析(2)

zip压缩算法分析(2)

前言

在zip压缩算法分析(1)中已经分析了利用文本中短语重复的特性来进行压缩的lz77算法部分，接下来分析利用信息熵进行压缩的huffman编码算法，zip作者在这里对霍夫曼树的处理十分精彩，huffman树本身就已经很cool了，简直无法想象还能有这么流弊的改进。
gzip源码下载地址 参考资料 1 参考资料 2
huffman编码是很有名的一种压缩编码方式，网上，书上都有很多描述；其主要思想如下：
给出文本中所有字符c与各个字符出现频率f组成的字符表S[2, n],比起定长编码，一个比较明智的编码方法是将频率大的赋予较短的编码，频率小的则赋予较长的编码。那么究竟该如何分配呢？

1.编码树的概念。

为了便于解码，这里只使用前缀码（从实际含义上来讲，应该是无前缀码，但是由于权威文献中都使用这种坑爹翻译就只好随大流了），原因如图：

如果字符x的编码成为了字符y编码的一个前缀，那么很明显地，在解码时可能无法分辨是x还是y。考虑如图的一棵树：

所有字符与其在文本中出现的频率构成这棵树的所有叶节点，由叶节点到根节点的路径决定了该字符的编码，因此编码树就成为了表示前缀编码方案的一个极好的模型：对于2个不同叶节点，不可能存在一个编码为另一个编码前缀的情形。

2.Huffman编码算法

Huffman给出了一个构造最优编码树的贪心算法，其正确性证明见《算法导论》（第三版）16章第三节。算法如下：

Huffman(C) //C 为带频率的字母表n = |C|; // n = C 字符数目Q = C; //用C初始化一个最小优先队列Qfor i = 1 to n - 1    allocate a new node z    z.left = x = EXTRACT-MIN(Q) //取出最小节点    z.right = y = EXTRACT-MIN(Q)    z.freq = x.freq + y.freq    INSERT(Q, z)return EXTRACT-MIN(Q)主要思想是用最小优先队列装载字母表，每次循环将频率最小的2个节点取出，合并为一个新节点，再插入队列，直到队列只剩一个节点为止。

霍夫曼编码的原理讲解到此打住，接下来说一说zip压缩算法为何使用 以及如何实现霍夫曼树的。
zip压缩算法分析(1)中分析的lz77压缩算法部分已经利用重复出现的短语进行了压缩，短语式重复的倾向已被破坏，无再次进行lz77的条件。但此时压缩后输出的几种形式的压缩数据：(distance, length), literal仍然在信息熵方面上有压缩的可能，就是说，不同的distance,length, literal在lz77输出流中的频率可能存在较大差距，这样就可以用huffman编码继续对其进行压缩。
huffman编码的主要部分位于tree.c文件中，既然是源码分析，接下来就上码吧：

头部注释

/* trees.c -- output deflated data using Huffman coding * trees.c -- 对deflate()处理过后的数据使用霍夫曼编码 * Copyright (C) 1992-1993 Jean-loup Gailly * This is free software; you can redistribute it and/or modify it under the * terms of the GNU General Public License, see the file COPYING. *//* *  PURPOSE * *      Encode various sets of source values using variable-length *      binary code trees. *      使用二进制变长编码树来编码各种值。 * *  DISCUSSION * *      The PKZIP "deflation" process uses several Huffman trees. The more *      common source values are represented by shorter bit sequences. *      PKZIP的"deflation"算法使用了一些霍夫曼树，出现频率越高的值用越短的bit序列编码。 * *      Each code tree is stored in the ZIP file in a compressed form *      which is itself a Huffman encoding of the lengths of *      all the code strings (in ascending order by source values). *      （此处更倾向于意译而非直译，因为我觉得理解这几句话比看懂这个句子更重要） *      编码树的实现方式是：按照源数据（即lz77压缩后输出的length, distance, literal） *      所有可能值从小到大顺序，将它们的霍夫曼码长(只记录长度!很神奇吧)记录在数组里。 *      The actual code strings are reconstructed from the lengths in *      the UNZIP process, as described in the "application note" *      (APPNOTE.TXT) distributed as part of PKWARE's PKZIP program. * *  REFERENCES *  一些相关算法知识的参考书籍 *      Lynch, Thomas J. *          Data Compression:  Techniques and Applications, pp. 53-55. *          Lifetime Learning Publications, 1985.  ISBN 0-534-03418-7. * *      Storer, James A. *          Data Compression:  Methods and Theory, pp. 49-50. *          Computer Science Press, 1988.  ISBN 0-7167-8156-5. * *      Sedgewick, R. *          Algorithms, p290. *          Addison-Wesley, 1983. ISBN 0-201-06672-6. * *  INTERFACE *      3个接口 *      1.初始化函数 *      void ct_init (ush *attr, int *methodp) *          Allocate the match buffer, initialize the various tables and save *          the location of the internal file attribute (ascii/binary) and *          method (DEFLATE/STORE) *      2.计数器函数 *      void ct_tally (int dist, int lc); *          Save the match info and tally the frequency counts. *      3. *      long flush_block (char *buf, ulg stored_len, int eof) *          Determine the best encoding for the current block: dynamic trees, *          static trees or store, and output the encoded block to the zip *          file. Returns the total compressed length for the file so far. * */

和上篇文章一样，分析是以3个interface函数为主要对象的，在分析源码的同时补充相关信息。
之所以这么安排是因为前面的常量和宏太尼玛多了，全部列出来，谁记得住啊？只有从对函数
的解读中才比较方便认识理解这些常量，宏。毕竟这些量说到底还是为了函数而存在的。

函数ct_init

代码：

/* =========================================================================== * Allocate the match buffer, initialize the various tables and save the * location of the internal file attribute (ascii/binary) and method * (DEFLATE/STORE). * 为匹配块收集空间，初始化变量表并存储文件属性(ASCII编码/二进制编码)与压缩方案 * (压缩/仅存储) */void ct_init(attr, methodp)    ush  *attr;   /* pointer to internal file attribute */    int  *methodp; /* pointer to compression method */{    int n;        /* iterates over tree elements */    int bits;     /* bit counter */    int length;   /* length value */    int code;     /* code value */    int dist;     /* distance index */    file_type = attr;    file_method = methodp;    compressed_len = input_len = 0L;    if (static_dtree[0].Len != 0) return; /* ct_init already called */    /* Initialize the mapping length (0..255) -> length code (0..28)     *  初始化映射 0到255的length值 -> 30个length区间码    *  这个区间压缩方案实在太厉害了，详情见该函数源码下方注1。    */    length = 0;    for (code = 0; code < LENGTH_CODES-1; code++) {        base_length[code] = length;        for (n = 0; n < (1<<extra_lbits[code]); n++) {            length_code[length++] = (uch)code;        }    }    Assert (length == 256, "ct_init: length != 256");    /* Note that the length 255 (match length 258) can be represented     * in two different ways: code 284 + 5 bits or code 285, so we     * overwrite length_code[255] to use the best encoding:     * 刚好有一个剩下的code，分配给length 255(+ 3 = 258)     */    length_code[length-1] = (uch)code;    /* Initialize the mapping dist (0..32K) -> dist code (0..29)     *  初始化映射 所有0 ~ 32k(16bit)distance值 -> 30个区间码，    *  详情见该函数源码下方注2。    */    dist = 0;    //此处的循环与前面length数据处理方法类似。    for (code = 0 ; code < 16; code++) {        base_dist[code] = dist;        for (n = 0; n < (1<<extra_dbits[code]); n++) {            dist_code[dist++] = (uch)code;        }    }    Assert (dist == 256, "ct_init: dist != 256");    //此处的处理很微妙，见下方注2。    dist >>= 7; /* from now on, all distances are divided by 128 */    for ( ; code < D_CODES; code++) {        base_dist[code] = dist << 7;        for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {            dist_code[256 + dist++] = (uch)code;        }    }    Assert (dist == 256, "ct_init: 256+dist != 512");    //初始化静态literal树中各值对应编码的长度，    //静态意为所有literal字符值都给出默认的编码    /* Construct the codes of the static literal tree */    for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;    n = 0;    while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;    while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;    while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;    while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;    /* Codes 286 and 287 do not exist, but we must include them in the     * tree construction to get a canonical Huffman tree (longest code     * all ones)     */    //调用gen_codes为已经分配好长度的静态literal树生成编码，    //gen_codes是一个重要函数，看懂就能理解为什么这里只需记录编码长度的分布    //而不需记录所有的编码值了。详情见后面对gen_codes的专门分析。    gen_codes((ct_data near *)static_ltree, L_CODES+1);    /* The static distance tree is trivial:     *  静态distance树的初始化较为简单，就不用gen_codes了，    * 注意要用bi_reverse将编码方向，这是为了便于输出，详情见注3。    */    for (n = 0; n < D_CODES; n++) {        static_dtree[n].Len = 5;        static_dtree[n].Code = bi_reverse(n, 5);    }    /* Initialize the first block of the first file:     *  初始化第一个文件的第一个压缩数据块，函数 init_block 详情见该函数源码下方注4。    */    init_block();}

注1 length与literal 数据的组织方式

lz77输出的3种数据类型：
length, literal, distance
length: 匹配串的长度，限制在 [MIN_MATCH = 3, MAX_MATCH = 258]区间范围内；
literal: 未匹配的字符或匹配串的首字符，按ASCII表来说取值在0~256之间
distance: 一对匹配串之间的距离

先介绍几个常量和数据块：

#define LENGTH_CODES 29/* number of length codes, not counting the special END_BLOCK code *  length 区间码的个数，还有一个特殊的结束符END_BLOCK没有算上*/#define LITERALS  256/* number of literal bytes 0..255 *  literal 字符的个数(ASCII表 256个值对应256个字符)*/#define L_CODES (LITERALS+1+LENGTH_CODES)/* number of Literal or Length codes, including the END_BLOCK code *  literal 和 length 编码的总个数，包括结束符END_BLOCK在内。*/#define HEAP_SIZE (2*L_CODES+1)/* maximum heap size *  为霍夫曼编码提供足够的空间，装有字符信息的叶节点L_CODES个，但还需要额外的*  内部节点，最多L_CODES + 1个，详细情况后面的几个造树函数会解释。*/typedef static locallocal ct_data near dyn_ltree[HEAP_SIZE];   /* literal and length tree *  length & literal动态编码树，literal 和 length 数据被存在同一个树中*/local ct_data near static_ltree[L_CODES+2];/* The static literal tree. Since the bit lengths are imposed, there is no * need for the L_CODES extra codes used during heap construction. However * The codes 286 and 287 are needed to build a canonical tree (see ct_init * below). * length & literal静态编码树，由于编码方案已经钦定了，所以不用再特意多出L_CODES空间来 * 构建最小堆进行多余的霍夫曼编码。 */

literal的值范围有ASCII编码表决定，[0, 255]；
而length值范围则为MIN_MATCH = 3 ~ MAX_MATCH = 258;恰好都是256个值；
literal 与 length共存在同一棵静态编码树或动态编码树中，
以动态编码树为例，

local ct_data near dyn_ltree[HEAP_SIZE]

该树包含了所有的length与literal数据
每一个length或literal或distance数据都装在

结构体 ct_data

/* Data structure describing a single value and its code string. */typedef struct ct_data {    union {        ush  freq;       /* 出现的频率 */        ush  code;       /* huffman编码 */    } fc;    union {        ush  dad;        /* huffman树中该数据的父节点 */        ush  len;        /* huffman编码的长度 */    } dl;} ct_data;

literal直接用原本的值表示，0 ~ 255；256表示结束符END_BLOCK
那么，既然length有256种不同取值，为何只有LENGTH_CODES = 29个编码呢？
这里就要说到一个重要的概念了：

区间码

将length 分为29个区间，257 ~ 285这29个值作为区间的编号，我们只统计落在
各区间内的length数目，在把每个区间看做节点，进行霍夫曼编码。真他妈聪明。
具体的分法如下图，

图源：《Data Compression The Complete Reference》
code为各区间的标号，bits则表示区间内可以自由取值的bit位数，
例如
区间[35， 42] 或 [43 , 50]之间的值有8 = 2 ^ (bit位= 3) 个。这些多出的bit位的信息
存放在数组extra_lbits[LENGH_CODES]中。

local int near extra_lbits[LENGTH_CODES] /* extra bits for each length code */   = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0};

好，说完这些原理后再回过头来看建立length实际值到length区间映射的代码

length = 0;    for (code = 0; code < LENGTH_CODES-1; code++) {        base_length[code] = length;        for (n = 0; n < (1<<extra_lbits[code]); n++) {            length_code[length++] = (uch)code;        }    }

明显地，code为区间的编号，length为实际的length值，
base_length[code]为code编号区间的起始值，
extra_lbit记录该区间的bit长度
而length_code[length]记载了length值所位于的区间，
程序员前辈应该不难看懂，
1 << extra_lbits[code]表示2 ^ (extra_lbits[code])，即该区间的长度。

@注2 distance数据的组织形式**

distance 与前面length类似，也分成一个个区间来编号，
先介绍几个相关的量：

#define D_CODES   30/* number of distance codes*  30个distance区间 */local uch dist_code[512];/* distance codes. The first 256 values correspond to the distances * 3 .. 258, the last 256 values correspond to the top 8 bits of * the 15 bit distances. * distance码，distance_code[distance]为distance所在区间的编号， * 前256个下标值对应distance值3,...,258，后256个值对应大于256的 * distance值的前8bit位(二进制位)。 */ local int near base_dist[D_CODES];/* First normalized distance for each code (0 = distance of 1)  * 装载各区间最左端的值，作为其“基数” */

distance的存储方式与length类似，一共划分为30个区间，
取值范围是 3 ~ MAX_DIST，其中MAX_DIST定义在前一篇文章中有描述：

#define MAX_DIST  (WSIZE-MIN_LOOKAHEAD)/* In order to simplify the code, particularly on 16 bit machines, match * distances are limited to MAX_DIST instead of WSIZE. */

由于MAX_DIST十分接近lz77窗口长度W_SIZE = 32k， 于是不妨将取值范围扩大到 0 ~ 32k;
具体的划分方案如下：

图源：《Data Compression The Complete Reference》
前一段代码还比较好理解，和length一样处理：

dist = 0;    //此处的循环与前面length数据处理方法类似。    for (code = 0 ; code < 16; code++) {        base_dist[code] = dist;        for (n = 0; n < (1<<extra_dbits[code]); n++) {            dist_code[dist++] = (uch)code;        }    }

而后半段就不一样了：

dist >>= 7; /* from now on, all distances are divided by 128 */    for ( ; code < D_CODES; code++) {        base_dist[code] = dist << 7;        for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {            dist_code[256 + dist++] = (uch)code;        }    }

为什么要从dist = 267开始将dist右移7位呢？
考察记录每个区间bit长度的数组extra_dbits[D_CODES]：
{0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}
257是16号区间的开头，可以发现从该区间开始，bit长度都不低于7，进一步说，
每个区间长度都是2 ^ 7 = 128的整数倍，用二进制表示从第16号开始各区间范围：
16 [000000010 0000001, 000000011 0000000],
17 [000000011 0000001, 000000100 0000000],
18 [000000100 0000001, 000000110 0000000],
… … … … … … … … … … …
… … … … … … … … … … …
29 [011000000 0000001, 100000000 0000000]
由此可看出，只要前9位相同，就一定在同一区间内，而不用去管后7位。

注3 函数bi_reverse

该函数实现位于文件 bits.c中

/* =========================================================================== * Reverse the first len bits of a code, using straightforward code (a faster * method would use a table)将码的前len位反转，使用的是直观易懂的代码，用表实现的话会更快。 * IN assertion: 1 <= len <= 15 输入要求：1 <= len <= 15 */unsigned bi_reverse(code, len)    unsigned code; /* the value to invert */    int len;       /* its bit length */{    register unsigned res = 0;    do {        res |= code & 1;        code >>= 1, res <<= 1;    } while (--len > 0);    return res >> 1;}

用掩码反转位，这个算法算是烂大街了，就不多说了。

注4 函数init_block

一个工具函数。

/* =========================================================================== * Initialize a new block. * 初始化一个新的数据块。 */local void init_block(){    int n; /* iterates over tree elements */    /*初始化树 */    for (n = 0; n < L_CODES;  n++) dyn_ltree[n].Freq = 0;    for (n = 0; n < D_CODES;  n++) dyn_dtree[n].Freq = 0;    for (n = 0; n < BL_CODES; n++) bl_tree[n].Freq = 0;    dyn_ltree[END_BLOCK].Freq = 1;    opt_len = static_len = 0L;    last_lit = last_dist = last_flags = 0;    flags = 0; flag_bit = 1;}

建立huffman树

高度特化的huffman树—deflate树

不妨来思考一下huffman树的形式：
对于一组给定的输入，一共有多少颗结构不同的huffman树?
事实上，huffman算法所给出的解并非唯一的，如图：

第二层的2棵子树交换位置，得

第三层的2棵子树交换位置，得

毋庸置疑，这三棵树代表的压缩后文本总长度（即各字符频率 * 深度之和）都是一样的，
第一棵树是《算法导论》这三棵树中作为例子算出来的一棵最优树，那么按照如上所示的
交换操作，可以生成许多的最优编码方案。
但是 无论如何交换，每一层的叶节点数始终不变!，
于是，zip作者提出了一种特化编码的方法，只要知道每种长度，即每层的叶节点个数，便可以
得到一颗独特的编码树，称为deflate树。建立deflate树的过程包含在函数build_tree() 中。

建树前的准备统计频率函数ct_tally

当然，在建树之前，还必须获取length, literal, distance各种值在数据流中出现的的频率，
该过程在函数 ct_tally 内，lz77部分的函数deflate()就使用了该函数来不断地更新统计数据。ct_tally将统计数据暂时放在2个buffer中 :

//表示2个buff大小的宏，//LIT_BUFSIZE: l_buf 的大小#ifndef LIT_BUFSIZE#  ifdef SMALL_MEM#    define LIT_BUFSIZE  0x2000#  else#  ifdef MEDIUM_MEM#    define LIT_BUFSIZE  0x4000#  else#    define LIT_BUFSIZE  0x8000#  endif#  endif#endif//DIST_BUFSIZE: d_buff的大小#ifndef DIST_BUFSIZE#  define DIST_BUFSIZE  LIT_BUFSIZE#endif//l_buf 用于临时装载literal 和 length的信息，//由于literal取值范围都是 (0, 255)，所以用8bit的charunsigned char l_buf[LIT_BUFSIZE];//d_buff 用于临时装载distance的信息，//由于distance区间码取值范围是 (0, 511)，所以用16bit的shortunsigned short d_buff[DIST_BUFSIZE];

这2个buffer用2个counter跟踪记录运行时的数组index

static unsigned last_lit;    /* running index in l_buf */static unsigned last_dist;   /* running index in d_buf */

l_buf内一个值究竟表示length还是literal，使用flag_buf数组来区分，flag_buf为unsigned char *类型数组，
里面每个char值相当于8个bool值，可以记录8次。

static uch flags;            /* 当前待存入flag_buf的flag */static uch flag_bit;         /* flags目前正在用的bit位 *//* bits are filled in flags starting at bit 0 (least significant). * Note: these flags are overkill in the current code since we don't * take advantage of DIST_BUFSIZE == LIT_BUFSIZE. */ local uch near flag_buf[(LIT_BUFSIZE/8)];//由于每个flags可以记录8次所以除以8/* flag_buf is a bit array distinguishing literals from lengths in * l_buf, thus indicating the presence or absence of a distance. */

这里就有一个有趣的问题了：
既然literal取值在0~255, length区间码取值在257到285,那么只要依据是否大于256就可以分出
literal和length了，那么为何又要特意用一个flag_buf呢？
—注意l_buf的类型： unsigned char *，也就是说，length存入的值事实上不是区间码，而是真实
的length值，只要你仔细观察deflate() 的这一段代码：

flush = ct_tally(strstart-1-prev_match, prev_length - MIN_MATCH);

就可得知。因此，length的取值范围为0~255, 这样做也是为了满足char 8bit的大小限制，那么这时
length就和literal在取值上无区别了。

另外还要讲一下flag的运行机制：ct_tally接受2个参数：

 int dist;  /* 匹配串的距离 */ int lc;    /* 如果dist!=0, 为匹配串的长度，lc = match length-MIN_MATCH             * 否则dist==0, 为匹配失败后输出的单个字符literal*/

假设初始化后，一组连续输入的参数值从早到晚为
{ (0, literal), (0, literal) , (dist, length), (0, literal), (dist, length), ……… };
init_block函数初始化
flags = 0000 0000, flag_bit = 0000 0001;
第一次：判断为literal， 标记为true, flag_bit左移一位
flags = flags | flag_bit = 0000 000 1 , flag_bit = 0000 00 1 0;
第二次：判断为literal， 标记为true, flag_bit左移一位
flags = flags | flag_bit = 0000 00 11, flag_bit = 0000 0 1 00;
第三次：判断为匹配串， 标记为false, flag_bit左移一位
flags = flags = 0000 00 11, flag_bit = 0000 1 000;
第四次：判断为literal， 标记为true, flag_bit左移一位
flags = flags | flag_bit = 0000 1 0 11, flag_bit = 000**1** 0000;
第五次：判断为匹配串， 标记为false, flag_bit左移一位
flags = flags = 0000 1 0 11, flag_bit = 00**1** 0 0000;
………
一直到第八次操作完，算作一个周期，将flags存入flag_buf；
接下来就可以贴上ct_tally的源代码了：

/* =========================================================================== * Save the match info and tally the frequency counts. Return true if * the current block must be flushed. * 存储本次匹配的信息并更新频率统计数据，如果目前的数据块必须要刷新的话，返回true。 */int ct_tally (dist, lc)    int dist;  /* 匹配串的距离 */    int lc;    /* 如果dist!=0, 为匹配串的长度，lc = match length-MIN_MATCH                * 否则dist==0, 为匹配失败后输出的单个字符literal*/{    //l_buf 记录下lc的值    l_buf[last_lit++] = (uch)lc;    if (dist == 0) {        /* 是literal，只更新动态树dyn_ltree */        dyn_ltree[lc].Freq++;    } else {        /* 是匹配串, lc == match length - MIN_MATCH */        dist--;             /* dist = match distance - 1 */        Assert((ush)dist < (ush)MAX_DIST &&               (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&               (ush)d_code(dist) < (ush)D_CODES,  "ct_tally: bad match");        //更新两棵动态树        //LITERALS == 256        dyn_ltree[length_code[lc]+LITERALS+1].Freq++;        //宏d_code用于从distance值获取其区间码，比较trivial所以就不细究了。        dyn_dtree[d_code(dist)].Freq++;        //更新d_buf        d_buf[last_dist++] = (ush)dist;        //记录为true        flags |= flag_bit;    }    //左移一位    flag_bit <<= 1;    /* 如果flags整个byte都记录满了，即过了8次操作 */    if ((last_lit & 7) == 0) {        flag_buf[last_flags++] = flags;        flags = 0, flag_bit = 1;    }    /* Try to guess if it is profitable to stop the current block here     *  判断是不是该输出这个数据块的压缩结果    */    if (level > 2 && (last_lit & 0xfff) == 0) {        /* Compute an upper bound for the compressed length         *  计算压缩长度的上界        */        //输出长度，按bit算        ulg out_length = (ulg)last_lit*8L;        //输入长度，按byte(8 bit)算        ulg in_length = (ulg)strstart-block_start;        int dcode;        for (dcode = 0; dcode < D_CODES; dcode++) {            //加上distance的长度：5 + extra bits            //因为distance区间码为 0~29, 2^4 < 29 < 2^5，所以取基本长度5，再加上额外的bit位            out_length += (ulg)dyn_dtree[dcode].Freq*(5L+extra_dbits[dcode]);        }        //除以8，化为以byte为单位        out_length >>= 3;        Trace((stderr,"\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ",               last_lit, last_dist, in_length, out_length,               100L - out_length*100L/in_length));        //判断条件        if (last_dist < last_lit/2 && out_length < in_length/2) return 1;    }    return (last_lit == LIT_BUFSIZE-1 || last_dist == DIST_BUFSIZE);    /* We avoid equality with LIT_BUFSIZE because of wraparound at 64K     * on 16 bit machines and because stored blocks are restricted to     * 64K-1 bytes.     */}

build_tree开始建deflate树

deflate树相关数据的组织形式

如前面所述，树是以ct_data结构体数组来表示的，例如2棵动态树：

#define HEAP_SIZE (2*L_CODES+1)local ct_data near dyn_ltree[HEAP_SIZE];   /* literal and length tree */local ct_data near dyn_dtree[2*D_CODES+1]; /* distance tree */

之所以数组大小比要编码的元素个数要大一倍再多一个，是因为建树时内部节点需要额外空间，这一点前面已经讲过，现在再在这里重复一遍。如果还是不能理解，可以参考下图：

其中node是build_tree函数中要用到的一个迭代器，作为树和free space 的分界线。
对于每种数据(literal & length 或 distance)，都有一棵静态树(static_ltree或static_dtree)和一棵动态树(dyn_ltree或dyn_dtree)，其中静态树的编码方案是预先给定的，而动态树的编码方案动态生成；从而有了这样一个聚合了所有树相关信息的结构体 tree_desc：

typedef struct tree_desc {    ct_data near *dyn_tree;      /* 动态树 */    ct_data near *static_tree;   /* 静态树 or NULL */    int     near *extra_bits;    /* extra bits数组 or NULL */    int     extra_base;          /* base index for extra_bits */    int     elems;               /* 树内叶节点个数上限 */    int     max_length;          /* 树内元素的最长编码长度 */    int     max_code;            /* 最大的频率非零元素位置，也就是说右边的元素频率都为零 */} tree_desc;#define LITERALS  256/* number of literal bytes 0..255 */#define L_CODES (LITERALS+1+LENGTH_CODES)/* number of Literal or Length codes, including the END_BLOCK code */#define D_CODES   30/* number of distance codes */#define MAX_BITS 15/* All codes must not exceed MAX_BITS bits */local tree_desc near l_desc ={dyn_ltree, static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS, 0};local tree_desc near d_desc ={dyn_dtree, static_dtree, extra_dbits, 0,          D_CODES, MAX_BITS, 0};

huffman树的建造过程

build_tree 使用比较常规的方法建造haffman树，最小优先队列使用基于数组的最小堆实现，数组中节点heap[i]的左子节点为heap[2*i], 右子节点为heap[2*i + 1];
有一点是要提醒的：事实上，堆装载的是int值而不是ct_data结构体, 例如，若heap[i] = j，则表示堆的第i个节点对应的数据是ct_data 结构体tree[j]。也就是说，heap中只保留指向树中数据结构体的句柄，或者说序号。

static int near heap[2*L_CODES+1]

堆的结构如图：

堆的相关代码如下：

/* =========================================================================== * Remove the smallest element from the heap and recreate the heap with * one less element. Updates heap and heap_len. * 弹出最小堆的根节点，也就是目前的最小元素，将根节点换为尾节点的值， * 并调用pqdownheap及时维护堆的结构。 */#define pqremove(tree, top) \{\    top = heap[SMALLEST]; \    heap[SMALLEST] = heap[heap_len--]; \    pqdownheap(tree, SMALLEST); \}/* =========================================================================== * Compares to subtrees, using the tree depth as tie breaker when * the subtrees have equal frequency. This minimizes the worst case length. * 比较2个节点的频率：若频率相等，则比较以2个节点为根节点的2棵子树的深度。 */#define smaller(tree, n, m) \   (tree[n].Freq < tree[m].Freq || \   (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))/* =========================================================================== * Restore the heap property by moving down the tree starting at node k, * exchanging a node with the smallest of its two sons if necessary, stopping * when the heap property is re-established (each father smaller than its * two sons).将heap[k]向下移动到适当的地方。 */local void pqdownheap(tree, k)    ct_data near *tree;  /* the tree to restore */    int k;               /* node to move down */{    int v = heap[k];    int j = k << 1;  /* left son of k */    while (j <= heap_len) {        /* Set j to the smallest of the two sons: */        if (j < heap_len && smaller(tree, heap[j+1], heap[j])) j++;        /* Exit if v is smaller than both sons */        if (smaller(tree, v, heap[j])) break;        /* Exchange v with the smallest son */        heap[k] = heap[j];  k = j;        /* And continue down the tree, setting j to the left son of k */        j <<= 1;    }    heap[k] = v;}

这几个操作也算是很经典的啦，我就不多说了。
接下来就是函数build_tree的代码

/* =========================================================================== * Construct one Huffman tree and assigns the code bit strings and lengths. * 构造一颗huffman树并生成编码串，记录其长度 * Update the total bit length for the current block. * IN assertion: the field freq is set for all tree elements. * 输入前：要保证属性freq（即各值对应的频率）已经统计完备 * OUT assertions: the fields len and code are set to the optimal bit length *     and corresponding code. The length opt_len is updated; static_len is *     also updated if stree is not null. The field max_code is set. * 输出后：树中所有节点赋得属性len(huffman编码长度)与属性code(编码比特串)。 * 最优树的总长 */local void build_tree(desc)    tree_desc near *desc; /* the tree descriptor */{    ct_data near *tree   = desc->dyn_tree;    ct_data near *stree  = desc->static_tree;    int elems            = desc->elems;    //迭代器    int n, m;          /* iterate over heap elements */    //最大的频率非零节点位置    int max_code = -1; /* largest code with non zero frequency */    //下一个可以构造内部节点的位置    int node = elems;  /* next internal node of the tree */    /* Construct the initial heap, with least frequent element in     * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].     * heap[0] is not used.     * 初始化堆，heap[n]子节点为heap[2*n]和heap[2*n+1],heap[0]闲置。     */    //2个全局变量：heap_len: 堆长度 | heap_max:     heap_len = 0, heap_max = HEAP_SIZE;    for (n = 0; n < elems; n++) {        if (tree[n].Freq != 0) {            heap[++heap_len] = max_code = n;            depth[n] = 0;        } else {            tree[n].Len = 0;        }    }    /* The pkzip format requires that at least one distance code exists,     * and that at least one bit should be sent even if there is only one     * possible code. So to avoid special checks later on we force at least     * two codes of non zero frequency.     */    while (heap_len < 2) {        int new = heap[++heap_len] = (max_code < 2 ? ++max_code : 0);        tree[new].Freq = 1;        depth[new] = 0;        opt_len--; if (stree) static_len -= stree[new].Len;        /* new is 0 or 1 so it does not have extra bits */    }    desc->max_code = max_code;    /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,     * establish sub-heaps of increasing lengths:     */    for (n = heap_len/2; n >= 1; n--) pqdownheap(tree, n);    /* Construct the Huffman tree by repeatedly combining the least two     * frequent nodes.     */    do {        //弹出2个最小节点        pqremove(tree, n);   /* n = node of least frequency */        m = heap[SMALLEST];  /* m = node of next least frequency */        heap[--heap_max] = n; /* keep the nodes sorted by frequency */        heap[--heap_max] = m;        /* Create a new node father of n and m         * 合并n和m，在tree中生成新节点*/        tree[node].Freq = tree[n].Freq + tree[m].Freq;        depth[node] = (uch) (MAX(depth[n], depth[m]) + 1);        tree[n].Dad = tree[m].Dad = (ush)node;#ifdef DUMP_BL_TREE        if (tree == bl_tree) {            fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)",                    node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);        }#endif        /* and insert the new node in the heap         * 将tree中新节点(的位置)塞到堆里面*/        heap[SMALLEST] = node++;        pqdownheap(tree, SMALLEST);    } while (heap_len >= 2);    heap[--heap_max] = heap[SMALLEST];    //huffman树结构已生成，开始特化成deflate树    /* At this point, the fields freq and dad are set. We can now     * generate the bit lengths.     * 生成编码长度记录     */    gen_bitlen((tree_desc near *)desc);    /* The field len is now set, we can generate the bit codes *     * 生成bit编码串     */    gen_codes ((ct_data near *)tree, max_code);}

在函数中heap的结构变化如图所示：
初始堆

huffman编码中

处理完毕

在函数中tree的结构变化如图所示：
初始树

huffman编码中

记录长度gen_bitlen

gen_bitlen函数用于记录长度

编码长度存储数组bl_count

这里要先介绍一个数组，用于存储各长度节点的数目：

//bl_count[i]表示长度为i的编码个数local ush near bl_count[MAX_BITS+1];/* number of codes at each bit length for an optimal tree */

长度限制下的长度统计

如前面所讲到的，tree_desc 内含有属性max_length， 表示huffman编码的最大长度，对于length&literal tree descripter或distance tree descripter为MAX_BITS = 15;然而在实际的编码过程中可能由于元素之间频率差距过大，导致有些节点深度大于15，这样就很尴尬了;
gen_bitlen函数使用了合并节点的策略：
将 超长节点中层数最浅且频率最大的叶节点A与 目前正常节点中层数最深且频率最小的叶节点B合并，如图：

虚线表示max_length，2个紫色叶节点分别为A, B;可见合并之后A, B的父节点占据了B原来的位置，而A的一个超长兄弟节点向上移了一位，而A原来的那个超长(或刚好深度为max_length)父节点就可以扔掉无视了。

/* =========================================================================== * Compute the optimal bit lengths for a tree and update the total bit length * for the current block. * 计算最优的bit串长度，并更新整个数据块的压缩后长度。 * IN assertion: the fields freq and dad are set, heap[heap_max] and *    above are the tree nodes sorted by increasing frequency. * OUT assertions: the field len is set to the optimal bit length, the *     array bl_count contains the frequencies for each bit length. *     The length opt_len is updated; static_len is also updated if stree is *     not null. */local void gen_bitlen(desc)    tree_desc near *desc; /* the tree descriptor */{    ct_data near *tree  = desc->dyn_tree;    int near *extra     = desc->extra_bits;    int base            = desc->extra_base;    int max_code        = desc->max_code;    int max_length      = desc->max_length;    ct_data near *stree = desc->static_tree;    int h;              /* 用于遍历堆 */    int n, m;           /* 用于遍历树 */    int bits;           /* bit长度 */    int xbits;          /* extra bits */    ush f;              /* 频率 */    int overflow = 0;   /* 超长的节点数 */    for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;    /* In a first pass, compute the optimal bit lengths (which may     * overflow in the case of the bit length tree).     * 第一次遍历，计算出最优bit长度，并记录超长节点的数量，     * 如果节点超长，把它长度记为max_length。     */    tree[heap[heap_max]].Len = 0; /* root of the heap */    for (h = heap_max+1; h < HEAP_SIZE; h++) {        n = heap[h];        bits = tree[tree[n].Dad].Len + 1;        //统计overflow节点数目，注意：此处超长的内节点也算在内        if (bits > max_length) bits = max_length, overflow++;        //如果节点超长，把它长度记为max_length。        tree[n].Len = (ush)bits;        /* We overwrite tree[n].Dad which is no longer needed        *  这里体现了在ct_data结构体中使用union{dad, len}的好处：当用父节点dad        *  求出len后，数据成员dad就没有意义了，可以替换为len，节约空间        */        if (n > max_code) continue; /* 如果不是叶节点，不进行计数 */        //计数数组bl_count        bl_count[bits]++;        //由于区间码的原因，额外的扩展bit位要另外加上来。        xbits = 0;        if (n >= base) xbits = extra[n-base];        f = tree[n].Freq;        opt_len += (ulg)f * (bits + xbits);        //静态树(静态树老兄似乎没什么存在感。。。)        if (stree) static_len += (ulg)f * (stree[n].Len + xbits);    }    if (overflow == 0) return;    Trace((stderr,"\nbit length overflow\n"));    /* This happens for example on obj2 and pic of the Calgary corpus */    /* Find the first bit length which could increase:     *  开始合并超长节点    */    do {        bits = max_length-1;        while (bl_count[bits] == 0) bits--;        bl_count[bits]--;      /* 将一个叶节点下移一位 */        bl_count[bits+1] += 2; /* 将一个 overflow 叶节点上移作为其兄弟节点 */        bl_count[max_length]--;        /* 注意：此处max_length长度编码的计数器只减1，         * 却认为超长的节点消掉了2个，原因见上方图示。         */        overflow -= 2;    } while (overflow > 0);    /* Now recompute all bit lengths, scanning in increasing frequency.     * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all     * lengths instead of fixing only the wrong ones. This idea is taken     * from 'ar' written by Haruhiko Okumura.)     * 按照频率从小到大扫描，调整所有bit长度，h由于之前的循环递增，现在等于HEAP_SIZE。     */    for (bits = max_length; bits != 0; bits--) {        n = bl_count[bits];        while (n != 0) {            m = heap[--h];            if (m > max_code) continue;            if (tree[m].Len != (unsigned) bits) {                Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));                opt_len += ((long)bits-(long)tree[m].Len)*(long)tree[m].Freq;                tree[m].Len = (ush)bits;            }            n--;        }    }}

这里的映射可能有些让人头晕；就来解释一下：
映射 i -> heap[i] 中的 i 表示最大堆中的位置，而heap[i]则表示位于堆中该位置的节点在树中的位置，
因此，heap[i] = j 意味着 树节点tree[j] 在最小堆中的位置为i；
映射 j -> tree[j] 中的 j 表示length & literal 或 distace 的某个取值，
而tree[j]则是 包含着这个取值在文本中出现的频率 / huffma编码串，在堆中的父节点 / huffman编码长度的ct_data结构体；
因此，tree[j] 表示着值 j 的所有编码信息。

deflate树的特化规则gen_len

接下来分析最有意思的一段：根据长度自动生成huffman编码的过程，
1.首先将huffman树中每层节点按值(不是编码长度，是它实际的取值)从小到大排列，
比如distance = 2, 30, 5, 8, 7, 1拥有同一编码长度，就排成1, 2, 5, 7, 8, 30;

2.排列好之后，同一层从左到右(从小到大)逐个编码加一，跨层时就把当前编码左移一位；
由于之前已经记录了每层叶节点的数目，存储在bl_count中，我们可以预先算出每层最左边的那个编码；
比如，bl_count[16] =
{ 0(第零项不用), 0, 1, 1, 0, 1, 3, 1, 5, 6 ……… }

第一层：0000000 00000000（无叶节点）；加0，左移   第二层：0000000 00000000；加1，左移第三层：0000000 00000010；加1，左移第四层：0000000 00000110;加0，左移第五层：0000000 00001100；加1，左移第六层：0000000 00011010；加3，左移          第七层：0000000 00111010；

从而可以由最左边的值衍生出同一层右边的编码。
贴代码：

/* =========================================================================== * Generate the codes for a given tree and bit counts (which need not be * optimal).为作为参数传入的树生成编码 * IN assertion: the array bl_count contains the bit length statistics for * the given tree and the field len is set for all tree elements. * 输入前: 数组 bl_count 包含了所给树的所有叶节点霍夫曼编码长度的统计信息， *        并且树中所有节点都已拥有其编码串长度记录。 * OUT assertion: the field code is set for all tree elements of non *     zero code length. * 输出后：根据编码串长度自动分配好编码值。 */local void gen_codes (tree, max_code)    ct_data near *tree;        /* the tree to decorate */    int max_code;              /* largest code with non zero frequency */{    ush next_code[MAX_BITS+1]; /* next code value for each bit length */    ush code = 0;              /* running code value */    int bits;                  /* bit index */    int n;                     /* code index */    /* The distribution counts are first used to generate the code values     * without bit reversal.     */    for (bits = 1; bits <= MAX_BITS; bits++) {        next_code[bits] = code = (code + bl_count[bits-1]) << 1;    }    /* Check that the bit counts in bl_count are consistent. The last code     * must be all ones.     */    Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,            "inconsistent bit counts");    Tracev((stderr,"\ngen_codes: max_code %d ", max_code));    for (n = 0;  n <= max_code; n++) {        int len = tree[n].Len;        if (len == 0) continue;        /* Now reverse the bits */        tree[n].Code = bi_reverse(next_code[len]++, len);        Tracec(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",             n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));    }}

小结

到此为止，huffman压缩的部分已经基本分析完毕了，然而zip压缩算法还将huffman压缩的结果进行了再次压缩并封装输出，
这些过程将在下一篇文章中分析。如果你耐着性子看到了这里，真的很感谢了。