src/third_party/skia/src/pdf/SkPDFFont.cpp

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