From ee89f49100990256558d116a20999b4049560e72 Mon Sep 17 00:00:00 2001 From: nik Date: Sun, 2 Feb 2014 23:35:24 -0200 Subject: [PATCH] add deflate signatures --- lib/deflate.js | 50 ++++++++ lib/zlib/constants.js | 33 +++++ lib/zlib/deflate.js | 274 ++++++++++++++++++++++++++++++++++++++++++ lib/zlib/zstream.js | 24 ++++ 4 files changed, 381 insertions(+) create mode 100644 lib/deflate.js create mode 100644 lib/zlib/constants.js create mode 100644 lib/zlib/deflate.js create mode 100644 lib/zlib/zstream.js diff --git a/lib/deflate.js b/lib/deflate.js new file mode 100644 index 0000000..7ddb0b7 --- /dev/null +++ b/lib/deflate.js @@ -0,0 +1,50 @@ +var zlib = require('zlib/deflate.js'); +/** + * Deflate + * + * @param {Object} [options] zlib options + * @constructor + */ +var Deflate = function(options) { + +} + +/** + * Compresses the input data and fills output buffer with compressed data. + * @return {Array|Uint8Array} compressed data + */ +Deflate.prototype.deflate = function(input) { + +} + +Deflate.prototype.flush = function() { + +} + +Deflate.prototype.finish = function() { + +} + +Deflate.prototype.onData = function(output) { + +} + +Deflate.prototype.onEnd = function(error) { + +} + +exports.Deflate = Deflate; + +/** + * Compresses the input data + * @param input + * @param [options] + * @returns {Array|Uint8Array} + */ +exports.deflate = function(input, options) { + +} + +exports.deflateRaw = function(input, options) { + +} \ No newline at end of file diff --git a/lib/zlib/constants.js b/lib/zlib/constants.js new file mode 100644 index 0000000..5878714 --- /dev/null +++ b/lib/zlib/constants.js @@ -0,0 +1,33 @@ +module.exports = { + Z_NO_FLUSH: 0, + Z_PARTIAL_FLUSH: 1, + Z_SYNC_FLUSH: 2, + Z_FULL_FLUSH: 3, + Z_FINISH: 4, + Z_BLOCK: 5, + Z_TREES: 6, + + /* Allowed flush values; see deflate() and inflate() below for details */ + Z_OK: 0, + Z_STREAM_END: 1, + Z_NEED_DICT: 2, + Z_ERRNO: (-1), + Z_STREAM_ERROR: (-2), + Z_DATA_ERROR: (-3), + Z_MEM_ERROR: (-4), + Z_BUF_ERROR: (-5), + Z_VERSION_ERROR: (-6), + /* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ + Z_NO_COMPRESSION: 0, + Z_BEST_SPEED: 1, + Z_BEST_COMPRESSION: 9, + Z_DEFAULT_COMPRESSION: -1, + /* compression levels */ + Z_FILTERED: 1, + Z_HUFFMAN_ONLY: 2, + Z_RLE: 3, + Z_FIXED: 4, + Z_DEFAULT_STRATEGY: 0 +} \ No newline at end of file diff --git a/lib/zlib/deflate.js b/lib/zlib/deflate.js new file mode 100644 index 0000000..a3abded --- /dev/null +++ b/lib/zlib/deflate.js @@ -0,0 +1,274 @@ +var consts = require('constants'); + +function internal_state() { + this.status = 0; /* as the name implies */ + this.pending_buf = -1; /* output still pending */ + this.pending_buf_size = 0; /* size of pending_buf */ + this.pending_out = -1; /* next pending byte to output to the stream */ + this.pending = 0; /* nb of bytes in the pending buffer */ + this.last_flush = -1; /* value of flush param for previous deflate call */ + + this.w_size = 0; /* LZ77 window size (32K by default) */ + this.w_bits = 0; /* log2(w_size) (8..16) */ + this.w_mask = 0; /* w_size - 1 */ + + this.window = -1; + /* Sliding window. Input bytes are read into the second half of the window, + * and move to the first half later to keep a dictionary of at least wSize + * bytes. With this organization, matches are limited to a distance of + * wSize-MAX_MATCH bytes, but this ensures that IO is always + * performed with a length multiple of the block size. + */ + + this.window_size = 0; + /* Actual size of window: 2*wSize, except when the user input buffer + * is directly used as sliding window. + */ + + this.prev = -1; + /* Link to older string with same hash index. To limit the size of this + * array to 64K, this link is maintained only for the last 32K strings. + * An index in this array is thus a window index modulo 32K. + */ + + this.head = -1; /* Heads of the hash chains or NIL. */ + + this.ins_h = 0; /* hash index of string to be inserted */ + this.hash_size = 0; /* number of elements in hash table */ + this.hash_bits = 0; /* log2(hash_size) */ + this.hash_mask = 0; /* hash_size-1 */ + + this.hash_shift = 0; + /* Number of bits by which ins_h must be shifted at each input + * step. It must be such that after MIN_MATCH steps, the oldest + * byte no longer takes part in the hash key, that is: + * hash_shift * MIN_MATCH >= hash_bits + */ + + this.block_start = 0; + /* Window position at the beginning of the current output block. Gets + * negative when the window is moved backwards. + */ + + this.match_length = 0; /* length of best match */ + this.prev_match = 0; /* previous match */ + this.match_available = 1; /* set if previous match exists */ + this.strstart = 0; /* start of string to insert */ + this.match_start = 0; /* start of matching string */ + this.lookahead = 0; /* number of valid bytes ahead in window */ + + this.prev_length = 0; + /* Length of the best match at previous step. Matches not greater than this + * are discarded. This is used in the lazy match evaluation. + */ + + this.max_chain_length = 0; + /* To speed up deflation, hash chains are never searched beyond this + * length. A higher limit improves compression ratio but degrades the + * speed. + */ + + this.max_lazy_match = 0; + /* Attempt to find a better match only when the current match is strictly + * smaller than this value. This mechanism is used only for compression + * levels >= 4. + */ + this.max_insert_length = 0; + /* Insert new strings in the hash table only if the match length is not + * greater than this length. This saves time but degrades compression. + * max_insert_length is used only for compression levels <= 3. + */ + + this.level = 0; /* compression level (1..9) */ + this.strategy = 0; /* favor or force Huffman coding*/ + + this.good_match = 0; + /* Use a faster search when the previous match is longer than this */ + + this.nice_match = 0; /* Stop searching when current match exceeds this */ +} + +function deflateInit (strm, level) { + +} + +function deflateInit2 (strm, level, method, windowBits, memLevel, strategy) { + +} + +function deflateSetDictionary (strm, dictionary, dictLength) { + +} + +function deflateResetKeep (strm) { + +} + +function deflateReset (strm) { + +} + +function deflateParams (strm,level,strategy) { + +} + +function deflateSetHeader (strm, head) { + +} + +function deflateBound(strm, sourceLen) { + +} + +function deflatePending (strm, pending, bits) { + +} + +/* ========================================================================= + * Put a short in the pending buffer. The 16-bit value is put in MSB order. + * IN assertion: the stream state is correct and there is enough room in + * pending_buf. + */ +function putShortMSB (s, b) { + +} + +/* ========================================================================= + * Flush as much pending output as possible. All deflate() output goes + * through this function so some applications may wish to modify it + * to avoid allocating a large strm->next_out buffer and copying into it. + * (See also read_buf()). + */ +function flush_pending(strm) { + +} + +function deflate (strm, flush) { + +} + +function deflateEnd (strm) { + +} + +/* ========================================================================= + * Copy the source state to the destination state + */ +function deflateCopy (dest, source) { + +} + +/* =========================================================================== + * Read a new buffer from the current input stream, update the adler32 + * and total number of bytes read. All deflate() input goes through + * this function so some applications may wish to modify it to avoid + * allocating a large strm->next_in buffer and copying from it. + * (See also flush_pending()). + */ +function read_buf(strm, buf, size) { + +} + +/* =========================================================================== + * Initialize the "longest match" routines for a new zlib stream + */ +function lm_init (s) { + +} + +/* =========================================================================== + * Set match_start to the longest match starting at the given string and + * return its length. Matches shorter or equal to prev_length are discarded, + * in which case the result is equal to prev_length and match_start is + * garbage. + * IN assertions: cur_match is the head of the hash chain for the current + * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 + * OUT assertion: the match length is not greater than s->lookahead. + */ +function longest_match(s, cur_match) { + +} + +/* =========================================================================== + * Fill the window when the lookahead becomes insufficient. + * Updates strstart and lookahead. + * + * IN assertion: lookahead < MIN_LOOKAHEAD + * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD + * At least one byte has been read, or avail_in == 0; reads are + * performed for at least two bytes (required for the zip translate_eol + * option -- not supported here). + */ +function fill_window(s) { + +} + +/* =========================================================================== + * Copy without compression as much as possible from the input stream, return + * the current block state. + * This function does not insert new strings in the dictionary since + * uncompressible data is probably not useful. This function is used + * only for the level=0 compression option. + * NOTE: this function should be optimized to avoid extra copying from + * window to pending_buf. + */ +function deflate_stored(s, flush) { + +} + +/* =========================================================================== + * Compress as much as possible from the input stream, return the current + * block state. + * This function does not perform lazy evaluation of matches and inserts + * new strings in the dictionary only for unmatched strings or for short + * matches. It is used only for the fast compression options. + */ +function deflate_fast(s, flush) { + +} + +/* =========================================================================== + * Same as above, but achieves better compression. We use a lazy + * evaluation for matches: a match is finally adopted only if there is + * no better match at the next window position. + */ +function deflate_slow(s, flush) { + +} + +/* =========================================================================== + * For Z_RLE, simply look for runs of bytes, generate matches only of distance + * one. Do not maintain a hash table. (It will be regenerated if this run of + * deflate switches away from Z_RLE.) + */ +function deflate_rle(s, flush) { + +} + +/* =========================================================================== + * For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table. + * (It will be regenerated if this run of deflate switches away from Huffman.) + */ +function deflate_huff(s, flush) { + +} + +exports.deflateInit = deflateInit; + +exports.deflateInit2 = deflateInit2; + +exports.deflateSetDictionary = deflateSetDictionary; + +exports.deflateReset = deflateReset; + +exports.deflateParams = deflateParams; + +exports.deflateSetHeader = deflateSetHeader; + +exports.deflateBound = deflateBound; + +exports.deflatePending = deflatePending; + +exports.deflate = deflate; + +exports.deflateEnd = deflateEnd; \ No newline at end of file diff --git a/lib/zlib/zstream.js b/lib/zlib/zstream.js new file mode 100644 index 0000000..05c004a --- /dev/null +++ b/lib/zlib/zstream.js @@ -0,0 +1,24 @@ +function ZStream() { + /* next input byte */ + this.next_in = -1; + /* number of bytes available at next_in */ + this.avail_in = 0; + /* total number of input bytes read so far */ + this.total_in = 0; + /* next output byte should be put there */ + this.next_out = -1; + /* remaining free space at next_out */ + this.avail_out = 0; + /* total number of bytes output so far */ + this.total_out = 0; + /* last error message, NULL if no error */ + this.msg = -1; + /* not visible by applications */ + this.state = -1; + /* best guess about the data type: binary or text */ + this.data_type = 2; + /* adler32 value of the uncompressed data */ + this.adler = 0; +} + +module.exports = ZStream; \ No newline at end of file