pdf: write only ToUnicode mappings needed by the font, trimming anything out of [firstChar, lastCha…

src/pdf/SkPDFFont.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <ctype.h>
 
 #include "SkData.h"
@@ skipping 324 matching lines @@
                 appendAdvance(advanceInfo->fAdvance[0], emSize, result);
                 break;
             }
         }
     }
     return result;
 }
 
 }  // namespace
 
-static void append_tounicode_header(SkDynamicMemoryWStream* cmap) {
+static void append_tounicode_header(SkDynamicMemoryWStream* cmap,
+                                    uint16_t firstGlypthID,
+                                    uint16_t lastGlypthID) {
     // 12 dict begin: 12 is an Adobe-suggested value. Shall not change.
     // It's there to prevent old version Adobe Readers from malfunctioning.
     const char* kHeader =
         "/CIDInit /ProcSet findresource begin\n"
         "12 dict begin\n"
         "begincmap\n";
     cmap->writeText(kHeader);
 
     // The /CIDSystemInfo must be consistent to the one in
     // SkPDFFont::populateCIDFont().
     // We can not pass over the system info object here because the format is
     // different. This is not a reference object.
     const char* kSysInfo =
         "/CIDSystemInfo\n"
         "<<  /Registry (Adobe)\n"
         "/Ordering (UCS)\n"
         "/Supplement 0\n"
         ">> def\n";
     cmap->writeText(kSysInfo);
 
     // The CMapName must be consistent to /CIDSystemInfo above.
     // /CMapType 2 means ToUnicode.
-    // We specify codespacerange from 0x0000 to 0xFFFF because we convert our
-    // code table from unsigned short (16-bits). Codespace range just tells the
-    // PDF processor the valid range. It does not matter whether a complete
-    // mapping is provided or not.
-    const char* kTypeInfo =
+    // Codespace range just tells the PDF processor the valid range.
+    const char* kTypeInfoHeader =
         "/CMapName /Adobe-Identity-UCS def\n"
         "/CMapType 2 def\n"
-        "1 begincodespacerange\n"
-        "<0000> <FFFF>\n"
-        "endcodespacerange\n";
-    cmap->writeText(kTypeInfo);
+        "1 begincodespacerange\n";
+    cmap->writeText(kTypeInfoHeader);
+    
+    // e.g.     "<0000> <FFFF>\n"
+    SkString range;
+    range.appendf("<%04X> <%04X>\n", firstGlypthID, lastGlypthID);
+    cmap->writeText(range.c_str());
+    
+    const char* kTypeInfoFooter = "endcodespacerange\n";
+    cmap->writeText(kTypeInfoFooter);
 }
 
 static void append_cmap_footer(SkDynamicMemoryWStream* cmap) {
     const char* kFooter =
         "endcmap\n"
         "CMapName currentdict /CMap defineresource pop\n"
         "end\n"
         "end";
     cmap->writeText(kFooter);
 }
 
 struct BFChar {
     uint16_t fGlyphId;
     SkUnichar fUnicode;
 };
 
 struct BFRange {
     uint16_t fStart;
     uint16_t fEnd;
     SkUnichar fUnicode;
 };
 
 static void append_bfchar_section(const SkTDArray<BFChar>& bfchar,
-                                  SkDynamicMemoryWStream* cmap) {
+                                  SkDynamicMemoryWStream* cmap,
+                                  uint16_t firstGlypthID,
+                                  uint16_t lastGlypthID) {    
+    int32_t i = 0;
+    while (i < bfchar.count() && bfchar[i].fGlyphId < firstGlypthID) {

[vandebo (ex-Chrome), 2013/09/04 22:07:53]

While the end point probably doesn't take a lot of time, this one could. 
Probably worth the effort to figure out SkTSearch and use it here.  At that
point you might as well use it below as well.  Or you could do both outside the
loop and note the start and end indices. 

[edisonn, 2013/09/06 18:54:38]

N/A - moved filtering in the caller - fastest way to do something is not to do
it at all.

On 2013/09/04 22:07:53, vandebo wrote:

+        i++;
+    }
+    
     // PDF spec defines that every bf* list can have at most 100 entries.
-    for (int i = 0; i < bfchar.count(); i += 100) {
+    for (; i < bfchar.count(); i += 100) {
+        if (bfchar[i].fGlyphId > lastGlypthID) {
+            return;
+        }
+
         int count = bfchar.count() - i;
         count = SkMin32(count, 100);
+        // TODO(edisonn): perf, might be better to do a bsearch, but I think
+        // most of the times, we will have enough data to stop imediately.
+        while (count > 0 && bfchar[i + count - 1].fGlyphId > lastGlypthID) {
+            count--;
+        }
+
+        if (count == 0) {

[vandebo (ex-Chrome), 2013/09/04 22:07:53]

Not possible, count must be >= 1 because of the check on line 417

[edisonn, 2013/09/06 18:54:38]

On 2013/09/04 22:07:53, vandebo wrote:
dead code

Done.

+            return;
+        }
+        
         cmap->writeDecAsText(count);
         cmap->writeText(" beginbfchar\n");
         for (int j = 0; j < count; ++j) {
             cmap->writeText("<");
             cmap->writeHexAsText(bfchar[i + j].fGlyphId, 4);
             cmap->writeText("> <");
             cmap->writeHexAsText(bfchar[i + j].fUnicode, 4);
             cmap->writeText(">\n");
         }
         cmap->writeText("endbfchar\n");
     }
 }
 
 static void append_bfrange_section(const SkTDArray<BFRange>& bfrange,
-                                   SkDynamicMemoryWStream* cmap) {
+                                   SkDynamicMemoryWStream* cmap,
+                                   uint16_t firstGlypthID,
+                                   uint16_t lastGlypthID) {
+    int32_t i = 0;
+    while (i < bfrange.count() && bfrange[i].fEnd < firstGlypthID) {

[vandebo (ex-Chrome), 2013/09/04 22:07:53]

Same here re SkTSearch

[edisonn, 2013/09/06 18:54:38]

dead code
On 2013/09/04 22:07:53, vandebo wrote:

+        i++;
+    }
+
     // PDF spec defines that every bf* list can have at most 100 entries.
-    for (int i = 0; i < bfrange.count(); i += 100) {
+    for (; i < bfrange.count(); i += 100) {
+        if (bfrange[i].fStart > lastGlypthID) {
+            return;
+        }
+
         int count = bfrange.count() - i;
         count = SkMin32(count, 100);
         cmap->writeDecAsText(count);
         cmap->writeText(" beginbfrange\n");
+
+        // first range might be chopped.
+        uint16_t start = SkMax32(firstGlypthID, bfrange[i].fStart);
+
         for (int j = 0; j < count; ++j) {
+            if (bfrange[i + j].fStart > lastGlypthID) {
+                break;
+            }
             cmap->writeText("<");
-            cmap->writeHexAsText(bfrange[i + j].fStart, 4);
+            cmap->writeHexAsText(j == 0 ? start : bfrange[i + j].fStart, 4);

[vandebo (ex-Chrome), 2013/09/04 22:07:53]

It's probably the same computational cost to do the trinary operator as it is to
just inline the SkMax32 here.

[edisonn, 2013/09/06 18:54:38]

dead code

             cmap->writeText("> <");
-            cmap->writeHexAsText(bfrange[i + j].fEnd, 4);
+            cmap->writeHexAsText(SkMin32(bfrange[i + j].fEnd, lastGlypthID), 4);
             cmap->writeText("> <");
             cmap->writeHexAsText(bfrange[i + j].fUnicode, 4);
             cmap->writeText(">\n");
         }
         cmap->writeText("endbfrange\n");
     }
 }
 
 // Generate <bfchar> and <bfrange> table according to PDF spec 1.4 and Adobe
 // Technote 5014.
@@ skipping 19 matching lines @@
 // the spec does not mention how will this kind of conflict being resolved.
 //
 // For the worst case (having 65536 continuous unicode and we use every other
 // one of them), the possible savings by aggressive optimization is 416KB
 // pre-compressed and does not provide enough motivation for implementation.
 
 // FIXME: this should be in a header so that it is separately testable
 // ( see caller in tests/ToUnicode.cpp )
 void append_cmap_sections(const SkTDArray<SkUnichar>& glyphToUnicode,
                           const SkPDFGlyphSet* subset,
-                          SkDynamicMemoryWStream* cmap);
+                          SkDynamicMemoryWStream* cmap,
+                          uint16_t firstGlypthID = 0x0000,

[vandebo (ex-Chrome), 2013/09/04 22:07:53]

No need for defaults, these args are always passed in.

[edisonn, 2013/09/06 18:54:38]

Done.

+                          uint16_t lastGlypthID  = 0xffff);
 
 void append_cmap_sections(const SkTDArray<SkUnichar>& glyphToUnicode,
                           const SkPDFGlyphSet* subset,
-                          SkDynamicMemoryWStream* cmap) {
+                          SkDynamicMemoryWStream* cmap,
+                          uint16_t firstGlypthID,
+                          uint16_t lastGlypthID) {
     if (glyphToUnicode.isEmpty()) {
         return;
     }
 
     SkTDArray<BFChar> bfcharEntries;
     SkTDArray<BFRange> bfrangeEntries;
 
     BFRange currentRangeEntry = {0, 0, 0};
     bool rangeEmpty = true;
     const int count = glyphToUnicode.count();
@@ skipping 26 matching lines @@
             if (rangeEmpty) {
               currentRangeEntry.fStart = i;
               currentRangeEntry.fUnicode = glyphToUnicode[i];
               rangeEmpty = false;
             }
         }
     }
 
     // The spec requires all bfchar entries for a font must come before bfrange
     // entries.
-    append_bfchar_section(bfcharEntries, cmap);
-    append_bfrange_section(bfrangeEntries, cmap);
+    append_bfchar_section(bfcharEntries, cmap, firstGlypthID, lastGlypthID);
+    append_bfrange_section(bfrangeEntries, cmap, firstGlypthID, lastGlypthID);
 }
 
 static SkPDFStream* generate_tounicode_cmap(
         const SkTDArray<SkUnichar>& glyphToUnicode,
-        const SkPDFGlyphSet* subset) {
+        const SkPDFGlyphSet* subset,
+        uint16_t firstGlypthID,
+        uint16_t lastGlypthID) {
     SkDynamicMemoryWStream cmap;
-    append_tounicode_header(&cmap);
-    append_cmap_sections(glyphToUnicode, subset, &cmap);
+    append_tounicode_header(&cmap, firstGlypthID, lastGlypthID);
+    append_cmap_sections(glyphToUnicode, subset, &cmap,
+                         firstGlypthID, lastGlypthID);
     append_cmap_footer(&cmap);
     SkAutoTUnref<SkMemoryStream> cmapStream(new SkMemoryStream());
     cmapStream->setData(cmap.copyToData())->unref();
     return new SkPDFStream(cmapStream.get());
 }
 
 #if defined (SK_SFNTLY_SUBSETTER)
 static void sk_delete_array(const void* ptr, size_t, void*) {
     // Use C-style cast to cast away const and cast type simultaneously.
     delete[] (unsigned char*)ptr;
@@ skipping 464 matching lines @@
     : fFont(font),
       fFontID(fontID),
       fGlyphID(glyphID) {
 }
 
 void SkPDFFont::populateToUnicodeTable(const SkPDFGlyphSet* subset) {
     if (fFontInfo == NULL || fFontInfo->fGlyphToUnicode.begin() == NULL) {
         return;
     }
     SkAutoTUnref<SkPDFStream> pdfCmap(
-        generate_tounicode_cmap(fFontInfo->fGlyphToUnicode, subset));
+        generate_tounicode_cmap(fFontInfo->fGlyphToUnicode, subset,
+                                firstGlyphID(), lastGlyphID()));
     addResource(pdfCmap.get());
     insert("ToUnicode", new SkPDFObjRef(pdfCmap.get()))->unref();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFType0Font
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPDFType0Font::SkPDFType0Font(SkAdvancedTypefaceMetrics* info,
                                SkTypeface* typeface)
@@ skipping 380 matching lines @@
 
     insert("FontBBox", makeFontBBox(bbox, 1000))->unref();
     insertInt("FirstChar", firstGlyphID());
     insertInt("LastChar", lastGlyphID());
     insert("Widths", widthArray.get());
     insertName("CIDToGIDMap", "Identity");
 
     populateToUnicodeTable(NULL);
     return true;
 }