height

[11000] Fix | Delete

}) {

[11001] Fix | Delete

let i = 0;

[11002] Fix | Delete

const len32 = src.length >> 2;

[11003] Fix | Delete

const src32 = new Uint32Array(src.buffer, srcPos, len32);

[11004] Fix | Delete

if (FeatureTest.isLittleEndian) {

[11005] Fix | Delete

for (; i < len32 - 2; i += 3, destPos += 4) {

[11006] Fix | Delete

const s1 = src32[i];

[11007] Fix | Delete

const s2 = src32[i + 1];

[11008] Fix | Delete

const s3 = src32[i + 2];

[11009] Fix | Delete

dest[destPos] = s1 | 0xff000000;

[11010] Fix | Delete

dest[destPos + 1] = s1 >>> 24 | s2 << 8 | 0xff000000;

[11011] Fix | Delete

dest[destPos + 2] = s2 >>> 16 | s3 << 16 | 0xff000000;

[11012] Fix | Delete

dest[destPos + 3] = s3 >>> 8 | 0xff000000;

[11013] Fix | Delete

}

[11014] Fix | Delete

for (let j = i * 4, jj = src.length; j < jj; j += 3) {

[11015] Fix | Delete

dest[destPos++] = src[j] | src[j + 1] << 8 | src[j + 2] << 16 | 0xff000000;

[11016] Fix | Delete

}

[11017] Fix | Delete

} else {

[11018] Fix | Delete

for (; i < len32 - 2; i += 3, destPos += 4) {

[11019] Fix | Delete

const s1 = src32[i];

[11020] Fix | Delete

const s2 = src32[i + 1];

[11021] Fix | Delete

const s3 = src32[i + 2];

[11022] Fix | Delete

dest[destPos] = s1 | 0xff;

[11023] Fix | Delete

dest[destPos + 1] = s1 << 24 | s2 >>> 8 | 0xff;

[11024] Fix | Delete

dest[destPos + 2] = s2 << 16 | s3 >>> 16 | 0xff;

[11025] Fix | Delete

dest[destPos + 3] = s3 << 8 | 0xff;

[11026] Fix | Delete

}

[11027] Fix | Delete

for (let j = i * 4, jj = src.length; j < jj; j += 3) {

[11028] Fix | Delete

dest[destPos++] = src[j] << 24 | src[j + 1] << 16 | src[j + 2] << 8 | 0xff;

[11029] Fix | Delete

}

[11030] Fix | Delete

}

[11031] Fix | Delete

return {

[11032] Fix | Delete

srcPos,

[11033] Fix | Delete

destPos

[11034] Fix | Delete

};

[11035] Fix | Delete

}

[11036] Fix | Delete

function grayToRGBA(src, dest) {

[11037] Fix | Delete

if (FeatureTest.isLittleEndian) {

[11038] Fix | Delete

for (let i = 0, ii = src.length; i < ii; i++) {

[11039] Fix | Delete

dest[i] = src[i] * 0x10101 | 0xff000000;

[11040] Fix | Delete

}

[11041] Fix | Delete

} else {

[11042] Fix | Delete

for (let i = 0, ii = src.length; i < ii; i++) {

[11043] Fix | Delete

dest[i] = src[i] * 0x1010100 | 0x000000ff;

[11044] Fix | Delete

}

[11045] Fix | Delete

}

[11046] Fix | Delete

}

[11047] Fix | Delete

[11048] Fix | Delete

;// CONCATENATED MODULE: ./src/core/jpg.js

[11049] Fix | Delete

[11050] Fix | Delete

[11051] Fix | Delete

[11052] Fix | Delete

[11053] Fix | Delete

[11054] Fix | Delete

[11055] Fix | Delete

[11056] Fix | Delete

[11057] Fix | Delete

[11058] Fix | Delete

[11059] Fix | Delete

class JpegError extends BaseException {

[11060] Fix | Delete

constructor(msg) {

[11061] Fix | Delete

super(msg, "JpegError");

[11062] Fix | Delete

}

[11063] Fix | Delete

}

[11064] Fix | Delete

class DNLMarkerError extends BaseException {

[11065] Fix | Delete

constructor(message, scanLines) {

[11066] Fix | Delete

super(message, "DNLMarkerError");

[11067] Fix | Delete

this.scanLines = scanLines;

[11068] Fix | Delete

}

[11069] Fix | Delete

}

