typenative 0.3.1 → 0.4.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +57 -0
- package/README.md +17 -1
- package/bin/cli.js +25 -11
- package/bin/go/convert.js +11 -1
- package/bin/index.js +221 -47
- package/bin/main.js +35 -14
- package/bin/node/assert.js +2 -2
- package/bin/node/buffer.js +9 -0
- package/bin/node/dns.js +1 -1
- package/bin/node/events.js +1 -1
- package/bin/node/fs.js +1 -1
- package/bin/node/fs_watch.js +407 -0
- package/bin/node/http2.js +33 -6
- package/bin/node/readline.js +1 -1
- package/bin/node/registry.js +2 -1
- package/bin/node/stream.js +6 -3
- package/bin/node/timers.js +1 -1
- package/bin/node/typed_arrays.js +608 -0
- package/bin/node/util.js +3 -0
- package/bin/node/zlib.js +131 -16
- package/bin/transpiler.js +635 -44
- package/bin/version.js +1 -1
- package/conformance.md +16 -4
- package/examples/README.md +54 -0
- package/examples/fibonacci/README.md +89 -0
- package/examples/fibonacci/bench.mjs +87 -0
- package/examples/fibonacci/main.ts +21 -0
- package/examples/hello-world/README.md +62 -0
- package/examples/hello-world/bench.mjs +66 -0
- package/examples/hello-world/main.ts +7 -0
- package/examples/json-server/README.md +125 -0
- package/examples/json-server/bench.mjs +171 -0
- package/examples/json-server/main.ts +67 -0
- package/govendor/github.com/andybalholm/brotli/LICENSE +19 -0
- package/govendor/github.com/andybalholm/brotli/README.md +19 -0
- package/govendor/github.com/andybalholm/brotli/backward_references.go +185 -0
- package/govendor/github.com/andybalholm/brotli/backward_references_hq.go +796 -0
- package/govendor/github.com/andybalholm/brotli/bit_cost.go +436 -0
- package/govendor/github.com/andybalholm/brotli/bit_reader.go +266 -0
- package/govendor/github.com/andybalholm/brotli/bitwriter.go +56 -0
- package/govendor/github.com/andybalholm/brotli/block_splitter.go +144 -0
- package/govendor/github.com/andybalholm/brotli/block_splitter_command.go +434 -0
- package/govendor/github.com/andybalholm/brotli/block_splitter_distance.go +433 -0
- package/govendor/github.com/andybalholm/brotli/block_splitter_literal.go +433 -0
- package/govendor/github.com/andybalholm/brotli/brotli_bit_stream.go +1435 -0
- package/govendor/github.com/andybalholm/brotli/cluster.go +30 -0
- package/govendor/github.com/andybalholm/brotli/cluster_command.go +164 -0
- package/govendor/github.com/andybalholm/brotli/cluster_distance.go +326 -0
- package/govendor/github.com/andybalholm/brotli/cluster_literal.go +326 -0
- package/govendor/github.com/andybalholm/brotli/command.go +254 -0
- package/govendor/github.com/andybalholm/brotli/compress_fragment.go +834 -0
- package/govendor/github.com/andybalholm/brotli/compress_fragment_two_pass.go +775 -0
- package/govendor/github.com/andybalholm/brotli/constants.go +77 -0
- package/govendor/github.com/andybalholm/brotli/context.go +2176 -0
- package/govendor/github.com/andybalholm/brotli/decode.go +2570 -0
- package/govendor/github.com/andybalholm/brotli/dictionary.go +122890 -0
- package/govendor/github.com/andybalholm/brotli/dictionary_hash.go +32779 -0
- package/govendor/github.com/andybalholm/brotli/encode.go +1220 -0
- package/govendor/github.com/andybalholm/brotli/encoder.go +177 -0
- package/govendor/github.com/andybalholm/brotli/encoder_dict.go +22 -0
- package/govendor/github.com/andybalholm/brotli/encoder_fast.go +201 -0
- package/govendor/github.com/andybalholm/brotli/entropy_encode.go +592 -0
- package/govendor/github.com/andybalholm/brotli/entropy_encode_static.go +4399 -0
- package/govendor/github.com/andybalholm/brotli/fast_log.go +290 -0
- package/govendor/github.com/andybalholm/brotli/find_match_length.go +45 -0
- package/govendor/github.com/andybalholm/brotli/go.mod +3 -0
- package/govendor/github.com/andybalholm/brotli/h10.go +287 -0
- package/govendor/github.com/andybalholm/brotli/h5.go +214 -0
- package/govendor/github.com/andybalholm/brotli/h6.go +216 -0
- package/govendor/github.com/andybalholm/brotli/hash.go +342 -0
- package/govendor/github.com/andybalholm/brotli/hash_composite.go +93 -0
- package/govendor/github.com/andybalholm/brotli/hash_forgetful_chain.go +252 -0
- package/govendor/github.com/andybalholm/brotli/hash_longest_match_quickly.go +214 -0
- package/govendor/github.com/andybalholm/brotli/hash_rolling.go +168 -0
- package/govendor/github.com/andybalholm/brotli/histogram.go +226 -0
- package/govendor/github.com/andybalholm/brotli/http.go +201 -0
- package/govendor/github.com/andybalholm/brotli/huffman.go +653 -0
- package/govendor/github.com/andybalholm/brotli/literal_cost.go +182 -0
- package/govendor/github.com/andybalholm/brotli/matchfinder/bargain1.go +212 -0
- package/govendor/github.com/andybalholm/brotli/matchfinder/bargain2.go +248 -0
- package/govendor/github.com/andybalholm/brotli/matchfinder/bargain3.go +278 -0
- package/govendor/github.com/andybalholm/brotli/matchfinder/emitter.go +34 -0
- package/govendor/github.com/andybalholm/brotli/matchfinder/m0.go +175 -0
- package/govendor/github.com/andybalholm/brotli/matchfinder/m4.go +339 -0
- package/govendor/github.com/andybalholm/brotli/matchfinder/matchfinder.go +103 -0
- package/govendor/github.com/andybalholm/brotli/matchfinder/pathfinder.go +328 -0
- package/govendor/github.com/andybalholm/brotli/matchfinder/textencoder.go +53 -0
- package/govendor/github.com/andybalholm/brotli/matchfinder/trio.go +327 -0
- package/govendor/github.com/andybalholm/brotli/matchfinder/zdfast.go +258 -0
- package/govendor/github.com/andybalholm/brotli/matchfinder/zfast.go +206 -0
- package/govendor/github.com/andybalholm/brotli/matchfinder/zm.go +302 -0
- package/govendor/github.com/andybalholm/brotli/memory.go +66 -0
- package/govendor/github.com/andybalholm/brotli/metablock.go +574 -0
- package/govendor/github.com/andybalholm/brotli/metablock_command.go +165 -0
- package/govendor/github.com/andybalholm/brotli/metablock_distance.go +165 -0
- package/govendor/github.com/andybalholm/brotli/metablock_literal.go +165 -0
- package/govendor/github.com/andybalholm/brotli/params.go +37 -0
- package/govendor/github.com/andybalholm/brotli/platform.go +103 -0
- package/govendor/github.com/andybalholm/brotli/prefix.go +30 -0
- package/govendor/github.com/andybalholm/brotli/prefix_dec.go +723 -0
- package/govendor/github.com/andybalholm/brotli/quality.go +196 -0
- package/govendor/github.com/andybalholm/brotli/reader.go +127 -0
- package/govendor/github.com/andybalholm/brotli/ringbuffer.go +134 -0
- package/govendor/github.com/andybalholm/brotli/state.go +313 -0
- package/govendor/github.com/andybalholm/brotli/static_dict.go +662 -0
- package/govendor/github.com/andybalholm/brotli/static_dict_lut.go +75094 -0
- package/govendor/github.com/andybalholm/brotli/symbol_list.go +22 -0
- package/govendor/github.com/andybalholm/brotli/transform.go +641 -0
- package/govendor/github.com/andybalholm/brotli/utf8_util.go +70 -0
- package/govendor/github.com/andybalholm/brotli/util.go +7 -0
- package/govendor/github.com/andybalholm/brotli/write_bits.go +52 -0
- package/govendor/github.com/andybalholm/brotli/writer.go +162 -0
- package/govendor/github.com/fsnotify/fsnotify/.mailmap +2 -0
- package/govendor/github.com/fsnotify/fsnotify/CHANGELOG.md +651 -0
- package/govendor/github.com/fsnotify/fsnotify/CONTRIBUTING.md +147 -0
- package/govendor/github.com/fsnotify/fsnotify/LICENSE +25 -0
- package/govendor/github.com/fsnotify/fsnotify/README.md +214 -0
- package/govendor/github.com/fsnotify/fsnotify/backend_fen.go +469 -0
- package/govendor/github.com/fsnotify/fsnotify/backend_inotify.go +597 -0
- package/govendor/github.com/fsnotify/fsnotify/backend_kqueue.go +735 -0
- package/govendor/github.com/fsnotify/fsnotify/backend_other.go +22 -0
- package/govendor/github.com/fsnotify/fsnotify/backend_windows.go +702 -0
- package/govendor/github.com/fsnotify/fsnotify/fsnotify.go +526 -0
- package/govendor/github.com/fsnotify/fsnotify/go.mod +3 -0
- package/govendor/github.com/fsnotify/fsnotify/internal/darwin.go +20 -0
- package/govendor/github.com/fsnotify/fsnotify/internal/debug_darwin.go +15 -0
- package/govendor/github.com/fsnotify/fsnotify/internal/debug_dragonfly.go +15 -0
- package/govendor/github.com/fsnotify/fsnotify/internal/debug_freebsd.go +20 -0
- package/govendor/github.com/fsnotify/fsnotify/internal/debug_kqueue.go +32 -0
- package/govendor/github.com/fsnotify/fsnotify/internal/debug_linux.go +56 -0
- package/govendor/github.com/fsnotify/fsnotify/internal/debug_netbsd.go +15 -0
- package/govendor/github.com/fsnotify/fsnotify/internal/debug_openbsd.go +16 -0
- package/govendor/github.com/fsnotify/fsnotify/internal/debug_solaris.go +45 -0
- package/govendor/github.com/fsnotify/fsnotify/internal/debug_windows.go +40 -0
- package/govendor/github.com/fsnotify/fsnotify/internal/freebsd.go +20 -0
- package/govendor/github.com/fsnotify/fsnotify/internal/internal.go +2 -0
- package/govendor/github.com/fsnotify/fsnotify/internal/unix.go +20 -0
- package/govendor/github.com/fsnotify/fsnotify/internal/unix2.go +25 -0
- package/govendor/github.com/fsnotify/fsnotify/internal/windows.go +40 -0
- package/govendor/github.com/fsnotify/fsnotify/shared.go +64 -0
- package/govendor/github.com/fsnotify/fsnotify/staticcheck.conf +3 -0
- package/govendor/github.com/fsnotify/fsnotify/system_bsd.go +7 -0
- package/govendor/github.com/fsnotify/fsnotify/system_darwin.go +8 -0
- package/govendor/manifest.txt +3 -1
- package/package.json +1 -1
- package/types/typenative-npm.d.ts +72 -0
- package/types/typenative.d.ts +117 -1
|
@@ -0,0 +1,2570 @@
|
|
|
1
|
+
package brotli
|
|
2
|
+
|
|
3
|
+
/* Copyright 2013 Google Inc. All Rights Reserved.
|
|
4
|
+
|
|
5
|
+
Distributed under MIT license.
|
|
6
|
+
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
|
|
7
|
+
*/
|
|
8
|
+
|
|
9
|
+
const (
|
|
10
|
+
decoderResultError = 0
|
|
11
|
+
decoderResultSuccess = 1
|
|
12
|
+
decoderResultNeedsMoreInput = 2
|
|
13
|
+
decoderResultNeedsMoreOutput = 3
|
|
14
|
+
)
|
|
15
|
+
|
|
16
|
+
/**
|
|
17
|
+
* Error code for detailed logging / production debugging.
|
|
18
|
+
*
|
|
19
|
+
* See ::BrotliDecoderGetErrorCode and ::BROTLI_LAST_ERROR_CODE.
|
|
20
|
+
*/
|
|
21
|
+
const (
|
|
22
|
+
decoderNoError = 0
|
|
23
|
+
decoderSuccess = 1
|
|
24
|
+
decoderNeedsMoreInput = 2
|
|
25
|
+
decoderNeedsMoreOutput = 3
|
|
26
|
+
decoderErrorFormatExuberantNibble = -1
|
|
27
|
+
decoderErrorFormatReserved = -2
|
|
28
|
+
decoderErrorFormatExuberantMetaNibble = -3
|
|
29
|
+
decoderErrorFormatSimpleHuffmanAlphabet = -4
|
|
30
|
+
decoderErrorFormatSimpleHuffmanSame = -5
|
|
31
|
+
decoderErrorFormatClSpace = -6
|
|
32
|
+
decoderErrorFormatHuffmanSpace = -7
|
|
33
|
+
decoderErrorFormatContextMapRepeat = -8
|
|
34
|
+
decoderErrorFormatBlockLength1 = -9
|
|
35
|
+
decoderErrorFormatBlockLength2 = -10
|
|
36
|
+
decoderErrorFormatTransform = -11
|
|
37
|
+
decoderErrorFormatDictionary = -12
|
|
38
|
+
decoderErrorFormatWindowBits = -13
|
|
39
|
+
decoderErrorFormatPadding1 = -14
|
|
40
|
+
decoderErrorFormatPadding2 = -15
|
|
41
|
+
decoderErrorFormatDistance = -16
|
|
42
|
+
decoderErrorDictionaryNotSet = -19
|
|
43
|
+
decoderErrorInvalidArguments = -20
|
|
44
|
+
decoderErrorAllocContextModes = -21
|
|
45
|
+
decoderErrorAllocTreeGroups = -22
|
|
46
|
+
decoderErrorAllocContextMap = -25
|
|
47
|
+
decoderErrorAllocRingBuffer1 = -26
|
|
48
|
+
decoderErrorAllocRingBuffer2 = -27
|
|
49
|
+
decoderErrorAllocBlockTypeTrees = -30
|
|
50
|
+
decoderErrorUnreachable = -31
|
|
51
|
+
)
|
|
52
|
+
|
|
53
|
+
const huffmanTableBits = 8
|
|
54
|
+
|
|
55
|
+
const huffmanTableMask = 0xFF
|
|
56
|
+
|
|
57
|
+
/* We need the slack region for the following reasons:
|
|
58
|
+
- doing up to two 16-byte copies for fast backward copying
|
|
59
|
+
- inserting transformed dictionary word (5 prefix + 24 base + 8 suffix) */
|
|
60
|
+
const kRingBufferWriteAheadSlack uint32 = 42
|
|
61
|
+
|
|
62
|
+
var kCodeLengthCodeOrder = [codeLengthCodes]byte{1, 2, 3, 4, 0, 5, 17, 6, 16, 7, 8, 9, 10, 11, 12, 13, 14, 15}
|
|
63
|
+
|
|
64
|
+
/* Static prefix code for the complex code length code lengths. */
|
|
65
|
+
var kCodeLengthPrefixLength = [16]byte{2, 2, 2, 3, 2, 2, 2, 4, 2, 2, 2, 3, 2, 2, 2, 4}
|
|
66
|
+
|
|
67
|
+
var kCodeLengthPrefixValue = [16]byte{0, 4, 3, 2, 0, 4, 3, 1, 0, 4, 3, 2, 0, 4, 3, 5}
|
|
68
|
+
|
|
69
|
+
/* Saves error code and converts it to BrotliDecoderResult. */
|
|
70
|
+
func saveErrorCode(s *Reader, e int) int {
|
|
71
|
+
s.error_code = int(e)
|
|
72
|
+
switch e {
|
|
73
|
+
case decoderSuccess:
|
|
74
|
+
return decoderResultSuccess
|
|
75
|
+
|
|
76
|
+
case decoderNeedsMoreInput:
|
|
77
|
+
return decoderResultNeedsMoreInput
|
|
78
|
+
|
|
79
|
+
case decoderNeedsMoreOutput:
|
|
80
|
+
return decoderResultNeedsMoreOutput
|
|
81
|
+
|
|
82
|
+
default:
|
|
83
|
+
return decoderResultError
|
|
84
|
+
}
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
/* Decodes WBITS by reading 1 - 7 bits, or 0x11 for "Large Window Brotli".
|
|
88
|
+
Precondition: bit-reader accumulator has at least 8 bits. */
|
|
89
|
+
func decodeWindowBits(s *Reader, br *bitReader) int {
|
|
90
|
+
var n uint32
|
|
91
|
+
var large_window bool = s.large_window
|
|
92
|
+
s.large_window = false
|
|
93
|
+
takeBits(br, 1, &n)
|
|
94
|
+
if n == 0 {
|
|
95
|
+
s.window_bits = 16
|
|
96
|
+
return decoderSuccess
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
takeBits(br, 3, &n)
|
|
100
|
+
if n != 0 {
|
|
101
|
+
s.window_bits = 17 + n
|
|
102
|
+
return decoderSuccess
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
takeBits(br, 3, &n)
|
|
106
|
+
if n == 1 {
|
|
107
|
+
if large_window {
|
|
108
|
+
takeBits(br, 1, &n)
|
|
109
|
+
if n == 1 {
|
|
110
|
+
return decoderErrorFormatWindowBits
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
s.large_window = true
|
|
114
|
+
return decoderSuccess
|
|
115
|
+
} else {
|
|
116
|
+
return decoderErrorFormatWindowBits
|
|
117
|
+
}
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
if n != 0 {
|
|
121
|
+
s.window_bits = 8 + n
|
|
122
|
+
return decoderSuccess
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
s.window_bits = 17
|
|
126
|
+
return decoderSuccess
|
|
127
|
+
}
|
|
128
|
+
|
|
129
|
+
/* Decodes a number in the range [0..255], by reading 1 - 11 bits. */
|
|
130
|
+
func decodeVarLenUint8(s *Reader, br *bitReader, value *uint32) int {
|
|
131
|
+
var bits uint32
|
|
132
|
+
switch s.substate_decode_uint8 {
|
|
133
|
+
case stateDecodeUint8None:
|
|
134
|
+
if !safeReadBits(br, 1, &bits) {
|
|
135
|
+
return decoderNeedsMoreInput
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
if bits == 0 {
|
|
139
|
+
*value = 0
|
|
140
|
+
return decoderSuccess
|
|
141
|
+
}
|
|
142
|
+
fallthrough
|
|
143
|
+
|
|
144
|
+
/* Fall through. */
|
|
145
|
+
case stateDecodeUint8Short:
|
|
146
|
+
if !safeReadBits(br, 3, &bits) {
|
|
147
|
+
s.substate_decode_uint8 = stateDecodeUint8Short
|
|
148
|
+
return decoderNeedsMoreInput
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
if bits == 0 {
|
|
152
|
+
*value = 1
|
|
153
|
+
s.substate_decode_uint8 = stateDecodeUint8None
|
|
154
|
+
return decoderSuccess
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
/* Use output value as a temporary storage. It MUST be persisted. */
|
|
158
|
+
*value = bits
|
|
159
|
+
fallthrough
|
|
160
|
+
|
|
161
|
+
/* Fall through. */
|
|
162
|
+
case stateDecodeUint8Long:
|
|
163
|
+
if !safeReadBits(br, *value, &bits) {
|
|
164
|
+
s.substate_decode_uint8 = stateDecodeUint8Long
|
|
165
|
+
return decoderNeedsMoreInput
|
|
166
|
+
}
|
|
167
|
+
|
|
168
|
+
*value = (1 << *value) + bits
|
|
169
|
+
s.substate_decode_uint8 = stateDecodeUint8None
|
|
170
|
+
return decoderSuccess
|
|
171
|
+
|
|
172
|
+
default:
|
|
173
|
+
return decoderErrorUnreachable
|
|
174
|
+
}
|
|
175
|
+
}
|
|
176
|
+
|
|
177
|
+
/* Decodes a metablock length and flags by reading 2 - 31 bits. */
|
|
178
|
+
func decodeMetaBlockLength(s *Reader, br *bitReader) int {
|
|
179
|
+
var bits uint32
|
|
180
|
+
var i int
|
|
181
|
+
for {
|
|
182
|
+
switch s.substate_metablock_header {
|
|
183
|
+
case stateMetablockHeaderNone:
|
|
184
|
+
if !safeReadBits(br, 1, &bits) {
|
|
185
|
+
return decoderNeedsMoreInput
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
if bits != 0 {
|
|
189
|
+
s.is_last_metablock = 1
|
|
190
|
+
} else {
|
|
191
|
+
s.is_last_metablock = 0
|
|
192
|
+
}
|
|
193
|
+
s.meta_block_remaining_len = 0
|
|
194
|
+
s.is_uncompressed = 0
|
|
195
|
+
s.is_metadata = 0
|
|
196
|
+
if s.is_last_metablock == 0 {
|
|
197
|
+
s.substate_metablock_header = stateMetablockHeaderNibbles
|
|
198
|
+
break
|
|
199
|
+
}
|
|
200
|
+
|
|
201
|
+
s.substate_metablock_header = stateMetablockHeaderEmpty
|
|
202
|
+
fallthrough
|
|
203
|
+
|
|
204
|
+
/* Fall through. */
|
|
205
|
+
case stateMetablockHeaderEmpty:
|
|
206
|
+
if !safeReadBits(br, 1, &bits) {
|
|
207
|
+
return decoderNeedsMoreInput
|
|
208
|
+
}
|
|
209
|
+
|
|
210
|
+
if bits != 0 {
|
|
211
|
+
s.substate_metablock_header = stateMetablockHeaderNone
|
|
212
|
+
return decoderSuccess
|
|
213
|
+
}
|
|
214
|
+
|
|
215
|
+
s.substate_metablock_header = stateMetablockHeaderNibbles
|
|
216
|
+
fallthrough
|
|
217
|
+
|
|
218
|
+
/* Fall through. */
|
|
219
|
+
case stateMetablockHeaderNibbles:
|
|
220
|
+
if !safeReadBits(br, 2, &bits) {
|
|
221
|
+
return decoderNeedsMoreInput
|
|
222
|
+
}
|
|
223
|
+
|
|
224
|
+
s.size_nibbles = uint(byte(bits + 4))
|
|
225
|
+
s.loop_counter = 0
|
|
226
|
+
if bits == 3 {
|
|
227
|
+
s.is_metadata = 1
|
|
228
|
+
s.substate_metablock_header = stateMetablockHeaderReserved
|
|
229
|
+
break
|
|
230
|
+
}
|
|
231
|
+
|
|
232
|
+
s.substate_metablock_header = stateMetablockHeaderSize
|
|
233
|
+
fallthrough
|
|
234
|
+
|
|
235
|
+
/* Fall through. */
|
|
236
|
+
case stateMetablockHeaderSize:
|
|
237
|
+
i = s.loop_counter
|
|
238
|
+
|
|
239
|
+
for ; i < int(s.size_nibbles); i++ {
|
|
240
|
+
if !safeReadBits(br, 4, &bits) {
|
|
241
|
+
s.loop_counter = i
|
|
242
|
+
return decoderNeedsMoreInput
|
|
243
|
+
}
|
|
244
|
+
|
|
245
|
+
if uint(i+1) == s.size_nibbles && s.size_nibbles > 4 && bits == 0 {
|
|
246
|
+
return decoderErrorFormatExuberantNibble
|
|
247
|
+
}
|
|
248
|
+
|
|
249
|
+
s.meta_block_remaining_len |= int(bits << uint(i*4))
|
|
250
|
+
}
|
|
251
|
+
|
|
252
|
+
s.substate_metablock_header = stateMetablockHeaderUncompressed
|
|
253
|
+
fallthrough
|
|
254
|
+
|
|
255
|
+
/* Fall through. */
|
|
256
|
+
case stateMetablockHeaderUncompressed:
|
|
257
|
+
if s.is_last_metablock == 0 {
|
|
258
|
+
if !safeReadBits(br, 1, &bits) {
|
|
259
|
+
return decoderNeedsMoreInput
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
if bits != 0 {
|
|
263
|
+
s.is_uncompressed = 1
|
|
264
|
+
} else {
|
|
265
|
+
s.is_uncompressed = 0
|
|
266
|
+
}
|
|
267
|
+
}
|
|
268
|
+
|
|
269
|
+
s.meta_block_remaining_len++
|
|
270
|
+
s.substate_metablock_header = stateMetablockHeaderNone
|
|
271
|
+
return decoderSuccess
|
|
272
|
+
|
|
273
|
+
case stateMetablockHeaderReserved:
|
|
274
|
+
if !safeReadBits(br, 1, &bits) {
|
|
275
|
+
return decoderNeedsMoreInput
|
|
276
|
+
}
|
|
277
|
+
|
|
278
|
+
if bits != 0 {
|
|
279
|
+
return decoderErrorFormatReserved
|
|
280
|
+
}
|
|
281
|
+
|
|
282
|
+
s.substate_metablock_header = stateMetablockHeaderBytes
|
|
283
|
+
fallthrough
|
|
284
|
+
|
|
285
|
+
/* Fall through. */
|
|
286
|
+
case stateMetablockHeaderBytes:
|
|
287
|
+
if !safeReadBits(br, 2, &bits) {
|
|
288
|
+
return decoderNeedsMoreInput
|
|
289
|
+
}
|
|
290
|
+
|
|
291
|
+
if bits == 0 {
|
|
292
|
+
s.substate_metablock_header = stateMetablockHeaderNone
|
|
293
|
+
return decoderSuccess
|
|
294
|
+
}
|
|
295
|
+
|
|
296
|
+
s.size_nibbles = uint(byte(bits))
|
|
297
|
+
s.substate_metablock_header = stateMetablockHeaderMetadata
|
|
298
|
+
fallthrough
|
|
299
|
+
|
|
300
|
+
/* Fall through. */
|
|
301
|
+
case stateMetablockHeaderMetadata:
|
|
302
|
+
i = s.loop_counter
|
|
303
|
+
|
|
304
|
+
for ; i < int(s.size_nibbles); i++ {
|
|
305
|
+
if !safeReadBits(br, 8, &bits) {
|
|
306
|
+
s.loop_counter = i
|
|
307
|
+
return decoderNeedsMoreInput
|
|
308
|
+
}
|
|
309
|
+
|
|
310
|
+
if uint(i+1) == s.size_nibbles && s.size_nibbles > 1 && bits == 0 {
|
|
311
|
+
return decoderErrorFormatExuberantMetaNibble
|
|
312
|
+
}
|
|
313
|
+
|
|
314
|
+
s.meta_block_remaining_len |= int(bits << uint(i*8))
|
|
315
|
+
}
|
|
316
|
+
|
|
317
|
+
s.meta_block_remaining_len++
|
|
318
|
+
s.substate_metablock_header = stateMetablockHeaderNone
|
|
319
|
+
return decoderSuccess
|
|
320
|
+
|
|
321
|
+
default:
|
|
322
|
+
return decoderErrorUnreachable
|
|
323
|
+
}
|
|
324
|
+
}
|
|
325
|
+
}
|
|
326
|
+
|
|
327
|
+
/* Decodes the Huffman code.
|
|
328
|
+
This method doesn't read data from the bit reader, BUT drops the amount of
|
|
329
|
+
bits that correspond to the decoded symbol.
|
|
330
|
+
bits MUST contain at least 15 (BROTLI_HUFFMAN_MAX_CODE_LENGTH) valid bits. */
|
|
331
|
+
func decodeSymbol(bits uint32, table []huffmanCode, br *bitReader) uint32 {
|
|
332
|
+
table = table[bits&huffmanTableMask:]
|
|
333
|
+
if table[0].bits > huffmanTableBits {
|
|
334
|
+
var nbits uint32 = uint32(table[0].bits) - huffmanTableBits
|
|
335
|
+
dropBits(br, huffmanTableBits)
|
|
336
|
+
table = table[uint32(table[0].value)+((bits>>huffmanTableBits)&bitMask(nbits)):]
|
|
337
|
+
}
|
|
338
|
+
|
|
339
|
+
dropBits(br, uint32(table[0].bits))
|
|
340
|
+
return uint32(table[0].value)
|
|
341
|
+
}
|
|
342
|
+
|
|
343
|
+
/* Reads and decodes the next Huffman code from bit-stream.
|
|
344
|
+
This method peeks 16 bits of input and drops 0 - 15 of them. */
|
|
345
|
+
func readSymbol(table []huffmanCode, br *bitReader) uint32 {
|
|
346
|
+
return decodeSymbol(get16BitsUnmasked(br), table, br)
|
|
347
|
+
}
|
|
348
|
+
|
|
349
|
+
/* Same as DecodeSymbol, but it is known that there is less than 15 bits of
|
|
350
|
+
input are currently available. */
|
|
351
|
+
func safeDecodeSymbol(table []huffmanCode, br *bitReader, result *uint32) bool {
|
|
352
|
+
var val uint32
|
|
353
|
+
var available_bits uint32 = getAvailableBits(br)
|
|
354
|
+
if available_bits == 0 {
|
|
355
|
+
if table[0].bits == 0 {
|
|
356
|
+
*result = uint32(table[0].value)
|
|
357
|
+
return true
|
|
358
|
+
}
|
|
359
|
+
|
|
360
|
+
return false /* No valid bits at all. */
|
|
361
|
+
}
|
|
362
|
+
|
|
363
|
+
val = uint32(getBitsUnmasked(br))
|
|
364
|
+
table = table[val&huffmanTableMask:]
|
|
365
|
+
if table[0].bits <= huffmanTableBits {
|
|
366
|
+
if uint32(table[0].bits) <= available_bits {
|
|
367
|
+
dropBits(br, uint32(table[0].bits))
|
|
368
|
+
*result = uint32(table[0].value)
|
|
369
|
+
return true
|
|
370
|
+
} else {
|
|
371
|
+
return false /* Not enough bits for the first level. */
|
|
372
|
+
}
|
|
373
|
+
}
|
|
374
|
+
|
|
375
|
+
if available_bits <= huffmanTableBits {
|
|
376
|
+
return false /* Not enough bits to move to the second level. */
|
|
377
|
+
}
|
|
378
|
+
|
|
379
|
+
/* Speculatively drop HUFFMAN_TABLE_BITS. */
|
|
380
|
+
val = (val & bitMask(uint32(table[0].bits))) >> huffmanTableBits
|
|
381
|
+
|
|
382
|
+
available_bits -= huffmanTableBits
|
|
383
|
+
table = table[uint32(table[0].value)+val:]
|
|
384
|
+
if available_bits < uint32(table[0].bits) {
|
|
385
|
+
return false /* Not enough bits for the second level. */
|
|
386
|
+
}
|
|
387
|
+
|
|
388
|
+
dropBits(br, huffmanTableBits+uint32(table[0].bits))
|
|
389
|
+
*result = uint32(table[0].value)
|
|
390
|
+
return true
|
|
391
|
+
}
|
|
392
|
+
|
|
393
|
+
func safeReadSymbol(table []huffmanCode, br *bitReader, result *uint32) bool {
|
|
394
|
+
var val uint32
|
|
395
|
+
if safeGetBits(br, 15, &val) {
|
|
396
|
+
*result = decodeSymbol(val, table, br)
|
|
397
|
+
return true
|
|
398
|
+
}
|
|
399
|
+
|
|
400
|
+
return safeDecodeSymbol(table, br, result)
|
|
401
|
+
}
|
|
402
|
+
|
|
403
|
+
/* Makes a look-up in first level Huffman table. Peeks 8 bits. */
|
|
404
|
+
func preloadSymbol(safe int, table []huffmanCode, br *bitReader, bits *uint32, value *uint32) {
|
|
405
|
+
if safe != 0 {
|
|
406
|
+
return
|
|
407
|
+
}
|
|
408
|
+
|
|
409
|
+
table = table[getBits(br, huffmanTableBits):]
|
|
410
|
+
*bits = uint32(table[0].bits)
|
|
411
|
+
*value = uint32(table[0].value)
|
|
412
|
+
}
|
|
413
|
+
|
|
414
|
+
/* Decodes the next Huffman code using data prepared by PreloadSymbol.
|
|
415
|
+
Reads 0 - 15 bits. Also peeks 8 following bits. */
|
|
416
|
+
func readPreloadedSymbol(table []huffmanCode, br *bitReader, bits *uint32, value *uint32) uint32 {
|
|
417
|
+
var result uint32 = *value
|
|
418
|
+
var ext []huffmanCode
|
|
419
|
+
if *bits > huffmanTableBits {
|
|
420
|
+
var val uint32 = get16BitsUnmasked(br)
|
|
421
|
+
ext = table[val&huffmanTableMask:][*value:]
|
|
422
|
+
var mask uint32 = bitMask((*bits - huffmanTableBits))
|
|
423
|
+
dropBits(br, huffmanTableBits)
|
|
424
|
+
ext = ext[(val>>huffmanTableBits)&mask:]
|
|
425
|
+
dropBits(br, uint32(ext[0].bits))
|
|
426
|
+
result = uint32(ext[0].value)
|
|
427
|
+
} else {
|
|
428
|
+
dropBits(br, *bits)
|
|
429
|
+
}
|
|
430
|
+
|
|
431
|
+
preloadSymbol(0, table, br, bits, value)
|
|
432
|
+
return result
|
|
433
|
+
}
|
|
434
|
+
|
|
435
|
+
func log2Floor(x uint32) uint32 {
|
|
436
|
+
var result uint32 = 0
|
|
437
|
+
for x != 0 {
|
|
438
|
+
x >>= 1
|
|
439
|
+
result++
|
|
440
|
+
}
|
|
441
|
+
|
|
442
|
+
return result
|
|
443
|
+
}
|
|
444
|
+
|
|
445
|
+
/* Reads (s->symbol + 1) symbols.
|
|
446
|
+
Totally 1..4 symbols are read, 1..11 bits each.
|
|
447
|
+
The list of symbols MUST NOT contain duplicates. */
|
|
448
|
+
func readSimpleHuffmanSymbols(alphabet_size uint32, max_symbol uint32, s *Reader) int {
|
|
449
|
+
var br *bitReader = &s.br
|
|
450
|
+
var max_bits uint32 = log2Floor(alphabet_size - 1)
|
|
451
|
+
var i uint32 = s.sub_loop_counter
|
|
452
|
+
/* max_bits == 1..11; symbol == 0..3; 1..44 bits will be read. */
|
|
453
|
+
|
|
454
|
+
var num_symbols uint32 = s.symbol
|
|
455
|
+
for i <= num_symbols {
|
|
456
|
+
var v uint32
|
|
457
|
+
if !safeReadBits(br, max_bits, &v) {
|
|
458
|
+
s.sub_loop_counter = i
|
|
459
|
+
s.substate_huffman = stateHuffmanSimpleRead
|
|
460
|
+
return decoderNeedsMoreInput
|
|
461
|
+
}
|
|
462
|
+
|
|
463
|
+
if v >= max_symbol {
|
|
464
|
+
return decoderErrorFormatSimpleHuffmanAlphabet
|
|
465
|
+
}
|
|
466
|
+
|
|
467
|
+
s.symbols_lists_array[i] = uint16(v)
|
|
468
|
+
i++
|
|
469
|
+
}
|
|
470
|
+
|
|
471
|
+
for i = 0; i < num_symbols; i++ {
|
|
472
|
+
var k uint32 = i + 1
|
|
473
|
+
for ; k <= num_symbols; k++ {
|
|
474
|
+
if s.symbols_lists_array[i] == s.symbols_lists_array[k] {
|
|
475
|
+
return decoderErrorFormatSimpleHuffmanSame
|
|
476
|
+
}
|
|
477
|
+
}
|
|
478
|
+
}
|
|
479
|
+
|
|
480
|
+
return decoderSuccess
|
|
481
|
+
}
|
|
482
|
+
|
|
483
|
+
/* Process single decoded symbol code length:
|
|
484
|
+
A) reset the repeat variable
|
|
485
|
+
B) remember code length (if it is not 0)
|
|
486
|
+
C) extend corresponding index-chain
|
|
487
|
+
D) reduce the Huffman space
|
|
488
|
+
E) update the histogram */
|
|
489
|
+
func processSingleCodeLength(code_len uint32, symbol *uint32, repeat *uint32, space *uint32, prev_code_len *uint32, symbol_lists symbolList, code_length_histo []uint16, next_symbol []int) {
|
|
490
|
+
*repeat = 0
|
|
491
|
+
if code_len != 0 { /* code_len == 1..15 */
|
|
492
|
+
symbolListPut(symbol_lists, next_symbol[code_len], uint16(*symbol))
|
|
493
|
+
next_symbol[code_len] = int(*symbol)
|
|
494
|
+
*prev_code_len = code_len
|
|
495
|
+
*space -= 32768 >> code_len
|
|
496
|
+
code_length_histo[code_len]++
|
|
497
|
+
}
|
|
498
|
+
|
|
499
|
+
(*symbol)++
|
|
500
|
+
}
|
|
501
|
+
|
|
502
|
+
/* Process repeated symbol code length.
|
|
503
|
+
A) Check if it is the extension of previous repeat sequence; if the decoded
|
|
504
|
+
value is not BROTLI_REPEAT_PREVIOUS_CODE_LENGTH, then it is a new
|
|
505
|
+
symbol-skip
|
|
506
|
+
B) Update repeat variable
|
|
507
|
+
C) Check if operation is feasible (fits alphabet)
|
|
508
|
+
D) For each symbol do the same operations as in ProcessSingleCodeLength
|
|
509
|
+
|
|
510
|
+
PRECONDITION: code_len == BROTLI_REPEAT_PREVIOUS_CODE_LENGTH or
|
|
511
|
+
code_len == BROTLI_REPEAT_ZERO_CODE_LENGTH */
|
|
512
|
+
func processRepeatedCodeLength(code_len uint32, repeat_delta uint32, alphabet_size uint32, symbol *uint32, repeat *uint32, space *uint32, prev_code_len *uint32, repeat_code_len *uint32, symbol_lists symbolList, code_length_histo []uint16, next_symbol []int) {
|
|
513
|
+
var old_repeat uint32 /* for BROTLI_REPEAT_ZERO_CODE_LENGTH */ /* for BROTLI_REPEAT_ZERO_CODE_LENGTH */
|
|
514
|
+
var extra_bits uint32 = 3
|
|
515
|
+
var new_len uint32 = 0
|
|
516
|
+
if code_len == repeatPreviousCodeLength {
|
|
517
|
+
new_len = *prev_code_len
|
|
518
|
+
extra_bits = 2
|
|
519
|
+
}
|
|
520
|
+
|
|
521
|
+
if *repeat_code_len != new_len {
|
|
522
|
+
*repeat = 0
|
|
523
|
+
*repeat_code_len = new_len
|
|
524
|
+
}
|
|
525
|
+
|
|
526
|
+
old_repeat = *repeat
|
|
527
|
+
if *repeat > 0 {
|
|
528
|
+
*repeat -= 2
|
|
529
|
+
*repeat <<= extra_bits
|
|
530
|
+
}
|
|
531
|
+
|
|
532
|
+
*repeat += repeat_delta + 3
|
|
533
|
+
repeat_delta = *repeat - old_repeat
|
|
534
|
+
if *symbol+repeat_delta > alphabet_size {
|
|
535
|
+
*symbol = alphabet_size
|
|
536
|
+
*space = 0xFFFFF
|
|
537
|
+
return
|
|
538
|
+
}
|
|
539
|
+
|
|
540
|
+
if *repeat_code_len != 0 {
|
|
541
|
+
var last uint = uint(*symbol + repeat_delta)
|
|
542
|
+
var next int = next_symbol[*repeat_code_len]
|
|
543
|
+
for {
|
|
544
|
+
symbolListPut(symbol_lists, next, uint16(*symbol))
|
|
545
|
+
next = int(*symbol)
|
|
546
|
+
(*symbol)++
|
|
547
|
+
if (*symbol) == uint32(last) {
|
|
548
|
+
break
|
|
549
|
+
}
|
|
550
|
+
}
|
|
551
|
+
|
|
552
|
+
next_symbol[*repeat_code_len] = next
|
|
553
|
+
*space -= repeat_delta << (15 - *repeat_code_len)
|
|
554
|
+
code_length_histo[*repeat_code_len] = uint16(uint32(code_length_histo[*repeat_code_len]) + repeat_delta)
|
|
555
|
+
} else {
|
|
556
|
+
*symbol += repeat_delta
|
|
557
|
+
}
|
|
558
|
+
}
|
|
559
|
+
|
|
560
|
+
/* Reads and decodes symbol codelengths. */
|
|
561
|
+
func readSymbolCodeLengths(alphabet_size uint32, s *Reader) int {
|
|
562
|
+
var br *bitReader = &s.br
|
|
563
|
+
var symbol uint32 = s.symbol
|
|
564
|
+
var repeat uint32 = s.repeat
|
|
565
|
+
var space uint32 = s.space
|
|
566
|
+
var prev_code_len uint32 = s.prev_code_len
|
|
567
|
+
var repeat_code_len uint32 = s.repeat_code_len
|
|
568
|
+
var symbol_lists symbolList = s.symbol_lists
|
|
569
|
+
var code_length_histo []uint16 = s.code_length_histo[:]
|
|
570
|
+
var next_symbol []int = s.next_symbol[:]
|
|
571
|
+
if !warmupBitReader(br) {
|
|
572
|
+
return decoderNeedsMoreInput
|
|
573
|
+
}
|
|
574
|
+
var p []huffmanCode
|
|
575
|
+
for symbol < alphabet_size && space > 0 {
|
|
576
|
+
p = s.table[:]
|
|
577
|
+
var code_len uint32
|
|
578
|
+
if !checkInputAmount(br, shortFillBitWindowRead) {
|
|
579
|
+
s.symbol = symbol
|
|
580
|
+
s.repeat = repeat
|
|
581
|
+
s.prev_code_len = prev_code_len
|
|
582
|
+
s.repeat_code_len = repeat_code_len
|
|
583
|
+
s.space = space
|
|
584
|
+
return decoderNeedsMoreInput
|
|
585
|
+
}
|
|
586
|
+
|
|
587
|
+
fillBitWindow16(br)
|
|
588
|
+
p = p[getBitsUnmasked(br)&uint64(bitMask(huffmanMaxCodeLengthCodeLength)):]
|
|
589
|
+
dropBits(br, uint32(p[0].bits)) /* Use 1..5 bits. */
|
|
590
|
+
code_len = uint32(p[0].value) /* code_len == 0..17 */
|
|
591
|
+
if code_len < repeatPreviousCodeLength {
|
|
592
|
+
processSingleCodeLength(code_len, &symbol, &repeat, &space, &prev_code_len, symbol_lists, code_length_histo, next_symbol) /* code_len == 16..17, extra_bits == 2..3 */
|
|
593
|
+
} else {
|
|
594
|
+
var extra_bits uint32
|
|
595
|
+
if code_len == repeatPreviousCodeLength {
|
|
596
|
+
extra_bits = 2
|
|
597
|
+
} else {
|
|
598
|
+
extra_bits = 3
|
|
599
|
+
}
|
|
600
|
+
var repeat_delta uint32 = uint32(getBitsUnmasked(br)) & bitMask(extra_bits)
|
|
601
|
+
dropBits(br, extra_bits)
|
|
602
|
+
processRepeatedCodeLength(code_len, repeat_delta, alphabet_size, &symbol, &repeat, &space, &prev_code_len, &repeat_code_len, symbol_lists, code_length_histo, next_symbol)
|
|
603
|
+
}
|
|
604
|
+
}
|
|
605
|
+
|
|
606
|
+
s.space = space
|
|
607
|
+
return decoderSuccess
|
|
608
|
+
}
|
|
609
|
+
|
|
610
|
+
func safeReadSymbolCodeLengths(alphabet_size uint32, s *Reader) int {
|
|
611
|
+
var br *bitReader = &s.br
|
|
612
|
+
var get_byte bool = false
|
|
613
|
+
var p []huffmanCode
|
|
614
|
+
for s.symbol < alphabet_size && s.space > 0 {
|
|
615
|
+
p = s.table[:]
|
|
616
|
+
var code_len uint32
|
|
617
|
+
var available_bits uint32
|
|
618
|
+
var bits uint32 = 0
|
|
619
|
+
if get_byte && !pullByte(br) {
|
|
620
|
+
return decoderNeedsMoreInput
|
|
621
|
+
}
|
|
622
|
+
get_byte = false
|
|
623
|
+
available_bits = getAvailableBits(br)
|
|
624
|
+
if available_bits != 0 {
|
|
625
|
+
bits = uint32(getBitsUnmasked(br))
|
|
626
|
+
}
|
|
627
|
+
|
|
628
|
+
p = p[bits&bitMask(huffmanMaxCodeLengthCodeLength):]
|
|
629
|
+
if uint32(p[0].bits) > available_bits {
|
|
630
|
+
get_byte = true
|
|
631
|
+
continue
|
|
632
|
+
}
|
|
633
|
+
|
|
634
|
+
code_len = uint32(p[0].value) /* code_len == 0..17 */
|
|
635
|
+
if code_len < repeatPreviousCodeLength {
|
|
636
|
+
dropBits(br, uint32(p[0].bits))
|
|
637
|
+
processSingleCodeLength(code_len, &s.symbol, &s.repeat, &s.space, &s.prev_code_len, s.symbol_lists, s.code_length_histo[:], s.next_symbol[:]) /* code_len == 16..17, extra_bits == 2..3 */
|
|
638
|
+
} else {
|
|
639
|
+
var extra_bits uint32 = code_len - 14
|
|
640
|
+
var repeat_delta uint32 = (bits >> p[0].bits) & bitMask(extra_bits)
|
|
641
|
+
if available_bits < uint32(p[0].bits)+extra_bits {
|
|
642
|
+
get_byte = true
|
|
643
|
+
continue
|
|
644
|
+
}
|
|
645
|
+
|
|
646
|
+
dropBits(br, uint32(p[0].bits)+extra_bits)
|
|
647
|
+
processRepeatedCodeLength(code_len, repeat_delta, alphabet_size, &s.symbol, &s.repeat, &s.space, &s.prev_code_len, &s.repeat_code_len, s.symbol_lists, s.code_length_histo[:], s.next_symbol[:])
|
|
648
|
+
}
|
|
649
|
+
}
|
|
650
|
+
|
|
651
|
+
return decoderSuccess
|
|
652
|
+
}
|
|
653
|
+
|
|
654
|
+
/* Reads and decodes 15..18 codes using static prefix code.
|
|
655
|
+
Each code is 2..4 bits long. In total 30..72 bits are used. */
|
|
656
|
+
func readCodeLengthCodeLengths(s *Reader) int {
|
|
657
|
+
var br *bitReader = &s.br
|
|
658
|
+
var num_codes uint32 = s.repeat
|
|
659
|
+
var space uint32 = s.space
|
|
660
|
+
var i uint32 = s.sub_loop_counter
|
|
661
|
+
for ; i < codeLengthCodes; i++ {
|
|
662
|
+
var code_len_idx byte = kCodeLengthCodeOrder[i]
|
|
663
|
+
var ix uint32
|
|
664
|
+
var v uint32
|
|
665
|
+
if !safeGetBits(br, 4, &ix) {
|
|
666
|
+
var available_bits uint32 = getAvailableBits(br)
|
|
667
|
+
if available_bits != 0 {
|
|
668
|
+
ix = uint32(getBitsUnmasked(br) & 0xF)
|
|
669
|
+
} else {
|
|
670
|
+
ix = 0
|
|
671
|
+
}
|
|
672
|
+
|
|
673
|
+
if uint32(kCodeLengthPrefixLength[ix]) > available_bits {
|
|
674
|
+
s.sub_loop_counter = i
|
|
675
|
+
s.repeat = num_codes
|
|
676
|
+
s.space = space
|
|
677
|
+
s.substate_huffman = stateHuffmanComplex
|
|
678
|
+
return decoderNeedsMoreInput
|
|
679
|
+
}
|
|
680
|
+
}
|
|
681
|
+
|
|
682
|
+
v = uint32(kCodeLengthPrefixValue[ix])
|
|
683
|
+
dropBits(br, uint32(kCodeLengthPrefixLength[ix]))
|
|
684
|
+
s.code_length_code_lengths[code_len_idx] = byte(v)
|
|
685
|
+
if v != 0 {
|
|
686
|
+
space = space - (32 >> v)
|
|
687
|
+
num_codes++
|
|
688
|
+
s.code_length_histo[v]++
|
|
689
|
+
if space-1 >= 32 {
|
|
690
|
+
/* space is 0 or wrapped around. */
|
|
691
|
+
break
|
|
692
|
+
}
|
|
693
|
+
}
|
|
694
|
+
}
|
|
695
|
+
|
|
696
|
+
if num_codes != 1 && space != 0 {
|
|
697
|
+
return decoderErrorFormatClSpace
|
|
698
|
+
}
|
|
699
|
+
|
|
700
|
+
return decoderSuccess
|
|
701
|
+
}
|
|
702
|
+
|
|
703
|
+
/* Decodes the Huffman tables.
|
|
704
|
+
There are 2 scenarios:
|
|
705
|
+
A) Huffman code contains only few symbols (1..4). Those symbols are read
|
|
706
|
+
directly; their code lengths are defined by the number of symbols.
|
|
707
|
+
For this scenario 4 - 49 bits will be read.
|
|
708
|
+
|
|
709
|
+
B) 2-phase decoding:
|
|
710
|
+
B.1) Small Huffman table is decoded; it is specified with code lengths
|
|
711
|
+
encoded with predefined entropy code. 32 - 74 bits are used.
|
|
712
|
+
B.2) Decoded table is used to decode code lengths of symbols in resulting
|
|
713
|
+
Huffman table. In worst case 3520 bits are read. */
|
|
714
|
+
func readHuffmanCode(alphabet_size uint32, max_symbol uint32, table []huffmanCode, opt_table_size *uint32, s *Reader) int {
|
|
715
|
+
var br *bitReader = &s.br
|
|
716
|
+
|
|
717
|
+
/* Unnecessary masking, but might be good for safety. */
|
|
718
|
+
alphabet_size &= 0x7FF
|
|
719
|
+
|
|
720
|
+
/* State machine. */
|
|
721
|
+
for {
|
|
722
|
+
switch s.substate_huffman {
|
|
723
|
+
case stateHuffmanNone:
|
|
724
|
+
if !safeReadBits(br, 2, &s.sub_loop_counter) {
|
|
725
|
+
return decoderNeedsMoreInput
|
|
726
|
+
}
|
|
727
|
+
|
|
728
|
+
/* The value is used as follows:
|
|
729
|
+
1 for simple code;
|
|
730
|
+
0 for no skipping, 2 skips 2 code lengths, 3 skips 3 code lengths */
|
|
731
|
+
if s.sub_loop_counter != 1 {
|
|
732
|
+
s.space = 32
|
|
733
|
+
s.repeat = 0 /* num_codes */
|
|
734
|
+
var i int
|
|
735
|
+
for i = 0; i <= huffmanMaxCodeLengthCodeLength; i++ {
|
|
736
|
+
s.code_length_histo[i] = 0
|
|
737
|
+
}
|
|
738
|
+
|
|
739
|
+
for i = 0; i < codeLengthCodes; i++ {
|
|
740
|
+
s.code_length_code_lengths[i] = 0
|
|
741
|
+
}
|
|
742
|
+
|
|
743
|
+
s.substate_huffman = stateHuffmanComplex
|
|
744
|
+
continue
|
|
745
|
+
}
|
|
746
|
+
fallthrough
|
|
747
|
+
|
|
748
|
+
/* Read symbols, codes & code lengths directly. */
|
|
749
|
+
case stateHuffmanSimpleSize:
|
|
750
|
+
if !safeReadBits(br, 2, &s.symbol) { /* num_symbols */
|
|
751
|
+
s.substate_huffman = stateHuffmanSimpleSize
|
|
752
|
+
return decoderNeedsMoreInput
|
|
753
|
+
}
|
|
754
|
+
|
|
755
|
+
s.sub_loop_counter = 0
|
|
756
|
+
fallthrough
|
|
757
|
+
|
|
758
|
+
case stateHuffmanSimpleRead:
|
|
759
|
+
{
|
|
760
|
+
var result int = readSimpleHuffmanSymbols(alphabet_size, max_symbol, s)
|
|
761
|
+
if result != decoderSuccess {
|
|
762
|
+
return result
|
|
763
|
+
}
|
|
764
|
+
}
|
|
765
|
+
fallthrough
|
|
766
|
+
|
|
767
|
+
case stateHuffmanSimpleBuild:
|
|
768
|
+
var table_size uint32
|
|
769
|
+
if s.symbol == 3 {
|
|
770
|
+
var bits uint32
|
|
771
|
+
if !safeReadBits(br, 1, &bits) {
|
|
772
|
+
s.substate_huffman = stateHuffmanSimpleBuild
|
|
773
|
+
return decoderNeedsMoreInput
|
|
774
|
+
}
|
|
775
|
+
|
|
776
|
+
s.symbol += bits
|
|
777
|
+
}
|
|
778
|
+
|
|
779
|
+
table_size = buildSimpleHuffmanTable(table, huffmanTableBits, s.symbols_lists_array[:], s.symbol)
|
|
780
|
+
if opt_table_size != nil {
|
|
781
|
+
*opt_table_size = table_size
|
|
782
|
+
}
|
|
783
|
+
|
|
784
|
+
s.substate_huffman = stateHuffmanNone
|
|
785
|
+
return decoderSuccess
|
|
786
|
+
|
|
787
|
+
/* Decode Huffman-coded code lengths. */
|
|
788
|
+
case stateHuffmanComplex:
|
|
789
|
+
{
|
|
790
|
+
var i uint32
|
|
791
|
+
var result int = readCodeLengthCodeLengths(s)
|
|
792
|
+
if result != decoderSuccess {
|
|
793
|
+
return result
|
|
794
|
+
}
|
|
795
|
+
|
|
796
|
+
buildCodeLengthsHuffmanTable(s.table[:], s.code_length_code_lengths[:], s.code_length_histo[:])
|
|
797
|
+
for i = 0; i < 16; i++ {
|
|
798
|
+
s.code_length_histo[i] = 0
|
|
799
|
+
}
|
|
800
|
+
|
|
801
|
+
for i = 0; i <= huffmanMaxCodeLength; i++ {
|
|
802
|
+
s.next_symbol[i] = int(i) - (huffmanMaxCodeLength + 1)
|
|
803
|
+
symbolListPut(s.symbol_lists, s.next_symbol[i], 0xFFFF)
|
|
804
|
+
}
|
|
805
|
+
|
|
806
|
+
s.symbol = 0
|
|
807
|
+
s.prev_code_len = initialRepeatedCodeLength
|
|
808
|
+
s.repeat = 0
|
|
809
|
+
s.repeat_code_len = 0
|
|
810
|
+
s.space = 32768
|
|
811
|
+
s.substate_huffman = stateHuffmanLengthSymbols
|
|
812
|
+
}
|
|
813
|
+
fallthrough
|
|
814
|
+
|
|
815
|
+
case stateHuffmanLengthSymbols:
|
|
816
|
+
var table_size uint32
|
|
817
|
+
var result int = readSymbolCodeLengths(max_symbol, s)
|
|
818
|
+
if result == decoderNeedsMoreInput {
|
|
819
|
+
result = safeReadSymbolCodeLengths(max_symbol, s)
|
|
820
|
+
}
|
|
821
|
+
|
|
822
|
+
if result != decoderSuccess {
|
|
823
|
+
return result
|
|
824
|
+
}
|
|
825
|
+
|
|
826
|
+
if s.space != 0 {
|
|
827
|
+
return decoderErrorFormatHuffmanSpace
|
|
828
|
+
}
|
|
829
|
+
|
|
830
|
+
table_size = buildHuffmanTable(table, huffmanTableBits, s.symbol_lists, s.code_length_histo[:])
|
|
831
|
+
if opt_table_size != nil {
|
|
832
|
+
*opt_table_size = table_size
|
|
833
|
+
}
|
|
834
|
+
|
|
835
|
+
s.substate_huffman = stateHuffmanNone
|
|
836
|
+
return decoderSuccess
|
|
837
|
+
|
|
838
|
+
default:
|
|
839
|
+
return decoderErrorUnreachable
|
|
840
|
+
}
|
|
841
|
+
}
|
|
842
|
+
}
|
|
843
|
+
|
|
844
|
+
/* Decodes a block length by reading 3..39 bits. */
|
|
845
|
+
func readBlockLength(table []huffmanCode, br *bitReader) uint32 {
|
|
846
|
+
var code uint32
|
|
847
|
+
var nbits uint32
|
|
848
|
+
code = readSymbol(table, br)
|
|
849
|
+
nbits = kBlockLengthPrefixCode[code].nbits /* nbits == 2..24 */
|
|
850
|
+
return kBlockLengthPrefixCode[code].offset + readBits(br, nbits)
|
|
851
|
+
}
|
|
852
|
+
|
|
853
|
+
/* WARNING: if state is not BROTLI_STATE_READ_BLOCK_LENGTH_NONE, then
|
|
854
|
+
reading can't be continued with ReadBlockLength. */
|
|
855
|
+
func safeReadBlockLength(s *Reader, result *uint32, table []huffmanCode, br *bitReader) bool {
|
|
856
|
+
var index uint32
|
|
857
|
+
if s.substate_read_block_length == stateReadBlockLengthNone {
|
|
858
|
+
if !safeReadSymbol(table, br, &index) {
|
|
859
|
+
return false
|
|
860
|
+
}
|
|
861
|
+
} else {
|
|
862
|
+
index = s.block_length_index
|
|
863
|
+
}
|
|
864
|
+
{
|
|
865
|
+
var bits uint32 /* nbits == 2..24 */
|
|
866
|
+
var nbits uint32 = kBlockLengthPrefixCode[index].nbits
|
|
867
|
+
if !safeReadBits(br, nbits, &bits) {
|
|
868
|
+
s.block_length_index = index
|
|
869
|
+
s.substate_read_block_length = stateReadBlockLengthSuffix
|
|
870
|
+
return false
|
|
871
|
+
}
|
|
872
|
+
|
|
873
|
+
*result = kBlockLengthPrefixCode[index].offset + bits
|
|
874
|
+
s.substate_read_block_length = stateReadBlockLengthNone
|
|
875
|
+
return true
|
|
876
|
+
}
|
|
877
|
+
}
|
|
878
|
+
|
|
879
|
+
/* Transform:
|
|
880
|
+
1) initialize list L with values 0, 1,... 255
|
|
881
|
+
2) For each input element X:
|
|
882
|
+
2.1) let Y = L[X]
|
|
883
|
+
2.2) remove X-th element from L
|
|
884
|
+
2.3) prepend Y to L
|
|
885
|
+
2.4) append Y to output
|
|
886
|
+
|
|
887
|
+
In most cases max(Y) <= 7, so most of L remains intact.
|
|
888
|
+
To reduce the cost of initialization, we reuse L, remember the upper bound
|
|
889
|
+
of Y values, and reinitialize only first elements in L.
|
|
890
|
+
|
|
891
|
+
Most of input values are 0 and 1. To reduce number of branches, we replace
|
|
892
|
+
inner for loop with do-while. */
|
|
893
|
+
func inverseMoveToFrontTransform(v []byte, v_len uint32, state *Reader) {
|
|
894
|
+
var mtf [256]byte
|
|
895
|
+
var i int
|
|
896
|
+
for i = 1; i < 256; i++ {
|
|
897
|
+
mtf[i] = byte(i)
|
|
898
|
+
}
|
|
899
|
+
var mtf_1 byte
|
|
900
|
+
|
|
901
|
+
/* Transform the input. */
|
|
902
|
+
for i = 0; uint32(i) < v_len; i++ {
|
|
903
|
+
var index int = int(v[i])
|
|
904
|
+
var value byte = mtf[index]
|
|
905
|
+
v[i] = value
|
|
906
|
+
mtf_1 = value
|
|
907
|
+
for index >= 1 {
|
|
908
|
+
index--
|
|
909
|
+
mtf[index+1] = mtf[index]
|
|
910
|
+
}
|
|
911
|
+
|
|
912
|
+
mtf[0] = mtf_1
|
|
913
|
+
}
|
|
914
|
+
}
|
|
915
|
+
|
|
916
|
+
/* Decodes a series of Huffman table using ReadHuffmanCode function. */
|
|
917
|
+
func huffmanTreeGroupDecode(group *huffmanTreeGroup, s *Reader) int {
|
|
918
|
+
if s.substate_tree_group != stateTreeGroupLoop {
|
|
919
|
+
s.next = group.codes
|
|
920
|
+
s.htree_index = 0
|
|
921
|
+
s.substate_tree_group = stateTreeGroupLoop
|
|
922
|
+
}
|
|
923
|
+
|
|
924
|
+
for s.htree_index < int(group.num_htrees) {
|
|
925
|
+
var table_size uint32
|
|
926
|
+
var result int = readHuffmanCode(uint32(group.alphabet_size), uint32(group.max_symbol), s.next, &table_size, s)
|
|
927
|
+
if result != decoderSuccess {
|
|
928
|
+
return result
|
|
929
|
+
}
|
|
930
|
+
group.htrees[s.htree_index] = s.next
|
|
931
|
+
s.next = s.next[table_size:]
|
|
932
|
+
s.htree_index++
|
|
933
|
+
}
|
|
934
|
+
|
|
935
|
+
s.substate_tree_group = stateTreeGroupNone
|
|
936
|
+
return decoderSuccess
|
|
937
|
+
}
|
|
938
|
+
|
|
939
|
+
/* Decodes a context map.
|
|
940
|
+
Decoding is done in 4 phases:
|
|
941
|
+
1) Read auxiliary information (6..16 bits) and allocate memory.
|
|
942
|
+
In case of trivial context map, decoding is finished at this phase.
|
|
943
|
+
2) Decode Huffman table using ReadHuffmanCode function.
|
|
944
|
+
This table will be used for reading context map items.
|
|
945
|
+
3) Read context map items; "0" values could be run-length encoded.
|
|
946
|
+
4) Optionally, apply InverseMoveToFront transform to the resulting map. */
|
|
947
|
+
func decodeContextMap(context_map_size uint32, num_htrees *uint32, context_map_arg *[]byte, s *Reader) int {
|
|
948
|
+
var br *bitReader = &s.br
|
|
949
|
+
var result int = decoderSuccess
|
|
950
|
+
|
|
951
|
+
switch int(s.substate_context_map) {
|
|
952
|
+
case stateContextMapNone:
|
|
953
|
+
result = decodeVarLenUint8(s, br, num_htrees)
|
|
954
|
+
if result != decoderSuccess {
|
|
955
|
+
return result
|
|
956
|
+
}
|
|
957
|
+
|
|
958
|
+
(*num_htrees)++
|
|
959
|
+
s.context_index = 0
|
|
960
|
+
*context_map_arg = make([]byte, uint(context_map_size))
|
|
961
|
+
if *context_map_arg == nil {
|
|
962
|
+
return decoderErrorAllocContextMap
|
|
963
|
+
}
|
|
964
|
+
|
|
965
|
+
if *num_htrees <= 1 {
|
|
966
|
+
for i := 0; i < int(context_map_size); i++ {
|
|
967
|
+
(*context_map_arg)[i] = 0
|
|
968
|
+
}
|
|
969
|
+
return decoderSuccess
|
|
970
|
+
}
|
|
971
|
+
|
|
972
|
+
s.substate_context_map = stateContextMapReadPrefix
|
|
973
|
+
fallthrough
|
|
974
|
+
/* Fall through. */
|
|
975
|
+
case stateContextMapReadPrefix:
|
|
976
|
+
{
|
|
977
|
+
var bits uint32
|
|
978
|
+
|
|
979
|
+
/* In next stage ReadHuffmanCode uses at least 4 bits, so it is safe
|
|
980
|
+
to peek 4 bits ahead. */
|
|
981
|
+
if !safeGetBits(br, 5, &bits) {
|
|
982
|
+
return decoderNeedsMoreInput
|
|
983
|
+
}
|
|
984
|
+
|
|
985
|
+
if bits&1 != 0 { /* Use RLE for zeros. */
|
|
986
|
+
s.max_run_length_prefix = (bits >> 1) + 1
|
|
987
|
+
dropBits(br, 5)
|
|
988
|
+
} else {
|
|
989
|
+
s.max_run_length_prefix = 0
|
|
990
|
+
dropBits(br, 1)
|
|
991
|
+
}
|
|
992
|
+
|
|
993
|
+
s.substate_context_map = stateContextMapHuffman
|
|
994
|
+
}
|
|
995
|
+
fallthrough
|
|
996
|
+
|
|
997
|
+
/* Fall through. */
|
|
998
|
+
case stateContextMapHuffman:
|
|
999
|
+
{
|
|
1000
|
+
var alphabet_size uint32 = *num_htrees + s.max_run_length_prefix
|
|
1001
|
+
result = readHuffmanCode(alphabet_size, alphabet_size, s.context_map_table[:], nil, s)
|
|
1002
|
+
if result != decoderSuccess {
|
|
1003
|
+
return result
|
|
1004
|
+
}
|
|
1005
|
+
s.code = 0xFFFF
|
|
1006
|
+
s.substate_context_map = stateContextMapDecode
|
|
1007
|
+
}
|
|
1008
|
+
fallthrough
|
|
1009
|
+
|
|
1010
|
+
/* Fall through. */
|
|
1011
|
+
case stateContextMapDecode:
|
|
1012
|
+
{
|
|
1013
|
+
var context_index uint32 = s.context_index
|
|
1014
|
+
var max_run_length_prefix uint32 = s.max_run_length_prefix
|
|
1015
|
+
var context_map []byte = *context_map_arg
|
|
1016
|
+
var code uint32 = s.code
|
|
1017
|
+
var skip_preamble bool = (code != 0xFFFF)
|
|
1018
|
+
for context_index < context_map_size || skip_preamble {
|
|
1019
|
+
if !skip_preamble {
|
|
1020
|
+
if !safeReadSymbol(s.context_map_table[:], br, &code) {
|
|
1021
|
+
s.code = 0xFFFF
|
|
1022
|
+
s.context_index = context_index
|
|
1023
|
+
return decoderNeedsMoreInput
|
|
1024
|
+
}
|
|
1025
|
+
|
|
1026
|
+
if code == 0 {
|
|
1027
|
+
context_map[context_index] = 0
|
|
1028
|
+
context_index++
|
|
1029
|
+
continue
|
|
1030
|
+
}
|
|
1031
|
+
|
|
1032
|
+
if code > max_run_length_prefix {
|
|
1033
|
+
context_map[context_index] = byte(code - max_run_length_prefix)
|
|
1034
|
+
context_index++
|
|
1035
|
+
continue
|
|
1036
|
+
}
|
|
1037
|
+
} else {
|
|
1038
|
+
skip_preamble = false
|
|
1039
|
+
}
|
|
1040
|
+
|
|
1041
|
+
/* RLE sub-stage. */
|
|
1042
|
+
{
|
|
1043
|
+
var reps uint32
|
|
1044
|
+
if !safeReadBits(br, code, &reps) {
|
|
1045
|
+
s.code = code
|
|
1046
|
+
s.context_index = context_index
|
|
1047
|
+
return decoderNeedsMoreInput
|
|
1048
|
+
}
|
|
1049
|
+
|
|
1050
|
+
reps += 1 << code
|
|
1051
|
+
if context_index+reps > context_map_size {
|
|
1052
|
+
return decoderErrorFormatContextMapRepeat
|
|
1053
|
+
}
|
|
1054
|
+
|
|
1055
|
+
for {
|
|
1056
|
+
context_map[context_index] = 0
|
|
1057
|
+
context_index++
|
|
1058
|
+
reps--
|
|
1059
|
+
if reps == 0 {
|
|
1060
|
+
break
|
|
1061
|
+
}
|
|
1062
|
+
}
|
|
1063
|
+
}
|
|
1064
|
+
}
|
|
1065
|
+
}
|
|
1066
|
+
fallthrough
|
|
1067
|
+
|
|
1068
|
+
case stateContextMapTransform:
|
|
1069
|
+
var bits uint32
|
|
1070
|
+
if !safeReadBits(br, 1, &bits) {
|
|
1071
|
+
s.substate_context_map = stateContextMapTransform
|
|
1072
|
+
return decoderNeedsMoreInput
|
|
1073
|
+
}
|
|
1074
|
+
|
|
1075
|
+
if bits != 0 {
|
|
1076
|
+
inverseMoveToFrontTransform(*context_map_arg, context_map_size, s)
|
|
1077
|
+
}
|
|
1078
|
+
|
|
1079
|
+
s.substate_context_map = stateContextMapNone
|
|
1080
|
+
return decoderSuccess
|
|
1081
|
+
|
|
1082
|
+
default:
|
|
1083
|
+
return decoderErrorUnreachable
|
|
1084
|
+
}
|
|
1085
|
+
}
|
|
1086
|
+
|
|
1087
|
+
/* Decodes a command or literal and updates block type ring-buffer.
|
|
1088
|
+
Reads 3..54 bits. */
|
|
1089
|
+
func decodeBlockTypeAndLength(safe int, s *Reader, tree_type int) bool {
|
|
1090
|
+
var max_block_type uint32 = s.num_block_types[tree_type]
|
|
1091
|
+
type_tree := s.block_type_trees[tree_type*huffmanMaxSize258:]
|
|
1092
|
+
len_tree := s.block_len_trees[tree_type*huffmanMaxSize26:]
|
|
1093
|
+
var br *bitReader = &s.br
|
|
1094
|
+
var ringbuffer []uint32 = s.block_type_rb[tree_type*2:]
|
|
1095
|
+
var block_type uint32
|
|
1096
|
+
if max_block_type <= 1 {
|
|
1097
|
+
return false
|
|
1098
|
+
}
|
|
1099
|
+
|
|
1100
|
+
/* Read 0..15 + 3..39 bits. */
|
|
1101
|
+
if safe == 0 {
|
|
1102
|
+
block_type = readSymbol(type_tree, br)
|
|
1103
|
+
s.block_length[tree_type] = readBlockLength(len_tree, br)
|
|
1104
|
+
} else {
|
|
1105
|
+
var memento bitReaderState
|
|
1106
|
+
bitReaderSaveState(br, &memento)
|
|
1107
|
+
if !safeReadSymbol(type_tree, br, &block_type) {
|
|
1108
|
+
return false
|
|
1109
|
+
}
|
|
1110
|
+
if !safeReadBlockLength(s, &s.block_length[tree_type], len_tree, br) {
|
|
1111
|
+
s.substate_read_block_length = stateReadBlockLengthNone
|
|
1112
|
+
bitReaderRestoreState(br, &memento)
|
|
1113
|
+
return false
|
|
1114
|
+
}
|
|
1115
|
+
}
|
|
1116
|
+
|
|
1117
|
+
if block_type == 1 {
|
|
1118
|
+
block_type = ringbuffer[1] + 1
|
|
1119
|
+
} else if block_type == 0 {
|
|
1120
|
+
block_type = ringbuffer[0]
|
|
1121
|
+
} else {
|
|
1122
|
+
block_type -= 2
|
|
1123
|
+
}
|
|
1124
|
+
|
|
1125
|
+
if block_type >= max_block_type {
|
|
1126
|
+
block_type -= max_block_type
|
|
1127
|
+
}
|
|
1128
|
+
|
|
1129
|
+
ringbuffer[0] = ringbuffer[1]
|
|
1130
|
+
ringbuffer[1] = block_type
|
|
1131
|
+
return true
|
|
1132
|
+
}
|
|
1133
|
+
|
|
1134
|
+
func detectTrivialLiteralBlockTypes(s *Reader) {
|
|
1135
|
+
var i uint
|
|
1136
|
+
for i = 0; i < 8; i++ {
|
|
1137
|
+
s.trivial_literal_contexts[i] = 0
|
|
1138
|
+
}
|
|
1139
|
+
for i = 0; uint32(i) < s.num_block_types[0]; i++ {
|
|
1140
|
+
var offset uint = i << literalContextBits
|
|
1141
|
+
var error uint = 0
|
|
1142
|
+
var sample uint = uint(s.context_map[offset])
|
|
1143
|
+
var j uint
|
|
1144
|
+
for j = 0; j < 1<<literalContextBits; {
|
|
1145
|
+
var k int
|
|
1146
|
+
for k = 0; k < 4; k++ {
|
|
1147
|
+
error |= uint(s.context_map[offset+j]) ^ sample
|
|
1148
|
+
j++
|
|
1149
|
+
}
|
|
1150
|
+
}
|
|
1151
|
+
|
|
1152
|
+
if error == 0 {
|
|
1153
|
+
s.trivial_literal_contexts[i>>5] |= 1 << (i & 31)
|
|
1154
|
+
}
|
|
1155
|
+
}
|
|
1156
|
+
}
|
|
1157
|
+
|
|
1158
|
+
func prepareLiteralDecoding(s *Reader) {
|
|
1159
|
+
var context_mode byte
|
|
1160
|
+
var trivial uint
|
|
1161
|
+
var block_type uint32 = s.block_type_rb[1]
|
|
1162
|
+
var context_offset uint32 = block_type << literalContextBits
|
|
1163
|
+
s.context_map_slice = s.context_map[context_offset:]
|
|
1164
|
+
trivial = uint(s.trivial_literal_contexts[block_type>>5])
|
|
1165
|
+
s.trivial_literal_context = int((trivial >> (block_type & 31)) & 1)
|
|
1166
|
+
s.literal_htree = []huffmanCode(s.literal_hgroup.htrees[s.context_map_slice[0]])
|
|
1167
|
+
context_mode = s.context_modes[block_type] & 3
|
|
1168
|
+
s.context_lookup = getContextLUT(int(context_mode))
|
|
1169
|
+
}
|
|
1170
|
+
|
|
1171
|
+
/* Decodes the block type and updates the state for literal context.
|
|
1172
|
+
Reads 3..54 bits. */
|
|
1173
|
+
func decodeLiteralBlockSwitchInternal(safe int, s *Reader) bool {
|
|
1174
|
+
if !decodeBlockTypeAndLength(safe, s, 0) {
|
|
1175
|
+
return false
|
|
1176
|
+
}
|
|
1177
|
+
|
|
1178
|
+
prepareLiteralDecoding(s)
|
|
1179
|
+
return true
|
|
1180
|
+
}
|
|
1181
|
+
|
|
1182
|
+
func decodeLiteralBlockSwitch(s *Reader) {
|
|
1183
|
+
decodeLiteralBlockSwitchInternal(0, s)
|
|
1184
|
+
}
|
|
1185
|
+
|
|
1186
|
+
func safeDecodeLiteralBlockSwitch(s *Reader) bool {
|
|
1187
|
+
return decodeLiteralBlockSwitchInternal(1, s)
|
|
1188
|
+
}
|
|
1189
|
+
|
|
1190
|
+
/* Block switch for insert/copy length.
|
|
1191
|
+
Reads 3..54 bits. */
|
|
1192
|
+
func decodeCommandBlockSwitchInternal(safe int, s *Reader) bool {
|
|
1193
|
+
if !decodeBlockTypeAndLength(safe, s, 1) {
|
|
1194
|
+
return false
|
|
1195
|
+
}
|
|
1196
|
+
|
|
1197
|
+
s.htree_command = []huffmanCode(s.insert_copy_hgroup.htrees[s.block_type_rb[3]])
|
|
1198
|
+
return true
|
|
1199
|
+
}
|
|
1200
|
+
|
|
1201
|
+
func decodeCommandBlockSwitch(s *Reader) {
|
|
1202
|
+
decodeCommandBlockSwitchInternal(0, s)
|
|
1203
|
+
}
|
|
1204
|
+
|
|
1205
|
+
func safeDecodeCommandBlockSwitch(s *Reader) bool {
|
|
1206
|
+
return decodeCommandBlockSwitchInternal(1, s)
|
|
1207
|
+
}
|
|
1208
|
+
|
|
1209
|
+
/* Block switch for distance codes.
|
|
1210
|
+
Reads 3..54 bits. */
|
|
1211
|
+
func decodeDistanceBlockSwitchInternal(safe int, s *Reader) bool {
|
|
1212
|
+
if !decodeBlockTypeAndLength(safe, s, 2) {
|
|
1213
|
+
return false
|
|
1214
|
+
}
|
|
1215
|
+
|
|
1216
|
+
s.dist_context_map_slice = s.dist_context_map[s.block_type_rb[5]<<distanceContextBits:]
|
|
1217
|
+
s.dist_htree_index = s.dist_context_map_slice[s.distance_context]
|
|
1218
|
+
return true
|
|
1219
|
+
}
|
|
1220
|
+
|
|
1221
|
+
func decodeDistanceBlockSwitch(s *Reader) {
|
|
1222
|
+
decodeDistanceBlockSwitchInternal(0, s)
|
|
1223
|
+
}
|
|
1224
|
+
|
|
1225
|
+
func safeDecodeDistanceBlockSwitch(s *Reader) bool {
|
|
1226
|
+
return decodeDistanceBlockSwitchInternal(1, s)
|
|
1227
|
+
}
|
|
1228
|
+
|
|
1229
|
+
func unwrittenBytes(s *Reader, wrap bool) uint {
|
|
1230
|
+
var pos uint
|
|
1231
|
+
if wrap && s.pos > s.ringbuffer_size {
|
|
1232
|
+
pos = uint(s.ringbuffer_size)
|
|
1233
|
+
} else {
|
|
1234
|
+
pos = uint(s.pos)
|
|
1235
|
+
}
|
|
1236
|
+
var partial_pos_rb uint = (s.rb_roundtrips * uint(s.ringbuffer_size)) + pos
|
|
1237
|
+
return partial_pos_rb - s.partial_pos_out
|
|
1238
|
+
}
|
|
1239
|
+
|
|
1240
|
+
/* Dumps output.
|
|
1241
|
+
Returns BROTLI_DECODER_NEEDS_MORE_OUTPUT only if there is more output to push
|
|
1242
|
+
and either ring-buffer is as big as window size, or |force| is true. */
|
|
1243
|
+
func writeRingBuffer(s *Reader, available_out *uint, next_out *[]byte, total_out *uint, force bool) int {
|
|
1244
|
+
start := s.ringbuffer[s.partial_pos_out&uint(s.ringbuffer_mask):]
|
|
1245
|
+
var to_write uint = unwrittenBytes(s, true)
|
|
1246
|
+
var num_written uint = *available_out
|
|
1247
|
+
if num_written > to_write {
|
|
1248
|
+
num_written = to_write
|
|
1249
|
+
}
|
|
1250
|
+
|
|
1251
|
+
if s.meta_block_remaining_len < 0 {
|
|
1252
|
+
return decoderErrorFormatBlockLength1
|
|
1253
|
+
}
|
|
1254
|
+
|
|
1255
|
+
if next_out != nil && *next_out == nil {
|
|
1256
|
+
*next_out = start
|
|
1257
|
+
} else {
|
|
1258
|
+
if next_out != nil {
|
|
1259
|
+
copy(*next_out, start[:num_written])
|
|
1260
|
+
*next_out = (*next_out)[num_written:]
|
|
1261
|
+
}
|
|
1262
|
+
}
|
|
1263
|
+
|
|
1264
|
+
*available_out -= num_written
|
|
1265
|
+
s.partial_pos_out += num_written
|
|
1266
|
+
if total_out != nil {
|
|
1267
|
+
*total_out = s.partial_pos_out
|
|
1268
|
+
}
|
|
1269
|
+
|
|
1270
|
+
if num_written < to_write {
|
|
1271
|
+
if s.ringbuffer_size == 1<<s.window_bits || force {
|
|
1272
|
+
return decoderNeedsMoreOutput
|
|
1273
|
+
} else {
|
|
1274
|
+
return decoderSuccess
|
|
1275
|
+
}
|
|
1276
|
+
}
|
|
1277
|
+
|
|
1278
|
+
/* Wrap ring buffer only if it has reached its maximal size. */
|
|
1279
|
+
if s.ringbuffer_size == 1<<s.window_bits && s.pos >= s.ringbuffer_size {
|
|
1280
|
+
s.pos -= s.ringbuffer_size
|
|
1281
|
+
s.rb_roundtrips++
|
|
1282
|
+
if uint(s.pos) != 0 {
|
|
1283
|
+
s.should_wrap_ringbuffer = 1
|
|
1284
|
+
} else {
|
|
1285
|
+
s.should_wrap_ringbuffer = 0
|
|
1286
|
+
}
|
|
1287
|
+
}
|
|
1288
|
+
|
|
1289
|
+
return decoderSuccess
|
|
1290
|
+
}
|
|
1291
|
+
|
|
1292
|
+
func wrapRingBuffer(s *Reader) {
|
|
1293
|
+
if s.should_wrap_ringbuffer != 0 {
|
|
1294
|
+
copy(s.ringbuffer, s.ringbuffer_end[:uint(s.pos)])
|
|
1295
|
+
s.should_wrap_ringbuffer = 0
|
|
1296
|
+
}
|
|
1297
|
+
}
|
|
1298
|
+
|
|
1299
|
+
/* Allocates ring-buffer.
|
|
1300
|
+
|
|
1301
|
+
s->ringbuffer_size MUST be updated by BrotliCalculateRingBufferSize before
|
|
1302
|
+
this function is called.
|
|
1303
|
+
|
|
1304
|
+
Last two bytes of ring-buffer are initialized to 0, so context calculation
|
|
1305
|
+
could be done uniformly for the first two and all other positions. */
|
|
1306
|
+
func ensureRingBuffer(s *Reader) bool {
|
|
1307
|
+
var old_ringbuffer []byte
|
|
1308
|
+
if s.ringbuffer_size == s.new_ringbuffer_size {
|
|
1309
|
+
return true
|
|
1310
|
+
}
|
|
1311
|
+
spaceNeeded := int(s.new_ringbuffer_size) + int(kRingBufferWriteAheadSlack)
|
|
1312
|
+
if len(s.ringbuffer) < spaceNeeded {
|
|
1313
|
+
old_ringbuffer = s.ringbuffer
|
|
1314
|
+
s.ringbuffer = make([]byte, spaceNeeded)
|
|
1315
|
+
}
|
|
1316
|
+
|
|
1317
|
+
s.ringbuffer[s.new_ringbuffer_size-2] = 0
|
|
1318
|
+
s.ringbuffer[s.new_ringbuffer_size-1] = 0
|
|
1319
|
+
|
|
1320
|
+
if old_ringbuffer != nil {
|
|
1321
|
+
copy(s.ringbuffer, old_ringbuffer[:uint(s.pos)])
|
|
1322
|
+
}
|
|
1323
|
+
|
|
1324
|
+
s.ringbuffer_size = s.new_ringbuffer_size
|
|
1325
|
+
s.ringbuffer_mask = s.new_ringbuffer_size - 1
|
|
1326
|
+
s.ringbuffer_end = s.ringbuffer[s.ringbuffer_size:]
|
|
1327
|
+
|
|
1328
|
+
return true
|
|
1329
|
+
}
|
|
1330
|
+
|
|
1331
|
+
func copyUncompressedBlockToOutput(available_out *uint, next_out *[]byte, total_out *uint, s *Reader) int {
|
|
1332
|
+
/* TODO: avoid allocation for single uncompressed block. */
|
|
1333
|
+
if !ensureRingBuffer(s) {
|
|
1334
|
+
return decoderErrorAllocRingBuffer1
|
|
1335
|
+
}
|
|
1336
|
+
|
|
1337
|
+
/* State machine */
|
|
1338
|
+
for {
|
|
1339
|
+
switch s.substate_uncompressed {
|
|
1340
|
+
case stateUncompressedNone:
|
|
1341
|
+
{
|
|
1342
|
+
var nbytes int = int(getRemainingBytes(&s.br))
|
|
1343
|
+
if nbytes > s.meta_block_remaining_len {
|
|
1344
|
+
nbytes = s.meta_block_remaining_len
|
|
1345
|
+
}
|
|
1346
|
+
|
|
1347
|
+
if s.pos+nbytes > s.ringbuffer_size {
|
|
1348
|
+
nbytes = s.ringbuffer_size - s.pos
|
|
1349
|
+
}
|
|
1350
|
+
|
|
1351
|
+
/* Copy remaining bytes from s->br.buf_ to ring-buffer. */
|
|
1352
|
+
copyBytes(s.ringbuffer[s.pos:], &s.br, uint(nbytes))
|
|
1353
|
+
|
|
1354
|
+
s.pos += nbytes
|
|
1355
|
+
s.meta_block_remaining_len -= nbytes
|
|
1356
|
+
if s.pos < 1<<s.window_bits {
|
|
1357
|
+
if s.meta_block_remaining_len == 0 {
|
|
1358
|
+
return decoderSuccess
|
|
1359
|
+
}
|
|
1360
|
+
|
|
1361
|
+
return decoderNeedsMoreInput
|
|
1362
|
+
}
|
|
1363
|
+
|
|
1364
|
+
s.substate_uncompressed = stateUncompressedWrite
|
|
1365
|
+
}
|
|
1366
|
+
fallthrough
|
|
1367
|
+
|
|
1368
|
+
case stateUncompressedWrite:
|
|
1369
|
+
{
|
|
1370
|
+
result := writeRingBuffer(s, available_out, next_out, total_out, false)
|
|
1371
|
+
if result != decoderSuccess {
|
|
1372
|
+
return result
|
|
1373
|
+
}
|
|
1374
|
+
|
|
1375
|
+
if s.ringbuffer_size == 1<<s.window_bits {
|
|
1376
|
+
s.max_distance = s.max_backward_distance
|
|
1377
|
+
}
|
|
1378
|
+
|
|
1379
|
+
s.substate_uncompressed = stateUncompressedNone
|
|
1380
|
+
break
|
|
1381
|
+
}
|
|
1382
|
+
}
|
|
1383
|
+
}
|
|
1384
|
+
}
|
|
1385
|
+
|
|
1386
|
+
/* Calculates the smallest feasible ring buffer.
|
|
1387
|
+
|
|
1388
|
+
If we know the data size is small, do not allocate more ring buffer
|
|
1389
|
+
size than needed to reduce memory usage.
|
|
1390
|
+
|
|
1391
|
+
When this method is called, metablock size and flags MUST be decoded. */
|
|
1392
|
+
func calculateRingBufferSize(s *Reader) {
|
|
1393
|
+
var window_size int = 1 << s.window_bits
|
|
1394
|
+
var new_ringbuffer_size int = window_size
|
|
1395
|
+
var min_size int
|
|
1396
|
+
/* We need at least 2 bytes of ring buffer size to get the last two
|
|
1397
|
+
bytes for context from there */
|
|
1398
|
+
if s.ringbuffer_size != 0 {
|
|
1399
|
+
min_size = s.ringbuffer_size
|
|
1400
|
+
} else {
|
|
1401
|
+
min_size = 1024
|
|
1402
|
+
}
|
|
1403
|
+
var output_size int
|
|
1404
|
+
|
|
1405
|
+
/* If maximum is already reached, no further extension is retired. */
|
|
1406
|
+
if s.ringbuffer_size == window_size {
|
|
1407
|
+
return
|
|
1408
|
+
}
|
|
1409
|
+
|
|
1410
|
+
/* Metadata blocks does not touch ring buffer. */
|
|
1411
|
+
if s.is_metadata != 0 {
|
|
1412
|
+
return
|
|
1413
|
+
}
|
|
1414
|
+
|
|
1415
|
+
if s.ringbuffer == nil {
|
|
1416
|
+
output_size = 0
|
|
1417
|
+
} else {
|
|
1418
|
+
output_size = s.pos
|
|
1419
|
+
}
|
|
1420
|
+
|
|
1421
|
+
output_size += s.meta_block_remaining_len
|
|
1422
|
+
if min_size < output_size {
|
|
1423
|
+
min_size = output_size
|
|
1424
|
+
}
|
|
1425
|
+
|
|
1426
|
+
if !(s.canny_ringbuffer_allocation == 0) {
|
|
1427
|
+
/* Reduce ring buffer size to save memory when server is unscrupulous.
|
|
1428
|
+
In worst case memory usage might be 1.5x bigger for a short period of
|
|
1429
|
+
ring buffer reallocation. */
|
|
1430
|
+
for new_ringbuffer_size>>1 >= min_size {
|
|
1431
|
+
new_ringbuffer_size >>= 1
|
|
1432
|
+
}
|
|
1433
|
+
}
|
|
1434
|
+
|
|
1435
|
+
s.new_ringbuffer_size = new_ringbuffer_size
|
|
1436
|
+
}
|
|
1437
|
+
|
|
1438
|
+
/* Reads 1..256 2-bit context modes. */
|
|
1439
|
+
func readContextModes(s *Reader) int {
|
|
1440
|
+
var br *bitReader = &s.br
|
|
1441
|
+
var i int = s.loop_counter
|
|
1442
|
+
|
|
1443
|
+
for i < int(s.num_block_types[0]) {
|
|
1444
|
+
var bits uint32
|
|
1445
|
+
if !safeReadBits(br, 2, &bits) {
|
|
1446
|
+
s.loop_counter = i
|
|
1447
|
+
return decoderNeedsMoreInput
|
|
1448
|
+
}
|
|
1449
|
+
|
|
1450
|
+
s.context_modes[i] = byte(bits)
|
|
1451
|
+
i++
|
|
1452
|
+
}
|
|
1453
|
+
|
|
1454
|
+
return decoderSuccess
|
|
1455
|
+
}
|
|
1456
|
+
|
|
1457
|
+
func takeDistanceFromRingBuffer(s *Reader) {
|
|
1458
|
+
if s.distance_code == 0 {
|
|
1459
|
+
s.dist_rb_idx--
|
|
1460
|
+
s.distance_code = s.dist_rb[s.dist_rb_idx&3]
|
|
1461
|
+
|
|
1462
|
+
/* Compensate double distance-ring-buffer roll for dictionary items. */
|
|
1463
|
+
s.distance_context = 1
|
|
1464
|
+
} else {
|
|
1465
|
+
var distance_code int = s.distance_code << 1
|
|
1466
|
+
const kDistanceShortCodeIndexOffset uint32 = 0xAAAFFF1B
|
|
1467
|
+
const kDistanceShortCodeValueOffset uint32 = 0xFA5FA500
|
|
1468
|
+
var v int = (s.dist_rb_idx + int(kDistanceShortCodeIndexOffset>>uint(distance_code))) & 0x3
|
|
1469
|
+
/* kDistanceShortCodeIndexOffset has 2-bit values from LSB:
|
|
1470
|
+
3, 2, 1, 0, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2 */
|
|
1471
|
+
|
|
1472
|
+
/* kDistanceShortCodeValueOffset has 2-bit values from LSB:
|
|
1473
|
+
-0, 0,-0, 0,-1, 1,-2, 2,-3, 3,-1, 1,-2, 2,-3, 3 */
|
|
1474
|
+
s.distance_code = s.dist_rb[v]
|
|
1475
|
+
|
|
1476
|
+
v = int(kDistanceShortCodeValueOffset>>uint(distance_code)) & 0x3
|
|
1477
|
+
if distance_code&0x3 != 0 {
|
|
1478
|
+
s.distance_code += v
|
|
1479
|
+
} else {
|
|
1480
|
+
s.distance_code -= v
|
|
1481
|
+
if s.distance_code <= 0 {
|
|
1482
|
+
/* A huge distance will cause a () soon.
|
|
1483
|
+
This is a little faster than failing here. */
|
|
1484
|
+
s.distance_code = 0x7FFFFFFF
|
|
1485
|
+
}
|
|
1486
|
+
}
|
|
1487
|
+
}
|
|
1488
|
+
}
|
|
1489
|
+
|
|
1490
|
+
func safeReadBitsMaybeZero(br *bitReader, n_bits uint32, val *uint32) bool {
|
|
1491
|
+
if n_bits != 0 {
|
|
1492
|
+
return safeReadBits(br, n_bits, val)
|
|
1493
|
+
} else {
|
|
1494
|
+
*val = 0
|
|
1495
|
+
return true
|
|
1496
|
+
}
|
|
1497
|
+
}
|
|
1498
|
+
|
|
1499
|
+
/* Precondition: s->distance_code < 0. */
|
|
1500
|
+
func readDistanceInternal(safe int, s *Reader, br *bitReader) bool {
|
|
1501
|
+
var distval int
|
|
1502
|
+
var memento bitReaderState
|
|
1503
|
+
var distance_tree []huffmanCode = []huffmanCode(s.distance_hgroup.htrees[s.dist_htree_index])
|
|
1504
|
+
if safe == 0 {
|
|
1505
|
+
s.distance_code = int(readSymbol(distance_tree, br))
|
|
1506
|
+
} else {
|
|
1507
|
+
var code uint32
|
|
1508
|
+
bitReaderSaveState(br, &memento)
|
|
1509
|
+
if !safeReadSymbol(distance_tree, br, &code) {
|
|
1510
|
+
return false
|
|
1511
|
+
}
|
|
1512
|
+
|
|
1513
|
+
s.distance_code = int(code)
|
|
1514
|
+
}
|
|
1515
|
+
|
|
1516
|
+
/* Convert the distance code to the actual distance by possibly
|
|
1517
|
+
looking up past distances from the s->ringbuffer. */
|
|
1518
|
+
s.distance_context = 0
|
|
1519
|
+
|
|
1520
|
+
if s.distance_code&^0xF == 0 {
|
|
1521
|
+
takeDistanceFromRingBuffer(s)
|
|
1522
|
+
s.block_length[2]--
|
|
1523
|
+
return true
|
|
1524
|
+
}
|
|
1525
|
+
|
|
1526
|
+
distval = s.distance_code - int(s.num_direct_distance_codes)
|
|
1527
|
+
if distval >= 0 {
|
|
1528
|
+
var nbits uint32
|
|
1529
|
+
var postfix int
|
|
1530
|
+
var offset int
|
|
1531
|
+
if safe == 0 && (s.distance_postfix_bits == 0) {
|
|
1532
|
+
nbits = (uint32(distval) >> 1) + 1
|
|
1533
|
+
offset = ((2 + (distval & 1)) << nbits) - 4
|
|
1534
|
+
s.distance_code = int(s.num_direct_distance_codes) + offset + int(readBits(br, nbits))
|
|
1535
|
+
} else {
|
|
1536
|
+
/* This branch also works well when s->distance_postfix_bits == 0. */
|
|
1537
|
+
var bits uint32
|
|
1538
|
+
postfix = distval & s.distance_postfix_mask
|
|
1539
|
+
distval >>= s.distance_postfix_bits
|
|
1540
|
+
nbits = (uint32(distval) >> 1) + 1
|
|
1541
|
+
if safe != 0 {
|
|
1542
|
+
if !safeReadBitsMaybeZero(br, nbits, &bits) {
|
|
1543
|
+
s.distance_code = -1 /* Restore precondition. */
|
|
1544
|
+
bitReaderRestoreState(br, &memento)
|
|
1545
|
+
return false
|
|
1546
|
+
}
|
|
1547
|
+
} else {
|
|
1548
|
+
bits = readBits(br, nbits)
|
|
1549
|
+
}
|
|
1550
|
+
|
|
1551
|
+
offset = ((2 + (distval & 1)) << nbits) - 4
|
|
1552
|
+
s.distance_code = int(s.num_direct_distance_codes) + ((offset + int(bits)) << s.distance_postfix_bits) + postfix
|
|
1553
|
+
}
|
|
1554
|
+
}
|
|
1555
|
+
|
|
1556
|
+
s.distance_code = s.distance_code - numDistanceShortCodes + 1
|
|
1557
|
+
s.block_length[2]--
|
|
1558
|
+
return true
|
|
1559
|
+
}
|
|
1560
|
+
|
|
1561
|
+
func readDistance(s *Reader, br *bitReader) {
|
|
1562
|
+
readDistanceInternal(0, s, br)
|
|
1563
|
+
}
|
|
1564
|
+
|
|
1565
|
+
func safeReadDistance(s *Reader, br *bitReader) bool {
|
|
1566
|
+
return readDistanceInternal(1, s, br)
|
|
1567
|
+
}
|
|
1568
|
+
|
|
1569
|
+
func readCommandInternal(safe int, s *Reader, br *bitReader, insert_length *int) bool {
|
|
1570
|
+
var cmd_code uint32
|
|
1571
|
+
var insert_len_extra uint32 = 0
|
|
1572
|
+
var copy_length uint32
|
|
1573
|
+
var v cmdLutElement
|
|
1574
|
+
var memento bitReaderState
|
|
1575
|
+
if safe == 0 {
|
|
1576
|
+
cmd_code = readSymbol(s.htree_command, br)
|
|
1577
|
+
} else {
|
|
1578
|
+
bitReaderSaveState(br, &memento)
|
|
1579
|
+
if !safeReadSymbol(s.htree_command, br, &cmd_code) {
|
|
1580
|
+
return false
|
|
1581
|
+
}
|
|
1582
|
+
}
|
|
1583
|
+
|
|
1584
|
+
v = kCmdLut[cmd_code]
|
|
1585
|
+
s.distance_code = int(v.distance_code)
|
|
1586
|
+
s.distance_context = int(v.context)
|
|
1587
|
+
s.dist_htree_index = s.dist_context_map_slice[s.distance_context]
|
|
1588
|
+
*insert_length = int(v.insert_len_offset)
|
|
1589
|
+
if safe == 0 {
|
|
1590
|
+
if v.insert_len_extra_bits != 0 {
|
|
1591
|
+
insert_len_extra = readBits(br, uint32(v.insert_len_extra_bits))
|
|
1592
|
+
}
|
|
1593
|
+
|
|
1594
|
+
copy_length = readBits(br, uint32(v.copy_len_extra_bits))
|
|
1595
|
+
} else {
|
|
1596
|
+
if !safeReadBitsMaybeZero(br, uint32(v.insert_len_extra_bits), &insert_len_extra) || !safeReadBitsMaybeZero(br, uint32(v.copy_len_extra_bits), ©_length) {
|
|
1597
|
+
bitReaderRestoreState(br, &memento)
|
|
1598
|
+
return false
|
|
1599
|
+
}
|
|
1600
|
+
}
|
|
1601
|
+
|
|
1602
|
+
s.copy_length = int(copy_length) + int(v.copy_len_offset)
|
|
1603
|
+
s.block_length[1]--
|
|
1604
|
+
*insert_length += int(insert_len_extra)
|
|
1605
|
+
return true
|
|
1606
|
+
}
|
|
1607
|
+
|
|
1608
|
+
func readCommand(s *Reader, br *bitReader, insert_length *int) {
|
|
1609
|
+
readCommandInternal(0, s, br, insert_length)
|
|
1610
|
+
}
|
|
1611
|
+
|
|
1612
|
+
func safeReadCommand(s *Reader, br *bitReader, insert_length *int) bool {
|
|
1613
|
+
return readCommandInternal(1, s, br, insert_length)
|
|
1614
|
+
}
|
|
1615
|
+
|
|
1616
|
+
func checkInputAmountMaybeSafe(safe int, br *bitReader, num uint) bool {
|
|
1617
|
+
if safe != 0 {
|
|
1618
|
+
return true
|
|
1619
|
+
}
|
|
1620
|
+
|
|
1621
|
+
return checkInputAmount(br, num)
|
|
1622
|
+
}
|
|
1623
|
+
|
|
1624
|
+
func processCommandsInternal(safe int, s *Reader) int {
|
|
1625
|
+
var pos int = s.pos
|
|
1626
|
+
var i int = s.loop_counter
|
|
1627
|
+
var result int = decoderSuccess
|
|
1628
|
+
var br *bitReader = &s.br
|
|
1629
|
+
var hc []huffmanCode
|
|
1630
|
+
|
|
1631
|
+
if !checkInputAmountMaybeSafe(safe, br, 28) {
|
|
1632
|
+
result = decoderNeedsMoreInput
|
|
1633
|
+
goto saveStateAndReturn
|
|
1634
|
+
}
|
|
1635
|
+
|
|
1636
|
+
if safe == 0 {
|
|
1637
|
+
warmupBitReader(br)
|
|
1638
|
+
}
|
|
1639
|
+
|
|
1640
|
+
/* Jump into state machine. */
|
|
1641
|
+
if s.state == stateCommandBegin {
|
|
1642
|
+
goto CommandBegin
|
|
1643
|
+
} else if s.state == stateCommandInner {
|
|
1644
|
+
goto CommandInner
|
|
1645
|
+
} else if s.state == stateCommandPostDecodeLiterals {
|
|
1646
|
+
goto CommandPostDecodeLiterals
|
|
1647
|
+
} else if s.state == stateCommandPostWrapCopy {
|
|
1648
|
+
goto CommandPostWrapCopy
|
|
1649
|
+
} else {
|
|
1650
|
+
return decoderErrorUnreachable
|
|
1651
|
+
}
|
|
1652
|
+
|
|
1653
|
+
CommandBegin:
|
|
1654
|
+
if safe != 0 {
|
|
1655
|
+
s.state = stateCommandBegin
|
|
1656
|
+
}
|
|
1657
|
+
|
|
1658
|
+
if !checkInputAmountMaybeSafe(safe, br, 28) { /* 156 bits + 7 bytes */
|
|
1659
|
+
s.state = stateCommandBegin
|
|
1660
|
+
result = decoderNeedsMoreInput
|
|
1661
|
+
goto saveStateAndReturn
|
|
1662
|
+
}
|
|
1663
|
+
|
|
1664
|
+
if s.block_length[1] == 0 {
|
|
1665
|
+
if safe != 0 {
|
|
1666
|
+
if !safeDecodeCommandBlockSwitch(s) {
|
|
1667
|
+
result = decoderNeedsMoreInput
|
|
1668
|
+
goto saveStateAndReturn
|
|
1669
|
+
}
|
|
1670
|
+
} else {
|
|
1671
|
+
decodeCommandBlockSwitch(s)
|
|
1672
|
+
}
|
|
1673
|
+
|
|
1674
|
+
goto CommandBegin
|
|
1675
|
+
}
|
|
1676
|
+
|
|
1677
|
+
/* Read the insert/copy length in the command. */
|
|
1678
|
+
if safe != 0 {
|
|
1679
|
+
if !safeReadCommand(s, br, &i) {
|
|
1680
|
+
result = decoderNeedsMoreInput
|
|
1681
|
+
goto saveStateAndReturn
|
|
1682
|
+
}
|
|
1683
|
+
} else {
|
|
1684
|
+
readCommand(s, br, &i)
|
|
1685
|
+
}
|
|
1686
|
+
|
|
1687
|
+
if i == 0 {
|
|
1688
|
+
goto CommandPostDecodeLiterals
|
|
1689
|
+
}
|
|
1690
|
+
|
|
1691
|
+
s.meta_block_remaining_len -= i
|
|
1692
|
+
|
|
1693
|
+
CommandInner:
|
|
1694
|
+
if safe != 0 {
|
|
1695
|
+
s.state = stateCommandInner
|
|
1696
|
+
}
|
|
1697
|
+
|
|
1698
|
+
/* Read the literals in the command. */
|
|
1699
|
+
if s.trivial_literal_context != 0 {
|
|
1700
|
+
var bits uint32
|
|
1701
|
+
var value uint32
|
|
1702
|
+
preloadSymbol(safe, s.literal_htree, br, &bits, &value)
|
|
1703
|
+
for {
|
|
1704
|
+
if !checkInputAmountMaybeSafe(safe, br, 28) { /* 162 bits + 7 bytes */
|
|
1705
|
+
s.state = stateCommandInner
|
|
1706
|
+
result = decoderNeedsMoreInput
|
|
1707
|
+
goto saveStateAndReturn
|
|
1708
|
+
}
|
|
1709
|
+
|
|
1710
|
+
if s.block_length[0] == 0 {
|
|
1711
|
+
if safe != 0 {
|
|
1712
|
+
if !safeDecodeLiteralBlockSwitch(s) {
|
|
1713
|
+
result = decoderNeedsMoreInput
|
|
1714
|
+
goto saveStateAndReturn
|
|
1715
|
+
}
|
|
1716
|
+
} else {
|
|
1717
|
+
decodeLiteralBlockSwitch(s)
|
|
1718
|
+
}
|
|
1719
|
+
|
|
1720
|
+
preloadSymbol(safe, s.literal_htree, br, &bits, &value)
|
|
1721
|
+
if s.trivial_literal_context == 0 {
|
|
1722
|
+
goto CommandInner
|
|
1723
|
+
}
|
|
1724
|
+
}
|
|
1725
|
+
|
|
1726
|
+
if safe == 0 {
|
|
1727
|
+
s.ringbuffer[pos] = byte(readPreloadedSymbol(s.literal_htree, br, &bits, &value))
|
|
1728
|
+
} else {
|
|
1729
|
+
var literal uint32
|
|
1730
|
+
if !safeReadSymbol(s.literal_htree, br, &literal) {
|
|
1731
|
+
result = decoderNeedsMoreInput
|
|
1732
|
+
goto saveStateAndReturn
|
|
1733
|
+
}
|
|
1734
|
+
|
|
1735
|
+
s.ringbuffer[pos] = byte(literal)
|
|
1736
|
+
}
|
|
1737
|
+
|
|
1738
|
+
s.block_length[0]--
|
|
1739
|
+
pos++
|
|
1740
|
+
if pos == s.ringbuffer_size {
|
|
1741
|
+
s.state = stateCommandInnerWrite
|
|
1742
|
+
i--
|
|
1743
|
+
goto saveStateAndReturn
|
|
1744
|
+
}
|
|
1745
|
+
i--
|
|
1746
|
+
if i == 0 {
|
|
1747
|
+
break
|
|
1748
|
+
}
|
|
1749
|
+
}
|
|
1750
|
+
} else {
|
|
1751
|
+
var p1 byte = s.ringbuffer[(pos-1)&s.ringbuffer_mask]
|
|
1752
|
+
var p2 byte = s.ringbuffer[(pos-2)&s.ringbuffer_mask]
|
|
1753
|
+
for {
|
|
1754
|
+
var context byte
|
|
1755
|
+
if !checkInputAmountMaybeSafe(safe, br, 28) { /* 162 bits + 7 bytes */
|
|
1756
|
+
s.state = stateCommandInner
|
|
1757
|
+
result = decoderNeedsMoreInput
|
|
1758
|
+
goto saveStateAndReturn
|
|
1759
|
+
}
|
|
1760
|
+
|
|
1761
|
+
if s.block_length[0] == 0 {
|
|
1762
|
+
if safe != 0 {
|
|
1763
|
+
if !safeDecodeLiteralBlockSwitch(s) {
|
|
1764
|
+
result = decoderNeedsMoreInput
|
|
1765
|
+
goto saveStateAndReturn
|
|
1766
|
+
}
|
|
1767
|
+
} else {
|
|
1768
|
+
decodeLiteralBlockSwitch(s)
|
|
1769
|
+
}
|
|
1770
|
+
|
|
1771
|
+
if s.trivial_literal_context != 0 {
|
|
1772
|
+
goto CommandInner
|
|
1773
|
+
}
|
|
1774
|
+
}
|
|
1775
|
+
|
|
1776
|
+
context = getContext(p1, p2, s.context_lookup)
|
|
1777
|
+
hc = []huffmanCode(s.literal_hgroup.htrees[s.context_map_slice[context]])
|
|
1778
|
+
p2 = p1
|
|
1779
|
+
if safe == 0 {
|
|
1780
|
+
p1 = byte(readSymbol(hc, br))
|
|
1781
|
+
} else {
|
|
1782
|
+
var literal uint32
|
|
1783
|
+
if !safeReadSymbol(hc, br, &literal) {
|
|
1784
|
+
result = decoderNeedsMoreInput
|
|
1785
|
+
goto saveStateAndReturn
|
|
1786
|
+
}
|
|
1787
|
+
|
|
1788
|
+
p1 = byte(literal)
|
|
1789
|
+
}
|
|
1790
|
+
|
|
1791
|
+
s.ringbuffer[pos] = p1
|
|
1792
|
+
s.block_length[0]--
|
|
1793
|
+
pos++
|
|
1794
|
+
if pos == s.ringbuffer_size {
|
|
1795
|
+
s.state = stateCommandInnerWrite
|
|
1796
|
+
i--
|
|
1797
|
+
goto saveStateAndReturn
|
|
1798
|
+
}
|
|
1799
|
+
i--
|
|
1800
|
+
if i == 0 {
|
|
1801
|
+
break
|
|
1802
|
+
}
|
|
1803
|
+
}
|
|
1804
|
+
}
|
|
1805
|
+
|
|
1806
|
+
if s.meta_block_remaining_len <= 0 {
|
|
1807
|
+
s.state = stateMetablockDone
|
|
1808
|
+
goto saveStateAndReturn
|
|
1809
|
+
}
|
|
1810
|
+
|
|
1811
|
+
CommandPostDecodeLiterals:
|
|
1812
|
+
if safe != 0 {
|
|
1813
|
+
s.state = stateCommandPostDecodeLiterals
|
|
1814
|
+
}
|
|
1815
|
+
|
|
1816
|
+
if s.distance_code >= 0 {
|
|
1817
|
+
/* Implicit distance case. */
|
|
1818
|
+
if s.distance_code != 0 {
|
|
1819
|
+
s.distance_context = 0
|
|
1820
|
+
} else {
|
|
1821
|
+
s.distance_context = 1
|
|
1822
|
+
}
|
|
1823
|
+
|
|
1824
|
+
s.dist_rb_idx--
|
|
1825
|
+
s.distance_code = s.dist_rb[s.dist_rb_idx&3]
|
|
1826
|
+
} else {
|
|
1827
|
+
/* Read distance code in the command, unless it was implicitly zero. */
|
|
1828
|
+
if s.block_length[2] == 0 {
|
|
1829
|
+
if safe != 0 {
|
|
1830
|
+
if !safeDecodeDistanceBlockSwitch(s) {
|
|
1831
|
+
result = decoderNeedsMoreInput
|
|
1832
|
+
goto saveStateAndReturn
|
|
1833
|
+
}
|
|
1834
|
+
} else {
|
|
1835
|
+
decodeDistanceBlockSwitch(s)
|
|
1836
|
+
}
|
|
1837
|
+
}
|
|
1838
|
+
|
|
1839
|
+
if safe != 0 {
|
|
1840
|
+
if !safeReadDistance(s, br) {
|
|
1841
|
+
result = decoderNeedsMoreInput
|
|
1842
|
+
goto saveStateAndReturn
|
|
1843
|
+
}
|
|
1844
|
+
} else {
|
|
1845
|
+
readDistance(s, br)
|
|
1846
|
+
}
|
|
1847
|
+
}
|
|
1848
|
+
|
|
1849
|
+
if s.max_distance != s.max_backward_distance {
|
|
1850
|
+
if pos < s.max_backward_distance {
|
|
1851
|
+
s.max_distance = pos
|
|
1852
|
+
} else {
|
|
1853
|
+
s.max_distance = s.max_backward_distance
|
|
1854
|
+
}
|
|
1855
|
+
}
|
|
1856
|
+
|
|
1857
|
+
i = s.copy_length
|
|
1858
|
+
|
|
1859
|
+
/* Apply copy of LZ77 back-reference, or static dictionary reference if
|
|
1860
|
+
the distance is larger than the max LZ77 distance */
|
|
1861
|
+
if s.distance_code > s.max_distance {
|
|
1862
|
+
/* The maximum allowed distance is BROTLI_MAX_ALLOWED_DISTANCE = 0x7FFFFFFC.
|
|
1863
|
+
With this choice, no signed overflow can occur after decoding
|
|
1864
|
+
a special distance code (e.g., after adding 3 to the last distance). */
|
|
1865
|
+
if s.distance_code > maxAllowedDistance {
|
|
1866
|
+
return decoderErrorFormatDistance
|
|
1867
|
+
}
|
|
1868
|
+
|
|
1869
|
+
if i >= minDictionaryWordLength && i <= maxDictionaryWordLength {
|
|
1870
|
+
var address int = s.distance_code - s.max_distance - 1
|
|
1871
|
+
var words *dictionary = s.dictionary
|
|
1872
|
+
var trans *transforms = s.transforms
|
|
1873
|
+
var offset int = int(s.dictionary.offsets_by_length[i])
|
|
1874
|
+
var shift uint32 = uint32(s.dictionary.size_bits_by_length[i])
|
|
1875
|
+
var mask int = int(bitMask(shift))
|
|
1876
|
+
var word_idx int = address & mask
|
|
1877
|
+
var transform_idx int = address >> shift
|
|
1878
|
+
|
|
1879
|
+
/* Compensate double distance-ring-buffer roll. */
|
|
1880
|
+
s.dist_rb_idx += s.distance_context
|
|
1881
|
+
|
|
1882
|
+
offset += word_idx * i
|
|
1883
|
+
if words.data == nil {
|
|
1884
|
+
return decoderErrorDictionaryNotSet
|
|
1885
|
+
}
|
|
1886
|
+
|
|
1887
|
+
if transform_idx < int(trans.num_transforms) {
|
|
1888
|
+
word := words.data[offset:]
|
|
1889
|
+
var len int = i
|
|
1890
|
+
if transform_idx == int(trans.cutOffTransforms[0]) {
|
|
1891
|
+
copy(s.ringbuffer[pos:], word[:uint(len)])
|
|
1892
|
+
} else {
|
|
1893
|
+
len = transformDictionaryWord(s.ringbuffer[pos:], word, int(len), trans, transform_idx)
|
|
1894
|
+
}
|
|
1895
|
+
|
|
1896
|
+
pos += int(len)
|
|
1897
|
+
s.meta_block_remaining_len -= int(len)
|
|
1898
|
+
if pos >= s.ringbuffer_size {
|
|
1899
|
+
s.state = stateCommandPostWrite1
|
|
1900
|
+
goto saveStateAndReturn
|
|
1901
|
+
}
|
|
1902
|
+
} else {
|
|
1903
|
+
return decoderErrorFormatTransform
|
|
1904
|
+
}
|
|
1905
|
+
} else {
|
|
1906
|
+
return decoderErrorFormatDictionary
|
|
1907
|
+
}
|
|
1908
|
+
} else {
|
|
1909
|
+
var src_start int = (pos - s.distance_code) & s.ringbuffer_mask
|
|
1910
|
+
copy_dst := s.ringbuffer[pos:]
|
|
1911
|
+
copy_src := s.ringbuffer[src_start:]
|
|
1912
|
+
var dst_end int = pos + i
|
|
1913
|
+
var src_end int = src_start + i
|
|
1914
|
+
|
|
1915
|
+
/* Update the recent distances cache. */
|
|
1916
|
+
s.dist_rb[s.dist_rb_idx&3] = s.distance_code
|
|
1917
|
+
|
|
1918
|
+
s.dist_rb_idx++
|
|
1919
|
+
s.meta_block_remaining_len -= i
|
|
1920
|
+
|
|
1921
|
+
/* There are 32+ bytes of slack in the ring-buffer allocation.
|
|
1922
|
+
Also, we have 16 short codes, that make these 16 bytes irrelevant
|
|
1923
|
+
in the ring-buffer. Let's copy over them as a first guess. */
|
|
1924
|
+
copy(copy_dst, copy_src[:16])
|
|
1925
|
+
|
|
1926
|
+
if src_end > pos && dst_end > src_start {
|
|
1927
|
+
/* Regions intersect. */
|
|
1928
|
+
goto CommandPostWrapCopy
|
|
1929
|
+
}
|
|
1930
|
+
|
|
1931
|
+
if dst_end >= s.ringbuffer_size || src_end >= s.ringbuffer_size {
|
|
1932
|
+
/* At least one region wraps. */
|
|
1933
|
+
goto CommandPostWrapCopy
|
|
1934
|
+
}
|
|
1935
|
+
|
|
1936
|
+
pos += i
|
|
1937
|
+
if i > 16 {
|
|
1938
|
+
if i > 32 {
|
|
1939
|
+
copy(copy_dst[16:], copy_src[16:][:uint(i-16)])
|
|
1940
|
+
} else {
|
|
1941
|
+
/* This branch covers about 45% cases.
|
|
1942
|
+
Fixed size short copy allows more compiler optimizations. */
|
|
1943
|
+
copy(copy_dst[16:], copy_src[16:][:16])
|
|
1944
|
+
}
|
|
1945
|
+
}
|
|
1946
|
+
}
|
|
1947
|
+
|
|
1948
|
+
if s.meta_block_remaining_len <= 0 {
|
|
1949
|
+
/* Next metablock, if any. */
|
|
1950
|
+
s.state = stateMetablockDone
|
|
1951
|
+
|
|
1952
|
+
goto saveStateAndReturn
|
|
1953
|
+
} else {
|
|
1954
|
+
goto CommandBegin
|
|
1955
|
+
}
|
|
1956
|
+
CommandPostWrapCopy:
|
|
1957
|
+
{
|
|
1958
|
+
var wrap_guard int = s.ringbuffer_size - pos
|
|
1959
|
+
for {
|
|
1960
|
+
i--
|
|
1961
|
+
if i < 0 {
|
|
1962
|
+
break
|
|
1963
|
+
}
|
|
1964
|
+
s.ringbuffer[pos] = s.ringbuffer[(pos-s.distance_code)&s.ringbuffer_mask]
|
|
1965
|
+
pos++
|
|
1966
|
+
wrap_guard--
|
|
1967
|
+
if wrap_guard == 0 {
|
|
1968
|
+
s.state = stateCommandPostWrite2
|
|
1969
|
+
goto saveStateAndReturn
|
|
1970
|
+
}
|
|
1971
|
+
}
|
|
1972
|
+
}
|
|
1973
|
+
|
|
1974
|
+
if s.meta_block_remaining_len <= 0 {
|
|
1975
|
+
/* Next metablock, if any. */
|
|
1976
|
+
s.state = stateMetablockDone
|
|
1977
|
+
|
|
1978
|
+
goto saveStateAndReturn
|
|
1979
|
+
} else {
|
|
1980
|
+
goto CommandBegin
|
|
1981
|
+
}
|
|
1982
|
+
|
|
1983
|
+
saveStateAndReturn:
|
|
1984
|
+
s.pos = pos
|
|
1985
|
+
s.loop_counter = i
|
|
1986
|
+
return result
|
|
1987
|
+
}
|
|
1988
|
+
|
|
1989
|
+
func processCommands(s *Reader) int {
|
|
1990
|
+
return processCommandsInternal(0, s)
|
|
1991
|
+
}
|
|
1992
|
+
|
|
1993
|
+
func safeProcessCommands(s *Reader) int {
|
|
1994
|
+
return processCommandsInternal(1, s)
|
|
1995
|
+
}
|
|
1996
|
+
|
|
1997
|
+
/* Returns the maximum number of distance symbols which can only represent
|
|
1998
|
+
distances not exceeding BROTLI_MAX_ALLOWED_DISTANCE. */
|
|
1999
|
+
|
|
2000
|
+
var maxDistanceSymbol_bound = [maxNpostfix + 1]uint32{0, 4, 12, 28}
|
|
2001
|
+
var maxDistanceSymbol_diff = [maxNpostfix + 1]uint32{73, 126, 228, 424}
|
|
2002
|
+
|
|
2003
|
+
func maxDistanceSymbol(ndirect uint32, npostfix uint32) uint32 {
|
|
2004
|
+
var postfix uint32 = 1 << npostfix
|
|
2005
|
+
if ndirect < maxDistanceSymbol_bound[npostfix] {
|
|
2006
|
+
return ndirect + maxDistanceSymbol_diff[npostfix] + postfix
|
|
2007
|
+
} else if ndirect > maxDistanceSymbol_bound[npostfix]+postfix {
|
|
2008
|
+
return ndirect + maxDistanceSymbol_diff[npostfix]
|
|
2009
|
+
} else {
|
|
2010
|
+
return maxDistanceSymbol_bound[npostfix] + maxDistanceSymbol_diff[npostfix] + postfix
|
|
2011
|
+
}
|
|
2012
|
+
}
|
|
2013
|
+
|
|
2014
|
+
/* Invariant: input stream is never overconsumed:
|
|
2015
|
+
- invalid input implies that the whole stream is invalid -> any amount of
|
|
2016
|
+
input could be read and discarded
|
|
2017
|
+
- when result is "needs more input", then at least one more byte is REQUIRED
|
|
2018
|
+
to complete decoding; all input data MUST be consumed by decoder, so
|
|
2019
|
+
client could swap the input buffer
|
|
2020
|
+
- when result is "needs more output" decoder MUST ensure that it doesn't
|
|
2021
|
+
hold more than 7 bits in bit reader; this saves client from swapping input
|
|
2022
|
+
buffer ahead of time
|
|
2023
|
+
- when result is "success" decoder MUST return all unused data back to input
|
|
2024
|
+
buffer; this is possible because the invariant is held on enter */
|
|
2025
|
+
func decoderDecompressStream(s *Reader, available_in *uint, next_in *[]byte, available_out *uint, next_out *[]byte) int {
|
|
2026
|
+
var result int = decoderSuccess
|
|
2027
|
+
var br *bitReader = &s.br
|
|
2028
|
+
|
|
2029
|
+
/* Do not try to process further in a case of unrecoverable error. */
|
|
2030
|
+
if int(s.error_code) < 0 {
|
|
2031
|
+
return decoderResultError
|
|
2032
|
+
}
|
|
2033
|
+
|
|
2034
|
+
if *available_out != 0 && (next_out == nil || *next_out == nil) {
|
|
2035
|
+
return saveErrorCode(s, decoderErrorInvalidArguments)
|
|
2036
|
+
}
|
|
2037
|
+
|
|
2038
|
+
if *available_out == 0 {
|
|
2039
|
+
next_out = nil
|
|
2040
|
+
}
|
|
2041
|
+
if s.buffer_length == 0 { /* Just connect bit reader to input stream. */
|
|
2042
|
+
br.input_len = *available_in
|
|
2043
|
+
br.input = *next_in
|
|
2044
|
+
br.byte_pos = 0
|
|
2045
|
+
} else {
|
|
2046
|
+
/* At least one byte of input is required. More than one byte of input may
|
|
2047
|
+
be required to complete the transaction -> reading more data must be
|
|
2048
|
+
done in a loop -> do it in a main loop. */
|
|
2049
|
+
result = decoderNeedsMoreInput
|
|
2050
|
+
|
|
2051
|
+
br.input = s.buffer.u8[:]
|
|
2052
|
+
br.byte_pos = 0
|
|
2053
|
+
}
|
|
2054
|
+
|
|
2055
|
+
/* State machine */
|
|
2056
|
+
for {
|
|
2057
|
+
if result != decoderSuccess {
|
|
2058
|
+
/* Error, needs more input/output. */
|
|
2059
|
+
if result == decoderNeedsMoreInput {
|
|
2060
|
+
if s.ringbuffer != nil { /* Pro-actively push output. */
|
|
2061
|
+
var intermediate_result int = writeRingBuffer(s, available_out, next_out, nil, true)
|
|
2062
|
+
|
|
2063
|
+
/* WriteRingBuffer checks s->meta_block_remaining_len validity. */
|
|
2064
|
+
if int(intermediate_result) < 0 {
|
|
2065
|
+
result = intermediate_result
|
|
2066
|
+
break
|
|
2067
|
+
}
|
|
2068
|
+
}
|
|
2069
|
+
|
|
2070
|
+
if s.buffer_length != 0 { /* Used with internal buffer. */
|
|
2071
|
+
if br.byte_pos == br.input_len {
|
|
2072
|
+
/* Successfully finished read transaction.
|
|
2073
|
+
Accumulator contains less than 8 bits, because internal buffer
|
|
2074
|
+
is expanded byte-by-byte until it is enough to complete read. */
|
|
2075
|
+
s.buffer_length = 0
|
|
2076
|
+
|
|
2077
|
+
/* Switch to input stream and restart. */
|
|
2078
|
+
result = decoderSuccess
|
|
2079
|
+
|
|
2080
|
+
br.input_len = *available_in
|
|
2081
|
+
br.input = *next_in
|
|
2082
|
+
br.byte_pos = 0
|
|
2083
|
+
continue
|
|
2084
|
+
} else if *available_in != 0 {
|
|
2085
|
+
/* Not enough data in buffer, but can take one more byte from
|
|
2086
|
+
input stream. */
|
|
2087
|
+
result = decoderSuccess
|
|
2088
|
+
|
|
2089
|
+
s.buffer.u8[s.buffer_length] = (*next_in)[0]
|
|
2090
|
+
s.buffer_length++
|
|
2091
|
+
br.input_len = uint(s.buffer_length)
|
|
2092
|
+
*next_in = (*next_in)[1:]
|
|
2093
|
+
(*available_in)--
|
|
2094
|
+
|
|
2095
|
+
/* Retry with more data in buffer. */
|
|
2096
|
+
continue
|
|
2097
|
+
}
|
|
2098
|
+
|
|
2099
|
+
/* Can't finish reading and no more input. */
|
|
2100
|
+
break
|
|
2101
|
+
/* Input stream doesn't contain enough input. */
|
|
2102
|
+
} else {
|
|
2103
|
+
/* Copy tail to internal buffer and return. */
|
|
2104
|
+
*next_in = br.input[br.byte_pos:]
|
|
2105
|
+
|
|
2106
|
+
*available_in = br.input_len - br.byte_pos
|
|
2107
|
+
for *available_in != 0 {
|
|
2108
|
+
s.buffer.u8[s.buffer_length] = (*next_in)[0]
|
|
2109
|
+
s.buffer_length++
|
|
2110
|
+
*next_in = (*next_in)[1:]
|
|
2111
|
+
(*available_in)--
|
|
2112
|
+
}
|
|
2113
|
+
|
|
2114
|
+
break
|
|
2115
|
+
}
|
|
2116
|
+
}
|
|
2117
|
+
|
|
2118
|
+
/* Unreachable. */
|
|
2119
|
+
|
|
2120
|
+
/* Fail or needs more output. */
|
|
2121
|
+
if s.buffer_length != 0 {
|
|
2122
|
+
/* Just consumed the buffered input and produced some output. Otherwise
|
|
2123
|
+
it would result in "needs more input". Reset internal buffer. */
|
|
2124
|
+
s.buffer_length = 0
|
|
2125
|
+
} else {
|
|
2126
|
+
/* Using input stream in last iteration. When decoder switches to input
|
|
2127
|
+
stream it has less than 8 bits in accumulator, so it is safe to
|
|
2128
|
+
return unused accumulator bits there. */
|
|
2129
|
+
bitReaderUnload(br)
|
|
2130
|
+
|
|
2131
|
+
*available_in = br.input_len - br.byte_pos
|
|
2132
|
+
*next_in = br.input[br.byte_pos:]
|
|
2133
|
+
}
|
|
2134
|
+
|
|
2135
|
+
break
|
|
2136
|
+
}
|
|
2137
|
+
|
|
2138
|
+
switch s.state {
|
|
2139
|
+
/* Prepare to the first read. */
|
|
2140
|
+
case stateUninited:
|
|
2141
|
+
if !warmupBitReader(br) {
|
|
2142
|
+
result = decoderNeedsMoreInput
|
|
2143
|
+
break
|
|
2144
|
+
}
|
|
2145
|
+
|
|
2146
|
+
/* Decode window size. */
|
|
2147
|
+
result = decodeWindowBits(s, br) /* Reads 1..8 bits. */
|
|
2148
|
+
if result != decoderSuccess {
|
|
2149
|
+
break
|
|
2150
|
+
}
|
|
2151
|
+
|
|
2152
|
+
if s.large_window {
|
|
2153
|
+
s.state = stateLargeWindowBits
|
|
2154
|
+
break
|
|
2155
|
+
}
|
|
2156
|
+
|
|
2157
|
+
s.state = stateInitialize
|
|
2158
|
+
|
|
2159
|
+
case stateLargeWindowBits:
|
|
2160
|
+
if !safeReadBits(br, 6, &s.window_bits) {
|
|
2161
|
+
result = decoderNeedsMoreInput
|
|
2162
|
+
break
|
|
2163
|
+
}
|
|
2164
|
+
|
|
2165
|
+
if s.window_bits < largeMinWbits || s.window_bits > largeMaxWbits {
|
|
2166
|
+
result = decoderErrorFormatWindowBits
|
|
2167
|
+
break
|
|
2168
|
+
}
|
|
2169
|
+
|
|
2170
|
+
s.state = stateInitialize
|
|
2171
|
+
fallthrough
|
|
2172
|
+
|
|
2173
|
+
/* Maximum distance, see section 9.1. of the spec. */
|
|
2174
|
+
/* Fall through. */
|
|
2175
|
+
case stateInitialize:
|
|
2176
|
+
s.max_backward_distance = (1 << s.window_bits) - windowGap
|
|
2177
|
+
|
|
2178
|
+
if s.block_type_trees == nil {
|
|
2179
|
+
/* Allocate memory for both block_type_trees and block_len_trees. */
|
|
2180
|
+
s.block_type_trees = make([]huffmanCode, (3 * (huffmanMaxSize258 + huffmanMaxSize26)))
|
|
2181
|
+
}
|
|
2182
|
+
|
|
2183
|
+
s.block_len_trees = s.block_type_trees[3*huffmanMaxSize258:]
|
|
2184
|
+
|
|
2185
|
+
s.state = stateMetablockBegin
|
|
2186
|
+
fallthrough
|
|
2187
|
+
|
|
2188
|
+
/* Fall through. */
|
|
2189
|
+
case stateMetablockBegin:
|
|
2190
|
+
decoderStateMetablockBegin(s)
|
|
2191
|
+
|
|
2192
|
+
s.state = stateMetablockHeader
|
|
2193
|
+
fallthrough
|
|
2194
|
+
|
|
2195
|
+
/* Fall through. */
|
|
2196
|
+
case stateMetablockHeader:
|
|
2197
|
+
result = decodeMetaBlockLength(s, br)
|
|
2198
|
+
/* Reads 2 - 31 bits. */
|
|
2199
|
+
if result != decoderSuccess {
|
|
2200
|
+
break
|
|
2201
|
+
}
|
|
2202
|
+
|
|
2203
|
+
if s.is_metadata != 0 || s.is_uncompressed != 0 {
|
|
2204
|
+
if !bitReaderJumpToByteBoundary(br) {
|
|
2205
|
+
result = decoderErrorFormatPadding1
|
|
2206
|
+
break
|
|
2207
|
+
}
|
|
2208
|
+
}
|
|
2209
|
+
|
|
2210
|
+
if s.is_metadata != 0 {
|
|
2211
|
+
s.state = stateMetadata
|
|
2212
|
+
break
|
|
2213
|
+
}
|
|
2214
|
+
|
|
2215
|
+
if s.meta_block_remaining_len == 0 {
|
|
2216
|
+
s.state = stateMetablockDone
|
|
2217
|
+
break
|
|
2218
|
+
}
|
|
2219
|
+
|
|
2220
|
+
calculateRingBufferSize(s)
|
|
2221
|
+
if s.is_uncompressed != 0 {
|
|
2222
|
+
s.state = stateUncompressed
|
|
2223
|
+
break
|
|
2224
|
+
}
|
|
2225
|
+
|
|
2226
|
+
s.loop_counter = 0
|
|
2227
|
+
s.state = stateHuffmanCode0
|
|
2228
|
+
|
|
2229
|
+
case stateUncompressed:
|
|
2230
|
+
result = copyUncompressedBlockToOutput(available_out, next_out, nil, s)
|
|
2231
|
+
if result == decoderSuccess {
|
|
2232
|
+
s.state = stateMetablockDone
|
|
2233
|
+
}
|
|
2234
|
+
|
|
2235
|
+
case stateMetadata:
|
|
2236
|
+
for ; s.meta_block_remaining_len > 0; s.meta_block_remaining_len-- {
|
|
2237
|
+
var bits uint32
|
|
2238
|
+
|
|
2239
|
+
/* Read one byte and ignore it. */
|
|
2240
|
+
if !safeReadBits(br, 8, &bits) {
|
|
2241
|
+
result = decoderNeedsMoreInput
|
|
2242
|
+
break
|
|
2243
|
+
}
|
|
2244
|
+
}
|
|
2245
|
+
|
|
2246
|
+
if result == decoderSuccess {
|
|
2247
|
+
s.state = stateMetablockDone
|
|
2248
|
+
}
|
|
2249
|
+
|
|
2250
|
+
case stateHuffmanCode0:
|
|
2251
|
+
if s.loop_counter >= 3 {
|
|
2252
|
+
s.state = stateMetablockHeader2
|
|
2253
|
+
break
|
|
2254
|
+
}
|
|
2255
|
+
|
|
2256
|
+
/* Reads 1..11 bits. */
|
|
2257
|
+
result = decodeVarLenUint8(s, br, &s.num_block_types[s.loop_counter])
|
|
2258
|
+
|
|
2259
|
+
if result != decoderSuccess {
|
|
2260
|
+
break
|
|
2261
|
+
}
|
|
2262
|
+
|
|
2263
|
+
s.num_block_types[s.loop_counter]++
|
|
2264
|
+
if s.num_block_types[s.loop_counter] < 2 {
|
|
2265
|
+
s.loop_counter++
|
|
2266
|
+
break
|
|
2267
|
+
}
|
|
2268
|
+
|
|
2269
|
+
s.state = stateHuffmanCode1
|
|
2270
|
+
fallthrough
|
|
2271
|
+
|
|
2272
|
+
case stateHuffmanCode1:
|
|
2273
|
+
{
|
|
2274
|
+
var alphabet_size uint32 = s.num_block_types[s.loop_counter] + 2
|
|
2275
|
+
var tree_offset int = s.loop_counter * huffmanMaxSize258
|
|
2276
|
+
result = readHuffmanCode(alphabet_size, alphabet_size, s.block_type_trees[tree_offset:], nil, s)
|
|
2277
|
+
if result != decoderSuccess {
|
|
2278
|
+
break
|
|
2279
|
+
}
|
|
2280
|
+
s.state = stateHuffmanCode2
|
|
2281
|
+
}
|
|
2282
|
+
fallthrough
|
|
2283
|
+
|
|
2284
|
+
case stateHuffmanCode2:
|
|
2285
|
+
{
|
|
2286
|
+
var alphabet_size uint32 = numBlockLenSymbols
|
|
2287
|
+
var tree_offset int = s.loop_counter * huffmanMaxSize26
|
|
2288
|
+
result = readHuffmanCode(alphabet_size, alphabet_size, s.block_len_trees[tree_offset:], nil, s)
|
|
2289
|
+
if result != decoderSuccess {
|
|
2290
|
+
break
|
|
2291
|
+
}
|
|
2292
|
+
s.state = stateHuffmanCode3
|
|
2293
|
+
}
|
|
2294
|
+
fallthrough
|
|
2295
|
+
|
|
2296
|
+
case stateHuffmanCode3:
|
|
2297
|
+
var tree_offset int = s.loop_counter * huffmanMaxSize26
|
|
2298
|
+
if !safeReadBlockLength(s, &s.block_length[s.loop_counter], s.block_len_trees[tree_offset:], br) {
|
|
2299
|
+
result = decoderNeedsMoreInput
|
|
2300
|
+
break
|
|
2301
|
+
}
|
|
2302
|
+
|
|
2303
|
+
s.loop_counter++
|
|
2304
|
+
s.state = stateHuffmanCode0
|
|
2305
|
+
|
|
2306
|
+
case stateMetablockHeader2:
|
|
2307
|
+
{
|
|
2308
|
+
var bits uint32
|
|
2309
|
+
if !safeReadBits(br, 6, &bits) {
|
|
2310
|
+
result = decoderNeedsMoreInput
|
|
2311
|
+
break
|
|
2312
|
+
}
|
|
2313
|
+
|
|
2314
|
+
s.distance_postfix_bits = bits & bitMask(2)
|
|
2315
|
+
bits >>= 2
|
|
2316
|
+
s.num_direct_distance_codes = numDistanceShortCodes + (bits << s.distance_postfix_bits)
|
|
2317
|
+
s.distance_postfix_mask = int(bitMask(s.distance_postfix_bits))
|
|
2318
|
+
s.context_modes = make([]byte, uint(s.num_block_types[0]))
|
|
2319
|
+
if s.context_modes == nil {
|
|
2320
|
+
result = decoderErrorAllocContextModes
|
|
2321
|
+
break
|
|
2322
|
+
}
|
|
2323
|
+
|
|
2324
|
+
s.loop_counter = 0
|
|
2325
|
+
s.state = stateContextModes
|
|
2326
|
+
}
|
|
2327
|
+
fallthrough
|
|
2328
|
+
|
|
2329
|
+
case stateContextModes:
|
|
2330
|
+
result = readContextModes(s)
|
|
2331
|
+
|
|
2332
|
+
if result != decoderSuccess {
|
|
2333
|
+
break
|
|
2334
|
+
}
|
|
2335
|
+
|
|
2336
|
+
s.state = stateContextMap1
|
|
2337
|
+
fallthrough
|
|
2338
|
+
|
|
2339
|
+
case stateContextMap1:
|
|
2340
|
+
result = decodeContextMap(s.num_block_types[0]<<literalContextBits, &s.num_literal_htrees, &s.context_map, s)
|
|
2341
|
+
|
|
2342
|
+
if result != decoderSuccess {
|
|
2343
|
+
break
|
|
2344
|
+
}
|
|
2345
|
+
|
|
2346
|
+
detectTrivialLiteralBlockTypes(s)
|
|
2347
|
+
s.state = stateContextMap2
|
|
2348
|
+
fallthrough
|
|
2349
|
+
|
|
2350
|
+
case stateContextMap2:
|
|
2351
|
+
{
|
|
2352
|
+
var num_direct_codes uint32 = s.num_direct_distance_codes - numDistanceShortCodes
|
|
2353
|
+
var num_distance_codes uint32
|
|
2354
|
+
var max_distance_symbol uint32
|
|
2355
|
+
if s.large_window {
|
|
2356
|
+
num_distance_codes = uint32(distanceAlphabetSize(uint(s.distance_postfix_bits), uint(num_direct_codes), largeMaxDistanceBits))
|
|
2357
|
+
max_distance_symbol = maxDistanceSymbol(num_direct_codes, s.distance_postfix_bits)
|
|
2358
|
+
} else {
|
|
2359
|
+
num_distance_codes = uint32(distanceAlphabetSize(uint(s.distance_postfix_bits), uint(num_direct_codes), maxDistanceBits))
|
|
2360
|
+
max_distance_symbol = num_distance_codes
|
|
2361
|
+
}
|
|
2362
|
+
var allocation_success bool = true
|
|
2363
|
+
result = decodeContextMap(s.num_block_types[2]<<distanceContextBits, &s.num_dist_htrees, &s.dist_context_map, s)
|
|
2364
|
+
if result != decoderSuccess {
|
|
2365
|
+
break
|
|
2366
|
+
}
|
|
2367
|
+
|
|
2368
|
+
decoderHuffmanTreeGroupInit(&s.literal_hgroup, numLiteralSymbols, numLiteralSymbols, s.num_literal_htrees)
|
|
2369
|
+
decoderHuffmanTreeGroupInit(&s.insert_copy_hgroup, numCommandSymbols, numCommandSymbols, s.num_block_types[1])
|
|
2370
|
+
decoderHuffmanTreeGroupInit(&s.distance_hgroup, num_distance_codes, max_distance_symbol, s.num_dist_htrees)
|
|
2371
|
+
|
|
2372
|
+
if !allocation_success {
|
|
2373
|
+
return saveErrorCode(s, decoderErrorAllocTreeGroups)
|
|
2374
|
+
}
|
|
2375
|
+
|
|
2376
|
+
s.loop_counter = 0
|
|
2377
|
+
s.state = stateTreeGroup
|
|
2378
|
+
}
|
|
2379
|
+
fallthrough
|
|
2380
|
+
|
|
2381
|
+
case stateTreeGroup:
|
|
2382
|
+
var hgroup *huffmanTreeGroup = nil
|
|
2383
|
+
switch s.loop_counter {
|
|
2384
|
+
case 0:
|
|
2385
|
+
hgroup = &s.literal_hgroup
|
|
2386
|
+
case 1:
|
|
2387
|
+
hgroup = &s.insert_copy_hgroup
|
|
2388
|
+
case 2:
|
|
2389
|
+
hgroup = &s.distance_hgroup
|
|
2390
|
+
default:
|
|
2391
|
+
return saveErrorCode(s, decoderErrorUnreachable)
|
|
2392
|
+
}
|
|
2393
|
+
|
|
2394
|
+
result = huffmanTreeGroupDecode(hgroup, s)
|
|
2395
|
+
if result != decoderSuccess {
|
|
2396
|
+
break
|
|
2397
|
+
}
|
|
2398
|
+
s.loop_counter++
|
|
2399
|
+
if s.loop_counter >= 3 {
|
|
2400
|
+
prepareLiteralDecoding(s)
|
|
2401
|
+
s.dist_context_map_slice = s.dist_context_map
|
|
2402
|
+
s.htree_command = []huffmanCode(s.insert_copy_hgroup.htrees[0])
|
|
2403
|
+
if !ensureRingBuffer(s) {
|
|
2404
|
+
result = decoderErrorAllocRingBuffer2
|
|
2405
|
+
break
|
|
2406
|
+
}
|
|
2407
|
+
|
|
2408
|
+
s.state = stateCommandBegin
|
|
2409
|
+
}
|
|
2410
|
+
|
|
2411
|
+
case stateCommandBegin, stateCommandInner, stateCommandPostDecodeLiterals, stateCommandPostWrapCopy:
|
|
2412
|
+
result = processCommands(s)
|
|
2413
|
+
|
|
2414
|
+
if result == decoderNeedsMoreInput {
|
|
2415
|
+
result = safeProcessCommands(s)
|
|
2416
|
+
}
|
|
2417
|
+
|
|
2418
|
+
case stateCommandInnerWrite, stateCommandPostWrite1, stateCommandPostWrite2:
|
|
2419
|
+
result = writeRingBuffer(s, available_out, next_out, nil, false)
|
|
2420
|
+
|
|
2421
|
+
if result != decoderSuccess {
|
|
2422
|
+
break
|
|
2423
|
+
}
|
|
2424
|
+
|
|
2425
|
+
wrapRingBuffer(s)
|
|
2426
|
+
if s.ringbuffer_size == 1<<s.window_bits {
|
|
2427
|
+
s.max_distance = s.max_backward_distance
|
|
2428
|
+
}
|
|
2429
|
+
|
|
2430
|
+
if s.state == stateCommandPostWrite1 {
|
|
2431
|
+
if s.meta_block_remaining_len == 0 {
|
|
2432
|
+
/* Next metablock, if any. */
|
|
2433
|
+
s.state = stateMetablockDone
|
|
2434
|
+
} else {
|
|
2435
|
+
s.state = stateCommandBegin
|
|
2436
|
+
}
|
|
2437
|
+
} else if s.state == stateCommandPostWrite2 {
|
|
2438
|
+
s.state = stateCommandPostWrapCopy /* BROTLI_STATE_COMMAND_INNER_WRITE */
|
|
2439
|
+
} else {
|
|
2440
|
+
if s.loop_counter == 0 {
|
|
2441
|
+
if s.meta_block_remaining_len == 0 {
|
|
2442
|
+
s.state = stateMetablockDone
|
|
2443
|
+
} else {
|
|
2444
|
+
s.state = stateCommandPostDecodeLiterals
|
|
2445
|
+
}
|
|
2446
|
+
|
|
2447
|
+
break
|
|
2448
|
+
}
|
|
2449
|
+
|
|
2450
|
+
s.state = stateCommandInner
|
|
2451
|
+
}
|
|
2452
|
+
|
|
2453
|
+
case stateMetablockDone:
|
|
2454
|
+
if s.meta_block_remaining_len < 0 {
|
|
2455
|
+
result = decoderErrorFormatBlockLength2
|
|
2456
|
+
break
|
|
2457
|
+
}
|
|
2458
|
+
|
|
2459
|
+
decoderStateCleanupAfterMetablock(s)
|
|
2460
|
+
if s.is_last_metablock == 0 {
|
|
2461
|
+
s.state = stateMetablockBegin
|
|
2462
|
+
break
|
|
2463
|
+
}
|
|
2464
|
+
|
|
2465
|
+
if !bitReaderJumpToByteBoundary(br) {
|
|
2466
|
+
result = decoderErrorFormatPadding2
|
|
2467
|
+
break
|
|
2468
|
+
}
|
|
2469
|
+
|
|
2470
|
+
if s.buffer_length == 0 {
|
|
2471
|
+
bitReaderUnload(br)
|
|
2472
|
+
*available_in = br.input_len - br.byte_pos
|
|
2473
|
+
*next_in = br.input[br.byte_pos:]
|
|
2474
|
+
}
|
|
2475
|
+
|
|
2476
|
+
s.state = stateDone
|
|
2477
|
+
fallthrough
|
|
2478
|
+
|
|
2479
|
+
case stateDone:
|
|
2480
|
+
if s.ringbuffer != nil {
|
|
2481
|
+
result = writeRingBuffer(s, available_out, next_out, nil, true)
|
|
2482
|
+
if result != decoderSuccess {
|
|
2483
|
+
break
|
|
2484
|
+
}
|
|
2485
|
+
}
|
|
2486
|
+
|
|
2487
|
+
return saveErrorCode(s, result)
|
|
2488
|
+
}
|
|
2489
|
+
}
|
|
2490
|
+
|
|
2491
|
+
return saveErrorCode(s, result)
|
|
2492
|
+
}
|
|
2493
|
+
|
|
2494
|
+
func decoderHasMoreOutput(s *Reader) bool {
|
|
2495
|
+
/* After unrecoverable error remaining output is considered nonsensical. */
|
|
2496
|
+
if int(s.error_code) < 0 {
|
|
2497
|
+
return false
|
|
2498
|
+
}
|
|
2499
|
+
|
|
2500
|
+
return s.ringbuffer != nil && unwrittenBytes(s, false) != 0
|
|
2501
|
+
}
|
|
2502
|
+
|
|
2503
|
+
func decoderGetErrorCode(s *Reader) int {
|
|
2504
|
+
return int(s.error_code)
|
|
2505
|
+
}
|
|
2506
|
+
|
|
2507
|
+
func decoderErrorString(c int) string {
|
|
2508
|
+
switch c {
|
|
2509
|
+
case decoderNoError:
|
|
2510
|
+
return "NO_ERROR"
|
|
2511
|
+
case decoderSuccess:
|
|
2512
|
+
return "SUCCESS"
|
|
2513
|
+
case decoderNeedsMoreInput:
|
|
2514
|
+
return "NEEDS_MORE_INPUT"
|
|
2515
|
+
case decoderNeedsMoreOutput:
|
|
2516
|
+
return "NEEDS_MORE_OUTPUT"
|
|
2517
|
+
case decoderErrorFormatExuberantNibble:
|
|
2518
|
+
return "EXUBERANT_NIBBLE"
|
|
2519
|
+
case decoderErrorFormatReserved:
|
|
2520
|
+
return "RESERVED"
|
|
2521
|
+
case decoderErrorFormatExuberantMetaNibble:
|
|
2522
|
+
return "EXUBERANT_META_NIBBLE"
|
|
2523
|
+
case decoderErrorFormatSimpleHuffmanAlphabet:
|
|
2524
|
+
return "SIMPLE_HUFFMAN_ALPHABET"
|
|
2525
|
+
case decoderErrorFormatSimpleHuffmanSame:
|
|
2526
|
+
return "SIMPLE_HUFFMAN_SAME"
|
|
2527
|
+
case decoderErrorFormatClSpace:
|
|
2528
|
+
return "CL_SPACE"
|
|
2529
|
+
case decoderErrorFormatHuffmanSpace:
|
|
2530
|
+
return "HUFFMAN_SPACE"
|
|
2531
|
+
case decoderErrorFormatContextMapRepeat:
|
|
2532
|
+
return "CONTEXT_MAP_REPEAT"
|
|
2533
|
+
case decoderErrorFormatBlockLength1:
|
|
2534
|
+
return "BLOCK_LENGTH_1"
|
|
2535
|
+
case decoderErrorFormatBlockLength2:
|
|
2536
|
+
return "BLOCK_LENGTH_2"
|
|
2537
|
+
case decoderErrorFormatTransform:
|
|
2538
|
+
return "TRANSFORM"
|
|
2539
|
+
case decoderErrorFormatDictionary:
|
|
2540
|
+
return "DICTIONARY"
|
|
2541
|
+
case decoderErrorFormatWindowBits:
|
|
2542
|
+
return "WINDOW_BITS"
|
|
2543
|
+
case decoderErrorFormatPadding1:
|
|
2544
|
+
return "PADDING_1"
|
|
2545
|
+
case decoderErrorFormatPadding2:
|
|
2546
|
+
return "PADDING_2"
|
|
2547
|
+
case decoderErrorFormatDistance:
|
|
2548
|
+
return "DISTANCE"
|
|
2549
|
+
case decoderErrorDictionaryNotSet:
|
|
2550
|
+
return "DICTIONARY_NOT_SET"
|
|
2551
|
+
case decoderErrorInvalidArguments:
|
|
2552
|
+
return "INVALID_ARGUMENTS"
|
|
2553
|
+
case decoderErrorAllocContextModes:
|
|
2554
|
+
return "CONTEXT_MODES"
|
|
2555
|
+
case decoderErrorAllocTreeGroups:
|
|
2556
|
+
return "TREE_GROUPS"
|
|
2557
|
+
case decoderErrorAllocContextMap:
|
|
2558
|
+
return "CONTEXT_MAP"
|
|
2559
|
+
case decoderErrorAllocRingBuffer1:
|
|
2560
|
+
return "RING_BUFFER_1"
|
|
2561
|
+
case decoderErrorAllocRingBuffer2:
|
|
2562
|
+
return "RING_BUFFER_2"
|
|
2563
|
+
case decoderErrorAllocBlockTypeTrees:
|
|
2564
|
+
return "BLOCK_TYPE_TREES"
|
|
2565
|
+
case decoderErrorUnreachable:
|
|
2566
|
+
return "UNREACHABLE"
|
|
2567
|
+
default:
|
|
2568
|
+
return "INVALID"
|
|
2569
|
+
}
|
|
2570
|
+
}
|