Home | History | Annotate | Download | only in pdf 
      1 /*
      2  * Copyright 2011 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 
      8 #include <ctype.h>
      9 
     10 #include "SkData.h"
     11 #include "SkGlyphCache.h"
     12 #include "SkPaint.h"
     13 #include "SkPDFCanon.h"
     14 #include "SkPDFDevice.h"
     15 #include "SkPDFFont.h"
     16 #include "SkPDFFontImpl.h"
     17 #include "SkPDFStream.h"
     18 #include "SkPDFTypes.h"
     19 #include "SkPDFUtils.h"
     20 #include "SkRefCnt.h"
     21 #include "SkScalar.h"
     22 #include "SkStream.h"
     23 #include "SkTypefacePriv.h"
     24 #include "SkTypes.h"
     25 #include "SkUtils.h"
     26 
     27 #if defined (SK_SFNTLY_SUBSETTER)
     28     #include SK_SFNTLY_SUBSETTER
     29 #endif
     30 
     31 #if defined (GOOGLE3)
     32     // #including #defines doesn't work in with this build system.
     33     #include "typography/font/sfntly/src/sample/chromium/font_subsetter.h"
     34     #define SK_SFNTLY_SUBSETTER  // For the benefit of #ifdefs below.
     35 #endif
     36 
     37 // PDF's notion of symbolic vs non-symbolic is related to the character set, not
     38 // symbols vs. characters.  Rarely is a font the right character set to call it
     39 // non-symbolic, so always call it symbolic.  (PDF 1.4 spec, section 5.7.1)
     40 static const int kPdfSymbolic = 4;
     41 
     42 namespace {
     43 
     44 ///////////////////////////////////////////////////////////////////////////////
     45 // File-Local Functions
     46 ///////////////////////////////////////////////////////////////////////////////
     47 
     48 bool parsePFBSection(const uint8_t** src, size_t* len, int sectionType,
     49                      size_t* size) {
     50     // PFB sections have a two or six bytes header. 0x80 and a one byte
     51     // section type followed by a four byte section length.  Type one is
     52     // an ASCII section (includes a length), type two is a binary section
     53     // (includes a length) and type three is an EOF marker with no length.
     54     const uint8_t* buf = *src;
     55     if (*len < 2 || buf[0] != 0x80 || buf[1] != sectionType) {
     56         return false;
     57     } else if (buf[1] == 3) {
     58         return true;
     59     } else if (*len < 6) {
     60         return false;
     61     }
     62 
     63     *size = (size_t)buf[2] | ((size_t)buf[3] << 8) | ((size_t)buf[4] << 16) |
     64             ((size_t)buf[5] << 24);
     65     size_t consumed = *size + 6;
     66     if (consumed > *len) {
     67         return false;
     68     }
     69     *src = *src + consumed;
     70     *len = *len - consumed;
     71     return true;
     72 }
     73 
     74 bool parsePFB(const uint8_t* src, size_t size, size_t* headerLen,
     75               size_t* dataLen, size_t* trailerLen) {
     76     const uint8_t* srcPtr = src;
     77     size_t remaining = size;
     78 
     79     return parsePFBSection(&srcPtr, &remaining, 1, headerLen) &&
     80            parsePFBSection(&srcPtr, &remaining, 2, dataLen) &&
     81            parsePFBSection(&srcPtr, &remaining, 1, trailerLen) &&
     82            parsePFBSection(&srcPtr, &remaining, 3, NULL);
     83 }
     84 
     85 /* The sections of a PFA file are implicitly defined.  The body starts
     86  * after the line containing "eexec," and the trailer starts with 512
     87  * literal 0's followed by "cleartomark" (plus arbitrary white space).
     88  *
     89  * This function assumes that src is NUL terminated, but the NUL
     90  * termination is not included in size.
     91  *
     92  */
     93 bool parsePFA(const char* src, size_t size, size_t* headerLen,
     94               size_t* hexDataLen, size_t* dataLen, size_t* trailerLen) {
     95     const char* end = src + size;
     96 
     97     const char* dataPos = strstr(src, "eexec");
     98     if (!dataPos) {
     99         return false;
    100     }
    101     dataPos += strlen("eexec");
    102     while ((*dataPos == '\n' || *dataPos == '\r' || *dataPos == ' ') &&
    103             dataPos < end) {
    104         dataPos++;
    105     }
    106     *headerLen = dataPos - src;
    107 
    108     const char* trailerPos = strstr(dataPos, "cleartomark");
    109     if (!trailerPos) {
    110         return false;
    111     }
    112     int zeroCount = 0;
    113     for (trailerPos--; trailerPos > dataPos && zeroCount < 512; trailerPos--) {
    114         if (*trailerPos == '\n' || *trailerPos == '\r' || *trailerPos == ' ') {
    115             continue;
    116         } else if (*trailerPos == '0') {
    117             zeroCount++;
    118         } else {
    119             return false;
    120         }
    121     }
    122     if (zeroCount != 512) {
    123         return false;
    124     }
    125 
    126     *hexDataLen = trailerPos - src - *headerLen;
    127     *trailerLen = size - *headerLen - *hexDataLen;
    128 
    129     // Verify that the data section is hex encoded and count the bytes.
    130     int nibbles = 0;
    131     for (; dataPos < trailerPos; dataPos++) {
    132         if (isspace(*dataPos)) {
    133             continue;
    134         }
    135         if (!isxdigit(*dataPos)) {
    136             return false;
    137         }
    138         nibbles++;
    139     }
    140     *dataLen = (nibbles + 1) / 2;
    141 
    142     return true;
    143 }
    144 
    145 int8_t hexToBin(uint8_t c) {
    146     if (!isxdigit(c)) {
    147         return -1;
    148     } else if (c <= '9') {
    149         return c - '0';
    150     } else if (c <= 'F') {
    151         return c - 'A' + 10;
    152     } else if (c <= 'f') {
    153         return c - 'a' + 10;
    154     }
    155     return -1;
    156 }
    157 
    158 static SkData* handle_type1_stream(SkStream* srcStream, size_t* headerLen,
    159                                    size_t* dataLen, size_t* trailerLen) {
    160     // srcStream may be backed by a file or a unseekable fd, so we may not be
    161     // able to use skip(), rewind(), or getMemoryBase().  read()ing through
    162     // the input only once is doable, but very ugly. Furthermore, it'd be nice
    163     // if the data was NUL terminated so that we can use strstr() to search it.
    164     // Make as few copies as possible given these constraints.
    165     SkDynamicMemoryWStream dynamicStream;
    166     SkAutoTDelete<SkMemoryStream> staticStream;
    167     SkData* data = NULL;
    168     const uint8_t* src;
    169     size_t srcLen;
    170     if ((srcLen = srcStream->getLength()) > 0) {
    171         staticStream.reset(new SkMemoryStream(srcLen + 1));
    172         src = (const uint8_t*)staticStream->getMemoryBase();
    173         if (srcStream->getMemoryBase() != NULL) {
    174             memcpy((void *)src, srcStream->getMemoryBase(), srcLen);
    175         } else {
    176             size_t read = 0;
    177             while (read < srcLen) {
    178                 size_t got = srcStream->read((void *)staticStream->getAtPos(),
    179                                              srcLen - read);
    180                 if (got == 0) {
    181                     return NULL;
    182                 }
    183                 read += got;
    184                 staticStream->seek(read);
    185             }
    186         }
    187         ((uint8_t *)src)[srcLen] = 0;
    188     } else {
    189         static const size_t kBufSize = 4096;
    190         uint8_t buf[kBufSize];
    191         size_t amount;
    192         while ((amount = srcStream->read(buf, kBufSize)) > 0) {
    193             dynamicStream.write(buf, amount);
    194         }
    195         amount = 0;
    196         dynamicStream.write(&amount, 1);  // NULL terminator.
    197         data = dynamicStream.copyToData();
    198         src = data->bytes();
    199         srcLen = data->size() - 1;
    200     }
    201 
    202     // this handles releasing the data we may have gotten from dynamicStream.
    203     // if data is null, it is a no-op
    204     SkAutoDataUnref aud(data);
    205 
    206     if (parsePFB(src, srcLen, headerLen, dataLen, trailerLen)) {
    207         static const int kPFBSectionHeaderLength = 6;
    208         const size_t length = *headerLen + *dataLen + *trailerLen;
    209         SkASSERT(length > 0);
    210         SkASSERT(length + (2 * kPFBSectionHeaderLength) <= srcLen);
    211 
    212         SkData* data = SkData::NewUninitialized(length);
    213 
    214         const uint8_t* const srcHeader = src + kPFBSectionHeaderLength;
    215         // There is a six-byte section header before header and data
    216         // (but not trailer) that we're not going to copy.
    217         const uint8_t* const srcData = srcHeader + *headerLen + kPFBSectionHeaderLength;
    218         const uint8_t* const srcTrailer = srcData + *headerLen;
    219 
    220         uint8_t* const resultHeader = (uint8_t*)data->writable_data();
    221         uint8_t* const resultData = resultHeader + *headerLen;
    222         uint8_t* const resultTrailer = resultData + *dataLen;
    223 
    224         SkASSERT(resultTrailer + *trailerLen == resultHeader + length);
    225 
    226         memcpy(resultHeader,  srcHeader,  *headerLen);
    227         memcpy(resultData,    srcData,    *dataLen);
    228         memcpy(resultTrailer, srcTrailer, *trailerLen);
    229 
    230         return data;
    231     }
    232 
    233     // A PFA has to be converted for PDF.
    234     size_t hexDataLen;
    235     if (parsePFA((const char*)src, srcLen, headerLen, &hexDataLen, dataLen,
    236                  trailerLen)) {
    237         const size_t length = *headerLen + *dataLen + *trailerLen;
    238         SkASSERT(length > 0);
    239         SkAutoTMalloc<uint8_t> buffer(length);
    240 
    241         memcpy(buffer.get(), src, *headerLen);
    242         uint8_t* const resultData = &(buffer[SkToInt(*headerLen)]);
    243 
    244         const uint8_t* hexData = src + *headerLen;
    245         const uint8_t* trailer = hexData + hexDataLen;
    246         size_t outputOffset = 0;
    247         uint8_t dataByte = 0;  // To hush compiler.
    248         bool highNibble = true;
    249         for (; hexData < trailer; hexData++) {
    250             int8_t curNibble = hexToBin(*hexData);
    251             if (curNibble < 0) {
    252                 continue;
    253             }
    254             if (highNibble) {
    255                 dataByte = curNibble << 4;
    256                 highNibble = false;
    257             } else {
    258                 dataByte |= curNibble;
    259                 highNibble = true;
    260                 resultData[outputOffset++] = dataByte;
    261             }
    262         }
    263         if (!highNibble) {
    264             resultData[outputOffset++] = dataByte;
    265         }
    266         SkASSERT(outputOffset == *dataLen);
    267 
    268         uint8_t* const resultTrailer = &(buffer[SkToInt(*headerLen + outputOffset)]);
    269         memcpy(resultTrailer, src + *headerLen + hexDataLen, *trailerLen);
    270 
    271         return SkData::NewFromMalloc(buffer.detach(), length);
    272     }
    273     return NULL;
    274 }
    275 
    276 // scale from em-units to base-1000, returning as a SkScalar
    277 SkScalar scaleFromFontUnits(int16_t val, uint16_t emSize) {
    278     SkScalar scaled = SkIntToScalar(val);
    279     if (emSize == 1000) {
    280         return scaled;
    281     } else {
    282         return SkScalarMulDiv(scaled, 1000, emSize);
    283     }
    284 }
    285 
    286 void setGlyphWidthAndBoundingBox(SkScalar width, SkIRect box,
    287                                  SkWStream* content) {
    288     // Specify width and bounding box for the glyph.
    289     SkPDFUtils::AppendScalar(width, content);
    290     content->writeText(" 0 ");
    291     content->writeDecAsText(box.fLeft);
    292     content->writeText(" ");
    293     content->writeDecAsText(box.fTop);
    294     content->writeText(" ");
    295     content->writeDecAsText(box.fRight);
    296     content->writeText(" ");
    297     content->writeDecAsText(box.fBottom);
    298     content->writeText(" d1\n");
    299 }
    300 
    301 SkPDFArray* makeFontBBox(SkIRect glyphBBox, uint16_t emSize) {
    302     SkPDFArray* bbox = new SkPDFArray;
    303     bbox->reserve(4);
    304     bbox->appendScalar(scaleFromFontUnits(glyphBBox.fLeft, emSize));
    305     bbox->appendScalar(scaleFromFontUnits(glyphBBox.fBottom, emSize));
    306     bbox->appendScalar(scaleFromFontUnits(glyphBBox.fRight, emSize));
    307     bbox->appendScalar(scaleFromFontUnits(glyphBBox.fTop, emSize));
    308     return bbox;
    309 }
    310 
    311 SkPDFArray* appendWidth(const int16_t& width, uint16_t emSize,
    312                         SkPDFArray* array) {
    313     array->appendScalar(scaleFromFontUnits(width, emSize));
    314     return array;
    315 }
    316 
    317 SkPDFArray* appendVerticalAdvance(
    318         const SkAdvancedTypefaceMetrics::VerticalMetric& advance,
    319         uint16_t emSize, SkPDFArray* array) {
    320     appendWidth(advance.fVerticalAdvance, emSize, array);
    321     appendWidth(advance.fOriginXDisp, emSize, array);
    322     appendWidth(advance.fOriginYDisp, emSize, array);
    323     return array;
    324 }
    325 
    326 template <typename Data>
    327 SkPDFArray* composeAdvanceData(
    328         SkAdvancedTypefaceMetrics::AdvanceMetric<Data>* advanceInfo,
    329         uint16_t emSize,
    330         SkPDFArray* (*appendAdvance)(const Data& advance, uint16_t emSize,
    331                                      SkPDFArray* array),
    332         Data* defaultAdvance) {
    333     SkPDFArray* result = new SkPDFArray();
    334     for (; advanceInfo != NULL; advanceInfo = advanceInfo->fNext.get()) {
    335         switch (advanceInfo->fType) {
    336             case SkAdvancedTypefaceMetrics::WidthRange::kDefault: {
    337                 SkASSERT(advanceInfo->fAdvance.count() == 1);
    338                 *defaultAdvance = advanceInfo->fAdvance[0];
    339                 break;
    340             }
    341             case SkAdvancedTypefaceMetrics::WidthRange::kRange: {
    342                 SkAutoTUnref<SkPDFArray> advanceArray(new SkPDFArray());
    343                 for (int j = 0; j < advanceInfo->fAdvance.count(); j++)
    344                     appendAdvance(advanceInfo->fAdvance[j], emSize,
    345                                   advanceArray.get());
    346                 result->appendInt(advanceInfo->fStartId);
    347                 result->appendObject(advanceArray.detach());
    348                 break;
    349             }
    350             case SkAdvancedTypefaceMetrics::WidthRange::kRun: {
    351                 SkASSERT(advanceInfo->fAdvance.count() == 1);
    352                 result->appendInt(advanceInfo->fStartId);
    353                 result->appendInt(advanceInfo->fEndId);
    354                 appendAdvance(advanceInfo->fAdvance[0], emSize, result);
    355                 break;
    356             }
    357         }
    358     }
    359     return result;
    360 }
    361 
    362 }  // namespace
    363 
    364 static void append_tounicode_header(SkDynamicMemoryWStream* cmap,
    365                                     uint16_t firstGlyphID,
    366                                     uint16_t lastGlyphID) {
    367     // 12 dict begin: 12 is an Adobe-suggested value. Shall not change.
    368     // It's there to prevent old version Adobe Readers from malfunctioning.
    369     const char* kHeader =
    370         "/CIDInit /ProcSet findresource begin\n"
    371         "12 dict begin\n"
    372         "begincmap\n";
    373     cmap->writeText(kHeader);
    374 
    375     // The /CIDSystemInfo must be consistent to the one in
    376     // SkPDFFont::populateCIDFont().
    377     // We can not pass over the system info object here because the format is
    378     // different. This is not a reference object.
    379     const char* kSysInfo =
    380         "/CIDSystemInfo\n"
    381         "<<  /Registry (Adobe)\n"
    382         "/Ordering (UCS)\n"
    383         "/Supplement 0\n"
    384         ">> def\n";
    385     cmap->writeText(kSysInfo);
    386 
    387     // The CMapName must be consistent to /CIDSystemInfo above.
    388     // /CMapType 2 means ToUnicode.
    389     // Codespace range just tells the PDF processor the valid range.
    390     const char* kTypeInfoHeader =
    391         "/CMapName /Adobe-Identity-UCS def\n"
    392         "/CMapType 2 def\n"
    393         "1 begincodespacerange\n";
    394     cmap->writeText(kTypeInfoHeader);
    395 
    396     // e.g.     "<0000> <FFFF>\n"
    397     SkString range;
    398     range.appendf("<%04X> <%04X>\n", firstGlyphID, lastGlyphID);
    399     cmap->writeText(range.c_str());
    400 
    401     const char* kTypeInfoFooter = "endcodespacerange\n";
    402     cmap->writeText(kTypeInfoFooter);
    403 }
    404 
    405 static void append_cmap_footer(SkDynamicMemoryWStream* cmap) {
    406     const char* kFooter =
    407         "endcmap\n"
    408         "CMapName currentdict /CMap defineresource pop\n"
    409         "end\n"
    410         "end";
    411     cmap->writeText(kFooter);
    412 }
    413 
    414 struct BFChar {
    415     uint16_t fGlyphId;
    416     SkUnichar fUnicode;
    417 };
    418 
    419 struct BFRange {
    420     uint16_t fStart;
    421     uint16_t fEnd;
    422     SkUnichar fUnicode;
    423 };
    424 
    425 static void append_bfchar_section(const SkTDArray<BFChar>& bfchar,
    426                                   SkDynamicMemoryWStream* cmap) {
    427     // PDF spec defines that every bf* list can have at most 100 entries.
    428     for (int i = 0; i < bfchar.count(); i += 100) {
    429         int count = bfchar.count() - i;
    430         count = SkMin32(count, 100);
    431         cmap->writeDecAsText(count);
    432         cmap->writeText(" beginbfchar\n");
    433         for (int j = 0; j < count; ++j) {
    434             cmap->writeText("<");
    435             cmap->writeHexAsText(bfchar[i + j].fGlyphId, 4);
    436             cmap->writeText("> <");
    437             cmap->writeHexAsText(bfchar[i + j].fUnicode, 4);
    438             cmap->writeText(">\n");
    439         }
    440         cmap->writeText("endbfchar\n");
    441     }
    442 }
    443 
    444 static void append_bfrange_section(const SkTDArray<BFRange>& bfrange,
    445                                    SkDynamicMemoryWStream* cmap) {
    446     // PDF spec defines that every bf* list can have at most 100 entries.
    447     for (int i = 0; i < bfrange.count(); i += 100) {
    448         int count = bfrange.count() - i;
    449         count = SkMin32(count, 100);
    450         cmap->writeDecAsText(count);
    451         cmap->writeText(" beginbfrange\n");
    452         for (int j = 0; j < count; ++j) {
    453             cmap->writeText("<");
    454             cmap->writeHexAsText(bfrange[i + j].fStart, 4);
    455             cmap->writeText("> <");
    456             cmap->writeHexAsText(bfrange[i + j].fEnd, 4);
    457             cmap->writeText("> <");
    458             cmap->writeHexAsText(bfrange[i + j].fUnicode, 4);
    459             cmap->writeText(">\n");
    460         }
    461         cmap->writeText("endbfrange\n");
    462     }
    463 }
    464 
    465 // Generate <bfchar> and <bfrange> table according to PDF spec 1.4 and Adobe
    466 // Technote 5014.
    467 // The function is not static so we can test it in unit tests.
    468 //
    469 // Current implementation guarantees bfchar and bfrange entries do not overlap.
    470 //
    471 // Current implementation does not attempt aggresive optimizations against
    472 // following case because the specification is not clear.
    473 //
    474 // 4 beginbfchar          1 beginbfchar
    475 // <0003> <0013>          <0020> <0014>
    476 // <0005> <0015>    to    endbfchar
    477 // <0007> <0017>          1 beginbfrange
    478 // <0020> <0014>          <0003> <0007> <0013>
    479 // endbfchar              endbfrange
    480 //
    481 // Adobe Technote 5014 said: "Code mappings (unlike codespace ranges) may
    482 // overlap, but succeeding maps supersede preceding maps."
    483 //
    484 // In case of searching text in PDF, bfrange will have higher precedence so
    485 // typing char id 0x0014 in search box will get glyph id 0x0004 first.  However,
    486 // the spec does not mention how will this kind of conflict being resolved.
    487 //
    488 // For the worst case (having 65536 continuous unicode and we use every other
    489 // one of them), the possible savings by aggressive optimization is 416KB
    490 // pre-compressed and does not provide enough motivation for implementation.
    491 
    492 // FIXME: this should be in a header so that it is separately testable
    493 // ( see caller in tests/ToUnicode.cpp )
    494 void append_cmap_sections(const SkTDArray<SkUnichar>& glyphToUnicode,
    495                           const SkPDFGlyphSet* subset,
    496                           SkDynamicMemoryWStream* cmap,
    497                           bool multiByteGlyphs,
    498                           uint16_t firstGlyphID,
    499                           uint16_t lastGlyphID);
    500 
    501 void append_cmap_sections(const SkTDArray<SkUnichar>& glyphToUnicode,
    502                           const SkPDFGlyphSet* subset,
    503                           SkDynamicMemoryWStream* cmap,
    504                           bool multiByteGlyphs,
    505                           uint16_t firstGlyphID,
    506                           uint16_t lastGlyphID) {
    507     if (glyphToUnicode.isEmpty()) {
    508         return;
    509     }
    510     int glyphOffset = 0;
    511     if (!multiByteGlyphs) {
    512         glyphOffset = firstGlyphID - 1;
    513     }
    514 
    515     SkTDArray<BFChar> bfcharEntries;
    516     SkTDArray<BFRange> bfrangeEntries;
    517 
    518     BFRange currentRangeEntry = {0, 0, 0};
    519     bool rangeEmpty = true;
    520     const int limit =
    521             SkMin32(lastGlyphID + 1, glyphToUnicode.count()) - glyphOffset;
    522 
    523     for (int i = firstGlyphID - glyphOffset; i < limit + 1; ++i) {
    524         bool inSubset = i < limit &&
    525                         (subset == NULL || subset->has(i + glyphOffset));
    526         if (!rangeEmpty) {
    527             // PDF spec requires bfrange not changing the higher byte,
    528             // e.g. <1035> <10FF> <2222> is ok, but
    529             //      <1035> <1100> <2222> is no good
    530             bool inRange =
    531                 i == currentRangeEntry.fEnd + 1 &&
    532                 i >> 8 == currentRangeEntry.fStart >> 8 &&
    533                 i < limit &&
    534                 glyphToUnicode[i + glyphOffset] ==
    535                     currentRangeEntry.fUnicode + i - currentRangeEntry.fStart;
    536             if (!inSubset || !inRange) {
    537                 if (currentRangeEntry.fEnd > currentRangeEntry.fStart) {
    538                     bfrangeEntries.push(currentRangeEntry);
    539                 } else {
    540                     BFChar* entry = bfcharEntries.append();
    541                     entry->fGlyphId = currentRangeEntry.fStart;
    542                     entry->fUnicode = currentRangeEntry.fUnicode;
    543                 }
    544                 rangeEmpty = true;
    545             }
    546         }
    547         if (inSubset) {
    548             currentRangeEntry.fEnd = i;
    549             if (rangeEmpty) {
    550               currentRangeEntry.fStart = i;
    551               currentRangeEntry.fUnicode = glyphToUnicode[i + glyphOffset];
    552               rangeEmpty = false;
    553             }
    554         }
    555     }
    556 
    557     // The spec requires all bfchar entries for a font must come before bfrange
    558     // entries.
    559     append_bfchar_section(bfcharEntries, cmap);
    560     append_bfrange_section(bfrangeEntries, cmap);
    561 }
    562 
    563 static SkPDFStream* generate_tounicode_cmap(
    564         const SkTDArray<SkUnichar>& glyphToUnicode,
    565         const SkPDFGlyphSet* subset,
    566         bool multiByteGlyphs,
    567         uint16_t firstGlyphID,
    568         uint16_t lastGlyphID) {
    569     SkDynamicMemoryWStream cmap;
    570     if (multiByteGlyphs) {
    571         append_tounicode_header(&cmap, firstGlyphID, lastGlyphID);
    572     } else {
    573         append_tounicode_header(&cmap, 1, lastGlyphID - firstGlyphID + 1);
    574     }
    575     append_cmap_sections(glyphToUnicode, subset, &cmap, multiByteGlyphs,
    576                          firstGlyphID, lastGlyphID);
    577     append_cmap_footer(&cmap);
    578     SkAutoTUnref<SkData> cmapData(cmap.copyToData());
    579     return new SkPDFStream(cmapData.get());
    580 }
    581 
    582 #if defined (SK_SFNTLY_SUBSETTER)
    583 static void sk_delete_array(const void* ptr, size_t, void*) {
    584     // Use C-style cast to cast away const and cast type simultaneously.
    585     delete[] (unsigned char*)ptr;
    586 }
    587 #endif
    588 
    589 static size_t get_subset_font_stream(const char* fontName,
    590                                      const SkTypeface* typeface,
    591                                      const SkTDArray<uint32_t>& subset,
    592                                      SkPDFStream** fontStream) {
    593     int ttcIndex;
    594     SkAutoTDelete<SkStream> fontData(typeface->openStream(&ttcIndex));
    595     SkASSERT(fontData.get());
    596 
    597     size_t fontSize = fontData->getLength();
    598 
    599 #if defined (SK_SFNTLY_SUBSETTER)
    600     // Read font into buffer.
    601     SkPDFStream* subsetFontStream = NULL;
    602     SkTDArray<unsigned char> originalFont;
    603     originalFont.setCount(SkToInt(fontSize));
    604     if (fontData->read(originalFont.begin(), fontSize) == fontSize) {
    605         unsigned char* subsetFont = NULL;
    606         // sfntly requires unsigned int* to be passed in, as far as we know,
    607         // unsigned int is equivalent to uint32_t on all platforms.
    608         SK_COMPILE_ASSERT(sizeof(unsigned int) == sizeof(uint32_t),
    609                           unsigned_int_not_32_bits);
    610         int subsetFontSize = SfntlyWrapper::SubsetFont(fontName,
    611                                                        originalFont.begin(),
    612                                                        fontSize,
    613                                                        subset.begin(),
    614                                                        subset.count(),
    615                                                        &subsetFont);
    616         if (subsetFontSize > 0 && subsetFont != NULL) {
    617             SkAutoDataUnref data(SkData::NewWithProc(subsetFont,
    618                                                      subsetFontSize,
    619                                                      sk_delete_array,
    620                                                      NULL));
    621             subsetFontStream = new SkPDFStream(data.get());
    622             fontSize = subsetFontSize;
    623         }
    624     }
    625     if (subsetFontStream) {
    626         *fontStream = subsetFontStream;
    627         return fontSize;
    628     }
    629     fontData->rewind();
    630 #else
    631     sk_ignore_unused_variable(fontName);
    632     sk_ignore_unused_variable(subset);
    633 #endif
    634 
    635     // Fail over: just embed the whole font.
    636     *fontStream = new SkPDFStream(fontData.get());
    637     return fontSize;
    638 }
    639 
    640 ///////////////////////////////////////////////////////////////////////////////
    641 // class SkPDFGlyphSet
    642 ///////////////////////////////////////////////////////////////////////////////
    643 
    644 SkPDFGlyphSet::SkPDFGlyphSet() : fBitSet(SK_MaxU16 + 1) {
    645 }
    646 
    647 void SkPDFGlyphSet::set(const uint16_t* glyphIDs, int numGlyphs) {
    648     for (int i = 0; i < numGlyphs; ++i) {
    649         fBitSet.setBit(glyphIDs[i], true);
    650     }
    651 }
    652 
    653 bool SkPDFGlyphSet::has(uint16_t glyphID) const {
    654     return fBitSet.isBitSet(glyphID);
    655 }
    656 
    657 void SkPDFGlyphSet::merge(const SkPDFGlyphSet& usage) {
    658     fBitSet.orBits(usage.fBitSet);
    659 }
    660 
    661 void SkPDFGlyphSet::exportTo(SkTDArray<unsigned int>* glyphIDs) const {
    662     fBitSet.exportTo(glyphIDs);
    663 }
    664 
    665 ///////////////////////////////////////////////////////////////////////////////
    666 // class SkPDFGlyphSetMap
    667 ///////////////////////////////////////////////////////////////////////////////
    668 SkPDFGlyphSetMap::FontGlyphSetPair::FontGlyphSetPair(SkPDFFont* font,
    669                                                      SkPDFGlyphSet* glyphSet)
    670         : fFont(font),
    671           fGlyphSet(glyphSet) {
    672 }
    673 
    674 SkPDFGlyphSetMap::F2BIter::F2BIter(const SkPDFGlyphSetMap& map) {
    675     reset(map);
    676 }
    677 
    678 const SkPDFGlyphSetMap::FontGlyphSetPair* SkPDFGlyphSetMap::F2BIter::next() const {
    679     if (fIndex >= fMap->count()) {
    680         return NULL;
    681     }
    682     return &((*fMap)[fIndex++]);
    683 }
    684 
    685 void SkPDFGlyphSetMap::F2BIter::reset(const SkPDFGlyphSetMap& map) {
    686     fMap = &(map.fMap);
    687     fIndex = 0;
    688 }
    689 
    690 SkPDFGlyphSetMap::SkPDFGlyphSetMap() {
    691 }
    692 
    693 SkPDFGlyphSetMap::~SkPDFGlyphSetMap() {
    694     reset();
    695 }
    696 
    697 void SkPDFGlyphSetMap::merge(const SkPDFGlyphSetMap& usage) {
    698     for (int i = 0; i < usage.fMap.count(); ++i) {
    699         SkPDFGlyphSet* myUsage = getGlyphSetForFont(usage.fMap[i].fFont);
    700         myUsage->merge(*(usage.fMap[i].fGlyphSet));
    701     }
    702 }
    703 
    704 void SkPDFGlyphSetMap::reset() {
    705     for (int i = 0; i < fMap.count(); ++i) {
    706         delete fMap[i].fGlyphSet;  // Should not be NULL.
    707     }
    708     fMap.reset();
    709 }
    710 
    711 void SkPDFGlyphSetMap::noteGlyphUsage(SkPDFFont* font, const uint16_t* glyphIDs,
    712                                       int numGlyphs) {
    713     SkPDFGlyphSet* subset = getGlyphSetForFont(font);
    714     if (subset) {
    715         subset->set(glyphIDs, numGlyphs);
    716     }
    717 }
    718 
    719 SkPDFGlyphSet* SkPDFGlyphSetMap::getGlyphSetForFont(SkPDFFont* font) {
    720     int index = fMap.count();
    721     for (int i = 0; i < index; ++i) {
    722         if (fMap[i].fFont == font) {
    723             return fMap[i].fGlyphSet;
    724         }
    725     }
    726     fMap.append();
    727     index = fMap.count() - 1;
    728     fMap[index].fFont = font;
    729     fMap[index].fGlyphSet = new SkPDFGlyphSet();
    730     return fMap[index].fGlyphSet;
    731 }
    732 
    733 ///////////////////////////////////////////////////////////////////////////////
    734 // class SkPDFFont
    735 ///////////////////////////////////////////////////////////////////////////////
    736 
    737 /* Font subset design: It would be nice to be able to subset fonts
    738  * (particularly type 3 fonts), but it's a lot of work and not a priority.
    739  *
    740  * Resources are canonicalized and uniqueified by pointer so there has to be
    741  * some additional state indicating which subset of the font is used.  It
    742  * must be maintained at the page granularity and then combined at the document
    743  * granularity. a) change SkPDFFont to fill in its state on demand, kind of
    744  * like SkPDFGraphicState.  b) maintain a per font glyph usage class in each
    745  * page/pdf device. c) in the document, retrieve the per font glyph usage
    746  * from each page and combine it and ask for a resource with that subset.
    747  */
    748 
    749 SkPDFFont::~SkPDFFont() {}
    750 
    751 SkTypeface* SkPDFFont::typeface() {
    752     return fTypeface.get();
    753 }
    754 
    755 SkAdvancedTypefaceMetrics::FontType SkPDFFont::getType() {
    756     return fFontType;
    757 }
    758 
    759 bool SkPDFFont::canEmbed() const {
    760     if (!fFontInfo.get()) {
    761         SkASSERT(fFontType == SkAdvancedTypefaceMetrics::kOther_Font);
    762         return true;
    763     }
    764     return (fFontInfo->fFlags &
    765             SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag) == 0;
    766 }
    767 
    768 bool SkPDFFont::canSubset() const {
    769     if (!fFontInfo.get()) {
    770         SkASSERT(fFontType == SkAdvancedTypefaceMetrics::kOther_Font);
    771         return true;
    772     }
    773     return (fFontInfo->fFlags &
    774             SkAdvancedTypefaceMetrics::kNotSubsettable_FontFlag) == 0;
    775 }
    776 
    777 bool SkPDFFont::hasGlyph(uint16_t id) {
    778     return (id >= fFirstGlyphID && id <= fLastGlyphID) || id == 0;
    779 }
    780 
    781 int SkPDFFont::glyphsToPDFFontEncoding(uint16_t* glyphIDs, int numGlyphs) {
    782     // A font with multibyte glyphs will support all glyph IDs in a single font.
    783     if (this->multiByteGlyphs()) {
    784         return numGlyphs;
    785     }
    786 
    787     for (int i = 0; i < numGlyphs; i++) {
    788         if (glyphIDs[i] == 0) {
    789             continue;
    790         }
    791         if (glyphIDs[i] < fFirstGlyphID || glyphIDs[i] > fLastGlyphID) {
    792             return i;
    793         }
    794         glyphIDs[i] -= (fFirstGlyphID - 1);
    795     }
    796 
    797     return numGlyphs;
    798 }
    799 
    800 // static
    801 SkPDFFont* SkPDFFont::GetFontResource(SkPDFCanon* canon,
    802                                       SkTypeface* typeface,
    803                                       uint16_t glyphID) {
    804     SkASSERT(canon);
    805     SkAutoResolveDefaultTypeface autoResolve(typeface);
    806     typeface = autoResolve.get();
    807     const uint32_t fontID = typeface->uniqueID();
    808 
    809     SkPDFFont* relatedFont;
    810     if (SkPDFFont* pdfFont = canon->findFont(fontID, glyphID, &relatedFont)) {
    811         return SkRef(pdfFont);
    812     }
    813 
    814     SkAutoTUnref<const SkAdvancedTypefaceMetrics> fontMetrics;
    815     SkPDFDict* relatedFontDescriptor = NULL;
    816     if (relatedFont) {
    817         fontMetrics.reset(SkSafeRef(relatedFont->fontInfo()));
    818         relatedFontDescriptor = relatedFont->getFontDescriptor();
    819 
    820         // This only is to catch callers who pass invalid glyph ids.
    821         // If glyph id is invalid, then we will create duplicate entries
    822         // for TrueType fonts.
    823         SkAdvancedTypefaceMetrics::FontType fontType =
    824             fontMetrics.get() ? fontMetrics.get()->fType :
    825                                 SkAdvancedTypefaceMetrics::kOther_Font;
    826 
    827         if (fontType == SkAdvancedTypefaceMetrics::kType1CID_Font ||
    828             fontType == SkAdvancedTypefaceMetrics::kTrueType_Font) {
    829             return SkRef(relatedFont);
    830         }
    831     } else {
    832         SkTypeface::PerGlyphInfo info;
    833         info = SkTypeface::kGlyphNames_PerGlyphInfo;
    834         info = SkTBitOr<SkTypeface::PerGlyphInfo>(
    835                   info, SkTypeface::kToUnicode_PerGlyphInfo);
    836 #if !defined (SK_SFNTLY_SUBSETTER)
    837         info = SkTBitOr<SkTypeface::PerGlyphInfo>(
    838                   info, SkTypeface::kHAdvance_PerGlyphInfo);
    839 #endif
    840         fontMetrics.reset(
    841             typeface->getAdvancedTypefaceMetrics(info, NULL, 0));
    842 #if defined (SK_SFNTLY_SUBSETTER)
    843         if (fontMetrics.get() &&
    844             fontMetrics->fType != SkAdvancedTypefaceMetrics::kTrueType_Font) {
    845             // Font does not support subsetting, get new info with advance.
    846             info = SkTBitOr<SkTypeface::PerGlyphInfo>(
    847                       info, SkTypeface::kHAdvance_PerGlyphInfo);
    848             fontMetrics.reset(
    849                 typeface->getAdvancedTypefaceMetrics(info, NULL, 0));
    850         }
    851 #endif
    852     }
    853 
    854     SkPDFFont* font = SkPDFFont::Create(canon, fontMetrics.get(), typeface,
    855                                         glyphID, relatedFontDescriptor);
    856     canon->addFont(font, fontID, font->fFirstGlyphID);
    857     return font;
    858 }
    859 
    860 SkPDFFont* SkPDFFont::getFontSubset(const SkPDFGlyphSet*) {
    861     return NULL;  // Default: no support.
    862 }
    863 
    864 SkPDFFont::SkPDFFont(const SkAdvancedTypefaceMetrics* info,
    865                      SkTypeface* typeface,
    866                      SkPDFDict* relatedFontDescriptor)
    867     : SkPDFDict("Font")
    868     , fTypeface(ref_or_default(typeface))
    869     , fFirstGlyphID(1)
    870     , fLastGlyphID(info ? info->fLastGlyphID : 0)
    871     , fFontInfo(SkSafeRef(info))
    872     , fDescriptor(SkSafeRef(relatedFontDescriptor)) {
    873     if (info == NULL ||
    874             info->fFlags & SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag) {
    875         fFontType = SkAdvancedTypefaceMetrics::kOther_Font;
    876     } else {
    877         fFontType = info->fType;
    878     }
    879 }
    880 
    881 // static
    882 SkPDFFont* SkPDFFont::Create(SkPDFCanon* canon,
    883                              const SkAdvancedTypefaceMetrics* info,
    884                              SkTypeface* typeface,
    885                              uint16_t glyphID,
    886                              SkPDFDict* relatedFontDescriptor) {
    887     SkAdvancedTypefaceMetrics::FontType type =
    888         info ? info->fType : SkAdvancedTypefaceMetrics::kOther_Font;
    889 
    890     if (info &&
    891             (info->fFlags & SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag)) {
    892         NOT_IMPLEMENTED(true, true);
    893         return new SkPDFType3Font(info, typeface, glyphID);
    894     }
    895     if (type == SkAdvancedTypefaceMetrics::kType1CID_Font ||
    896         type == SkAdvancedTypefaceMetrics::kTrueType_Font) {
    897         SkASSERT(relatedFontDescriptor == NULL);
    898         return new SkPDFType0Font(info, typeface);
    899     }
    900     if (type == SkAdvancedTypefaceMetrics::kType1_Font) {
    901         return new SkPDFType1Font(info, typeface, glyphID,
    902                                   relatedFontDescriptor);
    903     }
    904 
    905     SkASSERT(type == SkAdvancedTypefaceMetrics::kCFF_Font ||
    906              type == SkAdvancedTypefaceMetrics::kOther_Font);
    907 
    908     return new SkPDFType3Font(info, typeface, glyphID);
    909 }
    910 
    911 const SkAdvancedTypefaceMetrics* SkPDFFont::fontInfo() {
    912     return fFontInfo.get();
    913 }
    914 
    915 void SkPDFFont::setFontInfo(const SkAdvancedTypefaceMetrics* info) {
    916     if (info == NULL || info == fFontInfo.get()) {
    917         return;
    918     }
    919     fFontInfo.reset(info);
    920     SkSafeRef(info);
    921 }
    922 
    923 uint16_t SkPDFFont::firstGlyphID() const {
    924     return fFirstGlyphID;
    925 }
    926 
    927 uint16_t SkPDFFont::lastGlyphID() const {
    928     return fLastGlyphID;
    929 }
    930 
    931 void SkPDFFont::setLastGlyphID(uint16_t glyphID) {
    932     fLastGlyphID = glyphID;
    933 }
    934 
    935 SkPDFDict* SkPDFFont::getFontDescriptor() {
    936     return fDescriptor.get();
    937 }
    938 
    939 void SkPDFFont::setFontDescriptor(SkPDFDict* descriptor) {
    940     fDescriptor.reset(descriptor);
    941     SkSafeRef(descriptor);
    942 }
    943 
    944 bool SkPDFFont::addCommonFontDescriptorEntries(int16_t defaultWidth) {
    945     if (fDescriptor.get() == NULL) {
    946         return false;
    947     }
    948 
    949     const uint16_t emSize = fFontInfo->fEmSize;
    950 
    951     fDescriptor->insertName("FontName", fFontInfo->fFontName);
    952     fDescriptor->insertInt("Flags", fFontInfo->fStyle | kPdfSymbolic);
    953     fDescriptor->insertScalar("Ascent",
    954             scaleFromFontUnits(fFontInfo->fAscent, emSize));
    955     fDescriptor->insertScalar("Descent",
    956             scaleFromFontUnits(fFontInfo->fDescent, emSize));
    957     fDescriptor->insertScalar("StemV",
    958             scaleFromFontUnits(fFontInfo->fStemV, emSize));
    959 
    960     fDescriptor->insertScalar("CapHeight",
    961             scaleFromFontUnits(fFontInfo->fCapHeight, emSize));
    962     fDescriptor->insertInt("ItalicAngle", fFontInfo->fItalicAngle);
    963     fDescriptor->insertObject(
    964             "FontBBox", makeFontBBox(fFontInfo->fBBox, fFontInfo->fEmSize));
    965 
    966     if (defaultWidth > 0) {
    967         fDescriptor->insertScalar("MissingWidth",
    968                 scaleFromFontUnits(defaultWidth, emSize));
    969     }
    970     return true;
    971 }
    972 
    973 void SkPDFFont::adjustGlyphRangeForSingleByteEncoding(uint16_t glyphID) {
    974     // Single byte glyph encoding supports a max of 255 glyphs.
    975     fFirstGlyphID = glyphID - (glyphID - 1) % 255;
    976     if (fLastGlyphID > fFirstGlyphID + 255 - 1) {
    977         fLastGlyphID = fFirstGlyphID + 255 - 1;
    978     }
    979 }
    980 
    981 void SkPDFFont::populateToUnicodeTable(const SkPDFGlyphSet* subset) {
    982     if (fFontInfo == NULL || fFontInfo->fGlyphToUnicode.begin() == NULL) {
    983         return;
    984     }
    985     this->insertObjRef("ToUnicode",
    986                        generate_tounicode_cmap(fFontInfo->fGlyphToUnicode,
    987                                                subset,
    988                                                multiByteGlyphs(),
    989                                                firstGlyphID(),
    990                                                lastGlyphID()));
    991 }
    992 
    993 ///////////////////////////////////////////////////////////////////////////////
    994 // class SkPDFType0Font
    995 ///////////////////////////////////////////////////////////////////////////////
    996 
    997 SkPDFType0Font::SkPDFType0Font(const SkAdvancedTypefaceMetrics* info,
    998                                SkTypeface* typeface)
    999     : SkPDFFont(info, typeface, NULL) {
   1000     SkDEBUGCODE(fPopulated = false);
   1001     if (!canSubset()) {
   1002         populate(NULL);
   1003     }
   1004 }
   1005 
   1006 SkPDFType0Font::~SkPDFType0Font() {}
   1007 
   1008 SkPDFFont* SkPDFType0Font::getFontSubset(const SkPDFGlyphSet* subset) {
   1009     if (!canSubset()) {
   1010         return NULL;
   1011     }
   1012     SkPDFType0Font* newSubset =
   1013             new SkPDFType0Font(fontInfo(), typeface());
   1014     newSubset->populate(subset);
   1015     return newSubset;
   1016 }
   1017 
   1018 #ifdef SK_DEBUG
   1019 void SkPDFType0Font::emitObject(SkWStream* stream,
   1020                                 const SkPDFObjNumMap& objNumMap,
   1021                                 const SkPDFSubstituteMap& substitutes) {
   1022     SkASSERT(fPopulated);
   1023     return INHERITED::emitObject(stream, objNumMap, substitutes);
   1024 }
   1025 #endif
   1026 
   1027 bool SkPDFType0Font::populate(const SkPDFGlyphSet* subset) {
   1028     insertName("Subtype", "Type0");
   1029     insertName("BaseFont", fontInfo()->fFontName);
   1030     insertName("Encoding", "Identity-H");
   1031 
   1032     SkAutoTUnref<SkPDFCIDFont> newCIDFont(
   1033             new SkPDFCIDFont(fontInfo(), typeface(), subset));
   1034     SkAutoTUnref<SkPDFArray> descendantFonts(new SkPDFArray());
   1035     descendantFonts->appendObjRef(newCIDFont.detach());
   1036     this->insertObject("DescendantFonts", descendantFonts.detach());
   1037 
   1038     populateToUnicodeTable(subset);
   1039 
   1040     SkDEBUGCODE(fPopulated = true);
   1041     return true;
   1042 }
   1043 
   1044 ///////////////////////////////////////////////////////////////////////////////
   1045 // class SkPDFCIDFont
   1046 ///////////////////////////////////////////////////////////////////////////////
   1047 
   1048 SkPDFCIDFont::SkPDFCIDFont(const SkAdvancedTypefaceMetrics* info,
   1049                            SkTypeface* typeface,
   1050                            const SkPDFGlyphSet* subset)
   1051     : SkPDFFont(info, typeface, NULL) {
   1052     populate(subset);
   1053 }
   1054 
   1055 SkPDFCIDFont::~SkPDFCIDFont() {}
   1056 
   1057 bool SkPDFCIDFont::addFontDescriptor(int16_t defaultWidth,
   1058                                      const SkTDArray<uint32_t>* subset) {
   1059     SkAutoTUnref<SkPDFDict> descriptor(new SkPDFDict("FontDescriptor"));
   1060     setFontDescriptor(descriptor.get());
   1061     if (!addCommonFontDescriptorEntries(defaultWidth)) {
   1062         this->insertObjRef("FontDescriptor", descriptor.detach());
   1063         return false;
   1064     }
   1065     if (!canEmbed()) {
   1066         this->insertObjRef("FontDescriptor", descriptor.detach());
   1067         return true;
   1068     }
   1069 
   1070     switch (getType()) {
   1071         case SkAdvancedTypefaceMetrics::kTrueType_Font: {
   1072             SkAutoTUnref<SkPDFStream> fontStream;
   1073             size_t fontSize = 0;
   1074             if (canSubset()) {
   1075                 SkPDFStream* rawStream = NULL;
   1076                 fontSize = get_subset_font_stream(fontInfo()->fFontName.c_str(),
   1077                                                   typeface(),
   1078                                                   *subset,
   1079                                                   &rawStream);
   1080                 fontStream.reset(rawStream);
   1081             } else {
   1082                 int ttcIndex;
   1083                 SkAutoTDelete<SkStream> fontData(
   1084                         typeface()->openStream(&ttcIndex));
   1085                 fontStream.reset(new SkPDFStream(fontData.get()));
   1086                 fontSize = fontData->getLength();
   1087             }
   1088             SkASSERT(fontSize);
   1089             SkASSERT(fontStream.get());
   1090 
   1091             fontStream->insertInt("Length1", fontSize);
   1092             descriptor->insertObjRef("FontFile2", fontStream.detach());
   1093             break;
   1094         }
   1095         case SkAdvancedTypefaceMetrics::kCFF_Font:
   1096         case SkAdvancedTypefaceMetrics::kType1CID_Font: {
   1097             int ttcIndex;
   1098             SkAutoTDelete<SkStream> fontData(typeface()->openStream(&ttcIndex));
   1099             SkAutoTUnref<SkPDFStream> fontStream(
   1100                 new SkPDFStream(fontData.get()));
   1101 
   1102             if (getType() == SkAdvancedTypefaceMetrics::kCFF_Font) {
   1103                 fontStream->insertName("Subtype", "Type1C");
   1104             } else {
   1105                 fontStream->insertName("Subtype", "CIDFontType0c");
   1106             }
   1107             descriptor->insertObjRef("FontFile3", fontStream.detach());
   1108             break;
   1109         }
   1110         default:
   1111             SkASSERT(false);
   1112     }
   1113     this->insertObjRef("FontDescriptor", descriptor.detach());
   1114     return true;
   1115 }
   1116 
   1117 bool SkPDFCIDFont::populate(const SkPDFGlyphSet* subset) {
   1118     // Generate new font metrics with advance info for true type fonts.
   1119     if (fontInfo()->fType == SkAdvancedTypefaceMetrics::kTrueType_Font) {
   1120         // Generate glyph id array.
   1121         SkTDArray<uint32_t> glyphIDs;
   1122         if (subset) {
   1123             // Always include glyph 0.
   1124             if (!subset->has(0)) {
   1125                 glyphIDs.push(0);
   1126             }
   1127             subset->exportTo(&glyphIDs);
   1128         }
   1129 
   1130         SkTypeface::PerGlyphInfo info;
   1131         info = SkTypeface::kGlyphNames_PerGlyphInfo;
   1132         info = SkTBitOr<SkTypeface::PerGlyphInfo>(
   1133                   info, SkTypeface::kHAdvance_PerGlyphInfo);
   1134         uint32_t* glyphs = (glyphIDs.count() == 0) ? NULL : glyphIDs.begin();
   1135         uint32_t glyphsCount = glyphs ? glyphIDs.count() : 0;
   1136         SkAutoTUnref<const SkAdvancedTypefaceMetrics> fontMetrics(
   1137             typeface()->getAdvancedTypefaceMetrics(info, glyphs, glyphsCount));
   1138         setFontInfo(fontMetrics.get());
   1139         addFontDescriptor(0, &glyphIDs);
   1140     } else {
   1141         // Other CID fonts
   1142         addFontDescriptor(0, NULL);
   1143     }
   1144 
   1145     insertName("BaseFont", fontInfo()->fFontName);
   1146 
   1147     if (getType() == SkAdvancedTypefaceMetrics::kType1CID_Font) {
   1148         insertName("Subtype", "CIDFontType0");
   1149     } else if (getType() == SkAdvancedTypefaceMetrics::kTrueType_Font) {
   1150         insertName("Subtype", "CIDFontType2");
   1151         insertName("CIDToGIDMap", "Identity");
   1152     } else {
   1153         SkASSERT(false);
   1154     }
   1155 
   1156     SkAutoTUnref<SkPDFDict> sysInfo(new SkPDFDict);
   1157     sysInfo->insertString("Registry", "Adobe");
   1158     sysInfo->insertString("Ordering", "Identity");
   1159     sysInfo->insertInt("Supplement", 0);
   1160     this->insertObject("CIDSystemInfo", sysInfo.detach());
   1161 
   1162     if (fontInfo()->fGlyphWidths.get()) {
   1163         int16_t defaultWidth = 0;
   1164         SkAutoTUnref<SkPDFArray> widths(
   1165             composeAdvanceData(fontInfo()->fGlyphWidths.get(),
   1166                                fontInfo()->fEmSize, &appendWidth,
   1167                                &defaultWidth));
   1168         if (widths->size())
   1169             this->insertObject("W", widths.detach());
   1170         if (defaultWidth != 0) {
   1171             this->insertScalar(
   1172                     "DW",
   1173                     scaleFromFontUnits(defaultWidth, fontInfo()->fEmSize));
   1174         }
   1175     }
   1176     if (fontInfo()->fVerticalMetrics.get()) {
   1177         struct SkAdvancedTypefaceMetrics::VerticalMetric defaultAdvance;
   1178         defaultAdvance.fVerticalAdvance = 0;
   1179         defaultAdvance.fOriginXDisp = 0;
   1180         defaultAdvance.fOriginYDisp = 0;
   1181         SkAutoTUnref<SkPDFArray> advances(
   1182             composeAdvanceData(fontInfo()->fVerticalMetrics.get(),
   1183                                fontInfo()->fEmSize, &appendVerticalAdvance,
   1184                                &defaultAdvance));
   1185         if (advances->size())
   1186             this->insertObject("W2", advances.detach());
   1187         if (defaultAdvance.fVerticalAdvance ||
   1188                 defaultAdvance.fOriginXDisp ||
   1189                 defaultAdvance.fOriginYDisp) {
   1190             this->insertObject("DW2",
   1191                                appendVerticalAdvance(defaultAdvance,
   1192                                                      fontInfo()->fEmSize,
   1193                                                      new SkPDFArray));
   1194         }
   1195     }
   1196 
   1197     return true;
   1198 }
   1199 
   1200 ///////////////////////////////////////////////////////////////////////////////
   1201 // class SkPDFType1Font
   1202 ///////////////////////////////////////////////////////////////////////////////
   1203 
   1204 SkPDFType1Font::SkPDFType1Font(const SkAdvancedTypefaceMetrics* info,
   1205                                SkTypeface* typeface,
   1206                                uint16_t glyphID,
   1207                                SkPDFDict* relatedFontDescriptor)
   1208     : SkPDFFont(info, typeface, relatedFontDescriptor) {
   1209     populate(glyphID);
   1210 }
   1211 
   1212 SkPDFType1Font::~SkPDFType1Font() {}
   1213 
   1214 bool SkPDFType1Font::addFontDescriptor(int16_t defaultWidth) {
   1215     if (SkPDFDict* descriptor = getFontDescriptor()) {
   1216         this->insertObjRef("FontDescriptor", SkRef(descriptor));
   1217         return true;
   1218     }
   1219 
   1220     SkAutoTUnref<SkPDFDict> descriptor(new SkPDFDict("FontDescriptor"));
   1221     setFontDescriptor(descriptor.get());
   1222 
   1223     int ttcIndex;
   1224     size_t header SK_INIT_TO_AVOID_WARNING;
   1225     size_t data SK_INIT_TO_AVOID_WARNING;
   1226     size_t trailer SK_INIT_TO_AVOID_WARNING;
   1227     SkAutoTDelete<SkStream> rawFontData(typeface()->openStream(&ttcIndex));
   1228     SkAutoTUnref<SkData> fontData(handle_type1_stream(rawFontData.get(), &header,
   1229                                                       &data, &trailer));
   1230     if (fontData.get() == NULL) {
   1231         return false;
   1232     }
   1233     if (canEmbed()) {
   1234         SkAutoTUnref<SkPDFStream> fontStream(new SkPDFStream(fontData.get()));
   1235         fontStream->insertInt("Length1", header);
   1236         fontStream->insertInt("Length2", data);
   1237         fontStream->insertInt("Length3", trailer);
   1238         descriptor->insertObjRef("FontFile", fontStream.detach());
   1239     }
   1240 
   1241     this->insertObjRef("FontDescriptor", descriptor.detach());
   1242 
   1243     return addCommonFontDescriptorEntries(defaultWidth);
   1244 }
   1245 
   1246 bool SkPDFType1Font::populate(int16_t glyphID) {
   1247     SkASSERT(!fontInfo()->fVerticalMetrics.get());
   1248     SkASSERT(fontInfo()->fGlyphWidths.get());
   1249 
   1250     adjustGlyphRangeForSingleByteEncoding(glyphID);
   1251 
   1252     int16_t defaultWidth = 0;
   1253     const SkAdvancedTypefaceMetrics::WidthRange* widthRangeEntry = NULL;
   1254     const SkAdvancedTypefaceMetrics::WidthRange* widthEntry;
   1255     for (widthEntry = fontInfo()->fGlyphWidths.get();
   1256             widthEntry != NULL;
   1257             widthEntry = widthEntry->fNext.get()) {
   1258         switch (widthEntry->fType) {
   1259             case SkAdvancedTypefaceMetrics::WidthRange::kDefault:
   1260                 defaultWidth = widthEntry->fAdvance[0];
   1261                 break;
   1262             case SkAdvancedTypefaceMetrics::WidthRange::kRun:
   1263                 SkASSERT(false);
   1264                 break;
   1265             case SkAdvancedTypefaceMetrics::WidthRange::kRange:
   1266                 SkASSERT(widthRangeEntry == NULL);
   1267                 widthRangeEntry = widthEntry;
   1268                 break;
   1269         }
   1270     }
   1271 
   1272     if (!addFontDescriptor(defaultWidth)) {
   1273         return false;
   1274     }
   1275 
   1276     insertName("Subtype", "Type1");
   1277     insertName("BaseFont", fontInfo()->fFontName);
   1278 
   1279     addWidthInfoFromRange(defaultWidth, widthRangeEntry);
   1280 
   1281 
   1282     SkAutoTUnref<SkPDFArray> encDiffs(new SkPDFArray);
   1283     encDiffs->reserve(lastGlyphID() - firstGlyphID() + 2);
   1284     encDiffs->appendInt(1);
   1285     for (int gID = firstGlyphID(); gID <= lastGlyphID(); gID++) {
   1286         encDiffs->appendName(fontInfo()->fGlyphNames->get()[gID].c_str());
   1287     }
   1288 
   1289     SkAutoTUnref<SkPDFDict> encoding(new SkPDFDict("Encoding"));
   1290     encoding->insertObject("Differences", encDiffs.detach());
   1291     this->insertObject("Encoding", encoding.detach());
   1292     return true;
   1293 }
   1294 
   1295 void SkPDFType1Font::addWidthInfoFromRange(
   1296         int16_t defaultWidth,
   1297         const SkAdvancedTypefaceMetrics::WidthRange* widthRangeEntry) {
   1298     SkAutoTUnref<SkPDFArray> widthArray(new SkPDFArray());
   1299     int firstChar = 0;
   1300     if (widthRangeEntry) {
   1301         const uint16_t emSize = fontInfo()->fEmSize;
   1302         int startIndex = firstGlyphID() - widthRangeEntry->fStartId;
   1303         int endIndex = startIndex + lastGlyphID() - firstGlyphID() + 1;
   1304         if (startIndex < 0)
   1305             startIndex = 0;
   1306         if (endIndex > widthRangeEntry->fAdvance.count())
   1307             endIndex = widthRangeEntry->fAdvance.count();
   1308         if (widthRangeEntry->fStartId == 0) {
   1309             appendWidth(widthRangeEntry->fAdvance[0], emSize, widthArray.get());
   1310         } else {
   1311             firstChar = startIndex + widthRangeEntry->fStartId;
   1312         }
   1313         for (int i = startIndex; i < endIndex; i++) {
   1314             appendWidth(widthRangeEntry->fAdvance[i], emSize, widthArray.get());
   1315         }
   1316     } else {
   1317         appendWidth(defaultWidth, 1000, widthArray.get());
   1318     }
   1319     this->insertInt("FirstChar", firstChar);
   1320     this->insertInt("LastChar", firstChar + widthArray->size() - 1);
   1321     this->insertObject("Widths", widthArray.detach());
   1322 }
   1323 
   1324 ///////////////////////////////////////////////////////////////////////////////
   1325 // class SkPDFType3Font
   1326 ///////////////////////////////////////////////////////////////////////////////
   1327 
   1328 SkPDFType3Font::SkPDFType3Font(const SkAdvancedTypefaceMetrics* info,
   1329                                SkTypeface* typeface,
   1330                                uint16_t glyphID)
   1331     : SkPDFFont(info, typeface, NULL) {
   1332     populate(glyphID);
   1333 }
   1334 
   1335 SkPDFType3Font::~SkPDFType3Font() {}
   1336 
   1337 bool SkPDFType3Font::populate(uint16_t glyphID) {
   1338     SkPaint paint;
   1339     paint.setTypeface(typeface());
   1340     paint.setTextSize(1000);
   1341     SkAutoGlyphCache autoCache(paint, NULL, NULL);
   1342     SkGlyphCache* cache = autoCache.getCache();
   1343     // If fLastGlyphID isn't set (because there is not fFontInfo), look it up.
   1344     if (lastGlyphID() == 0) {
   1345         setLastGlyphID(cache->getGlyphCount() - 1);
   1346     }
   1347 
   1348     adjustGlyphRangeForSingleByteEncoding(glyphID);
   1349 
   1350     insertName("Subtype", "Type3");
   1351     // Flip about the x-axis and scale by 1/1000.
   1352     SkMatrix fontMatrix;
   1353     fontMatrix.setScale(SkScalarInvert(1000), -SkScalarInvert(1000));
   1354     this->insertObject("FontMatrix", SkPDFUtils::MatrixToArray(fontMatrix));
   1355 
   1356     SkAutoTUnref<SkPDFDict> charProcs(new SkPDFDict);
   1357     SkAutoTUnref<SkPDFDict> encoding(new SkPDFDict("Encoding"));
   1358 
   1359     SkAutoTUnref<SkPDFArray> encDiffs(new SkPDFArray);
   1360     encDiffs->reserve(lastGlyphID() - firstGlyphID() + 2);
   1361     encDiffs->appendInt(1);
   1362 
   1363     SkAutoTUnref<SkPDFArray> widthArray(new SkPDFArray());
   1364 
   1365     SkIRect bbox = SkIRect::MakeEmpty();
   1366     for (int gID = firstGlyphID(); gID <= lastGlyphID(); gID++) {
   1367         SkString characterName;
   1368         characterName.printf("gid%d", gID);
   1369         encDiffs->appendName(characterName.c_str());
   1370 
   1371         const SkGlyph& glyph = cache->getGlyphIDMetrics(gID);
   1372         widthArray->appendScalar(SkFixedToScalar(glyph.fAdvanceX));
   1373         SkIRect glyphBBox = SkIRect::MakeXYWH(glyph.fLeft, glyph.fTop,
   1374                                               glyph.fWidth, glyph.fHeight);
   1375         bbox.join(glyphBBox);
   1376 
   1377         SkDynamicMemoryWStream content;
   1378         setGlyphWidthAndBoundingBox(SkFixedToScalar(glyph.fAdvanceX), glyphBBox,
   1379                                     &content);
   1380         const SkPath* path = cache->findPath(glyph);
   1381         if (path) {
   1382             SkPDFUtils::EmitPath(*path, paint.getStyle(), &content);
   1383             SkPDFUtils::PaintPath(paint.getStyle(), path->getFillType(),
   1384                                   &content);
   1385         }
   1386         SkAutoTDelete<SkMemoryStream> glyphStream(new SkMemoryStream());
   1387         glyphStream->setData(content.copyToData())->unref();
   1388 
   1389         charProcs->insertObjRef(characterName,
   1390                                 new SkPDFStream(glyphStream.get()));
   1391     }
   1392 
   1393     encoding->insertObject("Differences", encDiffs.detach());
   1394 
   1395     this->insertObject("CharProcs", charProcs.detach());
   1396     this->insertObject("Encoding", encoding.detach());
   1397 
   1398     this->insertObject("FontBBox", makeFontBBox(bbox, 1000));
   1399     this->insertInt("FirstChar", 1);
   1400     this->insertInt("LastChar", lastGlyphID() - firstGlyphID() + 1);
   1401     this->insertObject("Widths", widthArray.detach());
   1402     this->insertName("CIDToGIDMap", "Identity");
   1403 
   1404     populateToUnicodeTable(NULL);
   1405     return true;
   1406 }
   1407 
   1408 SkPDFFont::Match SkPDFFont::IsMatch(SkPDFFont* existingFont,
   1409                                     uint32_t existingFontID,
   1410                                     uint16_t existingGlyphID,
   1411                                     uint32_t searchFontID,
   1412                                     uint16_t searchGlyphID) {
   1413     if (existingFontID != searchFontID) {
   1414         return SkPDFFont::kNot_Match;
   1415     }
   1416     if (existingGlyphID == 0 || searchGlyphID == 0) {
   1417         return SkPDFFont::kExact_Match;
   1418     }
   1419     if (existingFont != NULL) {
   1420         return (existingFont->fFirstGlyphID <= searchGlyphID &&
   1421                 searchGlyphID <= existingFont->fLastGlyphID)
   1422                        ? SkPDFFont::kExact_Match
   1423                        : SkPDFFont::kRelated_Match;
   1424     }
   1425     return (existingGlyphID == searchGlyphID) ? SkPDFFont::kExact_Match
   1426                                               : SkPDFFont::kRelated_Match;
   1427 }
   1428