Sakurai/pdf.js
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove the IR (internal representation) part of the ColorSpace parsing

Browse Source 
Originally ColorSpaces were only *partially* parsed on the worker-thread, to obtain an IR-format which was sent to the main-thread. This had the somewhat unfortunate side-effect of causing the majority of the (potentially heavy) ColorSpace parsing to happen on the main-thread.
Hence PR 4824 which, among other things, changed ColorSpaces to be *fully* parsed on the worker-thread with only RGB-data being sent to the main-thread.

While it thus originally was necessary to have `ColorSpace.{parseToIR, fromIR}` methods, to handle the worker/main-thread split, that's no longer the case and we can thus reduce all of the ColorSpace parsing to one method instead.

Currently, when parsing a ColorSpace, we call `ColorSpace.parseToIR` which parses the ColorSpace-data from the document and then creates the IR-format. We then, immediately, call `ColorSpace.fromIR` which parses the IR-format and then finally creates the actual ColorSpace.[1]
All-in-all, this leads to a fair amount of unnecessary indirection which also (in my opinion) makes the code less clear.

Obviously these changes are not really expected to have a significant effect on performance, especially with the recently added caching of ColorSpaces, however there'll now be strictly fewer function calls, less memory allocated, and overall less parsing required during ColorSpace-handling.

---
[1] For ICCBased ColorSpaces, given the validation necessary, this currently even leads to parsing an /Alternate ColorSpace *twice*.
This commit is contained in:
Jonas Jenwald 2020-07-10 16:01:33 +02:00
parent 38cf49bb81
commit ea6a0e4435
1 changed files with 47 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
src/core/colorspace.js
View File

