Skip to content

Commit

Permalink
Merge pull request #12083 from Snuffleupagus/ColorSpace-rm-IR
Browse files Browse the repository at this point in the history 
Remove the IR (internal representation) part of the ColorSpace parsing
  • Loading branch information
@timvandermeij
timvandermeij authored Jul 10, 2020
2 parents 38cf49b + d18cf47 commit c11fc3a
Show file tree
Hide file tree
Showing 2 changed files with 60 additions and 119 deletions.
167 changes: 53 additions & 114 deletions src/core/colorspace.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,7 +17,6 @@ import {
assert,
FormatError,
info,
isString,
shadow,
unreachable,
warn,
Expand Down Expand Up @@ -336,8 +335,12 @@ class ColorSpace {
"before calling `ColorSpace.parseAsync`."
);
}
const IR = this.parseToIR(cs, xref, resources, pdfFunctionFactory);
const parsedColorSpace = this.fromIR(IR);
const parsedColorSpace = this._parse(
cs,
xref,
resources,
pdfFunctionFactory
);

// Attempt to cache the parsed ColorSpace, by name and/or reference.
this._cache(cs, xref, localColorSpaceCache, parsedColorSpace);
Expand All @@ -356,86 +359,45 @@ class ColorSpace {
if (cachedColorSpace) {
return cachedColorSpace;
}
const IR = this.parseToIR(cs, xref, resources, pdfFunctionFactory);
const parsedColorSpace = this.fromIR(IR);
const parsedColorSpace = this._parse(
cs,
xref,
resources,
pdfFunctionFactory
);

// Attempt to cache the parsed ColorSpace, by name and/or reference.
this._cache(cs, xref, localColorSpaceCache, parsedColorSpace);

return parsedColorSpace;
}