[11070] Fix | Delete

class EOIMarkerError extends BaseException {

[11071] Fix | Delete

constructor(msg) {

[11072] Fix | Delete

super(msg, "EOIMarkerError");

[11073] Fix | Delete

}

[11074] Fix | Delete

}

[11075] Fix | Delete

const 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]);

[11076] Fix | Delete

const dctCos1 = 4017;

[11077] Fix | Delete

const dctSin1 = 799;

[11078] Fix | Delete

const dctCos3 = 3406;

[11079] Fix | Delete

const dctSin3 = 2276;

[11080] Fix | Delete

const dctCos6 = 1567;

[11081] Fix | Delete

const dctSin6 = 3784;

[11082] Fix | Delete

const dctSqrt2 = 5793;

[11083] Fix | Delete

const dctSqrt1d2 = 2896;

[11084] Fix | Delete

function buildHuffmanTable(codeLengths, values) {

[11085] Fix | Delete

let k = 0,

[11086] Fix | Delete

i,

[11087] Fix | Delete

j,

[11088] Fix | Delete

length = 16;

[11089] Fix | Delete

while (length > 0 && !codeLengths[length - 1]) {

[11090] Fix | Delete

length--;

[11091] Fix | Delete

}

[11092] Fix | Delete

const code = [{

[11093] Fix | Delete

children: [],

[11094] Fix | Delete

index: 0

[11095] Fix | Delete

}];

[11096] Fix | Delete

let p = code[0],

[11097] Fix | Delete

q;

[11098] Fix | Delete

for (i = 0; i < length; i++) {

[11099] Fix | Delete

for (j = 0; j < codeLengths[i]; j++) {

[11100] Fix | Delete

p = code.pop();

[11101] Fix | Delete

p.children[p.index] = values[k];

[11102] Fix | Delete

while (p.index > 0) {

[11103] Fix | Delete

p = code.pop();

[11104] Fix | Delete

}

[11105] Fix | Delete

p.index++;

[11106] Fix | Delete

code.push(p);

[11107] Fix | Delete

while (code.length <= i) {

[11108] Fix | Delete

code.push(q = {

[11109] Fix | Delete

children: [],

[11110] Fix | Delete

index: 0

[11111] Fix | Delete

});

[11112] Fix | Delete

p.children[p.index] = q.children;

[11113] Fix | Delete

p = q;

[11114] Fix | Delete

}

[11115] Fix | Delete

k++;

[11116] Fix | Delete

}

[11117] Fix | Delete

if (i + 1 < length) {

[11118] Fix | Delete

code.push(q = {

[11119] Fix | Delete

children: [],

[11120] Fix | Delete

index: 0

[11121] Fix | Delete

});

[11122] Fix | Delete

p.children[p.index] = q.children;

[11123] Fix | Delete

p = q;

[11124] Fix | Delete

}

[11125] Fix | Delete

}

[11126] Fix | Delete

return code[0].children;

[11127] Fix | Delete

}

[11128] Fix | Delete

function getBlockBufferOffset(component, row, col) {

[11129] Fix | Delete

return 64 * ((component.blocksPerLine + 1) * row + col);

[11130] Fix | Delete

}

[11131] Fix | Delete

function decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive, parseDNLMarker = false) {

[11132] Fix | Delete

const mcusPerLine = frame.mcusPerLine;

[11133] Fix | Delete

const progressive = frame.progressive;

[11134] Fix | Delete

const startOffset = offset;

[11135] Fix | Delete

let bitsData = 0,

[11136] Fix | Delete

bitsCount = 0;

[11137] Fix | Delete

function readBit() {

[11138] Fix | Delete

if (bitsCount > 0) {

[11139] Fix | Delete

bitsCount--;

[11140] Fix | Delete

return bitsData >> bitsCount & 1;

[11141] Fix | Delete

}

[11142] Fix | Delete

bitsData = data[offset++];

[11143] Fix | Delete

if (bitsData === 0xff) {

[11144] Fix | Delete

const nextByte = data[offset++];

[11145] Fix | Delete

if (nextByte) {

[11146] Fix | Delete

if (nextByte === 0xdc && parseDNLMarker) {

[11147] Fix | Delete

offset += 2;

[11148] Fix | Delete

const scanLines = readUint16(data, offset);

[11149] Fix | Delete

offset += 2;

[11150] Fix | Delete

if (scanLines > 0 && scanLines !== frame.scanLines) {

[11151] Fix | Delete

throw new DNLMarkerError("Found DNL marker (0xFFDC) while parsing scan data", scanLines);

[11152] Fix | Delete

}

[11153] Fix | Delete

} else if (nextByte === 0xd9) {

[11154] Fix | Delete

if (parseDNLMarker) {

[11155] Fix | Delete

const maybeScanLines = blockRow * (frame.precision === 8 ? 8 : 0);

[11156] Fix | Delete

if (maybeScanLines > 0 && Math.round(frame.scanLines / maybeScanLines) >= 5) {

[11157] Fix | Delete

throw new DNLMarkerError("Found EOI marker (0xFFD9) while parsing scan data, " + "possibly caused by incorrect `scanLines` parameter", maybeScanLines);

[11158] Fix | Delete

}

[11159] Fix | Delete

}

[11160] Fix | Delete

throw new EOIMarkerError("Found EOI marker (0xFFD9) while parsing scan data");

[11161] Fix | Delete

}

[11162] Fix | Delete

throw new JpegError(`unexpected marker ${(bitsData << 8 | nextByte).toString(16)}`);

[11163] Fix | Delete

}

[11164] Fix | Delete

}

[11165] Fix | Delete

bitsCount = 7;

[11166] Fix | Delete

return bitsData >>> 7;

[11167] Fix | Delete

}

[11168] Fix | Delete

function decodeHuffman(tree) {

[11169] Fix | Delete

let node = tree;

[11170] Fix | Delete

while (true) {

[11171] Fix | Delete

node = node[readBit()];

[11172] Fix | Delete

switch (typeof node) {

[11173] Fix | Delete

case "number":

[11174] Fix | Delete

return node;

[11175] Fix | Delete

case "object":

[11176] Fix | Delete

continue;

[11177] Fix | Delete

}

[11178] Fix | Delete

throw new JpegError("invalid huffman sequence");

[11179] Fix | Delete

}

[11180] Fix | Delete

}

[11181] Fix | Delete

function receive(length) {

[11182] Fix | Delete

let n = 0;

[11183] Fix | Delete

while (length > 0) {

[11184] Fix | Delete

n = n << 1 | readBit();

[11185] Fix | Delete

length--;

[11186] Fix | Delete

}

[11187] Fix | Delete

return n;

[11188] Fix | Delete

}

[11189] Fix | Delete

function receiveAndExtend(length) {

[11190] Fix | Delete

if (length === 1) {

[11191] Fix | Delete

return readBit() === 1 ? 1 : -1;

[11192] Fix | Delete

}

[11193] Fix | Delete

const n = receive(length);

[11194] Fix | Delete

if (n >= 1 << length - 1) {

[11195] Fix | Delete

return n;

[11196] Fix | Delete

}

[11197] Fix | Delete

return n + (-1 << length) + 1;

[11198] Fix | Delete

}

[11199] Fix | Delete

function decodeBaseline(component, blockOffset) {

[11200] Fix | Delete

const t = decodeHuffman(component.huffmanTableDC);

[11201] Fix | Delete

const diff = t === 0 ? 0 : receiveAndExtend(t);

[11202] Fix | Delete

component.blockData[blockOffset] = component.pred += diff;

[11203] Fix | Delete

let k = 1;

[11204] Fix | Delete

while (k < 64) {

[11205] Fix | Delete

const rs = decodeHuffman(component.huffmanTableAC);

[11206] Fix | Delete

const s = rs & 15,

[11207] Fix | Delete

r = rs >> 4;

[11208] Fix | Delete

if (s === 0) {

[11209] Fix | Delete

if (r < 15) {

[11210] Fix | Delete

break;

[11211] Fix | Delete

}

[11212] Fix | Delete

k += 16;

[11213] Fix | Delete

continue;

[11214] Fix | Delete

}

[11215] Fix | Delete

k += r;

[11216] Fix | Delete

const z = dctZigZag[k];

[11217] Fix | Delete

component.blockData[blockOffset + z] = receiveAndExtend(s);

[11218] Fix | Delete

k++;

[11219] Fix | Delete

}

[11220] Fix | Delete

}

[11221] Fix | Delete

function decodeDCFirst(component, blockOffset) {

[11222] Fix | Delete

const t = decodeHuffman(component.huffmanTableDC);

[11223] Fix | Delete

const diff = t === 0 ? 0 : receiveAndExtend(t) << successive;

[11224] Fix | Delete

component.blockData[blockOffset] = component.pred += diff;

[11225] Fix | Delete

}

[11226] Fix | Delete

function decodeDCSuccessive(component, blockOffset) {

[11227] Fix | Delete

component.blockData[blockOffset] |= readBit() << successive;

[11228] Fix | Delete

}

[11229] Fix | Delete

let eobrun = 0;

[11230] Fix | Delete

function decodeACFirst(component, blockOffset) {

[11231] Fix | Delete

if (eobrun > 0) {

[11232] Fix | Delete

eobrun--;

[11233] Fix | Delete

return;

[11234] Fix | Delete

}

[11235] Fix | Delete

let k = spectralStart;

[11236] Fix | Delete

const e = spectralEnd;

[11237] Fix | Delete

while (k <= e) {

[11238] Fix | Delete

const rs = decodeHuffman(component.huffmanTableAC);

[11239] Fix | Delete

const s = rs & 15,

[11240] Fix | Delete

r = rs >> 4;

[11241] Fix | Delete

if (s === 0) {

[11242] Fix | Delete

if (r < 15) {

[11243] Fix | Delete

eobrun = receive(r) + (1 << r) - 1;

[11244] Fix | Delete

break;

[11245] Fix | Delete

}

[11246] Fix | Delete

k += 16;

[11247] Fix | Delete

continue;

[11248] Fix | Delete

}

[11249] Fix | Delete

k += r;

[11250] Fix | Delete

const z = dctZigZag[k];

[11251] Fix | Delete

component.blockData[blockOffset + z] = receiveAndExtend(s) * (1 << successive);

[11252] Fix | Delete

k++;

[11253] Fix | Delete

}

[11254] Fix | Delete

}

[11255] Fix | Delete

let successiveACState = 0,

[11256] Fix | Delete

successiveACNextValue;

[11257] Fix | Delete

function decodeACSuccessive(component, blockOffset) {

[11258] Fix | Delete

let k = spectralStart;

[11259] Fix | Delete

const e = spectralEnd;

[11260] Fix | Delete

let r = 0;

[11261] Fix | Delete

let s;

[11262] Fix | Delete

let rs;

[11263] Fix | Delete

while (k <= e) {

[11264] Fix | Delete

const offsetZ = blockOffset + dctZigZag[k];

[11265] Fix | Delete

const sign = component.blockData[offsetZ] < 0 ? -1 : 1;

[11266] Fix | Delete

switch (successiveACState) {

[11267] Fix | Delete

case 0:

[11268] Fix | Delete

rs = decodeHuffman(component.huffmanTableAC);

[11269] Fix | Delete

s = rs & 15;

[11270] Fix | Delete

r = rs >> 4;

[11271] Fix | Delete

if (s === 0) {

[11272] Fix | Delete

if (r < 15) {

[11273] Fix | Delete

eobrun = receive(r) + (1 << r);

[11274] Fix | Delete

successiveACState = 4;

[11275] Fix | Delete

} else {

[11276] Fix | Delete

r = 16;

[11277] Fix | Delete

successiveACState = 1;

[11278] Fix | Delete

}

[11279] Fix | Delete

} else {

[11280] Fix | Delete

if (s !== 1) {

[11281] Fix | Delete

throw new JpegError("invalid ACn encoding");

[11282] Fix | Delete

}

[11283] Fix | Delete

successiveACNextValue = receiveAndExtend(s);

[11284] Fix | Delete

successiveACState = r ? 2 : 3;

[11285] Fix | Delete

}

[11286] Fix | Delete

continue;

[11287] Fix | Delete

case 1:

[11288] Fix | Delete

case 2:

[11289] Fix | Delete

if (component.blockData[offsetZ]) {

[11290] Fix | Delete

component.blockData[offsetZ] += sign * (readBit() << successive);

[11291] Fix | Delete

} else {

[11292] Fix | Delete

r--;

[11293] Fix | Delete

if (r === 0) {

[11294] Fix | Delete

successiveACState = successiveACState === 2 ? 3 : 0;

[11295] Fix | Delete

}

[11296] Fix | Delete

}

[11297] Fix | Delete

break;

[11298] Fix | Delete

case 3:

[11299] Fix | Delete

if (component.blockData[offsetZ]) {

[11300] Fix | Delete

component.blockData[offsetZ] += sign * (readBit() << successive);

[11301] Fix | Delete

} else {

[11302] Fix | Delete

component.blockData[offsetZ] = successiveACNextValue << successive;

[11303] Fix | Delete

successiveACState = 0;

[11304] Fix | Delete

}

[11305] Fix | Delete

break;

[11306] Fix | Delete

case 4:

[11307] Fix | Delete

if (component.blockData[offsetZ]) {

[11308] Fix | Delete

component.blockData[offsetZ] += sign * (readBit() << successive);

[11309] Fix | Delete

}

[11310] Fix | Delete

break;

[11311] Fix | Delete

}

[11312] Fix | Delete

k++;

[11313] Fix | Delete

}

[11314] Fix | Delete

if (successiveACState === 4) {

[11315] Fix | Delete

eobrun--;

[11316] Fix | Delete

if (eobrun === 0) {

[11317] Fix | Delete

successiveACState = 0;

[11318] Fix | Delete

}

[11319] Fix | Delete

}

[11320] Fix | Delete

}

[11321] Fix | Delete

let blockRow = 0;

[11322] Fix | Delete

function decodeMcu(component, decode, mcu, row, col) {

[11323] Fix | Delete

const mcuRow = mcu / mcusPerLine | 0;

[11324] Fix | Delete

const mcuCol = mcu % mcusPerLine;

[11325] Fix | Delete

blockRow = mcuRow * component.v + row;

[11326] Fix | Delete

const blockCol = mcuCol * component.h + col;

[11327] Fix | Delete

const blockOffset = getBlockBufferOffset(component, blockRow, blockCol);

[11328] Fix | Delete

decode(component, blockOffset);

[11329] Fix | Delete

}

[11330] Fix | Delete

function decodeBlock(component, decode, mcu) {

[11331] Fix | Delete

blockRow = mcu / component.blocksPerLine | 0;

[11332] Fix | Delete

const blockCol = mcu % component.blocksPerLine;

[11333] Fix | Delete

const blockOffset = getBlockBufferOffset(component, blockRow, blockCol);

[11334] Fix | Delete

decode(component, blockOffset);

[11335] Fix | Delete

}

[11336] Fix | Delete

const componentsLength = components.length;

[11337] Fix | Delete

let component, i, j, k, n;

[11338] Fix | Delete

let decodeFn;

[11339] Fix | Delete

if (progressive) {

[11340] Fix | Delete

if (spectralStart === 0) {

[11341] Fix | Delete

decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;

[11342] Fix | Delete

} else {

[11343] Fix | Delete

decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;

[11344] Fix | Delete

}

[11345] Fix | Delete

} else {

[11346] Fix | Delete

decodeFn = decodeBaseline;

[11347] Fix | Delete

}

[11348] Fix | Delete

let mcu = 0,

[11349] Fix | Delete

fileMarker;

[11350] Fix | Delete

const mcuExpected = componentsLength === 1 ? components[0].blocksPerLine * components[0].blocksPerColumn : mcusPerLine * frame.mcusPerColumn;

[11351] Fix | Delete

let h, v;

[11352] Fix | Delete

while (mcu <= mcuExpected) {

[11353] Fix | Delete

const mcuToRead = resetInterval ? Math.min(mcuExpected - mcu, resetInterval) : mcuExpected;

[11354] Fix | Delete

if (mcuToRead > 0) {

[11355] Fix | Delete

for (i = 0; i < componentsLength; i++) {

[11356] Fix | Delete

components[i].pred = 0;

[11357] Fix | Delete

}

[11358] Fix | Delete

eobrun = 0;

[11359] Fix | Delete

if (componentsLength === 1) {

[11360] Fix | Delete

component = components[0];

[11361] Fix | Delete

for (n = 0; n < mcuToRead; n++) {

[11362] Fix | Delete

decodeBlock(component, decodeFn, mcu);

[11363] Fix | Delete

mcu++;

[11364] Fix | Delete

}

[11365] Fix | Delete

} else {

[11366] Fix | Delete

for (n = 0; n < mcuToRead; n++) {

[11367] Fix | Delete

for (i = 0; i < componentsLength; i++) {

[11368] Fix | Delete

component = components[i];

[11369] Fix | Delete

h = component.h;

[11370] Fix | Delete

v = component.v;

[11371] Fix | Delete

for (j = 0; j < v; j++) {

[11372] Fix | Delete

for (k = 0; k < h; k++) {

[11373] Fix | Delete

decodeMcu(component, decodeFn, mcu, j, k);

[11374] Fix | Delete

}

[11375] Fix | Delete

}

[11376] Fix | Delete

}

[11377] Fix | Delete

mcu++;

[11378] Fix | Delete

}

[11379] Fix | Delete

}

[11380] Fix | Delete

}

[11381] Fix | Delete

bitsCount = 0;

[11382] Fix | Delete

fileMarker = findNextFileMarker(data, offset);

[11383] Fix | Delete

if (!fileMarker) {

[11384] Fix | Delete

break;

[11385] Fix | Delete

}

[11386] Fix | Delete

if (fileMarker.invalid) {

[11387] Fix | Delete

const partialMsg = mcuToRead > 0 ? "unexpected" : "excessive";

[11388] Fix | Delete

warn(`decodeScan - ${partialMsg} MCU data, current marker is: ${fileMarker.invalid}`);

[11389] Fix | Delete

offset = fileMarker.offset;

[11390] Fix | Delete

}

[11391] Fix | Delete

if (fileMarker.marker >= 0xffd0 && fileMarker.marker <= 0xffd7) {

[11392] Fix | Delete

offset += 2;

[11393] Fix | Delete

} else {

[11394] Fix | Delete

break;

[11395] Fix | Delete

}

[11396] Fix | Delete

}

[11397] Fix | Delete

return offset - startOffset;

[11398] Fix | Delete

}

