Overview
Comment: | OFInflate64Stream: Don't subclass OFInflateStream |
---|---|
Downloads: | Tarball | ZIP archive | SQL archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA3-256: |
1b5d3ac8afde8e6716fdd7b82865f31a |
User & Date: | js on 2018-06-09 14:36:43 |
Other Links: | manifest | tags |
Context
2018-06-09
| ||
16:30 | OFObject: Change one #else to #elif check-in: 745d514023 user: js tags: trunk | |
14:36 | OFInflate64Stream: Don't subclass OFInflateStream check-in: 1b5d3ac8af user: js tags: trunk | |
2018-06-06
| ||
21:55 | Deflate & LHA: Return buffer to stream on close check-in: fd9801229f user: js tags: trunk | |
Changes
Modified src/OFInflate64Stream.h from [c7424bfa54] to [a6347e111a].
︙ | ︙ | |||
11 12 13 14 15 16 17 | * * Alternatively, it may be distributed under the terms of the GNU General * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ | | > > > > > > | | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 | * * Alternatively, it may be distributed under the terms of the GNU General * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFStream.h" #import "OFKernelEventObserver.h" OF_ASSUME_NONNULL_BEGIN #define OF_INFLATE64_STREAM_BUFFER_SIZE 4096 /*! * @class OFInflate64Stream OFInflate64Stream.h ObjFW/OFInflate64Stream.h * * @note This class only conforms to OFReadyForReadingObserving if the * underlying stream does so, too. * * @brief A class that handles Deflate decompression transparently for an * underlying stream. */ @interface OFInflate64Stream: OFStream <OFReadyForReadingObserving> { #ifdef OF_INFLATE64_STREAM_M @public #endif OF_KINDOF(OFStream *) _stream; unsigned char _buffer[OF_INFLATE64_STREAM_BUFFER_SIZE]; uint16_t _bufferIndex, _bufferLength; uint8_t _byte; uint8_t _bitIndex, _savedBitsLength; uint16_t _savedBits; unsigned char *_Nullable _slidingWindow; uint16_t _slidingWindowIndex, _slidingWindowMask; int _state; union { struct { uint8_t position; uint8_t length[4]; } uncompressedHeader; struct { uint16_t position, length; } uncompressed; struct { struct of_huffman_tree *_Nullable litLenTree; struct of_huffman_tree *_Nullable distTree; struct of_huffman_tree *_Nullable codeLenTree; struct of_huffman_tree *_Nullable treeIter; uint8_t *_Nullable lengths; uint16_t receivedCount; uint8_t value, litLenCodesCount, distCodesCount; uint8_t codeLenCodesCount; } huffmanTree; struct { struct of_huffman_tree *_Nullable litLenTree; struct of_huffman_tree *_Nullable distTree; struct of_huffman_tree *_Nullable treeIter; int state; uint16_t value, length, distance, extraBits; } huffman; } _context; bool _inLastBlock, _atEndOfStream; } /*! * @brief Creates a new OFInflate64Stream with the specified underlying stream. * * @param stream The underlying stream to which compressed data is written or * from which compressed data is read * @return A new, autoreleased OFInflate64Stream */ + (instancetype)streamWithStream: (OFStream *)stream; - (instancetype)init OF_UNAVAILABLE; /*! * @brief Initializes an already allocated OFInflate64Stream with the specified * underlying stream. * * @param stream The underlying stream to which compressed data is written or * from which compressed data is read * @return A initialized OFInflate64Stream */ - (instancetype)initWithStream: (OFStream *)stream OF_DESIGNATED_INITIALIZER; @end OF_ASSUME_NONNULL_END |
Modified src/OFInflate64Stream.m from [014d618e07] to [619b82e83f].
︙ | ︙ | |||
11 12 13 14 15 16 17 | * * Alternatively, it may be distributed under the terms of the GNU General * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ | | | 11 12 13 14 15 16 17 18 19 | * * Alternatively, it may be distributed under the terms of the GNU General * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #define OF_INFLATE64_STREAM_M #include "OFInflateStream.m" |
Modified src/OFInflateStream.m from [e6df60b73e] to [84940553dd].
︙ | ︙ | |||
20 21 22 23 24 25 26 | #include "config.h" #include <stdlib.h> #include <string.h> #include <assert.h> | | > | > > > | | 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 | #include "config.h" #include <stdlib.h> #include <string.h> #include <assert.h> #ifndef OF_INFLATE64_STREAM_M # import "OFInflateStream.h" #else # import "OFInflate64Stream.h" # define OFInflateStream OFInflate64Stream #endif #import "huffman_tree.h" #import "OFInitializationFailedException.h" #import "OFInvalidFormatException.h" #import "OFNotOpenException.h" #import "OFOutOfMemoryException.h" #ifndef OF_INFLATE64_STREAM_M # define BUFFER_SIZE OF_INFLATE_STREAM_BUFFER_SIZE #else # define BUFFER_SIZE OF_INFLATE64_STREAM_BUFFER_SIZE #endif enum state { BLOCK_HEADER, UNCOMPRESSED_BLOCK_HEADER, UNCOMPRESSED_BLOCK, HUFFMAN_TREE, HUFFMAN_BLOCK }; enum huffman_state { WRITE_VALUE, AWAIT_CODE, AWAIT_LENGTH_EXTRA_BITS, AWAIT_DISTANCE, AWAIT_DISTANCE_EXTRA_BITS, PROCESS_PAIR }; #ifndef OF_INFLATE64_STREAM_M static const uint8_t numDistanceCodes = 30; static const uint8_t lengthCodes[29] = { /* indices are -257, values -3 */ 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 255 }; static const uint8_t lengthExtraBits[29] = { |
︙ | ︙ | |||
164 165 166 167 168 169 170 | for (uint16_t i = 0; i <= 31; i++) lengths[i] = 5; fixedDistTree = of_huffman_tree_construct(lengths, 32); } | < | | 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 | for (uint16_t i = 0; i <= 31; i++) lengths[i] = 5; fixedDistTree = of_huffman_tree_construct(lengths, 32); } + (instancetype)streamWithStream: (OFStream *)stream { return [[[self alloc] initWithStream: stream] autorelease]; } - (instancetype)init { OF_INVALID_INIT_METHOD } - (instancetype)initWithStream: (OFStream *)stream { self = [super init]; @try { _stream = [stream retain]; /* 0-7 address the bit, 8 means fetch next byte */ _bitIndex = 8; #ifdef OF_INFLATE64_STREAM_M _slidingWindowMask = 0xFFFF; #else _slidingWindowMask = 0x7FFF; #endif _slidingWindow = [self allocZeroedMemoryWithSize: _slidingWindowMask + 1]; } @catch (id e) { |
︙ | ︙ | |||
218 219 220 221 222 223 224 | of_huffman_tree_release(_context.huffman.litLenTree); if (_context.huffman.distTree != fixedDistTree) of_huffman_tree_release(_context.huffman.distTree); } [super dealloc]; } | < | 221 222 223 224 225 226 227 228 229 230 231 232 233 234 | of_huffman_tree_release(_context.huffman.litLenTree); if (_context.huffman.distTree != fixedDistTree) of_huffman_tree_release(_context.huffman.distTree); } [super dealloc]; } - (size_t)lowlevelReadIntoBuffer: (void *)buffer_ length: (size_t)length { unsigned char *buffer = buffer_; uint16_t bits, tmp, value; size_t bytesWritten = 0; |
︙ | ︙ | |||
652 653 654 655 656 657 658 | break; #undef CTX } OF_UNREACHABLE } | < < | 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 | break; #undef CTX } OF_UNREACHABLE } - (bool)lowlevelIsAtEndOfStream { if (_stream == nil) @throw [OFNotOpenException exceptionWithObject: self]; return _atEndOfStream; } - (int)fileDescriptorForReading { return [_stream fileDescriptorForReading]; } - (bool)hasDataInReadBuffer { return ([super hasDataInReadBuffer] || [_stream hasDataInReadBuffer]); } - (void)close { /* Give back our buffer to the stream, in case it's shared */ [_stream unreadFromBuffer: _buffer + _bufferIndex length: _bufferLength - _bufferIndex]; _bufferIndex = _bufferLength = 0; |
︙ | ︙ |