Differences From Artifact [47e2756e95]:
- File
src/OFInflateStream.m
— part of check-in
[d3158d091f]
at
2016-01-05 22:00:03
on branch trunk
— (u)int_fast*_t -> (u)int*_t
(U)INT_FAST*_MAX is broken on Android, which makes (u)int_fast*_t
dangerous to use while it does not provide any real speed benefit. (user: js, size: 18741) [annotate] [blame] [check-ins using]
To Artifact [c913b5050c]:
- File src/OFInflateStream.m — part of check-in [e0b9167693] at 2016-02-21 15:37:42 on branch trunk — Make use of C99-style for loops (user: js, size: 18800) [annotate] [blame] [check-ins using]
| ︙ | ︙ | |||
104 105 106 107 108 109 110 |
};
static struct huffman_tree *fixedLitLenTree, *fixedDistTree;
static bool
tryReadBits(OFInflateStream *stream, uint16_t *bits, uint8_t count)
{
uint16_t ret = stream->_savedBits;
| < | | 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 |
};
static struct huffman_tree *fixedLitLenTree, *fixedDistTree;
static bool
tryReadBits(OFInflateStream *stream, uint16_t *bits, uint8_t count)
{
uint16_t ret = stream->_savedBits;
assert(stream->_savedBitsLength < count);
for (uint8_t i = stream->_savedBitsLength; i < count; i++) {
if OF_UNLIKELY (stream->_bitIndex == 8) {
if (stream->_bufferIndex < stream->_bufferLength)
stream->_byte =
stream->_buffer[stream->_bufferIndex++];
else {
size_t length = [stream->_stream
readIntoBuffer: stream->_buffer
|
| ︙ | ︙ | |||
182 183 184 185 186 187 188 |
static struct huffman_tree*
constructTree(uint8_t lengths[], uint16_t count)
{
struct huffman_tree *tree;
uint16_t lengthCount[MAX_BITS + 1] = { 0 };
uint16_t code, maxCode = 0, nextCode[MAX_BITS + 1];
| < | | | | 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 |
static struct huffman_tree*
constructTree(uint8_t lengths[], uint16_t count)
{
struct huffman_tree *tree;
uint16_t lengthCount[MAX_BITS + 1] = { 0 };
uint16_t code, maxCode = 0, nextCode[MAX_BITS + 1];
for (uint16_t i = 0; i < count; i++) {
uint8_t length = lengths[i];
if OF_UNLIKELY (length > MAX_BITS)
@throw [OFInvalidFormatException exception];
if (length > 0) {
lengthCount[length]++;
maxCode = i;
}
}
code = 0;
for (size_t i = 1; i <= MAX_BITS; i++) {
code = (code + lengthCount[i - 1]) << 1;
nextCode[i] = code;
}
tree = newTree();
for (uint16_t i = 0; i <= maxCode; i++) {
uint8_t length = lengths[i];
if (length > 0)
treeInsert(tree, nextCode[length]++, length, i);
}
return tree;
|
| ︙ | ︙ | |||
239 240 241 242 243 244 245 |
*value = iter->value;
return true;
}
static void
releaseTree(struct huffman_tree *tree)
{
| < < | < | | | | | | 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 |
*value = iter->value;
return true;
}
static void
releaseTree(struct huffman_tree *tree)
{
for (uint8_t i = 0; i < 2; i++)
if OF_LIKELY (tree->leafs[i] != NULL)
releaseTree(tree->leafs[i]);
free(tree);
}
@implementation OFInflateStream
+ (void)initialize
{
uint8_t lengths[288];
if (self != [OFInflateStream class])
return;
for (uint16_t i = 0; i <= 143; i++)
lengths[i] = 8;
for (uint16_t i = 144; i <= 255; i++)
lengths[i] = 9;
for (uint16_t i = 256; i <= 279; i++)
lengths[i] = 7;
for (uint16_t i = 280; i <= 287; i++)
lengths[i] = 8;
fixedLitLenTree = constructTree(lengths, 288);
for (uint16_t i = 0; i <= 31; i++)
lengths[i] = 5;
fixedDistTree = constructTree(lengths, 32);
}
#ifndef DEFLATE64
+ (instancetype)streamWithStream: (OFStream*)stream
|
| ︙ | ︙ | |||
308 309 310 311 312 313 314 |
}
#endif
- (size_t)lowlevelReadIntoBuffer: (void*)buffer_
length: (size_t)length
{
uint8_t *buffer = buffer_;
| | | 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 |
}
#endif
- (size_t)lowlevelReadIntoBuffer: (void*)buffer_
length: (size_t)length
{
uint8_t *buffer = buffer_;
uint16_t bits, tmp;
uint16_t value;
size_t bytesWritten = 0;
uint8_t *slidingWindow;
uint16_t slidingWindowIndex;
if (_atEndOfStream)
@throw [OFReadFailedException exceptionWithObject: self
|
| ︙ | ︙ | |||
413 414 415 416 417 418 419 | [self allocMemoryWithSize: _slidingWindowMask + 1]; /* Avoid leaking data */ memset(_slidingWindow, 0, _slidingWindowMask + 1); } slidingWindow = _slidingWindow; slidingWindowIndex = _slidingWindowIndex; | | | 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 |
[self allocMemoryWithSize: _slidingWindowMask + 1];
/* Avoid leaking data */
memset(_slidingWindow, 0, _slidingWindowMask + 1);
}
slidingWindow = _slidingWindow;
slidingWindowIndex = _slidingWindowIndex;
for (uint16_t i = 0; i < tmp; i++) {
slidingWindow[slidingWindowIndex] =
buffer[bytesWritten + i];
slidingWindowIndex = (slidingWindowIndex + 1) &
_slidingWindowMask;
}
_slidingWindowIndex = slidingWindowIndex;
|
| ︙ | ︙ | |||
463 464 465 466 467 468 469 |
}
if OF_LIKELY (CTX.lengths == NULL) {
CTX.lengths = [self allocMemoryWithSize: 19];
memset(CTX.lengths, 0, 19);
}
| | | 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 |
}
if OF_LIKELY (CTX.lengths == NULL) {
CTX.lengths = [self allocMemoryWithSize: 19];
memset(CTX.lengths, 0, 19);
}
for (uint16_t i = CTX.receivedCount;
i < CTX.codeLenCodesCount + 4; i++) {
if OF_UNLIKELY (!tryReadBits(self, &bits, 3)) {
CTX.receivedCount = i;
return bytesWritten;
}
CTX.lengths[codeLengthsOrder[i]] = bits;
|
| ︙ | ︙ | |||
486 487 488 489 490 491 492 | CTX.value = 0xFF; } if OF_LIKELY (CTX.lengths == NULL) CTX.lengths = [self allocMemoryWithSize: CTX.litLenCodesCount + CTX.distCodesCount + 258]; | | | 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 |
CTX.value = 0xFF;
}
if OF_LIKELY (CTX.lengths == NULL)
CTX.lengths = [self allocMemoryWithSize:
CTX.litLenCodesCount + CTX.distCodesCount + 258];
for (uint16_t i = CTX.receivedCount;
i < CTX.litLenCodesCount + CTX.distCodesCount + 258;) {
uint8_t j, count;
if OF_LIKELY (CTX.value == 0xFF) {
if OF_UNLIKELY (!walkTree(self, &CTX.treeIter,
&value)) {
CTX.receivedCount = i;
|
| ︙ | ︙ |