1143 lines
38 KiB
JavaScript
1143 lines
38 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 */
|
|
|
|
import { warn } from '../shared/util';
|
|
|
|
let JpegError = (function JpegErrorClosure() {
|
|
function JpegError(msg) {
|
|
this.message = 'JPEG error: ' + msg;
|
|
}
|
|
|
|
JpegError.prototype = new Error();
|
|
JpegError.prototype.name = 'JpegError';
|
|
JpegError.constructor = JpegError;
|
|
|
|
return JpegError;
|
|
})();
|
|
|
|
/**
|
|
* 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) {
|
|
throw new JpegError(
|
|
`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') {
|
|
throw new JpegError('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) {
|
|
throw new JpegError('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, fileMarker;
|
|
var mcuExpected;
|
|
if (componentsLength === 1) {
|
|
mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn;
|
|
} else {
|
|
mcuExpected = mcusPerLine * frame.mcusPerColumn;
|
|
}
|
|
|
|
var h, v;
|
|
while (mcu < mcuExpected) {
|
|
// reset interval stuff
|
|
var mcuToRead = resetInterval ?
|
|
Math.min(mcuExpected - mcu, resetInterval) : mcuExpected;
|
|
for (i = 0; i < componentsLength; i++) {
|
|
components[i].pred = 0;
|
|
}
|
|
eobrun = 0;
|
|
|
|
if (componentsLength === 1) {
|
|
component = components[0];
|
|
for (n = 0; n < mcuToRead; n++) {
|
|
decodeBlock(component, decodeFn, mcu);
|
|
mcu++;
|
|
}
|
|
} else {
|
|
for (n = 0; n < mcuToRead; 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;
|
|
fileMarker = findNextFileMarker(data, offset);
|
|
// Some bad images seem to pad Scan blocks with e.g. zero bytes, skip past
|
|
// those to attempt to find a valid marker (fixes issue4090.pdf).
|
|
if (fileMarker && fileMarker.invalid) {
|
|
warn('decodeScan - unexpected MCU data, next marker is: ' +
|
|
fileMarker.invalid);
|
|
offset = fileMarker.offset;
|
|
}
|
|
var marker = fileMarker && fileMarker.marker;
|
|
if (!marker || marker <= 0xFF00) {
|
|
throw new JpegError('marker was not found');
|
|
}
|
|
|
|
if (marker >= 0xFFD0 && marker <= 0xFFD7) { // RSTx
|
|
offset += 2;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
fileMarker = findNextFileMarker(data, offset);
|
|
// Some images include more Scan blocks than expected, skip past those and
|
|
// attempt to find the next valid marker (fixes issue8182.pdf).
|
|
if (fileMarker && fileMarker.invalid) {
|
|
warn('decodeScan - unexpected Scan data, next marker is: ' +
|
|
fileMarker.invalid);
|
|
offset = fileMarker.offset;
|
|
}
|
|
|
|
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) {
|
|
throw new JpegError('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;
|
|
}
|
|
|
|
function findNextFileMarker(data, currentPos, startPos) {
|
|
function peekUint16(pos) {
|
|
return (data[pos] << 8) | data[pos + 1];
|
|
}
|
|
|
|
var maxPos = data.length - 1;
|
|
var newPos = startPos < currentPos ? startPos : currentPos;
|
|
|
|
if (currentPos >= maxPos) {
|
|
return null; // Don't attempt to read non-existent data and just return.
|
|
}
|
|
var currentMarker = peekUint16(currentPos);
|
|
if (currentMarker >= 0xFFC0 && currentMarker <= 0xFFFE) {
|
|
return {
|
|
invalid: null,
|
|
marker: currentMarker,
|
|
offset: currentPos,
|
|
};
|
|
}
|
|
var newMarker = peekUint16(newPos);
|
|
while (!(newMarker >= 0xFFC0 && newMarker <= 0xFFFE)) {
|
|
if (++newPos >= maxPos) {
|
|
return null; // Don't attempt to read non-existent data and just return.
|
|
}
|
|
newMarker = peekUint16(newPos);
|
|
}
|
|
return {
|
|
invalid: currentMarker.toString(16),
|
|
marker: newMarker,
|
|
offset: newPos,
|
|
};
|
|
}
|
|
|
|
JpegImage.prototype = {
|
|
parse: function parse(data) {
|
|
|
|
function readUint16() {
|
|
var value = (data[offset] << 8) | data[offset + 1];
|
|
offset += 2;
|
|
return value;
|
|
}
|
|
|
|
function readDataBlock() {
|
|
var length = readUint16();
|
|
var endOffset = offset + length - 2;
|
|
|
|
var fileMarker = findNextFileMarker(data, endOffset, offset);
|
|
if (fileMarker && fileMarker.invalid) {
|
|
warn('readDataBlock - incorrect length, next marker is: ' +
|
|
fileMarker.invalid);
|
|
endOffset = fileMarker.offset;
|
|
}
|
|
|
|
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)
|
|
throw new JpegError('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 {
|
|
throw new JpegError('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) {
|
|
throw new JpegError('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,
|
|
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;
|
|
}
|
|
throw new JpegError('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) {
|
|
throw new JpegError('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;
|
|
})();
|
|
|
|
export {
|
|
JpegImage,
|
|
};
|