=========================================================================== * 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 up
(s, desc)
| 613 | * also updated if stree is not null. The field max_code is set. |
| 614 | */ |
| 615 | local void build_tree(s, desc) |
| 616 | deflate_state *s; |
| 617 | tree_desc *desc; /* the tree descriptor */ |
| 618 | { |
| 619 | ct_data *tree = desc->dyn_tree; |
| 620 | const ct_data *stree = desc->stat_desc->static_tree; |
| 621 | int elems = desc->stat_desc->elems; |
| 622 | int n, m; /* iterate over heap elements */ |
| 623 | int max_code = -1; /* largest code with non zero frequency */ |
| 624 | int node; /* new node being created */ |
| 625 | |
| 626 | /* Construct the initial heap, with least frequent element in |
| 627 | * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. |
| 628 | * heap[0] is not used. |
| 629 | */ |
| 630 | s->heap_len = 0, s->heap_max = HEAP_SIZE; |
| 631 | |
| 632 | for (n = 0; n < elems; n++) { |
| 633 | if (tree[n].Freq != 0) { |
| 634 | s->heap[++(s->heap_len)] = max_code = n; |
| 635 | s->depth[n] = 0; |
| 636 | } else { |
| 637 | tree[n].Len = 0; |
| 638 | } |
| 639 | } |
| 640 | |
| 641 | /* The pkzip format requires that at least one distance code exists, |
| 642 | * and that at least one bit should be sent even if there is only one |
| 643 | * possible code. So to avoid special checks later on we force at least |
| 644 | * two codes of non zero frequency. |
| 645 | */ |
| 646 | while (s->heap_len < 2) { |
| 647 | node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0); |
| 648 | tree[node].Freq = 1; |
| 649 | s->depth[node] = 0; |
| 650 | s->opt_len--; if (stree) s->static_len -= stree[node].Len; |
| 651 | /* node is 0 or 1 so it does not have extra bits */ |
| 652 | } |
| 653 | desc->max_code = max_code; |
| 654 | |
| 655 | /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, |
| 656 | * establish sub-heaps of increasing lengths: |
| 657 | */ |
| 658 | for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n); |
| 659 | |
| 660 | /* Construct the Huffman tree by repeatedly combining the least two |
| 661 | * frequent nodes. |
| 662 | */ |
| 663 | node = elems; /* next internal node of the tree */ |
| 664 | do { |
| 665 | pqremove(s, tree, n); /* n = node of least frequency */ |
| 666 | m = s->heap[SMALLEST]; /* m = node of next least frequency */ |
| 667 | |
| 668 | s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */ |
| 669 | s->heap[--(s->heap_max)] = m; |
| 670 | |
| 671 | /* Create a new node father of n and m */ |
| 672 | tree[node].Freq = tree[n].Freq + tree[m].Freq; |
no test coverage detected