e82ad79eb9
This method/function was added only for the `gulp image_decoders`-builds, and is completely unused elsewhere (e.g. in the Firefox PDF Viewer). While this only reduces the size of the *built* `pdf.worker.js` file by a little over 1 kB, it can't hurt to remove completely unused code from the "normal" builds.
2576 lines
69 KiB
JavaScript
2576 lines
69 KiB
JavaScript
/* Copyright 2012 Mozilla Foundation
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
import { BaseException, shadow } from "../shared/util.js";
|
|
import { log2, readInt8, readUint16, readUint32 } from "./core_utils.js";
|
|
import { ArithmeticDecoder } from "./arithmetic_decoder.js";
|
|
import { CCITTFaxDecoder } from "./ccitt.js";
|
|
|
|
class Jbig2Error extends BaseException {
|
|
constructor(msg) {
|
|
super(`JBIG2 error: ${msg}`, "Jbig2Error");
|
|
}
|
|
}
|
|
|
|
// Utility data structures
|
|
class ContextCache {
|
|
getContexts(id) {
|
|
if (id in this) {
|
|
return this[id];
|
|
}
|
|
return (this[id] = new Int8Array(1 << 16));
|
|
}
|
|
}
|
|
|
|
class DecodingContext {
|
|
constructor(data, start, end) {
|
|
this.data = data;
|
|
this.start = start;
|
|
this.end = end;
|
|
}
|
|
|
|
get decoder() {
|
|
const decoder = new ArithmeticDecoder(this.data, this.start, this.end);
|
|
return shadow(this, "decoder", decoder);
|
|
}
|
|
|
|
get contextCache() {
|
|
const cache = new ContextCache();
|
|
return shadow(this, "contextCache", cache);
|
|
}
|
|
}
|
|
|
|
// Annex A. Arithmetic Integer Decoding Procedure
|
|
// A.2 Procedure for decoding values
|
|
function decodeInteger(contextCache, procedure, decoder) {
|
|
const contexts = contextCache.getContexts(procedure);
|
|
let prev = 1;
|
|
|
|
function readBits(length) {
|
|
let v = 0;
|
|
for (let i = 0; i < length; i++) {
|
|
const bit = decoder.readBit(contexts, prev);
|
|
prev = prev < 256 ? (prev << 1) | bit : (((prev << 1) | bit) & 511) | 256;
|
|
v = (v << 1) | bit;
|
|
}
|
|
return v >>> 0;
|
|
}
|
|
|
|
const sign = readBits(1);
|
|
// prettier-ignore
|
|
/* eslint-disable no-nested-ternary */
|
|
const value = readBits(1) ?
|
|
(readBits(1) ?
|
|
(readBits(1) ?
|
|
(readBits(1) ?
|
|
(readBits(1) ?
|
|
(readBits(32) + 4436) :
|
|
readBits(12) + 340) :
|
|
readBits(8) + 84) :
|
|
readBits(6) + 20) :
|
|
readBits(4) + 4) :
|
|
readBits(2);
|
|
/* eslint-enable no-nested-ternary */
|
|
if (sign === 0) {
|
|
return value;
|
|
} else if (value > 0) {
|
|
return -value;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// A.3 The IAID decoding procedure
|
|
function decodeIAID(contextCache, decoder, codeLength) {
|
|
const contexts = contextCache.getContexts("IAID");
|
|
|
|
let prev = 1;
|
|
for (let i = 0; i < codeLength; i++) {
|
|
const bit = decoder.readBit(contexts, prev);
|
|
prev = (prev << 1) | bit;
|
|
}
|
|
if (codeLength < 31) {
|
|
return prev & ((1 << codeLength) - 1);
|
|
}
|
|
return prev & 0x7fffffff;
|
|
}
|
|
|
|
// 7.3 Segment types
|
|
const SegmentTypes = [
|
|
"SymbolDictionary",
|
|
null,
|
|
null,
|
|
null,
|
|
"IntermediateTextRegion",
|
|
null,
|
|
"ImmediateTextRegion",
|
|
"ImmediateLosslessTextRegion",
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
"PatternDictionary",
|
|
null,
|
|
null,
|
|
null,
|
|
"IntermediateHalftoneRegion",
|
|
null,
|
|
"ImmediateHalftoneRegion",
|
|
"ImmediateLosslessHalftoneRegion",
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
"IntermediateGenericRegion",
|
|
null,
|
|
"ImmediateGenericRegion",
|
|
"ImmediateLosslessGenericRegion",
|
|
"IntermediateGenericRefinementRegion",
|
|
null,
|
|
"ImmediateGenericRefinementRegion",
|
|
"ImmediateLosslessGenericRefinementRegion",
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
"PageInformation",
|
|
"EndOfPage",
|
|
"EndOfStripe",
|
|
"EndOfFile",
|
|
"Profiles",
|
|
"Tables",
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
"Extension",
|
|
];
|
|
|
|
const CodingTemplates = [
|
|
[
|
|
{ x: -1, y: -2 },
|
|
{ x: 0, y: -2 },
|
|
{ x: 1, y: -2 },
|
|
{ x: -2, y: -1 },
|
|
{ x: -1, y: -1 },
|
|
{ x: 0, y: -1 },
|
|
{ x: 1, y: -1 },
|
|
{ x: 2, y: -1 },
|
|
{ x: -4, y: 0 },
|
|
{ x: -3, y: 0 },
|
|
{ x: -2, y: 0 },
|
|
{ x: -1, y: 0 },
|
|
],
|
|
[
|
|
{ x: -1, y: -2 },
|
|
{ x: 0, y: -2 },
|
|
{ x: 1, y: -2 },
|
|
{ x: 2, y: -2 },
|
|
{ x: -2, y: -1 },
|
|
{ x: -1, y: -1 },
|
|
{ x: 0, y: -1 },
|
|
{ x: 1, y: -1 },
|
|
{ x: 2, y: -1 },
|
|
{ x: -3, y: 0 },
|
|
{ x: -2, y: 0 },
|
|
{ x: -1, y: 0 },
|
|
],
|
|
[
|
|
{ x: -1, y: -2 },
|
|
{ x: 0, y: -2 },
|
|
{ x: 1, y: -2 },
|
|
{ x: -2, y: -1 },
|
|
{ x: -1, y: -1 },
|
|
{ x: 0, y: -1 },
|
|
{ x: 1, y: -1 },
|
|
{ x: -2, y: 0 },
|
|
{ x: -1, y: 0 },
|
|
],
|
|
[
|
|
{ x: -3, y: -1 },
|
|
{ x: -2, y: -1 },
|
|
{ x: -1, y: -1 },
|
|
{ x: 0, y: -1 },
|
|
{ x: 1, y: -1 },
|
|
{ x: -4, y: 0 },
|
|
{ x: -3, y: 0 },
|
|
{ x: -2, y: 0 },
|
|
{ x: -1, y: 0 },
|
|
],
|
|
];
|
|
|
|
const RefinementTemplates = [
|
|
{
|
|
coding: [
|
|
{ x: 0, y: -1 },
|
|
{ x: 1, y: -1 },
|
|
{ x: -1, y: 0 },
|
|
],
|
|
reference: [
|
|
{ x: 0, y: -1 },
|
|
{ x: 1, y: -1 },
|
|
{ x: -1, y: 0 },
|
|
{ x: 0, y: 0 },
|
|
{ x: 1, y: 0 },
|
|
{ x: -1, y: 1 },
|
|
{ x: 0, y: 1 },
|
|
{ x: 1, y: 1 },
|
|
],
|
|
},
|
|
{
|
|
coding: [
|
|
{ x: -1, y: -1 },
|
|
{ x: 0, y: -1 },
|
|
{ x: 1, y: -1 },
|
|
{ x: -1, y: 0 },
|
|
],
|
|
reference: [
|
|
{ x: 0, y: -1 },
|
|
{ x: -1, y: 0 },
|
|
{ x: 0, y: 0 },
|
|
{ x: 1, y: 0 },
|
|
{ x: 0, y: 1 },
|
|
{ x: 1, y: 1 },
|
|
],
|
|
},
|
|
];
|
|
|
|
// See 6.2.5.7 Decoding the bitmap.
|
|
const ReusedContexts = [
|
|
0x9b25, // 10011 0110010 0101
|
|
0x0795, // 0011 110010 101
|
|
0x00e5, // 001 11001 01
|
|
0x0195, // 011001 0101
|
|
];
|
|
|
|
const RefinementReusedContexts = [
|
|
0x0020, // '000' + '0' (coding) + '00010000' + '0' (reference)
|
|
0x0008, // '0000' + '001000'
|
|
];
|
|
|
|
function decodeBitmapTemplate0(width, height, decodingContext) {
|
|
const decoder = decodingContext.decoder;
|
|
const contexts = decodingContext.contextCache.getContexts("GB");
|
|
const bitmap = [];
|
|
let contextLabel, i, j, pixel, row, row1, row2;
|
|
|
|
// ...ooooo....
|
|
// ..ooooooo... Context template for current pixel (X)
|
|
// .ooooX...... (concatenate values of 'o'-pixels to get contextLabel)
|
|
const OLD_PIXEL_MASK = 0x7bf7; // 01111 0111111 0111
|
|
|
|
for (i = 0; i < height; i++) {
|
|
row = bitmap[i] = new Uint8Array(width);
|
|
row1 = i < 1 ? row : bitmap[i - 1];
|
|
row2 = i < 2 ? row : bitmap[i - 2];
|
|
|
|
// At the beginning of each row:
|
|
// Fill contextLabel with pixels that are above/right of (X)
|
|
contextLabel =
|
|
(row2[0] << 13) |
|
|
(row2[1] << 12) |
|
|
(row2[2] << 11) |
|
|
(row1[0] << 7) |
|
|
(row1[1] << 6) |
|
|
(row1[2] << 5) |
|
|
(row1[3] << 4);
|
|
|
|
for (j = 0; j < width; j++) {
|
|
row[j] = pixel = decoder.readBit(contexts, contextLabel);
|
|
|
|
// At each pixel: Clear contextLabel pixels that are shifted
|
|
// out of the context, then add new ones.
|
|
contextLabel =
|
|
((contextLabel & OLD_PIXEL_MASK) << 1) |
|
|
(j + 3 < width ? row2[j + 3] << 11 : 0) |
|
|
(j + 4 < width ? row1[j + 4] << 4 : 0) |
|
|
pixel;
|
|
}
|
|
}
|
|
|
|
return bitmap;
|
|
}
|
|
|
|
// 6.2 Generic Region Decoding Procedure
|
|
function decodeBitmap(
|
|
mmr,
|
|
width,
|
|
height,
|
|
templateIndex,
|
|
prediction,
|
|
skip,
|
|
at,
|
|
decodingContext
|
|
) {
|
|
if (mmr) {
|
|
const input = new Reader(
|
|
decodingContext.data,
|
|
decodingContext.start,
|
|
decodingContext.end
|
|
);
|
|
return decodeMMRBitmap(input, width, height, false);
|
|
}
|
|
|
|
// Use optimized version for the most common case
|
|
if (
|
|
templateIndex === 0 &&
|
|
!skip &&
|
|
!prediction &&
|
|
at.length === 4 &&
|
|
at[0].x === 3 &&
|
|
at[0].y === -1 &&
|
|
at[1].x === -3 &&
|
|
at[1].y === -1 &&
|
|
at[2].x === 2 &&
|
|
at[2].y === -2 &&
|
|
at[3].x === -2 &&
|
|
at[3].y === -2
|
|
) {
|
|
return decodeBitmapTemplate0(width, height, decodingContext);
|
|
}
|
|
|
|
const useskip = !!skip;
|
|
const template = CodingTemplates[templateIndex].concat(at);
|
|
|
|
// Sorting is non-standard, and it is not required. But sorting increases
|
|
// the number of template bits that can be reused from the previous
|
|
// contextLabel in the main loop.
|
|
template.sort(function (a, b) {
|
|
return a.y - b.y || a.x - b.x;
|
|
});
|
|
|
|
const templateLength = template.length;
|
|
const templateX = new Int8Array(templateLength);
|
|
const templateY = new Int8Array(templateLength);
|
|
const changingTemplateEntries = [];
|
|
let reuseMask = 0,
|
|
minX = 0,
|
|
maxX = 0,
|
|
minY = 0;
|
|
let c, k;
|
|
|
|
for (k = 0; k < templateLength; k++) {
|
|
templateX[k] = template[k].x;
|
|
templateY[k] = template[k].y;
|
|
minX = Math.min(minX, template[k].x);
|
|
maxX = Math.max(maxX, template[k].x);
|
|
minY = Math.min(minY, template[k].y);
|
|
// Check if the template pixel appears in two consecutive context labels,
|
|
// so it can be reused. Otherwise, we add it to the list of changing
|
|
// template entries.
|
|
if (
|
|
k < templateLength - 1 &&
|
|
template[k].y === template[k + 1].y &&
|
|
template[k].x === template[k + 1].x - 1
|
|
) {
|
|
reuseMask |= 1 << (templateLength - 1 - k);
|
|
} else {
|
|
changingTemplateEntries.push(k);
|
|
}
|
|
}
|
|
const changingEntriesLength = changingTemplateEntries.length;
|
|
|
|
const changingTemplateX = new Int8Array(changingEntriesLength);
|
|
const changingTemplateY = new Int8Array(changingEntriesLength);
|
|
const changingTemplateBit = new Uint16Array(changingEntriesLength);
|
|
for (c = 0; c < changingEntriesLength; c++) {
|
|
k = changingTemplateEntries[c];
|
|
changingTemplateX[c] = template[k].x;
|
|
changingTemplateY[c] = template[k].y;
|
|
changingTemplateBit[c] = 1 << (templateLength - 1 - k);
|
|
}
|
|
|
|
// Get the safe bounding box edges from the width, height, minX, maxX, minY
|
|
const sbb_left = -minX;
|
|
const sbb_top = -minY;
|
|
const sbb_right = width - maxX;
|
|
|
|
const pseudoPixelContext = ReusedContexts[templateIndex];
|
|
let row = new Uint8Array(width);
|
|
const bitmap = [];
|
|
|
|
const decoder = decodingContext.decoder;
|
|
const contexts = decodingContext.contextCache.getContexts("GB");
|
|
|
|
let ltp = 0,
|
|
j,
|
|
i0,
|
|
j0,
|
|
contextLabel = 0,
|
|
bit,
|
|
shift;
|
|
for (let i = 0; i < height; i++) {
|
|
if (prediction) {
|
|
const sltp = decoder.readBit(contexts, pseudoPixelContext);
|
|
ltp ^= sltp;
|
|
if (ltp) {
|
|
bitmap.push(row); // duplicate previous row
|
|
continue;
|
|
}
|
|
}
|
|
row = new Uint8Array(row);
|
|
bitmap.push(row);
|
|
for (j = 0; j < width; j++) {
|
|
if (useskip && skip[i][j]) {
|
|
row[j] = 0;
|
|
continue;
|
|
}
|
|
// Are we in the middle of a scanline, so we can reuse contextLabel
|
|
// bits?
|
|
if (j >= sbb_left && j < sbb_right && i >= sbb_top) {
|
|
// If yes, we can just shift the bits that are reusable and only
|
|
// fetch the remaining ones.
|
|
contextLabel = (contextLabel << 1) & reuseMask;
|
|
for (k = 0; k < changingEntriesLength; k++) {
|
|
i0 = i + changingTemplateY[k];
|
|
j0 = j + changingTemplateX[k];
|
|
bit = bitmap[i0][j0];
|
|
if (bit) {
|
|
bit = changingTemplateBit[k];
|
|
contextLabel |= bit;
|
|
}
|
|
}
|
|
} else {
|
|
// compute the contextLabel from scratch
|
|
contextLabel = 0;
|
|
shift = templateLength - 1;
|
|
for (k = 0; k < templateLength; k++, shift--) {
|
|
j0 = j + templateX[k];
|
|
if (j0 >= 0 && j0 < width) {
|
|
i0 = i + templateY[k];
|
|
if (i0 >= 0) {
|
|
bit = bitmap[i0][j0];
|
|
if (bit) {
|
|
contextLabel |= bit << shift;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const pixel = decoder.readBit(contexts, contextLabel);
|
|
row[j] = pixel;
|
|
}
|
|
}
|
|
return bitmap;
|
|
}
|
|
|
|
// 6.3.2 Generic Refinement Region Decoding Procedure
|
|
function decodeRefinement(
|
|
width,
|
|
height,
|
|
templateIndex,
|
|
referenceBitmap,
|
|
offsetX,
|
|
offsetY,
|
|
prediction,
|
|
at,
|
|
decodingContext
|
|
) {
|
|
let codingTemplate = RefinementTemplates[templateIndex].coding;
|
|
if (templateIndex === 0) {
|
|
codingTemplate = codingTemplate.concat([at[0]]);
|
|
}
|
|
const codingTemplateLength = codingTemplate.length;
|
|
const codingTemplateX = new Int32Array(codingTemplateLength);
|
|
const codingTemplateY = new Int32Array(codingTemplateLength);
|
|
let k;
|
|
for (k = 0; k < codingTemplateLength; k++) {
|
|
codingTemplateX[k] = codingTemplate[k].x;
|
|
codingTemplateY[k] = codingTemplate[k].y;
|
|
}
|
|
|
|
let referenceTemplate = RefinementTemplates[templateIndex].reference;
|
|
if (templateIndex === 0) {
|
|
referenceTemplate = referenceTemplate.concat([at[1]]);
|
|
}
|
|
const referenceTemplateLength = referenceTemplate.length;
|
|
const referenceTemplateX = new Int32Array(referenceTemplateLength);
|
|
const referenceTemplateY = new Int32Array(referenceTemplateLength);
|
|
for (k = 0; k < referenceTemplateLength; k++) {
|
|
referenceTemplateX[k] = referenceTemplate[k].x;
|
|
referenceTemplateY[k] = referenceTemplate[k].y;
|
|
}
|
|
const referenceWidth = referenceBitmap[0].length;
|
|
const referenceHeight = referenceBitmap.length;
|
|
|
|
const pseudoPixelContext = RefinementReusedContexts[templateIndex];
|
|
const bitmap = [];
|
|
|
|
const decoder = decodingContext.decoder;
|
|
const contexts = decodingContext.contextCache.getContexts("GR");
|
|
|
|
let ltp = 0;
|
|
for (let i = 0; i < height; i++) {
|
|
if (prediction) {
|
|
const sltp = decoder.readBit(contexts, pseudoPixelContext);
|
|
ltp ^= sltp;
|
|
if (ltp) {
|
|
throw new Jbig2Error("prediction is not supported");
|
|
}
|
|
}
|
|
const row = new Uint8Array(width);
|
|
bitmap.push(row);
|
|
for (let j = 0; j < width; j++) {
|
|
let i0, j0;
|
|
let contextLabel = 0;
|
|
for (k = 0; k < codingTemplateLength; k++) {
|
|
i0 = i + codingTemplateY[k];
|
|
j0 = j + codingTemplateX[k];
|
|
if (i0 < 0 || j0 < 0 || j0 >= width) {
|
|
contextLabel <<= 1; // out of bound pixel
|
|
} else {
|
|
contextLabel = (contextLabel << 1) | bitmap[i0][j0];
|
|
}
|
|
}
|
|
for (k = 0; k < referenceTemplateLength; k++) {
|
|
i0 = i + referenceTemplateY[k] - offsetY;
|
|
j0 = j + referenceTemplateX[k] - offsetX;
|
|
if (i0 < 0 || i0 >= referenceHeight || j0 < 0 || j0 >= referenceWidth) {
|
|
contextLabel <<= 1; // out of bound pixel
|
|
} else {
|
|
contextLabel = (contextLabel << 1) | referenceBitmap[i0][j0];
|
|
}
|
|
}
|
|
const pixel = decoder.readBit(contexts, contextLabel);
|
|
row[j] = pixel;
|
|
}
|
|
}
|
|
|
|
return bitmap;
|
|
}
|
|
|
|
// 6.5.5 Decoding the symbol dictionary
|
|
function decodeSymbolDictionary(
|
|
huffman,
|
|
refinement,
|
|
symbols,
|
|
numberOfNewSymbols,
|
|
numberOfExportedSymbols,
|
|
huffmanTables,
|
|
templateIndex,
|
|
at,
|
|
refinementTemplateIndex,
|
|
refinementAt,
|
|
decodingContext,
|
|
huffmanInput
|
|
) {
|
|
if (huffman && refinement) {
|
|
throw new Jbig2Error("symbol refinement with Huffman is not supported");
|
|
}
|
|
|
|
const newSymbols = [];
|
|
let currentHeight = 0;
|
|
let symbolCodeLength = log2(symbols.length + numberOfNewSymbols);
|
|
|
|
const decoder = decodingContext.decoder;
|
|
const contextCache = decodingContext.contextCache;
|
|
let tableB1, symbolWidths;
|
|
if (huffman) {
|
|
tableB1 = getStandardTable(1); // standard table B.1
|
|
symbolWidths = [];
|
|
symbolCodeLength = Math.max(symbolCodeLength, 1); // 6.5.8.2.3
|
|
}
|
|
|
|
while (newSymbols.length < numberOfNewSymbols) {
|
|
const deltaHeight = huffman
|
|
? huffmanTables.tableDeltaHeight.decode(huffmanInput)
|
|
: decodeInteger(contextCache, "IADH", decoder); // 6.5.6
|
|
currentHeight += deltaHeight;
|
|
let currentWidth = 0,
|
|
totalWidth = 0;
|
|
const firstSymbol = huffman ? symbolWidths.length : 0;
|
|
while (true) {
|
|
const deltaWidth = huffman
|
|
? huffmanTables.tableDeltaWidth.decode(huffmanInput)
|
|
: decodeInteger(contextCache, "IADW", decoder); // 6.5.7
|
|
if (deltaWidth === null) {
|
|
break; // OOB
|
|
}
|
|
currentWidth += deltaWidth;
|
|
totalWidth += currentWidth;
|
|
let bitmap;
|
|
if (refinement) {
|
|
// 6.5.8.2 Refinement/aggregate-coded symbol bitmap
|
|
const numberOfInstances = decodeInteger(contextCache, "IAAI", decoder);
|
|
if (numberOfInstances > 1) {
|
|
bitmap = decodeTextRegion(
|
|
huffman,
|
|
refinement,
|
|
currentWidth,
|
|
currentHeight,
|
|
0,
|
|
numberOfInstances,
|
|
1, // strip size
|
|
symbols.concat(newSymbols),
|
|
symbolCodeLength,
|
|
0, // transposed
|
|
0, // ds offset
|
|
1, // top left 7.4.3.1.1
|
|
0, // OR operator
|
|
huffmanTables,
|
|
refinementTemplateIndex,
|
|
refinementAt,
|
|
decodingContext,
|
|
0,
|
|
huffmanInput
|
|
);
|
|
} else {
|
|
const symbolId = decodeIAID(contextCache, decoder, symbolCodeLength);
|
|
const rdx = decodeInteger(contextCache, "IARDX", decoder); // 6.4.11.3
|
|
const rdy = decodeInteger(contextCache, "IARDY", decoder); // 6.4.11.4
|
|
const symbol =
|
|
symbolId < symbols.length
|
|
? symbols[symbolId]
|
|
: newSymbols[symbolId - symbols.length];
|
|
bitmap = decodeRefinement(
|
|
currentWidth,
|
|
currentHeight,
|
|
refinementTemplateIndex,
|
|
symbol,
|
|
rdx,
|
|
rdy,
|
|
false,
|
|
refinementAt,
|
|
decodingContext
|
|
);
|
|
}
|
|
newSymbols.push(bitmap);
|
|
} else if (huffman) {
|
|
// Store only symbol width and decode a collective bitmap when the
|
|
// height class is done.
|
|
symbolWidths.push(currentWidth);
|
|
} else {
|
|
// 6.5.8.1 Direct-coded symbol bitmap
|
|
bitmap = decodeBitmap(
|
|
false,
|
|
currentWidth,
|
|
currentHeight,
|
|
templateIndex,
|
|
false,
|
|
null,
|
|
at,
|
|
decodingContext
|
|
);
|
|
newSymbols.push(bitmap);
|
|
}
|
|
}
|
|
if (huffman && !refinement) {
|
|
// 6.5.9 Height class collective bitmap
|
|
const bitmapSize = huffmanTables.tableBitmapSize.decode(huffmanInput);
|
|
huffmanInput.byteAlign();
|
|
let collectiveBitmap;
|
|
if (bitmapSize === 0) {
|
|
// Uncompressed collective bitmap
|
|
collectiveBitmap = readUncompressedBitmap(
|
|
huffmanInput,
|
|
totalWidth,
|
|
currentHeight
|
|
);
|
|
} else {
|
|
// MMR collective bitmap
|
|
const originalEnd = huffmanInput.end;
|
|
const bitmapEnd = huffmanInput.position + bitmapSize;
|
|
huffmanInput.end = bitmapEnd;
|
|
collectiveBitmap = decodeMMRBitmap(
|
|
huffmanInput,
|
|
totalWidth,
|
|
currentHeight,
|
|
false
|
|
);
|
|
huffmanInput.end = originalEnd;
|
|
huffmanInput.position = bitmapEnd;
|
|
}
|
|
const numberOfSymbolsDecoded = symbolWidths.length;
|
|
if (firstSymbol === numberOfSymbolsDecoded - 1) {
|
|
// collectiveBitmap is a single symbol.
|
|
newSymbols.push(collectiveBitmap);
|
|
} else {
|
|
// Divide collectiveBitmap into symbols.
|
|
let i,
|
|
y,
|
|
xMin = 0,
|
|
xMax,
|
|
bitmapWidth,
|
|
symbolBitmap;
|
|
for (i = firstSymbol; i < numberOfSymbolsDecoded; i++) {
|
|
bitmapWidth = symbolWidths[i];
|
|
xMax = xMin + bitmapWidth;
|
|
symbolBitmap = [];
|
|
for (y = 0; y < currentHeight; y++) {
|
|
symbolBitmap.push(collectiveBitmap[y].subarray(xMin, xMax));
|
|
}
|
|
newSymbols.push(symbolBitmap);
|
|
xMin = xMax;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 6.5.10 Exported symbols
|
|
const exportedSymbols = [],
|
|
flags = [];
|
|
let currentFlag = false,
|
|
i,
|
|
ii;
|
|
const totalSymbolsLength = symbols.length + numberOfNewSymbols;
|
|
while (flags.length < totalSymbolsLength) {
|
|
let runLength = huffman
|
|
? tableB1.decode(huffmanInput)
|
|
: decodeInteger(contextCache, "IAEX", decoder);
|
|
while (runLength--) {
|
|
flags.push(currentFlag);
|
|
}
|
|
currentFlag = !currentFlag;
|
|
}
|
|
for (i = 0, ii = symbols.length; i < ii; i++) {
|
|
if (flags[i]) {
|
|
exportedSymbols.push(symbols[i]);
|
|
}
|
|
}
|
|
for (let j = 0; j < numberOfNewSymbols; i++, j++) {
|
|
if (flags[i]) {
|
|
exportedSymbols.push(newSymbols[j]);
|
|
}
|
|
}
|
|
return exportedSymbols;
|
|
}
|
|
|
|
function decodeTextRegion(
|
|
huffman,
|
|
refinement,
|
|
width,
|
|
height,
|
|
defaultPixelValue,
|
|
numberOfSymbolInstances,
|
|
stripSize,
|
|
inputSymbols,
|
|
symbolCodeLength,
|
|
transposed,
|
|
dsOffset,
|
|
referenceCorner,
|
|
combinationOperator,
|
|
huffmanTables,
|
|
refinementTemplateIndex,
|
|
refinementAt,
|
|
decodingContext,
|
|
logStripSize,
|
|
huffmanInput
|
|
) {
|
|
if (huffman && refinement) {
|
|
throw new Jbig2Error("refinement with Huffman is not supported");
|
|
}
|
|
|
|
// Prepare bitmap
|
|
const bitmap = [];
|
|
let i, row;
|
|
for (i = 0; i < height; i++) {
|
|
row = new Uint8Array(width);
|
|
if (defaultPixelValue) {
|
|
for (let j = 0; j < width; j++) {
|
|
row[j] = defaultPixelValue;
|
|
}
|
|
}
|
|
bitmap.push(row);
|
|
}
|
|
|
|
const decoder = decodingContext.decoder;
|
|
const contextCache = decodingContext.contextCache;
|
|
|
|
let stripT = huffman
|
|
? -huffmanTables.tableDeltaT.decode(huffmanInput)
|
|
: -decodeInteger(contextCache, "IADT", decoder); // 6.4.6
|
|
let firstS = 0;
|
|
i = 0;
|
|
while (i < numberOfSymbolInstances) {
|
|
const deltaT = huffman
|
|
? huffmanTables.tableDeltaT.decode(huffmanInput)
|
|
: decodeInteger(contextCache, "IADT", decoder); // 6.4.6
|
|
stripT += deltaT;
|
|
|
|
const deltaFirstS = huffman
|
|
? huffmanTables.tableFirstS.decode(huffmanInput)
|
|
: decodeInteger(contextCache, "IAFS", decoder); // 6.4.7
|
|
firstS += deltaFirstS;
|
|
let currentS = firstS;
|
|
do {
|
|
let currentT = 0; // 6.4.9
|
|
if (stripSize > 1) {
|
|
currentT = huffman
|
|
? huffmanInput.readBits(logStripSize)
|
|
: decodeInteger(contextCache, "IAIT", decoder);
|
|
}
|
|
const t = stripSize * stripT + currentT;
|
|
const symbolId = huffman
|
|
? huffmanTables.symbolIDTable.decode(huffmanInput)
|
|
: decodeIAID(contextCache, decoder, symbolCodeLength);
|
|
const applyRefinement =
|
|
refinement &&
|
|
(huffman
|
|
? huffmanInput.readBit()
|
|
: decodeInteger(contextCache, "IARI", decoder));
|
|
let symbolBitmap = inputSymbols[symbolId];
|
|
let symbolWidth = symbolBitmap[0].length;
|
|
let symbolHeight = symbolBitmap.length;
|
|
if (applyRefinement) {
|
|
const rdw = decodeInteger(contextCache, "IARDW", decoder); // 6.4.11.1
|
|
const rdh = decodeInteger(contextCache, "IARDH", decoder); // 6.4.11.2
|
|
const rdx = decodeInteger(contextCache, "IARDX", decoder); // 6.4.11.3
|
|
const rdy = decodeInteger(contextCache, "IARDY", decoder); // 6.4.11.4
|
|
symbolWidth += rdw;
|
|
symbolHeight += rdh;
|
|
symbolBitmap = decodeRefinement(
|
|
symbolWidth,
|
|
symbolHeight,
|
|
refinementTemplateIndex,
|
|
symbolBitmap,
|
|
(rdw >> 1) + rdx,
|
|
(rdh >> 1) + rdy,
|
|
false,
|
|
refinementAt,
|
|
decodingContext
|
|
);
|
|
}
|
|
const offsetT = t - (referenceCorner & 1 ? 0 : symbolHeight - 1);
|
|
const offsetS = currentS - (referenceCorner & 2 ? symbolWidth - 1 : 0);
|
|
let s2, t2, symbolRow;
|
|
if (transposed) {
|
|
// Place Symbol Bitmap from T1,S1
|
|
for (s2 = 0; s2 < symbolHeight; s2++) {
|
|
row = bitmap[offsetS + s2];
|
|
if (!row) {
|
|
continue;
|
|
}
|
|
symbolRow = symbolBitmap[s2];
|
|
// To ignore Parts of Symbol bitmap which goes
|
|
// outside bitmap region
|
|
const maxWidth = Math.min(width - offsetT, symbolWidth);
|
|
switch (combinationOperator) {
|
|
case 0: // OR
|
|
for (t2 = 0; t2 < maxWidth; t2++) {
|
|
row[offsetT + t2] |= symbolRow[t2];
|
|
}
|
|
break;
|
|
case 2: // XOR
|
|
for (t2 = 0; t2 < maxWidth; t2++) {
|
|
row[offsetT + t2] ^= symbolRow[t2];
|
|
}
|
|
break;
|
|
default:
|
|
throw new Jbig2Error(
|
|
`operator ${combinationOperator} is not supported`
|
|
);
|
|
}
|
|
}
|
|
currentS += symbolHeight - 1;
|
|
} else {
|
|
for (t2 = 0; t2 < symbolHeight; t2++) {
|
|
row = bitmap[offsetT + t2];
|
|
if (!row) {
|
|
continue;
|
|
}
|
|
symbolRow = symbolBitmap[t2];
|
|
switch (combinationOperator) {
|
|
case 0: // OR
|
|
for (s2 = 0; s2 < symbolWidth; s2++) {
|
|
row[offsetS + s2] |= symbolRow[s2];
|
|
}
|
|
break;
|
|
case 2: // XOR
|
|
for (s2 = 0; s2 < symbolWidth; s2++) {
|
|
row[offsetS + s2] ^= symbolRow[s2];
|
|
}
|
|
break;
|
|
default:
|
|
throw new Jbig2Error(
|
|
`operator ${combinationOperator} is not supported`
|
|
);
|
|
}
|
|
}
|
|
currentS += symbolWidth - 1;
|
|
}
|
|
i++;
|
|
const deltaS = huffman
|
|
? huffmanTables.tableDeltaS.decode(huffmanInput)
|
|
: decodeInteger(contextCache, "IADS", decoder); // 6.4.8
|
|
if (deltaS === null) {
|
|
break; // OOB
|
|
}
|
|
currentS += deltaS + dsOffset;
|
|
} while (true);
|
|
}
|
|
return bitmap;
|
|
}
|
|
|
|
function decodePatternDictionary(
|
|
mmr,
|
|
patternWidth,
|
|
patternHeight,
|
|
maxPatternIndex,
|
|
template,
|
|
decodingContext
|
|
) {
|
|
const at = [];
|
|
if (!mmr) {
|
|
at.push({
|
|
x: -patternWidth,
|
|
y: 0,
|
|
});
|
|
if (template === 0) {
|
|
at.push(
|
|
{
|
|
x: -3,
|
|
y: -1,
|
|
},
|
|
{
|
|
x: 2,
|
|
y: -2,
|
|
},
|
|
{
|
|
x: -2,
|
|
y: -2,
|
|
}
|
|
);
|
|
}
|
|
}
|
|
const collectiveWidth = (maxPatternIndex + 1) * patternWidth;
|
|
const collectiveBitmap = decodeBitmap(
|
|
mmr,
|
|
collectiveWidth,
|
|
patternHeight,
|
|
template,
|
|
false,
|
|
null,
|
|
at,
|
|
decodingContext
|
|
);
|
|
// Divide collective bitmap into patterns.
|
|
const patterns = [];
|
|
for (let i = 0; i <= maxPatternIndex; i++) {
|
|
const patternBitmap = [];
|
|
const xMin = patternWidth * i;
|
|
const xMax = xMin + patternWidth;
|
|
for (let y = 0; y < patternHeight; y++) {
|
|
patternBitmap.push(collectiveBitmap[y].subarray(xMin, xMax));
|
|
}
|
|
patterns.push(patternBitmap);
|
|
}
|
|
return patterns;
|
|
}
|
|
|
|
function decodeHalftoneRegion(
|
|
mmr,
|
|
patterns,
|
|
template,
|
|
regionWidth,
|
|
regionHeight,
|
|
defaultPixelValue,
|
|
enableSkip,
|
|
combinationOperator,
|
|
gridWidth,
|
|
gridHeight,
|
|
gridOffsetX,
|
|
gridOffsetY,
|
|
gridVectorX,
|
|
gridVectorY,
|
|
decodingContext
|
|
) {
|
|
const skip = null;
|
|
if (enableSkip) {
|
|
throw new Jbig2Error("skip is not supported");
|
|
}
|
|
if (combinationOperator !== 0) {
|
|
throw new Jbig2Error(
|
|
`operator "${combinationOperator}" is not supported in halftone region`
|
|
);
|
|
}
|
|
|
|
// Prepare bitmap.
|
|
const regionBitmap = [];
|
|
let i, j, row;
|
|
for (i = 0; i < regionHeight; i++) {
|
|
row = new Uint8Array(regionWidth);
|
|
if (defaultPixelValue) {
|
|
for (j = 0; j < regionWidth; j++) {
|
|
row[j] = defaultPixelValue;
|
|
}
|
|
}
|
|
regionBitmap.push(row);
|
|
}
|
|
|
|
const numberOfPatterns = patterns.length;
|
|
const pattern0 = patterns[0];
|
|
const patternWidth = pattern0[0].length,
|
|
patternHeight = pattern0.length;
|
|
const bitsPerValue = log2(numberOfPatterns);
|
|
const at = [];
|
|
if (!mmr) {
|
|
at.push({
|
|
x: template <= 1 ? 3 : 2,
|
|
y: -1,
|
|
});
|
|
if (template === 0) {
|
|
at.push(
|
|
{
|
|
x: -3,
|
|
y: -1,
|
|
},
|
|
{
|
|
x: 2,
|
|
y: -2,
|
|
},
|
|
{
|
|
x: -2,
|
|
y: -2,
|
|
}
|
|
);
|
|
}
|
|
}
|
|
// Annex C. Gray-scale Image Decoding Procedure.
|
|
const grayScaleBitPlanes = [];
|
|
let mmrInput, bitmap;
|
|
if (mmr) {
|
|
// MMR bit planes are in one continuous stream. Only EOFB codes indicate
|
|
// the end of each bitmap, so EOFBs must be decoded.
|
|
mmrInput = new Reader(
|
|
decodingContext.data,
|
|
decodingContext.start,
|
|
decodingContext.end
|
|
);
|
|
}
|
|
for (i = bitsPerValue - 1; i >= 0; i--) {
|
|
if (mmr) {
|
|
bitmap = decodeMMRBitmap(mmrInput, gridWidth, gridHeight, true);
|
|
} else {
|
|
bitmap = decodeBitmap(
|
|
false,
|
|
gridWidth,
|
|
gridHeight,
|
|
template,
|
|
false,
|
|
skip,
|
|
at,
|
|
decodingContext
|
|
);
|
|
}
|
|
grayScaleBitPlanes[i] = bitmap;
|
|
}
|
|
// 6.6.5.2 Rendering the patterns.
|
|
let mg, ng, bit, patternIndex, patternBitmap, x, y, patternRow, regionRow;
|
|
for (mg = 0; mg < gridHeight; mg++) {
|
|
for (ng = 0; ng < gridWidth; ng++) {
|
|
bit = 0;
|
|
patternIndex = 0;
|
|
for (j = bitsPerValue - 1; j >= 0; j--) {
|
|
bit ^= grayScaleBitPlanes[j][mg][ng]; // Gray decoding
|
|
patternIndex |= bit << j;
|
|
}
|
|
patternBitmap = patterns[patternIndex];
|
|
x = (gridOffsetX + mg * gridVectorY + ng * gridVectorX) >> 8;
|
|
y = (gridOffsetY + mg * gridVectorX - ng * gridVectorY) >> 8;
|
|
// Draw patternBitmap at (x, y).
|
|
if (
|
|
x >= 0 &&
|
|
x + patternWidth <= regionWidth &&
|
|
y >= 0 &&
|
|
y + patternHeight <= regionHeight
|
|
) {
|
|
for (i = 0; i < patternHeight; i++) {
|
|
regionRow = regionBitmap[y + i];
|
|
patternRow = patternBitmap[i];
|
|
for (j = 0; j < patternWidth; j++) {
|
|
regionRow[x + j] |= patternRow[j];
|
|
}
|
|
}
|
|
} else {
|
|
let regionX, regionY;
|
|
for (i = 0; i < patternHeight; i++) {
|
|
regionY = y + i;
|
|
if (regionY < 0 || regionY >= regionHeight) {
|
|
continue;
|
|
}
|
|
regionRow = regionBitmap[regionY];
|
|
patternRow = patternBitmap[i];
|
|
for (j = 0; j < patternWidth; j++) {
|
|
regionX = x + j;
|
|
if (regionX >= 0 && regionX < regionWidth) {
|
|
regionRow[regionX] |= patternRow[j];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return regionBitmap;
|
|
}
|
|
|
|
function readSegmentHeader(data, start) {
|
|
const segmentHeader = {};
|
|
segmentHeader.number = readUint32(data, start);
|
|
const flags = data[start + 4];
|
|
const segmentType = flags & 0x3f;
|
|
if (!SegmentTypes[segmentType]) {
|
|
throw new Jbig2Error("invalid segment type: " + segmentType);
|
|
}
|
|
segmentHeader.type = segmentType;
|
|
segmentHeader.typeName = SegmentTypes[segmentType];
|
|
segmentHeader.deferredNonRetain = !!(flags & 0x80);
|
|
|
|
const pageAssociationFieldSize = !!(flags & 0x40);
|
|
const referredFlags = data[start + 5];
|
|
let referredToCount = (referredFlags >> 5) & 7;
|
|
const retainBits = [referredFlags & 31];
|
|
let position = start + 6;
|
|
if (referredFlags === 7) {
|
|
referredToCount = readUint32(data, position - 1) & 0x1fffffff;
|
|
position += 3;
|
|
let bytes = (referredToCount + 7) >> 3;
|
|
retainBits[0] = data[position++];
|
|
while (--bytes > 0) {
|
|
retainBits.push(data[position++]);
|
|
}
|
|
} else if (referredFlags === 5 || referredFlags === 6) {
|
|
throw new Jbig2Error("invalid referred-to flags");
|
|
}
|
|
|
|
segmentHeader.retainBits = retainBits;
|
|
|
|
let referredToSegmentNumberSize = 4;
|
|
if (segmentHeader.number <= 256) {
|
|
referredToSegmentNumberSize = 1;
|
|
} else if (segmentHeader.number <= 65536) {
|
|
referredToSegmentNumberSize = 2;
|
|
}
|
|
const referredTo = [];
|
|
let i, ii;
|
|
for (i = 0; i < referredToCount; i++) {
|
|
let number;
|
|
if (referredToSegmentNumberSize === 1) {
|
|
number = data[position];
|
|
} else if (referredToSegmentNumberSize === 2) {
|
|
number = readUint16(data, position);
|
|
} else {
|
|
number = readUint32(data, position);
|
|
}
|
|
referredTo.push(number);
|
|
position += referredToSegmentNumberSize;
|
|
}
|
|
segmentHeader.referredTo = referredTo;
|
|
if (!pageAssociationFieldSize) {
|
|
segmentHeader.pageAssociation = data[position++];
|
|
} else {
|
|
segmentHeader.pageAssociation = readUint32(data, position);
|
|
position += 4;
|
|
}
|
|
segmentHeader.length = readUint32(data, position);
|
|
position += 4;
|
|
|
|
if (segmentHeader.length === 0xffffffff) {
|
|
// 7.2.7 Segment data length, unknown segment length
|
|
if (segmentType === 38) {
|
|
// ImmediateGenericRegion
|
|
const genericRegionInfo = readRegionSegmentInformation(data, position);
|
|
const genericRegionSegmentFlags =
|
|
data[position + RegionSegmentInformationFieldLength];
|
|
const genericRegionMmr = !!(genericRegionSegmentFlags & 1);
|
|
// searching for the segment end
|
|
const searchPatternLength = 6;
|
|
const searchPattern = new Uint8Array(searchPatternLength);
|
|
if (!genericRegionMmr) {
|
|
searchPattern[0] = 0xff;
|
|
searchPattern[1] = 0xac;
|
|
}
|
|
searchPattern[2] = (genericRegionInfo.height >>> 24) & 0xff;
|
|
searchPattern[3] = (genericRegionInfo.height >> 16) & 0xff;
|
|
searchPattern[4] = (genericRegionInfo.height >> 8) & 0xff;
|
|
searchPattern[5] = genericRegionInfo.height & 0xff;
|
|
for (i = position, ii = data.length; i < ii; i++) {
|
|
let j = 0;
|
|
while (j < searchPatternLength && searchPattern[j] === data[i + j]) {
|
|
j++;
|
|
}
|
|
if (j === searchPatternLength) {
|
|
segmentHeader.length = i + searchPatternLength;
|
|
break;
|
|
}
|
|
}
|
|
if (segmentHeader.length === 0xffffffff) {
|
|
throw new Jbig2Error("segment end was not found");
|
|
}
|
|
} else {
|
|
throw new Jbig2Error("invalid unknown segment length");
|
|
}
|
|
}
|
|
segmentHeader.headerEnd = position;
|
|
return segmentHeader;
|
|
}
|
|
|
|
function readSegments(header, data, start, end) {
|
|
const segments = [];
|
|
let position = start;
|
|
while (position < end) {
|
|
const segmentHeader = readSegmentHeader(data, position);
|
|
position = segmentHeader.headerEnd;
|
|
const segment = {
|
|
header: segmentHeader,
|
|
data,
|
|
};
|
|
if (!header.randomAccess) {
|
|
segment.start = position;
|
|
position += segmentHeader.length;
|
|
segment.end = position;
|
|
}
|
|
segments.push(segment);
|
|
if (segmentHeader.type === 51) {
|
|
break; // end of file is found
|
|
}
|
|
}
|
|
if (header.randomAccess) {
|
|
for (let i = 0, ii = segments.length; i < ii; i++) {
|
|
segments[i].start = position;
|
|
position += segments[i].header.length;
|
|
segments[i].end = position;
|
|
}
|
|
}
|
|
return segments;
|
|
}
|
|
|
|
// 7.4.1 Region segment information field
|
|
function readRegionSegmentInformation(data, start) {
|
|
return {
|
|
width: readUint32(data, start),
|
|
height: readUint32(data, start + 4),
|
|
x: readUint32(data, start + 8),
|
|
y: readUint32(data, start + 12),
|
|
combinationOperator: data[start + 16] & 7,
|
|
};
|
|
}
|
|
const RegionSegmentInformationFieldLength = 17;
|
|
|
|
function processSegment(segment, visitor) {
|
|
const header = segment.header;
|
|
|
|
const data = segment.data,
|
|
end = segment.end;
|
|
let position = segment.start;
|
|
let args, at, i, atLength;
|
|
switch (header.type) {
|
|
case 0: // SymbolDictionary
|
|
// 7.4.2 Symbol dictionary segment syntax
|
|
const dictionary = {};
|
|
const dictionaryFlags = readUint16(data, position); // 7.4.2.1.1
|
|
dictionary.huffman = !!(dictionaryFlags & 1);
|
|
dictionary.refinement = !!(dictionaryFlags & 2);
|
|
dictionary.huffmanDHSelector = (dictionaryFlags >> 2) & 3;
|
|
dictionary.huffmanDWSelector = (dictionaryFlags >> 4) & 3;
|
|
dictionary.bitmapSizeSelector = (dictionaryFlags >> 6) & 1;
|
|
dictionary.aggregationInstancesSelector = (dictionaryFlags >> 7) & 1;
|
|
dictionary.bitmapCodingContextUsed = !!(dictionaryFlags & 256);
|
|
dictionary.bitmapCodingContextRetained = !!(dictionaryFlags & 512);
|
|
dictionary.template = (dictionaryFlags >> 10) & 3;
|
|
dictionary.refinementTemplate = (dictionaryFlags >> 12) & 1;
|
|
position += 2;
|
|
if (!dictionary.huffman) {
|
|
atLength = dictionary.template === 0 ? 4 : 1;
|
|
at = [];
|
|
for (i = 0; i < atLength; i++) {
|
|
at.push({
|
|
x: readInt8(data, position),
|
|
y: readInt8(data, position + 1),
|
|
});
|
|
position += 2;
|
|
}
|
|
dictionary.at = at;
|
|
}
|
|
if (dictionary.refinement && !dictionary.refinementTemplate) {
|
|
at = [];
|
|
for (i = 0; i < 2; i++) {
|
|
at.push({
|
|
x: readInt8(data, position),
|
|
y: readInt8(data, position + 1),
|
|
});
|
|
position += 2;
|
|
}
|
|
dictionary.refinementAt = at;
|
|
}
|
|
dictionary.numberOfExportedSymbols = readUint32(data, position);
|
|
position += 4;
|
|
dictionary.numberOfNewSymbols = readUint32(data, position);
|
|
position += 4;
|
|
args = [
|
|
dictionary,
|
|
header.number,
|
|
header.referredTo,
|
|
data,
|
|
position,
|
|
end,
|
|
];
|
|
break;
|
|
case 6: // ImmediateTextRegion
|
|
case 7: // ImmediateLosslessTextRegion
|
|
const textRegion = {};
|
|
textRegion.info = readRegionSegmentInformation(data, position);
|
|
position += RegionSegmentInformationFieldLength;
|
|
const textRegionSegmentFlags = readUint16(data, position);
|
|
position += 2;
|
|
textRegion.huffman = !!(textRegionSegmentFlags & 1);
|
|
textRegion.refinement = !!(textRegionSegmentFlags & 2);
|
|
textRegion.logStripSize = (textRegionSegmentFlags >> 2) & 3;
|
|
textRegion.stripSize = 1 << textRegion.logStripSize;
|
|
textRegion.referenceCorner = (textRegionSegmentFlags >> 4) & 3;
|
|
textRegion.transposed = !!(textRegionSegmentFlags & 64);
|
|
textRegion.combinationOperator = (textRegionSegmentFlags >> 7) & 3;
|
|
textRegion.defaultPixelValue = (textRegionSegmentFlags >> 9) & 1;
|
|
textRegion.dsOffset = (textRegionSegmentFlags << 17) >> 27;
|
|
textRegion.refinementTemplate = (textRegionSegmentFlags >> 15) & 1;
|
|
if (textRegion.huffman) {
|
|
const textRegionHuffmanFlags = readUint16(data, position);
|
|
position += 2;
|
|
textRegion.huffmanFS = textRegionHuffmanFlags & 3;
|
|
textRegion.huffmanDS = (textRegionHuffmanFlags >> 2) & 3;
|
|
textRegion.huffmanDT = (textRegionHuffmanFlags >> 4) & 3;
|
|
textRegion.huffmanRefinementDW = (textRegionHuffmanFlags >> 6) & 3;
|
|
textRegion.huffmanRefinementDH = (textRegionHuffmanFlags >> 8) & 3;
|
|
textRegion.huffmanRefinementDX = (textRegionHuffmanFlags >> 10) & 3;
|
|
textRegion.huffmanRefinementDY = (textRegionHuffmanFlags >> 12) & 3;
|
|
textRegion.huffmanRefinementSizeSelector = !!(
|
|
textRegionHuffmanFlags & 0x4000
|
|
);
|
|
}
|
|
if (textRegion.refinement && !textRegion.refinementTemplate) {
|
|
at = [];
|
|
for (i = 0; i < 2; i++) {
|
|
at.push({
|
|
x: readInt8(data, position),
|
|
y: readInt8(data, position + 1),
|
|
});
|
|
position += 2;
|
|
}
|
|
textRegion.refinementAt = at;
|
|
}
|
|
textRegion.numberOfSymbolInstances = readUint32(data, position);
|
|
position += 4;
|
|
args = [textRegion, header.referredTo, data, position, end];
|
|
break;
|
|
case 16: // PatternDictionary
|
|
// 7.4.4. Pattern dictionary segment syntax
|
|
const patternDictionary = {};
|
|
const patternDictionaryFlags = data[position++];
|
|
patternDictionary.mmr = !!(patternDictionaryFlags & 1);
|
|
patternDictionary.template = (patternDictionaryFlags >> 1) & 3;
|
|
patternDictionary.patternWidth = data[position++];
|
|
patternDictionary.patternHeight = data[position++];
|
|
patternDictionary.maxPatternIndex = readUint32(data, position);
|
|
position += 4;
|
|
args = [patternDictionary, header.number, data, position, end];
|
|
break;
|
|
case 22: // ImmediateHalftoneRegion
|
|
case 23: // ImmediateLosslessHalftoneRegion
|
|
// 7.4.5 Halftone region segment syntax
|
|
const halftoneRegion = {};
|
|
halftoneRegion.info = readRegionSegmentInformation(data, position);
|
|
position += RegionSegmentInformationFieldLength;
|
|
const halftoneRegionFlags = data[position++];
|
|
halftoneRegion.mmr = !!(halftoneRegionFlags & 1);
|
|
halftoneRegion.template = (halftoneRegionFlags >> 1) & 3;
|
|
halftoneRegion.enableSkip = !!(halftoneRegionFlags & 8);
|
|
halftoneRegion.combinationOperator = (halftoneRegionFlags >> 4) & 7;
|
|
halftoneRegion.defaultPixelValue = (halftoneRegionFlags >> 7) & 1;
|
|
halftoneRegion.gridWidth = readUint32(data, position);
|
|
position += 4;
|
|
halftoneRegion.gridHeight = readUint32(data, position);
|
|
position += 4;
|
|
halftoneRegion.gridOffsetX = readUint32(data, position) & 0xffffffff;
|
|
position += 4;
|
|
halftoneRegion.gridOffsetY = readUint32(data, position) & 0xffffffff;
|
|
position += 4;
|
|
halftoneRegion.gridVectorX = readUint16(data, position);
|
|
position += 2;
|
|
halftoneRegion.gridVectorY = readUint16(data, position);
|
|
position += 2;
|
|
args = [halftoneRegion, header.referredTo, data, position, end];
|
|
break;
|
|
case 38: // ImmediateGenericRegion
|
|
case 39: // ImmediateLosslessGenericRegion
|
|
const genericRegion = {};
|
|
genericRegion.info = readRegionSegmentInformation(data, position);
|
|
position += RegionSegmentInformationFieldLength;
|
|
const genericRegionSegmentFlags = data[position++];
|
|
genericRegion.mmr = !!(genericRegionSegmentFlags & 1);
|
|
genericRegion.template = (genericRegionSegmentFlags >> 1) & 3;
|
|
genericRegion.prediction = !!(genericRegionSegmentFlags & 8);
|
|
if (!genericRegion.mmr) {
|
|
atLength = genericRegion.template === 0 ? 4 : 1;
|
|
at = [];
|
|
for (i = 0; i < atLength; i++) {
|
|
at.push({
|
|
x: readInt8(data, position),
|
|
y: readInt8(data, position + 1),
|
|
});
|
|
position += 2;
|
|
}
|
|
genericRegion.at = at;
|
|
}
|
|
args = [genericRegion, data, position, end];
|
|
break;
|
|
case 48: // PageInformation
|
|
const pageInfo = {
|
|
width: readUint32(data, position),
|
|
height: readUint32(data, position + 4),
|
|
resolutionX: readUint32(data, position + 8),
|
|
resolutionY: readUint32(data, position + 12),
|
|
};
|
|
if (pageInfo.height === 0xffffffff) {
|
|
delete pageInfo.height;
|
|
}
|
|
const pageSegmentFlags = data[position + 16];
|
|
readUint16(data, position + 17); // pageStripingInformation
|
|
pageInfo.lossless = !!(pageSegmentFlags & 1);
|
|
pageInfo.refinement = !!(pageSegmentFlags & 2);
|
|
pageInfo.defaultPixelValue = (pageSegmentFlags >> 2) & 1;
|
|
pageInfo.combinationOperator = (pageSegmentFlags >> 3) & 3;
|
|
pageInfo.requiresBuffer = !!(pageSegmentFlags & 32);
|
|
pageInfo.combinationOperatorOverride = !!(pageSegmentFlags & 64);
|
|
args = [pageInfo];
|
|
break;
|
|
case 49: // EndOfPage
|
|
break;
|
|
case 50: // EndOfStripe
|
|
break;
|
|
case 51: // EndOfFile
|
|
break;
|
|
case 53: // Tables
|
|
args = [header.number, data, position, end];
|
|
break;
|
|
case 62: // 7.4.15 defines 2 extension types which
|
|
// are comments and can be ignored.
|
|
break;
|
|
default:
|
|
throw new Jbig2Error(
|
|
`segment type ${header.typeName}(${header.type}) is not implemented`
|
|
);
|
|
}
|
|
const callbackName = "on" + header.typeName;
|
|
if (callbackName in visitor) {
|
|
visitor[callbackName].apply(visitor, args);
|
|
}
|
|
}
|
|
|
|
function processSegments(segments, visitor) {
|
|
for (let i = 0, ii = segments.length; i < ii; i++) {
|
|
processSegment(segments[i], visitor);
|
|
}
|
|
}
|
|
|
|
function parseJbig2Chunks(chunks) {
|
|
const visitor = new SimpleSegmentVisitor();
|
|
for (let i = 0, ii = chunks.length; i < ii; i++) {
|
|
const chunk = chunks[i];
|
|
const segments = readSegments({}, chunk.data, chunk.start, chunk.end);
|
|
processSegments(segments, visitor);
|
|
}
|
|
return visitor.buffer;
|
|
}
|
|
|
|
function parseJbig2(data) {
|
|
if (typeof PDFJSDev === "undefined" || !PDFJSDev.test("IMAGE_DECODERS")) {
|
|
throw new Error("Not implemented: parseJbig2");
|
|
}
|
|
const end = data.length;
|
|
let position = 0;
|
|
|
|
if (
|
|
data[position] !== 0x97 ||
|
|
data[position + 1] !== 0x4a ||
|
|
data[position + 2] !== 0x42 ||
|
|
data[position + 3] !== 0x32 ||
|
|
data[position + 4] !== 0x0d ||
|
|
data[position + 5] !== 0x0a ||
|
|
data[position + 6] !== 0x1a ||
|
|
data[position + 7] !== 0x0a
|
|
) {
|
|
throw new Jbig2Error("parseJbig2 - invalid header.");
|
|
}
|
|
|
|
const header = Object.create(null);
|
|
position += 8;
|
|
const flags = data[position++];
|
|
header.randomAccess = !(flags & 1);
|
|
if (!(flags & 2)) {
|
|
header.numberOfPages = readUint32(data, position);
|
|
position += 4;
|
|
}
|
|
|
|
const segments = readSegments(header, data, position, end);
|
|
const visitor = new SimpleSegmentVisitor();
|
|
processSegments(segments, visitor);
|
|
|
|
const { width, height } = visitor.currentPageInfo;
|
|
const bitPacked = visitor.buffer;
|
|
const imgData = new Uint8ClampedArray(width * height);
|
|
let q = 0,
|
|
k = 0;
|
|
for (let i = 0; i < height; i++) {
|
|
let mask = 0,
|
|
buffer;
|
|
for (let j = 0; j < width; j++) {
|
|
if (!mask) {
|
|
mask = 128;
|
|
buffer = bitPacked[k++];
|
|
}
|
|
imgData[q++] = buffer & mask ? 0 : 255;
|
|
mask >>= 1;
|
|
}
|
|
}
|
|
|
|
return { imgData, width, height };
|
|
}
|
|
|
|
class SimpleSegmentVisitor {
|
|
onPageInformation(info) {
|
|
this.currentPageInfo = info;
|
|
const rowSize = (info.width + 7) >> 3;
|
|
const buffer = new Uint8ClampedArray(rowSize * info.height);
|
|
// The contents of ArrayBuffers are initialized to 0.
|
|
// Fill the buffer with 0xFF only if info.defaultPixelValue is set
|
|
if (info.defaultPixelValue) {
|
|
buffer.fill(0xff);
|
|
}
|
|
this.buffer = buffer;
|
|
}
|
|
|
|
drawBitmap(regionInfo, bitmap) {
|
|
const pageInfo = this.currentPageInfo;
|
|
const width = regionInfo.width,
|
|
height = regionInfo.height;
|
|
const rowSize = (pageInfo.width + 7) >> 3;
|
|
const combinationOperator = pageInfo.combinationOperatorOverride
|
|
? regionInfo.combinationOperator
|
|
: pageInfo.combinationOperator;
|
|
const buffer = this.buffer;
|
|
const mask0 = 128 >> (regionInfo.x & 7);
|
|
let offset0 = regionInfo.y * rowSize + (regionInfo.x >> 3);
|
|
let i, j, mask, offset;
|
|
switch (combinationOperator) {
|
|
case 0: // OR
|
|
for (i = 0; i < height; i++) {
|
|
mask = mask0;
|
|
offset = offset0;
|
|
for (j = 0; j < width; j++) {
|
|
if (bitmap[i][j]) {
|
|
buffer[offset] |= mask;
|
|
}
|
|
mask >>= 1;
|
|
if (!mask) {
|
|
mask = 128;
|
|
offset++;
|
|
}
|
|
}
|
|
offset0 += rowSize;
|
|
}
|
|
break;
|
|
case 2: // XOR
|
|
for (i = 0; i < height; i++) {
|
|
mask = mask0;
|
|
offset = offset0;
|
|
for (j = 0; j < width; j++) {
|
|
if (bitmap[i][j]) {
|
|
buffer[offset] ^= mask;
|
|
}
|
|
mask >>= 1;
|
|
if (!mask) {
|
|
mask = 128;
|
|
offset++;
|
|
}
|
|
}
|
|
offset0 += rowSize;
|
|
}
|
|
break;
|
|
default:
|
|
throw new Jbig2Error(
|
|
`operator ${combinationOperator} is not supported`
|
|
);
|
|
}
|
|
}
|
|
|
|
onImmediateGenericRegion(region, data, start, end) {
|
|
const regionInfo = region.info;
|
|
const decodingContext = new DecodingContext(data, start, end);
|
|
const bitmap = decodeBitmap(
|
|
region.mmr,
|
|
regionInfo.width,
|
|
regionInfo.height,
|
|
region.template,
|
|
region.prediction,
|
|
null,
|
|
region.at,
|
|
decodingContext
|
|
);
|
|
this.drawBitmap(regionInfo, bitmap);
|
|
}
|
|
|
|
onImmediateLosslessGenericRegion() {
|
|
this.onImmediateGenericRegion.apply(this, arguments);
|
|
}
|
|
|
|
onSymbolDictionary(
|
|
dictionary,
|
|
currentSegment,
|
|
referredSegments,
|
|
data,
|
|
start,
|
|
end
|
|
) {
|
|
let huffmanTables, huffmanInput;
|
|
if (dictionary.huffman) {
|
|
huffmanTables = getSymbolDictionaryHuffmanTables(
|
|
dictionary,
|
|
referredSegments,
|
|
this.customTables
|
|
);
|
|
huffmanInput = new Reader(data, start, end);
|
|
}
|
|
|
|
// Combines exported symbols from all referred segments
|
|
let symbols = this.symbols;
|
|
if (!symbols) {
|
|
this.symbols = symbols = {};
|
|
}
|
|
|
|
let inputSymbols = [];
|
|
for (let i = 0, ii = referredSegments.length; i < ii; i++) {
|
|
const referredSymbols = symbols[referredSegments[i]];
|
|
// referredSymbols is undefined when we have a reference to a Tables
|
|
// segment instead of a SymbolDictionary.
|
|
if (referredSymbols) {
|
|
inputSymbols = inputSymbols.concat(referredSymbols);
|
|
}
|
|
}
|
|
|
|
const decodingContext = new DecodingContext(data, start, end);
|
|
symbols[currentSegment] = decodeSymbolDictionary(
|
|
dictionary.huffman,
|
|
dictionary.refinement,
|
|
inputSymbols,
|
|
dictionary.numberOfNewSymbols,
|
|
dictionary.numberOfExportedSymbols,
|
|
huffmanTables,
|
|
dictionary.template,
|
|
dictionary.at,
|
|
dictionary.refinementTemplate,
|
|
dictionary.refinementAt,
|
|
decodingContext,
|
|
huffmanInput
|
|
);
|
|
}
|
|
|
|
onImmediateTextRegion(region, referredSegments, data, start, end) {
|
|
const regionInfo = region.info;
|
|
let huffmanTables, huffmanInput;
|
|
|
|
// Combines exported symbols from all referred segments
|
|
const symbols = this.symbols;
|
|
let inputSymbols = [];
|
|
for (let i = 0, ii = referredSegments.length; i < ii; i++) {
|
|
const referredSymbols = symbols[referredSegments[i]];
|
|
// referredSymbols is undefined when we have a reference to a Tables
|
|
// segment instead of a SymbolDictionary.
|
|
if (referredSymbols) {
|
|
inputSymbols = inputSymbols.concat(referredSymbols);
|
|
}
|
|
}
|
|
const symbolCodeLength = log2(inputSymbols.length);
|
|
if (region.huffman) {
|
|
huffmanInput = new Reader(data, start, end);
|
|
huffmanTables = getTextRegionHuffmanTables(
|
|
region,
|
|
referredSegments,
|
|
this.customTables,
|
|
inputSymbols.length,
|
|
huffmanInput
|
|
);
|
|
}
|
|
|
|
const decodingContext = new DecodingContext(data, start, end);
|
|
const bitmap = decodeTextRegion(
|
|
region.huffman,
|
|
region.refinement,
|
|
regionInfo.width,
|
|
regionInfo.height,
|
|
region.defaultPixelValue,
|
|
region.numberOfSymbolInstances,
|
|
region.stripSize,
|
|
inputSymbols,
|
|
symbolCodeLength,
|
|
region.transposed,
|
|
region.dsOffset,
|
|
region.referenceCorner,
|
|
region.combinationOperator,
|
|
huffmanTables,
|
|
region.refinementTemplate,
|
|
region.refinementAt,
|
|
decodingContext,
|
|
region.logStripSize,
|
|
huffmanInput
|
|
);
|
|
this.drawBitmap(regionInfo, bitmap);
|
|
}
|
|
|
|
onImmediateLosslessTextRegion() {
|
|
this.onImmediateTextRegion.apply(this, arguments);
|
|
}
|
|
|
|
onPatternDictionary(dictionary, currentSegment, data, start, end) {
|
|
let patterns = this.patterns;
|
|
if (!patterns) {
|
|
this.patterns = patterns = {};
|
|
}
|
|
const decodingContext = new DecodingContext(data, start, end);
|
|
patterns[currentSegment] = decodePatternDictionary(
|
|
dictionary.mmr,
|
|
dictionary.patternWidth,
|
|
dictionary.patternHeight,
|
|
dictionary.maxPatternIndex,
|
|
dictionary.template,
|
|
decodingContext
|
|
);
|
|
}
|
|
|
|
onImmediateHalftoneRegion(region, referredSegments, data, start, end) {
|
|
// HalftoneRegion refers to exactly one PatternDictionary.
|
|
const patterns = this.patterns[referredSegments[0]];
|
|
const regionInfo = region.info;
|
|
const decodingContext = new DecodingContext(data, start, end);
|
|
const bitmap = decodeHalftoneRegion(
|
|
region.mmr,
|
|
patterns,
|
|
region.template,
|
|
regionInfo.width,
|
|
regionInfo.height,
|
|
region.defaultPixelValue,
|
|
region.enableSkip,
|
|
region.combinationOperator,
|
|
region.gridWidth,
|
|
region.gridHeight,
|
|
region.gridOffsetX,
|
|
region.gridOffsetY,
|
|
region.gridVectorX,
|
|
region.gridVectorY,
|
|
decodingContext
|
|
);
|
|
this.drawBitmap(regionInfo, bitmap);
|
|
}
|
|
|
|
onImmediateLosslessHalftoneRegion() {
|
|
this.onImmediateHalftoneRegion.apply(this, arguments);
|
|
}
|
|
|
|
onTables(currentSegment, data, start, end) {
|
|
let customTables = this.customTables;
|
|
if (!customTables) {
|
|
this.customTables = customTables = {};
|
|
}
|
|
customTables[currentSegment] = decodeTablesSegment(data, start, end);
|
|
}
|
|
}
|
|
|
|
class HuffmanLine {
|
|
constructor(lineData) {
|
|
if (lineData.length === 2) {
|
|
// OOB line.
|
|
this.isOOB = true;
|
|
this.rangeLow = 0;
|
|
this.prefixLength = lineData[0];
|
|
this.rangeLength = 0;
|
|
this.prefixCode = lineData[1];
|
|
this.isLowerRange = false;
|
|
} else {
|
|
// Normal, upper range or lower range line.
|
|
// Upper range lines are processed like normal lines.
|
|
this.isOOB = false;
|
|
this.rangeLow = lineData[0];
|
|
this.prefixLength = lineData[1];
|
|
this.rangeLength = lineData[2];
|
|
this.prefixCode = lineData[3];
|
|
this.isLowerRange = lineData[4] === "lower";
|
|
}
|
|
}
|
|
}
|
|
|
|
class HuffmanTreeNode {
|
|
constructor(line) {
|
|
this.children = [];
|
|
if (line) {
|
|
// Leaf node
|
|
this.isLeaf = true;
|
|
this.rangeLength = line.rangeLength;
|
|
this.rangeLow = line.rangeLow;
|
|
this.isLowerRange = line.isLowerRange;
|
|
this.isOOB = line.isOOB;
|
|
} else {
|
|
// Intermediate or root node
|
|
this.isLeaf = false;
|
|
}
|
|
}
|
|
|
|
buildTree(line, shift) {
|
|
const bit = (line.prefixCode >> shift) & 1;
|
|
if (shift <= 0) {
|
|
// Create a leaf node.
|
|
this.children[bit] = new HuffmanTreeNode(line);
|
|
} else {
|
|
// Create an intermediate node and continue recursively.
|
|
let node = this.children[bit];
|
|
if (!node) {
|
|
this.children[bit] = node = new HuffmanTreeNode(null);
|
|
}
|
|
node.buildTree(line, shift - 1);
|
|
}
|
|
}
|
|
|
|
decodeNode(reader) {
|
|
if (this.isLeaf) {
|
|
if (this.isOOB) {
|
|
return null;
|
|
}
|
|
const htOffset = reader.readBits(this.rangeLength);
|
|
return this.rangeLow + (this.isLowerRange ? -htOffset : htOffset);
|
|
}
|
|
const node = this.children[reader.readBit()];
|
|
if (!node) {
|
|
throw new Jbig2Error("invalid Huffman data");
|
|
}
|
|
return node.decodeNode(reader);
|
|
}
|
|
}
|
|
|
|
class HuffmanTable {
|
|
constructor(lines, prefixCodesDone) {
|
|
if (!prefixCodesDone) {
|
|
this.assignPrefixCodes(lines);
|
|
}
|
|
// Create Huffman tree.
|
|
this.rootNode = new HuffmanTreeNode(null);
|
|
for (let i = 0, ii = lines.length; i < ii; i++) {
|
|
const line = lines[i];
|
|
if (line.prefixLength > 0) {
|
|
this.rootNode.buildTree(line, line.prefixLength - 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
decode(reader) {
|
|
return this.rootNode.decodeNode(reader);
|
|
}
|
|
|
|
assignPrefixCodes(lines) {
|
|
// Annex B.3 Assigning the prefix codes.
|
|
const linesLength = lines.length;
|
|
let prefixLengthMax = 0;
|
|
for (let i = 0; i < linesLength; i++) {
|
|
prefixLengthMax = Math.max(prefixLengthMax, lines[i].prefixLength);
|
|
}
|
|
|
|
const histogram = new Uint32Array(prefixLengthMax + 1);
|
|
for (let i = 0; i < linesLength; i++) {
|
|
histogram[lines[i].prefixLength]++;
|
|
}
|
|
let currentLength = 1,
|
|
firstCode = 0,
|
|
currentCode,
|
|
currentTemp,
|
|
line;
|
|
histogram[0] = 0;
|
|
|
|
while (currentLength <= prefixLengthMax) {
|
|
firstCode = (firstCode + histogram[currentLength - 1]) << 1;
|
|
currentCode = firstCode;
|
|
currentTemp = 0;
|
|
while (currentTemp < linesLength) {
|
|
line = lines[currentTemp];
|
|
if (line.prefixLength === currentLength) {
|
|
line.prefixCode = currentCode;
|
|
currentCode++;
|
|
}
|
|
currentTemp++;
|
|
}
|
|
currentLength++;
|
|
}
|
|
}
|
|
}
|
|
|
|
function decodeTablesSegment(data, start, end) {
|
|
// Decodes a Tables segment, i.e., a custom Huffman table.
|
|
// Annex B.2 Code table structure.
|
|
const flags = data[start];
|
|
const lowestValue = readUint32(data, start + 1) & 0xffffffff;
|
|
const highestValue = readUint32(data, start + 5) & 0xffffffff;
|
|
const reader = new Reader(data, start + 9, end);
|
|
|
|
const prefixSizeBits = ((flags >> 1) & 7) + 1;
|
|
const rangeSizeBits = ((flags >> 4) & 7) + 1;
|
|
const lines = [];
|
|
let prefixLength,
|
|
rangeLength,
|
|
currentRangeLow = lowestValue;
|
|
|
|
// Normal table lines
|
|
do {
|
|
prefixLength = reader.readBits(prefixSizeBits);
|
|
rangeLength = reader.readBits(rangeSizeBits);
|
|
lines.push(
|
|
new HuffmanLine([currentRangeLow, prefixLength, rangeLength, 0])
|
|
);
|
|
currentRangeLow += 1 << rangeLength;
|
|
} while (currentRangeLow < highestValue);
|
|
|
|
// Lower range table line
|
|
prefixLength = reader.readBits(prefixSizeBits);
|
|
lines.push(new HuffmanLine([lowestValue - 1, prefixLength, 32, 0, "lower"]));
|
|
|
|
// Upper range table line
|
|
prefixLength = reader.readBits(prefixSizeBits);
|
|
lines.push(new HuffmanLine([highestValue, prefixLength, 32, 0]));
|
|
|
|
if (flags & 1) {
|
|
// Out-of-band table line
|
|
prefixLength = reader.readBits(prefixSizeBits);
|
|
lines.push(new HuffmanLine([prefixLength, 0]));
|
|
}
|
|
|
|
return new HuffmanTable(lines, false);
|
|
}
|
|
|
|
const standardTablesCache = {};
|
|
|
|
function getStandardTable(number) {
|
|
// Annex B.5 Standard Huffman tables.
|
|
let table = standardTablesCache[number];
|
|
if (table) {
|
|
return table;
|
|
}
|
|
let lines;
|
|
switch (number) {
|
|
case 1:
|
|
lines = [
|
|
[0, 1, 4, 0x0],
|
|
[16, 2, 8, 0x2],
|
|
[272, 3, 16, 0x6],
|
|
[65808, 3, 32, 0x7], // upper
|
|
];
|
|
break;
|
|
case 2:
|
|
lines = [
|
|
[0, 1, 0, 0x0],
|
|
[1, 2, 0, 0x2],
|
|
[2, 3, 0, 0x6],
|
|
[3, 4, 3, 0xe],
|
|
[11, 5, 6, 0x1e],
|
|
[75, 6, 32, 0x3e], // upper
|
|
[6, 0x3f], // OOB
|
|
];
|
|
break;
|
|
case 3:
|
|
lines = [
|
|
[-256, 8, 8, 0xfe],
|
|
[0, 1, 0, 0x0],
|
|
[1, 2, 0, 0x2],
|
|
[2, 3, 0, 0x6],
|
|
[3, 4, 3, 0xe],
|
|
[11, 5, 6, 0x1e],
|
|
[-257, 8, 32, 0xff, "lower"],
|
|
[75, 7, 32, 0x7e], // upper
|
|
[6, 0x3e], // OOB
|
|
];
|
|
break;
|
|
case 4:
|
|
lines = [
|
|
[1, 1, 0, 0x0],
|
|
[2, 2, 0, 0x2],
|
|
[3, 3, 0, 0x6],
|
|
[4, 4, 3, 0xe],
|
|
[12, 5, 6, 0x1e],
|
|
[76, 5, 32, 0x1f], // upper
|
|
];
|
|
break;
|
|
case 5:
|
|
lines = [
|
|
[-255, 7, 8, 0x7e],
|
|
[1, 1, 0, 0x0],
|
|
[2, 2, 0, 0x2],
|
|
[3, 3, 0, 0x6],
|
|
[4, 4, 3, 0xe],
|
|
[12, 5, 6, 0x1e],
|
|
[-256, 7, 32, 0x7f, "lower"],
|
|
[76, 6, 32, 0x3e], // upper
|
|
];
|
|
break;
|
|
case 6:
|
|
lines = [
|
|
[-2048, 5, 10, 0x1c],
|
|
[-1024, 4, 9, 0x8],
|
|
[-512, 4, 8, 0x9],
|
|
[-256, 4, 7, 0xa],
|
|
[-128, 5, 6, 0x1d],
|
|
[-64, 5, 5, 0x1e],
|
|
[-32, 4, 5, 0xb],
|
|
[0, 2, 7, 0x0],
|
|
[128, 3, 7, 0x2],
|
|
[256, 3, 8, 0x3],
|
|
[512, 4, 9, 0xc],
|
|
[1024, 4, 10, 0xd],
|
|
[-2049, 6, 32, 0x3e, "lower"],
|
|
[2048, 6, 32, 0x3f], // upper
|
|
];
|
|
break;
|
|
case 7:
|
|
lines = [
|
|
[-1024, 4, 9, 0x8],
|
|
[-512, 3, 8, 0x0],
|
|
[-256, 4, 7, 0x9],
|
|
[-128, 5, 6, 0x1a],
|
|
[-64, 5, 5, 0x1b],
|
|
[-32, 4, 5, 0xa],
|
|
[0, 4, 5, 0xb],
|
|
[32, 5, 5, 0x1c],
|
|
[64, 5, 6, 0x1d],
|
|
[128, 4, 7, 0xc],
|
|
[256, 3, 8, 0x1],
|
|
[512, 3, 9, 0x2],
|
|
[1024, 3, 10, 0x3],
|
|
[-1025, 5, 32, 0x1e, "lower"],
|
|
[2048, 5, 32, 0x1f], // upper
|
|
];
|
|
break;
|
|
case 8:
|
|
lines = [
|
|
[-15, 8, 3, 0xfc],
|
|
[-7, 9, 1, 0x1fc],
|
|
[-5, 8, 1, 0xfd],
|
|
[-3, 9, 0, 0x1fd],
|
|
[-2, 7, 0, 0x7c],
|
|
[-1, 4, 0, 0xa],
|
|
[0, 2, 1, 0x0],
|
|
[2, 5, 0, 0x1a],
|
|
[3, 6, 0, 0x3a],
|
|
[4, 3, 4, 0x4],
|
|
[20, 6, 1, 0x3b],
|
|
[22, 4, 4, 0xb],
|
|
[38, 4, 5, 0xc],
|
|
[70, 5, 6, 0x1b],
|
|
[134, 5, 7, 0x1c],
|
|
[262, 6, 7, 0x3c],
|
|
[390, 7, 8, 0x7d],
|
|
[646, 6, 10, 0x3d],
|
|
[-16, 9, 32, 0x1fe, "lower"],
|
|
[1670, 9, 32, 0x1ff], // upper
|
|
[2, 0x1], // OOB
|
|
];
|
|
break;
|
|
case 9:
|
|
lines = [
|
|
[-31, 8, 4, 0xfc],
|
|
[-15, 9, 2, 0x1fc],
|
|
[-11, 8, 2, 0xfd],
|
|
[-7, 9, 1, 0x1fd],
|
|
[-5, 7, 1, 0x7c],
|
|
[-3, 4, 1, 0xa],
|
|
[-1, 3, 1, 0x2],
|
|
[1, 3, 1, 0x3],
|
|
[3, 5, 1, 0x1a],
|
|
[5, 6, 1, 0x3a],
|
|
[7, 3, 5, 0x4],
|
|
[39, 6, 2, 0x3b],
|
|
[43, 4, 5, 0xb],
|
|
[75, 4, 6, 0xc],
|
|
[139, 5, 7, 0x1b],
|
|
[267, 5, 8, 0x1c],
|
|
[523, 6, 8, 0x3c],
|
|
[779, 7, 9, 0x7d],
|
|
[1291, 6, 11, 0x3d],
|
|
[-32, 9, 32, 0x1fe, "lower"],
|
|
[3339, 9, 32, 0x1ff], // upper
|
|
[2, 0x0], // OOB
|
|
];
|
|
break;
|
|
case 10:
|
|
lines = [
|
|
[-21, 7, 4, 0x7a],
|
|
[-5, 8, 0, 0xfc],
|
|
[-4, 7, 0, 0x7b],
|
|
[-3, 5, 0, 0x18],
|
|
[-2, 2, 2, 0x0],
|
|
[2, 5, 0, 0x19],
|
|
[3, 6, 0, 0x36],
|
|
[4, 7, 0, 0x7c],
|
|
[5, 8, 0, 0xfd],
|
|
[6, 2, 6, 0x1],
|
|
[70, 5, 5, 0x1a],
|
|
[102, 6, 5, 0x37],
|
|
[134, 6, 6, 0x38],
|
|
[198, 6, 7, 0x39],
|
|
[326, 6, 8, 0x3a],
|
|
[582, 6, 9, 0x3b],
|
|
[1094, 6, 10, 0x3c],
|
|
[2118, 7, 11, 0x7d],
|
|
[-22, 8, 32, 0xfe, "lower"],
|
|
[4166, 8, 32, 0xff], // upper
|
|
[2, 0x2], // OOB
|
|
];
|
|
break;
|
|
case 11:
|
|
lines = [
|
|
[1, 1, 0, 0x0],
|
|
[2, 2, 1, 0x2],
|
|
[4, 4, 0, 0xc],
|
|
[5, 4, 1, 0xd],
|
|
[7, 5, 1, 0x1c],
|
|
[9, 5, 2, 0x1d],
|
|
[13, 6, 2, 0x3c],
|
|
[17, 7, 2, 0x7a],
|
|
[21, 7, 3, 0x7b],
|
|
[29, 7, 4, 0x7c],
|
|
[45, 7, 5, 0x7d],
|
|
[77, 7, 6, 0x7e],
|
|
[141, 7, 32, 0x7f], // upper
|
|
];
|
|
break;
|
|
case 12:
|
|
lines = [
|
|
[1, 1, 0, 0x0],
|
|
[2, 2, 0, 0x2],
|
|
[3, 3, 1, 0x6],
|
|
[5, 5, 0, 0x1c],
|
|
[6, 5, 1, 0x1d],
|
|
[8, 6, 1, 0x3c],
|
|
[10, 7, 0, 0x7a],
|
|
[11, 7, 1, 0x7b],
|
|
[13, 7, 2, 0x7c],
|
|
[17, 7, 3, 0x7d],
|
|
[25, 7, 4, 0x7e],
|
|
[41, 8, 5, 0xfe],
|
|
[73, 8, 32, 0xff], // upper
|
|
];
|
|
break;
|
|
case 13:
|
|
lines = [
|
|
[1, 1, 0, 0x0],
|
|
[2, 3, 0, 0x4],
|
|
[3, 4, 0, 0xc],
|
|
[4, 5, 0, 0x1c],
|
|
[5, 4, 1, 0xd],
|
|
[7, 3, 3, 0x5],
|
|
[15, 6, 1, 0x3a],
|
|
[17, 6, 2, 0x3b],
|
|
[21, 6, 3, 0x3c],
|
|
[29, 6, 4, 0x3d],
|
|
[45, 6, 5, 0x3e],
|
|
[77, 7, 6, 0x7e],
|
|
[141, 7, 32, 0x7f], // upper
|
|
];
|
|
break;
|
|
case 14:
|
|
lines = [
|
|
[-2, 3, 0, 0x4],
|
|
[-1, 3, 0, 0x5],
|
|
[0, 1, 0, 0x0],
|
|
[1, 3, 0, 0x6],
|
|
[2, 3, 0, 0x7],
|
|
];
|
|
break;
|
|
case 15:
|
|
lines = [
|
|
[-24, 7, 4, 0x7c],
|
|
[-8, 6, 2, 0x3c],
|
|
[-4, 5, 1, 0x1c],
|
|
[-2, 4, 0, 0xc],
|
|
[-1, 3, 0, 0x4],
|
|
[0, 1, 0, 0x0],
|
|
[1, 3, 0, 0x5],
|
|
[2, 4, 0, 0xd],
|
|
[3, 5, 1, 0x1d],
|
|
[5, 6, 2, 0x3d],
|
|
[9, 7, 4, 0x7d],
|
|
[-25, 7, 32, 0x7e, "lower"],
|
|
[25, 7, 32, 0x7f], // upper
|
|
];
|
|
break;
|
|
default:
|
|
throw new Jbig2Error(`standard table B.${number} does not exist`);
|
|
}
|
|
|
|
for (let i = 0, ii = lines.length; i < ii; i++) {
|
|
lines[i] = new HuffmanLine(lines[i]);
|
|
}
|
|
table = new HuffmanTable(lines, true);
|
|
standardTablesCache[number] = table;
|
|
return table;
|
|
}
|
|
|
|
class Reader {
|
|
constructor(data, start, end) {
|
|
this.data = data;
|
|
this.start = start;
|
|
this.end = end;
|
|
this.position = start;
|
|
this.shift = -1;
|
|
this.currentByte = 0;
|
|
}
|
|
|
|
readBit() {
|
|
if (this.shift < 0) {
|
|
if (this.position >= this.end) {
|
|
throw new Jbig2Error("end of data while reading bit");
|
|
}
|
|
this.currentByte = this.data[this.position++];
|
|
this.shift = 7;
|
|
}
|
|
const bit = (this.currentByte >> this.shift) & 1;
|
|
this.shift--;
|
|
return bit;
|
|
}
|
|
|
|
readBits(numBits) {
|
|
let result = 0,
|
|
i;
|
|
for (i = numBits - 1; i >= 0; i--) {
|
|
result |= this.readBit() << i;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
byteAlign() {
|
|
this.shift = -1;
|
|
}
|
|
|
|
next() {
|
|
if (this.position >= this.end) {
|
|
return -1;
|
|
}
|
|
return this.data[this.position++];
|
|
}
|
|
}
|
|
|
|
function getCustomHuffmanTable(index, referredTo, customTables) {
|
|
// Returns a Tables segment that has been earlier decoded.
|
|
// See 7.4.2.1.6 (symbol dictionary) or 7.4.3.1.6 (text region).
|
|
let currentIndex = 0;
|
|
for (let i = 0, ii = referredTo.length; i < ii; i++) {
|
|
const table = customTables[referredTo[i]];
|
|
if (table) {
|
|
if (index === currentIndex) {
|
|
return table;
|
|
}
|
|
currentIndex++;
|
|
}
|
|
}
|
|
throw new Jbig2Error("can't find custom Huffman table");
|
|
}
|
|
|
|
function getTextRegionHuffmanTables(
|
|
textRegion,
|
|
referredTo,
|
|
customTables,
|
|
numberOfSymbols,
|
|
reader
|
|
) {
|
|
// 7.4.3.1.7 Symbol ID Huffman table decoding
|
|
|
|
// Read code lengths for RUNCODEs 0...34.
|
|
const codes = [];
|
|
for (let i = 0; i <= 34; i++) {
|
|
const codeLength = reader.readBits(4);
|
|
codes.push(new HuffmanLine([i, codeLength, 0, 0]));
|
|
}
|
|
// Assign Huffman codes for RUNCODEs.
|
|
const runCodesTable = new HuffmanTable(codes, false);
|
|
|
|
// Read a Huffman code using the assignment above.
|
|
// Interpret the RUNCODE codes and the additional bits (if any).
|
|
codes.length = 0;
|
|
for (let i = 0; i < numberOfSymbols; ) {
|
|
const codeLength = runCodesTable.decode(reader);
|
|
if (codeLength >= 32) {
|
|
let repeatedLength, numberOfRepeats, j;
|
|
switch (codeLength) {
|
|
case 32:
|
|
if (i === 0) {
|
|
throw new Jbig2Error("no previous value in symbol ID table");
|
|
}
|
|
numberOfRepeats = reader.readBits(2) + 3;
|
|
repeatedLength = codes[i - 1].prefixLength;
|
|
break;
|
|
case 33:
|
|
numberOfRepeats = reader.readBits(3) + 3;
|
|
repeatedLength = 0;
|
|
break;
|
|
case 34:
|
|
numberOfRepeats = reader.readBits(7) + 11;
|
|
repeatedLength = 0;
|
|
break;
|
|
default:
|
|
throw new Jbig2Error("invalid code length in symbol ID table");
|
|
}
|
|
for (j = 0; j < numberOfRepeats; j++) {
|
|
codes.push(new HuffmanLine([i, repeatedLength, 0, 0]));
|
|
i++;
|
|
}
|
|
} else {
|
|
codes.push(new HuffmanLine([i, codeLength, 0, 0]));
|
|
i++;
|
|
}
|
|
}
|
|
reader.byteAlign();
|
|
const symbolIDTable = new HuffmanTable(codes, false);
|
|
|
|
// 7.4.3.1.6 Text region segment Huffman table selection
|
|
|
|
let customIndex = 0,
|
|
tableFirstS,
|
|
tableDeltaS,
|
|
tableDeltaT;
|
|
|
|
switch (textRegion.huffmanFS) {
|
|
case 0:
|
|
case 1:
|
|
tableFirstS = getStandardTable(textRegion.huffmanFS + 6);
|
|
break;
|
|
case 3:
|
|
tableFirstS = getCustomHuffmanTable(
|
|
customIndex,
|
|
referredTo,
|
|
customTables
|
|
);
|
|
customIndex++;
|
|
break;
|
|
default:
|
|
throw new Jbig2Error("invalid Huffman FS selector");
|
|
}
|
|
|
|
switch (textRegion.huffmanDS) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
tableDeltaS = getStandardTable(textRegion.huffmanDS + 8);
|
|
break;
|
|
case 3:
|
|
tableDeltaS = getCustomHuffmanTable(
|
|
customIndex,
|
|
referredTo,
|
|
customTables
|
|
);
|
|
customIndex++;
|
|
break;
|
|
default:
|
|
throw new Jbig2Error("invalid Huffman DS selector");
|
|
}
|
|
|
|
switch (textRegion.huffmanDT) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
tableDeltaT = getStandardTable(textRegion.huffmanDT + 11);
|
|
break;
|
|
case 3:
|
|
tableDeltaT = getCustomHuffmanTable(
|
|
customIndex,
|
|
referredTo,
|
|
customTables
|
|
);
|
|
customIndex++;
|
|
break;
|
|
default:
|
|
throw new Jbig2Error("invalid Huffman DT selector");
|
|
}
|
|
|
|
if (textRegion.refinement) {
|
|
// Load tables RDW, RDH, RDX and RDY.
|
|
throw new Jbig2Error("refinement with Huffman is not supported");
|
|
}
|
|
|
|
return {
|
|
symbolIDTable,
|
|
tableFirstS,
|
|
tableDeltaS,
|
|
tableDeltaT,
|
|
};
|
|
}
|
|
|
|
function getSymbolDictionaryHuffmanTables(
|
|
dictionary,
|
|
referredTo,
|
|
customTables
|
|
) {
|
|
// 7.4.2.1.6 Symbol dictionary segment Huffman table selection
|
|
|
|
let customIndex = 0,
|
|
tableDeltaHeight,
|
|
tableDeltaWidth;
|
|
switch (dictionary.huffmanDHSelector) {
|
|
case 0:
|
|
case 1:
|
|
tableDeltaHeight = getStandardTable(dictionary.huffmanDHSelector + 4);
|
|
break;
|
|
case 3:
|
|
tableDeltaHeight = getCustomHuffmanTable(
|
|
customIndex,
|
|
referredTo,
|
|
customTables
|
|
);
|
|
customIndex++;
|
|
break;
|
|
default:
|
|
throw new Jbig2Error("invalid Huffman DH selector");
|
|
}
|
|
|
|
switch (dictionary.huffmanDWSelector) {
|
|
case 0:
|
|
case 1:
|
|
tableDeltaWidth = getStandardTable(dictionary.huffmanDWSelector + 2);
|
|
break;
|
|
case 3:
|
|
tableDeltaWidth = getCustomHuffmanTable(
|
|
customIndex,
|
|
referredTo,
|
|
customTables
|
|
);
|
|
customIndex++;
|
|
break;
|
|
default:
|
|
throw new Jbig2Error("invalid Huffman DW selector");
|
|
}
|
|
|
|
let tableBitmapSize, tableAggregateInstances;
|
|
if (dictionary.bitmapSizeSelector) {
|
|
tableBitmapSize = getCustomHuffmanTable(
|
|
customIndex,
|
|
referredTo,
|
|
customTables
|
|
);
|
|
customIndex++;
|
|
} else {
|
|
tableBitmapSize = getStandardTable(1);
|
|
}
|
|
|
|
if (dictionary.aggregationInstancesSelector) {
|
|
tableAggregateInstances = getCustomHuffmanTable(
|
|
customIndex,
|
|
referredTo,
|
|
customTables
|
|
);
|
|
} else {
|
|
tableAggregateInstances = getStandardTable(1);
|
|
}
|
|
|
|
return {
|
|
tableDeltaHeight,
|
|
tableDeltaWidth,
|
|
tableBitmapSize,
|
|
tableAggregateInstances,
|
|
};
|
|
}
|
|
|
|
function readUncompressedBitmap(reader, width, height) {
|
|
const bitmap = [];
|
|
for (let y = 0; y < height; y++) {
|
|
const row = new Uint8Array(width);
|
|
bitmap.push(row);
|
|
for (let x = 0; x < width; x++) {
|
|
row[x] = reader.readBit();
|
|
}
|
|
reader.byteAlign();
|
|
}
|
|
return bitmap;
|
|
}
|
|
|
|
function decodeMMRBitmap(input, width, height, endOfBlock) {
|
|
// MMR is the same compression algorithm as the PDF filter
|
|
// CCITTFaxDecode with /K -1.
|
|
const params = {
|
|
K: -1,
|
|
Columns: width,
|
|
Rows: height,
|
|
BlackIs1: true,
|
|
EndOfBlock: endOfBlock,
|
|
};
|
|
const decoder = new CCITTFaxDecoder(input, params);
|
|
const bitmap = [];
|
|
let currentByte,
|
|
eof = false;
|
|
|
|
for (let y = 0; y < height; y++) {
|
|
const row = new Uint8Array(width);
|
|
bitmap.push(row);
|
|
let shift = -1;
|
|
for (let x = 0; x < width; x++) {
|
|
if (shift < 0) {
|
|
currentByte = decoder.readNextChar();
|
|
if (currentByte === -1) {
|
|
// Set the rest of the bits to zero.
|
|
currentByte = 0;
|
|
eof = true;
|
|
}
|
|
shift = 7;
|
|
}
|
|
row[x] = (currentByte >> shift) & 1;
|
|
shift--;
|
|
}
|
|
}
|
|
|
|
if (endOfBlock && !eof) {
|
|
// Read until EOFB has been consumed.
|
|
const lookForEOFLimit = 5;
|
|
for (let i = 0; i < lookForEOFLimit; i++) {
|
|
if (decoder.readNextChar() === -1) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bitmap;
|
|
}
|
|
|
|
class Jbig2Image {
|
|
parseChunks(chunks) {
|
|
return parseJbig2Chunks(chunks);
|
|
}
|
|
|
|
parse(data) {
|
|
if (typeof PDFJSDev === "undefined" || !PDFJSDev.test("IMAGE_DECODERS")) {
|
|
throw new Error("Not implemented: Jbig2Image.parse");
|
|
}
|
|
const { imgData, width, height } = parseJbig2(data);
|
|
this.width = width;
|
|
this.height = height;
|
|
return imgData;
|
|
}
|
|
}
|
|
|
|
export { Jbig2Image };
|