private pqdownheap ( short tree, int k ) : void | ||
tree | short | |
k | int | |
return | void |
internal void build_tree(Deflate s) { short[] array = dyn_tree; short[] static_tree = stat_desc.static_tree; int elems = stat_desc.elems; int num = -1; s.heap_len = 0; s.heap_max = HEAP_SIZE; for (int i = 0; i < elems; i++) { if (array[i * 2] != 0) { num = (s.heap[++s.heap_len] = i); s.depth[i] = 0; } else { array[i * 2 + 1] = 0; } } int num2; while (s.heap_len < 2) { num2 = (s.heap[++s.heap_len] = ((num < 2) ? (++num) : 0)); array[num2 * 2] = 1; s.depth[num2] = 0; s.opt_len--; if (static_tree != null) { s.static_len -= static_tree[num2 * 2 + 1]; } } max_code = num; for (int i = s.heap_len / 2; i >= 1; i--) { s.pqdownheap(array, i); } num2 = elems; do { int i = s.heap[1]; s.heap[1] = s.heap[s.heap_len--]; s.pqdownheap(array, 1); int num3 = s.heap[1]; s.heap[--s.heap_max] = i; s.heap[--s.heap_max] = num3; array[num2 * 2] = (short)(array[i * 2] + array[num3 * 2]); s.depth[num2] = (byte)(Math.Max(s.depth[i], s.depth[num3]) + 1); array[i * 2 + 1] = (array[num3 * 2 + 1] = (short)num2); s.heap[1] = num2++; s.pqdownheap(array, 1); }while (s.heap_len >= 2); s.heap[--s.heap_max] = s.heap[1]; gen_bitlen(s); gen_codes(array, num, s.bl_count); }
// 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. internal void build_tree(Deflate s) { short[] tree = dyn_tree; short[] stree = stat_desc.static_tree; int elems = stat_desc.elems; int n, m; // iterate over heap elements int max_code = - 1; // largest code with non zero frequency int node; // new node being created // Construct the initial heap, with least frequent element in // heap[1]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. // heap[0] is not used. s.heap_len = 0; s.heap_max = HEAP_SIZE; for (n = 0; n < elems; n++) { if (tree[n * 2] != 0) { s.heap[++s.heap_len] = max_code = n; s.depth[n] = 0; } else { tree[n * 2 + 1] = 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 (s.heap_len < 2) { node = s.heap[++s.heap_len] = (max_code < 2?++max_code:0); tree[node * 2] = 1; s.depth[node] = 0; s.opt_len--; if (stree != null) s.static_len -= stree[node * 2 + 1]; // node is 0 or 1 so it does not have extra bits } this.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 = s.heap_len / 2; n >= 1; n--) s.pqdownheap(tree, n); // Construct the Huffman tree by repeatedly combining the least two // frequent nodes. node = elems; // next internal node of the tree do { // n = node of least frequency n = s.heap[1]; s.heap[1] = s.heap[s.heap_len--]; s.pqdownheap(tree, 1); m = s.heap[1]; // m = node of next least frequency s.heap[--s.heap_max] = n; // keep the nodes sorted by frequency s.heap[--s.heap_max] = m; // Create a new node father of n and m tree[node * 2] = (short) (tree[n * 2] + tree[m * 2]); s.depth[node] = (byte) (System.Math.Max((byte) s.depth[n], (byte) s.depth[m]) + 1); tree[n * 2 + 1] = tree[m * 2 + 1] = (short) node; // and insert the new node in the heap s.heap[1] = node++; s.pqdownheap(tree, 1); } while (s.heap_len >= 2); s.heap[--s.heap_max] = s.heap[1]; // At this point, the fields freq and dad are set. We can now // generate the bit lengths. gen_bitlen(s); // The field len is now set, we can generate the bit codes gen_codes(tree, max_code, s.bl_count); }
// 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. internal void build_tree(Deflate s) { short[] tree = dyn_tree; short[] stree = stat_desc.static_tree; int elems = stat_desc.elems; int n, m; // iterate over heap elements int max_code = -1; // largest code with non zero frequency int node; // new node being created // Construct the initial heap, with least frequent element in // heap[1]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. // heap[0] is not used. s.heap_len = 0; s.heap_max = HEAP_SIZE; for (n = 0; n < elems; n++) { if (tree[n * 2] != 0) { s.heap[++s.heap_len] = max_code = n; s.depth[n] = 0; } else { tree[n * 2 + 1] = 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 (s.heap_len < 2) { node = s.heap[++s.heap_len] = (max_code < 2?++max_code:0); tree[node * 2] = 1; s.depth[node] = 0; s.opt_len--; if (stree != null) { s.static_len -= stree[node * 2 + 1]; } // node is 0 or 1 so it does not have extra bits } this.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 = s.heap_len / 2; n >= 1; n--) { s.pqdownheap(tree, n); } // Construct the Huffman tree by repeatedly combining the least two // frequent nodes. node = elems; // next internal node of the tree do { // n = node of least frequency n = s.heap[1]; s.heap[1] = s.heap[s.heap_len--]; s.pqdownheap(tree, 1); m = s.heap[1]; // m = node of next least frequency s.heap[--s.heap_max] = n; // keep the nodes sorted by frequency s.heap[--s.heap_max] = m; // Create a new node father of n and m tree[node * 2] = (short)(tree[n * 2] + tree[m * 2]); s.depth[node] = (byte)(System.Math.Max((byte)s.depth[n], (byte)s.depth[m]) + 1); tree[n * 2 + 1] = tree[m * 2 + 1] = (short)node; // and insert the new node in the heap s.heap[1] = node++; s.pqdownheap(tree, 1); }while (s.heap_len >= 2); s.heap[--s.heap_max] = s.heap[1]; // At this point, the fields freq and dad are set. We can now // generate the bit lengths. gen_bitlen(s); // The field len is now set, we can generate the bit codes gen_codes(tree, max_code, s.bl_count); }
internal void build_tree(Deflate s) { int i; int num; int num1; short[] dynTree = this.dyn_tree; short[] staticTree = this.stat_desc.static_tree; int statDesc = this.stat_desc.elems; int num2 = -1; s.heap_len = 0; s.heap_max = Tree.HEAP_SIZE; for (i = 0; i < statDesc; i++) { if (dynTree[i * 2] == 0) { dynTree[i * 2 + 1] = 0; } else { Deflate deflate = s; int heapLen = deflate.heap_len + 1; int num3 = heapLen; deflate.heap_len = heapLen; int num4 = i; num2 = num4; s.heap[num3] = num4; s.depth[i] = 0; } } while (s.heap_len < 2) { int[] numArray = s.heap; Deflate deflate1 = s; int heapLen1 = deflate1.heap_len + 1; int num5 = heapLen1; deflate1.heap_len = heapLen1; int num6 = num5; if (num2 < 2) { num1 = num2 + 1; num2 = num1; } else { num1 = 0; } int num7 = num1; numArray[num6] = num1; num = num7; dynTree[num * 2] = 1; s.depth[num] = 0; Deflate optLen = s; optLen.opt_len = optLen.opt_len - 1; if (staticTree == null) { continue; } Deflate staticLen = s; staticLen.static_len = staticLen.static_len - staticTree[num * 2 + 1]; } this.max_code = num2; for (i = s.heap_len / 2; i >= 1; i--) { s.pqdownheap(dynTree, i); } num = statDesc; do { i = s.heap[1]; int[] numArray1 = s.heap; int[] numArray2 = s.heap; Deflate deflate2 = s; int heapLen2 = deflate2.heap_len; int num8 = heapLen2; deflate2.heap_len = heapLen2 - 1; numArray1[1] = numArray2[num8]; s.pqdownheap(dynTree, 1); int num9 = s.heap[1]; Deflate deflate3 = s; int heapMax = deflate3.heap_max - 1; int num10 = heapMax; deflate3.heap_max = heapMax; s.heap[num10] = i; Deflate deflate4 = s; int heapMax1 = deflate4.heap_max - 1; int num11 = heapMax1; deflate4.heap_max = heapMax1; s.heap[num11] = num9; dynTree[num * 2] = (short)(dynTree[i * 2] + dynTree[num9 * 2]); s.depth[num] = (byte)(Math.Max(s.depth[i], s.depth[num9]) + 1); short num12 = (short)num; short num13 = num12; dynTree[num9 * 2 + 1] = num12; dynTree[i * 2 + 1] = num13; int num14 = num; num = num14 + 1; s.heap[1] = num14; s.pqdownheap(dynTree, 1); }while (s.heap_len >= 2); Deflate deflate5 = s; int heapMax2 = deflate5.heap_max - 1; int num15 = heapMax2; deflate5.heap_max = heapMax2; s.heap[num15] = s.heap[1]; this.gen_bitlen(s); Tree.gen_codes(dynTree, num2, s.bl_count); }