Merge branch 'master' of https://github.com/andreasgal/pdf.js.git into hacks

Conflicts:
	fonts.js

README.md

@@ -9,9 +9,14 @@ yet to integrate it into Firefox. We will explore that possibility once
 pdf.js is production ready. Until then we aim to publish a Firefox
 PDF reader extension powered by pdf.js.
 
+Our demo site is here:
+
+  http://andreasgal.github.com/pdf.js/
+
 You can read more about pdf.js here:
 
   http://andreasgal.com/2011/06/15/pdf-js/
+
   http://blog.mozilla.com/cjones/2011/06/15/overview-of-pdf-js-guts/
 
 follow us on twitter: @pdfjs

multi_page_viewer.js

@@ -43,12 +43,12 @@ var PDFViewer = {
   lastPagesDrawn: [],
   
   visiblePages: function() {
-    const pageBottomMargin = 20;
+    const pageBottomMargin = 10;
     var windowTop = window.pageYOffset;
     var windowBottom = window.pageYOffset + window.innerHeight;
 
     var pageHeight, page;
-    var i, n = PDFViewer.numberOfPages, currentHeight = 0;
+    var i, n = PDFViewer.numberOfPages, currentHeight = pageBottomMargin;
     for (i = 1; i <= n; i++) {
       var page = PDFViewer.pdf.getPage(i);
       pageHeight = PDFViewer.pageHeight(page) + pageBottomMargin;
@@ -130,14 +130,7 @@ var PDFViewer = {
       var fonts = [];
       page.compile(gfx, fonts);
 
-      var loadFont = function() {
-        if (!FontLoader.bind(fonts)) {
-          pageTimeout = window.setTimeout(loadFont, 10);
-          return;
-        }
-        page.display(gfx);
-      }
-      loadFont();
+      FontLoader.bind(fonts, function() { page.display(gfx); });
     }
   },
   
@@ -197,17 +190,10 @@ var PDFViewer = {
       var fonts = [];
       page.compile(gfx, fonts);
 
-      var loadFont = function() {
-        if (!FontLoader.bind(fonts)) {
-          pageTimeout = window.setTimeout(loadFont, 10);
-          return;
-        }
-        page.display(gfx);
-      }
-      loadFont();
+      FontLoader.bind(fonts, function() { page.display(gfx); });
     }
   },
-  
+
   changeScale: function(num) {
     while (PDFViewer.element.hasChildNodes()) {
       PDFViewer.element.removeChild(PDFViewer.element.firstChild);

pdf.js

@@ -3266,7 +3266,6 @@ var CanvasExtraState = (function() {
         this.fontSize = 0;
         this.textMatrix = IDENTITY_MATRIX;
         this.leading = 0;
-        this.colorSpace = null;
         // Current point (in user coordinates)
         this.x = 0;
         this.y = 0;
@@ -3277,6 +3276,9 @@ var CanvasExtraState = (function() {
         this.charSpace = 0;
         this.wordSpace = 0;
         this.textHScale = 100;
+        // Color spaces
+        this.fillColorSpace = null;
+        this.strokeColorSpace = null;
     }
     constructor.prototype = {
     };
@@ -3404,7 +3406,7 @@ var CanvasGraphics = (function() {
             BX: "beginCompat",
             EX: "endCompat",
         },
-      
+
         translateFont: function(fontDict, xref, resources) {
             var fd = fontDict.get("FontDescriptor");
             if (!fd)
@@ -3544,7 +3546,8 @@ var CanvasGraphics = (function() {
                 capHeight: descriptor.get("CapHeight"),
                 flags: descriptor.get("Flags"),
                 italicAngle: descriptor.get("ItalicAngle"),
-                fixedPitch: false
+                fixedPitch: false,
+                textMatrix: IDENTITY_MATRIX
             };
 
             return {
@@ -3869,6 +3872,11 @@ var CanvasGraphics = (function() {
             } else {
                 text = Fonts.charsToUnicode(text);
                 this.ctx.translate(this.current.x, -1 * this.current.y);
+
+                var font = Fonts.lookup(this.current.fontName);
+                if (font)
+                  this.ctx.transform.apply(this.ctx, font.properties.textMatrix);
+
                 this.ctx.fillText(text, 0, 0);
                 this.current.x += Fonts.measureText(text);
             }
@@ -3911,51 +3919,36 @@ var CanvasGraphics = (function() {
 
         // Color
         setStrokeColorSpace: function(space) {
-            // TODO real impl
+            this.current.strokeColorSpace = 
+                ColorSpace.parse(space, this.xref, this.res);
         },
         setFillColorSpace: function(space) {
-            // TODO real impl
-            if (space.name === "Pattern")
-                this.current.colorSpace = "Pattern";
-            else
-                this.current.colorSpace = "DeviceRGB";
+            this.current.fillColorSpace = 
+                ColorSpace.parse(space, this.xref, this.res);
         },
         setStrokeColor: function(/*...*/) {
-            // TODO real impl
-            if (1 === arguments.length) {
-                this.setStrokeGray.apply(this, arguments);
-            } else if (3 === arguments.length) {
-                this.setStrokeRGBColor.apply(this, arguments);
-            } else if (4 === arguments.length) {
-                this.setStrokeCMYKColor.apply(this, arguments);
-            }
+            var cs = this.getStrokeColorSpace();
+            var color = cs.getRgb(arguments);
+            this.setStrokeRGBColor.apply(this, color);
         },
         setStrokeColorN: function(/*...*/) {
             // TODO real impl
+            TODO("check for special color spaces");
             this.setStrokeColor.apply(this, arguments);
         },
         setFillColor: function(/*...*/) {
-            // TODO real impl
-            if (1 === arguments.length) {
-                this.setFillGray.apply(this, arguments);
-            } else if (3 === arguments.length) {
-                this.setFillRGBColor.apply(this, arguments);
-            } else if (4 === arguments.length) {
-                this.setFillCMYKColor.apply(this, arguments);
+            var cs = this.getFillColorSpace();
+            if (cs.name == "Pattern") {
+                TODO("implement Pattern fill");
+                return;
             }
+            var color = cs.getRgb(arguments);
+            this.setFillRGBColor.apply(this, color);
         },
         setFillColorN: function(/*...*/) {
-            // TODO real impl
-            var colorSpace = this.current.colorSpace;
-            if (!colorSpace) {
-                var stateStack = this.stateStack;
-                var i = stateStack.length - 1;
-                while (!colorSpace && i >= 0) {
-                    colorSpace = stateStack[i--].colorSpace;
-                }
-            }
+            var cs = this.getFillColorSpace();
 
-            if (this.current.colorSpace == "Pattern") {
+            if (cs.name == "Pattern") {
                 var patternName = arguments[0];
                 if (IsName(patternName)) {
                     var xref = this.xref;
@@ -4333,6 +4326,36 @@ var CanvasGraphics = (function() {
             var bi = (255 * (1 - Math.min(1, y * (1 - k) + k))) | 0;
             return "rgb("+ ri +","+ gi +","+ bi +")";
         },
+        getFillColorSpace: function() {
+            var cs = this.current.fillColorSpace;
+            if (cs)
+                return cs;
+
+            var states = this.stateStack;
+            var i = states.length - 1;
+            while (i >= 0 && !(cs = states[i].fillColorSpace))
+                --i;
+
+            if (cs)
+                return cs;
+            else
+                return new DeviceRgbCS();
+        },
+        getStrokeColorSpace: function() {
+            var cs = this.current.strokeColorSpace;
+            if (cs)
+                return cs;
+            
+            var states = this.stateStack;
+            var i = states.length - 1;
+            while (i >= 0 && !(cs = states[i].strokeColorSpace))
+                --i;
+
+            if (cs)
+                return cs;
+            else
+                return new DeviceRgbCS();
+        },
         // We generally keep the canvas context set for
         // nonzero-winding, and just set evenodd for the operations
         // that need them.
@@ -4350,51 +4373,90 @@ var CanvasGraphics = (function() {
 })();
 
 var ColorSpace = (function() {
-    function constructor(xref, cs) {
+    function constructor() {
+        error("should not call ColorSpace constructor");
+    };
+
+    constructor.parse = function colorspace_parse(cs, xref, res) {
+        if (IsName(cs)) {
+            var colorSpaces = res.get("ColorSpace");
+            if (colorSpaces) {
+                var refcs = colorSpaces.get(cs.name);
+                if (refcs)
+                    cs = refcs;
+            }
+        }
+            
+        cs = xref.fetchIfRef(cs);
+
         if (IsName(cs)) {
             var mode = cs.name;
             this.mode = mode;
+
             switch(mode) {
             case "DeviceGray":
             case "G":
-                this.numComps = 1;
+                return new DeviceGrayCS();
                 break;
             case "DeviceRGB":
-                this.numComps = 3;
+            case "RGB":
+                return new DeviceRgbCS();
                 break;
+            case "DeviceCMYK":
+            case "CMYK":
+                return new DeviceCmykCS();
+                break;
+            case "Pattern":
+                return new PatternCS(null);
+                break;
+            default:
+                error("unrecognized colorspace " + mode);
             }
-            TODO("fill in color space constructor");
         } else if (IsArray(cs)) {
             var mode = cs[0].name;
             this.mode = mode;
 
-            var stream = cs[1];
-            stream = xref.fetchIfRef(stream);
-
             switch (mode) {
             case "DeviceGray":
             case "G":
-                this.stream = stream;
-                this.dict = stream.dict;
-                this.numComps = 1;
+                return new DeviceGrayCS();
+                break;
+            case "DeviceRGB":
+            case "RGB":
+                return new DeviceRgbCS();
+                break;
+            case "DeviceCMYK":
+            case "CMYK":
+                return new DeviceCmykCS();
+                break;
+            case "CalGray":
+                return new DeviceGrayCS();
+                break;
+            case "CalRGB":
+                return new DeviceRgbCS();
                 break;
             case "ICCBased":
+                var stream = xref.fetchIfRef(cs[1]);
                 var dict = stream.dict;
-
-                this.stream = stream;
-                this.dict = dict;
-                this.numComps = dict.get("N");
+                var numComps = dict.get("N");
+                if (numComps == 1)
+                    return new DeviceGrayCS();
+                else if (numComps == 3)
+                    return new DeviceRgbCS();
+                else if (numComps == 4)
+                    return new DeviceCmykCS();
+                break;
+            case "Pattern":
+                return new PatternCS();
                 break;
             case "Indexed":
-                this.stream = stream;
-                this.dict = stream.dict;
-                var base = cs[1];
-                var hival = cs[2];
-                assertWellFormed(0 <= hival && hival <= 255, "hival in range");
-                var lookupTable = cs[3];
-                TODO("implement 'Indexed' color space");
-                this.numComps = 3; // HACK
-                break;
+                var base = ColorSpace.parse(cs[1], xref, res);
+                var hiVal = cs[2];
+                var lookup = xref.fetchIfRef(cs[3]);
+                return new IndexedCS(base, hiVal, lookup);
+            case "Lab":
+            case "Seperation":
+            case "DeviceN":
             default:
                 error("unrecognized color space object '"+ mode +"'");
             }
@@ -4403,9 +4465,137 @@ var ColorSpace = (function() {
         }
     };
 
+    return constructor;
+})();
+
+var PatternCS = (function() {
+    function constructor() {
+        this.name = "Pattern";
+    }
+    constructor.prototype = {};
+  
+    return constructor;
+})();
+
+var IndexedCS = (function() {
+    function constructor(base, highVal, lookup) {
+        this.name = "Indexed";
+        this.numComps = 1;
+        this.defaultColor = [0];
+
+        this.base = base;
+        var baseNumComps = base.numComps;
+        this.highVal = highVal;
+
+        var length = baseNumComps * highVal;
+        var lookupArray = new Uint8Array(length);
+        if (IsStream(lookup)) {
+            var bytes = lookup.getBytes(length);
+            lookupArray.set(bytes);
+        } else if (IsString(lookup)) {
+            for (var i = 0; i < length; ++i)
+                lookupArray[i] = lookup.charCodeAt(i);
+        } else {
+            error("Unrecognized lookup table");
+        }
+        this.lookup = lookupArray;
+    }
+
     constructor.prototype = {
+        getRgb: function graycs_getRgb(color) {
+            var lookup = this.lookup;
+            var base = this.base;
+            var numComps = base.numComps;
+            
+            var c = [];
+            for (var i = 0; i < numComps; ++i)
+                c.push(lookup[i])
+            return this.base.getRgb(c);
+        },
+        getRgbBuffer: function graycs_getRgbBuffer(input) {
+            var base = this.base;
+            var numComps = base.numComps;
+            var lookup = this.lookup;
+            var length = input.length;
+
+            var baseBuf = new Uint8Array(length * numComps);
+            var baseBufPos = 0;
+            for (var i = 0; i < length; ++i) {
+                var lookupPos = input[i];
+                for (var j = 0; j < numComps ; ++j) {
+                    baseBuf[baseBufPos++] = lookup[lookupPos + j];
+                }
+            }
+            
+            return base.getRgbBuffer(baseBuf);
+        }
+    };
+    return constructor;
+})();
+
+var DeviceGrayCS = (function() {
+    function constructor() {
+        this.name = "DeviceGray";
+        this.numComps = 1;
+        this.defaultColor = [0];
     };
 
+    constructor.prototype = {
+        getRgb: function graycs_getRgb(color) {
+            var c = color[0];
+            return [c, c, c];
+        },
+        getRgbBuffer: function graycs_getRgbBuffer(input) {
+            var length = input.length;
+            var rgbBuf = new Uint8Array(length);
+            for (var i = 0, j = 0; i < length; ++i) {
+                var c = input[i];
+                rgbBuf[j++] = c;
+                rgbBuf[j++] = c;
+                rgbBuf[j++] = c;
+            }
+            return rgbBuf;
+        }
+    };
+    return constructor;
+})();
+
+var DeviceRgbCS = (function() {
+    function constructor() {
+        this.name = "DeviceRGB";
+        this.numComps = 3;
+        this.defaultColor = [0, 0, 0];
+    }
+    constructor.prototype = {
+        getRgb: function graycs_getRgb(color) {
+            return color;
+        },
+        getRgbBuffer: function graycs_getRgbBuffer(input) {
+            return input;
+        }
+    };
+    return constructor;
+})();
+
+var DeviceCmykCS = (function() {
+    function constructor() {
+        this.name = "DeviceCMYK";
+        this.numComps = 4;
+        this.defaultColor = [0, 0, 0, 1];
+    }
+    constructor.prototype = {
+        getRgb: function graycs_getRgb(color) {
+            var c = color[0], y = color[1], m = color[2], k = color[3];
+            var ri = (1 - Math.min(1, c * (1 - k) + k)) | 0;
+            var gi = (1 - Math.min(1, m * (1 - k) + k)) | 0;
+            var bi = (1 - Math.min(1, y * (1 - k) + k)) | 0;
+            return [ri, gi, bi];
+        },
+        getRgbBuffer: function graycs_getRgbBuffer(colorBuf) {
+            error("conversion from rgb to cmyk not implemented for images");
+            return colorBuf;
+        }
+    };
     return constructor;
 })();
 
@@ -4443,11 +4633,8 @@ var PDFImage = (function() {
         }
         this.bpc = bitsPerComponent;
 
-        var colorSpaces = res.get("ColorSpace");
-        var csStream = xref.fetchIfRef(dict.get2("ColorSpace", "CS"));
-        if (IsName(csStream) && inline)
-            csStream = colorSpaces.get(csStream);
-        this.colorSpace = new ColorSpace(xref, csStream);
+        var colorSpace = dict.get2("ColorSpace", "CS");
+        this.colorSpace = ColorSpace.parse(colorSpace, xref, res);
 
         this.numComps = this.colorSpace.numComps;
         this.decode = dict.get2("Decode", "D");
@@ -4523,7 +4710,7 @@ var PDFImage = (function() {
                     output[i] = Math.round(255 * ret / ((1 << bpc) - 1));
                 }
             }
-            return output;
+            return this.colorSpace.getRbaBuffer(output);
         },
         getOpacity: function getOpacity() {
             var smask = this.smask;

test/test.py

@@ -16,6 +16,9 @@ REFDIR = 'ref'
 TMPDIR = 'tmp'
 VERBOSE = False
 
+SERVER_HOST = "localhost"
+SERVER_PORT = 8080
+
 class TestOptions(OptionParser):
     def __init__(self, **kwargs):
         OptionParser.__init__(self, **kwargs)
@@ -41,7 +44,7 @@ class TestOptions(OptionParser):
         if options.browser and options.browserManifestFile:
             print "Warning: ignoring browser argument since manifest file was also supplied"
         if not options.browser and not options.browserManifestFile:
-            self.error("No test browsers found. Use --browserManifest or --browser args.")
+            print "No browser arguments supplied, so just starting server on port %s." % SERVER_PORT
         return options
         
 def prompt(question):
@@ -295,7 +298,9 @@ def setUp(options):
         testBrowsers = makeBrowserCommands(options.browserManifestFile)
     elif options.browser:
         testBrowsers = [makeBrowserCommand({"path":options.browser, "name":None})]
-    assert len(testBrowsers) > 0
+
+    if options.browserManifestFile or options.browser:
+        assert len(testBrowsers) > 0
 
     with open(options.manifestFile) as mf:
         manifestList = json.load(mf)
@@ -320,9 +325,11 @@ def startBrowsers(browsers, options):
     for b in browsers:
         b.setup()
         print 'Launching', b.name
+        host = 'http://%s:%s' % (SERVER_HOST, SERVER_PORT) 
+        path = '/test/test_slave.html?'
         qs = 'browser='+ urllib.quote(b.name) +'&manifestFile='+ urllib.quote(options.manifestFile)
         qs += '&path=' + b.path
-        b.start('http://localhost:8080/test/test_slave.html?'+ qs)
+        b.start(host + path + qs)
 
 def teardownBrowsers(browsers):
     for b in browsers:
@@ -476,7 +483,8 @@ def maybeUpdateRefImages(options, browser):
                 print 'done'
 
 def startReftest(browser):
-    url = "http://127.0.0.1:8080/test/resources/reftest-analyzer.xhtml"
+    url = "http://%s:%s" % (SERVER_HOST, SERVER_PORT)
+    url += "/test/resources/reftest-analyzer.xhtml"
     url += "#web=/test/eq.log"
     try:
         browser.setup()
@@ -487,20 +495,8 @@ def startReftest(browser):
         teardownBrowsers([browser])
     print "Completed reftest usage."
 
-def main():
+def runTests(options, browsers):
     t1 = time.time()
-    optionParser = TestOptions()
-    options, args = optionParser.parse_args()
-    options = optionParser.verifyOptions(options)
-    if options == None:
-        sys.exit(1)
-
-    httpd = TestServer(('127.0.0.1', 8080), PDFTestHandler)
-    httpd_thread = threading.Thread(target=httpd.serve_forever)
-    httpd_thread.setDaemon(True)
-    httpd_thread.start()
-
-    browsers = setUp(options)
     try:
         startBrowsers(browsers, options)
         while not State.done:
@@ -517,5 +513,26 @@ def main():
         print "\nStarting reftest harness to examine %d eq test failures." % State.numEqFailures
         startReftest(browsers[0])
 
+def main():
+    optionParser = TestOptions()
+    options, args = optionParser.parse_args()
+    options = optionParser.verifyOptions(options)
+    if options == None:
+        sys.exit(1)
+
+    httpd = TestServer((SERVER_HOST, SERVER_PORT), PDFTestHandler)
+    httpd_thread = threading.Thread(target=httpd.serve_forever)
+    httpd_thread.setDaemon(True)
+    httpd_thread.start()
+
+    browsers = setUp(options)
+    if len(browsers) > 0:
+        runTests(options, browsers)
+    else:
+        # just run the server
+        print "Running HTTP server. Press Ctrl-C to quit."
+        while True:
+            time.sleep(1)
+
 if __name__ == '__main__':
     main()

test/test_slave.html

@@ -115,25 +115,18 @@ function nextPage() {
     failure = 'page setup: '+ e.toString();
   }
 
-  var fontLoaderTimer = null;
-  function checkFontsLoaded() {
+  if (!failure) {
     try {
-      if (!FontLoader.bind(fonts)) {
-        fontLoaderTimer = window.setTimeout(checkFontsLoaded, 10);
-        return;
-      }
+      FontLoader.bind(fonts, function() { snapshotCurrentPage(gfx); });
     } catch(e) {
       failure = 'fonts: '+ e.toString();
     }
-    snapshotCurrentPage(gfx);
   }
 
   if (failure) {
-    // Skip font loading if there was a failure, since the fonts might
-    // be in an inconsistent state.
+    // Skip right to snapshotting if there was a failure, since the
+    // fonts might be in an inconsistent state.
     snapshotCurrentPage(gfx);
-  } else {
-    checkFontsLoaded();
   }
 }
 

utils/fonts_utils.js

@@ -12,8 +12,6 @@
  * CharString or to understand the structure of the CFF format.
  */
 
-"use strict";
-
 /**
  * Build a charset by assigning the glyph name and the human readable form
  * of the glyph data.
@@ -380,6 +378,9 @@ var Type2Parser = function(aFilePath) {
  * writeToFile(fontData, "/tmp/pdf.js." + fontCount + ".cff");
  */
 function writeToFile(aBytes, aFilePath) {
+  if (!("netscape" in window))
+    return;
+
   netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
   var Cc = Components.classes,
       Ci = Components.interfaces;
@@ -388,7 +389,7 @@ function writeToFile(aBytes, aFilePath) {
 
   var stream = Cc["@mozilla.org/network/file-output-stream;1"]
                  .createInstance(Ci.nsIFileOutputStream);
-  stream.init(file, 0x04 | 0x08 | 0x20, 600, 0);
+  stream.init(file, 0x04 | 0x08 | 0x20, 0x180, 0);
 
   var bos = Cc["@mozilla.org/binaryoutputstream;1"]
               .createInstance(Ci.nsIBinaryOutputStream);

viewer.js

@@ -3,7 +3,7 @@
 
 "use strict";
 
-var pdfDocument, canvas, pageScale, pageDisplay, pageNum, numPages, pageTimeout;
+var pdfDocument, canvas, pageScale, pageDisplay, pageNum, numPages;
 function load(userInput) {
     canvas = document.getElementById("canvas");
     canvas.mozOpaque = true;
@@ -53,8 +53,6 @@ function gotoPage(num) {
 }
 
 function displayPage(num) {
-    window.clearTimeout(pageTimeout);
-
     document.getElementById("pageNumber").value = num;
 
     var t0 = Date.now();
@@ -82,22 +80,18 @@ function displayPage(num) {
     page.compile(gfx, fonts);
     var t2 = Date.now();
 
-    function loadFont() {
-      if (!FontLoader.bind(fonts)) {
-        pageTimeout = window.setTimeout(loadFont, 10);
-        return;
-      }
+    function displayPage() {
+        var t3 = Date.now();
 
-      var t3 = Date.now();
+        page.display(gfx);
 
-      page.display(gfx);
+        var t4 = Date.now();
 
-      var t4 = Date.now();
+        var infoDisplay = document.getElementById("info");
+        infoDisplay.innerHTML = "Time to load/compile/fonts/render: "+ (t1 - t0) + "/" + (t2 - t1) + "/" + (t3 - t2) + "/" + (t4 - t3) + " ms";
+    }
 
-      var infoDisplay = document.getElementById("info");
-      infoDisplay.innerHTML = "Time to load/compile/fonts/render: "+ (t1 - t0) + "/" + (t2 - t1) + "/" + (t3 - t2) + "/" + (t4 - t3) + " ms";
-    };
-    loadFont();
+    FontLoader.bind(fonts, displayPage);
 }
 
 function nextPage() {