|
|
|
@ -9,7 +9,7 @@
|
|
|
|
* ZIP format: http://www.pkware.com/documents/casestudies/APPNOTE.TXT
|
|
|
|
* ZIP format: http://www.pkware.com/documents/casestudies/APPNOTE.TXT
|
|
|
|
* DEFLATE format: http://tools.ietf.org/html/rfc1951
|
|
|
|
* DEFLATE format: http://tools.ietf.org/html/rfc1951
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
/* global bitjs */
|
|
|
|
/* global bitjs, importScripts, Uint8Array */
|
|
|
|
|
|
|
|
|
|
|
|
// This file expects to be invoked as a Worker (see onmessage below).
|
|
|
|
// This file expects to be invoked as a Worker (see onmessage below).
|
|
|
|
importScripts("io.js");
|
|
|
|
importScripts("io.js");
|
|
|
|
@ -44,12 +44,12 @@ var zLocalFileHeaderSignature = 0x04034b50;
|
|
|
|
var zArchiveExtraDataSignature = 0x08064b50;
|
|
|
|
var zArchiveExtraDataSignature = 0x08064b50;
|
|
|
|
var zCentralFileHeaderSignature = 0x02014b50;
|
|
|
|
var zCentralFileHeaderSignature = 0x02014b50;
|
|
|
|
var zDigitalSignatureSignature = 0x05054b50;
|
|
|
|
var zDigitalSignatureSignature = 0x05054b50;
|
|
|
|
var zEndOfCentralDirSignature = 0x06064b50;
|
|
|
|
//var zEndOfCentralDirSignature = 0x06064b50;
|
|
|
|
var zEndOfCentralDirLocatorSignature = 0x07064b50;
|
|
|
|
//var zEndOfCentralDirLocatorSignature = 0x07064b50;
|
|
|
|
|
|
|
|
|
|
|
|
// takes a ByteStream and parses out the local file information
|
|
|
|
// takes a ByteStream and parses out the local file information
|
|
|
|
var ZipLocalFile = function(bstream) {
|
|
|
|
var ZipLocalFile = function(bstream) {
|
|
|
|
if (typeof bstream != typeof {} || !bstream.readNumber || typeof bstream.readNumber != typeof function(){}) {
|
|
|
|
if (typeof bstream !== typeof {} || !bstream.readNumber || typeof bstream.readNumber != typeof function() {} ) {
|
|
|
|
return null;
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -100,7 +100,7 @@ var ZipLocalFile = function(bstream) {
|
|
|
|
// "This descriptor exists only if bit 3 of the general purpose bit flag is set"
|
|
|
|
// "This descriptor exists only if bit 3 of the general purpose bit flag is set"
|
|
|
|
// But how do you figure out how big the file data is if you don't know the compressedSize
|
|
|
|
// But how do you figure out how big the file data is if you don't know the compressedSize
|
|
|
|
// from the header?!?
|
|
|
|
// from the header?!?
|
|
|
|
if ((this.generalPurpose & bitjs.BIT[3]) != 0) {
|
|
|
|
if ((this.generalPurpose & bitjs.BIT[3]) !== 0) {
|
|
|
|
this.crc32 = bstream.readNumber(4);
|
|
|
|
this.crc32 = bstream.readNumber(4);
|
|
|
|
this.compressedSize = bstream.readNumber(4);
|
|
|
|
this.compressedSize = bstream.readNumber(4);
|
|
|
|
this.uncompressedSize = bstream.readNumber(4);
|
|
|
|
this.uncompressedSize = bstream.readNumber(4);
|
|
|
|
@ -111,13 +111,13 @@ var ZipLocalFile = function(bstream) {
|
|
|
|
ZipLocalFile.prototype.unzip = function() {
|
|
|
|
ZipLocalFile.prototype.unzip = function() {
|
|
|
|
|
|
|
|
|
|
|
|
// Zip Version 1.0, no compression (store only)
|
|
|
|
// Zip Version 1.0, no compression (store only)
|
|
|
|
if (this.compressionMethod == 0 ) {
|
|
|
|
if (this.compressionMethod === 0 ) {
|
|
|
|
info("ZIP v"+this.version+", store only: " + this.filename + " (" + this.compressedSize + " bytes)");
|
|
|
|
info("ZIP v" + this.version + ", store only: " + this.filename + " (" + this.compressedSize + " bytes)");
|
|
|
|
currentBytesUnarchivedInFile = this.compressedSize;
|
|
|
|
currentBytesUnarchivedInFile = this.compressedSize;
|
|
|
|
currentBytesUnarchived += this.compressedSize;
|
|
|
|
currentBytesUnarchived += this.compressedSize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// version == 20, compression method == 8 (DEFLATE)
|
|
|
|
// version == 20, compression method == 8 (DEFLATE)
|
|
|
|
else if (this.compressionMethod == 8) {
|
|
|
|
else if (this.compressionMethod === 8) {
|
|
|
|
info("ZIP v2.0, DEFLATE: " + this.filename + " (" + this.compressedSize + " bytes)");
|
|
|
|
info("ZIP v2.0, DEFLATE: " + this.filename + " (" + this.compressedSize + " bytes)");
|
|
|
|
this.fileData = inflate(this.fileData, this.uncompressedSize);
|
|
|
|
this.fileData = inflate(this.fileData, this.uncompressedSize);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -144,10 +144,10 @@ var unzip = function(arrayBuffer) {
|
|
|
|
|
|
|
|
|
|
|
|
var bstream = new bitjs.io.ByteStream(arrayBuffer);
|
|
|
|
var bstream = new bitjs.io.ByteStream(arrayBuffer);
|
|
|
|
// detect local file header signature or return null
|
|
|
|
// detect local file header signature or return null
|
|
|
|
if (bstream.peekNumber(4) == zLocalFileHeaderSignature) {
|
|
|
|
if (bstream.peekNumber(4) === zLocalFileHeaderSignature) {
|
|
|
|
var localFiles = [];
|
|
|
|
var localFiles = [];
|
|
|
|
// loop until we don't see any more local files
|
|
|
|
// loop until we don't see any more local files
|
|
|
|
while (bstream.peekNumber(4) == zLocalFileHeaderSignature) {
|
|
|
|
while (bstream.peekNumber(4) === zLocalFileHeaderSignature) {
|
|
|
|
var oneLocalFile = new ZipLocalFile(bstream);
|
|
|
|
var oneLocalFile = new ZipLocalFile(bstream);
|
|
|
|
// this should strip out directories/folders
|
|
|
|
// this should strip out directories/folders
|
|
|
|
if (oneLocalFile && oneLocalFile.uncompressedSize > 0 && oneLocalFile.fileData) {
|
|
|
|
if (oneLocalFile && oneLocalFile.uncompressedSize > 0 && oneLocalFile.fileData) {
|
|
|
|
@ -158,14 +158,14 @@ var unzip = function(arrayBuffer) {
|
|
|
|
totalFilesInArchive = localFiles.length;
|
|
|
|
totalFilesInArchive = localFiles.length;
|
|
|
|
|
|
|
|
|
|
|
|
// got all local files, now sort them
|
|
|
|
// got all local files, now sort them
|
|
|
|
localFiles.sort(function(a,b) {
|
|
|
|
localFiles.sort(function(a, b) {
|
|
|
|
var aname = a.filename.toLowerCase();
|
|
|
|
var aname = a.filename.toLowerCase();
|
|
|
|
var bname = b.filename.toLowerCase();
|
|
|
|
var bname = b.filename.toLowerCase();
|
|
|
|
return aname > bname ? 1 : -1;
|
|
|
|
return aname > bname ? 1 : -1;
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
// archive extra data record
|
|
|
|
// archive extra data record
|
|
|
|
if (bstream.peekNumber(4) == zArchiveExtraDataSignature) {
|
|
|
|
if (bstream.peekNumber(4) === zArchiveExtraDataSignature) {
|
|
|
|
info(" Found an Archive Extra Data Signature");
|
|
|
|
info(" Found an Archive Extra Data Signature");
|
|
|
|
|
|
|
|
|
|
|
|
// skipping this record for now
|
|
|
|
// skipping this record for now
|
|
|
|
@ -176,11 +176,11 @@ var unzip = function(arrayBuffer) {
|
|
|
|
|
|
|
|
|
|
|
|
// central directory structure
|
|
|
|
// central directory structure
|
|
|
|
// TODO: handle the rest of the structures (Zip64 stuff)
|
|
|
|
// TODO: handle the rest of the structures (Zip64 stuff)
|
|
|
|
if (bstream.peekNumber(4) == zCentralFileHeaderSignature) {
|
|
|
|
if (bstream.peekNumber(4) === zCentralFileHeaderSignature) {
|
|
|
|
info(" Found a Central File Header");
|
|
|
|
info(" Found a Central File Header");
|
|
|
|
|
|
|
|
|
|
|
|
// read all file headers
|
|
|
|
// read all file headers
|
|
|
|
while (bstream.peekNumber(4) == zCentralFileHeaderSignature) {
|
|
|
|
while (bstream.peekNumber(4) === zCentralFileHeaderSignature) {
|
|
|
|
bstream.readNumber(4); // signature
|
|
|
|
bstream.readNumber(4); // signature
|
|
|
|
bstream.readNumber(2); // version made by
|
|
|
|
bstream.readNumber(2); // version made by
|
|
|
|
bstream.readNumber(2); // version needed to extract
|
|
|
|
bstream.readNumber(2); // version needed to extract
|
|
|
|
@ -206,7 +206,7 @@ var unzip = function(arrayBuffer) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// digital signature
|
|
|
|
// digital signature
|
|
|
|
if (bstream.peekNumber(4) == zDigitalSignatureSignature) {
|
|
|
|
if (bstream.peekNumber(4) === zDigitalSignatureSignature) {
|
|
|
|
info(" Found a Digital Signature");
|
|
|
|
info(" Found a Digital Signature");
|
|
|
|
|
|
|
|
|
|
|
|
bstream.readNumber(4);
|
|
|
|
bstream.readNumber(4);
|
|
|
|
@ -231,7 +231,7 @@ var unzip = function(arrayBuffer) {
|
|
|
|
// actually do the unzipping
|
|
|
|
// actually do the unzipping
|
|
|
|
localfile.unzip();
|
|
|
|
localfile.unzip();
|
|
|
|
|
|
|
|
|
|
|
|
if (localfile.fileData != null) {
|
|
|
|
if (localfile.fileData !== null) {
|
|
|
|
postMessage(new bitjs.archive.UnarchiveExtractEvent(localfile));
|
|
|
|
postMessage(new bitjs.archive.UnarchiveExtractEvent(localfile));
|
|
|
|
postProgress();
|
|
|
|
postProgress();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -239,58 +239,58 @@ var unzip = function(arrayBuffer) {
|
|
|
|
postProgress();
|
|
|
|
postProgress();
|
|
|
|
postMessage(new bitjs.archive.UnarchiveFinishEvent());
|
|
|
|
postMessage(new bitjs.archive.UnarchiveFinishEvent());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
// returns a table of Huffman codes
|
|
|
|
// returns a table of Huffman codes
|
|
|
|
// each entry's index is its code and its value is a JavaScript object
|
|
|
|
// each entry's index is its code and its value is a JavaScript object
|
|
|
|
// containing {length: 6, symbol: X}
|
|
|
|
// containing {length: 6, symbol: X}
|
|
|
|
function getHuffmanCodes(bitLengths) {
|
|
|
|
function getHuffmanCodes(bitLengths) {
|
|
|
|
// ensure bitLengths is an array containing at least one element
|
|
|
|
// ensure bitLengths is an array containing at least one element
|
|
|
|
if (typeof bitLengths != typeof [] || bitLengths.length < 1) {
|
|
|
|
if (typeof bitLengths !== typeof [] || bitLengths.length < 1) {
|
|
|
|
err("Error! getHuffmanCodes() called with an invalid array");
|
|
|
|
err("Error! getHuffmanCodes() called with an invalid array");
|
|
|
|
return null;
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Reference: http://tools.ietf.org/html/rfc1951#page-8
|
|
|
|
// Reference: http://tools.ietf.org/html/rfc1951#page-8
|
|
|
|
var numLengths = bitLengths.length,
|
|
|
|
var numLengths = bitLengths.length,
|
|
|
|
bl_count = [],
|
|
|
|
blCount = [],
|
|
|
|
MAX_BITS = 1;
|
|
|
|
MAX_BITS = 1;
|
|
|
|
|
|
|
|
|
|
|
|
// Step 1: count up how many codes of each length we have
|
|
|
|
// Step 1: count up how many codes of each length we have
|
|
|
|
for (var i = 0; i < numLengths; ++i) {
|
|
|
|
for (var i = 0; i < numLengths; ++i) {
|
|
|
|
var length = bitLengths[i];
|
|
|
|
var len = bitLengths[i];
|
|
|
|
// test to ensure each bit length is a positive, non-zero number
|
|
|
|
// test to ensure each bit length is a positive, non-zero number
|
|
|
|
if (typeof length != typeof 1 || length < 0) {
|
|
|
|
if (typeof len !== typeof 1 || len < 0) {
|
|
|
|
err("bitLengths contained an invalid number in getHuffmanCodes(): " + length + " of type " + (typeof length));
|
|
|
|
err("bitLengths contained an invalid number in getHuffmanCodes(): " + len + " of type " + (typeof len));
|
|
|
|
return null;
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// increment the appropriate bitlength count
|
|
|
|
// increment the appropriate bitlength count
|
|
|
|
if (bl_count[length] == undefined) bl_count[length] = 0;
|
|
|
|
if (blCount[len] === undefined) blCount[len] = 0;
|
|
|
|
// a length of zero means this symbol is not participating in the huffman coding
|
|
|
|
// a length of zero means this symbol is not participating in the huffman coding
|
|
|
|
if (length > 0) bl_count[length]++;
|
|
|
|
if (len > 0) blCount[len]++;
|
|
|
|
|
|
|
|
|
|
|
|
if (length > MAX_BITS) MAX_BITS = length;
|
|
|
|
if (len > MAX_BITS) MAX_BITS = len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Step 2: Find the numerical value of the smallest code for each code length
|
|
|
|
// Step 2: Find the numerical value of the smallest code for each code length
|
|
|
|
var next_code = [],
|
|
|
|
var nextCode = [],
|
|
|
|
code = 0;
|
|
|
|
code = 0;
|
|
|
|
for (var bits = 1; bits <= MAX_BITS; ++bits) {
|
|
|
|
for (var bits = 1; bits <= MAX_BITS; ++bits) {
|
|
|
|
var length = bits-1;
|
|
|
|
var len = bits-1;
|
|
|
|
// ensure undefined lengths are zero
|
|
|
|
// ensure undefined lengths are zero
|
|
|
|
if (bl_count[length] == undefined) bl_count[length] = 0;
|
|
|
|
if (blCount[len] == undefined) blCount[len] = 0;
|
|
|
|
code = (code + bl_count[bits-1]) << 1;
|
|
|
|
code = (code + blCount[bits-1]) << 1;
|
|
|
|
next_code[bits] = code;
|
|
|
|
nextCode[bits] = code;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Step 3: Assign numerical values to all codes
|
|
|
|
// Step 3: Assign numerical values to all codes
|
|
|
|
var table = {}, tableLength = 0;
|
|
|
|
var table = {}, tableLength = 0;
|
|
|
|
for (var n = 0; n < numLengths; ++n) {
|
|
|
|
for (var n = 0; n < numLengths; ++n) {
|
|
|
|
var len = bitLengths[n];
|
|
|
|
var len = bitLengths[n];
|
|
|
|
if (len != 0) {
|
|
|
|
if (len !== 0) {
|
|
|
|
table[next_code[len]] = { length: len, symbol: n }; //, bitstring: binaryValueToString(next_code[len],len) };
|
|
|
|
table[nextCode[len]] = { length: len, symbol: n }; //, bitstring: binaryValueToString(nextCode[len],len) };
|
|
|
|
tableLength++;
|
|
|
|
tableLength++;
|
|
|
|
next_code[len]++;
|
|
|
|
nextCode[len]++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
table.maxLength = tableLength;
|
|
|
|
table.maxLength = tableLength;
|
|
|
|
@ -322,9 +322,9 @@ function getFixedLiteralTable() {
|
|
|
|
if (!fixedHCtoLiteral) {
|
|
|
|
if (!fixedHCtoLiteral) {
|
|
|
|
var bitlengths = new Array(288);
|
|
|
|
var bitlengths = new Array(288);
|
|
|
|
for (var i = 0; i <= 143; ++i) bitlengths[i] = 8;
|
|
|
|
for (var i = 0; i <= 143; ++i) bitlengths[i] = 8;
|
|
|
|
for (i = 144; i <= 255; ++i) bitlengths[i] = 9;
|
|
|
|
for (var i = 144; i <= 255; ++i) bitlengths[i] = 9;
|
|
|
|
for (i = 256; i <= 279; ++i) bitlengths[i] = 7;
|
|
|
|
for (var i = 256; i <= 279; ++i) bitlengths[i] = 7;
|
|
|
|
for (i = 280; i <= 287; ++i) bitlengths[i] = 8;
|
|
|
|
for (var i = 280; i <= 287; ++i) bitlengths[i] = 8;
|
|
|
|
|
|
|
|
|
|
|
|
// get huffman code table
|
|
|
|
// get huffman code table
|
|
|
|
fixedHCtoLiteral = getHuffmanCodes(bitlengths);
|
|
|
|
fixedHCtoLiteral = getHuffmanCodes(bitlengths);
|
|
|
|
@ -335,7 +335,9 @@ function getFixedDistanceTable() {
|
|
|
|
// create once
|
|
|
|
// create once
|
|
|
|
if (!fixedHCtoDistance) {
|
|
|
|
if (!fixedHCtoDistance) {
|
|
|
|
var bitlengths = new Array(32);
|
|
|
|
var bitlengths = new Array(32);
|
|
|
|
for (var i = 0; i < 32; ++i) { bitlengths[i] = 5; }
|
|
|
|
for (var i = 0; i < 32; ++i) {
|
|
|
|
|
|
|
|
bitlengths[i] = 5;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// get huffman code table
|
|
|
|
// get huffman code table
|
|
|
|
fixedHCtoDistance = getHuffmanCodes(bitlengths);
|
|
|
|
fixedHCtoDistance = getHuffmanCodes(bitlengths);
|
|
|
|
@ -347,7 +349,7 @@ function getFixedDistanceTable() {
|
|
|
|
// then return that symbol
|
|
|
|
// then return that symbol
|
|
|
|
function decodeSymbol(bstream, hcTable) {
|
|
|
|
function decodeSymbol(bstream, hcTable) {
|
|
|
|
var code = 0, len = 0;
|
|
|
|
var code = 0, len = 0;
|
|
|
|
var match = false;
|
|
|
|
// var match = false;
|
|
|
|
|
|
|
|
|
|
|
|
// loop until we match
|
|
|
|
// loop until we match
|
|
|
|
for (;;) {
|
|
|
|
for (;;) {
|
|
|
|
@ -389,14 +391,14 @@ var CodeLengthCodeOrder = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2
|
|
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
var LengthLookupTable = [
|
|
|
|
var LengthLookupTable = [
|
|
|
|
[0,3], [0,4], [0,5], [0,6],
|
|
|
|
[0, 3], [0, 4], [0, 5], [0, 6],
|
|
|
|
[0,7], [0,8], [0,9], [0,10],
|
|
|
|
[0, 7], [0, 8], [0, 9], [0, 10],
|
|
|
|
[1,11], [1,13], [1,15], [1,17],
|
|
|
|
[1, 11], [1, 13], [1, 15], [1, 17],
|
|
|
|
[2,19], [2,23], [2,27], [2,31],
|
|
|
|
[2, 19], [2, 23], [2, 27], [2, 31],
|
|
|
|
[3,35], [3,43], [3,51], [3,59],
|
|
|
|
[3, 35], [3, 43], [3, 51], [3, 59],
|
|
|
|
[4,67], [4,83], [4,99], [4,115],
|
|
|
|
[4, 67], [4, 83], [4, 99], [4, 115],
|
|
|
|
[5,131], [5,163], [5,195], [5,227],
|
|
|
|
[5, 131], [5, 163], [5, 195], [5, 227],
|
|
|
|
[0,258]
|
|
|
|
[0, 258]
|
|
|
|
];
|
|
|
|
];
|
|
|
|
/*
|
|
|
|
/*
|
|
|
|
Extra Extra Extra
|
|
|
|
Extra Extra Extra
|
|
|
|
@ -414,20 +416,20 @@ var LengthLookupTable = [
|
|
|
|
9 3 25-32 19 8 769-1024 29 13 24577-32768
|
|
|
|
9 3 25-32 19 8 769-1024 29 13 24577-32768
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
var DistLookupTable = [
|
|
|
|
var DistLookupTable = [
|
|
|
|
[0,1], [0,2], [0,3], [0,4],
|
|
|
|
[0, 1], [0, 2], [0, 3], [0, 4],
|
|
|
|
[1,5], [1,7],
|
|
|
|
[1, 5], [1, 7],
|
|
|
|
[2,9], [2,13],
|
|
|
|
[2, 9], [2, 13],
|
|
|
|
[3,17], [3,25],
|
|
|
|
[3, 17], [3, 25],
|
|
|
|
[4,33], [4,49],
|
|
|
|
[4, 33], [4, 49],
|
|
|
|
[5,65], [5,97],
|
|
|
|
[5, 65], [5, 97],
|
|
|
|
[6,129], [6,193],
|
|
|
|
[6, 129], [6, 193],
|
|
|
|
[7,257], [7,385],
|
|
|
|
[7, 257], [7, 385],
|
|
|
|
[8,513], [8,769],
|
|
|
|
[8, 513], [8, 769],
|
|
|
|
[9,1025], [9,1537],
|
|
|
|
[9, 1025], [9, 1537],
|
|
|
|
[10,2049], [10,3073],
|
|
|
|
[10, 2049], [10, 3073],
|
|
|
|
[11,4097], [11,6145],
|
|
|
|
[11, 4097], [11, 6145],
|
|
|
|
[12,8193], [12,12289],
|
|
|
|
[12, 8193], [12, 12289],
|
|
|
|
[13,16385], [13,24577]
|
|
|
|
[13, 16385], [13, 24577]
|
|
|
|
];
|
|
|
|
];
|
|
|
|
|
|
|
|
|
|
|
|
function inflateBlockData(bstream, hcLiteralTable, hcDistanceTable, buffer) {
|
|
|
|
function inflateBlockData(bstream, hcLiteralTable, hcDistanceTable, buffer) {
|
|
|
|
@ -457,7 +459,7 @@ function inflateBlockData(bstream, hcLiteralTable, hcDistanceTable, buffer) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
else {
|
|
|
|
// end of block reached
|
|
|
|
// end of block reached
|
|
|
|
if (symbol == 256) {
|
|
|
|
if (symbol === 256) {
|
|
|
|
break;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
else {
|
|
|
|
@ -504,12 +506,13 @@ function inflate(compressedData, numDecompressedBytes) {
|
|
|
|
compressedData.byteOffset,
|
|
|
|
compressedData.byteOffset,
|
|
|
|
compressedData.byteLength);
|
|
|
|
compressedData.byteLength);
|
|
|
|
var buffer = new bitjs.io.ByteBuffer(numDecompressedBytes);
|
|
|
|
var buffer = new bitjs.io.ByteBuffer(numDecompressedBytes);
|
|
|
|
var numBlocks = 0, blockSize = 0;
|
|
|
|
var numBlocks = 0;
|
|
|
|
|
|
|
|
var blockSize = 0;
|
|
|
|
|
|
|
|
|
|
|
|
// block format: http://tools.ietf.org/html/rfc1951#page-9
|
|
|
|
// block format: http://tools.ietf.org/html/rfc1951#page-9
|
|
|
|
do {
|
|
|
|
do {
|
|
|
|
var bFinal = bstream.readBits(1),
|
|
|
|
var bFinal = bstream.readBits(1);
|
|
|
|
bType = bstream.readBits(2);
|
|
|
|
var bType = bstream.readBits(2);
|
|
|
|
blockSize = 0;
|
|
|
|
blockSize = 0;
|
|
|
|
++numBlocks;
|
|
|
|
++numBlocks;
|
|
|
|
// no compression
|
|
|
|
// no compression
|
|
|
|
@ -524,17 +527,17 @@ function inflate(compressedData, numDecompressedBytes) {
|
|
|
|
blockSize = len;
|
|
|
|
blockSize = len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// fixed Huffman codes
|
|
|
|
// fixed Huffman codes
|
|
|
|
else if(bType == 1) {
|
|
|
|
else if(bType === 1) {
|
|
|
|
blockSize = inflateBlockData(bstream, getFixedLiteralTable(), getFixedDistanceTable(), buffer);
|
|
|
|
blockSize = inflateBlockData(bstream, getFixedLiteralTable(), getFixedDistanceTable(), buffer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// dynamic Huffman codes
|
|
|
|
// dynamic Huffman codes
|
|
|
|
else if(bType == 2) {
|
|
|
|
else if(bType === 2) {
|
|
|
|
var numLiteralLengthCodes = bstream.readBits(5) + 257;
|
|
|
|
var numLiteralLengthCodes = bstream.readBits(5) + 257;
|
|
|
|
var numDistanceCodes = bstream.readBits(5) + 1,
|
|
|
|
var numDistanceCodes = bstream.readBits(5) + 1,
|
|
|
|
numCodeLengthCodes = bstream.readBits(4) + 4;
|
|
|
|
numCodeLengthCodes = bstream.readBits(4) + 4;
|
|
|
|
|
|
|
|
|
|
|
|
// populate the array of code length codes (first de-compaction)
|
|
|
|
// populate the array of code length codes (first de-compaction)
|
|
|
|
var codeLengthsCodeLengths = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
|
|
|
|
var codeLengthsCodeLengths = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
|
|
|
|
for (var i = 0; i < numCodeLengthCodes; ++i) {
|
|
|
|
for (var i = 0; i < numCodeLengthCodes; ++i) {
|
|
|
|
codeLengthsCodeLengths[ CodeLengthCodeOrder[i] ] = bstream.readBits(3);
|
|
|
|
codeLengthsCodeLengths[ CodeLengthCodeOrder[i] ] = bstream.readBits(3);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -566,19 +569,19 @@ function inflate(compressedData, numDecompressedBytes) {
|
|
|
|
literalCodeLengths.push(symbol);
|
|
|
|
literalCodeLengths.push(symbol);
|
|
|
|
prevCodeLength = symbol;
|
|
|
|
prevCodeLength = symbol;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (symbol == 16) {
|
|
|
|
else if (symbol === 16) {
|
|
|
|
var repeat = bstream.readBits(2) + 3;
|
|
|
|
var repeat = bstream.readBits(2) + 3;
|
|
|
|
while (repeat--) {
|
|
|
|
while (repeat--) {
|
|
|
|
literalCodeLengths.push(prevCodeLength);
|
|
|
|
literalCodeLengths.push(prevCodeLength);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (symbol == 17) {
|
|
|
|
else if (symbol === 17) {
|
|
|
|
var repeat = bstream.readBits(3) + 3;
|
|
|
|
var repeat = bstream.readBits(3) + 3;
|
|
|
|
while (repeat--) {
|
|
|
|
while (repeat--) {
|
|
|
|
literalCodeLengths.push(0);
|
|
|
|
literalCodeLengths.push(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (symbol == 18) {
|
|
|
|
else if (symbol === 18) {
|
|
|
|
var repeat = bstream.readBits(7) + 11;
|
|
|
|
var repeat = bstream.readBits(7) + 11;
|
|
|
|
while (repeat--) {
|
|
|
|
while (repeat--) {
|
|
|
|
literalCodeLengths.push(0);
|
|
|
|
literalCodeLengths.push(0);
|
|
|
|
@ -605,7 +608,7 @@ function inflate(compressedData, numDecompressedBytes) {
|
|
|
|
currentBytesUnarchived += blockSize;
|
|
|
|
currentBytesUnarchived += blockSize;
|
|
|
|
postProgress();
|
|
|
|
postProgress();
|
|
|
|
|
|
|
|
|
|
|
|
} while (bFinal != 1);
|
|
|
|
} while (bFinal !== 1);
|
|
|
|
// we are done reading blocks if the bFinal bit was set for this block
|
|
|
|
// we are done reading blocks if the bFinal bit was set for this block
|
|
|
|
|
|
|
|
|
|
|
|
// return the buffer data bytes
|
|
|
|
// return the buffer data bytes
|
|
|
|
|
unknown
7 years ago