[11399] Fix | Delete

function quantizeAndInverse(component, blockBufferOffset, p) {

[11400] Fix | Delete

const qt = component.quantizationTable,

[11401] Fix | Delete

blockData = component.blockData;

[11402] Fix | Delete

let v0, v1, v2, v3, v4, v5, v6, v7;

[11403] Fix | Delete

let p0, p1, p2, p3, p4, p5, p6, p7;

[11404] Fix | Delete

let t;

[11405] Fix | Delete

if (!qt) {

[11406] Fix | Delete

throw new JpegError("missing required Quantization Table.");

[11407] Fix | Delete

}

[11408] Fix | Delete

for (let row = 0; row < 64; row += 8) {

[11409] Fix | Delete

p0 = blockData[blockBufferOffset + row];

[11410] Fix | Delete

p1 = blockData[blockBufferOffset + row + 1];

[11411] Fix | Delete

p2 = blockData[blockBufferOffset + row + 2];

[11412] Fix | Delete

p3 = blockData[blockBufferOffset + row + 3];

[11413] Fix | Delete

p4 = blockData[blockBufferOffset + row + 4];

[11414] Fix | Delete

p5 = blockData[blockBufferOffset + row + 5];

[11415] Fix | Delete

p6 = blockData[blockBufferOffset + row + 6];

[11416] Fix | Delete

p7 = blockData[blockBufferOffset + row + 7];

[11417] Fix | Delete

p0 *= qt[row];

[11418] Fix | Delete

if ((p1 | p2 | p3 | p4 | p5 | p6 | p7) === 0) {

[11419] Fix | Delete

t = dctSqrt2 * p0 + 512 >> 10;

[11420] Fix | Delete

p[row] = t;

[11421] Fix | Delete

p[row + 1] = t;

[11422] Fix | Delete

p[row + 2] = t;

[11423] Fix | Delete

p[row + 3] = t;

[11424] Fix | Delete

p[row + 4] = t;

[11425] Fix | Delete

p[row + 5] = t;

[11426] Fix | Delete

p[row + 6] = t;

[11427] Fix | Delete

p[row + 7] = t;

[11428] Fix | Delete

continue;

[11429] Fix | Delete

}

[11430] Fix | Delete

p1 *= qt[row + 1];

[11431] Fix | Delete

p2 *= qt[row + 2];

[11432] Fix | Delete

p3 *= qt[row + 3];

[11433] Fix | Delete

p4 *= qt[row + 4];

[11434] Fix | Delete

p5 *= qt[row + 5];

[11435] Fix | Delete

p6 *= qt[row + 6];

[11436] Fix | Delete

p7 *= qt[row + 7];

[11437] Fix | Delete

v0 = dctSqrt2 * p0 + 128 >> 8;

[11438] Fix | Delete

v1 = dctSqrt2 * p4 + 128 >> 8;

[11439] Fix | Delete

v2 = p2;

[11440] Fix | Delete

v3 = p6;

[11441] Fix | Delete

v4 = dctSqrt1d2 * (p1 - p7) + 128 >> 8;

[11442] Fix | Delete

v7 = dctSqrt1d2 * (p1 + p7) + 128 >> 8;

[11443] Fix | Delete

v5 = p3 << 4;

[11444] Fix | Delete

v6 = p5 << 4;

[11445] Fix | Delete

v0 = v0 + v1 + 1 >> 1;

[11446] Fix | Delete

v1 = v0 - v1;

[11447] Fix | Delete

t = v2 * dctSin6 + v3 * dctCos6 + 128 >> 8;

[11448] Fix | Delete

v2 = v2 * dctCos6 - v3 * dctSin6 + 128 >> 8;

[11449] Fix | Delete

v3 = t;

[11450] Fix | Delete

v4 = v4 + v6 + 1 >> 1;

[11451] Fix | Delete

v6 = v4 - v6;

[11452] Fix | Delete

v7 = v7 + v5 + 1 >> 1;

[11453] Fix | Delete

v5 = v7 - v5;

[11454] Fix | Delete

v0 = v0 + v3 + 1 >> 1;

[11455] Fix | Delete

v3 = v0 - v3;

[11456] Fix | Delete

v1 = v1 + v2 + 1 >> 1;

[11457] Fix | Delete

v2 = v1 - v2;

[11458] Fix | Delete

t = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12;

[11459] Fix | Delete

v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12;

[11460] Fix | Delete

v7 = t;

[11461] Fix | Delete

t = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12;

[11462] Fix | Delete

v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12;

[11463] Fix | Delete

v6 = t;

[11464] Fix | Delete

p[row] = v0 + v7;

[11465] Fix | Delete

p[row + 7] = v0 - v7;

[11466] Fix | Delete

p[row + 1] = v1 + v6;

[11467] Fix | Delete

p[row + 6] = v1 - v6;

[11468] Fix | Delete

p[row + 2] = v2 + v5;

[11469] Fix | Delete

p[row + 5] = v2 - v5;

[11470] Fix | Delete

p[row + 3] = v3 + v4;

[11471] Fix | Delete

p[row + 4] = v3 - v4;

[11472] Fix | Delete

}

[11473] Fix | Delete

for (let col = 0; col < 8; ++col) {

[11474] Fix | Delete

p0 = p[col];

[11475] Fix | Delete

p1 = p[col + 8];

[11476] Fix | Delete

p2 = p[col + 16];

[11477] Fix | Delete

p3 = p[col + 24];

[11478] Fix | Delete

p4 = p[col + 32];

[11479] Fix | Delete

p5 = p[col + 40];

[11480] Fix | Delete

p6 = p[col + 48];

[11481] Fix | Delete

p7 = p[col + 56];

[11482] Fix | Delete

if ((p1 | p2 | p3 | p4 | p5 | p6 | p7) === 0) {

[11483] Fix | Delete

t = dctSqrt2 * p0 + 8192 >> 14;

[11484] Fix | Delete

if (t < -2040) {

[11485] Fix | Delete

t = 0;

[11486] Fix | Delete

} else if (t >= 2024) {

[11487] Fix | Delete

t = 255;

[11488] Fix | Delete

} else {

[11489] Fix | Delete

t = t + 2056 >> 4;

[11490] Fix | Delete

}

[11491] Fix | Delete

blockData[blockBufferOffset + col] = t;

[11492] Fix | Delete

blockData[blockBufferOffset + col + 8] = t;

[11493] Fix | Delete

blockData[blockBufferOffset + col + 16] = t;

[11494] Fix | Delete

blockData[blockBufferOffset + col + 24] = t;

[11495] Fix | Delete

blockData[blockBufferOffset + col + 32] = t;

[11496] Fix | Delete

blockData[blockBufferOffset + col + 40] = t;

[11497] Fix | Delete

blockData[blockBufferOffset + col + 48] = t;

[11498] Fix | Delete

blockData[blockBufferOffset + col + 56] = t;

[11499] Fix | Delete