Merge pull request #786 from brendandahl/cmykjpgnorm
Special color space JPEGS
This commit is contained in:
notmasteryet
commit
59d9dfc014
1
Makefile
1
Makefile
@ -33,6 +33,7 @@ PDF_JS_FILES = \
|
||||
pattern.js \
|
||||
stream.js \
|
||||
worker.js \
|
||||
../external/jpgjs/jpg.js \
|
||||
$(NULL)
|
||||
|
||||
# make server
|
||||
|
||||
@ -22,6 +22,7 @@
|
||||
<script type="text/javascript" src="../../src/pattern.js"></script>
|
||||
<script type="text/javascript" src="../../src/stream.js"></script>
|
||||
<script type="text/javascript" src="../../src/worker.js"></script>
|
||||
<script type="text/javascript" src="../../external/jpgjs/jpg.js"></script>
|
||||
|
||||
<script type="text/javascript">
|
||||
// Specify the main script used to create a new PDF.JS web worker.
|
||||
|
||||
24
external/jpgjs/LICENSE
vendored
Normal file
24
external/jpgjs/LICENSE
vendored
Normal file
@ -0,0 +1,24 @@
|
||||
|
||||
Copyright (C) 2011 by notmasteryet
|
||||
|
||||
Contributors: Yury Delendik
|
||||
Brendan Dahl <bdahl@mozilla.com>
|
||||
|
||||
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.
|
||||
911
external/jpgjs/jpg.js
vendored
Normal file
911
external/jpgjs/jpg.js
vendored
Normal file
@ -0,0 +1,911 @@
|
||||
/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- /
|
||||
/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
|
||||
|
||||
// - 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 jpegImage() {
|
||||
"use strict";
|
||||
var dctZigZag = new Int32Array([
|
||||
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 constructor() {
|
||||
}
|
||||
|
||||
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 decodeScan(data, offset,
|
||||
frame, components, resetInterval,
|
||||
spectralStart, spectralEnd,
|
||||
successivePrev, successive) {
|
||||
var precision = frame.precision;
|
||||
var samplesPerLine = frame.samplesPerLine;
|
||||
var scanLines = frame.scanLines;
|
||||
var mcusPerLine = frame.mcusPerLine;
|
||||
var progressive = frame.progressive;
|
||||
var maxH = frame.maxH, maxV = frame.maxV;
|
||||
|
||||
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 "unexpected marker: " + ((bitsData << 8) | nextByte).toString(16);
|
||||
}
|
||||
// unstuff 0
|
||||
}
|
||||
bitsCount = 7;
|
||||
return bitsData >>> 7;
|
||||
}
|
||||
function decodeHuffman(tree) {
|
||||
var node = tree, bit;
|
||||
while ((bit = readBit()) !== null) {
|
||||
node = node[bit];
|
||||
if (typeof node === 'number')
|
||||
return node;
|
||||
if (typeof node !== 'object')
|
||||
throw "invalid huffman sequence";
|
||||
}
|
||||
return null;
|
||||
}
|
||||
function receive(length) {
|
||||
var n = 0;
|
||||
while (length > 0) {
|
||||
var bit = readBit();
|
||||
if (bit === null) return;
|
||||
n = (n << 1) | bit;
|
||||
length--;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
function receiveAndExtend(length) {
|
||||
var n = receive(length);
|
||||
if (n >= 1 << (length - 1))
|
||||
return n;
|
||||
return n + (-1 << length) + 1;
|
||||
}
|
||||
function decodeBaseline(component, zz) {
|
||||
var t = decodeHuffman(component.huffmanTableDC);
|
||||
var diff = t === 0 ? 0 : receiveAndExtend(t);
|
||||
zz[0]= (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];
|
||||
zz[z] = receiveAndExtend(s);
|
||||
k++;
|
||||
}
|
||||
}
|
||||
function decodeDCFirst(component, zz) {
|
||||
var t = decodeHuffman(component.huffmanTableDC);
|
||||
var diff = t === 0 ? 0 : (receiveAndExtend(t) << successive);
|
||||
zz[0] = (component.pred += diff);
|
||||
}
|
||||
function decodeDCSuccessive(component, zz) {
|
||||
zz[0] |= readBit() << successive;
|
||||
}
|
||||
var eobrun = 0;
|
||||
function decodeACFirst(component, zz) {
|
||||
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];
|
||||
zz[z] = receiveAndExtend(s) * (1 << successive);
|
||||
k++;
|
||||
}
|
||||
}
|
||||
var successiveACState = 0, successiveACNextValue;
|
||||
function decodeACSuccessive(component, zz) {
|
||||
var k = spectralStart, e = spectralEnd, r = 0;
|
||||
while (k <= e) {
|
||||
var z = dctZigZag[k];
|
||||
switch (successiveACState) {
|
||||
case 0: // initial state
|
||||
var rs = decodeHuffman(component.huffmanTableAC);
|
||||
var 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 "invalid ACn encoding";
|
||||
successiveACNextValue = receiveAndExtend(s);
|
||||
successiveACState = r ? 2 : 3;
|
||||
}
|
||||
continue;
|
||||
case 1: // skipping r zero items
|
||||
case 2:
|
||||
if (zz[z])
|
||||
zz[z] += (readBit() << successive);
|
||||
else {
|
||||
r--;
|
||||
if (r === 0)
|
||||
successiveACState = successiveACState == 2 ? 3 : 0;
|
||||
}
|
||||
break;
|
||||
case 3: // set value for a zero item
|
||||
if (zz[z])
|
||||
zz[z] += (readBit() << successive);
|
||||
else {
|
||||
zz[z] = successiveACNextValue << successive;
|
||||
successiveACState = 0;
|
||||
}
|
||||
break;
|
||||
case 4: // eob
|
||||
if (zz[z])
|
||||
zz[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;
|
||||
decode(component, component.blocks[blockRow][blockCol]);
|
||||
}
|
||||
function decodeBlock(component, decode, mcu) {
|
||||
var blockRow = (mcu / component.blocksPerLine) | 0;
|
||||
var blockCol = mcu % component.blocksPerLine;
|
||||
decode(component, component.blocks[blockRow][blockCol]);
|
||||
}
|
||||
|
||||
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];
|
||||
if (marker <= 0xFF00) {
|
||||
throw "marker was not found";
|
||||
}
|
||||
|
||||
if (marker >= 0xFFD0 && marker <= 0xFFD7) { // RSTx
|
||||
offset += 2;
|
||||
}
|
||||
else
|
||||
break;
|
||||
}
|
||||
|
||||
return offset - startOffset;
|
||||
}
|
||||
|
||||
function buildComponentData(frame, component) {
|
||||
var lines = [];
|
||||
var blocksPerLine = component.blocksPerLine;
|
||||
var blocksPerColumn = component.blocksPerColumn;
|
||||
var samplesPerLine = blocksPerLine << 3;
|
||||
var R = new Int32Array(64), r = new Uint8Array(64);
|
||||
|
||||
// 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(zz, dataOut, dataIn) {
|
||||
var qt = component.quantizationTable;
|
||||
var v0, v1, v2, v3, v4, v5, v6, v7, t;
|
||||
var p = dataIn;
|
||||
var i;
|
||||
|
||||
// dequant
|
||||
for (i = 0; i < 64; i++)
|
||||
p[i] = zz[i] * qt[i];
|
||||
|
||||
// inverse DCT on rows
|
||||
for (i = 0; i < 8; ++i) {
|
||||
var row = 8 * i;
|
||||
|
||||
// check for all-zero AC coefficients
|
||||
if (p[1 + row] == 0 && p[2 + row] == 0 && p[3 + row] == 0 &&
|
||||
p[4 + row] == 0 && p[5 + row] == 0 && p[6 + row] == 0 &&
|
||||
p[7 + row] == 0) {
|
||||
t = (dctSqrt2 * p[0 + row] + 512) >> 10;
|
||||
p[0 + row] = t;
|
||||
p[1 + row] = t;
|
||||
p[2 + row] = t;
|
||||
p[3 + row] = t;
|
||||
p[4 + row] = t;
|
||||
p[5 + row] = t;
|
||||
p[6 + row] = t;
|
||||
p[7 + row] = t;
|
||||
continue;
|
||||
}
|
||||
|
||||
// stage 4
|
||||
v0 = (dctSqrt2 * p[0 + row] + 128) >> 8;
|
||||
v1 = (dctSqrt2 * p[4 + row] + 128) >> 8;
|
||||
v2 = p[2 + row];
|
||||
v3 = p[6 + row];
|
||||
v4 = (dctSqrt1d2 * (p[1 + row] - p[7 + row]) + 128) >> 8;
|
||||
v7 = (dctSqrt1d2 * (p[1 + row] + p[7 + row]) + 128) >> 8;
|
||||
v5 = p[3 + row] << 4;
|
||||
v6 = p[5 + row] << 4;
|
||||
|
||||
// stage 3
|
||||
t = (v0 - v1+ 1) >> 1;
|
||||
v0 = (v0 + v1 + 1) >> 1;
|
||||
v1 = t;
|
||||
t = (v2 * dctSin6 + v3 * dctCos6 + 128) >> 8;
|
||||
v2 = (v2 * dctCos6 - v3 * dctSin6 + 128) >> 8;
|
||||
v3 = t;
|
||||
t = (v4 - v6 + 1) >> 1;
|
||||
v4 = (v4 + v6 + 1) >> 1;
|
||||
v6 = t;
|
||||
t = (v7 + v5 + 1) >> 1;
|
||||
v5 = (v7 - v5 + 1) >> 1;
|
||||
v7 = t;
|
||||
|
||||
// stage 2
|
||||
t = (v0 - v3 + 1) >> 1;
|
||||
v0 = (v0 + v3 + 1) >> 1;
|
||||
v3 = t;
|
||||
t = (v1 - v2 + 1) >> 1;
|
||||
v1 = (v1 + v2 + 1) >> 1;
|
||||
v2 = t;
|
||||
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[0 + row] = v0 + v7;
|
||||
p[7 + row] = v0 - v7;
|
||||
p[1 + row] = v1 + v6;
|
||||
p[6 + row] = v1 - v6;
|
||||
p[2 + row] = v2 + v5;
|
||||
p[5 + row] = v2 - v5;
|
||||
p[3 + row] = v3 + v4;
|
||||
p[4 + row] = v3 - v4;
|
||||
}
|
||||
|
||||
// inverse DCT on columns
|
||||
for (i = 0; i < 8; ++i) {
|
||||
var col = i;
|
||||
|
||||
// check for all-zero AC coefficients
|
||||
if (p[1*8 + col] == 0 && p[2*8 + col] == 0 && p[3*8 + col] == 0 &&
|
||||
p[4*8 + col] == 0 && p[5*8 + col] == 0 && p[6*8 + col] == 0 &&
|
||||
p[7*8 + col] == 0) {
|
||||
t = (dctSqrt2 * dataIn[i+0] + 8192) >> 14;
|
||||
p[0*8 + col] = t;
|
||||
p[1*8 + col] = t;
|
||||
p[2*8 + col] = t;
|
||||
p[3*8 + col] = t;
|
||||
p[4*8 + col] = t;
|
||||
p[5*8 + col] = t;
|
||||
p[6*8 + col] = t;
|
||||
p[7*8 + col] = t;
|
||||
continue;
|
||||
}
|
||||
|
||||
// stage 4
|
||||
v0 = (dctSqrt2 * p[0*8 + col] + 2048) >> 12;
|
||||
v1 = (dctSqrt2 * p[4*8 + col] + 2048) >> 12;
|
||||
v2 = p[2*8 + col];
|
||||
v3 = p[6*8 + col];
|
||||
v4 = (dctSqrt1d2 * (p[1*8 + col] - p[7*8 + col]) + 2048) >> 12;
|
||||
v7 = (dctSqrt1d2 * (p[1*8 + col] + p[7*8 + col]) + 2048) >> 12;
|
||||
v5 = p[3*8 + col];
|
||||
v6 = p[5*8 + col];
|
||||
|
||||
// stage 3
|
||||
t = (v0 - v1 + 1) >> 1;
|
||||
v0 = (v0 + v1 + 1) >> 1;
|
||||
v1 = t;
|
||||
t = (v2 * dctSin6 + v3 * dctCos6 + 2048) >> 12;
|
||||
v2 = (v2 * dctCos6 - v3 * dctSin6 + 2048) >> 12;
|
||||
v3 = t;
|
||||
t = (v4 - v6 + 1) >> 1;
|
||||
v4 = (v4 + v6 + 1) >> 1;
|
||||
v6 = t;
|
||||
t = (v7 + v5 + 1) >> 1;
|
||||
v5 = (v7 - v5 + 1) >> 1;
|
||||
v7 = t;
|
||||
|
||||
// stage 2
|
||||
t = (v0 - v3 + 1) >> 1;
|
||||
v0 = (v0 + v3 + 1) >> 1;
|
||||
v3 = t;
|
||||
t = (v1 - v2 + 1) >> 1;
|
||||
v1 = (v1 + v2 + 1) >> 1;
|
||||
v2 = t;
|
||||
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[0*8 + col] = v0 + v7;
|
||||
p[7*8 + col] = v0 - v7;
|
||||
p[1*8 + col] = v1 + v6;
|
||||
p[6*8 + col] = v1 - v6;
|
||||
p[2*8 + col] = v2 + v5;
|
||||
p[5*8 + col] = v2 - v5;
|
||||
p[3*8 + col] = v3 + v4;
|
||||
p[4*8 + col] = v3 - v4;
|
||||
}
|
||||
|
||||
// convert to 8-bit integers
|
||||
for (i = 0; i < 64; ++i) {
|
||||
var sample = 128 + ((p[i] + 8) >> 4);
|
||||
dataOut[i] = sample < 0 ? 0 : sample > 0xFF ? 0xFF : sample;
|
||||
}
|
||||
}
|
||||
|
||||
var i, j;
|
||||
for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) {
|
||||
var scanLine = blockRow << 3;
|
||||
for (i = 0; i < 8; i++)
|
||||
lines.push(new Uint8Array(samplesPerLine));
|
||||
for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) {
|
||||
quantizeAndInverse(component.blocks[blockRow][blockCol], r, R);
|
||||
|
||||
var offset = 0, sample = blockCol << 3;
|
||||
for (j = 0; j < 8; j++) {
|
||||
var line = lines[scanLine + j];
|
||||
for (i = 0; i < 8; i++)
|
||||
line[sample + i] = r[offset++];
|
||||
}
|
||||
}
|
||||
}
|
||||
return lines;
|
||||
}
|
||||
|
||||
constructor.prototype = {
|
||||
load: function load(path) {
|
||||
var xhr = new XMLHttpRequest();
|
||||
xhr.open("GET", path, true);
|
||||
xhr.responseType = "arraybuffer";
|
||||
xhr.onload = (function() {
|
||||
// TODO catch parse error
|
||||
var data = new Uint8Array(xhr.response || xhr.mozResponseArrayBuffer);
|
||||
this.parse(data);
|
||||
if (this.onload)
|
||||
this.onload();
|
||||
}).bind(this);
|
||||
xhr.send(null);
|
||||
},
|
||||
parse: function parse(data) {
|
||||
var offset = 0, length = data.length;
|
||||
function readUint16() {
|
||||
var value = (data[offset] << 8) | data[offset + 1];
|
||||
offset += 2;
|
||||
return value;
|
||||
}
|
||||
function readDataBlock() {
|
||||
var length = readUint16();
|
||||
var array = data.subarray(offset, offset + length - 2);
|
||||
offset += array.length;
|
||||
return array;
|
||||
}
|
||||
function prepareComponents(frame) {
|
||||
var maxH = 0, maxV = 0;
|
||||
var component, componentId;
|
||||
for (componentId in frame.components) {
|
||||
if (frame.components.hasOwnProperty(componentId)) {
|
||||
component = frame.components[componentId];
|
||||
if (maxH < component.h) maxH = component.h;
|
||||
if (maxV < component.v) maxV = component.v;
|
||||
}
|
||||
}
|
||||
var mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / maxH);
|
||||
var mcusPerColumn = Math.ceil(frame.scanLines / 8 / maxV);
|
||||
for (componentId in frame.components) {
|
||||
if (frame.components.hasOwnProperty(componentId)) {
|
||||
component = frame.components[componentId];
|
||||
var blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / maxH);
|
||||
var blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / maxV);
|
||||
var blocksPerLineForMcu = mcusPerLine * component.h;
|
||||
var blocksPerColumnForMcu = mcusPerColumn * component.v;
|
||||
var blocks = [];
|
||||
for (var i = 0; i < blocksPerColumnForMcu; i++) {
|
||||
var row = [];
|
||||
for (var j = 0; j < blocksPerLineForMcu; j++)
|
||||
row.push(new Int32Array(64));
|
||||
blocks.push(row);
|
||||
}
|
||||
component.blocksPerLine = blocksPerLine;
|
||||
component.blocksPerColumn = blocksPerColumn;
|
||||
component.blocks = blocks;
|
||||
}
|
||||
}
|
||||
frame.maxH = maxH;
|
||||
frame.maxV = maxV;
|
||||
frame.mcusPerLine = mcusPerLine;
|
||||
frame.mcusPerColumn = mcusPerColumn;
|
||||
}
|
||||
var jfif = null;
|
||||
var adobe = null;
|
||||
var pixels = null;
|
||||
var frame, resetInterval;
|
||||
var quantizationTables = [], frames = [];
|
||||
var huffmanTablesAC = [], huffmanTablesDC = [];
|
||||
var fileMarker = readUint16();
|
||||
if (fileMarker != 0xFFD8) { // SOI (Start of Image)
|
||||
throw "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 && appData[5] === 0) { // 'Adobe\x00'
|
||||
adobe = {
|
||||
version: 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 quantizationTableCount = Math.floor((readUint16() - 2) / 65);
|
||||
for (i = 0; i < quantizationTableCount; i++) {
|
||||
var quantizationTableSpec = data[offset++];
|
||||
var tableData = new Int32Array(64);
|
||||
if ((quantizationTableSpec >> 4) === 0) { // 8 bit values
|
||||
for (j = 0; j < 64; j++) {
|
||||
var z = dctZigZag[j];
|
||||
tableData[z] = data[offset++];
|
||||
}
|
||||
} else if ((quantizationTableSpec >> 4) === 1) { //16 bit
|
||||
tableData[j] = readUint16();
|
||||
} else
|
||||
throw "DQT: invalid table spec";
|
||||
quantizationTables[quantizationTableSpec & 15] = tableData;
|
||||
}
|
||||
break;
|
||||
|
||||
case 0xFFC0: // SOF0 (Start of Frame, Baseline DCT)
|
||||
case 0xFFC2: // SOF2 (Start of Frame, Progressive DCT)
|
||||
readUint16(); // skip data length
|
||||
frame = {};
|
||||
frame.progressive = (fileMarker === 0xFFC2);
|
||||
frame.precision = data[offset++];
|
||||
frame.scanLines = readUint16();
|
||||
frame.samplesPerLine = readUint16();
|
||||
frame.components = [];
|
||||
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;
|
||||
var qId = data[offset + 2];
|
||||
frame.components[componentId] = {
|
||||
h: h,
|
||||
v: v,
|
||||
quantizationTable: quantizationTables[qId]
|
||||
};
|
||||
offset += 3;
|
||||
}
|
||||
prepareComponents(frame);
|
||||
frames.push(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)
|
||||
var scanLength = readUint16();
|
||||
var selectorsCount = data[offset++];
|
||||
var components = [], component;
|
||||
for (i = 0; i < selectorsCount; i++) {
|
||||
component = frame.components[data[offset++]];
|
||||
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;
|
||||
default:
|
||||
throw "unknown JPEG marker " + fileMarker.toString(16);
|
||||
}
|
||||
fileMarker = readUint16();
|
||||
}
|
||||
if (frames.length != 1)
|
||||
throw "only single frame JPEGs supported";
|
||||
|
||||
this.width = frame.samplesPerLine;
|
||||
this.height = frame.scanLines;
|
||||
this.jfif = jfif;
|
||||
this.adobe = adobe;
|
||||
this.components = [];
|
||||
for (var id in frame.components) {
|
||||
if (frame.components.hasOwnProperty(id)) {
|
||||
this.components.push({
|
||||
lines: buildComponentData(frame, frame.components[id]),
|
||||
scaleX: frame.components[id].h / frame.maxH,
|
||||
scaleY: frame.components[id].v / frame.maxV
|
||||
});
|
||||
}
|
||||
}
|
||||
},
|
||||
getData: function getData(width, height) {
|
||||
function clampTo8bit(a) {
|
||||
return a < 0 ? 0 : a > 255 ? 255 : a;
|
||||
}
|
||||
var scaleX = this.width / width, scaleY = this.height / height;
|
||||
|
||||
var component1, component2, component3, component4;
|
||||
var component1Line, component2Line, component3Line, component4Line;
|
||||
var x, y;
|
||||
var offset = 0;
|
||||
var Y, Cb, Cr, K, C, M, Ye, R, G, B;
|
||||
var colorTransform;
|
||||
var dataLength = width * height * this.components.length;
|
||||
var data = new Uint8Array(dataLength);
|
||||
switch (this.components.length) {
|
||||
case 1:
|
||||
component1 = this.components[0];
|
||||
for (y = 0; y < height; y++) {
|
||||
component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)];
|
||||
for (x = 0; x < width; x++) {
|
||||
Y = component1Line[0 | (x * component1.scaleX * scaleX)];
|
||||
|
||||
data[offset++] = Y;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
// The default transform for three components is true
|
||||
colorTransform = true;
|
||||
// The adobe transform marker overrides any previous setting
|
||||
if (this.adobe && this.adobe.transformCode)
|
||||
colorTransform = true;
|
||||
else if (typeof this.colorTransform !== 'undefined')
|
||||
colorTransform = !!this.colorTransform;
|
||||
|
||||
component1 = this.components[0];
|
||||
component2 = this.components[1];
|
||||
component3 = this.components[2];
|
||||
for (y = 0; y < height; y++) {
|
||||
component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)];
|
||||
component2Line = component2.lines[0 | (y * component2.scaleY * scaleY)];
|
||||
component3Line = component3.lines[0 | (y * component3.scaleY * scaleY)];
|
||||
for (x = 0; x < width; x++) {
|
||||
if (!colorTransform) {
|
||||
R = component1Line[0 | (x * component1.scaleX * scaleX)];
|
||||
G = component2Line[0 | (x * component2.scaleX * scaleX)];
|
||||
B = component3Line[0 | (x * component3.scaleX * scaleX)];
|
||||
} else {
|
||||
Y = component1Line[0 | (x * component1.scaleX * scaleX)];
|
||||
Cb = component2Line[0 | (x * component2.scaleX * scaleX)];
|
||||
Cr = component3Line[0 | (x * component3.scaleX * scaleX)];
|
||||
|
||||
R = clampTo8bit(Y + 1.402 * (Cr - 128));
|
||||
G = clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128));
|
||||
B = clampTo8bit(Y + 1.772 * (Cb - 128));
|
||||
}
|
||||
|
||||
data[offset++] = R;
|
||||
data[offset++] = G;
|
||||
data[offset++] = B;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
if (!this.adobe)
|
||||
throw 'Unsupported color mode (4 components)';
|
||||
// The default transform for four components is false
|
||||
colorTransform = false;
|
||||
// The adobe transform marker overrides any previous setting
|
||||
if (this.adobe && this.adobe.transformCode)
|
||||
colorTransform = true;
|
||||
else if (typeof this.colorTransform !== 'undefined')
|
||||
colorTransform = !!this.colorTransform;
|
||||
|
||||
component1 = this.components[0];
|
||||
component2 = this.components[1];
|
||||
component3 = this.components[2];
|
||||
component4 = this.components[3];
|
||||
for (y = 0; y < height; y++) {
|
||||
component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)];
|
||||
component2Line = component2.lines[0 | (y * component2.scaleY * scaleY)];
|
||||
component3Line = component3.lines[0 | (y * component3.scaleY * scaleY)];
|
||||
component4Line = component4.lines[0 | (y * component4.scaleY * scaleY)];
|
||||
for (x = 0; x < width; x++) {
|
||||
if (!colorTransform) {
|
||||
C = component1Line[0 | (x * component1.scaleX * scaleX)];
|
||||
M = component2Line[0 | (x * component2.scaleX * scaleX)];
|
||||
Ye = component3Line[0 | (x * component3.scaleX * scaleX)];
|
||||
K = component4Line[0 | (x * component4.scaleX * scaleX)];
|
||||
} else {
|
||||
Y = component1Line[0 | (x * component1.scaleX * scaleX)];
|
||||
Cb = component2Line[0 | (x * component2.scaleX * scaleX)];
|
||||
Cr = component3Line[0 | (x * component3.scaleX * scaleX)];
|
||||
K = component4Line[0 | (x * component4.scaleX * scaleX)];
|
||||
|
||||
C = 255 - clampTo8bit(Y + 1.402 * (Cr - 128));
|
||||
M = 255 - clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128));
|
||||
Ye = 255 - clampTo8bit(Y + 1.772 * (Cb - 128));
|
||||
}
|
||||
data[offset++] = C;
|
||||
data[offset++] = M;
|
||||
data[offset++] = Ye;
|
||||
data[offset++] = K;
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
throw 'Unsupported color mode';
|
||||
}
|
||||
return data;
|
||||
},
|
||||
copyToImageData: function copyToImageData(imageData) {
|
||||
var width = imageData.width, height = imageData.height;
|
||||
var imageDataArray = imageData.data;
|
||||
var data = this.getData(width, height);
|
||||
var i = 0, j = 0, x, y;
|
||||
var Y, K, C, M, R, G, B;
|
||||
switch (this.components.length) {
|
||||
case 1:
|
||||
for (y = 0; y < height; y++) {
|
||||
for (x = 0; x < width; x++) {
|
||||
Y = data[i++];
|
||||
|
||||
imageDataArray[j++] = Y;
|
||||
imageDataArray[j++] = Y;
|
||||
imageDataArray[j++] = Y;
|
||||
imageDataArray[j++] = 255;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
for (y = 0; y < height; y++) {
|
||||
for (x = 0; x < width; x++) {
|
||||
R = data[i++];
|
||||
G = data[i++];
|
||||
B = data[i++];
|
||||
|
||||
imageDataArray[j++] = R;
|
||||
imageDataArray[j++] = G;
|
||||
imageDataArray[j++] = B;
|
||||
imageDataArray[j++] = 255;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
for (y = 0; y < height; y++) {
|
||||
for (x = 0; x < width; x++) {
|
||||
C = data[i++];
|
||||
M = data[i++];
|
||||
Y = data[i++];
|
||||
K = data[i++];
|
||||
|
||||
R = 255 - clampTo8bit(C * (1 - K / 255) + K);
|
||||
G = 255 - clampTo8bit(M * (1 - K / 255) + K);
|
||||
B = 255 - clampTo8bit(Y * (1 - K / 255) + K);
|
||||
|
||||
imageDataArray[j++] = R;
|
||||
imageDataArray[j++] = G;
|
||||
imageDataArray[j++] = B;
|
||||
imageDataArray[j++] = 255;
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
throw 'Unsupported color mode';
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
return constructor;
|
||||
})();
|
||||
@ -550,7 +550,7 @@ var PDFDoc = (function pdfDoc() {
|
||||
switch (type) {
|
||||
case 'JpegStream':
|
||||
var IR = data[2];
|
||||
new JpegImage(id, IR, this.objs);
|
||||
new JpegImageLoader(id, IR, this.objs);
|
||||
break;
|
||||
case 'Font':
|
||||
var name = data[2];
|
||||
|
||||
@ -179,7 +179,7 @@ var PartialEvaluator = (function partialEvaluator() {
|
||||
var w = dict.get('Width', 'W');
|
||||
var h = dict.get('Height', 'H');
|
||||
|
||||
if (image instanceof JpegStream) {
|
||||
if (image instanceof JpegStream && image.isNative) {
|
||||
var objId = 'img_' + uniquePrefix + (++self.objIdCounter);
|
||||
handler.send('obj', [objId, 'JpegStream', image.getIR()]);
|
||||
|
||||
|
||||
12
src/image.js
12
src/image.js
@ -229,12 +229,12 @@ var PDFImage = (function pdfImage() {
|
||||
return constructor;
|
||||
})();
|
||||
|
||||
var JpegImage = (function jpegImage() {
|
||||
function JpegImage(objId, imageData, objs) {
|
||||
var JpegImageLoader = (function jpegImage() {
|
||||
function JpegImageLoader(objId, imageData, objs) {
|
||||
var src = 'data:image/jpeg;base64,' + window.btoa(imageData);
|
||||
|
||||
var img = new Image();
|
||||
img.onload = (function jpegImageOnload() {
|
||||
img.onload = (function jpegImageLoaderOnload() {
|
||||
this.loaded = true;
|
||||
|
||||
objs.resolve(objId, this);
|
||||
@ -246,12 +246,12 @@ var JpegImage = (function jpegImage() {
|
||||
this.domImage = img;
|
||||
}
|
||||
|
||||
JpegImage.prototype = {
|
||||
getImage: function jpegImageGetImage() {
|
||||
JpegImageLoader.prototype = {
|
||||
getImage: function jpegImageLoaderGetImage() {
|
||||
return this.domImage;
|
||||
}
|
||||
};
|
||||
|
||||
return JpegImage;
|
||||
return JpegImageLoader;
|
||||
})();
|
||||
|
||||
|
||||
@ -236,7 +236,7 @@ var Parser = (function parserParser() {
|
||||
return new LZWStream(stream, earlyChange);
|
||||
} else if (name == 'DCTDecode' || name == 'DCT') {
|
||||
var bytes = stream.getBytes(length);
|
||||
return new JpegStream(bytes, stream.dict);
|
||||
return new JpegStream(bytes, stream.dict, this.xref);
|
||||
} else if (name == 'ASCII85Decode' || name == 'A85') {
|
||||
return new Ascii85Stream(stream);
|
||||
} else if (name == 'ASCIIHexDecode' || name == 'AHx') {
|
||||
|
||||
@ -756,8 +756,13 @@ var PredictorStream = (function predictorStream() {
|
||||
return constructor;
|
||||
})();
|
||||
|
||||
// A JpegStream can't be read directly. We use the platform to render
|
||||
// the underlying JPEG data for us.
|
||||
/**
|
||||
* Depending on the type of JPEG a JpegStream is handled in different ways. For
|
||||
* JPEG's that are supported natively such as DeviceGray and DeviceRGB the image
|
||||
* data is stored and then loaded by the browser. For unsupported JPEG's we use
|
||||
* a library to decode these images and the stream behaves like all the other
|
||||
* DecodeStreams.
|
||||
*/
|
||||
var JpegStream = (function jpegStream() {
|
||||
function isAdobeImage(bytes) {
|
||||
var maxBytesScanned = Math.max(bytes.length - 16, 1024);
|
||||
@ -789,24 +794,56 @@ var JpegStream = (function jpegStream() {
|
||||
return newBytes;
|
||||
}
|
||||
|
||||
function constructor(bytes, dict) {
|
||||
function constructor(bytes, dict, xref) {
|
||||
// TODO: per poppler, some images may have 'junk' before that
|
||||
// need to be removed
|
||||
this.dict = dict;
|
||||
|
||||
if (isAdobeImage(bytes))
|
||||
bytes = fixAdobeImage(bytes);
|
||||
// Flag indicating wether the image can be natively loaded.
|
||||
this.isNative = true;
|
||||
|
||||
this.src = bytesToString(bytes);
|
||||
this.colorTransform = -1;
|
||||
|
||||
if (isAdobeImage(bytes)) {
|
||||
// when bug 674619 land, let's check if browser can do
|
||||
// normal cmyk and then we won't have to the following
|
||||
var cs = xref.fetchIfRef(dict.get('ColorSpace'));
|
||||
|
||||
// DeviceRGB and DeviceGray are the only Adobe images that work natively
|
||||
if (isName(cs) && (cs.name === 'DeviceRGB' || cs.name === 'DeviceGray')) {
|
||||
bytes = fixAdobeImage(bytes);
|
||||
this.src = bytesToString(bytes);
|
||||
} else {
|
||||
this.colorTransform = dict.get('ColorTransform');
|
||||
this.isNative = false;
|
||||
this.bytes = bytes;
|
||||
}
|
||||
} else {
|
||||
this.src = bytesToString(bytes);
|
||||
}
|
||||
|
||||
DecodeStream.call(this);
|
||||
}
|
||||
|
||||
constructor.prototype = {
|
||||
getIR: function jpegStreamGetIR() {
|
||||
return this.src;
|
||||
},
|
||||
getChar: function jpegStreamGetChar() {
|
||||
constructor.prototype = Object.create(DecodeStream.prototype);
|
||||
|
||||
constructor.prototype.ensureBuffer = function jpegStreamEnsureBuffer(req) {
|
||||
if (this.bufferLength)
|
||||
return;
|
||||
var jpegImage = new JpegImage();
|
||||
jpegImage.colorTransform = this.colorTransform;
|
||||
jpegImage.parse(this.bytes);
|
||||
var width = jpegImage.width;
|
||||
var height = jpegImage.height;
|
||||
var data = jpegImage.getData(width, height);
|
||||
this.buffer = data;
|
||||
this.bufferLength = data.length;
|
||||
};
|
||||
constructor.prototype.getIR = function jpegStreamGetIR() {
|
||||
return this.src;
|
||||
};
|
||||
constructor.prototype.getChar = function jpegStreamGetChar() {
|
||||
error('internal error: getChar is not valid on JpegStream');
|
||||
}
|
||||
};
|
||||
|
||||
return constructor;
|
||||
|
||||
@ -40,7 +40,8 @@ function onMessageLoader(evt) {
|
||||
'parser.js',
|
||||
'pattern.js',
|
||||
'stream.js',
|
||||
'worker.js'
|
||||
'worker.js',
|
||||
'../external/jpgjs/jpg.js'
|
||||
];
|
||||
|
||||
// Load all the files.
|
||||
|
||||
2
test/pdfs/.gitignore
vendored
2
test/pdfs/.gitignore
vendored
@ -15,4 +15,4 @@
|
||||
!close-path-bug.pdf
|
||||
!alphatrans.pdf
|
||||
!devicen.pdf
|
||||
|
||||
!cmykjpeg.pdf
|
||||
|
||||
2178
test/pdfs/cmykjpeg.pdf
Normal file
2178
test/pdfs/cmykjpeg.pdf
Normal file
File diff suppressed because one or more lines are too long
@ -1 +0,0 @@
|
||||
http://openweb.flossmanuals.net/materials/openweb_tm-PRINT.pdf
|
||||
@ -20,6 +20,7 @@
|
||||
{ "id": "intelisa-load",
|
||||
"file": "pdfs/intelisa.pdf",
|
||||
"md5": "f5712097d29287a97f1278839814f682",
|
||||
"md5": "f3ed5487d1afa34d8b77c0c734a95c79",
|
||||
"link": true,
|
||||
"rounds": 1,
|
||||
"type": "load"
|
||||
@ -44,13 +45,6 @@
|
||||
"rounds": 1,
|
||||
"type": "eq"
|
||||
},
|
||||
{ "id": "openweb-cover",
|
||||
"file": "pdfs/openweb_tm-PRINT.pdf",
|
||||
"md5": "53f611dfc19ddfb50554c21c4af465c0",
|
||||
"link": true,
|
||||
"rounds": 1,
|
||||
"type": "eq"
|
||||
},
|
||||
{ "id": "plusminus",
|
||||
"file": "pdfs/Test-plusminus.pdf",
|
||||
"md5": "1ec7ade5b95ac9aaba3a618af28d34c7",
|
||||
@ -275,5 +269,12 @@
|
||||
"link": false,
|
||||
"rounds": 1,
|
||||
"type": "eq"
|
||||
},
|
||||
{ "id": "cmykjpeg",
|
||||
"file": "pdfs/cmykjpeg.pdf",
|
||||
"md5": "85d162b48ce98503a382d96f574f70a2",
|
||||
"link": false,
|
||||
"rounds": 1,
|
||||
"type": "eq"
|
||||
}
|
||||
]
|
||||
|
||||
@ -21,6 +21,7 @@
|
||||
<script type="text/javascript" src="/src/pattern.js"></script>
|
||||
<script type="text/javascript" src="/src/stream.js"></script>
|
||||
<script type="text/javascript" src="/src/worker.js"></script>
|
||||
<script type="text/javascript" src="/external/jpgjs/jpg.js"></script>
|
||||
<script type="text/javascript" src="driver.js"></script>
|
||||
|
||||
<script type="text/javascript">
|
||||
|
||||
@ -25,7 +25,7 @@
|
||||
<script type="text/javascript" src="../src/pattern.js"></script> <!-- PDFJSSCRIPT_REMOVE -->
|
||||
<script type="text/javascript" src="../src/stream.js"></script> <!-- PDFJSSCRIPT_REMOVE -->
|
||||
<script type="text/javascript" src="../src/worker.js"></script> <!-- PDFJSSCRIPT_REMOVE -->
|
||||
|
||||
<script type="text/javascript" src="../external/jpgjs/jpg.js"></script> <!-- PDFJSSCRIPT_REMOVE -->
|
||||
<script type="text/javascript">PDFJS.workerSrc = '../src/worker_loader.js';</script> <!-- PDFJSSCRIPT_REMOVE -->
|
||||
|
||||
<script type="text/javascript" src="viewer.js"></script>
|
||||
|
||||
Loading…
Reference in New Issue
Block a user