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

fonts.js

@@ -1717,6 +1717,7 @@ var Type1Parser = function type1Parser() {
     var charstring = [];
     var lsb = 0;
     var width = 0;
+    var flexState = 0;
 
     var value = '';
     var count = array.length;
@@ -1750,7 +1751,11 @@ var Type1Parser = function type1Parser() {
               i++;
               continue;
             }
-          } else if (!kHintingEnabled && (value == 1 || value == 2)) {
+          } else if (escape == 17 || escape == 33) {
+            // pop or setcurrentpoint commands can be ignored
+            // since we are not doing callothersubr
+            continue;
+          } else if (!kHintingEnabled && (escape == 1 || escape == 2)) {
             charstring.push('drop', 'drop', 'drop', 'drop', 'drop', 'drop');
             continue;
           }
@@ -1777,6 +1782,29 @@ var Type1Parser = function type1Parser() {
 
             charstring.push(lsb, 'hmoveto');
             continue;
+          } else if (value == 10) { // callsubr
+            if (charstring[charstring.length - 1] < 3) { // subr #0..2
+              var subrNumber = charstring.pop();
+              switch (subrNumber) {
+                case 1:
+                  flexState = 1; // prepare for flex coordinates
+                  break;
+                case 2:
+                  flexState = 2; // flex in progress
+                  break;
+                case 0:
+                  // type2 flex command does not need final coords
+                  charstring.push('exch', 'drop', 'exch', 'drop');
+                  charstring.push('flex');
+                  flexState = 0;
+                  break;
+              }
+              continue;
+            }
+          } else if (value == 21 && flexState > 0) {
+            if (flexState > 1)
+              continue; // ignoring rmoveto
+            value = 5; // first segment replacing with rlineto
           } else if (!kHintingEnabled && (value == 1 || value == 3)) {
             charstring.push('drop', 'drop');
             continue;
@@ -2273,7 +2301,8 @@ CFF.prototype = {
     'return': 11,
     'sub': [12, 11],
     'div': [12, 12],
-    'pop': [1, 12, 18],
+    'exch': [12, 28],
+    'flex': [12, 35],
     'drop' : [12, 18],
     'endchar': 14,
     'rmoveto': 21,
@@ -2490,7 +2519,7 @@ var Type2CFF = (function type2CFF() {
       var charStrings = this.parseIndex(topDict.CharStrings);
       var charset = this.parseCharsets(topDict.charset,
                                        charStrings.length, strings);
-      var hasSupplement = this.parseEncoding(topDict.Encoding, properties,
+      var encoding = this.parseEncoding(topDict.Encoding, properties,
                                              strings, charset);
 
       // The font sanitizer does not support CFF encoding with a
@@ -2498,8 +2527,8 @@ var Type2CFF = (function type2CFF() {
       // between gid to glyph, let's overwrite what is declared in
       // the top dictionary to let the sanitizer think the font use
       // StandardEncoding, that's a lie but that's ok.
-      if (hasSupplement)
+      if (encoding.hasSupplement)
-        bytes[topDict.Encoding] = 0;
+        bytes[topDict.Encoding] &= 0x7F;
 
       // The CFF specification state that the 'dotsection' command
       // (12, 0) is deprecated and treated as a no-op, but all Type2
@@ -2530,7 +2559,7 @@ var Type2CFF = (function type2CFF() {
 
       // charstrings contains info about glyphs (one element per glyph
       // containing mappings for {unicode, width})
-      var charstrings = this.getCharStrings(charset, charStrings,
+      var charstrings = this.getCharStrings(charset, encoding.encoding,
                                             privateDict, this.properties);
 
       // create the mapping between charstring and glyph id
@@ -2547,49 +2576,85 @@ var Type2CFF = (function type2CFF() {
       return data;
     },
 
-    getCharStrings: function cff_charstrings(charsets, charStrings,
+    getCharStrings: function cff_charstrings(charsets, encoding,
                                              privateDict, properties) {
       var defaultWidth = privateDict['defaultWidthX'];
       var charstrings = [];
-      var differences = properties.differences;
+      var firstChar = properties.firstChar;
-      var index = properties.firstChar || 0;
+      var glyphMap = {};
-      for (var i = 1; i < charsets.length; i++) {
+      for (var i = 0; i < charsets.length; i++) {
-        var code = -1;
         var glyph = charsets[i];
-        for (var j = 0; j < differences.length; j++) {
+        for (var charcode in encoding) {
-          if (differences[j] == glyph) {
+          if (encoding[charcode] == i)
-            index = j;
+            glyphMap[glyph] = charcode | 0;
-            code = differences.indexOf(glyph);
-            break;
-          }
         }
+      }
 
-        var mapping =
+      var differences = properties.differences;
-          properties.glyphs[glyph] || properties.glyphs[index] || {};
+      for (var i = 0; i < differences.length; ++i) {
-        if (code == -1)
+        var glyph = differences[i];
-          index = code = mapping.unicode || index;
+        if (!glyph)
+          continue;
+        var oldGlyph = charsets[i];
+        if (oldGlyph)
+          delete glyphMap[oldGlyph];
+        glyphMap[differences[i]] = i;
+      }
 
-        if (code <= 0x1f || (code >= 127 && code <= 255))
+      var glyphs = properties.glyphs;
-          code += kCmapGlyphOffset;
+      for (var i = 1; i < charsets.length; i++) {
+        var glyph = charsets[i];
+        var code = glyphMap[glyph] || 0;
 
-        var width = mapping.width;
+        var mapping = glyphs[code] || glyphs[glyph] || {};
-        properties.glyphs[glyph] = properties.encoding[index] = {
+        var unicode = mapping.unicode;
-          unicode: code,
+
-          width: isNum(width) ? width : defaultWidth
+        if (unicode <= 0x1f || (unicode >= 127 && unicode <= 255))
+          unicode += kCmapGlyphOffset;
+
+        var width = isNum(mapping.width) ? mapping.width : defaultWidth;
+        properties.encoding[code] = {
+          unicode: unicode,
+          width: width
         };
 
         charstrings.push({
-          unicode: code,
+          unicode: unicode,
           width: width,
+          code: code,
           gid: i
         });
-        index++;
       }
 
       // sort the array by the unicode value
       charstrings.sort(function type2CFFGetCharStringsSort(a, b) {
         return a.unicode - b.unicode;
       });
+
+      // remove duplicates -- they might appear during selection:
+      //   properties.glyphs[code] || properties.glyphs[glyph]
+      var nextUnusedUnicode = kCmapGlyphOffset + 0x0020;
+      var lastUnicode = charstrings[0].unicode, wasModified = false;
+      for (var i = 1; i < charstrings.length; ++i) {
+        if (lastUnicode != charstrings[i].unicode) {
+          lastUnicode = charstrings[i].unicode;
+          continue;
+        }
+        // duplicate found -- keeping the item that has
+        // different code and unicode, that one created
+        // as result of modification of the base encoding
+        var duplicateIndex =
+          charstrings[i].unicode == charstrings[i].code ? i : i - 1;
+        charstrings[duplicateIndex].unicode = nextUnusedUnicode++;
+        wasModified = true;
+      }
+      if (!wasModified)
+        return charstrings;
+
+      // sort the array by the unicode value (again)
+      charstrings.sort(function type2CFFGetCharStringsSort(a, b) {
+        return a.unicode - b.unicode;
+      });
       return charstrings;
     },
 
@@ -2597,6 +2662,10 @@ var Type2CFF = (function type2CFF() {
                                               charset) {
       var encoding = {};
       var bytes = this.bytes;
+      var result = {
+        encoding: encoding,
+        hasSupplement: false
+      };
 
       function readSupplement() {
         var supplementsCount = bytes[pos++];
@@ -2623,11 +2692,6 @@ var Type2CFF = (function type2CFF() {
             var glyphsCount = bytes[pos++];
             for (var i = 1; i <= glyphsCount; i++)
               encoding[bytes[pos++]] = i;
-
-            if (format & 0x80) {
-              readSupplement();
-              return true;
-            }
             break;
 
           case 1:
@@ -2639,19 +2703,18 @@ var Type2CFF = (function type2CFF() {
               for (var j = start; j <= start + count; j++)
                 encoding[j] = gid++;
             }
-
-            if (format & 0x80) {
-              readSupplement();
-              return true;
-            }
             break;
 
           default:
             error('Unknow encoding format: ' + format + ' in CFF');
             break;
         }
+        if (format & 0x80) {
+          readSupplement();
+          result.hasSupplement = true;
+        }
       }
-      return false;
+      return result;
     },
 
     parseCharsets: function cff_parsecharsets(pos, length, strings) {

pdf.js

@@ -3558,6 +3558,12 @@ var Page = (function pagePage() {
       var self = this;
       var stats = self.stats;
       stats.compile = stats.fonts = stats.render = 0;
+      if (!this.content) {
+        setTimeout(function norenderingSetTimeout() {
+          if (continuation) continuation(null);
+        });
+        return;
+      }
 
       var gfx = new CanvasGraphics(canvasCtx);
       var fonts = [];
@@ -4609,7 +4615,9 @@ var PartialEvaluator = (function partialEvaluator() {
         };
 
         if (replaceGlyph || !glyphs[glyph])
-            glyphs[glyph] = map[i];
+          glyphs[glyph] = map[i];
+        if (replaceGlyph || !glyphs[index])
+          glyphs[index] = map[i];
 
         // If there is no file, the character mapping can't be modified
         // but this is unlikely that there is any standard encoding with

test/pdfs/fit11-talk.pdf.link

@@ -0,0 +1 @@
+http://www.ccs.neu.edu/home/samth/fit11-talk.pdf

test/test_manifest.json

@@ -144,6 +144,13 @@
        "rounds": 1,
        "type": "eq"
     },
+    {  "id": "fit11-talk",
+       "file": "pdfs/fit11-talk.pdf",
+       "link": true,
+       "rounds": 1,
+       "skipPages": [12,31],
+       "type": "eq"
+    },
     {  "id": "fips197",
        "file": "pdfs/fips197.pdf",
        "link": true,