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.
Files changed (147) hide show
  1. package/CHANGELOG.md +57 -0
  2. package/README.md +17 -1
  3. package/bin/cli.js +25 -11
  4. package/bin/go/convert.js +11 -1
  5. package/bin/index.js +221 -47
  6. package/bin/main.js +35 -14
  7. package/bin/node/assert.js +2 -2
  8. package/bin/node/buffer.js +9 -0
  9. package/bin/node/dns.js +1 -1
  10. package/bin/node/events.js +1 -1
  11. package/bin/node/fs.js +1 -1
  12. package/bin/node/fs_watch.js +407 -0
  13. package/bin/node/http2.js +33 -6
  14. package/bin/node/readline.js +1 -1
  15. package/bin/node/registry.js +2 -1
  16. package/bin/node/stream.js +6 -3
  17. package/bin/node/timers.js +1 -1
  18. package/bin/node/typed_arrays.js +608 -0
  19. package/bin/node/util.js +3 -0
  20. package/bin/node/zlib.js +131 -16
  21. package/bin/transpiler.js +635 -44
  22. package/bin/version.js +1 -1
  23. package/conformance.md +16 -4
  24. package/examples/README.md +54 -0
  25. package/examples/fibonacci/README.md +89 -0
  26. package/examples/fibonacci/bench.mjs +87 -0
  27. package/examples/fibonacci/main.ts +21 -0
  28. package/examples/hello-world/README.md +62 -0
  29. package/examples/hello-world/bench.mjs +66 -0
  30. package/examples/hello-world/main.ts +7 -0
  31. package/examples/json-server/README.md +125 -0
  32. package/examples/json-server/bench.mjs +171 -0
  33. package/examples/json-server/main.ts +67 -0
  34. package/govendor/github.com/andybalholm/brotli/LICENSE +19 -0
  35. package/govendor/github.com/andybalholm/brotli/README.md +19 -0
  36. package/govendor/github.com/andybalholm/brotli/backward_references.go +185 -0
  37. package/govendor/github.com/andybalholm/brotli/backward_references_hq.go +796 -0
  38. package/govendor/github.com/andybalholm/brotli/bit_cost.go +436 -0
  39. package/govendor/github.com/andybalholm/brotli/bit_reader.go +266 -0
  40. package/govendor/github.com/andybalholm/brotli/bitwriter.go +56 -0
  41. package/govendor/github.com/andybalholm/brotli/block_splitter.go +144 -0
  42. package/govendor/github.com/andybalholm/brotli/block_splitter_command.go +434 -0
  43. package/govendor/github.com/andybalholm/brotli/block_splitter_distance.go +433 -0
  44. package/govendor/github.com/andybalholm/brotli/block_splitter_literal.go +433 -0
  45. package/govendor/github.com/andybalholm/brotli/brotli_bit_stream.go +1435 -0
  46. package/govendor/github.com/andybalholm/brotli/cluster.go +30 -0
  47. package/govendor/github.com/andybalholm/brotli/cluster_command.go +164 -0
  48. package/govendor/github.com/andybalholm/brotli/cluster_distance.go +326 -0
  49. package/govendor/github.com/andybalholm/brotli/cluster_literal.go +326 -0
  50. package/govendor/github.com/andybalholm/brotli/command.go +254 -0
  51. package/govendor/github.com/andybalholm/brotli/compress_fragment.go +834 -0
  52. package/govendor/github.com/andybalholm/brotli/compress_fragment_two_pass.go +775 -0
  53. package/govendor/github.com/andybalholm/brotli/constants.go +77 -0
  54. package/govendor/github.com/andybalholm/brotli/context.go +2176 -0
  55. package/govendor/github.com/andybalholm/brotli/decode.go +2570 -0
  56. package/govendor/github.com/andybalholm/brotli/dictionary.go +122890 -0
  57. package/govendor/github.com/andybalholm/brotli/dictionary_hash.go +32779 -0
  58. package/govendor/github.com/andybalholm/brotli/encode.go +1220 -0
  59. package/govendor/github.com/andybalholm/brotli/encoder.go +177 -0
  60. package/govendor/github.com/andybalholm/brotli/encoder_dict.go +22 -0
  61. package/govendor/github.com/andybalholm/brotli/encoder_fast.go +201 -0
  62. package/govendor/github.com/andybalholm/brotli/entropy_encode.go +592 -0
  63. package/govendor/github.com/andybalholm/brotli/entropy_encode_static.go +4399 -0
  64. package/govendor/github.com/andybalholm/brotli/fast_log.go +290 -0
  65. package/govendor/github.com/andybalholm/brotli/find_match_length.go +45 -0
  66. package/govendor/github.com/andybalholm/brotli/go.mod +3 -0
  67. package/govendor/github.com/andybalholm/brotli/h10.go +287 -0
  68. package/govendor/github.com/andybalholm/brotli/h5.go +214 -0
  69. package/govendor/github.com/andybalholm/brotli/h6.go +216 -0
  70. package/govendor/github.com/andybalholm/brotli/hash.go +342 -0
  71. package/govendor/github.com/andybalholm/brotli/hash_composite.go +93 -0
  72. package/govendor/github.com/andybalholm/brotli/hash_forgetful_chain.go +252 -0
  73. package/govendor/github.com/andybalholm/brotli/hash_longest_match_quickly.go +214 -0
  74. package/govendor/github.com/andybalholm/brotli/hash_rolling.go +168 -0
  75. package/govendor/github.com/andybalholm/brotli/histogram.go +226 -0
  76. package/govendor/github.com/andybalholm/brotli/http.go +201 -0
  77. package/govendor/github.com/andybalholm/brotli/huffman.go +653 -0
  78. package/govendor/github.com/andybalholm/brotli/literal_cost.go +182 -0
  79. package/govendor/github.com/andybalholm/brotli/matchfinder/bargain1.go +212 -0
  80. package/govendor/github.com/andybalholm/brotli/matchfinder/bargain2.go +248 -0
  81. package/govendor/github.com/andybalholm/brotli/matchfinder/bargain3.go +278 -0
  82. package/govendor/github.com/andybalholm/brotli/matchfinder/emitter.go +34 -0
  83. package/govendor/github.com/andybalholm/brotli/matchfinder/m0.go +175 -0
  84. package/govendor/github.com/andybalholm/brotli/matchfinder/m4.go +339 -0
  85. package/govendor/github.com/andybalholm/brotli/matchfinder/matchfinder.go +103 -0
  86. package/govendor/github.com/andybalholm/brotli/matchfinder/pathfinder.go +328 -0
  87. package/govendor/github.com/andybalholm/brotli/matchfinder/textencoder.go +53 -0
  88. package/govendor/github.com/andybalholm/brotli/matchfinder/trio.go +327 -0
  89. package/govendor/github.com/andybalholm/brotli/matchfinder/zdfast.go +258 -0
  90. package/govendor/github.com/andybalholm/brotli/matchfinder/zfast.go +206 -0
  91. package/govendor/github.com/andybalholm/brotli/matchfinder/zm.go +302 -0
  92. package/govendor/github.com/andybalholm/brotli/memory.go +66 -0
  93. package/govendor/github.com/andybalholm/brotli/metablock.go +574 -0
  94. package/govendor/github.com/andybalholm/brotli/metablock_command.go +165 -0
  95. package/govendor/github.com/andybalholm/brotli/metablock_distance.go +165 -0
  96. package/govendor/github.com/andybalholm/brotli/metablock_literal.go +165 -0
  97. package/govendor/github.com/andybalholm/brotli/params.go +37 -0
  98. package/govendor/github.com/andybalholm/brotli/platform.go +103 -0
  99. package/govendor/github.com/andybalholm/brotli/prefix.go +30 -0
  100. package/govendor/github.com/andybalholm/brotli/prefix_dec.go +723 -0
  101. package/govendor/github.com/andybalholm/brotli/quality.go +196 -0
  102. package/govendor/github.com/andybalholm/brotli/reader.go +127 -0
  103. package/govendor/github.com/andybalholm/brotli/ringbuffer.go +134 -0
  104. package/govendor/github.com/andybalholm/brotli/state.go +313 -0
  105. package/govendor/github.com/andybalholm/brotli/static_dict.go +662 -0
  106. package/govendor/github.com/andybalholm/brotli/static_dict_lut.go +75094 -0
  107. package/govendor/github.com/andybalholm/brotli/symbol_list.go +22 -0
  108. package/govendor/github.com/andybalholm/brotli/transform.go +641 -0
  109. package/govendor/github.com/andybalholm/brotli/utf8_util.go +70 -0
  110. package/govendor/github.com/andybalholm/brotli/util.go +7 -0
  111. package/govendor/github.com/andybalholm/brotli/write_bits.go +52 -0
  112. package/govendor/github.com/andybalholm/brotli/writer.go +162 -0
  113. package/govendor/github.com/fsnotify/fsnotify/.mailmap +2 -0
  114. package/govendor/github.com/fsnotify/fsnotify/CHANGELOG.md +651 -0
  115. package/govendor/github.com/fsnotify/fsnotify/CONTRIBUTING.md +147 -0
  116. package/govendor/github.com/fsnotify/fsnotify/LICENSE +25 -0
  117. package/govendor/github.com/fsnotify/fsnotify/README.md +214 -0
  118. package/govendor/github.com/fsnotify/fsnotify/backend_fen.go +469 -0
  119. package/govendor/github.com/fsnotify/fsnotify/backend_inotify.go +597 -0
  120. package/govendor/github.com/fsnotify/fsnotify/backend_kqueue.go +735 -0
  121. package/govendor/github.com/fsnotify/fsnotify/backend_other.go +22 -0
  122. package/govendor/github.com/fsnotify/fsnotify/backend_windows.go +702 -0
  123. package/govendor/github.com/fsnotify/fsnotify/fsnotify.go +526 -0
  124. package/govendor/github.com/fsnotify/fsnotify/go.mod +3 -0
  125. package/govendor/github.com/fsnotify/fsnotify/internal/darwin.go +20 -0
  126. package/govendor/github.com/fsnotify/fsnotify/internal/debug_darwin.go +15 -0
  127. package/govendor/github.com/fsnotify/fsnotify/internal/debug_dragonfly.go +15 -0
  128. package/govendor/github.com/fsnotify/fsnotify/internal/debug_freebsd.go +20 -0
  129. package/govendor/github.com/fsnotify/fsnotify/internal/debug_kqueue.go +32 -0
  130. package/govendor/github.com/fsnotify/fsnotify/internal/debug_linux.go +56 -0
  131. package/govendor/github.com/fsnotify/fsnotify/internal/debug_netbsd.go +15 -0
  132. package/govendor/github.com/fsnotify/fsnotify/internal/debug_openbsd.go +16 -0
  133. package/govendor/github.com/fsnotify/fsnotify/internal/debug_solaris.go +45 -0
  134. package/govendor/github.com/fsnotify/fsnotify/internal/debug_windows.go +40 -0
  135. package/govendor/github.com/fsnotify/fsnotify/internal/freebsd.go +20 -0
  136. package/govendor/github.com/fsnotify/fsnotify/internal/internal.go +2 -0
  137. package/govendor/github.com/fsnotify/fsnotify/internal/unix.go +20 -0
  138. package/govendor/github.com/fsnotify/fsnotify/internal/unix2.go +25 -0
  139. package/govendor/github.com/fsnotify/fsnotify/internal/windows.go +40 -0
  140. package/govendor/github.com/fsnotify/fsnotify/shared.go +64 -0
  141. package/govendor/github.com/fsnotify/fsnotify/staticcheck.conf +3 -0
  142. package/govendor/github.com/fsnotify/fsnotify/system_bsd.go +7 -0
  143. package/govendor/github.com/fsnotify/fsnotify/system_darwin.go +8 -0
  144. package/govendor/manifest.txt +3 -1
  145. package/package.json +1 -1
  146. package/types/typenative-npm.d.ts +72 -0
  147. 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), &copy_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
+ }