Qt 6.x
The Qt SDK
Loading...
Searching...
No Matches
huffman.cpp
Go to the documentation of this file.
1// Copyright (C) 2016 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4#include "bitstreams_p.h"
5#include "huffman_p.h"
6
7#include <QtCore/qbytearray.h>
8
9#include <algorithm>
10#include <limits>
11
12QT_BEGIN_NAMESPACE
13
14namespace HPack
15{
16
17/*
18 The static Huffman code used here was extracted from:
19 https://http2.github.io/http2-spec/compression.html#huffman.code
20
21 This code was generated from statistics obtained on a large
22 sample of HTTP headers. It is a canonical Huffman code
23 with some tweaking to ensure that no symbol has a unique
24 code length. All codes were left-aligned - for implementation
25 convenience.
26
27 Using binary trees to implement decoding would be prohibitively
28 expensive (both memory and time-wise). Instead we use a table-based
29 approach and any given code itself works as an index into such table(s).
30 We have 256 possible byte values and code lengths in
31 a range [5, 26]. This would require a huge table (and most of entries
32 would be 'wasted', since we only have to encode 256 elements).
33 Instead we use multi-level tables. The first level table
34 is using 9-bit length index; some entries in this table are 'terminal',
35 some reference the next level table(s).
36
37 For example, bytes with values 48 and 49 (ASCII codes for '0' and '1')
38 both have code length 5, Huffman codes are: 00000 and 00001. They
39 both are placed in the 'root' table,
40 the 'root' table has index length == 9:
41 [00000 | 4 remaining bits]
42 ...
43 [00001 | 4 remaining bits]
44
45 All entries with indices between these two will 'point' to value 48
46 with bitLength == 5 so that bit stream (for example) 000001010 will be
47 decoded as: 48 + "put 1010 back into bitstream".
48
49 A good description can be found here:
50 http://commandlinefanatic.com/cgi-bin/showarticle.cgi?article=art007
51 or just google "Efficient Huffman Decoding".
52 Also see comments below about 'filling holes'.
53*/
54
55namespace
56{
57
58const CodeEntry staticHuffmanCodeTable[]
59{
60 { 0, 0xffc00000ul, 13}, // 11111111|11000
61 { 1, 0xffffb000ul, 23}, // 11111111|11111111|1011000
62 { 2, 0xfffffe20ul, 28}, // 11111111|11111111|11111110|0010
63 { 3, 0xfffffe30ul, 28}, // 11111111|11111111|11111110|0011
64 { 4, 0xfffffe40ul, 28}, // 11111111|11111111|11111110|0100
65 { 5, 0xfffffe50ul, 28}, // 11111111|11111111|11111110|0101
66 { 6, 0xfffffe60ul, 28}, // 11111111|11111111|11111110|0110
67 { 7, 0xfffffe70ul, 28}, // 11111111|11111111|11111110|0111
68 { 8, 0xfffffe80ul, 28}, // 11111111|11111111|11111110|1000
69 { 9, 0xffffea00ul, 24}, // 11111111|11111111|11101010
70 { 10, 0xfffffff0ul, 30}, // 11111111|11111111|11111111|111100
71 { 11, 0xfffffe90ul, 28}, // 11111111|11111111|11111110|1001
72 { 12, 0xfffffea0ul, 28}, // 11111111|11111111|11111110|1010
73 { 13, 0xfffffff4ul, 30}, // 11111111|11111111|11111111|111101
74 { 14, 0xfffffeb0ul, 28}, // 11111111|11111111|11111110|1011
75 { 15, 0xfffffec0ul, 28}, // 11111111|11111111|11111110|1100
76 { 16, 0xfffffed0ul, 28}, // 11111111|11111111|11111110|1101
77 { 17, 0xfffffee0ul, 28}, // 11111111|11111111|11111110|1110
78 { 18, 0xfffffef0ul, 28}, // 11111111|11111111|11111110|1111
79 { 19, 0xffffff00ul, 28}, // 11111111|11111111|11111111|0000
80 { 20, 0xffffff10ul, 28}, // 11111111|11111111|11111111|0001
81 { 21, 0xffffff20ul, 28}, // 11111111|11111111|11111111|0010
82 { 22, 0xfffffff8ul, 30}, // 11111111|11111111|11111111|111110
83 { 23, 0xffffff30ul, 28}, // 11111111|11111111|11111111|0011
84 { 24, 0xffffff40ul, 28}, // 11111111|11111111|11111111|0100
85 { 25, 0xffffff50ul, 28}, // 11111111|11111111|11111111|0101
86 { 26, 0xffffff60ul, 28}, // 11111111|11111111|11111111|0110
87 { 27, 0xffffff70ul, 28}, // 11111111|11111111|11111111|0111
88 { 28, 0xffffff80ul, 28}, // 11111111|11111111|11111111|1000
89 { 29, 0xffffff90ul, 28}, // 11111111|11111111|11111111|1001
90 { 30, 0xffffffa0ul, 28}, // 11111111|11111111|11111111|1010
91 { 31, 0xffffffb0ul, 28}, // 11111111|11111111|11111111|1011
92 { 32, 0x50000000ul, 6}, // ' ' 010100
93 { 33, 0xfe000000ul, 10}, // '!' 11111110|00
94 { 34, 0xfe400000ul, 10}, // '"' 11111110|01
95 { 35, 0xffa00000ul, 12}, // '#' 11111111|1010
96 { 36, 0xffc80000ul, 13}, // '$' 11111111|11001
97 { 37, 0x54000000ul, 6}, // '%' 010101
98 { 38, 0xf8000000ul, 8}, // '&' 11111000
99 { 39, 0xff400000ul, 11}, // ''' 11111111|010
100 { 40, 0xfe800000ul, 10}, // '(' 11111110|10
101 { 41, 0xfec00000ul, 10}, // ')' 11111110|11
102 { 42, 0xf9000000ul, 8}, // '*' 11111001
103 { 43, 0xff600000ul, 11}, // '+' 11111111|011
104 { 44, 0xfa000000ul, 8}, // ',' 11111010
105 { 45, 0x58000000ul, 6}, // '-' 010110
106 { 46, 0x5c000000ul, 6}, // '.' 010111
107 { 47, 0x60000000ul, 6}, // '/' 011000
108 { 48, 0x00000000ul, 5}, // '0' 00000
109 { 49, 0x08000000ul, 5}, // '1' 00001
110 { 50, 0x10000000ul, 5}, // '2' 00010
111 { 51, 0x64000000ul, 6}, // '3' 011001
112 { 52, 0x68000000ul, 6}, // '4' 011010
113 { 53, 0x6c000000ul, 6}, // '5' 011011
114 { 54, 0x70000000ul, 6}, // '6' 011100
115 { 55, 0x74000000ul, 6}, // '7' 011101
116 { 56, 0x78000000ul, 6}, // '8' 011110
117 { 57, 0x7c000000ul, 6}, // '9' 011111
118 { 58, 0xb8000000ul, 7}, // ':' 1011100
119 { 59, 0xfb000000ul, 8}, // ';' 11111011
120 { 60, 0xfff80000ul, 15}, // '<' 11111111|1111100
121 { 61, 0x80000000ul, 6}, // '=' 100000
122 { 62, 0xffb00000ul, 12}, // '>' 11111111|1011
123 { 63, 0xff000000ul, 10}, // '?' 11111111|00
124 { 64, 0xffd00000ul, 13}, // '@' 11111111|11010
125 { 65, 0x84000000ul, 6}, // 'A' 100001
126 { 66, 0xba000000ul, 7}, // 'B' 1011101
127 { 67, 0xbc000000ul, 7}, // 'C' 1011110
128 { 68, 0xbe000000ul, 7}, // 'D' 1011111
129 { 69, 0xc0000000ul, 7}, // 'E' 1100000
130 { 70, 0xc2000000ul, 7}, // 'F' 1100001
131 { 71, 0xc4000000ul, 7}, // 'G' 1100010
132 { 72, 0xc6000000ul, 7}, // 'H' 1100011
133 { 73, 0xc8000000ul, 7}, // 'I' 1100100
134 { 74, 0xca000000ul, 7}, // 'J' 1100101
135 { 75, 0xcc000000ul, 7}, // 'K' 1100110
136 { 76, 0xce000000ul, 7}, // 'L' 1100111
137 { 77, 0xd0000000ul, 7}, // 'M' 1101000
138 { 78, 0xd2000000ul, 7}, // 'N' 1101001
139 { 79, 0xd4000000ul, 7}, // 'O' 1101010
140 { 80, 0xd6000000ul, 7}, // 'P' 1101011
141 { 81, 0xd8000000ul, 7}, // 'Q' 1101100
142 { 82, 0xda000000ul, 7}, // 'R' 1101101
143 { 83, 0xdc000000ul, 7}, // 'S' 1101110
144 { 84, 0xde000000ul, 7}, // 'T' 1101111
145 { 85, 0xe0000000ul, 7}, // 'U' 1110000
146 { 86, 0xe2000000ul, 7}, // 'V' 1110001
147 { 87, 0xe4000000ul, 7}, // 'W' 1110010
148 { 88, 0xfc000000ul, 8}, // 'X' 11111100
149 { 89, 0xe6000000ul, 7}, // 'Y' 1110011
150 { 90, 0xfd000000ul, 8}, // 'Z' 11111101
151 { 91, 0xffd80000ul, 13}, // '[' 11111111|11011
152 { 92, 0xfffe0000ul, 19}, // '\' 11111111|11111110|000
153 { 93, 0xffe00000ul, 13}, // ']' 11111111|11100
154 { 94, 0xfff00000ul, 14}, // '^' 11111111|111100
155 { 95, 0x88000000ul, 6}, // '_' 100010
156 { 96, 0xfffa0000ul, 15}, // '`' 11111111|1111101
157 { 97, 0x18000000ul, 5}, // 'a' 00011
158 { 98, 0x8c000000ul, 6}, // 'b' 100011
159 { 99, 0x20000000ul, 5}, // 'c' 00100
160 {100, 0x90000000ul, 6}, // 'd' 100100
161 {101, 0x28000000ul, 5}, // 'e' 00101
162 {102, 0x94000000ul, 6}, // 'f' 100101
163 {103, 0x98000000ul, 6}, // 'g' 100110
164 {104, 0x9c000000ul, 6}, // 'h' 100111
165 {105, 0x30000000ul, 5}, // 'i' 00110
166 {106, 0xe8000000ul, 7}, // 'j' 1110100
167 {107, 0xea000000ul, 7}, // 'k' 1110101
168 {108, 0xa0000000ul, 6}, // 'l' 101000
169 {109, 0xa4000000ul, 6}, // 'm' 101001
170 {110, 0xa8000000ul, 6}, // 'n' 101010
171 {111, 0x38000000ul, 5}, // 'o' 00111
172 {112, 0xac000000ul, 6}, // 'p' 101011
173 {113, 0xec000000ul, 7}, // 'q' 1110110
174 {114, 0xb0000000ul, 6}, // 'r' 101100
175 {115, 0x40000000ul, 5}, // 's' 01000
176 {116, 0x48000000ul, 5}, // 't' 01001
177 {117, 0xb4000000ul, 6}, // 'u' 101101
178 {118, 0xee000000ul, 7}, // 'v' 1110111
179 {119, 0xf0000000ul, 7}, // 'w' 1111000
180 {120, 0xf2000000ul, 7}, // 'x' 1111001
181 {121, 0xf4000000ul, 7}, // 'y' 1111010
182 {122, 0xf6000000ul, 7}, // 'z' 1111011
183 {123, 0xfffc0000ul, 15}, // '{' 11111111|1111110
184 {124, 0xff800000ul, 11}, // '|' 11111111|100
185 {125, 0xfff40000ul, 14}, // '}' 11111111|111101
186 {126, 0xffe80000ul, 13}, // '~' 11111111|11101
187 {127, 0xffffffc0ul, 28}, // 11111111|11111111|11111111|1100
188 {128, 0xfffe6000ul, 20}, // 11111111|11111110|0110
189 {129, 0xffff4800ul, 22}, // 11111111|11111111|010010
190 {130, 0xfffe7000ul, 20}, // 11111111|11111110|0111
191 {131, 0xfffe8000ul, 20}, // 11111111|11111110|1000
192 {132, 0xffff4c00ul, 22}, // 11111111|11111111|010011
193 {133, 0xffff5000ul, 22}, // 11111111|11111111|010100
194 {134, 0xffff5400ul, 22}, // 11111111|11111111|010101
195 {135, 0xffffb200ul, 23}, // 11111111|11111111|1011001
196 {136, 0xffff5800ul, 22}, // 11111111|11111111|010110
197 {137, 0xffffb400ul, 23}, // 11111111|11111111|1011010
198 {138, 0xffffb600ul, 23}, // 11111111|11111111|1011011
199 {139, 0xffffb800ul, 23}, // 11111111|11111111|1011100
200 {140, 0xffffba00ul, 23}, // 11111111|11111111|1011101
201 {141, 0xffffbc00ul, 23}, // 11111111|11111111|1011110
202 {142, 0xffffeb00ul, 24}, // 11111111|11111111|11101011
203 {143, 0xffffbe00ul, 23}, // 11111111|11111111|1011111
204 {144, 0xffffec00ul, 24}, // 11111111|11111111|11101100
205 {145, 0xffffed00ul, 24}, // 11111111|11111111|11101101
206 {146, 0xffff5c00ul, 22}, // 11111111|11111111|010111
207 {147, 0xffffc000ul, 23}, // 11111111|11111111|1100000
208 {148, 0xffffee00ul, 24}, // 11111111|11111111|11101110
209 {149, 0xffffc200ul, 23}, // 11111111|11111111|1100001
210 {150, 0xffffc400ul, 23}, // 11111111|11111111|1100010
211 {151, 0xffffc600ul, 23}, // 11111111|11111111|1100011
212 {152, 0xffffc800ul, 23}, // 11111111|11111111|1100100
213 {153, 0xfffee000ul, 21}, // 11111111|11111110|11100
214 {154, 0xffff6000ul, 22}, // 11111111|11111111|011000
215 {155, 0xffffca00ul, 23}, // 11111111|11111111|1100101
216 {156, 0xffff6400ul, 22}, // 11111111|11111111|011001
217 {157, 0xffffcc00ul, 23}, // 11111111|11111111|1100110
218 {158, 0xffffce00ul, 23}, // 11111111|11111111|1100111
219 {159, 0xffffef00ul, 24}, // 11111111|11111111|11101111
220 {160, 0xffff6800ul, 22}, // 11111111|11111111|011010
221 {161, 0xfffee800ul, 21}, // 11111111|11111110|11101
222 {162, 0xfffe9000ul, 20}, // 11111111|11111110|1001
223 {163, 0xffff6c00ul, 22}, // 11111111|11111111|011011
224 {164, 0xffff7000ul, 22}, // 11111111|11111111|011100
225 {165, 0xffffd000ul, 23}, // 11111111|11111111|1101000
226 {166, 0xffffd200ul, 23}, // 11111111|11111111|1101001
227 {167, 0xfffef000ul, 21}, // 11111111|11111110|11110
228 {168, 0xffffd400ul, 23}, // 11111111|11111111|1101010
229 {169, 0xffff7400ul, 22}, // 11111111|11111111|011101
230 {170, 0xffff7800ul, 22}, // 11111111|11111111|011110
231 {171, 0xfffff000ul, 24}, // 11111111|11111111|11110000
232 {172, 0xfffef800ul, 21}, // 11111111|11111110|11111
233 {173, 0xffff7c00ul, 22}, // 11111111|11111111|011111
234 {174, 0xffffd600ul, 23}, // 11111111|11111111|1101011
235 {175, 0xffffd800ul, 23}, // 11111111|11111111|1101100
236 {176, 0xffff0000ul, 21}, // 11111111|11111111|00000
237 {177, 0xffff0800ul, 21}, // 11111111|11111111|00001
238 {178, 0xffff8000ul, 22}, // 11111111|11111111|100000
239 {179, 0xffff1000ul, 21}, // 11111111|11111111|00010
240 {180, 0xffffda00ul, 23}, // 11111111|11111111|1101101
241 {181, 0xffff8400ul, 22}, // 11111111|11111111|100001
242 {182, 0xffffdc00ul, 23}, // 11111111|11111111|1101110
243 {183, 0xffffde00ul, 23}, // 11111111|11111111|1101111
244 {184, 0xfffea000ul, 20}, // 11111111|11111110|1010
245 {185, 0xffff8800ul, 22}, // 11111111|11111111|100010
246 {186, 0xffff8c00ul, 22}, // 11111111|11111111|100011
247 {187, 0xffff9000ul, 22}, // 11111111|11111111|100100
248 {188, 0xffffe000ul, 23}, // 11111111|11111111|1110000
249 {189, 0xffff9400ul, 22}, // 11111111|11111111|100101
250 {190, 0xffff9800ul, 22}, // 11111111|11111111|100110
251 {191, 0xffffe200ul, 23}, // 11111111|11111111|1110001
252 {192, 0xfffff800ul, 26}, // 11111111|11111111|11111000|00
253 {193, 0xfffff840ul, 26}, // 11111111|11111111|11111000|01
254 {194, 0xfffeb000ul, 20}, // 11111111|11111110|1011
255 {195, 0xfffe2000ul, 19}, // 11111111|11111110|001
256 {196, 0xffff9c00ul, 22}, // 11111111|11111111|100111
257 {197, 0xffffe400ul, 23}, // 11111111|11111111|1110010
258 {198, 0xffffa000ul, 22}, // 11111111|11111111|101000
259 {199, 0xfffff600ul, 25}, // 11111111|11111111|11110110|0
260 {200, 0xfffff880ul, 26}, // 11111111|11111111|11111000|10
261 {201, 0xfffff8c0ul, 26}, // 11111111|11111111|11111000|11
262 {202, 0xfffff900ul, 26}, // 11111111|11111111|11111001|00
263 {203, 0xfffffbc0ul, 27}, // 11111111|11111111|11111011|110
264 {204, 0xfffffbe0ul, 27}, // 11111111|11111111|11111011|111
265 {205, 0xfffff940ul, 26}, // 11111111|11111111|11111001|01
266 {206, 0xfffff100ul, 24}, // 11111111|11111111|11110001
267 {207, 0xfffff680ul, 25}, // 11111111|11111111|11110110|1
268 {208, 0xfffe4000ul, 19}, // 11111111|11111110|010
269 {209, 0xffff1800ul, 21}, // 11111111|11111111|00011
270 {210, 0xfffff980ul, 26}, // 11111111|11111111|11111001|10
271 {211, 0xfffffc00ul, 27}, // 11111111|11111111|11111100|000
272 {212, 0xfffffc20ul, 27}, // 11111111|11111111|11111100|001
273 {213, 0xfffff9c0ul, 26}, // 11111111|11111111|11111001|11
274 {214, 0xfffffc40ul, 27}, // 11111111|11111111|11111100|010
275 {215, 0xfffff200ul, 24}, // 11111111|11111111|11110010
276 {216, 0xffff2000ul, 21}, // 11111111|11111111|00100
277 {217, 0xffff2800ul, 21}, // 11111111|11111111|00101
278 {218, 0xfffffa00ul, 26}, // 11111111|11111111|11111010|00
279 {219, 0xfffffa40ul, 26}, // 11111111|11111111|11111010|01
280 {220, 0xffffffd0ul, 28}, // 11111111|11111111|11111111|1101
281 {221, 0xfffffc60ul, 27}, // 11111111|11111111|11111100|011
282 {222, 0xfffffc80ul, 27}, // 11111111|11111111|11111100|100
283 {223, 0xfffffca0ul, 27}, // 11111111|11111111|11111100|101
284 {224, 0xfffec000ul, 20}, // 11111111|11111110|1100
285 {225, 0xfffff300ul, 24}, // 11111111|11111111|11110011
286 {226, 0xfffed000ul, 20}, // 11111111|11111110|1101
287 {227, 0xffff3000ul, 21}, // 11111111|11111111|00110
288 {228, 0xffffa400ul, 22}, // 11111111|11111111|101001
289 {229, 0xffff3800ul, 21}, // 11111111|11111111|00111
290 {230, 0xffff4000ul, 21}, // 11111111|11111111|01000
291 {231, 0xffffe600ul, 23}, // 11111111|11111111|1110011
292 {232, 0xffffa800ul, 22}, // 11111111|11111111|101010
293 {233, 0xffffac00ul, 22}, // 11111111|11111111|101011
294 {234, 0xfffff700ul, 25}, // 11111111|11111111|11110111|0
295 {235, 0xfffff780ul, 25}, // 11111111|11111111|11110111|1
296 {236, 0xfffff400ul, 24}, // 11111111|11111111|11110100
297 {237, 0xfffff500ul, 24}, // 11111111|11111111|11110101
298 {238, 0xfffffa80ul, 26}, // 11111111|11111111|11111010|10
299 {239, 0xffffe800ul, 23}, // 11111111|11111111|1110100
300 {240, 0xfffffac0ul, 26}, // 11111111|11111111|11111010|11
301 {241, 0xfffffcc0ul, 27}, // 11111111|11111111|11111100|110
302 {242, 0xfffffb00ul, 26}, // 11111111|11111111|11111011|00
303 {243, 0xfffffb40ul, 26}, // 11111111|11111111|11111011|01
304 {244, 0xfffffce0ul, 27}, // 11111111|11111111|11111100|111
305 {245, 0xfffffd00ul, 27}, // 11111111|11111111|11111101|000
306 {246, 0xfffffd20ul, 27}, // 11111111|11111111|11111101|001
307 {247, 0xfffffd40ul, 27}, // 11111111|11111111|11111101|010
308 {248, 0xfffffd60ul, 27}, // 11111111|11111111|11111101|011
309 {249, 0xffffffe0ul, 28}, // 11111111|11111111|11111111|1110
310 {250, 0xfffffd80ul, 27}, // 11111111|11111111|11111101|100
311 {251, 0xfffffda0ul, 27}, // 11111111|11111111|11111101|101
312 {252, 0xfffffdc0ul, 27}, // 11111111|11111111|11111101|110
313 {253, 0xfffffde0ul, 27}, // 11111111|11111111|11111101|111
314 {254, 0xfffffe00ul, 27}, // 11111111|11111111|11111110|000
315 {255, 0xfffffb80ul, 26}, // 11111111|11111111|11111011|10
316 {256, 0xfffffffcul, 30} // EOS 11111111|11111111|11111111|111111
317};
318
319void write_huffman_code(BitOStream &outputStream, const CodeEntry &code)
320{
321 // Append octet by octet.
322 auto bitLength = code.bitLength;
323 const auto hc = code.huffmanCode >> (32 - bitLength);
324
325 if (bitLength > 24) {
326 outputStream.writeBits(uchar(hc >> 24), bitLength - 24);
327 bitLength = 24;
328 }
329
330 if (bitLength > 16) {
331 outputStream.writeBits(uchar(hc >> 16), bitLength - 16);
332 bitLength = 16;
333 }
334
335 if (bitLength > 8) {
336 outputStream.writeBits(uchar(hc >> 8), bitLength - 8);
337 bitLength = 8;
338 }
339
340 outputStream.writeBits(uchar(hc), bitLength);
341}
342
343}
344
345// That's from HPACK's specs - we deal with octets.
346static_assert(std::numeric_limits<uchar>::digits == 8, "octets expected");
347
348quint64 huffman_encoded_bit_length(QByteArrayView inputData)
349{
350 quint64 bitLength = 0;
351 for (int i = 0, e = inputData.size(); i < e; ++i)
352 bitLength += staticHuffmanCodeTable[int(inputData[i])].bitLength;
353
354 return bitLength;
355}
356
357void huffman_encode_string(QByteArrayView inputData, BitOStream &outputStream)
358{
359 for (int i = 0, e = inputData.size(); i < e; ++i) {
360 const auto value = uchar(inputData[i]);
361 write_huffman_code(outputStream, staticHuffmanCodeTable[value]);
362 }
363
364 // Pad bits ...
365 if (outputStream.bitLength() % 8)
366 outputStream.writeBits(0xff, 8 - outputStream.bitLength() % 8);
367}
368
369static constexpr
370bool padding_is_valid(quint32 chunk, quint32 nBits)
371{
372 Q_ASSERT(nBits);
373
374 // HPACK, 5.2: "A padding strictly longer than 7 bits MUST be
375 // treated as a decoding error."
376 if (nBits > 7)
377 return false;
378 // HPACK, 5.2:
379 // "A padding not corresponding to the most significant bits
380 // of the code for the EOS symbol MUST be treated as a decoding error."
381 return (chunk >> (32 - nBits)) == quint32((1 << nBits) - 1);
382}
383
384HuffmanDecoder::HuffmanDecoder()
385 : minCodeLength()
386{
387 const auto nCodes = sizeof staticHuffmanCodeTable / sizeof staticHuffmanCodeTable[0];
388
389 std::vector<CodeEntry> symbols(staticHuffmanCodeTable, staticHuffmanCodeTable + nCodes);
390 // Now we sort: by bit length first (in the descending order) and by the symbol
391 // value (descending). Descending order: to make sure we do not create prefix tables with
392 // short 'indexLength' first and having longer codes that do not fit into such tables later.
393 std::sort(symbols.begin(), symbols.end(), [](const CodeEntry &code1, const CodeEntry &code2) {
394 if (code1.bitLength == code2.bitLength)
395 return code1.byteValue > code2.byteValue;
396 return code1.bitLength > code2.bitLength;
397 });
398
399 minCodeLength = symbols.back().bitLength; // The shortest one, currently it's 5.
400
401 // TODO: add a verification - Huffman codes
402 // within a given bit length range also
403 // should be in descending order.
404
405 // Initialize 'prefixTables' and 'tableData'.
406 addTable(0, quint32(BitConstants::rootPrefix)); // 'root' table.
407
408 for (const auto &s : symbols) {
409 quint32 tableIndex = 0;
410 while (true) {
411 Q_ASSERT(tableIndex < prefixTables.size());
412 // Note, by value - since prefixTables will be updated in between.
413 const auto table = prefixTables[tableIndex];
414 // We skip prefixed bits (if any) and use indexed bits only:
415 const auto entryIndex = s.huffmanCode << table.prefixLength >> (32 - table.indexLength);
416 // Again, by value.
417 PrefixTableEntry entry = tableEntry(table, entryIndex);
418 // How many bits were coded by previous tables and this table:
419 const auto codedLength = table.prefixLength + table.indexLength;
420 if (codedLength < s.bitLength) {
421 // We have to add a new prefix table ... (if it's not done yet).
422 if (!entry.bitLength) {
423 entry.nextTable = addTable(codedLength, std::min<quint32>(quint32(BitConstants::childPrefix),
424 s.bitLength - codedLength));
425 entry.bitLength = s.bitLength;
426 entry.byteValue = s.byteValue;
427 setTableEntry(table, entryIndex, entry);
428 }
429 tableIndex = entry.nextTable;
430 } else {
431 // We found the slot for our code (terminal entry):
432 entry.byteValue = s.byteValue;
433 entry.bitLength = s.bitLength;
434 // Refer to our own table as 'nextTable':
435 entry.nextTable = tableIndex;
436 setTableEntry(table, entryIndex, entry);
437 break;
438 }
439 }
440 }
441
442 // Now, we have a table(s) and have to fill 'holes' to
443 // 'fix' terminal entries.
444 for (const auto &table : prefixTables) {
445 const quint32 codedLength = table.prefixLength + table.indexLength;
446 for (quint32 j = 0; j < table.size();) {
447 const PrefixTableEntry &entry = tableEntry(table, j);
448 if (entry.bitLength && entry.bitLength < codedLength) {
449 const quint32 range = 1 << (codedLength - entry.bitLength);
450 for (quint32 k = 1; k < range; ++k)
451 setTableEntry(table, j + k, entry);
452 j += range;
453 } else {
454 ++j;
455 }
456 }
457 }
458}
459
460bool HuffmanDecoder::decodeStream(BitIStream &inputStream, QByteArray &outputBuffer)
461{
462 while (true) {
463 quint32 chunk = 0;
464 const quint32 readBits = inputStream.peekBits(inputStream.streamOffset(), 32, &chunk);
465 if (!readBits)
466 return !inputStream.hasMoreBits();
467
468 if (readBits < minCodeLength) {
469 inputStream.skipBits(readBits);
470 return padding_is_valid(chunk, readBits);
471 }
472
473 quint32 tableIndex = 0;
474 const PrefixTable *table = &prefixTables[tableIndex];
475 quint32 entryIndex = chunk >> (32 - table->indexLength);
476 PrefixTableEntry entry = tableEntry(*table, entryIndex);
477
478 while (true) {
479 if (entry.nextTable == tableIndex)
480 break;
481
482 tableIndex = entry.nextTable;
483 table = &prefixTables[tableIndex];
484 entryIndex = chunk << table->prefixLength >> (32 - table->indexLength);
485 entry = tableEntry(*table, entryIndex);
486 }
487
488 if (entry.bitLength > readBits) {
489 inputStream.skipBits(readBits);
490 return padding_is_valid(chunk, readBits);
491 }
492
493 if (!entry.bitLength || entry.byteValue == 256) {
494 //EOS (256) == compression error (HPACK).
495 inputStream.skipBits(readBits);
496 return false;
497 }
498
499 outputBuffer.append(entry.byteValue);
500 inputStream.skipBits(entry.bitLength);
501 }
502
503 return false;
504}
505
506quint32 HuffmanDecoder::addTable(quint32 prefix, quint32 index)
507{
508 PrefixTable newTable{prefix, index};
509 newTable.offset = quint32(tableData.size());
510 prefixTables.push_back(newTable);
511 // Add entries for this table:
512 tableData.resize(tableData.size() + newTable.size());
513
514 return quint32(prefixTables.size() - 1);
515}
516
517PrefixTableEntry HuffmanDecoder::tableEntry(const PrefixTable &table, quint32 index)
518{
519 Q_ASSERT(index < table.size());
520 return tableData[table.offset + index];
521}
522
523void HuffmanDecoder::setTableEntry(const PrefixTable &table, quint32 index,
524 const PrefixTableEntry &entry)
525{
526 Q_ASSERT(index < table.size());
527 tableData[table.offset + index] = entry;
528}
529
530bool huffman_decode_string(BitIStream &inputStream, QByteArray *outputBuffer)
531{
532 Q_ASSERT(outputBuffer);
533
534 static HuffmanDecoder decoder;
535 return decoder.decodeStream(inputStream, *outputBuffer);
536}
537
538}
539
540QT_END_NAMESPACE
bitstreams_p.h
HPack::BitIStream::hasMoreBits
bool hasMoreBits() const
Definition bitstreams.cpp:135
HPack::BitIStream::skipBits
bool skipBits(quint64 nBits)
Definition bitstreams.cpp:140
HPack::BitIStream::streamOffset
quint64 streamOffset() const
Definition bitstreams_p.h:123
HPack::BitIStream::peekBits
quint64 peekBits(quint64 from, quint64 length, T *dstPtr) const
Definition bitstreams_p.h:93
HPack::BitOStream::writeBits
void writeBits(uchar bits, quint8 bitLength)
Definition bitstreams.cpp:25
HPack::BitOStream::bitLength
quint64 bitLength() const
Definition bitstreams.cpp:88
HPack::HuffmanDecoder::decodeStream
bool decodeStream(BitIStream &inputStream, QByteArray &outputBuffer)
Definition huffman.cpp:460
QByteArrayView::size
constexpr qsizetype size() const noexcept
Definition qbytearrayview.h:178
QByteArray
\inmodule QtCore
Definition qbytearray.h:57
QByteArray::append
QByteArray & append(char c)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition qbytearray.cpp:2099
j
int j
Definition doc_src_containers.cpp:273
i
i
[1]
Definition doc_src_containers.cpp:167
e
double e
Definition doc_src_qalgorithms.cpp:6
huffman_p.h
HPack::huffman_encoded_bit_length
quint64 huffman_encoded_bit_length(QByteArrayView inputData)
Definition huffman.cpp:348
HPack::padding_is_valid
static constexpr bool padding_is_valid(quint32 chunk, quint32 nBits)
Definition huffman.cpp:370
HPack::huffman_decode_string
bool huffman_decode_string(BitIStream &inputStream, QByteArray *outputBuffer)
Definition huffman.cpp:530
HPack::huffman_encode_string
void huffman_encode_string(QByteArrayView inputData, BitOStream &outputStream)
Definition huffman.cpp:357
QT_BEGIN_NAMESPACE
Combined button and popup list for selecting options.
Definition qstandardpaths_haiku.cpp:21
QT_END_NAMESPACE
Definition qsharedpointer.cpp:1545
src_gui_qopenglshaderprogram::code
QString code
Definition src_gui_qopenglshaderprogram.cpp:8
value
EGLOutputLayerEXT EGLint EGLAttrib value
[5]
Definition qeglstreamconvenience_p.h:46
index
GLuint index
[2]
Definition qopengles2ext.h:331
range
GLsizei range
Definition qopengles2ext.h:3162
entry
GLuint entry
Definition qopenglext.h:11002
s
GLdouble s
[6]
Definition qopenglext.h:235
table
GLenum GLenum GLsizei void * table
Definition qopenglext.h:2745
Q_ASSERT
#define Q_ASSERT(cond)
Definition qrandom.cpp:47
quint32
unsigned int quint32
Definition qtypes.h:45
uchar
unsigned char uchar
Definition qtypes.h:27
quint64
unsigned long long quint64
Definition qtypes.h:56