/* eslint-disable */ import { Encoding } from '@syncfusion/ej2-file-utils'; /** * array literal codes */ const ARR_LITERAL_CODES: Int16Array = new Int16Array(286); const ARR_LITERAL_LENGTHS: Uint8Array = new Uint8Array(286); const ARR_DISTANCE_CODES: Int16Array = new Int16Array(30); const ARR_DISTANCE_LENGTHS: Uint8Array = new Uint8Array(30); /** * represent compression stream writer * ```typescript * let compressedWriter = new CompressedStreamWriter(); * let text: string = 'Hello world!!!'; * compressedWriter.write(text, 0, text.length); * compressedWriter.close(); * ``` */ export class CompressedStreamWriter { private static isHuffmanTreeInitiated: boolean = false; private stream: Uint8Array[]; private pendingBuffer: Uint8Array = new Uint8Array(1 << 16); private pendingBufLength: number = 0; private pendingBufCache: number = 0; private pendingBufBitsInCache: number = 0; private treeLiteral: CompressorHuffmanTree; private treeDistances: CompressorHuffmanTree; private treeCodeLengths: CompressorHuffmanTree; private bufferPosition: number = 0; private arrLiterals: Uint8Array; private arrDistances: Uint16Array; private extraBits: number = 0; private currentHash: number = 0; private hashHead: Int16Array; private hashPrevious: Int16Array; private matchStart: number = 0; private matchLength: number = 0; private matchPrevAvail: boolean = false; private blockStart: number = 0; private stringStart: number = 0; private lookAhead: number = 0; private dataWindow: Uint8Array; private inputBuffer: Uint8Array; private totalBytesIn: number = 0; private inputOffset: number = 0; private inputEnd: number = 0; private windowSize: number = 1 << 15; private windowMask: number = this.windowSize - 1; private hashSize: number = 1 << 15; private hashMask: number = this.hashSize - 1; private hashShift: number = Math.floor((15 + 3 - 1) / 3); private maxDist: number = this.windowSize - 262; private checkSum: number = 1; private noWrap: Boolean = false; /** * get compressed data */ get compressedData(): Uint8Array[] { return this.stream; } get getCompressedString(): string { let compressedString: string = ''; if (this.stream !== undefined) { for (let i: number = 0; i < this.stream.length; i++) { compressedString += String.fromCharCode.apply(null, this.stream[i]); } } return compressedString; } /** * Initializes compressor and writes ZLib header if needed. * @param {boolean} noWrap - optional if true, ZLib header and checksum will not be written. */ constructor(noWrap?: boolean) { if (!CompressedStreamWriter.isHuffmanTreeInitiated) { CompressedStreamWriter.initHuffmanTree(); CompressedStreamWriter.isHuffmanTreeInitiated = true; } this.treeLiteral = new CompressorHuffmanTree(this, 286, 257, 15); this.treeDistances = new CompressorHuffmanTree(this, 30, 1, 15); this.treeCodeLengths = new CompressorHuffmanTree(this, 19, 4, 7); this.arrDistances = new Uint16Array((1 << 14)); this.arrLiterals = new Uint8Array((1 << 14)); this.stream = []; this.dataWindow = new Uint8Array(2 * this.windowSize); this.hashHead = new Int16Array(this.hashSize); this.hashPrevious = new Int16Array(this.windowSize); this.blockStart = this.stringStart = 1; this.noWrap = noWrap; if (!noWrap) { this.writeZLibHeader(); } } /** * Compresses data and writes it to the stream. * @param {Uint8Array} data - data to compress * @param {number} offset - offset in data * @param {number} length - length of the data * @returns {void} */ public write(data: Uint8Array | string, offset: number, length: number): void { if (data === undefined || data === null) { throw new Error('ArgumentException: data cannot null or undefined'); } let end: number = offset + length; if (0 > offset || offset > end || end > data.length) { throw new Error('ArgumentOutOfRangeException: Offset or length is incorrect'); } if (typeof data === 'string') { let encode: Encoding = new Encoding(false); encode.type = 'Utf8'; data = new Uint8Array(encode.getBytes(data, 0, data.length)); end = offset + data.length; } this.inputBuffer = data as Uint8Array; this.inputOffset = offset; this.inputEnd = end; if (!this.noWrap) { this.checkSum = ChecksumCalculator.checksumUpdate(this.checkSum, this.inputBuffer, this.inputOffset, end); } while (!(this.inputEnd === this.inputOffset) || !(this.pendingBufLength === 0)) { this.pendingBufferFlush(); this.compressData(false); } } /** * write ZLib header to the compressed data * @return {void} */ public writeZLibHeader(): void { /* Initialize header.*/ let headerDate: number = (8 + (7 << 4)) << 8; /* Save compression level.*/ headerDate |= ((5 >> 2) & 3) << 6; /* Align header.*/ headerDate += 31 - (headerDate % 31); /* Write header to stream.*/ this.pendingBufferWriteShortBytes(headerDate); } /** * Write Most Significant Bytes in to stream * @param {number} s - check sum value */ public pendingBufferWriteShortBytes(s: number): void { this.pendingBuffer[this.pendingBufLength++] = s >> 8; this.pendingBuffer[this.pendingBufLength++] = s; } private compressData(finish: boolean): boolean { let success: boolean; do { this.fillWindow(); let canFlush: boolean = (finish && this.inputEnd === this.inputOffset); success = this.compressSlow(canFlush, finish); } while (this.pendingBufLength === 0 && success); return success; } private compressSlow(flush: boolean, finish: boolean): boolean { if (this.lookAhead < 262 && !flush) { return false; } while (this.lookAhead >= 262 || flush) { if (this.lookAhead === 0) { return this.lookAheadCompleted(finish); } if (this.stringStart >= 2 * this.windowSize - 262) { this.slideWindow(); } let prevMatch: number = this.matchStart; let prevLen: number = this.matchLength; if (this.lookAhead >= 3) { this.discardMatch(); } if (prevLen >= 3 && this.matchLength <= prevLen) { prevLen = this.matchPreviousBest(prevMatch, prevLen); } else { this.matchPreviousAvailable(); } if (this.bufferPosition >= (1 << 14)) { return this.huffmanIsFull(finish); } } return true; } private discardMatch(): void { let hashHead: number = this.insertString(); if (hashHead !== 0 && this.stringStart - hashHead <= this.maxDist && this.findLongestMatch(hashHead)) { if (this.matchLength <= 5 && (this.matchLength === 3 && this.stringStart - this.matchStart > 4096)) { this.matchLength = 3 - 1; } } } private matchPreviousAvailable(): void { if (this.matchPrevAvail) { this.huffmanTallyLit(this.dataWindow[this.stringStart - 1] & 0xff); } this.matchPrevAvail = true; this.stringStart++; this.lookAhead--; } private matchPreviousBest(prevMatch: number, prevLen: number): number { this.huffmanTallyDist(this.stringStart - 1 - prevMatch, prevLen); prevLen -= 2; do { this.stringStart++; this.lookAhead--; if (this.lookAhead >= 3) { this.insertString(); } } while (--prevLen > 0); this.stringStart++; this.lookAhead--; this.matchPrevAvail = false; this.matchLength = 3 - 1; return prevLen; } private lookAheadCompleted(finish: boolean): boolean { if (this.matchPrevAvail) { this.huffmanTallyLit(this.dataWindow[this.stringStart - 1] & 0xff); } this.matchPrevAvail = false; this.huffmanFlushBlock(this.dataWindow, this.blockStart, this.stringStart - this.blockStart, finish); this.blockStart = this.stringStart; return false; } private huffmanIsFull(finish: boolean): boolean { let len: number = this.stringStart - this.blockStart; if (this.matchPrevAvail) { len--; } let lastBlock: boolean = (finish && this.lookAhead === 0 && !this.matchPrevAvail); this.huffmanFlushBlock(this.dataWindow, this.blockStart, len, lastBlock); this.blockStart += len; return !lastBlock; } private fillWindow(): void { if (this.stringStart >= this.windowSize + this.maxDist) { this.slideWindow(); } while (this.lookAhead < 262 && this.inputOffset < this.inputEnd) { let more: number = 2 * this.windowSize - this.lookAhead - this.stringStart; if (more > this.inputEnd - this.inputOffset) { more = this.inputEnd - this.inputOffset; } this.dataWindow.set(this.inputBuffer.subarray(this.inputOffset, this.inputOffset + more), this.stringStart + this.lookAhead); this.inputOffset += more; this.totalBytesIn += more; this.lookAhead += more; } if (this.lookAhead >= 3) { this.updateHash(); } } private slideWindow(): void { this.dataWindow.set(this.dataWindow.subarray(this.windowSize, this.windowSize + this.windowSize), 0); this.matchStart -= this.windowSize; this.stringStart -= this.windowSize; this.blockStart -= this.windowSize; for (let i: number = 0; i < this.hashSize; ++i) { let m: number = this.hashHead[i] & 0xffff; this.hashHead[i] = (((m >= this.windowSize) ? (m - this.windowSize) : 0)); } for (let i: number = 0; i < this.windowSize; i++) { let m: number = this.hashPrevious[i] & 0xffff; this.hashPrevious[i] = ((m >= this.windowSize) ? (m - this.windowSize) : 0); } } private insertString(): number { let match: number; let hash: number = ((this.currentHash << this.hashShift) ^ this.dataWindow[this.stringStart + (3 - 1)]) & this.hashMask; this.hashPrevious[this.stringStart & this.windowMask] = match = this.hashHead[hash]; this.hashHead[hash] = this.stringStart; this.currentHash = hash; return match & 0xffff; } private findLongestMatch(curMatch: number): boolean { let chainLen: number = 4096; let niceLen: number = 258; let scan: number = this.stringStart; let match: number; let bestEnd: number = this.stringStart + this.matchLength; let bestLength: number = Math.max(this.matchLength, 3 - 1); let limit: number = Math.max(this.stringStart - this.maxDist, 0); let stringEnd: number = this.stringStart + 258 - 1; let scanEnd1: number = this.dataWindow[bestEnd - 1]; let scanEnd: number = this.dataWindow[bestEnd]; let data: Uint8Array = this.dataWindow; if (bestLength >= 32) { chainLen >>= 2; } if (niceLen > this.lookAhead) { niceLen = this.lookAhead; } do { if (data[curMatch + bestLength] !== scanEnd || data[curMatch + bestLength - 1] !== scanEnd1 || data[curMatch] !== data[scan] || data[curMatch + 1] !== data[scan + 1]) { continue; } match = curMatch + 2; scan += 2; /* tslint:disable */ while (data[++scan] === data[++match] && data[++scan] === data[++match] && data[++scan] === data[++match] && data[++scan] === data[++match] && data[++scan] === data[++match] && data[++scan] === data[++match] && data[++scan] === data[++match] && data[++scan] === data[++match] && scan < stringEnd) { /* tslint:disable */ } if (scan > bestEnd) { this.matchStart = curMatch; bestEnd = scan; bestLength = scan - this.stringStart; if (bestLength >= niceLen) { break; } scanEnd1 = data[bestEnd - 1]; scanEnd = data[bestEnd]; } scan = this.stringStart; } while ((curMatch = (this.hashPrevious[curMatch & this.windowMask] & 0xffff)) > limit && --chainLen !== 0); this.matchLength = Math.min(bestLength, this.lookAhead); return this.matchLength >= 3; } private updateHash(): void { this.currentHash = (this.dataWindow[this.stringStart] << this.hashShift) ^ this.dataWindow[this.stringStart + 1]; } private huffmanTallyLit(literal: number): boolean { this.arrDistances[this.bufferPosition] = 0; this.arrLiterals[this.bufferPosition++] = literal; this.treeLiteral.codeFrequencies[literal]++; return this.bufferPosition >= (1 << 14); } private huffmanTallyDist(dist: number, len: number): boolean { this.arrDistances[this.bufferPosition] = dist; this.arrLiterals[this.bufferPosition++] = (len - 3); let lc: number = this.huffmanLengthCode(len - 3); this.treeLiteral.codeFrequencies[lc]++; if (lc >= 265 && lc < 285) { this.extraBits += Math.floor((lc - 261) / 4); } let dc: number = this.huffmanDistanceCode(dist - 1); this.treeDistances.codeFrequencies[dc]++; if (dc >= 4) { this.extraBits += Math.floor((dc / 2 - 1)); } return this.bufferPosition >= (1 << 14); } private huffmanFlushBlock(stored: Uint8Array, storedOffset: number, storedLength: number, lastBlock: boolean): void { this.treeLiteral.codeFrequencies[256]++; this.treeLiteral.buildTree(); this.treeDistances.buildTree(); this.treeLiteral.calculateBLFreq(this.treeCodeLengths); this.treeDistances.calculateBLFreq(this.treeCodeLengths); this.treeCodeLengths.buildTree(); let blTreeCodes: number = 4; for (let i: number = 18; i > blTreeCodes; i--) { if (this.treeCodeLengths.codeLengths[CompressorHuffmanTree.huffCodeLengthOrders[i]] > 0) { blTreeCodes = i + 1; } } let opt_len: number = 14 + blTreeCodes * 3 + this.treeCodeLengths.getEncodedLength() + this.treeLiteral.getEncodedLength() + this.treeDistances.getEncodedLength() + this.extraBits; let static_len: number = this.extraBits; for (let i: number = 0; i < 286; i++) { static_len += this.treeLiteral.codeFrequencies[i] * ARR_LITERAL_LENGTHS[i]; } for (let i = 0; i < 30; i++) { static_len += this.treeDistances.codeFrequencies[i] * ARR_DISTANCE_LENGTHS[i]; } if (opt_len >= static_len) { // Force static trees. opt_len = static_len; } if (storedOffset >= 0 && storedLength + 4 < opt_len >> 3) { this.huffmanFlushStoredBlock(stored, storedOffset, storedLength, lastBlock); } else if (opt_len == static_len) { // Encode with static tree. this.pendingBufferWriteBits((1 << 1) + (lastBlock ? 1 : 0), 3); this.treeLiteral.setStaticCodes(ARR_LITERAL_CODES, ARR_LITERAL_LENGTHS); this.treeDistances.setStaticCodes(ARR_DISTANCE_CODES, ARR_DISTANCE_LENGTHS); this.huffmanCompressBlock(); this.huffmanReset(); } else { this.pendingBufferWriteBits((2 << 1) + (lastBlock ? 1 : 0), 3); this.huffmanSendAllTrees(blTreeCodes); this.huffmanCompressBlock(); this.huffmanReset(); } } private huffmanFlushStoredBlock(stored: Uint8Array, storedOffset: number, storedLength: number, lastBlock: boolean): void { this.pendingBufferWriteBits((0 << 1) + (lastBlock ? 1 : 0), 3); this.pendingBufferAlignToByte(); this.pendingBufferWriteShort(storedLength); this.pendingBufferWriteShort(~storedLength); this.pendingBufferWriteByteBlock(stored, storedOffset, storedLength); this.huffmanReset(); } private huffmanLengthCode(len: number): number { if (len === 255) { return 285; } let code: number = 257; while (len >= 8) { code += 4; len >>= 1; } return code + len; } private huffmanDistanceCode(distance: number): number { let code: number = 0; while (distance >= 4) { code += 2; distance >>= 1; } return code + distance; } private huffmanSendAllTrees(blTreeCodes: number): void { this.treeCodeLengths.buildCodes(); this.treeLiteral.buildCodes(); this.treeDistances.buildCodes(); this.pendingBufferWriteBits(this.treeLiteral.treeLength - 257, 5); this.pendingBufferWriteBits(this.treeDistances.treeLength - 1, 5); this.pendingBufferWriteBits(blTreeCodes - 4, 4); for (let rank: number = 0; rank < blTreeCodes; rank++) { this.pendingBufferWriteBits( this.treeCodeLengths.codeLengths[CompressorHuffmanTree.huffCodeLengthOrders[rank]] , 3); } this.treeLiteral.writeTree(this.treeCodeLengths); this.treeDistances.writeTree(this.treeCodeLengths); } private huffmanReset(): void { this.bufferPosition = 0; this.extraBits = 0; this.treeLiteral.reset(); this.treeDistances.reset(); this.treeCodeLengths.reset(); } private huffmanCompressBlock(): void { for (let i: number = 0; i < this.bufferPosition; i++) { let literalLen: number = this.arrLiterals[i] & 255; let dist: number = this.arrDistances[i]; if (dist-- !== 0) { let lc: number = this.huffmanLengthCode(literalLen); this.treeLiteral.writeCodeToStream(lc); let bits: number = Math.floor((lc - 261) / 4); if (bits > 0 && bits <= 5) { this.pendingBufferWriteBits(literalLen & ((1 << bits) - 1), bits); } let dc: number = this.huffmanDistanceCode(dist); this.treeDistances.writeCodeToStream(dc); bits = Math.floor(dc / 2 - 1); if (bits > 0) { this.pendingBufferWriteBits(dist & ((1 << bits) - 1), bits); } } else { this.treeLiteral.writeCodeToStream(literalLen); } } this.treeLiteral.writeCodeToStream(256); } /** * write bits in to internal buffer * @param {number} b - source of bits * @param {number} count - count of bits to write */ public pendingBufferWriteBits(b: number, count: number): void { let uint: Uint32Array = new Uint32Array(1); uint[0] = this.pendingBufCache | (b << this.pendingBufBitsInCache); this.pendingBufCache = uint[0]; this.pendingBufBitsInCache += count; this.pendingBufferFlushBits(); } private pendingBufferFlush(isClose?: boolean): void { this.pendingBufferFlushBits(); if (this.pendingBufLength > 0) { let array: Uint8Array = new Uint8Array(this.pendingBufLength); array.set(this.pendingBuffer.subarray(0, this.pendingBufLength), 0); this.stream.push(array); } this.pendingBufLength = 0; } private pendingBufferFlushBits(): number { let result: number = 0; while (this.pendingBufBitsInCache >= 8 && this.pendingBufLength < (1 << 16)) { this.pendingBuffer[this.pendingBufLength++] = this.pendingBufCache; this.pendingBufCache >>= 8; this.pendingBufBitsInCache -= 8; result++; } return result; } private pendingBufferWriteByteBlock(data: Uint8Array, offset: number, length: number): void { let array: Uint8Array = data.subarray(offset, offset + length); this.pendingBuffer.set(array, this.pendingBufLength); this.pendingBufLength += length; } private pendingBufferWriteShort(s: number): void { this.pendingBuffer[this.pendingBufLength++] = s; this.pendingBuffer[this.pendingBufLength++] = (s >> 8); } private pendingBufferAlignToByte(): void { if (this.pendingBufBitsInCache > 0) { this.pendingBuffer[this.pendingBufLength++] = this.pendingBufCache; } this.pendingBufCache = 0; this.pendingBufBitsInCache = 0; } /** * Huffman Tree literal calculation * @private */ public static initHuffmanTree(): void { let i: number = 0; while (i < 144) { ARR_LITERAL_CODES[i] = CompressorHuffmanTree.bitReverse((0x030 + i) << 8); ARR_LITERAL_LENGTHS[i++] = 8; } while (i < 256) { ARR_LITERAL_CODES[i] = CompressorHuffmanTree.bitReverse((0x190 - 144 + i) << 7); ARR_LITERAL_LENGTHS[i++] = 9; } while (i < 280) { ARR_LITERAL_CODES[i] = CompressorHuffmanTree.bitReverse((0x000 - 256 + i) << 9); ARR_LITERAL_LENGTHS[i++] = 7; } while (i < 286) { ARR_LITERAL_CODES[i] = CompressorHuffmanTree.bitReverse((0x0c0 - 280 + i) << 8); ARR_LITERAL_LENGTHS[i++] = 8; } for (i = 0; i < 30; i++) { ARR_DISTANCE_CODES[i] = CompressorHuffmanTree.bitReverse(i << 11); ARR_DISTANCE_LENGTHS[i] = 5; } } /** * close the stream and write all pending buffer in to stream * @returns {void} */ public close(): void { do { this.pendingBufferFlush(true); if (!this.compressData(true)) { this.pendingBufferFlush(true); this.pendingBufferAlignToByte(); if (!this.noWrap) { this.pendingBufferWriteShortBytes(this.checkSum >> 16); this.pendingBufferWriteShortBytes(this.checkSum & 0xffff); } this.pendingBufferFlush(true); } } while (!(this.inputEnd === this.inputOffset) || !(this.pendingBufLength === 0)); } /** * release allocated un-managed resource * @returns {void} */ public destroy(): void { this.stream = []; this.stream = undefined; this.pendingBuffer = undefined; this.treeLiteral = undefined; this.treeDistances = undefined; this.treeCodeLengths = undefined; this.arrLiterals = undefined; this.arrDistances = undefined; this.hashHead = undefined; this.hashPrevious = undefined; this.dataWindow = undefined; this.inputBuffer = undefined; this.pendingBufLength = undefined; this.pendingBufCache = undefined; this.pendingBufBitsInCache = undefined; this.bufferPosition = undefined; this.extraBits = undefined; this.currentHash = undefined; this.matchStart = undefined; this.matchLength = undefined; this.matchPrevAvail = undefined; this.blockStart = undefined; this.stringStart = undefined; this.lookAhead = undefined; this.totalBytesIn = undefined; this.inputOffset = undefined; this.inputEnd = undefined; this.windowSize = undefined; this.windowMask = undefined; this.hashSize = undefined; this.hashMask = undefined; this.hashShift = undefined; this.maxDist = undefined; this.checkSum = undefined; this.noWrap = undefined; } } /** * represent the Huffman Tree */ export class CompressorHuffmanTree { private codeFrequency: Uint16Array; private codes: Int16Array; private codeLength: Uint8Array; private lengthCount: Int32Array; private codeMinCount: number; private codeCount: number; private maxLength: number; private writer: CompressedStreamWriter; private static reverseBits: number[] = [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15]; public static huffCodeLengthOrders: number[] = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]; public get treeLength(): number { return this.codeCount; } public get codeLengths(): Uint8Array { return this.codeLength; } public get codeFrequencies(): Uint16Array { return this.codeFrequency; } /** * Create new Huffman Tree * @param {CompressedStreamWriter} writer instance * @param {number} elementCount - element count * @param {number} minCodes - minimum count * @param {number} maxLength - maximum count */ constructor(writer: CompressedStreamWriter, elementCount: number, minCodes: number, maxLength: number) { this.writer = writer; this.codeMinCount = minCodes; this.maxLength = maxLength; this.codeFrequency = new Uint16Array(elementCount); this.lengthCount = new Int32Array(maxLength); } public setStaticCodes(codes: Int16Array, lengths: Uint8Array): void { let temp: Int16Array = new Int16Array(codes.length); temp.set(codes, 0); this.codes = temp; let lengthTemp: Uint8Array = new Uint8Array(lengths.length); lengthTemp.set(lengths, 0); this.codeLength = lengthTemp; } /** * reset all code data in tree * @returns {void} */ public reset(): void { for (let i: number = 0; i < this.codeFrequency.length; i++) { this.codeFrequency[i] = 0; } this.codes = undefined; this.codeLength = undefined; } /** * write code to the compressor output stream * @param {number} code - code to be written * @returns {void} */ public writeCodeToStream(code: number): void { this.writer.pendingBufferWriteBits(this.codes[code] & 0xffff, this.codeLength[code]); } /** * calculate code from their frequencies * @returns {void} */ public buildCodes(): void { let nextCode: Int32Array = new Int32Array(this.maxLength); this.codes = new Int16Array(this.codeCount); let code: number = 0; for (let bitsCount: number = 0; bitsCount < this.maxLength; bitsCount++) { nextCode[bitsCount] = code; code += this.lengthCount[bitsCount] << (15 - bitsCount); } for (let i: number = 0; i < this.codeCount; i++) { let bits = this.codeLength[i]; if (bits > 0) { this.codes[i] = CompressorHuffmanTree.bitReverse(nextCode[bits - 1]); nextCode[bits - 1] += 1 << (16 - bits); } } } public static bitReverse(value: number): number { return (CompressorHuffmanTree.reverseBits[value & 15] << 12 | CompressorHuffmanTree.reverseBits[(value >> 4) & 15] << 8 | CompressorHuffmanTree.reverseBits[(value >> 8) & 15] << 4 | CompressorHuffmanTree.reverseBits[value >> 12]); } /** * calculate length of compressed data * @returns {number} */ public getEncodedLength(): number { let len: number = 0; for (let i: number = 0; i < this.codeFrequency.length; i++) { len += this.codeFrequency[i] * this.codeLength[i]; } return len; } /** * calculate code frequencies * @param {CompressorHuffmanTree} blTree * @returns {void} */ public calculateBLFreq(blTree: CompressorHuffmanTree): void { let maxCount: number; let minCount: number; let count: number; let curLen: number = -1; let i: number = 0; while (i < this.codeCount) { count = 1; let nextLen: number = this.codeLength[i]; if (nextLen === 0) { maxCount = 138; minCount = 3; } else { maxCount = 6; minCount = 3; if (curLen !== nextLen) { blTree.codeFrequency[nextLen]++; count = 0; } } curLen = nextLen; i++; while (i < this.codeCount && curLen === this.codeLength[i]) { i++; if (++count >= maxCount) { break; } } if (count < minCount) { blTree.codeFrequency[curLen] += count; } else if (curLen !== 0) { blTree.codeFrequency[16]++; } else if (count <= 10) { blTree.codeFrequency[17]++; } else { blTree.codeFrequency[18]++; } } } /** * @param {CompressorHuffmanTree} blTree - write tree to output stream * @returns {void} */ public writeTree(blTree: CompressorHuffmanTree): void { let maxRepeatCount: number; let minRepeatCount: number; let currentRepeatCount: number; let currentCodeLength: number = -1; let i: number = 0; while (i < this.codeCount) { currentRepeatCount = 1; let nextLen: number = this.codeLength[i]; if (nextLen === 0) { maxRepeatCount = 138; minRepeatCount = 3; } else { maxRepeatCount = 6; minRepeatCount = 3; if (currentCodeLength !== nextLen) { blTree.writeCodeToStream(nextLen); currentRepeatCount = 0; } } currentCodeLength = nextLen; i++; while (i < this.codeCount && currentCodeLength === this.codeLength[i]) { i++; if (++currentRepeatCount >= maxRepeatCount) { break; } } if (currentRepeatCount < minRepeatCount) { while (currentRepeatCount-- > 0) { blTree.writeCodeToStream(currentCodeLength); } } else if (currentCodeLength !== 0) { blTree.writeCodeToStream(16); this.writer.pendingBufferWriteBits(currentRepeatCount - 3, 2); } else if (currentRepeatCount <= 10) { blTree.writeCodeToStream(17); this.writer.pendingBufferWriteBits(currentRepeatCount - 3, 3); } else { blTree.writeCodeToStream(18); this.writer.pendingBufferWriteBits(currentRepeatCount - 11, 7); } } } /** * Build huffman tree * @returns {void} */ public buildTree(): void { let codesCount: number = this.codeFrequency.length; let arrTree: Int32Array = new Int32Array(codesCount); let treeLength: number = 0; let maxCount: number = 0; for (let n = 0; n < codesCount; n++) { let freq: number = this.codeFrequency[n]; if (freq !== 0) { let pos: number = treeLength++; let pPos: number = 0; while (pos > 0 && this.codeFrequency[arrTree[pPos = Math.floor((pos - 1) / 2)]] > freq) { arrTree[pos] = arrTree[pPos]; pos = pPos; } arrTree[pos] = n; maxCount = n; } } while (treeLength < 2) { arrTree[treeLength++] = (maxCount < 2) ? ++maxCount : 0; } this.codeCount = Math.max(maxCount + 1, this.codeMinCount); let leafsCount: number = treeLength; let nodesCount: number = leafsCount; let child: Int32Array = new Int32Array(4 * treeLength - 2); let values: Int32Array = new Int32Array(2 * treeLength - 1); for (let i: number = 0; i < treeLength; i++) { let node: number = arrTree[i]; let iIndex: number = 2 * i; child[iIndex] = node; child[iIndex + 1] = -1; values[i] = (this.codeFrequency[node] << 8); arrTree[i] = i; } this.constructHuffmanTree(arrTree, treeLength, values, nodesCount, child); this.buildLength(child); } private constructHuffmanTree(arrTree: Int32Array, treeLength: number, values: Int32Array, nodesCount: number, child: Int32Array): void { do { let first: number = arrTree[0]; let last: number = arrTree[--treeLength]; let lastVal: number = values[last]; let pPos: number = 0; let path: number = 1; while (path < treeLength) { if (path + 1 < treeLength && values[arrTree[path]] > values[arrTree[path + 1]]) { path++; } arrTree[pPos] = arrTree[path]; pPos = path; path = pPos * 2 + 1; } while ((path = pPos) > 0 && values[arrTree[pPos = Math.floor((path - 1) / 2)]] > lastVal) { arrTree[path] = arrTree[pPos]; } arrTree[path] = last; let second: number = arrTree[0]; last = nodesCount++; child[2 * last] = first; child[2 * last + 1] = second; let minDepth: number = Math.min(values[first] & 0xff, values[second] & 0xff); values[last] = lastVal = values[first] + values[second] - minDepth + 1; pPos = 0; path = 1; /* tslint:disable */ while (path < treeLength) { if (path + 1 < treeLength && values[arrTree[path]] > values[arrTree[path + 1]]) { path++; } arrTree[pPos] = arrTree[path]; pPos = path; path = pPos * 2 + 1; } /* tslint:disable */ while ((path = pPos) > 0 && values[arrTree[pPos = Math.floor((path - 1) / 2)]] > lastVal) { arrTree[path] = arrTree[pPos]; } arrTree[path] = last; } while (treeLength > 1); } private buildLength(child: Int32Array): void { this.codeLength = new Uint8Array(this.codeFrequency.length); let numNodes: number = Math.floor(child.length / 2); let numLeafs: number = Math.floor((numNodes + 1) / 2); let overflow: number = 0; for (let i = 0; i < this.maxLength; i++) { this.lengthCount[i] = 0; } overflow = this.calculateOptimalCodeLength(child, overflow, numNodes); if (overflow === 0) { return; } let iIncreasableLength: number = this.maxLength - 1; do { while (this.lengthCount[--iIncreasableLength] === 0) { /* tslint:disable */ } do { this.lengthCount[iIncreasableLength]--; this.lengthCount[++iIncreasableLength]++; overflow -= (1 << (this.maxLength - 1 - iIncreasableLength)); } while (overflow > 0 && iIncreasableLength < this.maxLength - 1); } while (overflow > 0); this.recreateTree(child, overflow, numLeafs); } private recreateTree(child: Int32Array, overflow: number, numLeafs: number): void { this.lengthCount[this.maxLength - 1] += overflow; this.lengthCount[this.maxLength - 2] -= overflow; let nodePtr: number = 2 * numLeafs; for (let bits: number = this.maxLength; bits !== 0; bits--) { let n = this.lengthCount[bits - 1]; while (n > 0) { let childPtr: number = 2 * child[nodePtr++]; if (child[childPtr + 1] === -1) { this.codeLength[child[childPtr]] = bits; n--; } } } } private calculateOptimalCodeLength(child: Int32Array, overflow: number, numNodes: number): number { let lengths: Int32Array = new Int32Array(numNodes); lengths[numNodes - 1] = 0; for (let i: number = numNodes - 1; i >= 0; i--) { let childIndex: number = 2 * i + 1; if (child[childIndex] !== -1) { let bitLength: number = lengths[i] + 1; if (bitLength > this.maxLength) { bitLength = this.maxLength; overflow++; } lengths[child[childIndex - 1]] = lengths[child[childIndex]] = bitLength; } else { let bitLength = lengths[i]; this.lengthCount[bitLength - 1]++; this.codeLength[child[childIndex - 1]] = lengths[i]; } } return overflow } } /** * Checksum calculator, based on Adler32 algorithm. */ export class ChecksumCalculator { private static checkSumBitOffset: number = 16; private static checksumBase: number = 65521; private static checksumIterationCount: number = 3800; /** * Updates checksum by calculating checksum of the * given buffer and adding it to current value. * @param {number} checksum - current checksum. * @param {Uint8Array} buffer - data byte array. * @param {number} offset - offset in the buffer. * @param {number} length - length of data to be used from the stream. * @returns {number} */ public static checksumUpdate(checksum: number, buffer: Uint8Array, offset: number, length: number): number { let uint = new Uint32Array(1); uint[0] = checksum; let checksum_uint: number = uint[0]; let s1 = uint[0] = checksum_uint & 65535; let s2 = uint[0] = checksum_uint >> ChecksumCalculator.checkSumBitOffset; while (length > 0) { let steps = Math.min(length, ChecksumCalculator.checksumIterationCount); length -= steps; while (--steps >= 0) { s1 = s1 + (uint[0] = (buffer[offset++] & 255)); s2 = s2 + s1; } s1 %= ChecksumCalculator.checksumBase; s2 %= ChecksumCalculator.checksumBase; } checksum_uint = (s2 << ChecksumCalculator.checkSumBitOffset) | s1; return checksum_uint; } } /* eslint-enable */