/* ========================================================================== *Construct one Huffman tree and assigns the code bit strings and lengths. *Update the total bit length for the current block. *IN assertion: the field freq is set for all tree elements. *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. */ void build_tree(DeflateTreeDesc desc) { // the tree descriptor DeflateCT[] tree =desc.dyn_tree; DeflateCT[] 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_len=0; heap_max=HEAP_SIZE; for(n=0;n<elems;n++){ if(tree[n].fc!=0){ heap[++heap_len]=max_code=n; depth[n]=0; }else{ tree[n].dl=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 xnew=heap[++heap_len]=(max_code<2?++max_code:0); tree[xnew].fc=1; depth[xnew]=0; opt_len--; if(stree!=null)static_len-=stree[xnew].dl; // 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>>1;n>=1;n--)pqdownheap(tree,n); /* Construct the Huffman tree by repeatedly combining the least two *frequent nodes. */ do{ n=heap[SMALLEST]; heap[SMALLEST]=heap[heap_len--]; pqdownheap(tree,SMALLEST); m=heap[SMALLEST]; // m=node of next least frequency // keep the nodes sorted by frequency heap[--heap_max]=n; heap[--heap_max]=m; // Create a new node father of n and m tree[node].fc=tree[n].fc+tree[m].fc; // depth[node]=(char)(MAX(depth[n],depth[m])+1); if(depth[n]>depth[m]+1){ depth[node]=depth[n]; }else{ depth[node]=depth[m]+1; } tree[n].dl=tree[m].dl=node; // and insert the new node in the heap heap[SMALLEST]=node++; pqdownheap(tree,SMALLEST); }while(heap_len>=2); heap[--heap_max]=heap[SMALLEST]; /* At this point,the fields freq and dad are set. We can now *generate the bit lengths. */ gen_bitlen(desc); // The field len is now set,we can generate the bit codes gen_codes(tree,max_code); }
void deflate_start(int level) { if(level==0) level=DEFAULT_LEVEL; else if(level<1) level=1; else if(level>9) level=9; this.compr_level=level; this.initflag=false; this.eofile=false; if(outbuf!=null)return; this.free_queue=this.qhead=this.qtail=null; this.outbuf=new byte[OUTBUFSIZ]; this.win=new byte[window_size]; this.d_buf=new int[DIST_BUFSIZE]; this.l_buf=new int[INBUFSIZ+INBUF_EXTRA]; this.prev=new int[1<<BITS]; this.dyn_ltree=new_ctarray(HEAP_SIZE); this.dyn_dtree=new_ctarray(2*D_CODES+1); this.static_ltree=new_ctarray(L_CODES+2); this.static_dtree=new_ctarray(D_CODES); this.bl_tree=new_ctarray(2*BL_CODES+1); this.l_desc=new DeflateTreeDesc(); this.d_desc=new DeflateTreeDesc(); this.bl_desc=new DeflateTreeDesc(); this.bl_count=new int[MAX_BITS+1]; this.heap=new int[2*L_CODES+1]; this.depth=new int[2*L_CODES+1]; this.length_code=new int[MAX_MATCH-MIN_MATCH+1]; this.dist_code=new int[512]; this.base_length=new int[LENGTH_CODES]; this.base_dist=new int[D_CODES]; this.flag_buf=new int[LIT_BUFSIZE/8]; }
/* ========================================================================== *Compute the optimal bit lengths for a tree and update the total bit length *for the current block. *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. */ void gen_bitlen(DeflateTreeDesc desc) { // the tree descriptor DeflateCT[] tree =desc.dyn_tree; int[] extra =desc.extra_bits; int @base =desc.extra_base; int max_code =desc.max_code; int max_length =desc.max_length; DeflateCT[] stree =desc.static_tree; int h; // heap index int n,m; // iterate over the tree elements int bits; // bit length int xbits; // extra bits int f; // frequency int overflow=0; // number of elements with bit length too large 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). */ tree[heap[heap_max]].dl=0;// root of the heap for(h=heap_max+1;h<HEAP_SIZE;h++){ n=heap[h]; bits=tree[tree[n].dl].dl+1; if(bits>max_length){ bits=max_length; overflow++; } tree[n].dl=bits; // We overwrite tree[n].dl which is no longer needed if(n>max_code)continue;// not a leaf node bl_count[bits]++; xbits=0; if(n>=@base)xbits=extra[n-@base]; f=tree[n].fc; opt_len+=f*(bits+xbits); if(stree!=null)static_len+=f*(stree[n].dl+xbits); } if(overflow==0)return; // 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]--; // move one leaf down the tree bl_count[bits+1]+=2; // move one overflow item as its brother bl_count[max_length]--; /* The brother of the overflow item also moves one step up, *but this does not affect bl_count[max_length] */ 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.) */ 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].dl!=bits){ opt_len+=(bits-tree[m].dl)*tree[m].fc; tree[m].fc=bits; } n--; } } }