summaryrefslogtreecommitdiff
path: root/src/pkg/compress/flate/huffman_code.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/compress/flate/huffman_code.go')
-rw-r--r--src/pkg/compress/flate/huffman_code.go240
1 files changed, 120 insertions, 120 deletions
diff --git a/src/pkg/compress/flate/huffman_code.go b/src/pkg/compress/flate/huffman_code.go
index f212d059d..94ff2dfb8 100644
--- a/src/pkg/compress/flate/huffman_code.go
+++ b/src/pkg/compress/flate/huffman_code.go
@@ -5,57 +5,57 @@
package flate
import (
- "math";
- "sort";
+ "math"
+ "sort"
)
type huffmanEncoder struct {
- codeBits []uint8;
- code []uint16;
+ codeBits []uint8
+ code []uint16
}
type literalNode struct {
- literal uint16;
- freq int32;
+ literal uint16
+ freq int32
}
type chain struct {
// The sum of the leaves in this tree
- freq int32;
+ freq int32
// The number of literals to the left of this item at this level
- leafCount int32;
+ leafCount int32
// The right child of this chain in the previous level.
- up *chain;
+ up *chain
}
type levelInfo struct {
// Our level. for better printing
- level int32;
+ level int32
// The most recent chain generated for this level
- lastChain *chain;
+ lastChain *chain
// The frequency of the next character to add to this level
- nextCharFreq int32;
+ nextCharFreq int32
// The frequency of the next pair (from level below) to add to this level.
// Only valid if the "needed" value of the next lower level is 0.
- nextPairFreq int32;
+ nextPairFreq int32
// The number of chains remaining to generate for this level before moving
// up to the next level
- needed int32;
+ needed int32
// The levelInfo for level+1
- up *levelInfo;
+ up *levelInfo
// The levelInfo for level-1
- down *levelInfo;
+ down *levelInfo
}
-func maxNode() literalNode { return literalNode{math.MaxUint16, math.MaxInt32} }
+func maxNode() literalNode { return literalNode{math.MaxUint16, math.MaxInt32} }
func newHuffmanEncoder(size int) *huffmanEncoder {
return &huffmanEncoder{make([]uint8, size), make([]uint16, size)}
@@ -63,96 +63,96 @@ func newHuffmanEncoder(size int) *huffmanEncoder {
// Generates a HuffmanCode corresponding to the fixed literal table
func generateFixedLiteralEncoding() *huffmanEncoder {
- h := newHuffmanEncoder(maxLit);
- codeBits := h.codeBits;
- code := h.code;
- var ch uint16;
+ h := newHuffmanEncoder(maxLit)
+ codeBits := h.codeBits
+ code := h.code
+ var ch uint16
for ch = 0; ch < maxLit; ch++ {
- var bits uint16;
- var size uint8;
+ var bits uint16
+ var size uint8
switch {
case ch < 144:
// size 8, 000110000 .. 10111111
- bits = ch + 48;
- size = 8;
- break;
+ bits = ch + 48
+ size = 8
+ break
case ch < 256:
// size 9, 110010000 .. 111111111
- bits = ch + 400 - 144;
- size = 9;
- break;
+ bits = ch + 400 - 144
+ size = 9
+ break
case ch < 280:
// size 7, 0000000 .. 0010111
- bits = ch - 256;
- size = 7;
- break;
+ bits = ch - 256
+ size = 7
+ break
default:
// size 8, 11000000 .. 11000111
- bits = ch + 192 - 280;
- size = 8;
+ bits = ch + 192 - 280
+ size = 8
}
- codeBits[ch] = size;
- code[ch] = reverseBits(bits, size);
+ codeBits[ch] = size
+ code[ch] = reverseBits(bits, size)
}
- return h;
+ return h
}
func generateFixedOffsetEncoding() *huffmanEncoder {
- h := newHuffmanEncoder(30);
- codeBits := h.codeBits;
- code := h.code;
+ h := newHuffmanEncoder(30)
+ codeBits := h.codeBits
+ code := h.code
for ch := uint16(0); ch < 30; ch++ {
- codeBits[ch] = 5;
- code[ch] = reverseBits(ch, 5);
+ codeBits[ch] = 5
+ code[ch] = reverseBits(ch, 5)
}
- return h;
+ return h
}
var fixedLiteralEncoding *huffmanEncoder = generateFixedLiteralEncoding()
var fixedOffsetEncoding *huffmanEncoder = generateFixedOffsetEncoding()
func (h *huffmanEncoder) bitLength(freq []int32) int64 {
- var total int64;
+ var total int64
for i, f := range freq {
if f != 0 {
total += int64(f) * int64(h.codeBits[i])
}
}
- return total;
+ return total
}
// Generate elements in the chain using an iterative algorithm.
func (h *huffmanEncoder) generateChains(top *levelInfo, list []literalNode) {
- n := len(list);
- list = list[0 : n+1];
- list[n] = maxNode();
+ n := len(list)
+ list = list[0 : n+1]
+ list[n] = maxNode()
- l := top;
+ l := top
for {
if l.nextPairFreq == math.MaxInt32 && l.nextCharFreq == math.MaxInt32 {
// We've run out of both leafs and pairs.
// End all calculations for this level.
// To m sure we never come back to this level or any lower level,
// set nextPairFreq impossibly large.
- l.lastChain = nil;
- l.needed = 0;
- l = l.up;
- l.nextPairFreq = math.MaxInt32;
- continue;
+ l.lastChain = nil
+ l.needed = 0
+ l = l.up
+ l.nextPairFreq = math.MaxInt32
+ continue
}
- prevFreq := l.lastChain.freq;
+ prevFreq := l.lastChain.freq
if l.nextCharFreq < l.nextPairFreq {
// The next item on this row is a leaf node.
- n := l.lastChain.leafCount + 1;
- l.lastChain = &chain{l.nextCharFreq, n, l.lastChain.up};
- l.nextCharFreq = list[n].freq;
+ n := l.lastChain.leafCount + 1
+ l.lastChain = &chain{l.nextCharFreq, n, l.lastChain.up}
+ l.nextCharFreq = list[n].freq
} else {
// The next item on this row is a pair from the previous row.
// nextPairFreq isn't valid until we generate two
// more values in the level below
- l.lastChain = &chain{l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain};
- l.down.needed = 2;
+ l.lastChain = &chain{l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain}
+ l.down.needed = 2
}
if l.needed--; l.needed == 0 {
@@ -160,13 +160,13 @@ func (h *huffmanEncoder) generateChains(top *levelInfo, list []literalNode) {
// Continue calculating one level up. Fill in nextPairFreq
// of that level with the sum of the two nodes we've just calculated on
// this level.
- up := l.up;
+ up := l.up
if up == nil {
// All done!
return
}
- up.nextPairFreq = prevFreq + l.lastChain.freq;
- l = up;
+ up.nextPairFreq = prevFreq + l.lastChain.freq
+ l = up
} else {
// If we stole from below, move down temporarily to replenish it.
for l.down.needed > 0 {
@@ -189,20 +189,20 @@ func (h *huffmanEncoder) generateChains(top *levelInfo, list []literalNode) {
// return An integer array in which array[i] indicates the number of literals
// that should be encoded in i bits.
func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
- n := int32(len(list));
- list = list[0 : n+1];
- list[n] = maxNode();
+ n := int32(len(list))
+ list = list[0 : n+1]
+ list[n] = maxNode()
// The tree can't have greater depth than n - 1, no matter what. This
// saves a little bit of work in some small cases
- maxBits = minInt32(maxBits, n-1);
+ maxBits = minInt32(maxBits, n-1)
// Create information about each of the levels.
// A bogus "Level 0" whose sole purpose is so that
// level1.prev.needed==0. This makes level1.nextPairFreq
// be a legitimate value that never gets chosen.
- top := &levelInfo{needed: 0};
- chain2 := &chain{list[1].freq, 2, new(chain)};
+ top := &levelInfo{needed: 0}
+ chain2 := &chain{list[1].freq, 2, new(chain)}
for level := int32(1); level <= maxBits; level++ {
// For every level, the first two items are the first two characters.
// We initialize the levels as if we had already figured this out.
@@ -212,42 +212,42 @@ func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
nextCharFreq: list[2].freq,
nextPairFreq: list[0].freq + list[1].freq,
down: top,
- };
- top.down.up = top;
+ }
+ top.down.up = top
if level == 1 {
top.nextPairFreq = math.MaxInt32
}
}
// We need a total of 2*n - 2 items at top level and have already generated 2.
- top.needed = 2*n - 4;
+ top.needed = 2*n - 4
- l := top;
+ l := top
for {
if l.nextPairFreq == math.MaxInt32 && l.nextCharFreq == math.MaxInt32 {
// We've run out of both leafs and pairs.
// End all calculations for this level.
// To m sure we never come back to this level or any lower level,
// set nextPairFreq impossibly large.
- l.lastChain = nil;
- l.needed = 0;
- l = l.up;
- l.nextPairFreq = math.MaxInt32;
- continue;
+ l.lastChain = nil
+ l.needed = 0
+ l = l.up
+ l.nextPairFreq = math.MaxInt32
+ continue
}
- prevFreq := l.lastChain.freq;
+ prevFreq := l.lastChain.freq
if l.nextCharFreq < l.nextPairFreq {
// The next item on this row is a leaf node.
- n := l.lastChain.leafCount + 1;
- l.lastChain = &chain{l.nextCharFreq, n, l.lastChain.up};
- l.nextCharFreq = list[n].freq;
+ n := l.lastChain.leafCount + 1
+ l.lastChain = &chain{l.nextCharFreq, n, l.lastChain.up}
+ l.nextCharFreq = list[n].freq
} else {
// The next item on this row is a pair from the previous row.
// nextPairFreq isn't valid until we generate two
// more values in the level below
- l.lastChain = &chain{l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain};
- l.down.needed = 2;
+ l.lastChain = &chain{l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain}
+ l.down.needed = 2
}
if l.needed--; l.needed == 0 {
@@ -255,13 +255,13 @@ func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
// Continue calculating one level up. Fill in nextPairFreq
// of that level with the sum of the two nodes we've just calculated on
// this level.
- up := l.up;
+ up := l.up
if up == nil {
// All done!
break
}
- up.nextPairFreq = prevFreq + l.lastChain.freq;
- l = up;
+ up.nextPairFreq = prevFreq + l.lastChain.freq
+ l = up
} else {
// If we stole from below, move down temporarily to replenish it.
for l.down.needed > 0 {
@@ -277,23 +277,23 @@ func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
panic("top.lastChain.leafCount != n")
}
- bitCount := make([]int32, maxBits+1);
- bits := 1;
+ bitCount := make([]int32, maxBits+1)
+ bits := 1
for chain := top.lastChain; chain.up != nil; chain = chain.up {
// chain.leafCount gives the number of literals requiring at least "bits"
// bits to encode.
- bitCount[bits] = chain.leafCount - chain.up.leafCount;
- bits++;
+ bitCount[bits] = chain.leafCount - chain.up.leafCount
+ bits++
}
- return bitCount;
+ return bitCount
}
// Look at the leaves and assign them a bit count and an encoding as specified
// in RFC 1951 3.2.2
func (h *huffmanEncoder) assignEncodingAndSize(bitCount []int32, list []literalNode) {
- code := uint16(0);
+ code := uint16(0)
for n, bits := range bitCount {
- code <<= 1;
+ code <<= 1
if n == 0 || bits == 0 {
continue
}
@@ -301,14 +301,14 @@ func (h *huffmanEncoder) assignEncodingAndSize(bitCount []int32, list []literalN
// are encoded using "bits" bits, and get the values
// code, code + 1, .... The code values are
// assigned in literal order (not frequency order).
- chunk := list[len(list)-int(bits):];
- sortByLiteral(chunk);
+ chunk := list[len(list)-int(bits):]
+ sortByLiteral(chunk)
for _, node := range chunk {
- h.codeBits[node.literal] = uint8(n);
- h.code[node.literal] = reverseBits(code, uint8(n));
- code++;
+ h.codeBits[node.literal] = uint8(n)
+ h.code[node.literal] = reverseBits(code, uint8(n))
+ code++
}
- list = list[0 : len(list)-int(bits)];
+ list = list[0 : len(list)-int(bits)]
}
}
@@ -317,58 +317,58 @@ func (h *huffmanEncoder) assignEncodingAndSize(bitCount []int32, list []literalN
// freq An array of frequencies, in which frequency[i] gives the frequency of literal i.
// maxBits The maximum number of bits to use for any literal.
func (h *huffmanEncoder) generate(freq []int32, maxBits int32) {
- list := make([]literalNode, len(freq)+1);
+ list := make([]literalNode, len(freq)+1)
// Number of non-zero literals
- count := 0;
+ count := 0
// Set list to be the set of all non-zero literals and their frequencies
for i, f := range freq {
if f != 0 {
- list[count] = literalNode{uint16(i), f};
- count++;
+ list[count] = literalNode{uint16(i), f}
+ count++
} else {
h.codeBits[i] = 0
}
}
// If freq[] is shorter than codeBits[], fill rest of codeBits[] with zeros
- h.codeBits = h.codeBits[0:len(freq)];
- list = list[0:count];
+ h.codeBits = h.codeBits[0:len(freq)]
+ list = list[0:count]
if count <= 2 {
// Handle the small cases here, because they are awkward for the general case code. With
// two or fewer literals, everything has bit length 1.
for i, node := range list {
// "list" is in order of increasing literal value.
- h.codeBits[node.literal] = 1;
- h.code[node.literal] = uint16(i);
+ h.codeBits[node.literal] = 1
+ h.code[node.literal] = uint16(i)
}
- return;
+ return
}
- sortByFreq(list);
+ sortByFreq(list)
// Get the number of literals for each bit count
- bitCount := h.bitCounts(list, maxBits);
+ bitCount := h.bitCounts(list, maxBits)
// And do the assignment
- h.assignEncodingAndSize(bitCount, list);
+ h.assignEncodingAndSize(bitCount, list)
}
type literalNodeSorter struct {
- a []literalNode;
- less func(i, j int) bool;
+ a []literalNode
+ less func(i, j int) bool
}
-func (s literalNodeSorter) Len() int { return len(s.a) }
+func (s literalNodeSorter) Len() int { return len(s.a) }
func (s literalNodeSorter) Less(i, j int) bool {
return s.less(i, j)
}
-func (s literalNodeSorter) Swap(i, j int) { s.a[i], s.a[j] = s.a[j], s.a[i] }
+func (s literalNodeSorter) Swap(i, j int) { s.a[i], s.a[j] = s.a[j], s.a[i] }
func sortByFreq(a []literalNode) {
- s := &literalNodeSorter{a, func(i, j int) bool { return a[i].freq < a[j].freq }};
- sort.Sort(s);
+ s := &literalNodeSorter{a, func(i, j int) bool { return a[i].freq < a[j].freq }}
+ sort.Sort(s)
}
func sortByLiteral(a []literalNode) {
- s := &literalNodeSorter{a, func(i, j int) bool { return a[i].literal < a[j].literal }};
- sort.Sort(s);
+ s := &literalNodeSorter{a, func(i, j int) bool { return a[i].literal < a[j].literal }}
+ sort.Sort(s)
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-12 16:59:02 +0000