blob: b4e6d98722ab61d029e324748c2c6a19d5117458 [file] [log] [blame]
vandebo@chromium.org28be72b2010-11-11 21:37:00 +00001/*
epoger@google.comec3ed6a2011-07-28 14:26:00 +00002 * Copyright 2011 Google Inc.
vandebo@chromium.org28be72b2010-11-11 21:37:00 +00003 *
epoger@google.comec3ed6a2011-07-28 14:26:00 +00004 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
vandebo@chromium.org28be72b2010-11-11 21:37:00 +00006 */
7
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00008#include <ctype.h>
9
reed@google.com8a85d0c2011-06-24 19:12:12 +000010#include "SkData.h"
vandebo@chromium.org2a22e102011-01-25 21:01:34 +000011#include "SkFontHost.h"
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +000012#include "SkGlyphCache.h"
vandebo@chromium.org28be72b2010-11-11 21:37:00 +000013#include "SkPaint.h"
vandebo@chromium.org98594282011-07-25 22:34:12 +000014#include "SkPDFCatalog.h"
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +000015#include "SkPDFDevice.h"
vandebo@chromium.org28be72b2010-11-11 21:37:00 +000016#include "SkPDFFont.h"
vandebo@chromium.org98594282011-07-25 22:34:12 +000017#include "SkPDFFontImpl.h"
vandebo@chromium.org2a22e102011-01-25 21:01:34 +000018#include "SkPDFStream.h"
vandebo@chromium.org2a22e102011-01-25 21:01:34 +000019#include "SkPDFTypes.h"
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +000020#include "SkPDFUtils.h"
vandebo@chromium.orgf77e27d2011-03-10 22:50:28 +000021#include "SkRefCnt.h"
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +000022#include "SkScalar.h"
vandebo@chromium.org2a22e102011-01-25 21:01:34 +000023#include "SkStream.h"
reed@google.comfed86bd2013-03-14 15:04:57 +000024#include "SkTypefacePriv.h"
vandebo@chromium.org325cb9a2011-03-30 18:36:29 +000025#include "SkTypes.h"
vandebo@chromium.org28be72b2010-11-11 21:37:00 +000026#include "SkUtils.h"
27
vandebo@chromium.org1f165892011-07-26 02:11:41 +000028#if defined (SK_SFNTLY_SUBSETTER)
29#include SK_SFNTLY_SUBSETTER
30#endif
31
vandebo@chromium.orgdcf9c192013-03-13 20:01:51 +000032// PDF's notion of symbolic vs non-symbolic is related to the character set, not
33// symbols vs. characters. Rarely is a font the right character set to call it
34// non-symbolic, so always call it symbolic. (PDF 1.4 spec, section 5.7.1)
35static const int kPdfSymbolic = 4;
36
vandebo@chromium.org28be72b2010-11-11 21:37:00 +000037namespace {
38
vandebo@chromium.org98594282011-07-25 22:34:12 +000039///////////////////////////////////////////////////////////////////////////////
40// File-Local Functions
41///////////////////////////////////////////////////////////////////////////////
42
vandebo@chromium.org2a22e102011-01-25 21:01:34 +000043bool parsePFBSection(const uint8_t** src, size_t* len, int sectionType,
44 size_t* size) {
45 // PFB sections have a two or six bytes header. 0x80 and a one byte
46 // section type followed by a four byte section length. Type one is
47 // an ASCII section (includes a length), type two is a binary section
48 // (includes a length) and type three is an EOF marker with no length.
49 const uint8_t* buf = *src;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +000050 if (*len < 2 || buf[0] != 0x80 || buf[1] != sectionType) {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +000051 return false;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +000052 } else if (buf[1] == 3) {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +000053 return true;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +000054 } else if (*len < 6) {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +000055 return false;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +000056 }
vandebo@chromium.org2a22e102011-01-25 21:01:34 +000057
vandebo@chromium.org73322072011-06-21 21:19:41 +000058 *size = (size_t)buf[2] | ((size_t)buf[3] << 8) | ((size_t)buf[4] << 16) |
59 ((size_t)buf[5] << 24);
vandebo@chromium.org2a22e102011-01-25 21:01:34 +000060 size_t consumed = *size + 6;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +000061 if (consumed > *len) {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +000062 return false;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +000063 }
vandebo@chromium.org2a22e102011-01-25 21:01:34 +000064 *src = *src + consumed;
65 *len = *len - consumed;
66 return true;
vandebo@chromium.org28be72b2010-11-11 21:37:00 +000067}
68
vandebo@chromium.org2a22e102011-01-25 21:01:34 +000069bool parsePFB(const uint8_t* src, size_t size, size_t* headerLen,
70 size_t* dataLen, size_t* trailerLen) {
71 const uint8_t* srcPtr = src;
72 size_t remaining = size;
73
74 return parsePFBSection(&srcPtr, &remaining, 1, headerLen) &&
75 parsePFBSection(&srcPtr, &remaining, 2, dataLen) &&
76 parsePFBSection(&srcPtr, &remaining, 1, trailerLen) &&
77 parsePFBSection(&srcPtr, &remaining, 3, NULL);
vandebo@chromium.org28be72b2010-11-11 21:37:00 +000078}
79
vandebo@chromium.org2a22e102011-01-25 21:01:34 +000080/* The sections of a PFA file are implicitly defined. The body starts
81 * after the line containing "eexec," and the trailer starts with 512
82 * literal 0's followed by "cleartomark" (plus arbitrary white space).
83 *
84 * This function assumes that src is NUL terminated, but the NUL
85 * termination is not included in size.
86 *
87 */
88bool parsePFA(const char* src, size_t size, size_t* headerLen,
89 size_t* hexDataLen, size_t* dataLen, size_t* trailerLen) {
90 const char* end = src + size;
91
92 const char* dataPos = strstr(src, "eexec");
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +000093 if (!dataPos) {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +000094 return false;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +000095 }
vandebo@chromium.org2a22e102011-01-25 21:01:34 +000096 dataPos += strlen("eexec");
97 while ((*dataPos == '\n' || *dataPos == '\r' || *dataPos == ' ') &&
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +000098 dataPos < end) {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +000099 dataPos++;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000100 }
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000101 *headerLen = dataPos - src;
102
103 const char* trailerPos = strstr(dataPos, "cleartomark");
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000104 if (!trailerPos) {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000105 return false;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000106 }
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000107 int zeroCount = 0;
108 for (trailerPos--; trailerPos > dataPos && zeroCount < 512; trailerPos--) {
109 if (*trailerPos == '\n' || *trailerPos == '\r' || *trailerPos == ' ') {
110 continue;
111 } else if (*trailerPos == '0') {
112 zeroCount++;
113 } else {
114 return false;
115 }
116 }
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000117 if (zeroCount != 512) {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000118 return false;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000119 }
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000120
121 *hexDataLen = trailerPos - src - *headerLen;
122 *trailerLen = size - *headerLen - *hexDataLen;
123
124 // Verify that the data section is hex encoded and count the bytes.
125 int nibbles = 0;
126 for (; dataPos < trailerPos; dataPos++) {
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000127 if (isspace(*dataPos)) {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000128 continue;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000129 }
130 if (!isxdigit(*dataPos)) {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000131 return false;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000132 }
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000133 nibbles++;
134 }
135 *dataLen = (nibbles + 1) / 2;
136
137 return true;
138}
139
140int8_t hexToBin(uint8_t c) {
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000141 if (!isxdigit(c)) {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000142 return -1;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000143 } else if (c <= '9') {
144 return c - '0';
145 } else if (c <= 'F') {
146 return c - 'A' + 10;
147 } else if (c <= 'f') {
148 return c - 'a' + 10;
149 }
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000150 return -1;
151}
152
halcanary67ec1f82014-06-27 11:36:20 -0700153static SkData* handle_type1_stream(SkStream* srcStream, size_t* headerLen,
154 size_t* dataLen, size_t* trailerLen) {
vandebo@chromium.org98594282011-07-25 22:34:12 +0000155 // srcStream may be backed by a file or a unseekable fd, so we may not be
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000156 // able to use skip(), rewind(), or getMemoryBase(). read()ing through
157 // the input only once is doable, but very ugly. Furthermore, it'd be nice
158 // if the data was NUL terminated so that we can use strstr() to search it.
159 // Make as few copies as possible given these constraints.
160 SkDynamicMemoryWStream dynamicStream;
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +0000161 SkAutoTUnref<SkMemoryStream> staticStream;
reed@google.com8a85d0c2011-06-24 19:12:12 +0000162 SkData* data = NULL;
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000163 const uint8_t* src;
164 size_t srcLen;
165 if ((srcLen = srcStream->getLength()) > 0) {
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +0000166 staticStream.reset(new SkMemoryStream(srcLen + 1));
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000167 src = (const uint8_t*)staticStream->getMemoryBase();
168 if (srcStream->getMemoryBase() != NULL) {
169 memcpy((void *)src, srcStream->getMemoryBase(), srcLen);
170 } else {
171 size_t read = 0;
172 while (read < srcLen) {
173 size_t got = srcStream->read((void *)staticStream->getAtPos(),
174 srcLen - read);
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000175 if (got == 0) {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000176 return NULL;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000177 }
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000178 read += got;
179 staticStream->seek(read);
180 }
181 }
182 ((uint8_t *)src)[srcLen] = 0;
183 } else {
ctguil@chromium.orga5c72342011-08-15 23:55:03 +0000184 static const size_t kBufSize = 4096;
185 uint8_t buf[kBufSize];
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000186 size_t amount;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000187 while ((amount = srcStream->read(buf, kBufSize)) > 0) {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000188 dynamicStream.write(buf, amount);
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000189 }
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000190 amount = 0;
191 dynamicStream.write(&amount, 1); // NULL terminator.
reed@google.com8a85d0c2011-06-24 19:12:12 +0000192 data = dynamicStream.copyToData();
193 src = data->bytes();
194 srcLen = data->size() - 1;
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000195 }
196
reed@google.com8a85d0c2011-06-24 19:12:12 +0000197 // this handles releasing the data we may have gotten from dynamicStream.
198 // if data is null, it is a no-op
199 SkAutoDataUnref aud(data);
200
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000201 if (parsePFB(src, srcLen, headerLen, dataLen, trailerLen)) {
halcanary67ec1f82014-06-27 11:36:20 -0700202 static const int kPFBSectionHeaderLength = 6;
203 const size_t length = *headerLen + *dataLen + *trailerLen;
204 SkASSERT(length > 0);
205 SkASSERT(length + (2 * kPFBSectionHeaderLength) <= srcLen);
206
reed33a30502014-09-11 08:42:36 -0700207 SkData* data = SkData::NewUninitialized(length);
halcanary67ec1f82014-06-27 11:36:20 -0700208
209 const uint8_t* const srcHeader = src + kPFBSectionHeaderLength;
210 // There is a six-byte section header before header and data
211 // (but not trailer) that we're not going to copy.
reed33a30502014-09-11 08:42:36 -0700212 const uint8_t* const srcData = srcHeader + *headerLen + kPFBSectionHeaderLength;
halcanary67ec1f82014-06-27 11:36:20 -0700213 const uint8_t* const srcTrailer = srcData + *headerLen;
214
reed33a30502014-09-11 08:42:36 -0700215 uint8_t* const resultHeader = (uint8_t*)data->writable_data();
halcanary67ec1f82014-06-27 11:36:20 -0700216 uint8_t* const resultData = resultHeader + *headerLen;
217 uint8_t* const resultTrailer = resultData + *dataLen;
218
219 SkASSERT(resultTrailer + *trailerLen == resultHeader + length);
220
221 memcpy(resultHeader, srcHeader, *headerLen);
222 memcpy(resultData, srcData, *dataLen);
223 memcpy(resultTrailer, srcTrailer, *trailerLen);
224
reed33a30502014-09-11 08:42:36 -0700225 return data;
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000226 }
227
228 // A PFA has to be converted for PDF.
229 size_t hexDataLen;
230 if (parsePFA((const char*)src, srcLen, headerLen, &hexDataLen, dataLen,
231 trailerLen)) {
halcanary67ec1f82014-06-27 11:36:20 -0700232 const size_t length = *headerLen + *dataLen + *trailerLen;
233 SkASSERT(length > 0);
234 SkAutoTMalloc<uint8_t> buffer(length);
235
236 memcpy(buffer.get(), src, *headerLen);
237 uint8_t* const resultData = &(buffer[*headerLen]);
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000238
239 const uint8_t* hexData = src + *headerLen;
240 const uint8_t* trailer = hexData + hexDataLen;
241 size_t outputOffset = 0;
vandebo@chromium.org5b073682011-03-08 18:33:31 +0000242 uint8_t dataByte = 0; // To hush compiler.
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000243 bool highNibble = true;
244 for (; hexData < trailer; hexData++) {
commit-bot@chromium.org3720fda2013-07-10 15:03:52 +0000245 int8_t curNibble = hexToBin(*hexData);
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000246 if (curNibble < 0) {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000247 continue;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000248 }
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000249 if (highNibble) {
250 dataByte = curNibble << 4;
251 highNibble = false;
252 } else {
253 dataByte |= curNibble;
254 highNibble = true;
halcanary67ec1f82014-06-27 11:36:20 -0700255 resultData[outputOffset++] = dataByte;
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000256 }
257 }
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000258 if (!highNibble) {
halcanary67ec1f82014-06-27 11:36:20 -0700259 resultData[outputOffset++] = dataByte;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000260 }
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000261 SkASSERT(outputOffset == *dataLen);
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000262
halcanary67ec1f82014-06-27 11:36:20 -0700263 uint8_t* const resultTrailer = &(buffer[*headerLen + outputOffset]);
264 memcpy(resultTrailer, src + *headerLen + hexDataLen, *trailerLen);
265
266 return SkData::NewFromMalloc(buffer.detach(), length);
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000267 }
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000268 return NULL;
269}
270
reed@google.com3f0dcf92011-03-18 21:23:45 +0000271// scale from em-units to base-1000, returning as a SkScalar
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +0000272SkScalar scaleFromFontUnits(int16_t val, uint16_t emSize) {
reed@google.com3f0dcf92011-03-18 21:23:45 +0000273 SkScalar scaled = SkIntToScalar(val);
274 if (emSize == 1000) {
275 return scaled;
276 } else {
277 return SkScalarMulDiv(scaled, 1000, emSize);
278 }
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +0000279}
280
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +0000281void setGlyphWidthAndBoundingBox(SkScalar width, SkIRect box,
vandebo@chromium.orgcae5fba2011-03-28 19:03:50 +0000282 SkWStream* content) {
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +0000283 // Specify width and bounding box for the glyph.
284 SkPDFScalar::Append(width, content);
vandebo@chromium.orgcae5fba2011-03-28 19:03:50 +0000285 content->writeText(" 0 ");
286 content->writeDecAsText(box.fLeft);
287 content->writeText(" ");
288 content->writeDecAsText(box.fTop);
289 content->writeText(" ");
290 content->writeDecAsText(box.fRight);
291 content->writeText(" ");
292 content->writeDecAsText(box.fBottom);
293 content->writeText(" d1\n");
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +0000294}
295
vandebo@chromium.org75f97e42011-04-11 23:24:18 +0000296SkPDFArray* makeFontBBox(SkIRect glyphBBox, uint16_t emSize) {
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +0000297 SkPDFArray* bbox = new SkPDFArray;
298 bbox->reserve(4);
reed@google.comc789cf12011-07-20 12:14:33 +0000299 bbox->appendScalar(scaleFromFontUnits(glyphBBox.fLeft, emSize));
300 bbox->appendScalar(scaleFromFontUnits(glyphBBox.fBottom, emSize));
301 bbox->appendScalar(scaleFromFontUnits(glyphBBox.fRight, emSize));
302 bbox->appendScalar(scaleFromFontUnits(glyphBBox.fTop, emSize));
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +0000303 return bbox;
304}
305
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +0000306SkPDFArray* appendWidth(const int16_t& width, uint16_t emSize,
307 SkPDFArray* array) {
reed@google.comc789cf12011-07-20 12:14:33 +0000308 array->appendScalar(scaleFromFontUnits(width, emSize));
vandebo@chromium.orgf7c15762011-02-01 22:19:44 +0000309 return array;
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000310}
311
vandebo@chromium.orgf7c15762011-02-01 22:19:44 +0000312SkPDFArray* appendVerticalAdvance(
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +0000313 const SkAdvancedTypefaceMetrics::VerticalMetric& advance,
314 uint16_t emSize, SkPDFArray* array) {
315 appendWidth(advance.fVerticalAdvance, emSize, array);
316 appendWidth(advance.fOriginXDisp, emSize, array);
317 appendWidth(advance.fOriginYDisp, emSize, array);
vandebo@chromium.orgf7c15762011-02-01 22:19:44 +0000318 return array;
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000319}
320
321template <typename Data>
322SkPDFArray* composeAdvanceData(
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +0000323 SkAdvancedTypefaceMetrics::AdvanceMetric<Data>* advanceInfo,
324 uint16_t emSize,
325 SkPDFArray* (*appendAdvance)(const Data& advance, uint16_t emSize,
326 SkPDFArray* array),
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000327 Data* defaultAdvance) {
328 SkPDFArray* result = new SkPDFArray();
329 for (; advanceInfo != NULL; advanceInfo = advanceInfo->fNext.get()) {
330 switch (advanceInfo->fType) {
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +0000331 case SkAdvancedTypefaceMetrics::WidthRange::kDefault: {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000332 SkASSERT(advanceInfo->fAdvance.count() == 1);
333 *defaultAdvance = advanceInfo->fAdvance[0];
334 break;
335 }
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +0000336 case SkAdvancedTypefaceMetrics::WidthRange::kRange: {
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +0000337 SkAutoTUnref<SkPDFArray> advanceArray(new SkPDFArray());
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000338 for (int j = 0; j < advanceInfo->fAdvance.count(); j++)
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +0000339 appendAdvance(advanceInfo->fAdvance[j], emSize,
340 advanceArray.get());
reed@google.comc789cf12011-07-20 12:14:33 +0000341 result->appendInt(advanceInfo->fStartId);
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000342 result->append(advanceArray.get());
343 break;
344 }
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +0000345 case SkAdvancedTypefaceMetrics::WidthRange::kRun: {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000346 SkASSERT(advanceInfo->fAdvance.count() == 1);
reed@google.comc789cf12011-07-20 12:14:33 +0000347 result->appendInt(advanceInfo->fStartId);
348 result->appendInt(advanceInfo->fEndId);
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +0000349 appendAdvance(advanceInfo->fAdvance[0], emSize, result);
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000350 break;
351 }
352 }
353 }
354 return result;
355}
356
357} // namespace
358
edisonn@google.com26d2e042013-09-18 19:29:08 +0000359static void append_tounicode_header(SkDynamicMemoryWStream* cmap,
360 uint16_t firstGlyphID,
361 uint16_t lastGlyphID) {
vandebo@chromium.org6744d492011-05-09 18:13:47 +0000362 // 12 dict begin: 12 is an Adobe-suggested value. Shall not change.
363 // It's there to prevent old version Adobe Readers from malfunctioning.
364 const char* kHeader =
365 "/CIDInit /ProcSet findresource begin\n"
366 "12 dict begin\n"
367 "begincmap\n";
368 cmap->writeText(kHeader);
369
370 // The /CIDSystemInfo must be consistent to the one in
371 // SkPDFFont::populateCIDFont().
372 // We can not pass over the system info object here because the format is
373 // different. This is not a reference object.
374 const char* kSysInfo =
375 "/CIDSystemInfo\n"
376 "<< /Registry (Adobe)\n"
377 "/Ordering (UCS)\n"
378 "/Supplement 0\n"
379 ">> def\n";
380 cmap->writeText(kSysInfo);
381
382 // The CMapName must be consistent to /CIDSystemInfo above.
383 // /CMapType 2 means ToUnicode.
edisonn@google.com26d2e042013-09-18 19:29:08 +0000384 // Codespace range just tells the PDF processor the valid range.
385 const char* kTypeInfoHeader =
vandebo@chromium.org6744d492011-05-09 18:13:47 +0000386 "/CMapName /Adobe-Identity-UCS def\n"
387 "/CMapType 2 def\n"
edisonn@google.com26d2e042013-09-18 19:29:08 +0000388 "1 begincodespacerange\n";
389 cmap->writeText(kTypeInfoHeader);
skia.committer@gmail.com2262c582013-09-19 07:25:55 +0000390
edisonn@google.com26d2e042013-09-18 19:29:08 +0000391 // e.g. "<0000> <FFFF>\n"
392 SkString range;
393 range.appendf("<%04X> <%04X>\n", firstGlyphID, lastGlyphID);
394 cmap->writeText(range.c_str());
skia.committer@gmail.com2262c582013-09-19 07:25:55 +0000395
edisonn@google.com26d2e042013-09-18 19:29:08 +0000396 const char* kTypeInfoFooter = "endcodespacerange\n";
397 cmap->writeText(kTypeInfoFooter);
vandebo@chromium.org6744d492011-05-09 18:13:47 +0000398}
399
vandebo@chromium.org6744d492011-05-09 18:13:47 +0000400static void append_cmap_footer(SkDynamicMemoryWStream* cmap) {
401 const char* kFooter =
402 "endcmap\n"
403 "CMapName currentdict /CMap defineresource pop\n"
404 "end\n"
405 "end";
406 cmap->writeText(kFooter);
407}
408
vandebo@chromium.org04c643b2011-08-08 22:33:05 +0000409struct BFChar {
410 uint16_t fGlyphId;
411 SkUnichar fUnicode;
412};
vandebo@chromium.org6744d492011-05-09 18:13:47 +0000413
vandebo@chromium.org04c643b2011-08-08 22:33:05 +0000414struct BFRange {
415 uint16_t fStart;
416 uint16_t fEnd;
417 SkUnichar fUnicode;
418};
419
420static void append_bfchar_section(const SkTDArray<BFChar>& bfchar,
421 SkDynamicMemoryWStream* cmap) {
422 // PDF spec defines that every bf* list can have at most 100 entries.
423 for (int i = 0; i < bfchar.count(); i += 100) {
424 int count = bfchar.count() - i;
425 count = SkMin32(count, 100);
426 cmap->writeDecAsText(count);
427 cmap->writeText(" beginbfchar\n");
428 for (int j = 0; j < count; ++j) {
429 cmap->writeText("<");
430 cmap->writeHexAsText(bfchar[i + j].fGlyphId, 4);
431 cmap->writeText("> <");
432 cmap->writeHexAsText(bfchar[i + j].fUnicode, 4);
433 cmap->writeText(">\n");
434 }
435 cmap->writeText("endbfchar\n");
vandebo@chromium.org6744d492011-05-09 18:13:47 +0000436 }
437}
438
vandebo@chromium.org04c643b2011-08-08 22:33:05 +0000439static void append_bfrange_section(const SkTDArray<BFRange>& bfrange,
440 SkDynamicMemoryWStream* cmap) {
441 // PDF spec defines that every bf* list can have at most 100 entries.
442 for (int i = 0; i < bfrange.count(); i += 100) {
443 int count = bfrange.count() - i;
444 count = SkMin32(count, 100);
445 cmap->writeDecAsText(count);
446 cmap->writeText(" beginbfrange\n");
447 for (int j = 0; j < count; ++j) {
448 cmap->writeText("<");
449 cmap->writeHexAsText(bfrange[i + j].fStart, 4);
450 cmap->writeText("> <");
451 cmap->writeHexAsText(bfrange[i + j].fEnd, 4);
452 cmap->writeText("> <");
453 cmap->writeHexAsText(bfrange[i + j].fUnicode, 4);
454 cmap->writeText(">\n");
455 }
456 cmap->writeText("endbfrange\n");
457 }
458}
459
460// Generate <bfchar> and <bfrange> table according to PDF spec 1.4 and Adobe
461// Technote 5014.
462// The function is not static so we can test it in unit tests.
463//
464// Current implementation guarantees bfchar and bfrange entries do not overlap.
465//
466// Current implementation does not attempt aggresive optimizations against
467// following case because the specification is not clear.
468//
469// 4 beginbfchar 1 beginbfchar
470// <0003> <0013> <0020> <0014>
471// <0005> <0015> to endbfchar
472// <0007> <0017> 1 beginbfrange
473// <0020> <0014> <0003> <0007> <0013>
474// endbfchar endbfrange
475//
476// Adobe Technote 5014 said: "Code mappings (unlike codespace ranges) may
commit-bot@chromium.org1236d8e2013-12-11 18:47:11 +0000477// overlap, but succeeding maps supersede preceding maps."
vandebo@chromium.org04c643b2011-08-08 22:33:05 +0000478//
479// In case of searching text in PDF, bfrange will have higher precedence so
480// typing char id 0x0014 in search box will get glyph id 0x0004 first. However,
481// the spec does not mention how will this kind of conflict being resolved.
482//
483// For the worst case (having 65536 continuous unicode and we use every other
484// one of them), the possible savings by aggressive optimization is 416KB
485// pre-compressed and does not provide enough motivation for implementation.
caryclark@google.com1445a0d2012-06-06 12:04:24 +0000486
487// FIXME: this should be in a header so that it is separately testable
488// ( see caller in tests/ToUnicode.cpp )
489void append_cmap_sections(const SkTDArray<SkUnichar>& glyphToUnicode,
490 const SkPDFGlyphSet* subset,
edisonn@google.com26d2e042013-09-18 19:29:08 +0000491 SkDynamicMemoryWStream* cmap,
commit-bot@chromium.org1236d8e2013-12-11 18:47:11 +0000492 bool multiByteGlyphs,
edisonn@google.com26d2e042013-09-18 19:29:08 +0000493 uint16_t firstGlyphID,
494 uint16_t lastGlyphID);
rmistry@google.comd6176b02012-08-23 18:14:13 +0000495
vandebo@chromium.org04c643b2011-08-08 22:33:05 +0000496void append_cmap_sections(const SkTDArray<SkUnichar>& glyphToUnicode,
497 const SkPDFGlyphSet* subset,
edisonn@google.com26d2e042013-09-18 19:29:08 +0000498 SkDynamicMemoryWStream* cmap,
commit-bot@chromium.org1236d8e2013-12-11 18:47:11 +0000499 bool multiByteGlyphs,
edisonn@google.com26d2e042013-09-18 19:29:08 +0000500 uint16_t firstGlyphID,
501 uint16_t lastGlyphID) {
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000502 if (glyphToUnicode.isEmpty()) {
503 return;
504 }
commit-bot@chromium.org1236d8e2013-12-11 18:47:11 +0000505 int glyphOffset = 0;
506 if (!multiByteGlyphs) {
507 glyphOffset = firstGlyphID - 1;
508 }
vandebo@chromium.org04c643b2011-08-08 22:33:05 +0000509
510 SkTDArray<BFChar> bfcharEntries;
511 SkTDArray<BFRange> bfrangeEntries;
512
bsalomon@google.comcadbcb82012-01-06 19:22:11 +0000513 BFRange currentRangeEntry = {0, 0, 0};
vandebo@chromium.org9ad35992012-01-03 18:35:39 +0000514 bool rangeEmpty = true;
commit-bot@chromium.org1236d8e2013-12-11 18:47:11 +0000515 const int limit =
516 SkMin32(lastGlyphID + 1, glyphToUnicode.count()) - glyphOffset;
vandebo@chromium.org04c643b2011-08-08 22:33:05 +0000517
commit-bot@chromium.org1236d8e2013-12-11 18:47:11 +0000518 for (int i = firstGlyphID - glyphOffset; i < limit + 1; ++i) {
edisonn@google.com26d2e042013-09-18 19:29:08 +0000519 bool inSubset = i < limit &&
commit-bot@chromium.org1236d8e2013-12-11 18:47:11 +0000520 (subset == NULL || subset->has(i + glyphOffset));
vandebo@chromium.org9ad35992012-01-03 18:35:39 +0000521 if (!rangeEmpty) {
vandebo@chromium.org04c643b2011-08-08 22:33:05 +0000522 // PDF spec requires bfrange not changing the higher byte,
523 // e.g. <1035> <10FF> <2222> is ok, but
524 // <1035> <1100> <2222> is no good
vandebo@chromium.org9ad35992012-01-03 18:35:39 +0000525 bool inRange =
526 i == currentRangeEntry.fEnd + 1 &&
527 i >> 8 == currentRangeEntry.fStart >> 8 &&
edisonn@google.com26d2e042013-09-18 19:29:08 +0000528 i < limit &&
commit-bot@chromium.org1236d8e2013-12-11 18:47:11 +0000529 glyphToUnicode[i + glyphOffset] ==
530 currentRangeEntry.fUnicode + i - currentRangeEntry.fStart;
vandebo@chromium.org9ad35992012-01-03 18:35:39 +0000531 if (!inSubset || !inRange) {
532 if (currentRangeEntry.fEnd > currentRangeEntry.fStart) {
vandebo@chromium.org04c643b2011-08-08 22:33:05 +0000533 bfrangeEntries.push(currentRangeEntry);
534 } else {
535 BFChar* entry = bfcharEntries.append();
536 entry->fGlyphId = currentRangeEntry.fStart;
537 entry->fUnicode = currentRangeEntry.fUnicode;
538 }
vandebo@chromium.org9ad35992012-01-03 18:35:39 +0000539 rangeEmpty = true;
vandebo@chromium.org04c643b2011-08-08 22:33:05 +0000540 }
vandebo@chromium.org9ad35992012-01-03 18:35:39 +0000541 }
542 if (inSubset) {
543 currentRangeEntry.fEnd = i;
544 if (rangeEmpty) {
545 currentRangeEntry.fStart = i;
commit-bot@chromium.org1236d8e2013-12-11 18:47:11 +0000546 currentRangeEntry.fUnicode = glyphToUnicode[i + glyphOffset];
vandebo@chromium.org9ad35992012-01-03 18:35:39 +0000547 rangeEmpty = false;
vandebo@chromium.org04c643b2011-08-08 22:33:05 +0000548 }
549 }
550 }
551
552 // The spec requires all bfchar entries for a font must come before bfrange
553 // entries.
554 append_bfchar_section(bfcharEntries, cmap);
555 append_bfrange_section(bfrangeEntries, cmap);
556}
557
vandebo@chromium.org98594282011-07-25 22:34:12 +0000558static SkPDFStream* generate_tounicode_cmap(
vandebo@chromium.org04c643b2011-08-08 22:33:05 +0000559 const SkTDArray<SkUnichar>& glyphToUnicode,
edisonn@google.com26d2e042013-09-18 19:29:08 +0000560 const SkPDFGlyphSet* subset,
commit-bot@chromium.org1236d8e2013-12-11 18:47:11 +0000561 bool multiByteGlyphs,
edisonn@google.com26d2e042013-09-18 19:29:08 +0000562 uint16_t firstGlyphID,
563 uint16_t lastGlyphID) {
vandebo@chromium.org98594282011-07-25 22:34:12 +0000564 SkDynamicMemoryWStream cmap;
commit-bot@chromium.org1236d8e2013-12-11 18:47:11 +0000565 if (multiByteGlyphs) {
566 append_tounicode_header(&cmap, firstGlyphID, lastGlyphID);
567 } else {
568 append_tounicode_header(&cmap, 1, lastGlyphID - firstGlyphID + 1);
569 }
570 append_cmap_sections(glyphToUnicode, subset, &cmap, multiByteGlyphs,
edisonn@google.com26d2e042013-09-18 19:29:08 +0000571 firstGlyphID, lastGlyphID);
vandebo@chromium.org98594282011-07-25 22:34:12 +0000572 append_cmap_footer(&cmap);
halcanary67ec1f82014-06-27 11:36:20 -0700573 SkAutoTUnref<SkData> cmapData(cmap.copyToData());
574 return new SkPDFStream(cmapData.get());
vandebo@chromium.org98594282011-07-25 22:34:12 +0000575}
576
caryclark@google.com1445a0d2012-06-06 12:04:24 +0000577#if defined (SK_SFNTLY_SUBSETTER)
vandebo@chromium.org1f165892011-07-26 02:11:41 +0000578static void sk_delete_array(const void* ptr, size_t, void*) {
579 // Use C-style cast to cast away const and cast type simultaneously.
580 delete[] (unsigned char*)ptr;
581}
caryclark@google.com1445a0d2012-06-06 12:04:24 +0000582#endif
vandebo@chromium.org1f165892011-07-26 02:11:41 +0000583
reed@google.comaec40662014-04-18 19:29:07 +0000584static size_t get_subset_font_stream(const char* fontName,
585 const SkTypeface* typeface,
586 const SkTDArray<uint32_t>& subset,
587 SkPDFStream** fontStream) {
reed@google.comfed86bd2013-03-14 15:04:57 +0000588 int ttcIndex;
589 SkAutoTUnref<SkStream> fontData(typeface->openStream(&ttcIndex));
halcanary67ec1f82014-06-27 11:36:20 -0700590 SkASSERT(fontData.get());
vandebo@chromium.org1f165892011-07-26 02:11:41 +0000591
reed@google.comaec40662014-04-18 19:29:07 +0000592 size_t fontSize = fontData->getLength();
vandebo@chromium.org1f165892011-07-26 02:11:41 +0000593
594#if defined (SK_SFNTLY_SUBSETTER)
vandebo@chromium.org1f165892011-07-26 02:11:41 +0000595 // Read font into buffer.
596 SkPDFStream* subsetFontStream = NULL;
597 SkTDArray<unsigned char> originalFont;
reed@google.comaec40662014-04-18 19:29:07 +0000598 originalFont.setCount(SkToInt(fontSize));
599 if (fontData->read(originalFont.begin(), fontSize) == fontSize) {
vandebo@chromium.org1f165892011-07-26 02:11:41 +0000600 unsigned char* subsetFont = NULL;
vandebo@chromium.org17e66e22011-07-27 20:59:55 +0000601 // sfntly requires unsigned int* to be passed in, as far as we know,
602 // unsigned int is equivalent to uint32_t on all platforms.
603 SK_COMPILE_ASSERT(sizeof(unsigned int) == sizeof(uint32_t),
604 unsigned_int_not_32_bits);
vandebo@chromium.org1f165892011-07-26 02:11:41 +0000605 int subsetFontSize = SfntlyWrapper::SubsetFont(fontName,
606 originalFont.begin(),
607 fontSize,
vandebo@chromium.org37ad8fb2011-08-18 02:38:50 +0000608 subset.begin(),
609 subset.count(),
vandebo@chromium.org1f165892011-07-26 02:11:41 +0000610 &subsetFont);
611 if (subsetFontSize > 0 && subsetFont != NULL) {
vandebo@chromium.org93225ff2011-07-27 18:38:11 +0000612 SkAutoDataUnref data(SkData::NewWithProc(subsetFont,
613 subsetFontSize,
614 sk_delete_array,
615 NULL));
616 subsetFontStream = new SkPDFStream(data.get());
vandebo@chromium.org1f165892011-07-26 02:11:41 +0000617 fontSize = subsetFontSize;
618 }
619 }
620 if (subsetFontStream) {
621 *fontStream = subsetFontStream;
622 return fontSize;
623 }
vandebo@chromium.org938ea622013-09-05 19:44:44 +0000624 fontData->rewind();
sugoi@google.come2e81132013-03-05 18:35:55 +0000625#else
626 sk_ignore_unused_variable(fontName);
627 sk_ignore_unused_variable(subset);
vandebo@chromium.org1f165892011-07-26 02:11:41 +0000628#endif
629
630 // Fail over: just embed the whole font.
631 *fontStream = new SkPDFStream(fontData.get());
632 return fontSize;
633}
634
vandebo@chromium.org98594282011-07-25 22:34:12 +0000635///////////////////////////////////////////////////////////////////////////////
636// class SkPDFGlyphSet
637///////////////////////////////////////////////////////////////////////////////
638
639SkPDFGlyphSet::SkPDFGlyphSet() : fBitSet(SK_MaxU16 + 1) {
640}
641
642void 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
648bool SkPDFGlyphSet::has(uint16_t glyphID) const {
649 return fBitSet.isBitSet(glyphID);
650}
651
652void SkPDFGlyphSet::merge(const SkPDFGlyphSet& usage) {
653 fBitSet.orBits(usage.fBitSet);
654}
655
vandebo@chromium.org17e66e22011-07-27 20:59:55 +0000656void SkPDFGlyphSet::exportTo(SkTDArray<unsigned int>* glyphIDs) const {
657 fBitSet.exportTo(glyphIDs);
658}
659
vandebo@chromium.org98594282011-07-25 22:34:12 +0000660///////////////////////////////////////////////////////////////////////////////
661// class SkPDFGlyphSetMap
662///////////////////////////////////////////////////////////////////////////////
663SkPDFGlyphSetMap::FontGlyphSetPair::FontGlyphSetPair(SkPDFFont* font,
664 SkPDFGlyphSet* glyphSet)
665 : fFont(font),
666 fGlyphSet(glyphSet) {
667}
668
669SkPDFGlyphSetMap::F2BIter::F2BIter(const SkPDFGlyphSetMap& map) {
670 reset(map);
671}
672
commit-bot@chromium.orgaa537d42013-02-28 19:03:13 +0000673const SkPDFGlyphSetMap::FontGlyphSetPair* SkPDFGlyphSetMap::F2BIter::next() const {
vandebo@chromium.org98594282011-07-25 22:34:12 +0000674 if (fIndex >= fMap->count()) {
675 return NULL;
676 }
677 return &((*fMap)[fIndex++]);
678}
679
680void SkPDFGlyphSetMap::F2BIter::reset(const SkPDFGlyphSetMap& map) {
681 fMap = &(map.fMap);
682 fIndex = 0;
683}
684
685SkPDFGlyphSetMap::SkPDFGlyphSetMap() {
686}
687
688SkPDFGlyphSetMap::~SkPDFGlyphSetMap() {
689 reset();
690}
691
692void 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
699void SkPDFGlyphSetMap::reset() {
700 for (int i = 0; i < fMap.count(); ++i) {
701 delete fMap[i].fGlyphSet; // Should not be NULL.
702 }
703 fMap.reset();
704}
705
706void 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
714SkPDFGlyphSet* 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
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000732/* 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
vandebo@chromium.org28be72b2010-11-11 21:37:00 +0000744SkPDFFont::~SkPDFFont() {
reed@google.comf6c3ebd2011-07-20 17:20:28 +0000745 SkAutoMutexAcquire lock(CanonicalFontsMutex());
edisonn@google.com022e8572012-10-23 21:32:39 +0000746 int index = -1;
747 for (int i = 0 ; i < CanonicalFonts().count() ; i++) {
748 if (CanonicalFonts()[i].fFont == this) {
749 index = i;
750 }
751 }
skia.committer@gmail.com1e34ff72012-10-24 02:01:24 +0000752
edisonn@google.com022e8572012-10-23 21:32:39 +0000753 SkDEBUGCODE(int indexFound;)
754 SkASSERT(index == -1 ||
reed@google.comfed86bd2013-03-14 15:04:57 +0000755 (Find(fTypeface->uniqueID(),
edisonn@google.com022e8572012-10-23 21:32:39 +0000756 fFirstGlyphID,
757 &indexFound) &&
758 index == indexFound));
759 if (index >= 0) {
reed@google.comf6c3ebd2011-07-20 17:20:28 +0000760 CanonicalFonts().removeShuffle(index);
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000761 }
762 fResources.unrefAll();
vandebo@chromium.org28be72b2010-11-11 21:37:00 +0000763}
764
edisonn@google.com6addb192013-04-02 15:33:08 +0000765void SkPDFFont::getResources(const SkTSet<SkPDFObject*>& knownResourceObjects,
766 SkTSet<SkPDFObject*>* newResourceObjects) {
767 GetResourcesHelper(&fResources, knownResourceObjects, newResourceObjects);
vandebo@chromium.org28be72b2010-11-11 21:37:00 +0000768}
769
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +0000770SkTypeface* SkPDFFont::typeface() {
771 return fTypeface.get();
vandebo@chromium.org28be72b2010-11-11 21:37:00 +0000772}
773
vandebo@chromium.orgf0ec2662011-05-29 05:55:42 +0000774SkAdvancedTypefaceMetrics::FontType SkPDFFont::getType() {
vandebo@chromium.org98594282011-07-25 22:34:12 +0000775 return fFontType;
vandebo@chromium.orgf0ec2662011-05-29 05:55:42 +0000776}
777
vandebo0f9bad02014-06-19 11:05:39 -0700778bool SkPDFFont::canEmbed() const {
779 if (!fFontInfo.get()) {
780 SkASSERT(fFontType == SkAdvancedTypefaceMetrics::kOther_Font);
781 return true;
782 }
783 return (fFontInfo->fFlags &
784 SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag) == 0;
785}
786
787bool SkPDFFont::canSubset() const {
788 if (!fFontInfo.get()) {
789 SkASSERT(fFontType == SkAdvancedTypefaceMetrics::kOther_Font);
790 return true;
791 }
792 return (fFontInfo->fFlags &
793 SkAdvancedTypefaceMetrics::kNotSubsettable_FontFlag) == 0;
794}
795
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000796bool SkPDFFont::hasGlyph(uint16_t id) {
797 return (id >= fFirstGlyphID && id <= fLastGlyphID) || id == 0;
798}
799
reed@google.comaec40662014-04-18 19:29:07 +0000800int SkPDFFont::glyphsToPDFFontEncoding(uint16_t* glyphIDs, int numGlyphs) {
vandebo@chromium.org01294102011-02-28 19:52:18 +0000801 // A font with multibyte glyphs will support all glyph IDs in a single font.
vandebo@chromium.org98594282011-07-25 22:34:12 +0000802 if (this->multiByteGlyphs()) {
vandebo@chromium.org01294102011-02-28 19:52:18 +0000803 return numGlyphs;
804 }
805
reed@google.comaec40662014-04-18 19:29:07 +0000806 for (int i = 0; i < numGlyphs; i++) {
vandebo@chromium.org01294102011-02-28 19:52:18 +0000807 if (glyphIDs[i] == 0) {
808 continue;
vandebo@chromium.org28be72b2010-11-11 21:37:00 +0000809 }
vandebo@chromium.org01294102011-02-28 19:52:18 +0000810 if (glyphIDs[i] < fFirstGlyphID || glyphIDs[i] > fLastGlyphID) {
811 return i;
812 }
813 glyphIDs[i] -= (fFirstGlyphID - 1);
vandebo@chromium.org28be72b2010-11-11 21:37:00 +0000814 }
815
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000816 return numGlyphs;
vandebo@chromium.org28be72b2010-11-11 21:37:00 +0000817}
818
819// static
reed@google.comf6c3ebd2011-07-20 17:20:28 +0000820SkPDFFont* SkPDFFont::GetFontResource(SkTypeface* typeface, uint16_t glyphID) {
821 SkAutoMutexAcquire lock(CanonicalFontsMutex());
reed@google.comfed86bd2013-03-14 15:04:57 +0000822
823 SkAutoResolveDefaultTypeface autoResolve(typeface);
824 typeface = autoResolve.get();
825
826 const uint32_t fontID = typeface->uniqueID();
vandebo@chromium.org98594282011-07-25 22:34:12 +0000827 int relatedFontIndex;
828 if (Find(fontID, glyphID, &relatedFontIndex)) {
829 CanonicalFonts()[relatedFontIndex].fFont->ref();
830 return CanonicalFonts()[relatedFontIndex].fFont;
vandebo@chromium.org28be72b2010-11-11 21:37:00 +0000831 }
832
halcanaryfb747e22014-07-11 19:45:23 -0700833 SkAutoTUnref<const SkAdvancedTypefaceMetrics> fontMetrics;
vandebo@chromium.org98594282011-07-25 22:34:12 +0000834 SkPDFDict* relatedFontDescriptor = NULL;
835 if (relatedFontIndex >= 0) {
836 SkPDFFont* relatedFont = CanonicalFonts()[relatedFontIndex].fFont;
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +0000837 fontMetrics.reset(relatedFont->fontInfo());
838 SkSafeRef(fontMetrics.get());
vandebo@chromium.org98594282011-07-25 22:34:12 +0000839 relatedFontDescriptor = relatedFont->getFontDescriptor();
edisonn@google.com022e8572012-10-23 21:32:39 +0000840
841 // This only is to catch callers who pass invalid glyph ids.
842 // If glyph id is invalid, then we will create duplicate entries
vandebo0f9bad02014-06-19 11:05:39 -0700843 // for TrueType fonts.
skia.committer@gmail.com1e34ff72012-10-24 02:01:24 +0000844 SkAdvancedTypefaceMetrics::FontType fontType =
edisonn@google.com022e8572012-10-23 21:32:39 +0000845 fontMetrics.get() ? fontMetrics.get()->fType :
846 SkAdvancedTypefaceMetrics::kOther_Font;
847
848 if (fontType == SkAdvancedTypefaceMetrics::kType1CID_Font ||
849 fontType == SkAdvancedTypefaceMetrics::kTrueType_Font) {
850 CanonicalFonts()[relatedFontIndex].fFont->ref();
851 return CanonicalFonts()[relatedFontIndex].fFont;
skia.committer@gmail.com1e34ff72012-10-24 02:01:24 +0000852 }
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000853 } else {
vandebo@chromium.org6744d492011-05-09 18:13:47 +0000854 SkAdvancedTypefaceMetrics::PerGlyphInfo info;
vandebo@chromium.org37ad8fb2011-08-18 02:38:50 +0000855 info = SkAdvancedTypefaceMetrics::kGlyphNames_PerGlyphInfo;
vandebo@chromium.org6744d492011-05-09 18:13:47 +0000856 info = SkTBitOr<SkAdvancedTypefaceMetrics::PerGlyphInfo>(
857 info, SkAdvancedTypefaceMetrics::kToUnicode_PerGlyphInfo);
vandebo@chromium.org37ad8fb2011-08-18 02:38:50 +0000858#if !defined (SK_SFNTLY_SUBSETTER)
859 info = SkTBitOr<SkAdvancedTypefaceMetrics::PerGlyphInfo>(
860 info, SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo);
861#endif
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +0000862 fontMetrics.reset(
reed@google.comfed86bd2013-03-14 15:04:57 +0000863 typeface->getAdvancedTypefaceMetrics(info, NULL, 0));
vandebo@chromium.org610f7162012-03-14 18:34:15 +0000864#if defined (SK_SFNTLY_SUBSETTER)
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +0000865 if (fontMetrics.get() &&
vandebo@chromium.orgb3b46552011-10-17 23:22:49 +0000866 fontMetrics->fType != SkAdvancedTypefaceMetrics::kTrueType_Font) {
vandebo@chromium.org37ad8fb2011-08-18 02:38:50 +0000867 // Font does not support subsetting, get new info with advance.
868 info = SkTBitOr<SkAdvancedTypefaceMetrics::PerGlyphInfo>(
869 info, SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo);
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +0000870 fontMetrics.reset(
reed@google.comfed86bd2013-03-14 15:04:57 +0000871 typeface->getAdvancedTypefaceMetrics(info, NULL, 0));
vandebo@chromium.org37ad8fb2011-08-18 02:38:50 +0000872 }
873#endif
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000874 }
vandebo@chromium.org28be72b2010-11-11 21:37:00 +0000875
vandebo@chromium.org98594282011-07-25 22:34:12 +0000876 SkPDFFont* font = Create(fontMetrics.get(), typeface, glyphID,
877 relatedFontDescriptor);
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000878 FontRec newEntry(font, fontID, font->fFirstGlyphID);
reed@google.comf6c3ebd2011-07-20 17:20:28 +0000879 CanonicalFonts().push(newEntry);
vandebo@chromium.org28be72b2010-11-11 21:37:00 +0000880 return font; // Return the reference new SkPDFFont() created.
881}
882
sugoi@google.come2e81132013-03-05 18:35:55 +0000883SkPDFFont* SkPDFFont::getFontSubset(const SkPDFGlyphSet*) {
vandebo@chromium.org98594282011-07-25 22:34:12 +0000884 return NULL; // Default: no support.
885}
886
vandebo@chromium.org28be72b2010-11-11 21:37:00 +0000887// static
reed@google.comf6c3ebd2011-07-20 17:20:28 +0000888SkTDArray<SkPDFFont::FontRec>& SkPDFFont::CanonicalFonts() {
halcanary24480bc2014-06-20 11:28:37 -0700889 SkPDFFont::CanonicalFontsMutex().assertHeld();
vandebo@chromium.org28be72b2010-11-11 21:37:00 +0000890 static SkTDArray<FontRec> gCanonicalFonts;
891 return gCanonicalFonts;
892}
893
bungemand6aeb6d2014-07-25 11:52:47 -0700894SK_DECLARE_STATIC_MUTEX(gCanonicalFontsMutex);
vandebo@chromium.org28be72b2010-11-11 21:37:00 +0000895// static
digit@google.com1771cbf2012-01-26 21:26:40 +0000896SkBaseMutex& SkPDFFont::CanonicalFontsMutex() {
vandebo@chromium.org28be72b2010-11-11 21:37:00 +0000897 return gCanonicalFontsMutex;
898}
899
900// static
reed@google.comf6c3ebd2011-07-20 17:20:28 +0000901bool SkPDFFont::Find(uint32_t fontID, uint16_t glyphID, int* index) {
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000902 // TODO(vandebo): Optimize this, do only one search?
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000903 FontRec search(NULL, fontID, glyphID);
reed@google.comf6c3ebd2011-07-20 17:20:28 +0000904 *index = CanonicalFonts().find(search);
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000905 if (*index >= 0) {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000906 return true;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +0000907 }
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000908 search.fGlyphID = 0;
reed@google.comf6c3ebd2011-07-20 17:20:28 +0000909 *index = CanonicalFonts().find(search);
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000910 return false;
vandebo@chromium.org28be72b2010-11-11 21:37:00 +0000911}
912
halcanaryfb747e22014-07-11 19:45:23 -0700913SkPDFFont::SkPDFFont(const SkAdvancedTypefaceMetrics* info,
914 SkTypeface* typeface,
sugoi@google.come2e81132013-03-05 18:35:55 +0000915 SkPDFDict* relatedFontDescriptor)
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000916 : SkPDFDict("Font"),
reed@google.comfed86bd2013-03-14 15:04:57 +0000917 fTypeface(ref_or_default(typeface)),
vandebo@chromium.org2a22e102011-01-25 21:01:34 +0000918 fFirstGlyphID(1),
vandebo@chromium.org98594282011-07-25 22:34:12 +0000919 fLastGlyphID(info ? info->fLastGlyphID : 0),
commit-bot@chromium.org45661072013-12-05 21:14:02 +0000920 fFontInfo(SkSafeRef(info)),
921 fDescriptor(SkSafeRef(relatedFontDescriptor)) {
vandebo0f9bad02014-06-19 11:05:39 -0700922 if (info == NULL ||
923 info->fFlags & SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag) {
vandebo@chromium.org98594282011-07-25 22:34:12 +0000924 fFontType = SkAdvancedTypefaceMetrics::kOther_Font;
925 } else {
926 fFontType = info->fType;
927 }
928}
929
930// static
halcanaryfb747e22014-07-11 19:45:23 -0700931SkPDFFont* SkPDFFont::Create(const SkAdvancedTypefaceMetrics* info,
vandebo@chromium.org98594282011-07-25 22:34:12 +0000932 SkTypeface* typeface, uint16_t glyphID,
933 SkPDFDict* relatedFontDescriptor) {
934 SkAdvancedTypefaceMetrics::FontType type =
vandebo0f9bad02014-06-19 11:05:39 -0700935 info ? info->fType : SkAdvancedTypefaceMetrics::kOther_Font;
vandebo@chromium.org98594282011-07-25 22:34:12 +0000936
vandebo0f9bad02014-06-19 11:05:39 -0700937 if (info &&
938 (info->fFlags & SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag)) {
vandebo@chromium.orgf0ec2662011-05-29 05:55:42 +0000939 NOT_IMPLEMENTED(true, true);
vandebo@chromium.org98594282011-07-25 22:34:12 +0000940 return new SkPDFType3Font(info,
941 typeface,
sugoi@google.come2e81132013-03-05 18:35:55 +0000942 glyphID);
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +0000943 }
vandebo@chromium.org98594282011-07-25 22:34:12 +0000944 if (type == SkAdvancedTypefaceMetrics::kType1CID_Font ||
945 type == SkAdvancedTypefaceMetrics::kTrueType_Font) {
946 SkASSERT(relatedFontDescriptor == NULL);
947 return new SkPDFType0Font(info, typeface);
948 }
949 if (type == SkAdvancedTypefaceMetrics::kType1_Font) {
950 return new SkPDFType1Font(info,
951 typeface,
952 glyphID,
953 relatedFontDescriptor);
vandebo@chromium.org6504cfd2011-07-23 20:22:53 +0000954 }
vandebo@chromium.org31dcee72011-07-23 21:13:30 +0000955
vandebo@chromium.org98594282011-07-25 22:34:12 +0000956 SkASSERT(type == SkAdvancedTypefaceMetrics::kCFF_Font ||
vandebo0f9bad02014-06-19 11:05:39 -0700957 type == SkAdvancedTypefaceMetrics::kOther_Font);
vandebo@chromium.org31dcee72011-07-23 21:13:30 +0000958
sugoi@google.come2e81132013-03-05 18:35:55 +0000959 return new SkPDFType3Font(info, typeface, glyphID);
vandebo@chromium.org31dcee72011-07-23 21:13:30 +0000960}
961
halcanaryfb747e22014-07-11 19:45:23 -0700962const SkAdvancedTypefaceMetrics* SkPDFFont::fontInfo() {
vandebo@chromium.org98594282011-07-25 22:34:12 +0000963 return fFontInfo.get();
vandebo@chromium.org31dcee72011-07-23 21:13:30 +0000964}
965
halcanaryfb747e22014-07-11 19:45:23 -0700966void SkPDFFont::setFontInfo(const SkAdvancedTypefaceMetrics* info) {
vandebo@chromium.org37ad8fb2011-08-18 02:38:50 +0000967 if (info == NULL || info == fFontInfo.get()) {
968 return;
969 }
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +0000970 fFontInfo.reset(info);
971 SkSafeRef(info);
vandebo@chromium.org37ad8fb2011-08-18 02:38:50 +0000972}
973
vandebo@chromium.org98594282011-07-25 22:34:12 +0000974uint16_t SkPDFFont::firstGlyphID() const {
975 return fFirstGlyphID;
976}
977
978uint16_t SkPDFFont::lastGlyphID() const {
979 return fLastGlyphID;
980}
981
982void SkPDFFont::setLastGlyphID(uint16_t glyphID) {
983 fLastGlyphID = glyphID;
984}
985
986void SkPDFFont::addResource(SkPDFObject* object) {
987 SkASSERT(object != NULL);
988 fResources.push(object);
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +0000989 object->ref();
vandebo@chromium.org98594282011-07-25 22:34:12 +0000990}
991
992SkPDFDict* SkPDFFont::getFontDescriptor() {
993 return fDescriptor.get();
994}
995
996void SkPDFFont::setFontDescriptor(SkPDFDict* descriptor) {
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +0000997 fDescriptor.reset(descriptor);
998 SkSafeRef(descriptor);
vandebo@chromium.org98594282011-07-25 22:34:12 +0000999}
1000
1001bool SkPDFFont::addCommonFontDescriptorEntries(int16_t defaultWidth) {
1002 if (fDescriptor.get() == NULL) {
1003 return false;
vandebo@chromium.org31dcee72011-07-23 21:13:30 +00001004 }
1005
vandebo@chromium.org98594282011-07-25 22:34:12 +00001006 const uint16_t emSize = fFontInfo->fEmSize;
1007
1008 fDescriptor->insertName("FontName", fFontInfo->fFontName);
vandebo@chromium.orgdcf9c192013-03-13 20:01:51 +00001009 fDescriptor->insertInt("Flags", fFontInfo->fStyle | kPdfSymbolic);
vandebo@chromium.org98594282011-07-25 22:34:12 +00001010 fDescriptor->insertScalar("Ascent",
1011 scaleFromFontUnits(fFontInfo->fAscent, emSize));
1012 fDescriptor->insertScalar("Descent",
1013 scaleFromFontUnits(fFontInfo->fDescent, emSize));
1014 fDescriptor->insertScalar("StemV",
1015 scaleFromFontUnits(fFontInfo->fStemV, emSize));
halcanaryfb747e22014-07-11 19:45:23 -07001016
vandebo@chromium.org98594282011-07-25 22:34:12 +00001017 fDescriptor->insertScalar("CapHeight",
1018 scaleFromFontUnits(fFontInfo->fCapHeight, emSize));
1019 fDescriptor->insertInt("ItalicAngle", fFontInfo->fItalicAngle);
1020 fDescriptor->insert("FontBBox", makeFontBBox(fFontInfo->fBBox,
1021 fFontInfo->fEmSize))->unref();
1022
1023 if (defaultWidth > 0) {
1024 fDescriptor->insertScalar("MissingWidth",
1025 scaleFromFontUnits(defaultWidth, emSize));
1026 }
1027 return true;
1028}
1029
1030void SkPDFFont::adjustGlyphRangeForSingleByteEncoding(int16_t glyphID) {
1031 // Single byte glyph encoding supports a max of 255 glyphs.
1032 fFirstGlyphID = glyphID - (glyphID - 1) % 255;
1033 if (fLastGlyphID > fFirstGlyphID + 255 - 1) {
1034 fLastGlyphID = fFirstGlyphID + 255 - 1;
1035 }
1036}
1037
1038bool SkPDFFont::FontRec::operator==(const SkPDFFont::FontRec& b) const {
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +00001039 if (fFontID != b.fFontID) {
vandebo@chromium.org98594282011-07-25 22:34:12 +00001040 return false;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +00001041 }
vandebo@chromium.org98594282011-07-25 22:34:12 +00001042 if (fFont != NULL && b.fFont != NULL) {
1043 return fFont->fFirstGlyphID == b.fFont->fFirstGlyphID &&
1044 fFont->fLastGlyphID == b.fFont->fLastGlyphID;
1045 }
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +00001046 if (fGlyphID == 0 || b.fGlyphID == 0) {
vandebo@chromium.org98594282011-07-25 22:34:12 +00001047 return true;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +00001048 }
vandebo@chromium.org98594282011-07-25 22:34:12 +00001049
1050 if (fFont != NULL) {
1051 return fFont->fFirstGlyphID <= b.fGlyphID &&
1052 b.fGlyphID <= fFont->fLastGlyphID;
1053 } else if (b.fFont != NULL) {
1054 return b.fFont->fFirstGlyphID <= fGlyphID &&
1055 fGlyphID <= b.fFont->fLastGlyphID;
1056 }
1057 return fGlyphID == b.fGlyphID;
1058}
1059
1060SkPDFFont::FontRec::FontRec(SkPDFFont* font, uint32_t fontID, uint16_t glyphID)
1061 : fFont(font),
1062 fFontID(fontID),
1063 fGlyphID(glyphID) {
1064}
1065
1066void SkPDFFont::populateToUnicodeTable(const SkPDFGlyphSet* subset) {
1067 if (fFontInfo == NULL || fFontInfo->fGlyphToUnicode.begin() == NULL) {
1068 return;
1069 }
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001070 SkAutoTUnref<SkPDFStream> pdfCmap(
edisonn@google.com26d2e042013-09-18 19:29:08 +00001071 generate_tounicode_cmap(fFontInfo->fGlyphToUnicode, subset,
commit-bot@chromium.org1236d8e2013-12-11 18:47:11 +00001072 multiByteGlyphs(), firstGlyphID(),
1073 lastGlyphID()));
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001074 addResource(pdfCmap.get());
vandebo@chromium.org6744d492011-05-09 18:13:47 +00001075 insert("ToUnicode", new SkPDFObjRef(pdfCmap.get()))->unref();
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001076}
1077
vandebo@chromium.org98594282011-07-25 22:34:12 +00001078///////////////////////////////////////////////////////////////////////////////
1079// class SkPDFType0Font
1080///////////////////////////////////////////////////////////////////////////////
vandebo@chromium.orgf7c15762011-02-01 22:19:44 +00001081
halcanaryfb747e22014-07-11 19:45:23 -07001082SkPDFType0Font::SkPDFType0Font(const SkAdvancedTypefaceMetrics* info,
vandebo@chromium.org98594282011-07-25 22:34:12 +00001083 SkTypeface* typeface)
sugoi@google.come2e81132013-03-05 18:35:55 +00001084 : SkPDFFont(info, typeface, NULL) {
vandebo@chromium.org98594282011-07-25 22:34:12 +00001085 SkDEBUGCODE(fPopulated = false);
vandebo0f9bad02014-06-19 11:05:39 -07001086 if (!canSubset()) {
1087 populate(NULL);
1088 }
vandebo@chromium.org98594282011-07-25 22:34:12 +00001089}
1090
1091SkPDFType0Font::~SkPDFType0Font() {}
1092
1093SkPDFFont* SkPDFType0Font::getFontSubset(const SkPDFGlyphSet* subset) {
vandebo0f9bad02014-06-19 11:05:39 -07001094 if (!canSubset()) {
1095 return NULL;
1096 }
vandebo@chromium.org98594282011-07-25 22:34:12 +00001097 SkPDFType0Font* newSubset = new SkPDFType0Font(fontInfo(), typeface());
1098 newSubset->populate(subset);
1099 return newSubset;
1100}
1101
1102#ifdef SK_DEBUG
1103void SkPDFType0Font::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
1104 bool indirect) {
1105 SkASSERT(fPopulated);
1106 return INHERITED::emitObject(stream, catalog, indirect);
1107}
1108#endif
1109
1110bool SkPDFType0Font::populate(const SkPDFGlyphSet* subset) {
1111 insertName("Subtype", "Type0");
1112 insertName("BaseFont", fontInfo()->fFontName);
1113 insertName("Encoding", "Identity-H");
1114
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001115 SkAutoTUnref<SkPDFCIDFont> newCIDFont(
1116 new SkPDFCIDFont(fontInfo(), typeface(), subset));
1117 addResource(newCIDFont.get());
1118 SkAutoTUnref<SkPDFArray> descendantFonts(new SkPDFArray());
1119 descendantFonts->append(new SkPDFObjRef(newCIDFont.get()))->unref();
vandebo@chromium.org98594282011-07-25 22:34:12 +00001120 insert("DescendantFonts", descendantFonts.get());
1121
1122 populateToUnicodeTable(subset);
1123
1124 SkDEBUGCODE(fPopulated = true);
1125 return true;
1126}
1127
1128///////////////////////////////////////////////////////////////////////////////
1129// class SkPDFCIDFont
1130///////////////////////////////////////////////////////////////////////////////
1131
halcanaryfb747e22014-07-11 19:45:23 -07001132SkPDFCIDFont::SkPDFCIDFont(const SkAdvancedTypefaceMetrics* info,
vandebo@chromium.org98594282011-07-25 22:34:12 +00001133 SkTypeface* typeface, const SkPDFGlyphSet* subset)
sugoi@google.come2e81132013-03-05 18:35:55 +00001134 : SkPDFFont(info, typeface, NULL) {
vandebo@chromium.org98594282011-07-25 22:34:12 +00001135 populate(subset);
1136}
1137
1138SkPDFCIDFont::~SkPDFCIDFont() {}
1139
1140bool SkPDFCIDFont::addFontDescriptor(int16_t defaultWidth,
vandebo@chromium.org37ad8fb2011-08-18 02:38:50 +00001141 const SkTDArray<uint32_t>* subset) {
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001142 SkAutoTUnref<SkPDFDict> descriptor(new SkPDFDict("FontDescriptor"));
vandebo@chromium.org98594282011-07-25 22:34:12 +00001143 setFontDescriptor(descriptor.get());
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001144 addResource(descriptor.get());
vandebo0f9bad02014-06-19 11:05:39 -07001145 insert("FontDescriptor", new SkPDFObjRef(descriptor.get()))->unref();
1146 if (!addCommonFontDescriptorEntries(defaultWidth)) {
1147 return false;
1148 }
1149 if (!canEmbed()) {
1150 return true;
1151 }
vandebo@chromium.org98594282011-07-25 22:34:12 +00001152
1153 switch (getType()) {
1154 case SkAdvancedTypefaceMetrics::kTrueType_Font: {
vandebo0f9bad02014-06-19 11:05:39 -07001155 SkAutoTUnref<SkPDFStream> fontStream;
1156 size_t fontSize = 0;
1157 if (canSubset()) {
1158 SkPDFStream* rawStream = NULL;
1159 fontSize = get_subset_font_stream(fontInfo()->fFontName.c_str(),
1160 typeface(),
1161 *subset,
1162 &rawStream);
1163 fontStream.reset(rawStream);
1164 } else {
1165 int ttcIndex;
1166 SkAutoTUnref<SkStream> fontData(
1167 typeface()->openStream(&ttcIndex));
1168 fontStream.reset(new SkPDFStream(fontData.get()));
1169 fontSize = fontData->getLength();
1170 }
vandebo@chromium.org1f165892011-07-26 02:11:41 +00001171 SkASSERT(fontSize);
vandebo0f9bad02014-06-19 11:05:39 -07001172 SkASSERT(fontStream.get());
vandebo@chromium.org98594282011-07-25 22:34:12 +00001173 addResource(fontStream.get());
1174
vandebo@chromium.org1f165892011-07-26 02:11:41 +00001175 fontStream->insertInt("Length1", fontSize);
vandebo@chromium.org98594282011-07-25 22:34:12 +00001176 descriptor->insert("FontFile2",
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001177 new SkPDFObjRef(fontStream.get()))->unref();
vandebo@chromium.org98594282011-07-25 22:34:12 +00001178 break;
1179 }
1180 case SkAdvancedTypefaceMetrics::kCFF_Font:
1181 case SkAdvancedTypefaceMetrics::kType1CID_Font: {
reed@google.comfed86bd2013-03-14 15:04:57 +00001182 int ttcIndex;
1183 SkAutoTUnref<SkStream> fontData(typeface()->openStream(&ttcIndex));
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001184 SkAutoTUnref<SkPDFStream> fontStream(
1185 new SkPDFStream(fontData.get()));
vandebo@chromium.org98594282011-07-25 22:34:12 +00001186 addResource(fontStream.get());
1187
1188 if (getType() == SkAdvancedTypefaceMetrics::kCFF_Font) {
1189 fontStream->insertName("Subtype", "Type1C");
1190 } else {
1191 fontStream->insertName("Subtype", "CIDFontType0c");
1192 }
1193 descriptor->insert("FontFile3",
1194 new SkPDFObjRef(fontStream.get()))->unref();
1195 break;
1196 }
1197 default:
1198 SkASSERT(false);
1199 }
vandebo0f9bad02014-06-19 11:05:39 -07001200 return true;
vandebo@chromium.org98594282011-07-25 22:34:12 +00001201}
1202
1203bool SkPDFCIDFont::populate(const SkPDFGlyphSet* subset) {
vandebo@chromium.org37ad8fb2011-08-18 02:38:50 +00001204 // Generate new font metrics with advance info for true type fonts.
1205 if (fontInfo()->fType == SkAdvancedTypefaceMetrics::kTrueType_Font) {
1206 // Generate glyph id array.
1207 SkTDArray<uint32_t> glyphIDs;
vandebo@chromium.org37ad8fb2011-08-18 02:38:50 +00001208 if (subset) {
commit-bot@chromium.org4da3bfc2013-12-11 23:54:31 +00001209 // Always include glyph 0.
1210 if (!subset->has(0)) {
1211 glyphIDs.push(0);
1212 }
vandebo@chromium.org37ad8fb2011-08-18 02:38:50 +00001213 subset->exportTo(&glyphIDs);
1214 }
1215
vandebo@chromium.org37ad8fb2011-08-18 02:38:50 +00001216 SkAdvancedTypefaceMetrics::PerGlyphInfo info;
1217 info = SkAdvancedTypefaceMetrics::kGlyphNames_PerGlyphInfo;
1218 info = SkTBitOr<SkAdvancedTypefaceMetrics::PerGlyphInfo>(
1219 info, SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo);
commit-bot@chromium.org4da3bfc2013-12-11 23:54:31 +00001220 uint32_t* glyphs = (glyphIDs.count() == 0) ? NULL : glyphIDs.begin();
vandebo@chromium.org37ad8fb2011-08-18 02:38:50 +00001221 uint32_t glyphsCount = glyphs ? glyphIDs.count() : 0;
halcanaryfb747e22014-07-11 19:45:23 -07001222 SkAutoTUnref<const SkAdvancedTypefaceMetrics> fontMetrics(
reed@google.comfed86bd2013-03-14 15:04:57 +00001223 typeface()->getAdvancedTypefaceMetrics(info, glyphs, glyphsCount));
vandebo@chromium.org37ad8fb2011-08-18 02:38:50 +00001224 setFontInfo(fontMetrics.get());
1225 addFontDescriptor(0, &glyphIDs);
1226 } else {
1227 // Other CID fonts
1228 addFontDescriptor(0, NULL);
1229 }
1230
vandebo@chromium.org98594282011-07-25 22:34:12 +00001231 insertName("BaseFont", fontInfo()->fFontName);
1232
1233 if (getType() == SkAdvancedTypefaceMetrics::kType1CID_Font) {
reed@google.comc789cf12011-07-20 12:14:33 +00001234 insertName("Subtype", "CIDFontType0");
vandebo@chromium.org98594282011-07-25 22:34:12 +00001235 } else if (getType() == SkAdvancedTypefaceMetrics::kTrueType_Font) {
reed@google.comc789cf12011-07-20 12:14:33 +00001236 insertName("Subtype", "CIDFontType2");
1237 insertName("CIDToGIDMap", "Identity");
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +00001238 } else {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001239 SkASSERT(false);
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +00001240 }
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001241
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001242 SkAutoTUnref<SkPDFDict> sysInfo(new SkPDFDict);
vandebo@chromium.orgf7c15762011-02-01 22:19:44 +00001243 sysInfo->insert("Registry", new SkPDFString("Adobe"))->unref();
1244 sysInfo->insert("Ordering", new SkPDFString("Identity"))->unref();
reed@google.comc789cf12011-07-20 12:14:33 +00001245 sysInfo->insertInt("Supplement", 0);
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001246 insert("CIDSystemInfo", sysInfo.get());
1247
vandebo@chromium.org98594282011-07-25 22:34:12 +00001248 if (fontInfo()->fGlyphWidths.get()) {
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +00001249 int16_t defaultWidth = 0;
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001250 SkAutoTUnref<SkPDFArray> widths(
vandebo@chromium.org98594282011-07-25 22:34:12 +00001251 composeAdvanceData(fontInfo()->fGlyphWidths.get(),
1252 fontInfo()->fEmSize, &appendWidth,
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001253 &defaultWidth));
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001254 if (widths->size())
1255 insert("W", widths.get());
1256 if (defaultWidth != 0) {
reed@google.comc789cf12011-07-20 12:14:33 +00001257 insertScalar("DW", scaleFromFontUnits(defaultWidth,
vandebo@chromium.org98594282011-07-25 22:34:12 +00001258 fontInfo()->fEmSize));
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001259 }
1260 }
vandebo@chromium.org98594282011-07-25 22:34:12 +00001261 if (fontInfo()->fVerticalMetrics.get()) {
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +00001262 struct SkAdvancedTypefaceMetrics::VerticalMetric defaultAdvance;
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001263 defaultAdvance.fVerticalAdvance = 0;
1264 defaultAdvance.fOriginXDisp = 0;
1265 defaultAdvance.fOriginYDisp = 0;
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001266 SkAutoTUnref<SkPDFArray> advances(
vandebo@chromium.org98594282011-07-25 22:34:12 +00001267 composeAdvanceData(fontInfo()->fVerticalMetrics.get(),
1268 fontInfo()->fEmSize, &appendVerticalAdvance,
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001269 &defaultAdvance));
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001270 if (advances->size())
1271 insert("W2", advances.get());
1272 if (defaultAdvance.fVerticalAdvance ||
1273 defaultAdvance.fOriginXDisp ||
1274 defaultAdvance.fOriginYDisp) {
vandebo@chromium.orgf7c15762011-02-01 22:19:44 +00001275 insert("DW2", appendVerticalAdvance(defaultAdvance,
vandebo@chromium.org98594282011-07-25 22:34:12 +00001276 fontInfo()->fEmSize,
vandebo@chromium.orgf7c15762011-02-01 22:19:44 +00001277 new SkPDFArray))->unref();
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001278 }
1279 }
vandebo@chromium.org98594282011-07-25 22:34:12 +00001280
1281 return true;
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001282}
1283
vandebo@chromium.org98594282011-07-25 22:34:12 +00001284///////////////////////////////////////////////////////////////////////////////
1285// class SkPDFType1Font
1286///////////////////////////////////////////////////////////////////////////////
1287
halcanaryfb747e22014-07-11 19:45:23 -07001288SkPDFType1Font::SkPDFType1Font(const SkAdvancedTypefaceMetrics* info,
vandebo@chromium.org98594282011-07-25 22:34:12 +00001289 SkTypeface* typeface,
1290 uint16_t glyphID,
1291 SkPDFDict* relatedFontDescriptor)
sugoi@google.come2e81132013-03-05 18:35:55 +00001292 : SkPDFFont(info, typeface, relatedFontDescriptor) {
vandebo@chromium.org98594282011-07-25 22:34:12 +00001293 populate(glyphID);
1294}
1295
1296SkPDFType1Font::~SkPDFType1Font() {}
1297
1298bool SkPDFType1Font::addFontDescriptor(int16_t defaultWidth) {
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001299 if (getFontDescriptor() != NULL) {
1300 SkPDFDict* descriptor = getFontDescriptor();
1301 addResource(descriptor);
1302 insert("FontDescriptor", new SkPDFObjRef(descriptor))->unref();
vandebo@chromium.org98594282011-07-25 22:34:12 +00001303 return true;
1304 }
1305
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001306 SkAutoTUnref<SkPDFDict> descriptor(new SkPDFDict("FontDescriptor"));
vandebo@chromium.org98594282011-07-25 22:34:12 +00001307 setFontDescriptor(descriptor.get());
1308
reed@google.comfed86bd2013-03-14 15:04:57 +00001309 int ttcIndex;
vandebo@chromium.org98594282011-07-25 22:34:12 +00001310 size_t header SK_INIT_TO_AVOID_WARNING;
1311 size_t data SK_INIT_TO_AVOID_WARNING;
1312 size_t trailer SK_INIT_TO_AVOID_WARNING;
reed@google.comfed86bd2013-03-14 15:04:57 +00001313 SkAutoTUnref<SkStream> rawFontData(typeface()->openStream(&ttcIndex));
djsollen7ba28282014-08-28 12:34:41 -07001314 SkAutoTUnref<SkData> fontData(handle_type1_stream(rawFontData.get(), &header,
1315 &data, &trailer));
1316 if (fontData.get() == NULL) {
vandebo@chromium.org98594282011-07-25 22:34:12 +00001317 return false;
1318 }
vandebo0f9bad02014-06-19 11:05:39 -07001319 if (canEmbed()) {
djsollen7ba28282014-08-28 12:34:41 -07001320 SkAutoTUnref<SkPDFStream> fontStream(new SkPDFStream(fontData.get()));
vandebo0f9bad02014-06-19 11:05:39 -07001321 addResource(fontStream.get());
1322 fontStream->insertInt("Length1", header);
1323 fontStream->insertInt("Length2", data);
1324 fontStream->insertInt("Length3", trailer);
1325 descriptor->insert("FontFile",
1326 new SkPDFObjRef(fontStream.get()))->unref();
1327 }
vandebo@chromium.org98594282011-07-25 22:34:12 +00001328
1329 addResource(descriptor.get());
vandebo@chromium.org98594282011-07-25 22:34:12 +00001330 insert("FontDescriptor", new SkPDFObjRef(descriptor.get()))->unref();
1331
1332 return addCommonFontDescriptorEntries(defaultWidth);
1333}
1334
1335bool SkPDFType1Font::populate(int16_t glyphID) {
1336 SkASSERT(!fontInfo()->fVerticalMetrics.get());
1337 SkASSERT(fontInfo()->fGlyphWidths.get());
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001338
vandebo@chromium.orgf77e27d2011-03-10 22:50:28 +00001339 adjustGlyphRangeForSingleByteEncoding(glyphID);
1340
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +00001341 int16_t defaultWidth = 0;
1342 const SkAdvancedTypefaceMetrics::WidthRange* widthRangeEntry = NULL;
1343 const SkAdvancedTypefaceMetrics::WidthRange* widthEntry;
vandebo@chromium.org98594282011-07-25 22:34:12 +00001344 for (widthEntry = fontInfo()->fGlyphWidths.get();
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001345 widthEntry != NULL;
1346 widthEntry = widthEntry->fNext.get()) {
1347 switch (widthEntry->fType) {
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +00001348 case SkAdvancedTypefaceMetrics::WidthRange::kDefault:
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001349 defaultWidth = widthEntry->fAdvance[0];
1350 break;
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +00001351 case SkAdvancedTypefaceMetrics::WidthRange::kRun:
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001352 SkASSERT(false);
1353 break;
vandebo@chromium.orgc48b2b32011-02-02 02:11:22 +00001354 case SkAdvancedTypefaceMetrics::WidthRange::kRange:
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001355 SkASSERT(widthRangeEntry == NULL);
1356 widthRangeEntry = widthEntry;
1357 break;
1358 }
1359 }
1360
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +00001361 if (!addFontDescriptor(defaultWidth)) {
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001362 return false;
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +00001363 }
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001364
reed@google.comc789cf12011-07-20 12:14:33 +00001365 insertName("Subtype", "Type1");
vandebo@chromium.org98594282011-07-25 22:34:12 +00001366 insertName("BaseFont", fontInfo()->fFontName);
vandebo@chromium.org28be72b2010-11-11 21:37:00 +00001367
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +00001368 addWidthInfoFromRange(defaultWidth, widthRangeEntry);
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001369
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001370 SkAutoTUnref<SkPDFDict> encoding(new SkPDFDict("Encoding"));
vandebo@chromium.org28be72b2010-11-11 21:37:00 +00001371 insert("Encoding", encoding.get());
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001372
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001373 SkAutoTUnref<SkPDFArray> encDiffs(new SkPDFArray);
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001374 encoding->insert("Differences", encDiffs.get());
1375
vandebo@chromium.org98594282011-07-25 22:34:12 +00001376 encDiffs->reserve(lastGlyphID() - firstGlyphID() + 2);
reed@google.comc789cf12011-07-20 12:14:33 +00001377 encDiffs->appendInt(1);
vandebo@chromium.org98594282011-07-25 22:34:12 +00001378 for (int gID = firstGlyphID(); gID <= lastGlyphID(); gID++) {
1379 encDiffs->appendName(fontInfo()->fGlyphNames->get()[gID].c_str());
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001380 }
1381
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001382 return true;
vandebo@chromium.org28be72b2010-11-11 21:37:00 +00001383}
1384
vandebo@chromium.org98594282011-07-25 22:34:12 +00001385void SkPDFType1Font::addWidthInfoFromRange(
1386 int16_t defaultWidth,
1387 const SkAdvancedTypefaceMetrics::WidthRange* widthRangeEntry) {
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001388 SkAutoTUnref<SkPDFArray> widthArray(new SkPDFArray());
vandebo@chromium.org98594282011-07-25 22:34:12 +00001389 int firstChar = 0;
1390 if (widthRangeEntry) {
1391 const uint16_t emSize = fontInfo()->fEmSize;
1392 int startIndex = firstGlyphID() - widthRangeEntry->fStartId;
1393 int endIndex = startIndex + lastGlyphID() - firstGlyphID() + 1;
1394 if (startIndex < 0)
1395 startIndex = 0;
1396 if (endIndex > widthRangeEntry->fAdvance.count())
1397 endIndex = widthRangeEntry->fAdvance.count();
1398 if (widthRangeEntry->fStartId == 0) {
1399 appendWidth(widthRangeEntry->fAdvance[0], emSize, widthArray.get());
1400 } else {
1401 firstChar = startIndex + widthRangeEntry->fStartId;
1402 }
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +00001403 for (int i = startIndex; i < endIndex; i++) {
vandebo@chromium.org98594282011-07-25 22:34:12 +00001404 appendWidth(widthRangeEntry->fAdvance[i], emSize, widthArray.get());
ctguil@chromium.org769fa6a2011-08-20 00:36:18 +00001405 }
vandebo@chromium.org98594282011-07-25 22:34:12 +00001406 } else {
1407 appendWidth(defaultWidth, 1000, widthArray.get());
1408 }
1409 insertInt("FirstChar", firstChar);
1410 insertInt("LastChar", firstChar + widthArray->size() - 1);
1411 insert("Widths", widthArray.get());
1412}
1413
1414///////////////////////////////////////////////////////////////////////////////
1415// class SkPDFType3Font
1416///////////////////////////////////////////////////////////////////////////////
1417
halcanaryfb747e22014-07-11 19:45:23 -07001418SkPDFType3Font::SkPDFType3Font(const SkAdvancedTypefaceMetrics* info,
vandebo@chromium.org98594282011-07-25 22:34:12 +00001419 SkTypeface* typeface,
sugoi@google.come2e81132013-03-05 18:35:55 +00001420 uint16_t glyphID)
1421 : SkPDFFont(info, typeface, NULL) {
vandebo@chromium.org98594282011-07-25 22:34:12 +00001422 populate(glyphID);
1423}
1424
1425SkPDFType3Font::~SkPDFType3Font() {}
1426
1427bool SkPDFType3Font::populate(int16_t glyphID) {
vandebo@chromium.orgf77e27d2011-03-10 22:50:28 +00001428 SkPaint paint;
vandebo@chromium.org98594282011-07-25 22:34:12 +00001429 paint.setTypeface(typeface());
vandebo@chromium.orgf77e27d2011-03-10 22:50:28 +00001430 paint.setTextSize(1000);
bungeman@google.com532470f2013-01-22 19:25:14 +00001431 SkAutoGlyphCache autoCache(paint, NULL, NULL);
vandebo@chromium.orgf77e27d2011-03-10 22:50:28 +00001432 SkGlyphCache* cache = autoCache.getCache();
1433 // If fLastGlyphID isn't set (because there is not fFontInfo), look it up.
vandebo@chromium.org98594282011-07-25 22:34:12 +00001434 if (lastGlyphID() == 0) {
1435 setLastGlyphID(cache->getGlyphCount() - 1);
vandebo@chromium.orgf77e27d2011-03-10 22:50:28 +00001436 }
1437
1438 adjustGlyphRangeForSingleByteEncoding(glyphID);
1439
reed@google.comc789cf12011-07-20 12:14:33 +00001440 insertName("Subtype", "Type3");
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +00001441 // Flip about the x-axis and scale by 1/1000.
1442 SkMatrix fontMatrix;
1443 fontMatrix.setScale(SkScalarInvert(1000), -SkScalarInvert(1000));
1444 insert("FontMatrix", SkPDFUtils::MatrixToArray(fontMatrix))->unref();
1445
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001446 SkAutoTUnref<SkPDFDict> charProcs(new SkPDFDict);
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +00001447 insert("CharProcs", charProcs.get());
1448
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001449 SkAutoTUnref<SkPDFDict> encoding(new SkPDFDict("Encoding"));
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +00001450 insert("Encoding", encoding.get());
1451
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001452 SkAutoTUnref<SkPDFArray> encDiffs(new SkPDFArray);
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +00001453 encoding->insert("Differences", encDiffs.get());
vandebo@chromium.org98594282011-07-25 22:34:12 +00001454 encDiffs->reserve(lastGlyphID() - firstGlyphID() + 2);
reed@google.comc789cf12011-07-20 12:14:33 +00001455 encDiffs->appendInt(1);
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +00001456
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001457 SkAutoTUnref<SkPDFArray> widthArray(new SkPDFArray());
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +00001458
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +00001459 SkIRect bbox = SkIRect::MakeEmpty();
vandebo@chromium.org98594282011-07-25 22:34:12 +00001460 for (int gID = firstGlyphID(); gID <= lastGlyphID(); gID++) {
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +00001461 SkString characterName;
1462 characterName.printf("gid%d", gID);
reed@google.comc789cf12011-07-20 12:14:33 +00001463 encDiffs->appendName(characterName.c_str());
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +00001464
reed@google.comce11b262011-03-21 21:25:35 +00001465 const SkGlyph& glyph = cache->getGlyphIDMetrics(gID);
reed@google.comc789cf12011-07-20 12:14:33 +00001466 widthArray->appendScalar(SkFixedToScalar(glyph.fAdvanceX));
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +00001467 SkIRect glyphBBox = SkIRect::MakeXYWH(glyph.fLeft, glyph.fTop,
1468 glyph.fWidth, glyph.fHeight);
1469 bbox.join(glyphBBox);
1470
vandebo@chromium.orgcae5fba2011-03-28 19:03:50 +00001471 SkDynamicMemoryWStream content;
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +00001472 setGlyphWidthAndBoundingBox(SkFixedToScalar(glyph.fAdvanceX), glyphBBox,
1473 &content);
1474 const SkPath* path = cache->findPath(glyph);
1475 if (path) {
vandebo@chromium.org683001c2012-05-09 17:17:51 +00001476 SkPDFUtils::EmitPath(*path, paint.getStyle(), &content);
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +00001477 SkPDFUtils::PaintPath(paint.getStyle(), path->getFillType(),
1478 &content);
1479 }
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001480 SkAutoTUnref<SkMemoryStream> glyphStream(new SkMemoryStream());
reed@google.com8a85d0c2011-06-24 19:12:12 +00001481 glyphStream->setData(content.copyToData())->unref();
vandebo@chromium.orgcae5fba2011-03-28 19:03:50 +00001482
vandebo@chromium.orgd96d17b2013-01-04 19:31:24 +00001483 SkAutoTUnref<SkPDFStream> glyphDescription(
1484 new SkPDFStream(glyphStream.get()));
vandebo@chromium.org98594282011-07-25 22:34:12 +00001485 addResource(glyphDescription.get());
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +00001486 charProcs->insert(characterName.c_str(),
1487 new SkPDFObjRef(glyphDescription.get()))->unref();
1488 }
1489
1490 insert("FontBBox", makeFontBBox(bbox, 1000))->unref();
commit-bot@chromium.org1236d8e2013-12-11 18:47:11 +00001491 insertInt("FirstChar", 1);
1492 insertInt("LastChar", lastGlyphID() - firstGlyphID() + 1);
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +00001493 insert("Widths", widthArray.get());
reed@google.comc789cf12011-07-20 12:14:33 +00001494 insertName("CIDToGIDMap", "Identity");
ctguil@chromium.org9db86bb2011-03-04 21:43:27 +00001495
vandebo@chromium.org98594282011-07-25 22:34:12 +00001496 populateToUnicodeTable(NULL);
vandebo@chromium.org2a22e102011-01-25 21:01:34 +00001497 return true;
1498}