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