881 lines
32 KiB
JavaScript
881 lines
32 KiB
JavaScript
/* Extracted from https://github.com/devongovett/png.js/ */
|
|
/*
|
|
# MIT LICENSE
|
|
# Copyright (c) 2011 Devon Govett
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining a copy of this
|
|
# software and associated documentation files (the "Software"), to deal in the Software
|
|
# without restriction, including without limitation the rights to use, copy, modify, merge,
|
|
# publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
|
|
# to whom the Software is furnished to do so, subject to the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be included in all copies or
|
|
# substantial portions of the Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
|
|
# BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
|
|
/*
|
|
* Extracted from pdf.js
|
|
* https://github.com/andreasgal/pdf.js
|
|
*
|
|
* Copyright (c) 2011 Mozilla Foundation
|
|
*
|
|
* Contributors: Andreas Gal <gal@mozilla.com>
|
|
* Chris G Jones <cjones@mozilla.com>
|
|
* Shaon Barman <shaon.barman@gmail.com>
|
|
* Vivien Nicolas <21@vingtetun.org>
|
|
* Justin D'Arcangelo <justindarc@gmail.com>
|
|
* Yury Delendik
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
var DecodeStream = (function() {
|
|
function constructor() {
|
|
this.pos = 0;
|
|
this.bufferLength = 0;
|
|
this.eof = false;
|
|
this.buffer = null;
|
|
}
|
|
|
|
constructor.prototype = {
|
|
ensureBuffer: function decodestream_ensureBuffer(requested) {
|
|
var buffer = this.buffer;
|
|
var current = buffer ? buffer.byteLength : 0;
|
|
if (requested < current)
|
|
return buffer;
|
|
var size = 512;
|
|
while (size < requested)
|
|
size <<= 1;
|
|
var buffer2 = new Uint8Array(size);
|
|
for (var i = 0; i < current; ++i)
|
|
buffer2[i] = buffer[i];
|
|
return this.buffer = buffer2;
|
|
},
|
|
getByte: function decodestream_getByte() {
|
|
var pos = this.pos;
|
|
while (this.bufferLength <= pos) {
|
|
if (this.eof)
|
|
return null;
|
|
this.readBlock();
|
|
}
|
|
return this.buffer[this.pos++];
|
|
},
|
|
getBytes: function decodestream_getBytes(length) {
|
|
var pos = this.pos;
|
|
|
|
if (length) {
|
|
this.ensureBuffer(pos + length);
|
|
var end = pos + length;
|
|
|
|
while (!this.eof && this.bufferLength < end)
|
|
this.readBlock();
|
|
|
|
var bufEnd = this.bufferLength;
|
|
if (end > bufEnd)
|
|
end = bufEnd;
|
|
} else {
|
|
while (!this.eof)
|
|
this.readBlock();
|
|
|
|
var end = this.bufferLength;
|
|
}
|
|
|
|
this.pos = end;
|
|
return this.buffer.subarray(pos, end);
|
|
},
|
|
lookChar: function decodestream_lookChar() {
|
|
var pos = this.pos;
|
|
while (this.bufferLength <= pos) {
|
|
if (this.eof)
|
|
return null;
|
|
this.readBlock();
|
|
}
|
|
return String.fromCharCode(this.buffer[this.pos]);
|
|
},
|
|
getChar: function decodestream_getChar() {
|
|
var pos = this.pos;
|
|
while (this.bufferLength <= pos) {
|
|
if (this.eof)
|
|
return null;
|
|
this.readBlock();
|
|
}
|
|
return String.fromCharCode(this.buffer[this.pos++]);
|
|
},
|
|
makeSubStream: function decodestream_makeSubstream(start, length, dict) {
|
|
var end = start + length;
|
|
while (this.bufferLength <= end && !this.eof)
|
|
this.readBlock();
|
|
return new Stream(this.buffer, start, length, dict);
|
|
},
|
|
skip: function decodestream_skip(n) {
|
|
if (!n)
|
|
n = 1;
|
|
this.pos += n;
|
|
},
|
|
reset: function decodestream_reset() {
|
|
this.pos = 0;
|
|
}
|
|
};
|
|
|
|
return constructor;
|
|
})();
|
|
|
|
var FlateStream = (function() {
|
|
var codeLenCodeMap = new Uint32Array([
|
|
16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
|
|
]);
|
|
|
|
var lengthDecode = new Uint32Array([
|
|
0x00003, 0x00004, 0x00005, 0x00006, 0x00007, 0x00008, 0x00009, 0x0000a,
|
|
0x1000b, 0x1000d, 0x1000f, 0x10011, 0x20013, 0x20017, 0x2001b, 0x2001f,
|
|
0x30023, 0x3002b, 0x30033, 0x3003b, 0x40043, 0x40053, 0x40063, 0x40073,
|
|
0x50083, 0x500a3, 0x500c3, 0x500e3, 0x00102, 0x00102, 0x00102
|
|
]);
|
|
|
|
var distDecode = new Uint32Array([
|
|
0x00001, 0x00002, 0x00003, 0x00004, 0x10005, 0x10007, 0x20009, 0x2000d,
|
|
0x30011, 0x30019, 0x40021, 0x40031, 0x50041, 0x50061, 0x60081, 0x600c1,
|
|
0x70101, 0x70181, 0x80201, 0x80301, 0x90401, 0x90601, 0xa0801, 0xa0c01,
|
|
0xb1001, 0xb1801, 0xc2001, 0xc3001, 0xd4001, 0xd6001
|
|
]);
|
|
|
|
var fixedLitCodeTab = [new Uint32Array([
|
|
0x70100, 0x80050, 0x80010, 0x80118, 0x70110, 0x80070, 0x80030, 0x900c0,
|
|
0x70108, 0x80060, 0x80020, 0x900a0, 0x80000, 0x80080, 0x80040, 0x900e0,
|
|
0x70104, 0x80058, 0x80018, 0x90090, 0x70114, 0x80078, 0x80038, 0x900d0,
|
|
0x7010c, 0x80068, 0x80028, 0x900b0, 0x80008, 0x80088, 0x80048, 0x900f0,
|
|
0x70102, 0x80054, 0x80014, 0x8011c, 0x70112, 0x80074, 0x80034, 0x900c8,
|
|
0x7010a, 0x80064, 0x80024, 0x900a8, 0x80004, 0x80084, 0x80044, 0x900e8,
|
|
0x70106, 0x8005c, 0x8001c, 0x90098, 0x70116, 0x8007c, 0x8003c, 0x900d8,
|
|
0x7010e, 0x8006c, 0x8002c, 0x900b8, 0x8000c, 0x8008c, 0x8004c, 0x900f8,
|
|
0x70101, 0x80052, 0x80012, 0x8011a, 0x70111, 0x80072, 0x80032, 0x900c4,
|
|
0x70109, 0x80062, 0x80022, 0x900a4, 0x80002, 0x80082, 0x80042, 0x900e4,
|
|
0x70105, 0x8005a, 0x8001a, 0x90094, 0x70115, 0x8007a, 0x8003a, 0x900d4,
|
|
0x7010d, 0x8006a, 0x8002a, 0x900b4, 0x8000a, 0x8008a, 0x8004a, 0x900f4,
|
|
0x70103, 0x80056, 0x80016, 0x8011e, 0x70113, 0x80076, 0x80036, 0x900cc,
|
|
0x7010b, 0x80066, 0x80026, 0x900ac, 0x80006, 0x80086, 0x80046, 0x900ec,
|
|
0x70107, 0x8005e, 0x8001e, 0x9009c, 0x70117, 0x8007e, 0x8003e, 0x900dc,
|
|
0x7010f, 0x8006e, 0x8002e, 0x900bc, 0x8000e, 0x8008e, 0x8004e, 0x900fc,
|
|
0x70100, 0x80051, 0x80011, 0x80119, 0x70110, 0x80071, 0x80031, 0x900c2,
|
|
0x70108, 0x80061, 0x80021, 0x900a2, 0x80001, 0x80081, 0x80041, 0x900e2,
|
|
0x70104, 0x80059, 0x80019, 0x90092, 0x70114, 0x80079, 0x80039, 0x900d2,
|
|
0x7010c, 0x80069, 0x80029, 0x900b2, 0x80009, 0x80089, 0x80049, 0x900f2,
|
|
0x70102, 0x80055, 0x80015, 0x8011d, 0x70112, 0x80075, 0x80035, 0x900ca,
|
|
0x7010a, 0x80065, 0x80025, 0x900aa, 0x80005, 0x80085, 0x80045, 0x900ea,
|
|
0x70106, 0x8005d, 0x8001d, 0x9009a, 0x70116, 0x8007d, 0x8003d, 0x900da,
|
|
0x7010e, 0x8006d, 0x8002d, 0x900ba, 0x8000d, 0x8008d, 0x8004d, 0x900fa,
|
|
0x70101, 0x80053, 0x80013, 0x8011b, 0x70111, 0x80073, 0x80033, 0x900c6,
|
|
0x70109, 0x80063, 0x80023, 0x900a6, 0x80003, 0x80083, 0x80043, 0x900e6,
|
|
0x70105, 0x8005b, 0x8001b, 0x90096, 0x70115, 0x8007b, 0x8003b, 0x900d6,
|
|
0x7010d, 0x8006b, 0x8002b, 0x900b6, 0x8000b, 0x8008b, 0x8004b, 0x900f6,
|
|
0x70103, 0x80057, 0x80017, 0x8011f, 0x70113, 0x80077, 0x80037, 0x900ce,
|
|
0x7010b, 0x80067, 0x80027, 0x900ae, 0x80007, 0x80087, 0x80047, 0x900ee,
|
|
0x70107, 0x8005f, 0x8001f, 0x9009e, 0x70117, 0x8007f, 0x8003f, 0x900de,
|
|
0x7010f, 0x8006f, 0x8002f, 0x900be, 0x8000f, 0x8008f, 0x8004f, 0x900fe,
|
|
0x70100, 0x80050, 0x80010, 0x80118, 0x70110, 0x80070, 0x80030, 0x900c1,
|
|
0x70108, 0x80060, 0x80020, 0x900a1, 0x80000, 0x80080, 0x80040, 0x900e1,
|
|
0x70104, 0x80058, 0x80018, 0x90091, 0x70114, 0x80078, 0x80038, 0x900d1,
|
|
0x7010c, 0x80068, 0x80028, 0x900b1, 0x80008, 0x80088, 0x80048, 0x900f1,
|
|
0x70102, 0x80054, 0x80014, 0x8011c, 0x70112, 0x80074, 0x80034, 0x900c9,
|
|
0x7010a, 0x80064, 0x80024, 0x900a9, 0x80004, 0x80084, 0x80044, 0x900e9,
|
|
0x70106, 0x8005c, 0x8001c, 0x90099, 0x70116, 0x8007c, 0x8003c, 0x900d9,
|
|
0x7010e, 0x8006c, 0x8002c, 0x900b9, 0x8000c, 0x8008c, 0x8004c, 0x900f9,
|
|
0x70101, 0x80052, 0x80012, 0x8011a, 0x70111, 0x80072, 0x80032, 0x900c5,
|
|
0x70109, 0x80062, 0x80022, 0x900a5, 0x80002, 0x80082, 0x80042, 0x900e5,
|
|
0x70105, 0x8005a, 0x8001a, 0x90095, 0x70115, 0x8007a, 0x8003a, 0x900d5,
|
|
0x7010d, 0x8006a, 0x8002a, 0x900b5, 0x8000a, 0x8008a, 0x8004a, 0x900f5,
|
|
0x70103, 0x80056, 0x80016, 0x8011e, 0x70113, 0x80076, 0x80036, 0x900cd,
|
|
0x7010b, 0x80066, 0x80026, 0x900ad, 0x80006, 0x80086, 0x80046, 0x900ed,
|
|
0x70107, 0x8005e, 0x8001e, 0x9009d, 0x70117, 0x8007e, 0x8003e, 0x900dd,
|
|
0x7010f, 0x8006e, 0x8002e, 0x900bd, 0x8000e, 0x8008e, 0x8004e, 0x900fd,
|
|
0x70100, 0x80051, 0x80011, 0x80119, 0x70110, 0x80071, 0x80031, 0x900c3,
|
|
0x70108, 0x80061, 0x80021, 0x900a3, 0x80001, 0x80081, 0x80041, 0x900e3,
|
|
0x70104, 0x80059, 0x80019, 0x90093, 0x70114, 0x80079, 0x80039, 0x900d3,
|
|
0x7010c, 0x80069, 0x80029, 0x900b3, 0x80009, 0x80089, 0x80049, 0x900f3,
|
|
0x70102, 0x80055, 0x80015, 0x8011d, 0x70112, 0x80075, 0x80035, 0x900cb,
|
|
0x7010a, 0x80065, 0x80025, 0x900ab, 0x80005, 0x80085, 0x80045, 0x900eb,
|
|
0x70106, 0x8005d, 0x8001d, 0x9009b, 0x70116, 0x8007d, 0x8003d, 0x900db,
|
|
0x7010e, 0x8006d, 0x8002d, 0x900bb, 0x8000d, 0x8008d, 0x8004d, 0x900fb,
|
|
0x70101, 0x80053, 0x80013, 0x8011b, 0x70111, 0x80073, 0x80033, 0x900c7,
|
|
0x70109, 0x80063, 0x80023, 0x900a7, 0x80003, 0x80083, 0x80043, 0x900e7,
|
|
0x70105, 0x8005b, 0x8001b, 0x90097, 0x70115, 0x8007b, 0x8003b, 0x900d7,
|
|
0x7010d, 0x8006b, 0x8002b, 0x900b7, 0x8000b, 0x8008b, 0x8004b, 0x900f7,
|
|
0x70103, 0x80057, 0x80017, 0x8011f, 0x70113, 0x80077, 0x80037, 0x900cf,
|
|
0x7010b, 0x80067, 0x80027, 0x900af, 0x80007, 0x80087, 0x80047, 0x900ef,
|
|
0x70107, 0x8005f, 0x8001f, 0x9009f, 0x70117, 0x8007f, 0x8003f, 0x900df,
|
|
0x7010f, 0x8006f, 0x8002f, 0x900bf, 0x8000f, 0x8008f, 0x8004f, 0x900ff
|
|
]), 9];
|
|
|
|
var fixedDistCodeTab = [new Uint32Array([
|
|
0x50000, 0x50010, 0x50008, 0x50018, 0x50004, 0x50014, 0x5000c, 0x5001c,
|
|
0x50002, 0x50012, 0x5000a, 0x5001a, 0x50006, 0x50016, 0x5000e, 0x00000,
|
|
0x50001, 0x50011, 0x50009, 0x50019, 0x50005, 0x50015, 0x5000d, 0x5001d,
|
|
0x50003, 0x50013, 0x5000b, 0x5001b, 0x50007, 0x50017, 0x5000f, 0x00000
|
|
]), 5];
|
|
|
|
function error(e) {
|
|
throw new Error(e)
|
|
}
|
|
|
|
function constructor(bytes) {
|
|
//var bytes = stream.getBytes();
|
|
var bytesPos = 0;
|
|
|
|
var cmf = bytes[bytesPos++];
|
|
var flg = bytes[bytesPos++];
|
|
if (cmf == -1 || flg == -1)
|
|
error('Invalid header in flate stream');
|
|
if ((cmf & 0x0f) != 0x08)
|
|
error('Unknown compression method in flate stream');
|
|
if ((((cmf << 8) + flg) % 31) != 0)
|
|
error('Bad FCHECK in flate stream');
|
|
if (flg & 0x20)
|
|
error('FDICT bit set in flate stream');
|
|
|
|
this.bytes = bytes;
|
|
this.bytesPos = bytesPos;
|
|
|
|
this.codeSize = 0;
|
|
this.codeBuf = 0;
|
|
|
|
DecodeStream.call(this);
|
|
}
|
|
|
|
constructor.prototype = Object.create(DecodeStream.prototype);
|
|
|
|
constructor.prototype.getBits = function(bits) {
|
|
var codeSize = this.codeSize;
|
|
var codeBuf = this.codeBuf;
|
|
var bytes = this.bytes;
|
|
var bytesPos = this.bytesPos;
|
|
|
|
var b;
|
|
while (codeSize < bits) {
|
|
if (typeof (b = bytes[bytesPos++]) == 'undefined')
|
|
error('Bad encoding in flate stream');
|
|
codeBuf |= b << codeSize;
|
|
codeSize += 8;
|
|
}
|
|
b = codeBuf & ((1 << bits) - 1);
|
|
this.codeBuf = codeBuf >> bits;
|
|
this.codeSize = codeSize -= bits;
|
|
this.bytesPos = bytesPos;
|
|
return b;
|
|
};
|
|
|
|
constructor.prototype.getCode = function(table) {
|
|
var codes = table[0];
|
|
var maxLen = table[1];
|
|
var codeSize = this.codeSize;
|
|
var codeBuf = this.codeBuf;
|
|
var bytes = this.bytes;
|
|
var bytesPos = this.bytesPos;
|
|
|
|
while (codeSize < maxLen) {
|
|
var b;
|
|
if (typeof (b = bytes[bytesPos++]) == 'undefined')
|
|
error('Bad encoding in flate stream');
|
|
codeBuf |= (b << codeSize);
|
|
codeSize += 8;
|
|
}
|
|
var code = codes[codeBuf & ((1 << maxLen) - 1)];
|
|
var codeLen = code >> 16;
|
|
var codeVal = code & 0xffff;
|
|
if (codeSize == 0 || codeSize < codeLen || codeLen == 0)
|
|
error('Bad encoding in flate stream');
|
|
this.codeBuf = (codeBuf >> codeLen);
|
|
this.codeSize = (codeSize - codeLen);
|
|
this.bytesPos = bytesPos;
|
|
return codeVal;
|
|
};
|
|
|
|
constructor.prototype.generateHuffmanTable = function(lengths) {
|
|
var n = lengths.length;
|
|
|
|
// find max code length
|
|
var maxLen = 0;
|
|
for (var i = 0; i < n; ++i) {
|
|
if (lengths[i] > maxLen)
|
|
maxLen = lengths[i];
|
|
}
|
|
|
|
// build the table
|
|
var size = 1 << maxLen;
|
|
var codes = new Uint32Array(size);
|
|
for (var len = 1, code = 0, skip = 2;
|
|
len <= maxLen;
|
|
++len, code <<= 1, skip <<= 1) {
|
|
for (var val = 0; val < n; ++val) {
|
|
if (lengths[val] == len) {
|
|
// bit-reverse the code
|
|
var code2 = 0;
|
|
var t = code;
|
|
for (var i = 0; i < len; ++i) {
|
|
code2 = (code2 << 1) | (t & 1);
|
|
t >>= 1;
|
|
}
|
|
|
|
// fill the table entries
|
|
for (var i = code2; i < size; i += skip)
|
|
codes[i] = (len << 16) | val;
|
|
|
|
++code;
|
|
}
|
|
}
|
|
}
|
|
|
|
return [codes, maxLen];
|
|
};
|
|
|
|
constructor.prototype.readBlock = function() {
|
|
function repeat(stream, array, len, offset, what) {
|
|
var repeat = stream.getBits(len) + offset;
|
|
while (repeat-- > 0)
|
|
array[i++] = what;
|
|
}
|
|
|
|
// read block header
|
|
var hdr = this.getBits(3);
|
|
if (hdr & 1)
|
|
this.eof = true;
|
|
hdr >>= 1;
|
|
|
|
if (hdr == 0) { // uncompressed block
|
|
var bytes = this.bytes;
|
|
var bytesPos = this.bytesPos;
|
|
var b;
|
|
|
|
if (typeof (b = bytes[bytesPos++]) == 'undefined')
|
|
error('Bad block header in flate stream');
|
|
var blockLen = b;
|
|
if (typeof (b = bytes[bytesPos++]) == 'undefined')
|
|
error('Bad block header in flate stream');
|
|
blockLen |= (b << 8);
|
|
if (typeof (b = bytes[bytesPos++]) == 'undefined')
|
|
error('Bad block header in flate stream');
|
|
var check = b;
|
|
if (typeof (b = bytes[bytesPos++]) == 'undefined')
|
|
error('Bad block header in flate stream');
|
|
check |= (b << 8);
|
|
if (check != (~blockLen & 0xffff))
|
|
error('Bad uncompressed block length in flate stream');
|
|
|
|
this.codeBuf = 0;
|
|
this.codeSize = 0;
|
|
|
|
var bufferLength = this.bufferLength;
|
|
var buffer = this.ensureBuffer(bufferLength + blockLen);
|
|
var end = bufferLength + blockLen;
|
|
this.bufferLength = end;
|
|
for (var n = bufferLength; n < end; ++n) {
|
|
if (typeof (b = bytes[bytesPos++]) == 'undefined') {
|
|
this.eof = true;
|
|
break;
|
|
}
|
|
buffer[n] = b;
|
|
}
|
|
this.bytesPos = bytesPos;
|
|
return;
|
|
}
|
|
|
|
var litCodeTable;
|
|
var distCodeTable;
|
|
if (hdr == 1) { // compressed block, fixed codes
|
|
litCodeTable = fixedLitCodeTab;
|
|
distCodeTable = fixedDistCodeTab;
|
|
} else if (hdr == 2) { // compressed block, dynamic codes
|
|
var numLitCodes = this.getBits(5) + 257;
|
|
var numDistCodes = this.getBits(5) + 1;
|
|
var numCodeLenCodes = this.getBits(4) + 4;
|
|
|
|
// build the code lengths code table
|
|
var codeLenCodeLengths = Array(codeLenCodeMap.length);
|
|
var i = 0;
|
|
while (i < numCodeLenCodes)
|
|
codeLenCodeLengths[codeLenCodeMap[i++]] = this.getBits(3);
|
|
var codeLenCodeTab = this.generateHuffmanTable(codeLenCodeLengths);
|
|
|
|
// build the literal and distance code tables
|
|
var len = 0;
|
|
var i = 0;
|
|
var codes = numLitCodes + numDistCodes;
|
|
var codeLengths = new Array(codes);
|
|
while (i < codes) {
|
|
var code = this.getCode(codeLenCodeTab);
|
|
if (code == 16) {
|
|
repeat(this, codeLengths, 2, 3, len);
|
|
} else if (code == 17) {
|
|
repeat(this, codeLengths, 3, 3, len = 0);
|
|
} else if (code == 18) {
|
|
repeat(this, codeLengths, 7, 11, len = 0);
|
|
} else {
|
|
codeLengths[i++] = len = code;
|
|
}
|
|
}
|
|
|
|
litCodeTable =
|
|
this.generateHuffmanTable(codeLengths.slice(0, numLitCodes));
|
|
distCodeTable =
|
|
this.generateHuffmanTable(codeLengths.slice(numLitCodes, codes));
|
|
} else {
|
|
error('Unknown block type in flate stream');
|
|
}
|
|
|
|
var buffer = this.buffer;
|
|
var limit = buffer ? buffer.length : 0;
|
|
var pos = this.bufferLength;
|
|
while (true) {
|
|
var code1 = this.getCode(litCodeTable);
|
|
if (code1 < 256) {
|
|
if (pos + 1 >= limit) {
|
|
buffer = this.ensureBuffer(pos + 1);
|
|
limit = buffer.length;
|
|
}
|
|
buffer[pos++] = code1;
|
|
continue;
|
|
}
|
|
if (code1 == 256) {
|
|
this.bufferLength = pos;
|
|
return;
|
|
}
|
|
code1 -= 257;
|
|
code1 = lengthDecode[code1];
|
|
var code2 = code1 >> 16;
|
|
if (code2 > 0)
|
|
code2 = this.getBits(code2);
|
|
var len = (code1 & 0xffff) + code2;
|
|
code1 = this.getCode(distCodeTable);
|
|
code1 = distDecode[code1];
|
|
code2 = code1 >> 16;
|
|
if (code2 > 0)
|
|
code2 = this.getBits(code2);
|
|
var dist = (code1 & 0xffff) + code2;
|
|
if (pos + len >= limit) {
|
|
buffer = this.ensureBuffer(pos + len);
|
|
limit = buffer.length;
|
|
}
|
|
for (var k = 0; k < len; ++k, ++pos)
|
|
buffer[pos] = buffer[pos - dist];
|
|
}
|
|
};
|
|
|
|
return constructor;
|
|
})();
|
|
|
|
|
|
/*
|
|
# MIT LICENSE
|
|
# Copyright (c) 2011 Devon Govett
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining a copy of this
|
|
# software and associated documentation files (the "Software"), to deal in the Software
|
|
# without restriction, including without limitation the rights to use, copy, modify, merge,
|
|
# publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
|
|
# to whom the Software is furnished to do so, subject to the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be included in all copies or
|
|
# substantial portions of the Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
|
|
# BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
|
|
var APNG_BLEND_OP_OVER, APNG_BLEND_OP_SOURCE, APNG_DISPOSE_OP_BACKGROUND, APNG_DISPOSE_OP_NONE, APNG_DISPOSE_OP_PREVIOUS, makeImage, scratchCanvas, scratchCtx;
|
|
APNG_DISPOSE_OP_NONE = 0;
|
|
APNG_DISPOSE_OP_BACKGROUND = 1;
|
|
APNG_DISPOSE_OP_PREVIOUS = 2;
|
|
APNG_BLEND_OP_SOURCE = 0;
|
|
APNG_BLEND_OP_OVER = 1;
|
|
function PNG(data) {
|
|
var chunkSize, colors, delayDen, delayNum, frame, i, section, short, _ref;
|
|
this.data = data;
|
|
this.pos = 8;
|
|
this.palette = [];
|
|
this.imgData = [];
|
|
this.transparency = {};
|
|
this.animation = null;
|
|
frame = null;
|
|
while (true) {
|
|
chunkSize = this.readUInt32();
|
|
section = ((function() {
|
|
var _results;
|
|
_results = [];
|
|
for (i = 0; i < 4; i++) {
|
|
_results.push(String.fromCharCode(this.data[this.pos++]));
|
|
}
|
|
return _results;
|
|
}).call(this)).join('');
|
|
switch (section) {
|
|
case 'IHDR':
|
|
this.width = this.readUInt32();
|
|
this.height = this.readUInt32();
|
|
this.bits = this.data[this.pos++];
|
|
this.colorType = this.data[this.pos++];
|
|
this.compressionMethod = this.data[this.pos++];
|
|
this.filterMethod = this.data[this.pos++];
|
|
this.interlaceMethod = this.data[this.pos++];
|
|
break;
|
|
case 'acTL':
|
|
this.animation = {
|
|
numFrames: this.readUInt32(),
|
|
numPlays: this.readUInt32() || Infinity,
|
|
frames: []
|
|
};
|
|
break;
|
|
case 'PLTE':
|
|
this.palette = this.read(chunkSize);
|
|
break;
|
|
case 'fcTL':
|
|
if (frame) {
|
|
this.animation.frames.push(frame);
|
|
}
|
|
this.pos += 4;
|
|
frame = {
|
|
width: this.readUInt32(),
|
|
height: this.readUInt32(),
|
|
xOffset: this.readUInt32(),
|
|
yOffset: this.readUInt32()
|
|
};
|
|
delayNum = this.readUInt16();
|
|
delayDen = this.readUInt16() || 100;
|
|
frame.delay = 1000 * delayNum / delayDen;
|
|
frame.disposeOp = this.data[this.pos++];
|
|
frame.blendOp = this.data[this.pos++];
|
|
frame.data = [];
|
|
break;
|
|
case 'IDAT':
|
|
case 'fdAT':
|
|
if (section === 'fdAT') {
|
|
this.pos += 4;
|
|
chunkSize -= 4;
|
|
}
|
|
data = (frame != null ? frame.data : void 0) || this.imgData;
|
|
for (i = 0; 0 <= chunkSize ? i < chunkSize : i > chunkSize; 0 <= chunkSize ? i++ : i--) {
|
|
data.push(this.data[this.pos++]);
|
|
}
|
|
break;
|
|
case 'tRNS':
|
|
this.transparency = {};
|
|
switch (this.colorType) {
|
|
case 3:
|
|
this.transparency.indexed = this.read(chunkSize);
|
|
short = 255 - this.transparency.indexed.length;
|
|
if (short > 0) {
|
|
for (i = 0; 0 <= short ? i < short : i > short; 0 <= short ? i++ : i--) {
|
|
this.transparency.indexed.push(255);
|
|
}
|
|
}
|
|
break;
|
|
case 0:
|
|
this.transparency.grayscale = this.read(chunkSize)[0];
|
|
break;
|
|
case 2:
|
|
this.transparency.rgb = this.read(chunkSize);
|
|
}
|
|
break;
|
|
case 'IEND':
|
|
if (frame) {
|
|
this.animation.frames.push(frame);
|
|
}
|
|
this.colors = (function() {
|
|
switch (this.colorType) {
|
|
case 0:
|
|
case 3:
|
|
case 4:
|
|
return 1;
|
|
case 2:
|
|
case 6:
|
|
return 3;
|
|
}
|
|
}).call(this);
|
|
this.hasAlphaChannel = (_ref = this.colorType) === 4 || _ref === 6;
|
|
colors = this.colors + (this.hasAlphaChannel ? 1 : 0);
|
|
this.pixelBitlength = this.bits * colors;
|
|
this.colorSpace = (function() {
|
|
switch (this.colors) {
|
|
case 1:
|
|
return 'DeviceGray';
|
|
case 3:
|
|
return 'DeviceRGB';
|
|
}
|
|
}).call(this);
|
|
this.imgData = new Uint8Array(this.imgData);
|
|
return;
|
|
default:
|
|
this.pos += chunkSize;
|
|
}
|
|
this.pos += 4;
|
|
}
|
|
return;
|
|
}
|
|
PNG.prototype.read = function(bytes) {
|
|
var i, _results;
|
|
_results = [];
|
|
for (i = 0; 0 <= bytes ? i < bytes : i > bytes; 0 <= bytes ? i++ : i--) {
|
|
_results.push(this.data[this.pos++]);
|
|
}
|
|
return _results;
|
|
};
|
|
PNG.prototype.readUInt32 = function() {
|
|
var b1, b2, b3, b4;
|
|
b1 = this.data[this.pos++] << 24;
|
|
b2 = this.data[this.pos++] << 16;
|
|
b3 = this.data[this.pos++] << 8;
|
|
b4 = this.data[this.pos++];
|
|
return b1 | b2 | b3 | b4;
|
|
};
|
|
PNG.prototype.readUInt16 = function() {
|
|
var b1, b2;
|
|
b1 = this.data[this.pos++] << 8;
|
|
b2 = this.data[this.pos++];
|
|
return b1 | b2;
|
|
};
|
|
PNG.prototype.decodePixels = function(data) {
|
|
var byte, col, filter, i, left, length, p, pa, paeth, pb, pc, pixelBytes, pixels, pos, row, rowData, s, scanlineLength, upper, upperLeft, _ref, _step;
|
|
if (data == null) {
|
|
data = this.imgData;
|
|
}
|
|
if (data.length === 0) {
|
|
return [];
|
|
}
|
|
data = new FlateStream(data);
|
|
data = data.getBytes();
|
|
pixelBytes = this.pixelBitlength / 8;
|
|
scanlineLength = pixelBytes * this.width;
|
|
row = 0;
|
|
pixels = [];
|
|
length = data.length;
|
|
pos = 0;
|
|
while (pos < length) {
|
|
filter = data[pos++];
|
|
i = 0;
|
|
rowData = [];
|
|
switch (filter) {
|
|
case 0:
|
|
while (i < scanlineLength) {
|
|
rowData[i++] = data[pos++];
|
|
}
|
|
break;
|
|
case 1:
|
|
while (i < scanlineLength) {
|
|
byte = data[pos++];
|
|
left = i < pixelBytes ? 0 : rowData[i - pixelBytes];
|
|
rowData[i++] = (byte + left) % 256;
|
|
}
|
|
break;
|
|
case 2:
|
|
while (i < scanlineLength) {
|
|
byte = data[pos++];
|
|
col = (i - (i % pixelBytes)) / pixelBytes;
|
|
upper = row === 0 ? 0 : pixels[row - 1][col][i % pixelBytes];
|
|
rowData[i++] = (upper + byte) % 256;
|
|
}
|
|
break;
|
|
case 3:
|
|
while (i < scanlineLength) {
|
|
byte = data[pos++];
|
|
col = (i - (i % pixelBytes)) / pixelBytes;
|
|
left = i < pixelBytes ? 0 : rowData[i - pixelBytes];
|
|
upper = row === 0 ? 0 : pixels[row - 1][col][i % pixelBytes];
|
|
rowData[i++] = (byte + Math.floor((left + upper) / 2)) % 256;
|
|
}
|
|
break;
|
|
case 4:
|
|
while (i < scanlineLength) {
|
|
byte = data[pos++];
|
|
col = (i - (i % pixelBytes)) / pixelBytes;
|
|
left = i < pixelBytes ? 0 : rowData[i - pixelBytes];
|
|
if (row === 0) {
|
|
upper = upperLeft = 0;
|
|
} else {
|
|
upper = pixels[row - 1][col][i % pixelBytes];
|
|
upperLeft = col === 0 ? 0 : pixels[row - 1][col - 1][i % pixelBytes];
|
|
}
|
|
p = left + upper - upperLeft;
|
|
pa = Math.abs(p - left);
|
|
pb = Math.abs(p - upper);
|
|
pc = Math.abs(p - upperLeft);
|
|
if (pa <= pb && pa <= pc) {
|
|
paeth = left;
|
|
} else if (pb <= pc) {
|
|
paeth = upper;
|
|
} else {
|
|
paeth = upperLeft;
|
|
}
|
|
rowData[i++] = (byte + paeth) % 256;
|
|
}
|
|
break;
|
|
default:
|
|
throw new Error("Invalid filter algorithm: " + filter);
|
|
}
|
|
s = [];
|
|
for (i = 0, _ref = rowData.length, _step = pixelBytes; 0 <= _ref ? i < _ref : i > _ref; i += _step) {
|
|
s.push(rowData.slice(i, i + pixelBytes));
|
|
}
|
|
pixels.push(s);
|
|
row += 1;
|
|
}
|
|
return pixels;
|
|
};
|
|
PNG.prototype.decodePalette = function() {
|
|
var alpha, decodingMap, i, index, palette, pixel, transparency, _ref, _ref2, _ref3, _step;
|
|
palette = this.palette;
|
|
transparency = (_ref = this.transparency.indexed) != null ? _ref : [];
|
|
decodingMap = [];
|
|
index = 0;
|
|
for (i = 0, _ref2 = palette.length, _step = 3; 0 <= _ref2 ? i < _ref2 : i > _ref2; i += _step) {
|
|
alpha = (_ref3 = transparency[index++]) != null ? _ref3 : 255;
|
|
pixel = palette.slice(i, i + 3).concat(alpha);
|
|
decodingMap.push(pixel);
|
|
}
|
|
return decodingMap;
|
|
};
|
|
PNG.prototype.copyToImageData = function(imageData, pixels) {
|
|
//console.log(this);
|
|
var alpha, byte, colors, data, i, palette, pixel, row, v, _i, _j, _k, _len, _len2, _len3, _ref;
|
|
colors = this.colors;
|
|
palette = null;
|
|
alpha = this.hasAlphaChannel;
|
|
if (this.palette.length) {
|
|
palette = (_ref = this._decodedPalette) != null ? _ref : this._decodedPalette = this.decodePalette();
|
|
colors = 4;
|
|
alpha = true;
|
|
}
|
|
data = imageData.data;
|
|
i = 0;
|
|
for (_i = 0, _len = pixels.length; _i < _len; _i++) {
|
|
row = pixels[_i];
|
|
for (_j = 0, _len2 = row.length; _j < _len2; _j++) {
|
|
pixel = row[_j];
|
|
if (palette) {
|
|
pixel = palette[pixel];
|
|
}
|
|
if (colors === 1) {
|
|
v = pixel[0];
|
|
data[i++] = v;
|
|
data[i++] = v;
|
|
data[i++] = v;
|
|
data[i++] = pixel[1] || 255;
|
|
} else {
|
|
//console.log(pixel.length);
|
|
//if (pixel.length == 4 && pixel[3] != 0)
|
|
//console.log(pixel);
|
|
//for (_k = 0, _len3 = pixel.length; _k < _len3; _k++) {
|
|
//for (_k = 0; _k < 4; _k++) {
|
|
// byte = pixel[_k];
|
|
// data[i++] = byte;
|
|
//}
|
|
var a = (256 - pixel[3])/256.;
|
|
var aa = (1.-a)*255.;
|
|
|
|
data[i++] = parseInt(pixel[2]*a + aa);
|
|
data[i++] = parseInt(pixel[1]*a + aa);
|
|
data[i++] = parseInt(pixel[0]*a + aa);
|
|
data[i++] = pixel[3];
|
|
if (!alpha) {
|
|
data[i++] = 255;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
PNG.prototype.decodeFrames = function(ctx) {
|
|
var frame, i, imageData, pixels, _len, _ref, _results;
|
|
if (!this.animation) {
|
|
return;
|
|
}
|
|
_ref = this.animation.frames;
|
|
_results = [];
|
|
for (i = 0, _len = _ref.length; i < _len; i++) {
|
|
frame = _ref[i];
|
|
imageData = ctx.createImageData(frame.width, frame.height);
|
|
pixels = this.decodePixels(new Uint8Array(frame.data));
|
|
this.copyToImageData(imageData, pixels);
|
|
frame.imageData = imageData;
|
|
_results.push(frame.image = makeImage(imageData));
|
|
}
|
|
return _results;
|
|
};
|
|
PNG.prototype.renderFrame = function(ctx, number) {
|
|
var frame, frames, prev;
|
|
frames = this.animation.frames;
|
|
frame = frames[number];
|
|
prev = frames[number - 1];
|
|
if (number === 0) {
|
|
ctx.clearRect(0, 0, this.width, this.height);
|
|
}
|
|
if ((prev != null ? prev.disposeOp : void 0) === APNG_DISPOSE_OP_BACKGROUND) {
|
|
ctx.clearRect(prev.xOffset, prev.yOffset, prev.width, prev.height);
|
|
} else if ((prev != null ? prev.disposeOp : void 0) === APNG_DISPOSE_OP_PREVIOUS) {
|
|
ctx.putImageData(prev.imageData, prev.xOffset, prev.yOffset);
|
|
}
|
|
if (frame.blendOp === APNG_BLEND_OP_SOURCE) {
|
|
ctx.clearRect(frame.xOffset, frame.yOffset, frame.width, frame.height);
|
|
}
|
|
return ctx.drawImage(frame.image, frame.xOffset, frame.yOffset);
|
|
};
|
|
PNG.prototype.animate = function(ctx) {
|
|
var doFrame, frameNumber, frames, numFrames, numPlays, _ref;
|
|
frameNumber = 0;
|
|
_ref = this.animation, numFrames = _ref.numFrames, frames = _ref.frames, numPlays = _ref.numPlays;
|
|
return (doFrame = __bind(function() {
|
|
var f, frame;
|
|
f = frameNumber++ % numFrames;
|
|
frame = frames[f];
|
|
this.renderFrame(ctx, f);
|
|
if (numFrames > 1 && frameNumber / numFrames < numPlays) {
|
|
return this.animation._timeout = setTimeout(doFrame, frame.delay);
|
|
}
|
|
}, this))();
|
|
};
|
|
PNG.prototype.stopAnimation = function() {
|
|
var _ref;
|
|
return clearTimeout((_ref = this.animation) != null ? _ref._timeout : void 0);
|
|
};
|
|
PNG.prototype.render = function(data) {
|
|
this.copyToImageData(data, this.decodePixels());
|
|
};
|
|
|
|
|
|
var Buffer = require('buffer').Buffer;
|
|
var fs = require('fs');
|
|
|
|
module.exports.readPng = function(path)
|
|
{
|
|
var pngData = fs.readFileSync(path);
|
|
var j = new PNG(pngData);
|
|
var imageData = {};
|
|
imageData.width = j.width;
|
|
imageData.height = j.height;
|
|
imageData.data = new Buffer(j.width*j.height*4);
|
|
j.render(imageData);
|
|
return imageData;
|
|
}
|