@ -336,8 +336,12 @@ class ColorSpace {
"before calling `ColorSpace.parseAsync`." "before calling `ColorSpace.parseAsync`."
); );
} }
const IR = this.parseToIR(cs, xref, resources, pdfFunctionFactory); const parsedColorSpace = this._parse(
const parsedColorSpace = this.fromIR(IR); cs,
xref,
resources,
pdfFunctionFactory
);
// Attempt to cache the parsed ColorSpace, by name and/or reference. // Attempt to cache the parsed ColorSpace, by name and/or reference.
this._cache(cs, xref, localColorSpaceCache, parsedColorSpace); this._cache(cs, xref, localColorSpaceCache, parsedColorSpace);
@ -356,8 +360,12 @@ class ColorSpace {
if (cachedColorSpace) { if (cachedColorSpace) {
return cachedColorSpace; return cachedColorSpace;
} }
const IR = this.parseToIR(cs, xref, resources, pdfFunctionFactory); const parsedColorSpace = this._parse(
const parsedColorSpace = this.fromIR(IR); cs,
xref,
resources,
pdfFunctionFactory
);
// Attempt to cache the parsed ColorSpace, by name and/or reference. // Attempt to cache the parsed ColorSpace, by name and/or reference.
this._cache(cs, xref, localColorSpaceCache, parsedColorSpace); this._cache(cs, xref, localColorSpaceCache, parsedColorSpace);
@ -365,69 +373,24 @@ class ColorSpace {
return parsedColorSpace; return parsedColorSpace;
} }
static fromIR(IR) { /**
const name = Array.isArray(IR) ? IR[0] : IR; * @private
let whitePoint, blackPoint, gamma; */
static _parse(cs, xref, resources = null, pdfFunctionFactory) {
switch (name) {
case "DeviceGrayCS":
return this.singletons.gray;
case "DeviceRgbCS":
return this.singletons.rgb;
case "DeviceCmykCS":
return this.singletons.cmyk;
case "CalGrayCS":
whitePoint = IR[1];
blackPoint = IR[2];
gamma = IR[3];
return new CalGrayCS(whitePoint, blackPoint, gamma);
case "CalRGBCS":
whitePoint = IR[1];
blackPoint = IR[2];
gamma = IR[3];
const matrix = IR[4];
return new CalRGBCS(whitePoint, blackPoint, gamma, matrix);
case "PatternCS":
let basePatternCS = IR[1];
if (basePatternCS) {
basePatternCS = this.fromIR(basePatternCS);
}
return new PatternCS(basePatternCS);
case "IndexedCS":
const baseIndexedCS = IR[1];
const hiVal = IR[2];
const lookup = IR[3];
return new IndexedCS(this.fromIR(baseIndexedCS), hiVal, lookup);
case "AlternateCS":
const numComps = IR[1];
const alt = IR[2];
const tintFn = IR[3];
return new AlternateCS(numComps, this.fromIR(alt), tintFn);
case "LabCS":
whitePoint = IR[1];
blackPoint = IR[2];
const range = IR[3];
return new LabCS(whitePoint, blackPoint, range);
default:
throw new FormatError(`Unknown colorspace name: ${name}`);
}
}
static parseToIR(cs, xref, resources = null, pdfFunctionFactory) {
cs = xref.fetchIfRef(cs); cs = xref.fetchIfRef(cs);
if (isName(cs)) { if (isName(cs)) {
switch (cs.name) { switch (cs.name) {
case "DeviceGray": case "DeviceGray":
case "G": case "G":
return "DeviceGrayCS"; return this.singletons.gray;
case "DeviceRGB": case "DeviceRGB":
case "RGB": case "RGB":
return "DeviceRgbCS"; return this.singletons.rgb;
case "DeviceCMYK": case "DeviceCMYK":
case "CMYK": case "CMYK":
return "DeviceCmykCS"; return this.singletons.cmyk;
case "Pattern": case "Pattern":
return ["PatternCS", null]; return new PatternCS(/* baseCS = */ null);
default: default:
if (isDict(resources)) { if (isDict(resources)) {
const colorSpaces = resources.get("ColorSpace"); const colorSpaces = resources.get("ColorSpace");
@ -435,7 +398,7 @@ class ColorSpace {
const resourcesCS = colorSpaces.get(cs.name); const resourcesCS = colorSpaces.get(cs.name);
if (resourcesCS) { if (resourcesCS) {
if (isName(resourcesCS)) { if (isName(resourcesCS)) {
return this.parseToIR( return this._parse(
resourcesCS, resourcesCS,
xref, xref,
resources, resources,
@ -447,107 +410,91 @@ class ColorSpace {
} }
} }
} }
throw new FormatError(`unrecognized colorspace ${cs.name}`); throw new FormatError(`Unrecognized ColorSpace: ${cs.name}`);
} }
} }
if (Array.isArray(cs)) { if (Array.isArray(cs)) {
const mode = xref.fetchIfRef(cs[0]).name; const mode = xref.fetchIfRef(cs[0]).name;
let numComps, params, alt, whitePoint, blackPoint, gamma; let params, numComps, baseCS, whitePoint, blackPoint, gamma;
switch (mode) { switch (mode) {
case "DeviceGray": case "DeviceGray":
case "G": case "G":
return "DeviceGrayCS"; return this.singletons.gray;
case "DeviceRGB": case "DeviceRGB":
case "RGB": case "RGB":
return "DeviceRgbCS"; return this.singletons.rgb;
case "DeviceCMYK": case "DeviceCMYK":
case "CMYK": case "CMYK":
return "DeviceCmykCS"; return this.singletons.cmyk;
case "CalGray": case "CalGray":
params = xref.fetchIfRef(cs[1]); params = xref.fetchIfRef(cs[1]);
whitePoint = params.getArray("WhitePoint"); whitePoint = params.getArray("WhitePoint");
blackPoint = params.getArray("BlackPoint"); blackPoint = params.getArray("BlackPoint");
gamma = params.get("Gamma"); gamma = params.get("Gamma");
return ["CalGrayCS", whitePoint, blackPoint, gamma]; return new CalGrayCS(whitePoint, blackPoint, gamma);
case "CalRGB": case "CalRGB":
params = xref.fetchIfRef(cs[1]); params = xref.fetchIfRef(cs[1]);
whitePoint = params.getArray("WhitePoint"); whitePoint = params.getArray("WhitePoint");
blackPoint = params.getArray("BlackPoint"); blackPoint = params.getArray("BlackPoint");
gamma = params.getArray("Gamma"); gamma = params.getArray("Gamma");
const matrix = params.getArray("Matrix"); const matrix = params.getArray("Matrix");
return ["CalRGBCS", whitePoint, blackPoint, gamma, matrix]; return new CalRGBCS(whitePoint, blackPoint, gamma, matrix);
case "ICCBased": case "ICCBased":
const stream = xref.fetchIfRef(cs[1]); const stream = xref.fetchIfRef(cs[1]);
const dict = stream.dict; const dict = stream.dict;
numComps = dict.get("N"); numComps = dict.get("N");
alt = dict.get("Alternate"); const alt = dict.get("Alternate");
if (alt) { if (alt) {
const altIR = this.parseToIR( const altCS = this._parse(alt, xref, resources, pdfFunctionFactory);
alt, // Ensure that the number of components are correct,
xref, // and also (indirectly) that it is not a PatternCS.
resources,
pdfFunctionFactory
);
// Parse the /Alternate CS to ensure that the number of components
// are correct, and also (indirectly) that it is not a PatternCS.
const altCS = this.fromIR(altIR);
if (altCS.numComps === numComps) { if (altCS.numComps === numComps) {
return altIR; return altCS;
} }
warn("ICCBased color space: Ignoring incorrect /Alternate entry."); warn("ICCBased color space: Ignoring incorrect /Alternate entry.");
} }
if (numComps === 1) { if (numComps === 1) {
return "DeviceGrayCS"; return this.singletons.gray;
} else if (numComps === 3) { } else if (numComps === 3) {
return "DeviceRgbCS"; return this.singletons.rgb;
} else if (numComps === 4) { } else if (numComps === 4) {
return "DeviceCmykCS"; return this.singletons.cmyk;
} }
break; break;
case "Pattern": case "Pattern":
let basePatternCS = cs[1] || null; baseCS = cs[1] || null;
if (basePatternCS) { if (baseCS) {
basePatternCS = this.parseToIR( baseCS = this._parse(baseCS, xref, resources, pdfFunctionFactory);
basePatternCS,
xref,
resources,
pdfFunctionFactory
);
} }
return ["PatternCS", basePatternCS]; return new PatternCS(baseCS);
case "Indexed": case "Indexed":
case "I": case "I":
const baseIndexedCS = this.parseToIR( baseCS = this._parse(cs[1], xref, resources, pdfFunctionFactory);
cs[1],
xref,
resources,
pdfFunctionFactory
);
const hiVal = xref.fetchIfRef(cs[2]) + 1; const hiVal = xref.fetchIfRef(cs[2]) + 1;
let lookup = xref.fetchIfRef(cs[3]); let lookup = xref.fetchIfRef(cs[3]);
if (isStream(lookup)) { if (isStream(lookup)) {
lookup = lookup.getBytes(); lookup = lookup.getBytes();
} }
return ["IndexedCS", baseIndexedCS, hiVal, lookup]; return new IndexedCS(baseCS, hiVal, lookup);
case "Separation": case "Separation":
case "DeviceN": case "DeviceN":
const name = xref.fetchIfRef(cs[1]); const name = xref.fetchIfRef(cs[1]);
numComps = Array.isArray(name) ? name.length : 1; numComps = Array.isArray(name) ? name.length : 1;
alt = this.parseToIR(cs[2], xref, resources, pdfFunctionFactory); baseCS = this._parse(cs[2], xref, resources, pdfFunctionFactory);
const tintFn = pdfFunctionFactory.create(cs[3]); const tintFn = pdfFunctionFactory.create(cs[3]);
return ["AlternateCS", numComps, alt, tintFn]; return new AlternateCS(numComps, baseCS, tintFn);
case "Lab": case "Lab":
params = xref.fetchIfRef(cs[1]); params = xref.fetchIfRef(cs[1]);
whitePoint = params.getArray("WhitePoint"); whitePoint = params.getArray("WhitePoint");
blackPoint = params.getArray("BlackPoint"); blackPoint = params.getArray("BlackPoint");
const range = params.getArray("Range"); const range = params.getArray("Range");
return ["LabCS", whitePoint, blackPoint, range]; return new LabCS(whitePoint, blackPoint, range);
default: default:
throw new FormatError(`unimplemented color space object "${mode}"`); throw new FormatError(`Unimplemented ColorSpace object: ${mode}`);
} }
} }
throw new FormatError(`unrecognized color space object: "${cs}"`); throw new FormatError(`Unrecognized ColorSpace object: ${cs}`);
} }
/** /**