be1a6f294f
The issue with the JPEG image in question, is that the COM (Comment) marker has an incorrect length entry. Fixes 8169.
1111 lines
37 KiB
JavaScript
1111 lines
37 KiB
JavaScript
/* Copyright 2014 Mozilla Foundation
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the 'License');
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an 'AS IS' BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/* eslint-disable no-multi-spaces */
|
|
|
|
'use strict';
|
|
|
|
(function (root, factory) {
|
|
if (typeof define === 'function' && define.amd) {
|
|
define('pdfjs/core/jpg', ['exports', 'pdfjs/shared/util'], factory);
|
|
} else if (typeof exports !== 'undefined') {
|
|
factory(exports, require('../shared/util.js'));
|
|
} else {
|
|
factory((root.pdfjsCoreJpg = {}), root.pdfjsSharedUtil);
|
|
}
|
|
}(this, function (exports, sharedUtil) {
|
|
|
|
var warn = sharedUtil.warn;
|
|
var error = sharedUtil.error;
|
|
|
|
/**
|
|
* This code was forked from https://github.com/notmasteryet/jpgjs.
|
|
* The original version was created by GitHub user notmasteryet.
|
|
*
|
|
* - The JPEG specification can be found in the ITU CCITT Recommendation T.81
|
|
* (www.w3.org/Graphics/JPEG/itu-t81.pdf)
|
|
* - The JFIF specification can be found in the JPEG File Interchange Format
|
|
* (www.w3.org/Graphics/JPEG/jfif3.pdf)
|
|
* - The Adobe Application-Specific JPEG markers in the
|
|
* Supporting the DCT Filters in PostScript Level 2, Technical Note #5116
|
|
* (partners.adobe.com/public/developer/en/ps/sdk/5116.DCT_Filter.pdf)
|
|
*/
|
|
|
|
var JpegImage = (function JpegImageClosure() {
|
|
var dctZigZag = new Uint8Array([
|
|
0,
|
|
1, 8,
|
|
16, 9, 2,
|
|
3, 10, 17, 24,
|
|
32, 25, 18, 11, 4,
|
|
5, 12, 19, 26, 33, 40,
|
|
48, 41, 34, 27, 20, 13, 6,
|
|
7, 14, 21, 28, 35, 42, 49, 56,
|
|
57, 50, 43, 36, 29, 22, 15,
|
|
23, 30, 37, 44, 51, 58,
|
|
59, 52, 45, 38, 31,
|
|
39, 46, 53, 60,
|
|
61, 54, 47,
|
|
55, 62,
|
|
63
|
|
]);
|
|
|
|
var dctCos1 = 4017; // cos(pi/16)
|
|
var dctSin1 = 799; // sin(pi/16)
|
|
var dctCos3 = 3406; // cos(3*pi/16)
|
|
var dctSin3 = 2276; // sin(3*pi/16)
|
|
var dctCos6 = 1567; // cos(6*pi/16)
|
|
var dctSin6 = 3784; // sin(6*pi/16)
|
|
var dctSqrt2 = 5793; // sqrt(2)
|
|
var dctSqrt1d2 = 2896; // sqrt(2) / 2
|
|
|
|
function JpegImage() {
|
|
this.decodeTransform = null;
|
|
this.colorTransform = -1;
|
|
}
|
|
|
|
function buildHuffmanTable(codeLengths, values) {
|
|
var k = 0, code = [], i, j, length = 16;
|
|
while (length > 0 && !codeLengths[length - 1]) {
|
|
length--;
|
|
}
|
|
code.push({children: [], index: 0});
|
|
var p = code[0], q;
|
|
for (i = 0; i < length; i++) {
|
|
for (j = 0; j < codeLengths[i]; j++) {
|
|
p = code.pop();
|
|
p.children[p.index] = values[k];
|
|
while (p.index > 0) {
|
|
p = code.pop();
|
|
}
|
|
p.index++;
|
|
code.push(p);
|
|
while (code.length <= i) {
|
|
code.push(q = {children: [], index: 0});
|
|
p.children[p.index] = q.children;
|
|
p = q;
|
|
}
|
|
k++;
|
|
}
|
|
if (i + 1 < length) {
|
|
// p here points to last code
|
|
code.push(q = {children: [], index: 0});
|
|
p.children[p.index] = q.children;
|
|
p = q;
|
|
}
|
|
}
|
|
return code[0].children;
|
|
}
|
|
|
|
function getBlockBufferOffset(component, row, col) {
|
|
return 64 * ((component.blocksPerLine + 1) * row + col);
|
|
}
|
|
|
|
function decodeScan(data, offset, frame, components, resetInterval,
|
|
spectralStart, spectralEnd, successivePrev, successive) {
|
|
var mcusPerLine = frame.mcusPerLine;
|
|
var progressive = frame.progressive;
|
|
|
|
var startOffset = offset, bitsData = 0, bitsCount = 0;
|
|
|
|
function readBit() {
|
|
if (bitsCount > 0) {
|
|
bitsCount--;
|
|
return (bitsData >> bitsCount) & 1;
|
|
}
|
|
bitsData = data[offset++];
|
|
if (bitsData === 0xFF) {
|
|
var nextByte = data[offset++];
|
|
if (nextByte) {
|
|
error('JPEG error: unexpected marker ' +
|
|
((bitsData << 8) | nextByte).toString(16));
|
|
}
|
|
// unstuff 0
|
|
}
|
|
bitsCount = 7;
|
|
return bitsData >>> 7;
|
|
}
|
|
|
|
function decodeHuffman(tree) {
|
|
var node = tree;
|
|
while (true) {
|
|
node = node[readBit()];
|
|
if (typeof node === 'number') {
|
|
return node;
|
|
}
|
|
if (typeof node !== 'object') {
|
|
error('JPEG error: invalid huffman sequence');
|
|
}
|
|
}
|
|
}
|
|
|
|
function receive(length) {
|
|
var n = 0;
|
|
while (length > 0) {
|
|
n = (n << 1) | readBit();
|
|
length--;
|
|
}
|
|
return n;
|
|
}
|
|
|
|
function receiveAndExtend(length) {
|
|
if (length === 1) {
|
|
return readBit() === 1 ? 1 : -1;
|
|
}
|
|
var n = receive(length);
|
|
if (n >= 1 << (length - 1)) {
|
|
return n;
|
|
}
|
|
return n + (-1 << length) + 1;
|
|
}
|
|
|
|
function decodeBaseline(component, offset) {
|
|
var t = decodeHuffman(component.huffmanTableDC);
|
|
var diff = t === 0 ? 0 : receiveAndExtend(t);
|
|
component.blockData[offset] = (component.pred += diff);
|
|
var k = 1;
|
|
while (k < 64) {
|
|
var rs = decodeHuffman(component.huffmanTableAC);
|
|
var s = rs & 15, r = rs >> 4;
|
|
if (s === 0) {
|
|
if (r < 15) {
|
|
break;
|
|
}
|
|
k += 16;
|
|
continue;
|
|
}
|
|
k += r;
|
|
var z = dctZigZag[k];
|
|
component.blockData[offset + z] = receiveAndExtend(s);
|
|
k++;
|
|
}
|
|
}
|
|
|
|
function decodeDCFirst(component, offset) {
|
|
var t = decodeHuffman(component.huffmanTableDC);
|
|
var diff = t === 0 ? 0 : (receiveAndExtend(t) << successive);
|
|
component.blockData[offset] = (component.pred += diff);
|
|
}
|
|
|
|
function decodeDCSuccessive(component, offset) {
|
|
component.blockData[offset] |= readBit() << successive;
|
|
}
|
|
|
|
var eobrun = 0;
|
|
function decodeACFirst(component, offset) {
|
|
if (eobrun > 0) {
|
|
eobrun--;
|
|
return;
|
|
}
|
|
var k = spectralStart, e = spectralEnd;
|
|
while (k <= e) {
|
|
var rs = decodeHuffman(component.huffmanTableAC);
|
|
var s = rs & 15, r = rs >> 4;
|
|
if (s === 0) {
|
|
if (r < 15) {
|
|
eobrun = receive(r) + (1 << r) - 1;
|
|
break;
|
|
}
|
|
k += 16;
|
|
continue;
|
|
}
|
|
k += r;
|
|
var z = dctZigZag[k];
|
|
component.blockData[offset + z] =
|
|
receiveAndExtend(s) * (1 << successive);
|
|
k++;
|
|
}
|
|
}
|
|
|
|
var successiveACState = 0, successiveACNextValue;
|
|
function decodeACSuccessive(component, offset) {
|
|
var k = spectralStart;
|
|
var e = spectralEnd;
|
|
var r = 0;
|
|
var s;
|
|
var rs;
|
|
while (k <= e) {
|
|
var z = dctZigZag[k];
|
|
switch (successiveACState) {
|
|
case 0: // initial state
|
|
rs = decodeHuffman(component.huffmanTableAC);
|
|
s = rs & 15;
|
|
r = rs >> 4;
|
|
if (s === 0) {
|
|
if (r < 15) {
|
|
eobrun = receive(r) + (1 << r);
|
|
successiveACState = 4;
|
|
} else {
|
|
r = 16;
|
|
successiveACState = 1;
|
|
}
|
|
} else {
|
|
if (s !== 1) {
|
|
error('JPEG error: invalid ACn encoding');
|
|
}
|
|
successiveACNextValue = receiveAndExtend(s);
|
|
successiveACState = r ? 2 : 3;
|
|
}
|
|
continue;
|
|
case 1: // skipping r zero items
|
|
case 2:
|
|
if (component.blockData[offset + z]) {
|
|
component.blockData[offset + z] += (readBit() << successive);
|
|
} else {
|
|
r--;
|
|
if (r === 0) {
|
|
successiveACState = successiveACState === 2 ? 3 : 0;
|
|
}
|
|
}
|
|
break;
|
|
case 3: // set value for a zero item
|
|
if (component.blockData[offset + z]) {
|
|
component.blockData[offset + z] += (readBit() << successive);
|
|
} else {
|
|
component.blockData[offset + z] =
|
|
successiveACNextValue << successive;
|
|
successiveACState = 0;
|
|
}
|
|
break;
|
|
case 4: // eob
|
|
if (component.blockData[offset + z]) {
|
|
component.blockData[offset + z] += (readBit() << successive);
|
|
}
|
|
break;
|
|
}
|
|
k++;
|
|
}
|
|
if (successiveACState === 4) {
|
|
eobrun--;
|
|
if (eobrun === 0) {
|
|
successiveACState = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
function decodeMcu(component, decode, mcu, row, col) {
|
|
var mcuRow = (mcu / mcusPerLine) | 0;
|
|
var mcuCol = mcu % mcusPerLine;
|
|
var blockRow = mcuRow * component.v + row;
|
|
var blockCol = mcuCol * component.h + col;
|
|
var offset = getBlockBufferOffset(component, blockRow, blockCol);
|
|
decode(component, offset);
|
|
}
|
|
|
|
function decodeBlock(component, decode, mcu) {
|
|
var blockRow = (mcu / component.blocksPerLine) | 0;
|
|
var blockCol = mcu % component.blocksPerLine;
|
|
var offset = getBlockBufferOffset(component, blockRow, blockCol);
|
|
decode(component, offset);
|
|
}
|
|
|
|
var componentsLength = components.length;
|
|
var component, i, j, k, n;
|
|
var decodeFn;
|
|
if (progressive) {
|
|
if (spectralStart === 0) {
|
|
decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;
|
|
} else {
|
|
decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;
|
|
}
|
|
} else {
|
|
decodeFn = decodeBaseline;
|
|
}
|
|
|
|
var mcu = 0, marker;
|
|
var mcuExpected;
|
|
if (componentsLength === 1) {
|
|
mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn;
|
|
} else {
|
|
mcuExpected = mcusPerLine * frame.mcusPerColumn;
|
|
}
|
|
if (!resetInterval) {
|
|
resetInterval = mcuExpected;
|
|
}
|
|
|
|
var h, v;
|
|
while (mcu < mcuExpected) {
|
|
// reset interval stuff
|
|
for (i = 0; i < componentsLength; i++) {
|
|
components[i].pred = 0;
|
|
}
|
|
eobrun = 0;
|
|
|
|
if (componentsLength === 1) {
|
|
component = components[0];
|
|
for (n = 0; n < resetInterval; n++) {
|
|
decodeBlock(component, decodeFn, mcu);
|
|
mcu++;
|
|
}
|
|
} else {
|
|
for (n = 0; n < resetInterval; n++) {
|
|
for (i = 0; i < componentsLength; i++) {
|
|
component = components[i];
|
|
h = component.h;
|
|
v = component.v;
|
|
for (j = 0; j < v; j++) {
|
|
for (k = 0; k < h; k++) {
|
|
decodeMcu(component, decodeFn, mcu, j, k);
|
|
}
|
|
}
|
|
}
|
|
mcu++;
|
|
}
|
|
}
|
|
|
|
// find marker
|
|
bitsCount = 0;
|
|
marker = (data[offset] << 8) | data[offset + 1];
|
|
// Some bad images seem to pad Scan blocks with zero bytes, skip past
|
|
// those to attempt to find a valid marker (fixes issue4090.pdf).
|
|
while (data[offset] === 0x00 && offset < data.length - 1) {
|
|
offset++;
|
|
marker = (data[offset] << 8) | data[offset + 1];
|
|
}
|
|
if (marker <= 0xFF00) {
|
|
error('JPEG error: marker was not found');
|
|
}
|
|
|
|
if (marker >= 0xFFD0 && marker <= 0xFFD7) { // RSTx
|
|
offset += 2;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return offset - startOffset;
|
|
}
|
|
|
|
// A port of poppler's IDCT method which in turn is taken from:
|
|
// Christoph Loeffler, Adriaan Ligtenberg, George S. Moschytz,
|
|
// 'Practical Fast 1-D DCT Algorithms with 11 Multiplications',
|
|
// IEEE Intl. Conf. on Acoustics, Speech & Signal Processing, 1989,
|
|
// 988-991.
|
|
function quantizeAndInverse(component, blockBufferOffset, p) {
|
|
var qt = component.quantizationTable, blockData = component.blockData;
|
|
var v0, v1, v2, v3, v4, v5, v6, v7;
|
|
var p0, p1, p2, p3, p4, p5, p6, p7;
|
|
var t;
|
|
|
|
if (!qt) {
|
|
error('JPEG error: missing required Quantization Table.');
|
|
}
|
|
|
|
// inverse DCT on rows
|
|
for (var row = 0; row < 64; row += 8) {
|
|
// gather block data
|
|
p0 = blockData[blockBufferOffset + row];
|
|
p1 = blockData[blockBufferOffset + row + 1];
|
|
p2 = blockData[blockBufferOffset + row + 2];
|
|
p3 = blockData[blockBufferOffset + row + 3];
|
|
p4 = blockData[blockBufferOffset + row + 4];
|
|
p5 = blockData[blockBufferOffset + row + 5];
|
|
p6 = blockData[blockBufferOffset + row + 6];
|
|
p7 = blockData[blockBufferOffset + row + 7];
|
|
|
|
// dequant p0
|
|
p0 *= qt[row];
|
|
|
|
// check for all-zero AC coefficients
|
|
if ((p1 | p2 | p3 | p4 | p5 | p6 | p7) === 0) {
|
|
t = (dctSqrt2 * p0 + 512) >> 10;
|
|
p[row] = t;
|
|
p[row + 1] = t;
|
|
p[row + 2] = t;
|
|
p[row + 3] = t;
|
|
p[row + 4] = t;
|
|
p[row + 5] = t;
|
|
p[row + 6] = t;
|
|
p[row + 7] = t;
|
|
continue;
|
|
}
|
|
// dequant p1 ... p7
|
|
p1 *= qt[row + 1];
|
|
p2 *= qt[row + 2];
|
|
p3 *= qt[row + 3];
|
|
p4 *= qt[row + 4];
|
|
p5 *= qt[row + 5];
|
|
p6 *= qt[row + 6];
|
|
p7 *= qt[row + 7];
|
|
|
|
// stage 4
|
|
v0 = (dctSqrt2 * p0 + 128) >> 8;
|
|
v1 = (dctSqrt2 * p4 + 128) >> 8;
|
|
v2 = p2;
|
|
v3 = p6;
|
|
v4 = (dctSqrt1d2 * (p1 - p7) + 128) >> 8;
|
|
v7 = (dctSqrt1d2 * (p1 + p7) + 128) >> 8;
|
|
v5 = p3 << 4;
|
|
v6 = p5 << 4;
|
|
|
|
// stage 3
|
|
v0 = (v0 + v1 + 1) >> 1;
|
|
v1 = v0 - v1;
|
|
t = (v2 * dctSin6 + v3 * dctCos6 + 128) >> 8;
|
|
v2 = (v2 * dctCos6 - v3 * dctSin6 + 128) >> 8;
|
|
v3 = t;
|
|
v4 = (v4 + v6 + 1) >> 1;
|
|
v6 = v4 - v6;
|
|
v7 = (v7 + v5 + 1) >> 1;
|
|
v5 = v7 - v5;
|
|
|
|
// stage 2
|
|
v0 = (v0 + v3 + 1) >> 1;
|
|
v3 = v0 - v3;
|
|
v1 = (v1 + v2 + 1) >> 1;
|
|
v2 = v1 - v2;
|
|
t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12;
|
|
v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12;
|
|
v7 = t;
|
|
t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12;
|
|
v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12;
|
|
v6 = t;
|
|
|
|
// stage 1
|
|
p[row] = v0 + v7;
|
|
p[row + 7] = v0 - v7;
|
|
p[row + 1] = v1 + v6;
|
|
p[row + 6] = v1 - v6;
|
|
p[row + 2] = v2 + v5;
|
|
p[row + 5] = v2 - v5;
|
|
p[row + 3] = v3 + v4;
|
|
p[row + 4] = v3 - v4;
|
|
}
|
|
|
|
// inverse DCT on columns
|
|
for (var col = 0; col < 8; ++col) {
|
|
p0 = p[col];
|
|
p1 = p[col + 8];
|
|
p2 = p[col + 16];
|
|
p3 = p[col + 24];
|
|
p4 = p[col + 32];
|
|
p5 = p[col + 40];
|
|
p6 = p[col + 48];
|
|
p7 = p[col + 56];
|
|
|
|
// check for all-zero AC coefficients
|
|
if ((p1 | p2 | p3 | p4 | p5 | p6 | p7) === 0) {
|
|
t = (dctSqrt2 * p0 + 8192) >> 14;
|
|
// convert to 8 bit
|
|
t = (t < -2040) ? 0 : (t >= 2024) ? 255 : (t + 2056) >> 4;
|
|
blockData[blockBufferOffset + col] = t;
|
|
blockData[blockBufferOffset + col + 8] = t;
|
|
blockData[blockBufferOffset + col + 16] = t;
|
|
blockData[blockBufferOffset + col + 24] = t;
|
|
blockData[blockBufferOffset + col + 32] = t;
|
|
blockData[blockBufferOffset + col + 40] = t;
|
|
blockData[blockBufferOffset + col + 48] = t;
|
|
blockData[blockBufferOffset + col + 56] = t;
|
|
continue;
|
|
}
|
|
|
|
// stage 4
|
|
v0 = (dctSqrt2 * p0 + 2048) >> 12;
|
|
v1 = (dctSqrt2 * p4 + 2048) >> 12;
|
|
v2 = p2;
|
|
v3 = p6;
|
|
v4 = (dctSqrt1d2 * (p1 - p7) + 2048) >> 12;
|
|
v7 = (dctSqrt1d2 * (p1 + p7) + 2048) >> 12;
|
|
v5 = p3;
|
|
v6 = p5;
|
|
|
|
// stage 3
|
|
// Shift v0 by 128.5 << 5 here, so we don't need to shift p0...p7 when
|
|
// converting to UInt8 range later.
|
|
v0 = ((v0 + v1 + 1) >> 1) + 4112;
|
|
v1 = v0 - v1;
|
|
t = (v2 * dctSin6 + v3 * dctCos6 + 2048) >> 12;
|
|
v2 = (v2 * dctCos6 - v3 * dctSin6 + 2048) >> 12;
|
|
v3 = t;
|
|
v4 = (v4 + v6 + 1) >> 1;
|
|
v6 = v4 - v6;
|
|
v7 = (v7 + v5 + 1) >> 1;
|
|
v5 = v7 - v5;
|
|
|
|
// stage 2
|
|
v0 = (v0 + v3 + 1) >> 1;
|
|
v3 = v0 - v3;
|
|
v1 = (v1 + v2 + 1) >> 1;
|
|
v2 = v1 - v2;
|
|
t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12;
|
|
v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12;
|
|
v7 = t;
|
|
t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12;
|
|
v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12;
|
|
v6 = t;
|
|
|
|
// stage 1
|
|
p0 = v0 + v7;
|
|
p7 = v0 - v7;
|
|
p1 = v1 + v6;
|
|
p6 = v1 - v6;
|
|
p2 = v2 + v5;
|
|
p5 = v2 - v5;
|
|
p3 = v3 + v4;
|
|
p4 = v3 - v4;
|
|
|
|
// convert to 8-bit integers
|
|
p0 = (p0 < 16) ? 0 : (p0 >= 4080) ? 255 : p0 >> 4;
|
|
p1 = (p1 < 16) ? 0 : (p1 >= 4080) ? 255 : p1 >> 4;
|
|
p2 = (p2 < 16) ? 0 : (p2 >= 4080) ? 255 : p2 >> 4;
|
|
p3 = (p3 < 16) ? 0 : (p3 >= 4080) ? 255 : p3 >> 4;
|
|
p4 = (p4 < 16) ? 0 : (p4 >= 4080) ? 255 : p4 >> 4;
|
|
p5 = (p5 < 16) ? 0 : (p5 >= 4080) ? 255 : p5 >> 4;
|
|
p6 = (p6 < 16) ? 0 : (p6 >= 4080) ? 255 : p6 >> 4;
|
|
p7 = (p7 < 16) ? 0 : (p7 >= 4080) ? 255 : p7 >> 4;
|
|
|
|
// store block data
|
|
blockData[blockBufferOffset + col] = p0;
|
|
blockData[blockBufferOffset + col + 8] = p1;
|
|
blockData[blockBufferOffset + col + 16] = p2;
|
|
blockData[blockBufferOffset + col + 24] = p3;
|
|
blockData[blockBufferOffset + col + 32] = p4;
|
|
blockData[blockBufferOffset + col + 40] = p5;
|
|
blockData[blockBufferOffset + col + 48] = p6;
|
|
blockData[blockBufferOffset + col + 56] = p7;
|
|
}
|
|
}
|
|
|
|
function buildComponentData(frame, component) {
|
|
var blocksPerLine = component.blocksPerLine;
|
|
var blocksPerColumn = component.blocksPerColumn;
|
|
var computationBuffer = new Int16Array(64);
|
|
|
|
for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) {
|
|
for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) {
|
|
var offset = getBlockBufferOffset(component, blockRow, blockCol);
|
|
quantizeAndInverse(component, offset, computationBuffer);
|
|
}
|
|
}
|
|
return component.blockData;
|
|
}
|
|
|
|
function clamp0to255(a) {
|
|
return a <= 0 ? 0 : a >= 255 ? 255 : a;
|
|
}
|
|
|
|
JpegImage.prototype = {
|
|
parse: function parse(data) {
|
|
|
|
function readUint16() {
|
|
var value = (data[offset] << 8) | data[offset + 1];
|
|
offset += 2;
|
|
return value;
|
|
}
|
|
|
|
function readDataBlock() {
|
|
function isValidMarkerAt(pos) {
|
|
if (pos < data.length - 1) {
|
|
return (data[pos] === 0xFF &&
|
|
data[pos + 1] >= 0xC0 && data[pos + 1] <= 0xFE);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
var length = readUint16();
|
|
var endOffset = offset + length - 2;
|
|
|
|
if (!isValidMarkerAt(endOffset)) {
|
|
warn('readDataBlock - incorrect length, next marker is: ' +
|
|
(data[endOffset] << 8 | data[endOffset + 1]).toString('16'));
|
|
var pos = offset;
|
|
while (!isValidMarkerAt(pos)) {
|
|
pos++;
|
|
}
|
|
endOffset = pos;
|
|
}
|
|
|
|
var array = data.subarray(offset, endOffset);
|
|
offset += array.length;
|
|
return array;
|
|
}
|
|
|
|
function prepareComponents(frame) {
|
|
var mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / frame.maxH);
|
|
var mcusPerColumn = Math.ceil(frame.scanLines / 8 / frame.maxV);
|
|
for (var i = 0; i < frame.components.length; i++) {
|
|
component = frame.components[i];
|
|
var blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) *
|
|
component.h / frame.maxH);
|
|
var blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) *
|
|
component.v / frame.maxV);
|
|
var blocksPerLineForMcu = mcusPerLine * component.h;
|
|
var blocksPerColumnForMcu = mcusPerColumn * component.v;
|
|
|
|
var blocksBufferSize = 64 * blocksPerColumnForMcu *
|
|
(blocksPerLineForMcu + 1);
|
|
component.blockData = new Int16Array(blocksBufferSize);
|
|
component.blocksPerLine = blocksPerLine;
|
|
component.blocksPerColumn = blocksPerColumn;
|
|
}
|
|
frame.mcusPerLine = mcusPerLine;
|
|
frame.mcusPerColumn = mcusPerColumn;
|
|
}
|
|
|
|
var offset = 0;
|
|
var jfif = null;
|
|
var adobe = null;
|
|
var frame, resetInterval;
|
|
var quantizationTables = [];
|
|
var huffmanTablesAC = [], huffmanTablesDC = [];
|
|
var fileMarker = readUint16();
|
|
if (fileMarker !== 0xFFD8) { // SOI (Start of Image)
|
|
error('JPEG error: SOI not found');
|
|
}
|
|
|
|
fileMarker = readUint16();
|
|
while (fileMarker !== 0xFFD9) { // EOI (End of image)
|
|
var i, j, l;
|
|
switch (fileMarker) {
|
|
case 0xFFE0: // APP0 (Application Specific)
|
|
case 0xFFE1: // APP1
|
|
case 0xFFE2: // APP2
|
|
case 0xFFE3: // APP3
|
|
case 0xFFE4: // APP4
|
|
case 0xFFE5: // APP5
|
|
case 0xFFE6: // APP6
|
|
case 0xFFE7: // APP7
|
|
case 0xFFE8: // APP8
|
|
case 0xFFE9: // APP9
|
|
case 0xFFEA: // APP10
|
|
case 0xFFEB: // APP11
|
|
case 0xFFEC: // APP12
|
|
case 0xFFED: // APP13
|
|
case 0xFFEE: // APP14
|
|
case 0xFFEF: // APP15
|
|
case 0xFFFE: // COM (Comment)
|
|
var appData = readDataBlock();
|
|
|
|
if (fileMarker === 0xFFE0) {
|
|
if (appData[0] === 0x4A && appData[1] === 0x46 &&
|
|
appData[2] === 0x49 && appData[3] === 0x46 &&
|
|
appData[4] === 0) { // 'JFIF\x00'
|
|
jfif = {
|
|
version: { major: appData[5], minor: appData[6] },
|
|
densityUnits: appData[7],
|
|
xDensity: (appData[8] << 8) | appData[9],
|
|
yDensity: (appData[10] << 8) | appData[11],
|
|
thumbWidth: appData[12],
|
|
thumbHeight: appData[13],
|
|
thumbData: appData.subarray(14, 14 +
|
|
3 * appData[12] * appData[13])
|
|
};
|
|
}
|
|
}
|
|
// TODO APP1 - Exif
|
|
if (fileMarker === 0xFFEE) {
|
|
if (appData[0] === 0x41 && appData[1] === 0x64 &&
|
|
appData[2] === 0x6F && appData[3] === 0x62 &&
|
|
appData[4] === 0x65) { // 'Adobe'
|
|
adobe = {
|
|
version: (appData[5] << 8) | appData[6],
|
|
flags0: (appData[7] << 8) | appData[8],
|
|
flags1: (appData[9] << 8) | appData[10],
|
|
transformCode: appData[11]
|
|
};
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 0xFFDB: // DQT (Define Quantization Tables)
|
|
var quantizationTablesLength = readUint16();
|
|
var quantizationTablesEnd = quantizationTablesLength + offset - 2;
|
|
var z;
|
|
while (offset < quantizationTablesEnd) {
|
|
var quantizationTableSpec = data[offset++];
|
|
var tableData = new Uint16Array(64);
|
|
if ((quantizationTableSpec >> 4) === 0) { // 8 bit values
|
|
for (j = 0; j < 64; j++) {
|
|
z = dctZigZag[j];
|
|
tableData[z] = data[offset++];
|
|
}
|
|
} else if ((quantizationTableSpec >> 4) === 1) { // 16 bit values
|
|
for (j = 0; j < 64; j++) {
|
|
z = dctZigZag[j];
|
|
tableData[z] = readUint16();
|
|
}
|
|
} else {
|
|
error('JPEG error: DQT - invalid table spec');
|
|
}
|
|
quantizationTables[quantizationTableSpec & 15] = tableData;
|
|
}
|
|
break;
|
|
|
|
case 0xFFC0: // SOF0 (Start of Frame, Baseline DCT)
|
|
case 0xFFC1: // SOF1 (Start of Frame, Extended DCT)
|
|
case 0xFFC2: // SOF2 (Start of Frame, Progressive DCT)
|
|
if (frame) {
|
|
error('JPEG error: Only single frame JPEGs supported');
|
|
}
|
|
readUint16(); // skip data length
|
|
frame = {};
|
|
frame.extended = (fileMarker === 0xFFC1);
|
|
frame.progressive = (fileMarker === 0xFFC2);
|
|
frame.precision = data[offset++];
|
|
frame.scanLines = readUint16();
|
|
frame.samplesPerLine = readUint16();
|
|
frame.components = [];
|
|
frame.componentIds = {};
|
|
var componentsCount = data[offset++], componentId;
|
|
var maxH = 0, maxV = 0;
|
|
for (i = 0; i < componentsCount; i++) {
|
|
componentId = data[offset];
|
|
var h = data[offset + 1] >> 4;
|
|
var v = data[offset + 1] & 15;
|
|
if (maxH < h) {
|
|
maxH = h;
|
|
}
|
|
if (maxV < v) {
|
|
maxV = v;
|
|
}
|
|
var qId = data[offset + 2];
|
|
l = frame.components.push({
|
|
h: h,
|
|
v: v,
|
|
quantizationId: qId,
|
|
quantizationTable: null, // See comment below.
|
|
});
|
|
frame.componentIds[componentId] = l - 1;
|
|
offset += 3;
|
|
}
|
|
frame.maxH = maxH;
|
|
frame.maxV = maxV;
|
|
prepareComponents(frame);
|
|
break;
|
|
|
|
case 0xFFC4: // DHT (Define Huffman Tables)
|
|
var huffmanLength = readUint16();
|
|
for (i = 2; i < huffmanLength;) {
|
|
var huffmanTableSpec = data[offset++];
|
|
var codeLengths = new Uint8Array(16);
|
|
var codeLengthSum = 0;
|
|
for (j = 0; j < 16; j++, offset++) {
|
|
codeLengthSum += (codeLengths[j] = data[offset]);
|
|
}
|
|
var huffmanValues = new Uint8Array(codeLengthSum);
|
|
for (j = 0; j < codeLengthSum; j++, offset++) {
|
|
huffmanValues[j] = data[offset];
|
|
}
|
|
i += 17 + codeLengthSum;
|
|
|
|
((huffmanTableSpec >> 4) === 0 ?
|
|
huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] =
|
|
buildHuffmanTable(codeLengths, huffmanValues);
|
|
}
|
|
break;
|
|
|
|
case 0xFFDD: // DRI (Define Restart Interval)
|
|
readUint16(); // skip data length
|
|
resetInterval = readUint16();
|
|
break;
|
|
|
|
case 0xFFDA: // SOS (Start of Scan)
|
|
readUint16(); // scanLength
|
|
var selectorsCount = data[offset++];
|
|
var components = [], component;
|
|
for (i = 0; i < selectorsCount; i++) {
|
|
var componentIndex = frame.componentIds[data[offset++]];
|
|
component = frame.components[componentIndex];
|
|
var tableSpec = data[offset++];
|
|
component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];
|
|
component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];
|
|
components.push(component);
|
|
}
|
|
var spectralStart = data[offset++];
|
|
var spectralEnd = data[offset++];
|
|
var successiveApproximation = data[offset++];
|
|
var processed = decodeScan(data, offset,
|
|
frame, components, resetInterval,
|
|
spectralStart, spectralEnd,
|
|
successiveApproximation >> 4, successiveApproximation & 15);
|
|
offset += processed;
|
|
break;
|
|
|
|
case 0xFFFF: // Fill bytes
|
|
if (data[offset] !== 0xFF) { // Avoid skipping a valid marker.
|
|
offset--;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
if (data[offset - 3] === 0xFF &&
|
|
data[offset - 2] >= 0xC0 && data[offset - 2] <= 0xFE) {
|
|
// could be incorrect encoding -- last 0xFF byte of the previous
|
|
// block was eaten by the encoder
|
|
offset -= 3;
|
|
break;
|
|
}
|
|
error('JPEG error: unknown marker ' + fileMarker.toString(16));
|
|
}
|
|
fileMarker = readUint16();
|
|
}
|
|
|
|
this.width = frame.samplesPerLine;
|
|
this.height = frame.scanLines;
|
|
this.jfif = jfif;
|
|
this.adobe = adobe;
|
|
this.components = [];
|
|
for (i = 0; i < frame.components.length; i++) {
|
|
component = frame.components[i];
|
|
|
|
// Prevent errors when DQT markers are placed after SOF{n} markers,
|
|
// by assigning the `quantizationTable` entry after the entire image
|
|
// has been parsed (fixes issue7406.pdf).
|
|
var quantizationTable = quantizationTables[component.quantizationId];
|
|
if (quantizationTable) {
|
|
component.quantizationTable = quantizationTable;
|
|
}
|
|
|
|
this.components.push({
|
|
output: buildComponentData(frame, component),
|
|
scaleX: component.h / frame.maxH,
|
|
scaleY: component.v / frame.maxV,
|
|
blocksPerLine: component.blocksPerLine,
|
|
blocksPerColumn: component.blocksPerColumn
|
|
});
|
|
}
|
|
this.numComponents = this.components.length;
|
|
},
|
|
|
|
_getLinearizedBlockData: function getLinearizedBlockData(width, height) {
|
|
var scaleX = this.width / width, scaleY = this.height / height;
|
|
|
|
var component, componentScaleX, componentScaleY, blocksPerScanline;
|
|
var x, y, i, j, k;
|
|
var index;
|
|
var offset = 0;
|
|
var output;
|
|
var numComponents = this.components.length;
|
|
var dataLength = width * height * numComponents;
|
|
var data = new Uint8Array(dataLength);
|
|
var xScaleBlockOffset = new Uint32Array(width);
|
|
var mask3LSB = 0xfffffff8; // used to clear the 3 LSBs
|
|
|
|
for (i = 0; i < numComponents; i++) {
|
|
component = this.components[i];
|
|
componentScaleX = component.scaleX * scaleX;
|
|
componentScaleY = component.scaleY * scaleY;
|
|
offset = i;
|
|
output = component.output;
|
|
blocksPerScanline = (component.blocksPerLine + 1) << 3;
|
|
// precalculate the xScaleBlockOffset
|
|
for (x = 0; x < width; x++) {
|
|
j = 0 | (x * componentScaleX);
|
|
xScaleBlockOffset[x] = ((j & mask3LSB) << 3) | (j & 7);
|
|
}
|
|
// linearize the blocks of the component
|
|
for (y = 0; y < height; y++) {
|
|
j = 0 | (y * componentScaleY);
|
|
index = blocksPerScanline * (j & mask3LSB) | ((j & 7) << 3);
|
|
for (x = 0; x < width; x++) {
|
|
data[offset] = output[index + xScaleBlockOffset[x]];
|
|
offset += numComponents;
|
|
}
|
|
}
|
|
}
|
|
|
|
// decodeTransform contains pairs of multiplier (-256..256) and additive
|
|
var transform = this.decodeTransform;
|
|
if (transform) {
|
|
for (i = 0; i < dataLength;) {
|
|
for (j = 0, k = 0; j < numComponents; j++, i++, k += 2) {
|
|
data[i] = ((data[i] * transform[k]) >> 8) + transform[k + 1];
|
|
}
|
|
}
|
|
}
|
|
return data;
|
|
},
|
|
|
|
_isColorConversionNeeded: function isColorConversionNeeded() {
|
|
if (this.adobe && this.adobe.transformCode) {
|
|
// The adobe transform marker overrides any previous setting
|
|
return true;
|
|
} else if (this.numComponents === 3) {
|
|
if (!this.adobe && this.colorTransform === 0) {
|
|
// If the Adobe transform marker is not present and the image
|
|
// dictionary has a 'ColorTransform' entry, explicitly set to `0`,
|
|
// then the colours should *not* be transformed.
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
// `this.numComponents !== 3`
|
|
if (!this.adobe && this.colorTransform === 1) {
|
|
// If the Adobe transform marker is not present and the image
|
|
// dictionary has a 'ColorTransform' entry, explicitly set to `1`,
|
|
// then the colours should be transformed.
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
|
|
_convertYccToRgb: function convertYccToRgb(data) {
|
|
var Y, Cb, Cr;
|
|
for (var i = 0, length = data.length; i < length; i += 3) {
|
|
Y = data[i ];
|
|
Cb = data[i + 1];
|
|
Cr = data[i + 2];
|
|
data[i ] = clamp0to255(Y - 179.456 + 1.402 * Cr);
|
|
data[i + 1] = clamp0to255(Y + 135.459 - 0.344 * Cb - 0.714 * Cr);
|
|
data[i + 2] = clamp0to255(Y - 226.816 + 1.772 * Cb);
|
|
}
|
|
return data;
|
|
},
|
|
|
|
_convertYcckToRgb: function convertYcckToRgb(data) {
|
|
var Y, Cb, Cr, k;
|
|
var offset = 0;
|
|
for (var i = 0, length = data.length; i < length; i += 4) {
|
|
Y = data[i];
|
|
Cb = data[i + 1];
|
|
Cr = data[i + 2];
|
|
k = data[i + 3];
|
|
|
|
var r = -122.67195406894 +
|
|
Cb * (-6.60635669420364e-5 * Cb + 0.000437130475926232 * Cr -
|
|
5.4080610064599e-5 * Y + 0.00048449797120281 * k -
|
|
0.154362151871126) +
|
|
Cr * (-0.000957964378445773 * Cr + 0.000817076911346625 * Y -
|
|
0.00477271405408747 * k + 1.53380253221734) +
|
|
Y * (0.000961250184130688 * Y - 0.00266257332283933 * k +
|
|
0.48357088451265) +
|
|
k * (-0.000336197177618394 * k + 0.484791561490776);
|
|
|
|
var g = 107.268039397724 +
|
|
Cb * (2.19927104525741e-5 * Cb - 0.000640992018297945 * Cr +
|
|
0.000659397001245577 * Y + 0.000426105652938837 * k -
|
|
0.176491792462875) +
|
|
Cr * (-0.000778269941513683 * Cr + 0.00130872261408275 * Y +
|
|
0.000770482631801132 * k - 0.151051492775562) +
|
|
Y * (0.00126935368114843 * Y - 0.00265090189010898 * k +
|
|
0.25802910206845) +
|
|
k * (-0.000318913117588328 * k - 0.213742400323665);
|
|
|
|
var b = -20.810012546947 +
|
|
Cb * (-0.000570115196973677 * Cb - 2.63409051004589e-5 * Cr +
|
|
0.0020741088115012 * Y - 0.00288260236853442 * k +
|
|
0.814272968359295) +
|
|
Cr * (-1.53496057440975e-5 * Cr - 0.000132689043961446 * Y +
|
|
0.000560833691242812 * k - 0.195152027534049) +
|
|
Y * (0.00174418132927582 * Y - 0.00255243321439347 * k +
|
|
0.116935020465145) +
|
|
k * (-0.000343531996510555 * k + 0.24165260232407);
|
|
|
|
data[offset++] = clamp0to255(r);
|
|
data[offset++] = clamp0to255(g);
|
|
data[offset++] = clamp0to255(b);
|
|
}
|
|
return data;
|
|
},
|
|
|
|
_convertYcckToCmyk: function convertYcckToCmyk(data) {
|
|
var Y, Cb, Cr;
|
|
for (var i = 0, length = data.length; i < length; i += 4) {
|
|
Y = data[i];
|
|
Cb = data[i + 1];
|
|
Cr = data[i + 2];
|
|
data[i ] = clamp0to255(434.456 - Y - 1.402 * Cr);
|
|
data[i + 1] = clamp0to255(119.541 - Y + 0.344 * Cb + 0.714 * Cr);
|
|
data[i + 2] = clamp0to255(481.816 - Y - 1.772 * Cb);
|
|
// K in data[i + 3] is unchanged
|
|
}
|
|
return data;
|
|
},
|
|
|
|
_convertCmykToRgb: function convertCmykToRgb(data) {
|
|
var c, m, y, k;
|
|
var offset = 0;
|
|
var min = -255 * 255 * 255;
|
|
var scale = 1 / 255 / 255;
|
|
for (var i = 0, length = data.length; i < length; i += 4) {
|
|
c = data[i];
|
|
m = data[i + 1];
|
|
y = data[i + 2];
|
|
k = data[i + 3];
|
|
|
|
var r =
|
|
c * (-4.387332384609988 * c + 54.48615194189176 * m +
|
|
18.82290502165302 * y + 212.25662451639585 * k -
|
|
72734.4411664936) +
|
|
m * (1.7149763477362134 * m - 5.6096736904047315 * y -
|
|
17.873870861415444 * k - 1401.7366389350734) +
|
|
y * (-2.5217340131683033 * y - 21.248923337353073 * k +
|
|
4465.541406466231) -
|
|
k * (21.86122147463605 * k + 48317.86113160301);
|
|
var g =
|
|
c * (8.841041422036149 * c + 60.118027045597366 * m +
|
|
6.871425592049007 * y + 31.159100130055922 * k -
|
|
20220.756542821975) +
|
|
m * (-15.310361306967817 * m + 17.575251261109482 * y +
|
|
131.35250912493976 * k - 48691.05921601825) +
|
|
y * (4.444339102852739 * y + 9.8632861493405 * k -
|
|
6341.191035517494) -
|
|
k * (20.737325471181034 * k + 47890.15695978492);
|
|
var b =
|
|
c * (0.8842522430003296 * c + 8.078677503112928 * m +
|
|
30.89978309703729 * y - 0.23883238689178934 * k -
|
|
3616.812083916688) +
|
|
m * (10.49593273432072 * m + 63.02378494754052 * y +
|
|
50.606957656360734 * k - 28620.90484698408) +
|
|
y * (0.03296041114873217 * y + 115.60384449646641 * k -
|
|
49363.43385999684) -
|
|
k * (22.33816807309886 * k + 45932.16563550634);
|
|
|
|
data[offset++] = r >= 0 ? 255 : r <= min ? 0 : 255 + r * scale | 0;
|
|
data[offset++] = g >= 0 ? 255 : g <= min ? 0 : 255 + g * scale | 0;
|
|
data[offset++] = b >= 0 ? 255 : b <= min ? 0 : 255 + b * scale | 0;
|
|
}
|
|
return data;
|
|
},
|
|
|
|
getData: function getData(width, height, forceRGBoutput) {
|
|
if (this.numComponents > 4) {
|
|
error('JPEG error: Unsupported color mode');
|
|
}
|
|
// type of data: Uint8Array(width * height * numComponents)
|
|
var data = this._getLinearizedBlockData(width, height);
|
|
|
|
if (this.numComponents === 1 && forceRGBoutput) {
|
|
var dataLength = data.length;
|
|
var rgbData = new Uint8Array(dataLength * 3);
|
|
var offset = 0;
|
|
for (var i = 0; i < dataLength; i++) {
|
|
var grayColor = data[i];
|
|
rgbData[offset++] = grayColor;
|
|
rgbData[offset++] = grayColor;
|
|
rgbData[offset++] = grayColor;
|
|
}
|
|
return rgbData;
|
|
} else if (this.numComponents === 3 && this._isColorConversionNeeded()) {
|
|
return this._convertYccToRgb(data);
|
|
} else if (this.numComponents === 4) {
|
|
if (this._isColorConversionNeeded()) {
|
|
if (forceRGBoutput) {
|
|
return this._convertYcckToRgb(data);
|
|
}
|
|
return this._convertYcckToCmyk(data);
|
|
} else if (forceRGBoutput) {
|
|
return this._convertCmykToRgb(data);
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
};
|
|
|
|
return JpegImage;
|
|
})();
|
|
|
|
exports.JpegImage = JpegImage;
|
|
}));
|