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