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

Incrementally render by sending the operator list by chunks as they're ready.

Browse Source
This commit is contained in:
Brendan Dahl 2013-07-31 11:17:36 -07:00
parent f7d2a09bf8
commit bf72bc94e2
11 changed files with 641 additions and 789 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

136
src/annotation.js
View File

@ -16,7 +16,7 @@
*/
/* globals Util, isDict, isName, stringToPDFString, TODO, Dict, Stream,
stringToBytes, PDFJS, isWorker, assert, NotImplementedException,
Promise, isArray, ObjectLoader, isValidUrl */
Promise, isArray, ObjectLoader, isValidUrl, OperatorList */
'use strict';
@ -162,13 +162,7 @@ var Annotation = (function AnnotationClosure() {
var promise = new Promise();
if (!this.appearance) {
promise.resolve({
queue: {
fnArray: [],
argsArray: []
},
dependency: {}
});
promise.resolve(new OperatorList());
return promise;
}
@ -192,19 +186,11 @@ var Annotation = (function AnnotationClosure() {
var border = data.border;
resourcesPromise.then(function(resources) {
var listPromise = evaluator.getOperatorList(this.appearance, resources);
listPromise.then(function(appearanceStreamData) {
var fnArray = appearanceStreamData.queue.fnArray;
var argsArray = appearanceStreamData.queue.argsArray;
fnArray.unshift('beginAnnotation');
argsArray.unshift([data.rect, transform, matrix]);
fnArray.push('endAnnotation');
argsArray.push([]);
promise.resolve(appearanceStreamData);
});
var opList = new OperatorList();
opList.addOp('beginAnnotation', [data.rect, transform, matrix]);
evaluator.getOperatorList(this.appearance, resources, opList);
opList.addOp('endAnnotation', []);
promise.resolve(opList);
}.bind(this));
return promise;
@ -284,7 +270,7 @@ var Annotation = (function AnnotationClosure() {
};
Annotation.appendToOperatorList = function Annotation_appendToOperatorList(
annotations, pageQueue, pdfManager, dependencies, partialEvaluator) {
annotations, opList, pdfManager, partialEvaluator) {
function reject(e) {
annotationsReadyPromise.reject(e);
@ -296,22 +282,13 @@ var Annotation = (function AnnotationClosure() {
for (var i = 0, n = annotations.length; i < n; ++i) {
annotationPromises.push(annotations[i].getOperatorList(partialEvaluator));
}
Promise.all(annotationPromises).then(function(datas) {
var fnArray = pageQueue.fnArray;
var argsArray = pageQueue.argsArray;
fnArray.push('beginAnnotations');
argsArray.push([]);
opList.addOp('beginAnnotations', []);
for (var i = 0, n = datas.length; i < n; ++i) {
var annotationData = datas[i];
var annotationQueue = annotationData.queue;
Util.concatenateToArray(fnArray, annotationQueue.fnArray);
Util.concatenateToArray(argsArray, annotationQueue.argsArray);
Util.extendObj(dependencies, annotationData.dependencies);
var annotOpList = datas[i];
opList.addOpList(annotOpList);
}
fnArray.push('endAnnotations');
argsArray.push([]);
opList.addOp('endAnnotations', []);
annotationsReadyPromise.resolve();
}, reject);
@ -458,8 +435,8 @@ var TextWidgetAnnotation = (function TextWidgetAnnotationClosure() {
getOperatorList: function TextWidgetAnnotation_getOperatorList(evaluator) {
var promise = new Promise();
var opList = new OperatorList();
var data = this.data;
// Even if there is an appearance stream, ignore it. This is the
@ -467,65 +444,44 @@ var TextWidgetAnnotation = (function TextWidgetAnnotationClosure() {
var defaultAppearance = data.defaultAppearance;
if (!defaultAppearance) {
promise.resolve({
queue: {
fnArray: [],
argsArray: []
},
dependency: {}
});
promise.resolve(opList);
return promise;
}
// Include any font resources found in the default appearance
var stream = new Stream(stringToBytes(defaultAppearance));
var listPromise = evaluator.getOperatorList(stream, this.fieldResources);
listPromise.then(function(appearanceStreamData) {
var appearanceFnArray = appearanceStreamData.queue.fnArray;
var appearanceArgsArray = appearanceStreamData.queue.argsArray;
var fnArray = [];
var argsArray = [];
evaluator.getOperatorList(stream, this.fieldResources, opList);
var appearanceFnArray = opList.fnArray;
var appearanceArgsArray = opList.argsArray;
var fnArray = [];
var argsArray = [];
// TODO(mack): Add support for stroke color
data.rgb = [0, 0, 0];
for (var i = 0, n = fnArray.length; i < n; ++i) {
var fnName = appearanceFnArray[i];
var args = appearanceArgsArray[i];
if (fnName === 'dependency') {
var dependency = args[i];
if (dependency.indexOf('g_font_') === 0) {
data.fontRefName = dependency;
}
fnArray.push(fnName);
argsArray.push(args);
} else if (fnName === 'setFont') {
data.fontRefName = args[0];
var size = args[1];
if (size < 0) {
data.fontDirection = -1;
data.fontSize = -size;
} else {
data.fontDirection = 1;
data.fontSize = size;
}
} else if (fnName === 'setFillRGBColor') {
data.rgb = args;
} else if (fnName === 'setFillGray') {
var rgbValue = args[0] * 255;
data.rgb = [rgbValue, rgbValue, rgbValue];
// TODO(mack): Add support for stroke color
data.rgb = [0, 0, 0];
// TODO THIS DOESN'T MAKE ANY SENSE SINCE THE fnArray IS EMPTY!
for (var i = 0, n = fnArray.length; i < n; ++i) {
var fnName = appearanceFnArray[i];
var args = appearanceArgsArray[i];
if (fnName === 'setFont') {
data.fontRefName = args[0];
var size = args[1];
if (size < 0) {
data.fontDirection = -1;
data.fontSize = -size;
} else {
data.fontDirection = 1;
data.fontSize = size;
}
} else if (fnName === 'setFillRGBColor') {
data.rgb = args;
} else if (fnName === 'setFillGray') {
var rgbValue = args[0] * 255;
data.rgb = [rgbValue, rgbValue, rgbValue];
}
promise.resolve({
queue: {
fnArray: fnArray,
argsArray: argsArray
},
dependency: {}
});
});
}
promise.resolve(opList);
return promise;
}
});
@ -557,13 +513,7 @@ var TextAnnotation = (function TextAnnotationClosure() {
getOperatorList: function TextAnnotation_getOperatorList(evaluator) {
var promise = new Promise();
promise.resolve({
queue: {
fnArray: [],
argsArray: []
},
dependency: {}
});
promise.resolve(new OperatorList());
return promise;
},

338
src/api.js
View File

@ -17,7 +17,7 @@
/* globals CanvasGraphics, combineUrl, createScratchCanvas, error, ErrorFont,
Font, FontLoader, globalScope, info, isArrayBuffer, loadJpegStream,
MessageHandler, PDFJS, PDFObjects, Promise, StatTimer, warn,
WorkerMessageHandler, PasswordResponses */
WorkerMessageHandler, PasswordResponses, Util */
'use strict';
@ -222,6 +222,7 @@ var PDFPageProxy = (function PDFPageProxyClosure() {
this.objs = new PDFObjects();
this.renderInProgress = false;
this.cleanupAfterRender = false;
this.renderTasks = [];
}
PDFPageProxy.prototype = {
/**
@ -289,20 +290,24 @@ var PDFPageProxy = (function PDFPageProxyClosure() {
* rendering call the function that is the
* first argument to the callback.
* }.
* @return {Promise} A promise that is resolved when the page finishes
* rendering.
* @return {RenderTask} An extended promise that is resolved when the page
* finishes rendering (see RenderTask).
*/
render: function PDFPageProxy_render(params) {
this.renderInProgress = true;
var promise = new Promise();
var stats = this.stats;
stats.time('Overall');
// If there is no displayReadyPromise yet, then the operatorList was never
// requested before. Make the request and create the promise.
if (!this.displayReadyPromise) {
this.displayReadyPromise = new Promise();
this.destroyed = false;
this.operatorList = {
fnArray: [],
argsArray: [],
lastChunk: false
};
this.stats.time('Page Request');
this.transport.messageHandler.send('RenderPageRequest', {
@ -310,128 +315,48 @@ var PDFPageProxy = (function PDFPageProxyClosure() {
});
}
var internalRenderTask = new InternalRenderTask(complete, params,
this.objs, this.commonObjs,
this.operatorList, this.pageNumber);
this.renderTasks.push(internalRenderTask);
var renderTask = new RenderTask(internalRenderTask);
var self = this;
function complete(error) {
self.renderInProgress = false;
if (self.destroyed || self.cleanupAfterRender) {
delete self.displayReadyPromise;
delete self.operatorList;
self.objs.clear();
}
if (error)
promise.reject(error);
else
promise.resolve();
}
var continueCallback = params.continueCallback;
// Once the operatorList and fonts are loaded, do the actual rendering.
this.displayReadyPromise.then(
function pageDisplayReadyPromise() {
function pageDisplayReadyPromise(transparency) {
if (self.destroyed) {
complete();
return;
}
var gfx = new CanvasGraphics(params.canvasContext, this.commonObjs,
this.objs, params.textLayer, params.imageLayer);
try {
this.display(gfx, params.viewport, complete, continueCallback);
} catch (e) {
complete(e);
}
}.bind(this),
stats.time('Rendering');
internalRenderTask.initalizeGraphics(transparency);
internalRenderTask.operatorListChanged();
},
function pageDisplayReadPromiseError(reason) {
complete(reason);
}
);
return promise;
},
/**
* For internal use only.
*/
startRenderingFromOperatorList:
function PDFPageProxy_startRenderingFromOperatorList(operatorList,
fonts) {
var self = this;
this.operatorList = operatorList;
function complete(error) {
var i = self.renderTasks.indexOf(internalRenderTask);
if (i >= 0) {
self.renderTasks.splice(i, 1);
}
this.ensureFonts(fonts,
function pageStartRenderingFromOperatorListEnsureFonts() {
self.displayReadyPromise.resolve();
if (self.renderTasks.length === 0 &&
(self.destroyed || self.cleanupAfterRender)) {
self._destroy();
}
);
},
/**
* For internal use only.
*/
ensureFonts: function PDFPageProxy_ensureFonts(fonts, callback) {
this.stats.time('Font Loading');
// Convert the font names to the corresponding font obj.
var fontObjs = [];
for (var i = 0, ii = fonts.length; i < ii; i++) {
var obj = this.commonObjs.getData(fonts[i]);
if (obj.error) {
warn('Error during font loading: ' + obj.error);
continue;
if (error) {
renderTask.reject(error);
} else {
renderTask.resolve();
}
if (!obj.coded) {
this.transport.embeddedFontsUsed = true;
}
fontObjs.push(obj);
stats.timeEnd('Rendering');
stats.timeEnd('Overall');
}
// Load all the fonts
FontLoader.bind(
fontObjs,
function pageEnsureFontsFontObjs(fontObjs) {
this.stats.timeEnd('Font Loading');
callback.call(this);
}.bind(this)
);
},
/**
* For internal use only.
*/
display: function PDFPageProxy_display(gfx, viewport, callback,
continueCallback) {
var stats = this.stats;
stats.time('Rendering');
var operatorList = this.operatorList;
gfx.beginDrawing(viewport, operatorList.transparency);
var startIdx = 0;
var length = operatorList.fnArray.length;
var stepper = null;
if (PDFJS.pdfBug && 'StepperManager' in globalScope &&
globalScope['StepperManager'].enabled) {
stepper = globalScope['StepperManager'].create(this.pageNumber - 1);
stepper.init(operatorList);
stepper.nextBreakPoint = stepper.getNextBreakPoint();
}
var continueWrapper;
if (continueCallback)
continueWrapper = function() { continueCallback(next); };
else
continueWrapper = next;
var self = this;
function next() {
startIdx = gfx.executeOperatorList(operatorList, startIdx,
continueWrapper, stepper);
if (startIdx == length) {
gfx.endDrawing();
stats.timeEnd('Rendering');
stats.timeEnd('Overall');
if (callback) callback();
}
}
continueWrapper();
return renderTask;
},
/**
* @return {Promise} That is resolved with the a {string} that is the text
@ -466,10 +391,38 @@ var PDFPageProxy = (function PDFPageProxyClosure() {
destroy: function PDFPageProxy_destroy() {
this.destroyed = true;
if (!this.renderInProgress) {
delete this.operatorList;
delete this.displayReadyPromise;
this.objs.clear();
if (this.renderTasks.length === 0) {
this._destroy();
}
},
/**
* For internal use only. Does the actual cleanup.
*/
_destroy: function PDFPageProxy__destroy() {
delete this.operatorList;
delete this.displayReadyPromise;
this.objs.clear();
},
/**
* For internal use only.
*/
_startRenderPage: function PDFPageProxy_startRenderPage(transparency) {
this.displayReadyPromise.resolve(transparency);
},
/**
* For internal use only.
*/
_renderPageChunk: function PDFPageProxy_renderPageChunk(operatorListChunk) {
// Add the new chunk to the current operator list.
Util.concatenateToArray(this.operatorList.fnArray,
operatorListChunk.fnArray);
Util.concatenateToArray(this.operatorList.argsArray,
operatorListChunk.argsArray);
this.operatorList.lastChunk = operatorListChunk.lastChunk;
// Notify all the rendering tasks there are more operators to be consumed.
for (var i = 0; i < this.renderTasks.length; i++) {
this.renderTasks[i].operatorListChanged();
}
}
};
@ -644,12 +597,17 @@ var WorkerTransport = (function WorkerTransportClosure() {
promise.resolve(annotations);
}, this);
messageHandler.on('RenderPage', function transportRender(data) {
messageHandler.on('StartRenderPage', function transportRender(data) {
var page = this.pageCache[data.pageIndex];
var depFonts = data.depFonts;
page.stats.timeEnd('Page Request');
page.startRenderingFromOperatorList(data.operatorList, depFonts);
page._startRenderPage(data.transparency);
}, this);
messageHandler.on('RenderPageChunk', function transportRender(data) {
var page = this.pageCache[data.pageIndex];
page._renderPageChunk(data.operatorList);
}, this);
messageHandler.on('commonobj', function transportObj(data) {
@ -662,14 +620,22 @@ var WorkerTransport = (function WorkerTransportClosure() {
case 'Font':
var exportedData = data[2];
// At this point, only the font object is created but the font is
// not yet attached to the DOM. This is done in `FontLoader.bind`.
var font;
if ('error' in exportedData)
if ('error' in exportedData) {
font = new ErrorFont(exportedData.error);
else
warn('Error during font loading: ' + font.error);
this.commonObjs.resolve(id, font);
break;
} else {
font = new Font(exportedData);
this.commonObjs.resolve(id, font);
}
FontLoader.bind(
[font],
function fontReady(fontObjs) {
this.commonObjs.resolve(id, font);
}.bind(this)
);
break;
default:
error('Got unknown common object type ' + type);
@ -814,3 +780,129 @@ var WorkerTransport = (function WorkerTransportClosure() {
return WorkerTransport;
})();
/**
* RenderTask is basically a promise but adds a cancel function to terminate it.
*/
var RenderTask = (function RenderTaskClosure() {
function RenderTask(internalRenderTask) {
this.internalRenderTask = internalRenderTask;
Promise.call(this);
}
RenderTask.prototype = Object.create(Promise.prototype);
/**
* Cancel the rendering task. If the task is curently rendering it will not be
* cancelled until graphics pauses with a timeout. The promise that this
* object extends will resolved when cancelled.
*/
RenderTask.prototype.cancel = function RenderTask_cancel() {
this.internalRenderTask.cancel();
};
return RenderTask;
})();
var InternalRenderTask = (function InternalRenderTaskClosure() {
function InternalRenderTask(callback, params, objs, commonObjs, operatorList,
pageNumber) {
this.callback = callback;
this.params = params;
this.objs = objs;
this.commonObjs = commonObjs;
this.operatorListIdx = null;
this.operatorList = operatorList;
this.pageNumber = pageNumber;
this.running = false;
this.graphicsReadyCallback = null;
this.graphicsReady = false;
this.cancelled = false;
}
InternalRenderTask.prototype = {
initalizeGraphics:
function InternalRenderTask_initalizeGraphics(transparency) {
if (this.cancelled) {
return;
}
if (PDFJS.pdfBug && 'StepperManager' in globalScope &&
globalScope.StepperManager.enabled) {
this.stepper = globalScope.StepperManager.create(this.pageNumber - 1);
this.stepper.init(this.operatorList);
this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint();
}
var params = this.params;
this.gfx = new CanvasGraphics(params.canvasContext, this.commonObjs,
this.objs, params.textLayer,
params.imageLayer);
this.gfx.beginDrawing(params.viewport, transparency);
this.operatorListIdx = 0;
this.graphicsReady = true;
if (this.graphicsReadyCallback) {
this.graphicsReadyCallback();
}
},
cancel: function InternalRenderTask_cancel() {
this.running = false;
this.cancelled = true;
this.callback();
},
operatorListChanged: function InternalRenderTask_operatorListChanged() {
if (!this.graphicsReady) {
if (!this.graphicsReadyCallback) {
this.graphicsReadyCallback = this._continue.bind(this);
}
return;
}
if (this.stepper) {
this.stepper.updateOperatorList(this.operatorList);
}
if (this.running) {
return;
}
this._continue();
},
_continue: function InternalRenderTask__continue() {
this.running = true;
if (this.cancelled) {
return;
}
if (this.params.continueCallback) {
this.params.continueCallback(this._next.bind(this));
} else {
this._next();
}
},
_next: function InternalRenderTask__next() {
if (this.cancelled) {
return;
}
this.operatorListIdx = this.gfx.executeOperatorList(this.operatorList,
this.operatorListIdx,
this._continue.bind(this),
this.stepper);
if (this.operatorListIdx === this.operatorList.fnArray.length) {
this.running = false;
if (this.operatorList.lastChunk) {
this.gfx.endDrawing();
this.callback();
}
}
}
};
return InternalRenderTask;
})();

2
src/canvas.js
View File

@ -670,7 +670,7 @@ var CanvasGraphics = (function CanvasGraphicsClosure() {
this.setFlatness(value);
break;
case 'Font':
this.setFont(state[1], state[2]);
this.setFont(value[0], value[1]);
break;
case 'CA':
this.current.strokeAlpha = state[1];

44
src/core.js
View File

@ -18,7 +18,8 @@
isArrayBuffer, isDict, isName, isStream, isString, Lexer,
Linearization, NullStream, PartialEvaluator, shadow, Stream,
StreamsSequenceStream, stringToPDFString, TODO, Util, warn, XRef,
MissingDataException, Promise, Annotation, ObjectLoader */
MissingDataException, Promise, Annotation, ObjectLoader, OperatorList
*/
'use strict';
@ -183,33 +184,35 @@ var Page = (function PageClosure() {
dataPromises.then(function(data) {
var contentStream = data[0];
partialEvaluator.getOperatorList(contentStream, self.resources).then(
function(data) {
pageListPromise.resolve(data);
},
reject
);
var opList = new OperatorList(handler, self.pageIndex);
handler.send('StartRenderPage', {
transparency: partialEvaluator.hasBlendModes(self.resources),
pageIndex: self.pageIndex
});
partialEvaluator.getOperatorList(contentStream, self.resources, opList);
pageListPromise.resolve(opList);
});
var annotationsPromise = pdfManager.ensure(this, 'annotations');
Promise.all([pageListPromise, annotationsPromise]).then(function(datas) {
var pageData = datas[0];
var pageQueue = pageData.queue;
var pageOpList = datas[0];
var annotations = datas[1];
if (annotations.length === 0) {
PartialEvaluator.optimizeQueue(pageQueue);
promise.resolve(pageData);
PartialEvaluator.optimizeQueue(pageOpList);
pageOpList.flush(true);
promise.resolve(pageOpList);
return;
}
var dependencies = pageData.dependencies;
var annotationsReadyPromise = Annotation.appendToOperatorList(
annotations, pageQueue, pdfManager, dependencies, partialEvaluator);
annotations, pageOpList, pdfManager, partialEvaluator);
annotationsReadyPromise.then(function () {
PartialEvaluator.optimizeQueue(pageQueue);
promise.resolve(pageData);
PartialEvaluator.optimizeQueue(pageOpList);
pageOpList.flush(true);
promise.resolve(pageOpList);
}, reject);
}, reject);
@ -244,12 +247,9 @@ var Page = (function PageClosure() {
self.pageIndex, 'p' + self.pageIndex + '_',
self.idCounters);
partialEvaluator.getTextContent(
contentStream, self.resources).then(function(bidiTexts) {
textContentPromise.resolve({
bidiTexts: bidiTexts
});
});
var bidiTexts = partialEvaluator.getTextContent(contentStream,
self.resources);
textContentPromise.resolve(bidiTexts);
});
return textContentPromise;

679
src/evaluator.js
View File

@ -153,24 +153,51 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
var TILING_PATTERN = 1, SHADING_PATTERN = 2;
function createOperatorList(fnArray, argsArray, dependencies) {
return {
queue: {
fnArray: fnArray || [],
argsArray: argsArray || []
},
dependencies: dependencies || {}
};
}
PartialEvaluator.prototype = {
hasBlendModes: function PartialEvaluator_hasBlendModes(resources) {
if (!isDict(resources)) {
return false;
}
var nodes = [resources];
while (nodes.length) {
var node = nodes.shift();
// First check the current resources for blend modes.
var graphicStates = node.get('ExtGState');
if (isDict(graphicStates)) {
graphicStates = graphicStates.getAll();
for (var key in graphicStates) {
var graphicState = graphicStates[key];
var bm = graphicState['BM'];
if (isName(bm) && bm.name !== 'Normal') {
return true;
}
}
}
// Descend into the XObjects to look for more resources and blend modes.
var xObjects = node.get('XObject');
if (!isDict(xObjects)) {
continue;
}
xObjects = xObjects.getAll();
for (var key in xObjects) {
var xObject = xObjects[key];
if (!isStream(xObject)) {
continue;
}
var xResources = xObject.dict.get('Resources');
if (isDict(xResources)) {
nodes.push(xResources);
}
}
}
return false;
},
buildFormXObject: function PartialEvaluator_buildFormXObject(resources,
xobj, smask) {
xobj, smask,
operatorList) {
var self = this;
var promise = new Promise();
var fnArray = [];
var argsArray = [];
var matrix = xobj.dict.get('Matrix');
var bbox = xobj.dict.get('BBox');
@ -191,44 +218,22 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
// There is also a group colorspace, but since we put everything in
// RGB I'm not sure we need it.
}
fnArray.push('beginGroup');
argsArray.push([groupOptions]);
operatorList.addOp('beginGroup', [groupOptions]);
}
fnArray.push('paintFormXObjectBegin');
argsArray.push([matrix, bbox]);
operatorList.addOp('paintFormXObjectBegin', [matrix, bbox]);
// Pass in the current `queue` object. That means the `fnArray`
// and the `argsArray` in this scope is reused and new commands
// are added to them.
var opListPromise = this.getOperatorList(xobj,
xobj.dict.get('Resources') || resources);
opListPromise.then(function(data) {
var queue = data.queue;
var dependencies = data.dependencies;
Util.prependToArray(queue.fnArray, fnArray);
Util.prependToArray(queue.argsArray, argsArray);
self.insertDependencies(queue, dependencies);
this.getOperatorList(xobj, xobj.dict.get('Resources') || resources,
operatorList);
operatorList.addOp('paintFormXObjectEnd', []);
queue.fnArray.push('paintFormXObjectEnd');
queue.argsArray.push([]);
if (group) {
queue.fnArray.push('endGroup');
queue.argsArray.push([groupOptions]);
}
promise.resolve({
queue: queue,
dependencies: dependencies
});
});
return promise;
if (group) {
operatorList.addOp('endGroup', [groupOptions]);
}
},
buildPaintImageXObject: function PartialEvaluator_buildPaintImageXObject(
resources, image, inline) {
resources, image, inline, operatorList) {
var self = this;
var dict = image.dict;
var w = dict.get('Width', 'W');
@ -236,14 +241,9 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
if (PDFJS.maxImageSize !== -1 && w * h > PDFJS.maxImageSize) {
warn('Image exceeded maximum allowed size and was removed.');
return null;
return;
}
var dependencies = {};
var retData = {
dependencies: dependencies
};
var imageMask = dict.get('ImageMask', 'IM') || false;
if (imageMask) {
// This depends on a tmpCanvas beeing filled with the
@ -259,10 +259,11 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
var decode = dict.get('Decode', 'D');
var inverseDecode = !!decode && decode[0] > 0;
retData.fn = 'paintImageMaskXObject';
retData.args = [PDFImage.createMask(imgArray, width, height,
inverseDecode)];
return retData;
operatorList.addOp('paintImageMaskXObject',
[PDFImage.createMask(imgArray, width, height,
inverseDecode)]
);
return;
}
var softMask = dict.get('SMask', 'SM') || false;
@ -276,64 +277,53 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
var imageObj = new PDFImage(this.xref, resources, image,
inline, null, null);
var imgData = imageObj.getImageData();
retData.fn = 'paintInlineImageXObject';
retData.args = [imgData];
return retData;
operatorList.addOp('paintInlineImageXObject', [imgData]);
return;
}
// If there is no imageMask, create the PDFImage and a lot
// of image processing can be done here.
var uniquePrefix = this.uniquePrefix || '';
var objId = 'img_' + uniquePrefix + (++this.idCounters.obj);
dependencies[objId] = true;
retData.args = [objId, w, h];
operatorList.addDependency(objId);
var args = [objId, w, h];
if (!softMask && !mask && image instanceof JpegStream &&
image.isNativelySupported(this.xref, resources)) {
// These JPEGs don't need any more processing so we can just send it.
retData.fn = 'paintJpegXObject';
operatorList.addOp('paintJpegXObject', args);
this.handler.send(
'obj', [objId, this.pageIndex, 'JpegStream', image.getIR()]);
return retData;
return;
}
retData.fn = 'paintImageXObject';
PDFImage.buildImage(function(imageObj) {
var imgData = imageObj.getImageData();
self.handler.send('obj', [objId, self.pageIndex, 'Image', imgData]);
}, self.handler, self.xref, resources, image, inline);
return retData;
operatorList.addOp('paintImageXObject', args);
},
handleTilingType: function PartialEvaluator_handleTilingType(
fn, args, resources, pattern, patternDict) {
var self = this;
fn, args, resources, pattern, patternDict,
operatorList) {
// Create an IR of the pattern code.
var promise = new Promise();
var opListPromise = this.getOperatorList(pattern,
patternDict.get('Resources') || resources);
opListPromise.then(function(data) {
var opListData = createOperatorList([], [], data.dependencies);
var queue = opListData.queue;
// Add the dependencies that are required to execute the
// operatorList.
self.insertDependencies(queue, data.dependencies);
queue.fnArray.push(fn);
queue.argsArray.push(
TilingPattern.getIR(data.queue, patternDict, args));
promise.resolve(opListData);
});
return promise;
var tilingOpList = this.getOperatorList(pattern,
patternDict.get('Resources') || resources);
// Add the dependencies to the parent operator list so they are resolved
// before sub operator list is executed synchronously.
operatorList.addDependencies(tilingOpList.dependencies);
operatorList.addOp(fn, TilingPattern.getIR({
fnArray: tilingOpList.fnArray,
argsArray: tilingOpList.argsArray
}, patternDict, args));
},
handleSetFont: function PartialEvaluator_handleSetFont(
resources, fontArgs, font) {
resources, fontArgs, fontRef, operatorList) {
var promise = new Promise();
// TODO(mack): Not needed?
var fontName;
if (fontArgs) {
@ -341,69 +331,27 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
fontName = fontArgs[0].name;
}
var self = this;
var fontPromise = this.loadFont(fontName, font, this.xref, resources);
fontPromise.then(function(data) {
var font = data.font;
var loadedName = font.loadedName;
if (!font.sent) {
var fontData = font.translated.exportData();
var font = this.loadFont(fontName, fontRef, this.xref, resources,
operatorList);
var loadedName = font.loadedName;
if (!font.sent) {
var fontData = font.translated.exportData();
self.handler.send('commonobj', [
loadedName,
'Font',
fontData
]);
font.sent = true;
}
// Ensure the font is ready before the font is set
// and later on used for drawing.
// OPTIMIZE: This should get insert to the operatorList only once per
// page.
var fnArray = [];
var argsArray = [];
var queue = {
fnArray: fnArray,
argsArray: argsArray
};
var dependencies = data.dependencies;
dependencies[loadedName] = true;
self.insertDependencies(queue, dependencies);
if (fontArgs) {
fontArgs[0] = loadedName;
fnArray.push('setFont');
argsArray.push(fontArgs);
}
promise.resolve({
loadedName: loadedName,
queue: queue,
dependencies: dependencies
});
});
return promise;
},
insertDependencies: function PartialEvaluator_insertDependencies(
queue, dependencies) {
var fnArray = queue.fnArray;
var argsArray = queue.argsArray;
var depList = Object.keys(dependencies);
if (depList.length) {
fnArray.push('dependency');
argsArray.push(depList);
self.handler.send('commonobj', [
loadedName,
'Font',
fontData
]);
font.sent = true;
}
return loadedName;
},
setGState: function PartialEvaluator_setGState(resources, gState) {
setGState: function PartialEvaluator_setGState(resources, gState,
operatorList) {
var self = this;
var opListData = createOperatorList();
var queue = opListData.queue;
var fnArray = queue.fnArray;
var argsArray = queue.argsArray;
var dependencies = opListData.dependencies;
// TODO(mack): This should be rewritten so that this function returns
// what should be added to the queue during each iteration
function setGStateForKey(gStateObj, key, value) {
@ -422,21 +370,12 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
gStateObj.push([key, value]);
break;
case 'Font':
var promise = new Promise();
self.handleSetFont(resources, null, value[0]).then(function(data) {
var gState = ['Font', data.loadedName, value[1]];
promise.resolve({
gState: gState,
queue: data.queue,
dependencies: data.dependencies
});
});
gStateObj.push(['promise', promise]);
var loadedName = self.handleSetFont(resources, null, value[0],
operatorList);
operatorList.addDependency(loadedName);
gStateObj.push([key, [loadedName, value[1]]]);
break;
case 'BM':
if (!isName(value) || value.name !== 'Normal') {
queue.transparency = true;
}
gStateObj.push([key, value]);
break;
case 'SMask':
@ -477,47 +416,18 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
setGStateForKey(gStateObj, key, value);
}
var promises = [];
var indices = [];
for (var i = 0, n = gStateObj.length; i < n; ++i) {
var value = gStateObj[i];
if (value[0] === 'promise') {
promises.push(value[1]);
indices.push(i);
}
}
var promise = new Promise();
Promise.all(promises).then(function(datas) {
for (var i = 0, n = datas.length; i < n; ++i) {
var data = datas[i];
var index = indices[i];
gStateObj[index] = data.gState;
var subQueue = data.queue;
Util.concatenateToArray(fnArray, subQueue.fnArray);
Util.concatenateToArray(argsArray, subQueue.argsArray);
queue.transparency = subQueue.transparency || queue.transparency;
Util.extendObj(dependencies, data.dependencies);
}
fnArray.push('setGState');
argsArray.push([gStateObj]);
promise.resolve(opListData);
});
return promise;
operatorList.addOp('setGState', [gStateObj]);
},
loadFont: function PartialEvaluator_loadFont(fontName, font, xref,
resources) {
function errorFont(promise) {
promise.resolve({
font: {
translated: new ErrorFont('Font ' + fontName + ' is not available'),
loadedName: 'g_font_error'
},
dependencies: {}
});
return promise;
resources,
parentOperatorList) {
function errorFont() {
return {
translated: new ErrorFont('Font ' + fontName + ' is not available'),
loadedName: 'g_font_error'
};
}
var fontRef;
@ -530,20 +440,19 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
fontRef = fontRes.getRaw(fontName);
} else {
warn('fontRes not available');
return errorFont(new Promise());
return errorFont();
}
}
if (this.fontCache.has(fontRef)) {
return this.fontCache.get(fontRef);
}
var promise = new Promise();
this.fontCache.put(fontRef, promise);
font = xref.fetchIfRef(fontRef);
if (!isDict(font)) {
return errorFont(promise);
return errorFont();
}
this.fontCache.put(fontRef, font);
// keep track of each font we translated so the caller can
// load them asynchronously before calling display on a page
@ -562,55 +471,37 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
if (font.translated.loadCharProcs) {
var charProcs = font.get('CharProcs').getAll();
var fontResources = font.get('Resources') || resources;
var opListPromises = [];
var charProcKeys = Object.keys(charProcs);
var charProcOperatorList = {};
for (var i = 0, n = charProcKeys.length; i < n; ++i) {
var key = charProcKeys[i];
var glyphStream = charProcs[key];
opListPromises.push(
this.getOperatorList(glyphStream, fontResources));
}
Promise.all(opListPromises).then(function(datas) {
var charProcOperatorList = {};
var dependencies = {};
for (var i = 0, n = charProcKeys.length; i < n; ++i) {
var key = charProcKeys[i];
var data = datas[i];
charProcOperatorList[key] = data.queue;
Util.extendObj(dependencies, data.dependencies);
var operatorList = this.getOperatorList(glyphStream, fontResources);
charProcOperatorList[key] = operatorList.getIR();
if (!parentOperatorList) {
continue;
}
font.translated.charProcOperatorList = charProcOperatorList;
font.loaded = true;
promise.resolve({
font: font,
dependencies: dependencies
});
}.bind(this));
// Add the dependencies to the parent operator list so they are
// resolved before sub operator list is executed synchronously.
parentOperatorList.addDependencies(charProcOperatorList.dependencies);
}
font.translated.charProcOperatorList = charProcOperatorList;
font.loaded = true;
} else {
font.loaded = true;
promise.resolve({
font: font,
dependencies: {}
});
}
return promise;
return font;
},
getOperatorList: function PartialEvaluator_getOperatorList(stream,
resources) {
resources,
operatorList) {
var self = this;
var xref = this.xref;
var handler = this.handler;
var fnArray = [];
var argsArray = [];
var queue = {
transparency: false,
fnArray: fnArray,
argsArray: argsArray
};
var dependencies = {};
operatorList = operatorList || new OperatorList();
resources = resources || new Dict();
var xobjs = resources.get('XObject') || new Dict();
@ -621,6 +512,7 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
var promise = new Promise();
var args = [];
nextOp:
while (true) {
var obj = parser.getObj();
@ -677,10 +569,10 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
var typeNum = dict.get('PatternType');
if (typeNum == TILING_PATTERN) {
var patternPromise = self.handleTilingType(
fn, args, resources, pattern, dict);
fn = 'promise';
args = [patternPromise];
self.handleTilingType(fn, args, resources, pattern, dict,
operatorList);
args = [];
continue;
} else if (typeNum == SHADING_PATTERN) {
var shading = dict.get('Shading');
var matrix = dict.get('Matrix');
@ -706,37 +598,28 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
);
if ('Form' == type.name) {
fn = 'promise';
args = [self.buildFormXObject(resources, xobj)];
self.buildFormXObject(resources, xobj, null, operatorList);
args = [];
continue;
} else if ('Image' == type.name) {
var data = self.buildPaintImageXObject(
resources, xobj, false);
if (!data) {
args = [];
continue;
}
Util.extendObj(dependencies, data.dependencies);
self.insertDependencies(queue, data.dependencies);
fn = data.fn;
args = data.args;
self.buildPaintImageXObject(resources, xobj, false,
operatorList);
args = [];
continue;
} else {
error('Unhandled XObject subtype ' + type.name);
}
}
} else if (cmd == 'Tf') { // eagerly collect all fonts
fn = 'promise';
args = [self.handleSetFont(resources, args)];
var loadedName = self.handleSetFont(resources, args, null,
operatorList);
operatorList.addDependency(loadedName);
fn = 'setFont';
args[0] = loadedName;
} else if (cmd == 'EI') {
var data = self.buildPaintImageXObject(
resources, args[0], true);
if (!data) {
args = [];
continue;
}
Util.extendObj(dependencies, data.dependencies);
self.insertDependencies(queue, data.dependencies);
fn = data.fn;
args = data.args;
self.buildPaintImageXObject(resources, args[0], true, operatorList);
args = [];
continue;
}
switch (fn) {
@ -768,12 +651,12 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
break;
var gState = extGState.get(dictName.name);
fn = 'promise';
args = [self.setGState(resources, gState)];
self.setGState(resources, gState, operatorList);
args = [];
continue nextOp;
} // switch
fnArray.push(fn);
argsArray.push(args);
operatorList.addOp(fn, args);
args = [];
parser.saveState();
} else if (obj !== null && obj !== undefined) {
@ -782,163 +665,86 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
}
}
var subQueuePromises = [];
for (var i = 0; i < fnArray.length; ++i) {
if (fnArray[i] === 'promise') {
subQueuePromises.push(argsArray[i][0]);
}
}
Promise.all(subQueuePromises).then(function(datas) {
// TODO(mack): Optimize by using repositioning elements
// in original queue rather than creating new queue
for (var i = 0, n = datas.length; i < n; ++i) {
var data = datas[i];
var subQueue = data.queue;
queue.transparency = subQueue.transparency || queue.transparency;
Util.extendObj(dependencies, data.dependencies);
}
var newFnArray = [];
var newArgsArray = [];
var currOffset = 0;
var subQueueIdx = 0;
for (var i = 0, n = fnArray.length; i < n; ++i) {
var offset = i + currOffset;
if (fnArray[i] === 'promise') {
var data = datas[subQueueIdx++];
var subQueue = data.queue;
var subQueueFnArray = subQueue.fnArray;
var subQueueArgsArray = subQueue.argsArray;
for (var j = 0, nn = subQueueFnArray.length; j < nn; ++j) {
newFnArray[offset + j] = subQueueFnArray[j];
newArgsArray[offset + j] = subQueueArgsArray[j];
}
currOffset += subQueueFnArray.length - 1;
} else {
newFnArray[offset] = fnArray[i];
newArgsArray[offset] = argsArray[i];
}
}
promise.resolve({
queue: {
fnArray: newFnArray,
argsArray: newArgsArray,
transparency: queue.transparency
},
dependencies: dependencies
});
});
return promise;
return operatorList;
},
getTextContent: function PartialEvaluator_getTextContent(
stream, resources) {
stream, resources, state) {
var bidiTexts;
var SPACE_FACTOR = 0.35;
var MULTI_SPACE_FACTOR = 1.5;
if (!state) {
bidiTexts = [];
state = {
bidiTexts: bidiTexts
};
} else {
bidiTexts = state.bidiTexts;
}
var self = this;
var xref = this.xref;
var statePromise = new Promise();
function handleSetFont(fontName, fontRef, resources) {
var promise = new Promise();
self.loadFont(fontName, fontRef, self.xref, resources).then(
function(data) {
promise.resolve(data.font.translated);
}
);
return promise;
function handleSetFont(fontName, fontRef) {
return self.loadFont(fontName, fontRef, xref, resources, null);
}
function getBidiText(str, startLevel, vertical) {
if (str) {
return PDFJS.bidi(str, -1, vertical);
}
}
resources = this.xref.fetchIfRef(resources) || new Dict();
resources = xref.fetchIfRef(resources) || new Dict();
// The xobj is parsed iff it's needed, e.g. if there is a `DO` cmd.
var xobjs = null;
var parser = new Parser(new Lexer(stream), false);
var res = resources;
var args = [], obj;
var chunkPromises = [];
var fontPromise;
var args = [];
while (true) {
var obj = parser.getObj();
if (isEOF(obj)) {
break;
}
var chunk = '';
var font = null;
while (!isEOF(obj = parser.getObj())) {
if (isCmd(obj)) {
var cmd = obj.cmd;
switch (cmd) {
// TODO: Add support for SAVE/RESTORE and XFORM here.
case 'Tf':
fontPromise = handleSetFont(args[0].name, null, resources);
//.translated;
font = handleSetFont(args[0].name).translated;
break;
case 'TJ':
var chunkPromise = new Promise();
chunkPromises.push(chunkPromise);
fontPromise.then(function(items, chunkPromise, font) {
var chunk = '';
for (var j = 0, jj = items.length; j < jj; j++) {
if (typeof items[j] === 'string') {
chunk += fontCharsToUnicode(items[j], font);
} else if (items[j] < 0 && font.spaceWidth > 0) {
var fakeSpaces = -items[j] / font.spaceWidth;
if (fakeSpaces > MULTI_SPACE_FACTOR) {
fakeSpaces = Math.round(fakeSpaces);
while (fakeSpaces--) {
chunk += ' ';
}
} else if (fakeSpaces > SPACE_FACTOR) {
var items = args[0];
for (var j = 0, jj = items.length; j < jj; j++) {
if (typeof items[j] === 'string') {
chunk += fontCharsToUnicode(items[j], font);
} else if (items[j] < 0 && font.spaceWidth > 0) {
var fakeSpaces = -items[j] / font.spaceWidth;
if (fakeSpaces > MULTI_SPACE_FACTOR) {
fakeSpaces = Math.round(fakeSpaces);
while (fakeSpaces--) {
chunk += ' ';
}
} else if (fakeSpaces > SPACE_FACTOR) {
chunk += ' ';
}
}
chunkPromise.resolve(
getBidiText(chunk, -1, font.vertical));
}.bind(null, args[0], chunkPromise));
}
break;
case 'Tj':
var chunkPromise = new Promise();
chunkPromises.push(chunkPromise);
fontPromise.then(function(charCodes, chunkPromise, font) {
var chunk = fontCharsToUnicode(charCodes, font);
chunkPromise.resolve(
getBidiText(chunk, -1, font.vertical));
}.bind(null, args[0], chunkPromise));
chunk += fontCharsToUnicode(args[0], font);
break;
case '\'':
// For search, adding a extra white space for line breaks
// would be better here, but that causes too much spaces in
// the text-selection divs.
var chunkPromise = new Promise();
chunkPromises.push(chunkPromise);
fontPromise.then(function(charCodes, chunkPromise, font) {
var chunk = fontCharsToUnicode(charCodes, font);
chunkPromise.resolve(
getBidiText(chunk, -1, font.vertical));
}.bind(null, args[0], chunkPromise));
// For search, adding a extra white space for line breaks would be
// better here, but that causes too much spaces in the
// text-selection divs.
chunk += fontCharsToUnicode(args[0], font);
break;
case '"':
// Note comment in "'"
var chunkPromise = new Promise();
chunkPromises.push(chunkPromise);
fontPromise.then(function(charCodes, chunkPromise, font) {
var chunk = fontCharsToUnicode(charCodes, font);
chunkPromise.resolve(
getBidiText(chunk, -1, font.vertical));
}.bind(null, args[2], chunkPromise));
chunk += fontCharsToUnicode(args[2], font);
break;
case 'Do':
// Set the chunk such that the following if won't add something
// to the state.
chunk = '';
if (args[0].code) {
break;
}
@ -951,8 +757,7 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
var xobj = xobjs.get(name);
if (!xobj)
break;
assertWellFormed(isStream(xobj),
'XObject should be a stream');
assertWellFormed(isStream(xobj), 'XObject should be a stream');
var type = xobj.dict.get('Subtype');
assertWellFormed(
@ -963,11 +768,11 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
if ('Form' !== type.name)
break;
var chunkPromise = self.getTextContent(
state = this.getTextContent(
xobj,
xobj.dict.get('Resources') || resources
xobj.dict.get('Resources') || resources,
state
);
chunkPromises.push(chunkPromise);
break;
case 'gs':
var dictName = args[0];
@ -980,37 +785,27 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
for (var i = 0; i < gsState.length; i++) {
if (gsState[i] === 'Font') {
fontPromise = handleSetFont(
args[0].name, null, resources);
font = handleSetFont(args[0].name).translated;
}
}
break;
} // switch
if (chunk !== '') {
var bidiText = PDFJS.bidi(chunk, -1, font.vertical);
bidiTexts.push(bidiText);
chunk = '';
}
args = [];
parser.saveState();
} else if (obj !== null && obj !== undefined) {
assertWellFormed(args.length <= 33, 'Too many arguments');
args.push(obj);
}
} // while
Promise.all(chunkPromises).then(function(datas) {
var bidiTexts = [];
for (var i = 0, n = datas.length; i < n; ++i) {
var bidiText = datas[i];
if (!bidiText) {
continue;
} else if (isArray(bidiText)) {
Util.concatenateToArray(bidiTexts, bidiText);
} else {
bidiTexts.push(bidiText);
}
}
statePromise.resolve(bidiTexts);
});
return statePromise;
return state;
},
extractDataStructures: function
@ -1639,6 +1434,74 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
return PartialEvaluator;
})();
var OperatorList = (function OperatorListClosure() {
var CHUNK_SIZE = 100;
function OperatorList(messageHandler, pageIndex) {
this.messageHandler = messageHandler;
this.fnArray = [];
this.argsArray = [];
this.dependencies = {},
this.pageIndex = pageIndex;
}
OperatorList.prototype = {
addOp: function(fn, args) {
this.fnArray.push(fn);
this.argsArray.push(args);
if (this.messageHandler && this.fnArray.length >= CHUNK_SIZE) {
this.flush();
}
},
addDependency: function(dependency) {
if (dependency in this.dependencies) {
return;
}
this.dependencies[dependency] = true;
this.addOp('dependency', [dependency]);
},
addDependencies: function(dependencies) {
for (var key in dependencies) {
this.addDependency(key);
}
},
addOpList: function(opList) {
Util.concatenateToArray(this.fnArray, opList.fnArray);
Util.concatenateToArray(this.argsArray, opList.argsArray);
Util.extendObj(this.dependencies, opList.dependencies);
},
getIR: function() {
return {
fnArray: this.fnArray,
argsArray: this.argsArray
};
},
flush: function(lastChunk) {
PartialEvaluator.optimizeQueue(this);
this.messageHandler.send('RenderPageChunk', {
operatorList: {
fnArray: this.fnArray,
argsArray: this.argsArray,
lastChunk: lastChunk
},
pageIndex: this.pageIndex
});
this.dependencies = [];
this.fnArray = [];
this.argsArray = [];
}
};
return OperatorList;
})();
var EvalState = (function EvalStateClosure() {
function EvalState() {
// Are soft masks and alpha values shapes or opacities?

4
src/util.js
View File

@ -903,14 +903,14 @@ var StatTimer = (function StatTimerClosure() {
if (!this.enabled)
return;
if (name in this.started)
throw 'Timer is already running for ' + name;
warn('Timer is already running for ' + name);
this.started[name] = Date.now();
},
timeEnd: function StatTimer_timeEnd(name) {
if (!this.enabled)
return;
if (!(name in this.started))
throw 'Timer has not been started for ' + name;
warn('Timer has not been started for ' + name);
this.times.push({
'name': name,
'start': this.started[name],

22
src/worker.js
View File

@ -398,31 +398,11 @@ var WorkerMessageHandler = {
var pageNum = data.pageIndex + 1;
var start = Date.now();
// Pre compile the pdf page and fetch the fonts/images.
page.getOperatorList(handler).then(function(opListData) {
var operatorList = opListData.queue;
var dependency = Object.keys(opListData.dependencies);
// The following code does quite the same as
// Page.prototype.startRendering, but stops at one point and sends the
// result back to the main thread.
page.getOperatorList(handler).then(function(operatorList) {
log('page=%d - getOperatorList: time=%dms, len=%d', pageNum,
Date.now() - start, operatorList.fnArray.length);
// Filter the dependecies for fonts.
var fonts = {};
for (var i = 0, ii = dependency.length; i < ii; i++) {
var dep = dependency[i];
if (dep.indexOf('g_font_') === 0) {
fonts[dep] = true;
}
}
handler.send('RenderPage', {
pageIndex: data.pageIndex,
operatorList: operatorList,
depFonts: Object.keys(fonts)
});
}, function(e) {
var minimumStackMessage =

146
test/unit/evaluator_spec.js
View File

@ -36,14 +36,11 @@ describe('evaluator', function() {
new XrefMock(), new HandlerMock(),
'prefix');
var stream = new StringStream('qTT');
var promise = evaluator.getOperatorList(stream, new ResourcesMock());
promise.then(function(data) {
var result = data.queue;
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
expect(result.fnArray.length).toEqual(1);
expect(result.fnArray[0]).toEqual('save');
expect(result.argsArray[0].length).toEqual(0);
});
var result = evaluator.getOperatorList(stream, new ResourcesMock());
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
expect(result.fnArray.length).toEqual(1);
expect(result.fnArray[0]).toEqual('save');
expect(result.argsArray[0].length).toEqual(0);
});
it('should handle one operations', function() {
@ -51,13 +48,10 @@ describe('evaluator', function() {
new XrefMock(), new HandlerMock(),
'prefix');
var stream = new StringStream('Q');
var promise = evaluator.getOperatorList(stream, new ResourcesMock());
promise.then(function(data) {
var result = data.queue;
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
expect(result.fnArray.length).toEqual(1);
expect(result.fnArray[0]).toEqual('restore');
});
var result = evaluator.getOperatorList(stream, new ResourcesMock());
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
expect(result.fnArray.length).toEqual(1);
expect(result.fnArray[0]).toEqual('restore');
});
it('should handle two glued operations', function() {
@ -67,14 +61,11 @@ describe('evaluator', function() {
var resources = new ResourcesMock();
resources.Res1 = {};
var stream = new StringStream('/Res1 DoQ');
var promise = evaluator.getOperatorList(stream, resources);
promise.then(function(data) {
var result = data.queue;
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
expect(result.fnArray.length).toEqual(2);
expect(result.fnArray[0]).toEqual('paintXObject');
expect(result.fnArray[1]).toEqual('restore');
});
var result = evaluator.getOperatorList(stream, resources);
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
expect(result.fnArray.length).toEqual(2);
expect(result.fnArray[0]).toEqual('paintXObject');
expect(result.fnArray[1]).toEqual('restore');
});
it('should handle tree glued operations', function() {
@ -82,15 +73,12 @@ describe('evaluator', function() {
new XrefMock(), new HandlerMock(),
'prefix');
var stream = new StringStream('qqq');
var promise = evaluator.getOperatorList(stream, new ResourcesMock());
promise.then(function(data) {
var result = data.queue;
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
expect(result.fnArray.length).toEqual(3);
expect(result.fnArray[0]).toEqual('save');
expect(result.fnArray[1]).toEqual('save');
expect(result.fnArray[2]).toEqual('save');
});
var result = evaluator.getOperatorList(stream, new ResourcesMock());
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
expect(result.fnArray.length).toEqual(3);
expect(result.fnArray[0]).toEqual('save');
expect(result.fnArray[1]).toEqual('save');
expect(result.fnArray[2]).toEqual('save');
});
it('should handle three glued operations #2', function() {
@ -100,15 +88,12 @@ describe('evaluator', function() {
var resources = new ResourcesMock();
resources.Res1 = {};
var stream = new StringStream('B*Bf*');
var promise = evaluator.getOperatorList(stream, resources);
promise.then(function(data) {
var result = data.queue;
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
expect(result.fnArray.length).toEqual(3);
expect(result.fnArray[0]).toEqual('eoFillStroke');
expect(result.fnArray[1]).toEqual('fillStroke');
expect(result.fnArray[2]).toEqual('eoFill');
});
var result = evaluator.getOperatorList(stream, resources);
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
expect(result.fnArray.length).toEqual(3);
expect(result.fnArray[0]).toEqual('eoFillStroke');
expect(result.fnArray[1]).toEqual('fillStroke');
expect(result.fnArray[2]).toEqual('eoFill');
});
it('should handle glued operations and operands', function() {
@ -116,17 +101,14 @@ describe('evaluator', function() {
new XrefMock(), new HandlerMock(),
'prefix');
var stream = new StringStream('q5 Ts');
var promise = evaluator.getOperatorList(stream, new ResourcesMock());
promise.then(function(data) {
var result = data.queue;
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
expect(result.fnArray.length).toEqual(2);
expect(result.fnArray[0]).toEqual('save');
expect(result.fnArray[1]).toEqual('setTextRise');
expect(result.argsArray.length).toEqual(2);
expect(result.argsArray[1].length).toEqual(1);
expect(result.argsArray[1][0]).toEqual(5);
});
var result = evaluator.getOperatorList(stream, new ResourcesMock());
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
expect(result.fnArray.length).toEqual(2);
expect(result.fnArray[0]).toEqual('save');
expect(result.fnArray[1]).toEqual('setTextRise');
expect(result.argsArray.length).toEqual(2);
expect(result.argsArray[1].length).toEqual(1);
expect(result.argsArray[1][0]).toEqual(5);
});
it('should handle glued operations and literals', function() {
@ -134,21 +116,18 @@ describe('evaluator', function() {
new XrefMock(), new HandlerMock(),
'prefix');
var stream = new StringStream('trueifalserinullq');
var promise = evaluator.getOperatorList(stream, new ResourcesMock());
promise.then(function(data) {
var result = data.queue;
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
expect(result.fnArray.length).toEqual(3);
expect(result.fnArray[0]).toEqual('setFlatness');
expect(result.fnArray[1]).toEqual('setRenderingIntent');
expect(result.fnArray[2]).toEqual('save');
expect(result.argsArray.length).toEqual(3);
expect(result.argsArray[0].length).toEqual(1);
expect(result.argsArray[0][0]).toEqual(true);
expect(result.argsArray[1].length).toEqual(1);
expect(result.argsArray[1][0]).toEqual(false);
expect(result.argsArray[2].length).toEqual(0);
});
var result = evaluator.getOperatorList(stream, new ResourcesMock());
expect(!!result.fnArray && !!result.argsArray).toEqual(true);
expect(result.fnArray.length).toEqual(3);
expect(result.fnArray[0]).toEqual('setFlatness');
expect(result.fnArray[1]).toEqual('setRenderingIntent');
expect(result.fnArray[2]).toEqual('save');
expect(result.argsArray.length).toEqual(3);
expect(result.argsArray[0].length).toEqual(1);
expect(result.argsArray[0][0]).toEqual(true);
expect(result.argsArray[1].length).toEqual(1);
expect(result.argsArray[1][0]).toEqual(false);
expect(result.argsArray[2].length).toEqual(0);
});
});
@ -159,39 +138,30 @@ describe('evaluator', function() {
'prefix');
var stream = new StringStream('5 1 d0');
console.log('here!');
var promise = evaluator.getOperatorList(stream, new ResourcesMock());
promise.then(function(data) {
var result = data.queue;
expect(result.argsArray[0][0]).toEqual(5);
expect(result.argsArray[0][1]).toEqual(1);
expect(result.fnArray[0]).toEqual('setCharWidth');
});
var result = evaluator.getOperatorList(stream, new ResourcesMock());
expect(result.argsArray[0][0]).toEqual(5);
expect(result.argsArray[0][1]).toEqual(1);
expect(result.fnArray[0]).toEqual('setCharWidth');
});
it('should execute if too many arguments', function() {
var evaluator = new PartialEvaluator(new PdfManagerMock(),
new XrefMock(), new HandlerMock(),
'prefix');
var stream = new StringStream('5 1 4 d0');
var promise = evaluator.getOperatorList(stream, new ResourcesMock());
promise.then(function(data) {
var result = data.queue;
expect(result.argsArray[0][0]).toEqual(5);
expect(result.argsArray[0][1]).toEqual(1);
expect(result.argsArray[0][2]).toEqual(4);
expect(result.fnArray[0]).toEqual('setCharWidth');
});
var result = evaluator.getOperatorList(stream, new ResourcesMock());
expect(result.argsArray[0][0]).toEqual(5);
expect(result.argsArray[0][1]).toEqual(1);
expect(result.argsArray[0][2]).toEqual(4);
expect(result.fnArray[0]).toEqual('setCharWidth');
});
it('should skip if too few arguments', function() {
var evaluator = new PartialEvaluator(new PdfManagerMock(),
new XrefMock(), new HandlerMock(),
'prefix');
var stream = new StringStream('5 d0');
var promise = evaluator.getOperatorList(stream, new ResourcesMock());
promise.then(function(data) {
var result = data.queue;
expect(result.argsArray).toEqual([]);
expect(result.fnArray).toEqual([]);
});
var result = evaluator.getOperatorList(stream, new ResourcesMock());
expect(result.argsArray).toEqual([]);
expect(result.fnArray).toEqual([]);
});
});
});

2
test/unit/unit_test.html
View File

@ -15,8 +15,8 @@
<script type="text/javascript" src="../../src/chunked_stream.js"></script>
<script type="text/javascript" src="../../src/pdf_manager.js"></script>
<script type="text/javascript" src="../../src/core.js"></script>
<script type="text/javascript" src="../../src/api.js"></script>
<script type="text/javascript" src="../../src/util.js"></script>
<script type="text/javascript" src="../../src/api.js"></script>
<script type="text/javascript" src="../../src/canvas.js"></script>
<script type="text/javascript" src="../../src/obj.js"></script>
<script type="text/javascript" src="../../src/annotation.js"></script>

35
web/debugger.js
View File

@ -220,26 +220,26 @@ var StepperManager = (function StepperManagerClosure() {
// The stepper for each page's IRQueue.
var Stepper = (function StepperClosure() {
// Shorter way to create element and optionally set textContent.
function c(tag, textContent) {
var d = document.createElement(tag);
if (textContent)
d.textContent = textContent;
return d;
}
function Stepper(panel, pageIndex, initialBreakPoints) {
this.panel = panel;
this.len = 0;
this.breakPoint = 0;
this.nextBreakPoint = null;
this.pageIndex = pageIndex;
this.breakPoints = initialBreakPoints;
this.currentIdx = -1;
this.operatorListIdx = 0;
}
Stepper.prototype = {
init: function init(IRQueue) {
// Shorter way to create element and optionally set textContent.
function c(tag, textContent) {
var d = document.createElement(tag);
if (textContent)
d.textContent = textContent;
return d;
}
init: function init() {
var panel = this.panel;
this.len = IRQueue.fnArray.length;
var content = c('div', 'c=continue, s=step');
var table = c('table');
content.appendChild(table);
@ -250,15 +250,18 @@ var Stepper = (function StepperClosure() {
headerRow.appendChild(c('th', 'Idx'));
headerRow.appendChild(c('th', 'fn'));
headerRow.appendChild(c('th', 'args'));
panel.appendChild(content);
this.table = table;
},
updateOperatorList: function updateOperatorList(operatorList) {
var self = this;
for (var i = 0; i < IRQueue.fnArray.length; i++) {
for (var i = this.operatorListIdx; i < operatorList.fnArray.length; i++) {
var line = c('tr');
line.className = 'line';
line.dataset.idx = i;
table.appendChild(line);
this.table.appendChild(line);
var checked = this.breakPoints.indexOf(i) != -1;
var args = IRQueue.argsArray[i] ? IRQueue.argsArray[i] : [];
var args = operatorList.argsArray[i] ? operatorList.argsArray[i] : [];
var breakCell = c('td');
var cbox = c('input');
@ -278,11 +281,9 @@ var Stepper = (function StepperClosure() {
breakCell.appendChild(cbox);
line.appendChild(breakCell);
line.appendChild(c('td', i.toString()));
line.appendChild(c('td', IRQueue.fnArray[i]));
line.appendChild(c('td', operatorList.fnArray[i]));
line.appendChild(c('td', args.join(', ')));
}
panel.appendChild(content);
var self = this;
},
getNextBreakPoint: function getNextBreakPoint() {
this.breakPoints.sort(function(a, b) { return a - b; });

22
web/viewer.js
View File

@ -1553,8 +1553,12 @@ var PageView = function pageView(container, id, scale,
};
this.update = function pageViewUpdate(scale, rotation) {
this.renderingState = RenderingStates.INITIAL;
if (this.renderTask) {
this.renderTask.cancel();
this.renderTask = null;
}
this.resume = null;
this.renderingState = RenderingStates.INITIAL;
if (typeof rotation !== 'undefined') {
this.rotation = rotation;
@ -1818,13 +1822,9 @@ var PageView = function pageView(container, id, scale,
// Rendering area
var self = this;
var renderingWasReset = false;
function pageViewDrawCallback(error) {
if (renderingWasReset) {
return;
}
self.renderingState = RenderingStates.FINISHED;
self.renderTask = null;
if (self.loadingIconDiv) {
div.removeChild(self.loadingIconDiv);
@ -1874,12 +1874,6 @@ var PageView = function pageView(container, id, scale,
viewport: this.viewport,
textLayer: textLayer,
continueCallback: function pdfViewcContinueCallback(cont) {
if (self.renderingState === RenderingStates.INITIAL) {
// The page update() was called, we just need to abort any rendering.
renderingWasReset = true;
return;
}
if (PDFView.highestPriorityPage !== 'page' + self.id) {
self.renderingState = RenderingStates.PAUSED;
self.resume = function resumeCallback() {
@ -1891,7 +1885,9 @@ var PageView = function pageView(container, id, scale,
cont();
}
};
this.pdfPage.render(renderContext).then(
this.renderTask = this.pdfPage.render(renderContext);
this.renderTask.then(
function pdfPageRenderCallback() {
pageViewDrawCallback(null);
},