static fromIR(IR) {
const name = Array.isArray(IR) ? IR[0] : IR;
let whitePoint, blackPoint, gamma;

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) {
/**
* @private
*/
static _parse(cs, xref, resources = null, pdfFunctionFactory) {
cs = xref.fetchIfRef(cs);
if (isName(cs)) {
switch (cs.name) {
case "DeviceGray":
case "G":
return "DeviceGrayCS";
return this.singletons.gray;
case "DeviceRGB":
case "RGB":
return "DeviceRgbCS";
return this.singletons.rgb;
case "DeviceCMYK":
case "CMYK":
return "DeviceCmykCS";
return this.singletons.cmyk;
case "Pattern":
return ["PatternCS", null];
return new PatternCS(/* baseCS = */ null);
default:
if (isDict(resources)) {
const colorSpaces = resources.get("ColorSpace");
if (isDict(colorSpaces)) {
const resourcesCS = colorSpaces.get(cs.name);
if (resourcesCS) {
if (isName(resourcesCS)) {
return this.parseToIR(
return this._parse(
resourcesCS,
xref,
resources,
Expand All @@ -447,107 +409,88 @@ class ColorSpace {
}
}
}
throw new FormatError(`unrecognized colorspace ${cs.name}`);
throw new FormatError(`Unrecognized ColorSpace: ${cs.name}`);
}
}
if (Array.isArray(cs)) {
const mode = xref.fetchIfRef(cs[0]).name;
let numComps, params, alt, whitePoint, blackPoint, gamma;
let params, numComps, baseCS, whitePoint, blackPoint, gamma;

switch (mode) {
case "DeviceGray":
case "G":
return "DeviceGrayCS";
return this.singletons.gray;
case "DeviceRGB":
case "RGB":
return "DeviceRgbCS";
return this.singletons.rgb;
case "DeviceCMYK":
case "CMYK":
return "DeviceCmykCS";
return this.singletons.cmyk;
case "CalGray":
params = xref.fetchIfRef(cs[1]);
whitePoint = params.getArray("WhitePoint");
blackPoint = params.getArray("BlackPoint");
gamma = params.get("Gamma");
return ["CalGrayCS", whitePoint, blackPoint, gamma];
return new CalGrayCS(whitePoint, blackPoint, gamma);
case "CalRGB":
params = xref.fetchIfRef(cs[1]);
whitePoint = params.getArray("WhitePoint");
blackPoint = params.getArray("BlackPoint");
gamma = params.getArray("Gamma");
const matrix = params.getArray("Matrix");
return ["CalRGBCS", whitePoint, blackPoint, gamma, matrix];
return new CalRGBCS(whitePoint, blackPoint, gamma, matrix);
case "ICCBased":
const stream = xref.fetchIfRef(cs[1]);
const dict = stream.dict;
numComps = dict.get("N");
alt = dict.get("Alternate");
const alt = dict.get("Alternate");
if (alt) {
const altIR = this.parseToIR(
alt,
xref,
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);
const altCS = this._parse(alt, xref, resources, pdfFunctionFactory);
// Ensure that the number of components are correct,
// and also (indirectly) that it is not a PatternCS.
if (altCS.numComps === numComps) {
return altIR;
return altCS;
}
warn("ICCBased color space: Ignoring incorrect /Alternate entry.");
}
if (numComps === 1) {
return "DeviceGrayCS";
return this.singletons.gray;
} else if (numComps === 3) {
return "DeviceRgbCS";
return this.singletons.rgb;
} else if (numComps === 4) {
return "DeviceCmykCS";
return this.singletons.cmyk;
}
break;
case "Pattern":
let basePatternCS = cs[1] || null;
if (basePatternCS) {
basePatternCS = this.parseToIR(
basePatternCS,
xref,
resources,
pdfFunctionFactory
);
baseCS = cs[1] || null;
if (baseCS) {
baseCS = this._parse(baseCS, xref, resources, pdfFunctionFactory);
}
return ["PatternCS", basePatternCS];
return new PatternCS(baseCS);
case "Indexed":
case "I":
const baseIndexedCS = this.parseToIR(
cs[1],
xref,
resources,
pdfFunctionFactory
);
baseCS = this._parse(cs[1], xref, resources, pdfFunctionFactory);
const hiVal = xref.fetchIfRef(cs[2]) + 1;
let lookup = xref.fetchIfRef(cs[3]);
if (isStream(lookup)) {
lookup = lookup.getBytes();
}
return ["IndexedCS", baseIndexedCS, hiVal, lookup];
const lookup = xref.fetchIfRef(cs[3]);
return new IndexedCS(baseCS, hiVal, lookup);
case "Separation":
case "DeviceN":
const name = xref.fetchIfRef(cs[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]);
return ["AlternateCS", numComps, alt, tintFn];
return new AlternateCS(numComps, baseCS, tintFn);
case "Lab":
params = xref.fetchIfRef(cs[1]);
whitePoint = params.getArray("WhitePoint");
blackPoint = params.getArray("BlackPoint");
const range = params.getArray("Range");
return ["LabCS", whitePoint, blackPoint, range];
return new LabCS(whitePoint, blackPoint, range);
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}`);
}

/**
Expand Down Expand Up @@ -696,22 +639,18 @@ class IndexedCS extends ColorSpace {
this.base = base;
this.highVal = highVal;

const baseNumComps = base.numComps;
const length = baseNumComps * highVal;
const length = base.numComps * highVal;
this.lookup = new Uint8Array(length);

if (isStream(lookup)) {
this.lookup = new Uint8Array(length);
const bytes = lookup.getBytes(length);
this.lookup.set(bytes);
} else if (isString(lookup)) {
this.lookup = new Uint8Array(length);
} else if (typeof lookup === "string") {
for (let i = 0; i < length; ++i) {
this.lookup[i] = lookup.charCodeAt(i);
this.lookup[i] = lookup.charCodeAt(i) & 0xff;
}
} else if (lookup instanceof Uint8Array) {
this.lookup = lookup;
} else {
throw new FormatError(`Unrecognized lookup table: ${lookup}`);
throw new FormatError(`IndexedCS - unrecognized lookup table: ${lookup}`);
}
}

Expand Down
12 changes: 7 additions & 5 deletions test/unit/colorspace_spec.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -679,11 +679,13 @@ describe("colorspace", function () {
describe("IndexedCS", function () {
it("should handle the case when cs is an array", function () {
// prettier-ignore
const lookup = new Uint8Array([
23, 155, 35,
147, 69, 93,
255, 109, 70
]);
const lookup = new Stream(
new Uint8Array([
23, 155, 35,
147, 69, 93,
255, 109, 70
])
);
const cs = [Name.get("Indexed"), Name.get("DeviceRGB"), 2, lookup];
const xref = new XRefMock([
{
Expand Down

0 comments on commit c11fc3a

Please sign in to comment.