jpeg -> array
Version vom
Dieses Skript sollte nicht direkt installiert werden. Es handelt sich hier um eine Bibliothek für andere Skripte, welche über folgenden Befehl in den Metadaten eines Skriptes eingebunden wird // @require https://update.greasyfork.org/scripts/38665/255142/bv7_jpeg2array_b.js
// ==UserScript==
// @name bv7_jpeg2array_b
// @namespace bv7
// @version 0.5
// @description jpeg -> array
// @author bv7
// @include file:///D:/projects/JSProjects/bv7bbc/bv7_bbc_dark/bv_dev_canvas*.html
// @run-at document-idle
// @grant GM_xmlhttpRequest
// ==/UserScript==
class BaseImage {
constructor() {
this._src = null;
this.onload = (() => '');
}
load() {
GM_xmlhttpRequest({
method : 'GET',
url : this._src,
overrideMimeType: 'text/plain; charset=x-user-defined',
onload : (v) => {
let data = new Uint8Array(v.responseText.length);
data.forEach((val, i) => data[i] = v.responseText.charCodeAt(i));
this.parse(data);
//this.decode();
this.onload();
}
});
}
get src() {return this._src;}
set src(v) {
if (this._src !== v) {
this._src = v;
this.load();
}
}
drawCanvas(canvas, dx, dy, dWidth, dHeight, sx, sy, sWidth, sHeight) {
let context = canvas.getContext('2d');
let imageData = context.getImageData(0, 0, canvas.width, canvas.height);
this.copyToImageData(imageData);
//for (let x = dx; x < imageData; x++) for (let y = dy; y < dy + dHeight; y++) context.
//context.putImageData(imageData, dx, dy, sx, sy, sWidth, sHeight);
context.putImageData(imageData, 0, 0);
}
}
class JpegImage extends BaseImage {
parse(data) {
this.jfif = null;
this.adobe = null;
const 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
]);
const dctCos1 = 4017; // cos( pi/16)
const dctSin1 = 799; // sin( pi/16)
const dctCos3 = 3406; // cos(3*pi/16)
const dctSin3 = 2276; // sin(3*pi/16)
const dctCos6 = 1567; // cos(6*pi/16)
const dctSin6 = 3784; // sin(6*pi/16)
const dctSqrt2 = 5793; // sqrt(2)
const dctSqrt1d2 = 2896; // sqrt(2) / 2
let frame;
let resetInterval;
let quantizationTables = [];
let frames = [];
let huffmanTablesAC = [];
let huffmanTablesDC = [];
let offset = 0;
let readUint8 = () => data[offset++];
let readUint16 = () => ((readUint8() << 8) | readUint8());
let readDataBlock = () => {
let length = readUint16() - 2;
let value = data.slice(offset, offset + length - 2);
offset += length;
return value;
};
let buildHuffmanTable = (codeLengths, values) => {
let length = codeLengths.length;
while (length > 0 && !codeLengths[length - 1]) length--;
let p = {children: [], index: 0};
let code = [p];
for (let i = 0, k = 0, q; i < length; i++) {
for (let j = 0; j < codeLengths[i]; j++, k++) {
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;
}
}
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;
};
let buildComponentData = (component) => {
let lines = [];
let samplesPerLine = component.blocksPerLine << 3;
let R = new Int32Array(64);
let 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.
let quantizeAndInverse = (zz, dataOut, dataIn) => {
let t, v, u;
// dequant
dataIn.forEach((v, i) => dataIn[i] = zz[i] * component.quantizationTable[i]);
for (let i = 0; i < 8; ++i) {
let row = 8 * i;
v = dataIn.slice(row, 8 + row);
// check for all-zero AC coefficients
if (v.every((val, i) => (!i || !val))) dataIn.fill((dctSqrt2 * v[0] + 512) >> 10, row, 8 + row);
else {
// stage 4
u = [
(dctSqrt2 * v[0] + 128) >> 8,
(dctSqrt2 * v[4] + 128) >> 8,
v[2],
v[6],
(dctSqrt1d2 * (v[1] - v[7]) + 128) >> 8,
v[3] << 4,
v[5] << 4,
(dctSqrt1d2 * (v[1] + v[7]) + 128) >> 8
];
// stage 3
v = [
(u[0] + u[1] + 1) >> 1,
(u[0] - u[1] + 1) >> 1,
(u[2] * dctCos6 - u[3] * dctSin6 + 128) >> 8,
(u[2] * dctSin6 + u[3] * dctCos6 + 128) >> 8,
(u[4] + u[6] + 1) >> 1,
(u[7] - u[5] + 1) >> 1,
(u[4] - u[6] + 1) >> 1,
(u[7] + u[5] + 1) >> 1
];
// stage 2
u = [
(v[0] + v[3] + 1) >> 1,
(v[1] + v[2] + 1) >> 1,
(v[1] - v[2] + 1) >> 1,
(v[0] - v[3] + 1) >> 1,
(v[4] * dctCos3 - v[7] * dctSin3 + 2048) >> 12,
(v[5] * dctCos1 - v[6] * dctSin1 + 2048) >> 12,
(v[5] * dctSin1 + v[6] * dctCos1 + 2048) >> 12,
(v[4] * dctSin3 + v[7] * dctCos3 + 2048) >> 12
];
// stage 1
for(let j = 0; j < 4; j++) {
dataIn[0 + j + row] = u[j] + u[7 - j];
dataIn[7 - j + row] = u[j] - u[7 - j];
}
}
}
// inverse DCT on columns
for (let col = 0; col < 8; ++col) {
for (let i = 0; i < 8; i++) v[i] = dataIn[i * 8 + col];
// check for all-zero AC coefficients
if (v.every((val, i) => (!i || !val))) {
t = (dctSqrt2 * v[0] + 8192) >> 14;
v.forEach((val, i) => dataIn[i * 8 + col] = t);
} else {
// stage 4
u = [
(dctSqrt2 * v[0] + 2048) >> 12,
(dctSqrt2 * v[4] + 2048) >> 12,
v[2],
v[6],
(dctSqrt1d2 * (v[1] - v[7]) + 2048) >> 12,
v[3],
v[5],
(dctSqrt1d2 * (v[1] + v[7]) + 2048) >> 12
];
// stage 3
v = [
(u[0] + u[1] + 1) >> 1,
(u[0] - u[1] + 1) >> 1,
(u[2] * dctCos6 - u[3] * dctSin6 + 2048) >> 12,
(u[2] * dctSin6 + u[3] * dctCos6 + 2048) >> 12,
(u[4] + u[6] + 1) >> 1,
(u[7] - u[5] + 1) >> 1,
(u[4] - u[6] + 1) >> 1,
(u[7] + u[5] + 1) >> 1
];
// stage 2
u = [
(v[0] + v[3] + 1) >> 1,
(v[1] + v[2] + 1) >> 1,
(v[1] - v[2] + 1) >> 1,
(v[0] - v[3] + 1) >> 1,
(v[4] * dctCos3 - v[7] * dctSin3 + 2048) >> 12,
(v[5] * dctCos1 - v[6] * dctSin1 + 2048) >> 12,
(v[5] * dctSin1 + v[6] * dctCos1 + 2048) >> 12,
(v[4] * dctSin3 + v[7] * dctCos3 + 2048) >> 12
];
// stage 1
for (let i = 0; i < 4; i++) {
dataIn[(0 + i) * 8 + col] = u[i] + u[7 - i];
dataIn[(7 - i) * 8 + col] = u[i] - u[7 - i];
}
}
}
// convert to 8-bit integers
dataIn.forEach((val, i) => {
let sample = 128 + ((val + 8) >> 4);
dataOut[i] = sample < 0 ? 0 : sample > 0xFF ? 0xFF : sample;
});
};
for (let blockRow = 0; blockRow < component.blocksPerColumn; blockRow++) {
let scanLine = blockRow << 3;
for (let i = 0; i < 8; i++) lines.push(new Uint8Array(samplesPerLine));
for (let blockCol = 0; blockCol < component.blocksPerLine; blockCol++) {
quantizeAndInverse(component.blocks[blockRow][blockCol], r, R);
let sample = blockCol << 3;
for (let j = 0, offset = 0; j < 8; j++) {
let line = lines[scanLine + j];
for (let i = 0; i < 8; i++, offset++) line[sample + i] = r[offset];
}
}
}
return lines;
}
let prepareComponents = (frame) => {
frame.maxH = 0;
frame.maxV = 0;
frame.componentsOrder.forEach((v) => {
let component = frame.components[v];
if (frame.maxH < component.h) frame.maxH = component.h;
if (frame.maxV < component.v) frame.maxV = component.v;
});
frame.mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / frame.maxH);
frame.mcusPerColumn = Math.ceil(frame.scanLines / 8 / frame.maxV);
frame.componentsOrder.forEach((v) => {
let component = frame.components[v];
component.blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / frame.maxH);
component.blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / frame.maxV);
component.blocks = [];
let blocksPerLineForMcu = frame.mcusPerLine * component.h;
let blocksPerColumnForMcu = frame.mcusPerColumn * component.v;
for (let i = 0; i < blocksPerColumnForMcu; i++) {
let row = [];
for (let j = 0; j < blocksPerLineForMcu; j++) row.push(new Int32Array(64));
component.blocks.push(row);
}
});
};
let decodeScan = (components, resetInterval, spectralStart, spectralEnd, successivePrev, successive) => {
let bitsData = 0;
let bitsCount = 0;
let readBit = () => {
if (bitsCount > 0) bitsCount--;
else {
bitsData = readUint8();
if (bitsData == 0xFF) {
let nextByte = readUint8();
if (nextByte) throw new Error('Unexpected marker: ' + ((bitsData << 8) | nextByte).toString(16));
// unstuff 0
}
bitsCount = 7;
}
return (bitsData >> bitsCount) & 1;
};
let decodeHuffman = (tree) => {
let node = tree;
let bit;
while ((bit = readBit()) !== null) if (typeof (node = node[bit]) === 'number') return node;
else if (typeof node !== 'object') throw new Error('Invalid huffman sequence');
return null;
};
let receive = (length) => {
let n = 0;
for (; length > 0; length--) {
let bit = readBit();
if (bit === null) return;
n = (n << 1) | bit;
}
return n;
};
let receiveAndExtend = (length) => {
let n = receive(length);
return (n >= 1 << (length - 1)) ? n : (n + (-1 << length) + 1);
};
let decodeBaseline = (component, zz) => {
let t = decodeHuffman(component.huffmanTableDC);
let diff = t === 0 ? 0 : receiveAndExtend(t);
zz[0] = (component.pred += diff);
let k = 1;
while (k < 64) {
let rs = decodeHuffman(component.huffmanTableAC);
let s = rs & 15;
let r = rs >> 4;
if (s === 0) {
if (r < 15) break;
else {
k += 16;
continue;
}
} else {
k += r;
zz[dctZigZag[k]] = receiveAndExtend(s);
k++;
}
}
}
let decodeDCFirst = (component, zz) => {
let t = decodeHuffman(component.huffmanTableDC);
let diff = t === 0 ? 0 : (receiveAndExtend(t) << successive);
zz[0] = (component.pred += diff);
}
let decodeDCSuccessive = (component, zz) => zz[0] |= readBit() << successive;
let eobrun = 0;
let decodeACFirst = (component, zz) => {
if (eobrun > 0) eobrun--;
else {
let k = spectralStart;
while (k <= spectralEnd) {
let rs = decodeHuffman(component.huffmanTableAC);
let s = rs & 15;
let r = rs >> 4;
if (s === 0) {
if (r < 15) {
eobrun = receive(r) + (1 << r) - 1;
break;
} else k += 16;
} else {
k += r;
zz[dctZigZag[k]] = receiveAndExtend(s) * (1 << successive);
k++;
}
}
}
};
let successiveACState = 0;
let successiveACNextValue = 0;
let decodeACSuccessive = (component, zz) => {
let k = spectralStart;
let r = 0;
while(k <= spectralEnd) {
let z = dctZigZag[k];
let direction = zz[z] < 0 ? -1 : 1;
switch (successiveACState) {
case 0: // initial state
let rs = decodeHuffman(component.huffmanTableAC);
let 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 Error('Invalid ACn encoding');
else {
successiveACNextValue = receiveAndExtend(s);
successiveACState = r ? 2 : 3;
}
continue;
case 1: // skipping r zero items
case 2:
if (zz[z]) zz[z] += (readBit() << successive) * direction;
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) * direction;
else {
zz[z] = successiveACNextValue << successive;
successiveACState = 0;
}
break;
case 4: // eob
if (zz[z]) zz[z] += (readBit() << successive) * direction;
break;
}
k++;
}
if (successiveACState === 4) {
eobrun--;
if (eobrun === 0) successiveACState = 0;
}
};
let decodeMcu = (component, decode, mcu, row, col) => decode(
component,
component.blocks[((mcu / frame.mcusPerLine) | 0) * component.v + row][(mcu % frame.mcusPerLine) * component.h + col]
);
let decodeBlock = (component, decode, mcu) => decode(
component,
component.blocks[(mcu / component.blocksPerLine) | 0][mcu % component.blocksPerLine]
);
let decodeFn = frame.progressive ? (
spectralStart === 0 ? (
successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive
) : (
successivePrev === 0 ? decodeACFirst : decodeACSuccessive
)
) : decodeBaseline;
let mcu = 0;
let mcuExpected = (components.length == 1) ? (
components[0].blocksPerLine * components[0].blocksPerColumn
) : (
frame.mcusPerLine * frame.mcusPerColumn
);
if (!resetInterval) resetInterval = mcuExpected;
while (mcu < mcuExpected) {
// reset interval stuff
components.forEach((v) => v.pred = 0);
eobrun = 0;
if (components.length == 1) {
let component = components[0];
for (let n = 0; n < resetInterval; n++, mcu++) decodeBlock(component, decodeFn, mcu);
} else for (let n = 0; n < resetInterval; n++) {
for (let i = 0; i < components.length; i++) {
let component = components[i];
for (let j = 0; j < component.v; j++) for (let k = 0; k < component.h; k++) decodeMcu(component, decodeFn, mcu, j, k);
}
mcu++;
// If we've reached our expected MCU's, stop decoding
if (mcu === mcuExpected) break;
}
// find marker
bitsCount = 0;
let marker = readUint16();
if (marker < 0xFFD0 || marker > 0xFFD7) { // !RSTx
offset -= 2;
if (marker < 0xFF00) throw new Error('Marker was not found');
break;
}
}
};
let fileMarker = readUint16();
if (fileMarker != 0xFFD8) // SOI (Start of Image)
throw new Error('SOI not found');
while ((fileMarker = readUint16()) != 0xFFD9) { // EOI (End of image)
let length;
switch(fileMarker) {
case 0xFF00: break;
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)
let appData = readDataBlock();
switch(fileMarker){
case 0xFFE0:
if (
appData[0] === 0x4A &&
appData[1] === 0x46 &&
appData[2] === 0x49 &&
appData[3] === 0x46 &&
appData[4] === 0
) this.jfif = { // 'JFIF\x00'
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.slice(14, 14 + 3 * appData[12] * appData[13] + 1)
};
break;
// TODO APP1 - Exif
case 0xFFEE:
if (
appData[0] === 0x41 &&
appData[1] === 0x64 &&
appData[2] === 0x6F &&
appData[3] === 0x62 &&
appData[4] === 0x65 &&
appData[5] === 0
) this.adobe = { // 'Adobe\x00'
version : appData[6],
flags0 : (appData[7] << 8) | appData[8],
flags1 : (appData[9] << 8) | appData[10],
transformCode: appData[11]
};
break;
}
break;
case 0xFFDB: // DQT (Define Quantization Tables)
let quantizationTablesLength = readUint16();
let quantizationTablesEnd = quantizationTablesLength + offset - 2;
while (offset < quantizationTablesEnd) {
let quantizationTableSpec = readUint8();
let tableData = new Int32Array(64);
switch(quantizationTableSpec >> 4){
case 0: // 8 bit values
tableData.forEach((v, i) => tableData[dctZigZag[i]] = readUint8());
break;
case 1: //16 bit
tableData.forEach((v, i) => tableData[dctZigZag[i]] = readUint16());
break;
default:
throw new Error('DQT: invalid table spec: ' + (quantizationTableSpec >> 4));
}
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)
readUint16(); // skip data length
frame = {
extended : fileMarker === 0xFFC1,
progressive : fileMarker === 0xFFC2,
precision : readUint8(),
scanLines : readUint16(),
samplesPerLine : readUint16(),
components : {},
componentsOrder: new Uint8Array(readUint8())
};
frame.componentsOrder.forEach((v, i) => {
let componentId = readUint8();
let b = readUint8();
frame.components[frame.componentsOrder[i] = componentId] = {
h : b >> 4,
v : b & 15,
quantizationIdx: readUint8()
};
});
prepareComponents(frame);
frames.push(frame);
break;
case 0xFFC4: // DHT (Define Huffman Tables)
let huffmanLength = readUint16() - 2;
while (huffmanLength > 0) {
let huffmanTableSpec = readUint8();
let codeLengths = new Uint8Array(16);
let codeLengthSum = 0;
codeLengths.forEach((v, i) => codeLengthSum += (codeLengths[i] = readUint8()));
let huffmanValues = new Uint8Array(codeLengthSum);
huffmanValues.forEach((v, i) => huffmanValues[i] = readUint8());
huffmanLength -= 1 + codeLengths.length + huffmanValues.length;
((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
let components = [];
for (let selectorsCount = readUint8(); selectorsCount > 0; selectorsCount--) {
let component = frame.components[readUint8()];
let tableSpec = readUint8();
component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];
component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];
components.push(component);
}
let spectralStart = readUint8();
let spectralEnd = readUint8();
let successiveApproximation = readUint8();
decodeScan(
components,
resetInterval,
spectralStart,
spectralEnd,
successiveApproximation >> 4,
successiveApproximation & 15
);
break;
case 0xFFFF: // Fill bytes
if (data[offset] !== 0xFF) offset--; // Avoid skipping a valid marker.
break;
default:
// could be incorrect encoding -- last 0xFF byte of the previous
// block was eaten by the encoder
if (data[offset - 3] == data[offset - 2] && data[offset - 2] >= 0xC0 && d1 <= 0xFE) {
offset -= 3;
break;
}
else throw new Error('Unknown JPEG marker ' + fileMarker.toString(16));
}
}
if (frames.length != 1) throw new Error("Only single frame JPEGs supported");
// set each frame's components quantization table
frames.forEach((v) => {
for (var j in v.components) {
v.components[j].quantizationTable = quantizationTables[v.components[j].quantizationIdx];
delete v.components[j].quantizationIdx;
}
});
this.width = frame.samplesPerLine;
this.height = frame.scanLines;
this.components = [];
frame.componentsOrder.forEach((v) => {
let component = frame.components[v];
this.components.push({
lines : buildComponentData(component),
scaleX: component.h / frame.maxH,
scaleY: component.v / frame.maxV
});
});
}
clampTo8bit(a) {
return a < 0 ? 0 : a > 255 ? 255 : a;
}
getData(width, height) {
let scaleX = this.width / width ;
let scaleY = this.height / height;
let data = new Uint8Array(width * height * this.components.length);
let offset = 0;
if (this.components.length > 0 && this.components.length < 5) {
let components4 = this.components.length == 4;
// PDF might compress two component data in custom colorspace
if (components4 && !this.adobe) throw new Error('Unsupported color mode (4 components)');
else {
// The default transform for three components is true
// The adobe transform marker overrides any previous setting
let colorTransform = this.components.length > 2 && (
(this.adobe && this.adobe.transformCode) ||
(typeof this.colorTransform === 'undefined') ||
!!this.colorTransform
);
let componentLines = [];
let d = new Uint8Array(this.components.length);
for (let y = 0; y < height; y++) {
this.components.forEach((v, i) => (componentLines[i] = v.lines[0 | (y * v.scaleY * scaleY)]));
for (let x = 0; x < width; x++) {
componentLines.forEach((v, i) => (d[i] = v[0 | (x * this.components[i].scaleX * scaleX)])); // Y
if (colorTransform) {
data[offset++] = this.clampTo8bit(d[0] + 1.402 * (d[2] - 128));
data[offset++] = this.clampTo8bit(d[0] - 0.3441363 * (d[1] - 128) - 0.71413636 * (d[2] - 128));
data[offset++] = this.clampTo8bit(d[0] + 1.772 * (d[1] - 128));
if (components4) data[offset++] = 255 - d[0];
} else if (components4) d.forEach((v) => data[offset++] = 255 - v);
else d.forEach((v) => data[offset++] = v);
}
}
}
} else throw new Error('Unsupported color mode');
return data;
}
copyToImageData(imageData) {
let data = this.getData(imageData.width, imageData.height);
let i = 0;
let j = 0;
switch (this.components.length) {
case 1:
for (let y = 0; y < imageData.height; y++) for (let x = 0; x < imageData.width; x++) {
imageData.data[j++] = imageData.data[j++] = imageData.data[j++] = data[i++]; // Y
imageData.data[j++] = 255;
}
break;
case 3:
for (let y = 0; y < imageData.height; y++) for (let x = 0; x < imageData.width; x++) {
imageData.data[j++] = data[i++]; // R
imageData.data[j++] = data[i++]; // G
imageData.data[j++] = data[i++]; // B
imageData.data[j++] = 255;
}
break;
case 4:
for (let y = 0; y < imageData.height; y++) for (let x = 0; x < imageData.width; x++) {
let C = data[i++];
let M = data[i++];
let Y = data[i++];
let K = data[i++];
imageData.data[j++] = 255 - this.clampTo8bit(C * (1 - K / 255) + K); // R
imageData.data[j++] = 255 - this.clampTo8bit(M * (1 - K / 255) + K); // G
imageData.data[j++] = 255 - this.clampTo8bit(Y * (1 - K / 255) + K); // B
imageData.data[j++] = 255;
}
break;
default:
throw new Error('Unsupported color mode');
}
}
}
let jpeg = new JpegImage();
jpeg.onload = function() {
this.drawCanvas(document.getElementById('canvas'), 10, 10, 20, 20, 50, 50);
console.log('jpeg =', this);
};
jpeg.src = document.getElementById('img1').src;