722 lines
25 KiB
JavaScript
722 lines
25 KiB
JavaScript
|
/* -*- 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";
|
||
|
|
|
||
|
|
function constructor(colorTransform) {
|
||
|
|
this.colorTransform = typeof colorTransform !== 'undefined' ? colorTransform : -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
var iDCTTables = (function initDCTTables() {
|
||
|
|
var cosTables = [], i, j;
|
||
|
|
for (i = 0; i < 8; i++) {
|
||
|
|
cosTables.push(new Float32Array(8));
|
||
|
|
for (j = 0; j < 8; j++)
|
||
|
|
cosTables[i][j] = Math.cos((2 * i + 1) * j * Math.PI / 16) *
|
||
|
|
(j > 0 ? 1 : 1/Math.sqrt(2));
|
||
|
|
}
|
||
|
|
|
||
|
|
var zzTransform = new Int32Array([
|
||
|
|
0, 1, 5, 6, 14, 15, 27, 28, 2, 4, 7, 13, 16, 26, 29, 42, 3, 8, 12,
|
||
|
|
17, 25, 30, 41, 43, 9, 11, 18, 24, 31, 40, 44, 53, 10, 19, 23, 32,
|
||
|
|
39, 45, 52, 54, 20, 22, 33, 38, 46, 51, 55, 60, 21, 34, 37, 47,
|
||
|
|
50, 56, 59, 61, 35, 36, 48, 49, 57, 58, 62, 63]);
|
||
|
|
|
||
|
|
var x, y, u, v;
|
||
|
|
var tables = [];
|
||
|
|
for (y = 0; y < 8; y++) {
|
||
|
|
var cosTable_y = cosTables[y];
|
||
|
|
for (x = 0; x < 8; x++) {
|
||
|
|
var cosTable_x = cosTables[x];
|
||
|
|
var table = new Float32Array(64);
|
||
|
|
i = 0;
|
||
|
|
for (v = 0; v < 8; v++) {
|
||
|
|
for (u = 0; u < 8; u++)
|
||
|
|
table[zzTransform[i++]] = cosTable_x[u] * cosTable_y[v];
|
||
|
|
}
|
||
|
|
tables.push(table);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return tables;
|
||
|
|
})();
|
||
|
|
|
||
|
|
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;
|
||
|
|
zz[k] = 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;
|
||
|
|
zz[k] = receiveAndExtend(s) * (1 << successive);
|
||
|
|
k++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var successiveACState = 0, successiveACNextValue;
|
||
|
|
function decodeACSuccessive(component, zz) {
|
||
|
|
var k = spectralStart, e = spectralEnd, r = 0;
|
||
|
|
while (k <= e) {
|
||
|
|
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[k])
|
||
|
|
zz[k] += (readBit() << successive);
|
||
|
|
else {
|
||
|
|
r--;
|
||
|
|
if (r === 0)
|
||
|
|
successiveACState = successiveACState == 2 ? 3 : 0;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3: // set value for a zero item
|
||
|
|
if (zz[k])
|
||
|
|
zz[k] += (readBit() << successive);
|
||
|
|
else {
|
||
|
|
zz[k] = successiveACNextValue << successive;
|
||
|
|
successiveACState = 0;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 4: // eob
|
||
|
|
if (zz[k])
|
||
|
|
zz[k] += (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;
|
||
|
|
|
||
|
|
function quantizeAndInverse(zz) {
|
||
|
|
var qt = component.quantizationTable;
|
||
|
|
var precisionShift = frame.precision - 8;
|
||
|
|
|
||
|
|
var R = new Int32Array(64);
|
||
|
|
for (i = 0; i < 64; i++)
|
||
|
|
R[i] = zz[i] * qt[i];
|
||
|
|
|
||
|
|
var r = new Uint8Array(64), i, j;
|
||
|
|
for (i = 0; i < 64; i++) {
|
||
|
|
var sum = 0;
|
||
|
|
var table = iDCTTables[i];
|
||
|
|
for (j = 0; j < 64; j++)
|
||
|
|
sum += table[j] * R[j];
|
||
|
|
// TODO loosing precision?
|
||
|
|
var sample = 128 + ((sum / 4) >> precisionShift);
|
||
|
|
// clamping
|
||
|
|
r[i] = sample < 0 ? 0 : sample > 0xFF ? 0xFF : sample;
|
||
|
|
}
|
||
|
|
return r;
|
||
|
|
}
|
||
|
|
|
||
|
|
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++) {
|
||
|
|
var r = quantizeAndInverse(component.blocks[blockRow][blockCol]);
|
||
|
|
|
||
|
|
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++)
|
||
|
|
tableData[j] = 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 != -1)
|
||
|
|
colorTransform = this.colorTransform == true;
|
||
|
|
|
||
|
|
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 != -1)
|
||
|
|
colorTransform = this.colorTransform == true;
|
||
|
|
|
||
|
|
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) {
|
||
|
|
this.getData(imageData.data, imageData.width, imageData.height);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
return constructor;
|
||
|
|
})();
|