The Tor Browser / file comparison

comparison: gfx/thebes/gfxFontUtils.cpp

gfx/thebes/gfxFontUtils.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:ac2609e35abd
1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #ifdef MOZ_LOGGING
7 #define FORCE_PR_LOG /* Allow logging in the release build */
8 #include "prlog.h"
9 #endif
10
11 #include "mozilla/ArrayUtils.h"
12
13 #include "gfxFontUtils.h"
14
15 #include "nsServiceManagerUtils.h"
16
17 #include "mozilla/dom/EncodingUtils.h"
18 #include "mozilla/Preferences.h"
19 #include "mozilla/Services.h"
20
21 #include "nsCOMPtr.h"
22 #include "nsIUUIDGenerator.h"
23 #include "nsIUnicodeDecoder.h"
24
25 #include "harfbuzz/hb.h"
26
27 #include "plbase64.h"
28 #include "prlog.h"
29
30 #ifdef PR_LOGGING
31
32 #define LOG(log, args) PR_LOG(gfxPlatform::GetLog(log), \
33 PR_LOG_DEBUG, args)
34
35 #endif // PR_LOGGING
36
37 #define UNICODE_BMP_LIMIT 0x10000
38
39 using namespace mozilla;
40
41 #pragma pack(1)
42
43 typedef struct {
44 AutoSwap_PRUint16 format;
45 AutoSwap_PRUint16 reserved;
46 AutoSwap_PRUint32 length;
47 AutoSwap_PRUint32 language;
48 AutoSwap_PRUint32 numGroups;
49 } Format12CmapHeader;
50
51 typedef struct {
52 AutoSwap_PRUint32 startCharCode;
53 AutoSwap_PRUint32 endCharCode;
54 AutoSwap_PRUint32 startGlyphId;
55 } Format12Group;
56
57 #pragma pack()
58
59 #if PR_LOGGING
60 void
61 gfxSparseBitSet::Dump(const char* aPrefix, eGfxLog aWhichLog) const
62 {
63 NS_ASSERTION(mBlocks.DebugGetHeader(), "mHdr is null, this is bad");
64 uint32_t b, numBlocks = mBlocks.Length();
65
66 for (b = 0; b < numBlocks; b++) {
67 Block *block = mBlocks[b];
68 if (!block) continue;
69 char outStr[256];
70 int index = 0;
71 index += sprintf(&outStr[index], "%s u+%6.6x [", aPrefix, (b << BLOCK_INDEX_SHIFT));
72 for (int i = 0; i < 32; i += 4) {
73 for (int j = i; j < i + 4; j++) {
74 uint8_t bits = block->mBits[j];
75 uint8_t flip1 = ((bits & 0xaa) >> 1) | ((bits & 0x55) << 1);
76 uint8_t flip2 = ((flip1 & 0xcc) >> 2) | ((flip1 & 0x33) << 2);
77 uint8_t flipped = ((flip2 & 0xf0) >> 4) | ((flip2 & 0x0f) << 4);
78
79 index += sprintf(&outStr[index], "%2.2x", flipped);
80 }
81 if (i + 4 != 32) index += sprintf(&outStr[index], " ");
82 }
83 index += sprintf(&outStr[index], "]");
84 LOG(aWhichLog, ("%s", outStr));
85 }
86 }
87 #endif
88
89
90 nsresult
91 gfxFontUtils::ReadCMAPTableFormat12(const uint8_t *aBuf, uint32_t aLength,
92 gfxSparseBitSet& aCharacterMap)
93 {
94 // Ensure table is large enough that we can safely read the header
95 NS_ENSURE_TRUE(aLength >= sizeof(Format12CmapHeader),
96 NS_ERROR_GFX_CMAP_MALFORMED);
97
98 // Sanity-check header fields
99 const Format12CmapHeader *cmap12 =
100 reinterpret_cast<const Format12CmapHeader*>(aBuf);
101 NS_ENSURE_TRUE(uint16_t(cmap12->format) == 12,
102 NS_ERROR_GFX_CMAP_MALFORMED);
103 NS_ENSURE_TRUE(uint16_t(cmap12->reserved) == 0,
104 NS_ERROR_GFX_CMAP_MALFORMED);
105
106 uint32_t tablelen = cmap12->length;
107 NS_ENSURE_TRUE(tablelen >= sizeof(Format12CmapHeader) &&
108 tablelen <= aLength, NS_ERROR_GFX_CMAP_MALFORMED);
109
110 NS_ENSURE_TRUE(cmap12->language == 0, NS_ERROR_GFX_CMAP_MALFORMED);
111
112 // Check that the table is large enough for the group array
113 const uint32_t numGroups = cmap12->numGroups;
114 NS_ENSURE_TRUE((tablelen - sizeof(Format12CmapHeader)) /
115 sizeof(Format12Group) >= numGroups,
116 NS_ERROR_GFX_CMAP_MALFORMED);
117
118 // The array of groups immediately follows the subtable header.
119 const Format12Group *group =
120 reinterpret_cast<const Format12Group*>(aBuf + sizeof(Format12CmapHeader));
121
122 // Check that groups are in correct order and do not overlap,
123 // and record character coverage in aCharacterMap.
124 uint32_t prevEndCharCode = 0;
125 for (uint32_t i = 0; i < numGroups; i++, group++) {
126 uint32_t startCharCode = group->startCharCode;
127 const uint32_t endCharCode = group->endCharCode;
128 NS_ENSURE_TRUE((prevEndCharCode < startCharCode || i == 0) &&
129 startCharCode <= endCharCode &&
130 endCharCode <= CMAP_MAX_CODEPOINT,
131 NS_ERROR_GFX_CMAP_MALFORMED);
132 // don't include a character that maps to glyph ID 0 (.notdef)
133 if (group->startGlyphId == 0) {
134 startCharCode++;
135 }
136 if (startCharCode <= endCharCode) {
137 aCharacterMap.SetRange(startCharCode, endCharCode);
138 }
139 prevEndCharCode = endCharCode;
140 }
141
142 aCharacterMap.Compact();
143
144 return NS_OK;
145 }
146
147 nsresult
148 gfxFontUtils::ReadCMAPTableFormat4(const uint8_t *aBuf, uint32_t aLength,
149 gfxSparseBitSet& aCharacterMap)
150 {
151 enum {
152 OffsetFormat = 0,
153 OffsetLength = 2,
154 OffsetLanguage = 4,
155 OffsetSegCountX2 = 6
156 };
157
158 NS_ENSURE_TRUE(ReadShortAt(aBuf, OffsetFormat) == 4,
159 NS_ERROR_GFX_CMAP_MALFORMED);
160 uint16_t tablelen = ReadShortAt(aBuf, OffsetLength);
161 NS_ENSURE_TRUE(tablelen <= aLength, NS_ERROR_GFX_CMAP_MALFORMED);
162 NS_ENSURE_TRUE(tablelen > 16, NS_ERROR_GFX_CMAP_MALFORMED);
163
164 // This field should normally (except for Mac platform subtables) be zero according to
165 // the OT spec, but some buggy fonts have lang = 1 (which would be English for MacOS).
166 // E.g. Arial Narrow Bold, v. 1.1 (Tiger), Arial Unicode MS (see bug 530614).
167 // So accept either zero or one here; the error should be harmless.
168 NS_ENSURE_TRUE((ReadShortAt(aBuf, OffsetLanguage) & 0xfffe) == 0,
169 NS_ERROR_GFX_CMAP_MALFORMED);
170
171 uint16_t segCountX2 = ReadShortAt(aBuf, OffsetSegCountX2);
172 NS_ENSURE_TRUE(tablelen >= 16 + (segCountX2 * 4),
173 NS_ERROR_GFX_CMAP_MALFORMED);
174
175 const uint16_t segCount = segCountX2 / 2;
176
177 const uint16_t *endCounts = reinterpret_cast<const uint16_t*>(aBuf + 14);
178 const uint16_t *startCounts = endCounts + 1 /* skip one uint16_t for reservedPad */ + segCount;
179 const uint16_t *idDeltas = startCounts + segCount;
180 const uint16_t *idRangeOffsets = idDeltas + segCount;
181 uint16_t prevEndCount = 0;
182 for (uint16_t i = 0; i < segCount; i++) {
183 const uint16_t endCount = ReadShortAt16(endCounts, i);
184 const uint16_t startCount = ReadShortAt16(startCounts, i);
185 const uint16_t idRangeOffset = ReadShortAt16(idRangeOffsets, i);
186
187 // sanity-check range
188 // This permits ranges to overlap by 1 character, which is strictly
189 // incorrect but occurs in Baskerville on OS X 10.7 (see bug 689087),
190 // and appears to be harmless in practice
191 NS_ENSURE_TRUE(startCount >= prevEndCount && startCount <= endCount,
192 NS_ERROR_GFX_CMAP_MALFORMED);
193 prevEndCount = endCount;
194
195 if (idRangeOffset == 0) {
196 // figure out if there's a code in the range that would map to
197 // glyph ID 0 (.notdef); if so, we need to skip setting that
198 // character code in the map
199 const uint16_t skipCode = 65536 - ReadShortAt16(idDeltas, i);
200 if (startCount < skipCode) {
201 aCharacterMap.SetRange(startCount,
202 std::min<uint16_t>(skipCode - 1,
203 endCount));
204 }
205 if (skipCode < endCount) {
206 aCharacterMap.SetRange(std::max<uint16_t>(startCount,
207 skipCode + 1),
208 endCount);
209 }
210 } else {
211 // const uint16_t idDelta = ReadShortAt16(idDeltas, i); // Unused: self-documenting.
212 for (uint32_t c = startCount; c <= endCount; ++c) {
213 if (c == 0xFFFF)
214 break;
215
216 const uint16_t *gdata = (idRangeOffset/2
217 + (c - startCount)
218 + &idRangeOffsets[i]);
219
220 NS_ENSURE_TRUE((uint8_t*)gdata > aBuf &&
221 (uint8_t*)gdata < aBuf + aLength,
222 NS_ERROR_GFX_CMAP_MALFORMED);
223
224 // make sure we have a glyph
225 if (*gdata != 0) {
226 // The glyph index at this point is:
227 uint16_t glyph = ReadShortAt16(idDeltas, i) + *gdata;
228 if (glyph) {
229 aCharacterMap.set(c);
230 }
231 }
232 }
233 }
234 }
235
236 aCharacterMap.Compact();
237
238 return NS_OK;
239 }
240
241 nsresult
242 gfxFontUtils::ReadCMAPTableFormat14(const uint8_t *aBuf, uint32_t aLength,
243 uint8_t*& aTable)
244 {
245 enum {
246 OffsetFormat = 0,
247 OffsetTableLength = 2,
248 OffsetNumVarSelectorRecords = 6,
249 OffsetVarSelectorRecords = 10,
250
251 SizeOfVarSelectorRecord = 11,
252 VSRecOffsetVarSelector = 0,
253 VSRecOffsetDefUVSOffset = 3,
254 VSRecOffsetNonDefUVSOffset = 7,
255
256 SizeOfDefUVSTable = 4,
257 DefUVSOffsetStartUnicodeValue = 0,
258 DefUVSOffsetAdditionalCount = 3,
259
260 SizeOfNonDefUVSTable = 5,
261 NonDefUVSOffsetUnicodeValue = 0,
262 NonDefUVSOffsetGlyphID = 3
263 };
264 NS_ENSURE_TRUE(aLength >= OffsetVarSelectorRecords,
265 NS_ERROR_GFX_CMAP_MALFORMED);
266
267 NS_ENSURE_TRUE(ReadShortAt(aBuf, OffsetFormat) == 14,
268 NS_ERROR_GFX_CMAP_MALFORMED);
269
270 uint32_t tablelen = ReadLongAt(aBuf, OffsetTableLength);
271 NS_ENSURE_TRUE(tablelen <= aLength, NS_ERROR_GFX_CMAP_MALFORMED);
272 NS_ENSURE_TRUE(tablelen >= OffsetVarSelectorRecords,
273 NS_ERROR_GFX_CMAP_MALFORMED);
274
275 const uint32_t numVarSelectorRecords = ReadLongAt(aBuf, OffsetNumVarSelectorRecords);
276 NS_ENSURE_TRUE((tablelen - OffsetVarSelectorRecords) /
277 SizeOfVarSelectorRecord >= numVarSelectorRecords,
278 NS_ERROR_GFX_CMAP_MALFORMED);
279
280 const uint8_t *records = aBuf + OffsetVarSelectorRecords;
281 for (uint32_t i = 0; i < numVarSelectorRecords;
282 i++, records += SizeOfVarSelectorRecord) {
283 const uint32_t varSelector = ReadUint24At(records, VSRecOffsetVarSelector);
284 const uint32_t defUVSOffset = ReadLongAt(records, VSRecOffsetDefUVSOffset);
285 const uint32_t nonDefUVSOffset = ReadLongAt(records, VSRecOffsetNonDefUVSOffset);
286 NS_ENSURE_TRUE(varSelector <= CMAP_MAX_CODEPOINT &&
287 defUVSOffset <= tablelen - 4 &&
288 nonDefUVSOffset <= tablelen - 4,
289 NS_ERROR_GFX_CMAP_MALFORMED);
290
291 if (defUVSOffset) {
292 const uint32_t numUnicodeValueRanges = ReadLongAt(aBuf, defUVSOffset);
293 NS_ENSURE_TRUE((tablelen - defUVSOffset) /
294 SizeOfDefUVSTable >= numUnicodeValueRanges,
295 NS_ERROR_GFX_CMAP_MALFORMED);
296 const uint8_t *tables = aBuf + defUVSOffset + 4;
297 uint32_t prevEndUnicode = 0;
298 for (uint32_t j = 0; j < numUnicodeValueRanges; j++, tables += SizeOfDefUVSTable) {
299 const uint32_t startUnicode = ReadUint24At(tables, DefUVSOffsetStartUnicodeValue);
300 const uint32_t endUnicode = startUnicode + tables[DefUVSOffsetAdditionalCount];
301 NS_ENSURE_TRUE((prevEndUnicode < startUnicode || j == 0) &&
302 endUnicode <= CMAP_MAX_CODEPOINT,
303 NS_ERROR_GFX_CMAP_MALFORMED);
304 prevEndUnicode = endUnicode;
305 }
306 }
307
308 if (nonDefUVSOffset) {
309 const uint32_t numUVSMappings = ReadLongAt(aBuf, nonDefUVSOffset);
310 NS_ENSURE_TRUE((tablelen - nonDefUVSOffset) /
311 SizeOfNonDefUVSTable >= numUVSMappings,
312 NS_ERROR_GFX_CMAP_MALFORMED);
313 const uint8_t *tables = aBuf + nonDefUVSOffset + 4;
314 uint32_t prevUnicode = 0;
315 for (uint32_t j = 0; j < numUVSMappings; j++, tables += SizeOfNonDefUVSTable) {
316 const uint32_t unicodeValue = ReadUint24At(tables, NonDefUVSOffsetUnicodeValue);
317 NS_ENSURE_TRUE((prevUnicode < unicodeValue || j == 0) &&
318 unicodeValue <= CMAP_MAX_CODEPOINT,
319 NS_ERROR_GFX_CMAP_MALFORMED);
320 prevUnicode = unicodeValue;
321 }
322 }
323 }
324
325 aTable = new uint8_t[tablelen];
326 memcpy(aTable, aBuf, tablelen);
327
328 return NS_OK;
329 }
330
331 // Windows requires fonts to have a format-4 cmap with a Microsoft ID (3). On the Mac, fonts either have
332 // a format-4 cmap with Microsoft platform/encoding id or they have one with a platformID == Unicode (0)
333 // For fonts with two format-4 tables, the first one (Unicode platform) is preferred on the Mac.
334
335 #if defined(XP_MACOSX)
336 #define acceptableFormat4(p,e,k) (((p) == PLATFORM_ID_MICROSOFT && (e) == EncodingIDMicrosoft && !(k)) || \
337 ((p) == PLATFORM_ID_UNICODE))
338
339 #define acceptableUCS4Encoding(p, e, k) \
340 (((p) == PLATFORM_ID_MICROSOFT && (e) == EncodingIDUCS4ForMicrosoftPlatform) && (k) != 12 || \
341 ((p) == PLATFORM_ID_UNICODE && \
342 ((e) == EncodingIDDefaultForUnicodePlatform || (e) >= EncodingIDUCS4ForUnicodePlatform)))
343 #else
344 #define acceptableFormat4(p,e,k) ((p) == PLATFORM_ID_MICROSOFT && (e) == EncodingIDMicrosoft)
345
346 #define acceptableUCS4Encoding(p, e, k) \
347 ((p) == PLATFORM_ID_MICROSOFT && (e) == EncodingIDUCS4ForMicrosoftPlatform)
348 #endif
349
350 #define acceptablePlatform(p) ((p) == PLATFORM_ID_UNICODE || (p) == PLATFORM_ID_MICROSOFT)
351 #define isSymbol(p,e) ((p) == PLATFORM_ID_MICROSOFT && (e) == EncodingIDSymbol)
352 #define isUVSEncoding(p, e) ((p) == PLATFORM_ID_UNICODE && (e) == EncodingIDUVSForUnicodePlatform)
353
354 uint32_t
355 gfxFontUtils::FindPreferredSubtable(const uint8_t *aBuf, uint32_t aBufLength,
356 uint32_t *aTableOffset,
357 uint32_t *aUVSTableOffset,
358 bool *aSymbolEncoding)
359 {
360 enum {
361 OffsetVersion = 0,
362 OffsetNumTables = 2,
363 SizeOfHeader = 4,
364
365 TableOffsetPlatformID = 0,
366 TableOffsetEncodingID = 2,
367 TableOffsetOffset = 4,
368 SizeOfTable = 8,
369
370 SubtableOffsetFormat = 0
371 };
372 enum {
373 EncodingIDSymbol = 0,
374 EncodingIDMicrosoft = 1,
375 EncodingIDDefaultForUnicodePlatform = 0,
376 EncodingIDUCS4ForUnicodePlatform = 3,
377 EncodingIDUVSForUnicodePlatform = 5,
378 EncodingIDUCS4ForMicrosoftPlatform = 10
379 };
380
381 if (aUVSTableOffset) {
382 *aUVSTableOffset = 0;
383 }
384
385 if (!aBuf || aBufLength < SizeOfHeader) {
386 // cmap table is missing, or too small to contain header fields!
387 return 0;
388 }
389
390 // uint16_t version = ReadShortAt(aBuf, OffsetVersion); // Unused: self-documenting.
391 uint16_t numTables = ReadShortAt(aBuf, OffsetNumTables);
392 if (aBufLength < uint32_t(SizeOfHeader + numTables * SizeOfTable)) {
393 return 0;
394 }
395
396 // save the format we want here
397 uint32_t keepFormat = 0;
398
399 const uint8_t *table = aBuf + SizeOfHeader;
400 for (uint16_t i = 0; i < numTables; ++i, table += SizeOfTable) {
401 const uint16_t platformID = ReadShortAt(table, TableOffsetPlatformID);
402 if (!acceptablePlatform(platformID))
403 continue;
404
405 const uint16_t encodingID = ReadShortAt(table, TableOffsetEncodingID);
406 const uint32_t offset = ReadLongAt(table, TableOffsetOffset);
407 if (aBufLength - 2 < offset) {
408 // this subtable is not valid - beyond end of buffer
409 return 0;
410 }
411
412 const uint8_t *subtable = aBuf + offset;
413 const uint16_t format = ReadShortAt(subtable, SubtableOffsetFormat);
414
415 if (isSymbol(platformID, encodingID)) {
416 keepFormat = format;
417 *aTableOffset = offset;
418 *aSymbolEncoding = true;
419 break;
420 } else if (format == 4 && acceptableFormat4(platformID, encodingID, keepFormat)) {
421 keepFormat = format;
422 *aTableOffset = offset;
423 *aSymbolEncoding = false;
424 } else if (format == 12 && acceptableUCS4Encoding(platformID, encodingID, keepFormat)) {
425 keepFormat = format;
426 *aTableOffset = offset;
427 *aSymbolEncoding = false;
428 if (platformID > PLATFORM_ID_UNICODE || !aUVSTableOffset || *aUVSTableOffset) {
429 break; // we don't want to try anything else when this format is available.
430 }
431 } else if (format == 14 && isUVSEncoding(platformID, encodingID) && aUVSTableOffset) {
432 *aUVSTableOffset = offset;
433 if (keepFormat == 12) {
434 break;
435 }
436 }
437 }
438
439 return keepFormat;
440 }
441
442 nsresult
443 gfxFontUtils::ReadCMAP(const uint8_t *aBuf, uint32_t aBufLength,
444 gfxSparseBitSet& aCharacterMap,
445 uint32_t& aUVSOffset,
446 bool& aUnicodeFont, bool& aSymbolFont)
447 {
448 uint32_t offset;
449 bool symbol;
450 uint32_t format = FindPreferredSubtable(aBuf, aBufLength,
451 &offset, &aUVSOffset, &symbol);
452
453 if (format == 4) {
454 if (symbol) {
455 aUnicodeFont = false;
456 aSymbolFont = true;
457 } else {
458 aUnicodeFont = true;
459 aSymbolFont = false;
460 }
461 return ReadCMAPTableFormat4(aBuf + offset, aBufLength - offset,
462 aCharacterMap);
463 }
464
465 if (format == 12) {
466 aUnicodeFont = true;
467 aSymbolFont = false;
468 return ReadCMAPTableFormat12(aBuf + offset, aBufLength - offset,
469 aCharacterMap);
470 }
471
472 return NS_ERROR_FAILURE;
473 }
474
475 #pragma pack(1)
476
477 typedef struct {
478 AutoSwap_PRUint16 format;
479 AutoSwap_PRUint16 length;
480 AutoSwap_PRUint16 language;
481 AutoSwap_PRUint16 segCountX2;
482 AutoSwap_PRUint16 searchRange;
483 AutoSwap_PRUint16 entrySelector;
484 AutoSwap_PRUint16 rangeShift;
485
486 AutoSwap_PRUint16 arrays[1];
487 } Format4Cmap;
488
489 typedef struct {
490 AutoSwap_PRUint16 format;
491 AutoSwap_PRUint32 length;
492 AutoSwap_PRUint32 numVarSelectorRecords;
493
494 typedef struct {
495 AutoSwap_PRUint24 varSelector;
496 AutoSwap_PRUint32 defaultUVSOffset;
497 AutoSwap_PRUint32 nonDefaultUVSOffset;
498 } VarSelectorRecord;
499
500 VarSelectorRecord varSelectorRecords[1];
501 } Format14Cmap;
502
503 typedef struct {
504 AutoSwap_PRUint32 numUVSMappings;
505
506 typedef struct {
507 AutoSwap_PRUint24 unicodeValue;
508 AutoSwap_PRUint16 glyphID;
509 } UVSMapping;
510
511 UVSMapping uvsMappings[1];
512 } NonDefUVSTable;
513
514 #pragma pack()
515
516 uint32_t
517 gfxFontUtils::MapCharToGlyphFormat4(const uint8_t *aBuf, char16_t aCh)
518 {
519 const Format4Cmap *cmap4 = reinterpret_cast<const Format4Cmap*>(aBuf);
520 uint16_t segCount;
521 const AutoSwap_PRUint16 *endCodes;
522 const AutoSwap_PRUint16 *startCodes;
523 const AutoSwap_PRUint16 *idDelta;
524 const AutoSwap_PRUint16 *idRangeOffset;
525 uint16_t probe;
526 uint16_t rangeShiftOver2;
527 uint16_t index;
528
529 segCount = (uint16_t)(cmap4->segCountX2) / 2;
530
531 endCodes = &cmap4->arrays[0];
532 startCodes = &cmap4->arrays[segCount + 1]; // +1 for reserved word between arrays
533 idDelta = &startCodes[segCount];
534 idRangeOffset = &idDelta[segCount];
535
536 probe = 1 << (uint16_t)(cmap4->entrySelector);
537 rangeShiftOver2 = (uint16_t)(cmap4->rangeShift) / 2;
538
539 if ((uint16_t)(startCodes[rangeShiftOver2]) <= aCh) {
540 index = rangeShiftOver2;
541 } else {
542 index = 0;
543 }
544
545 while (probe > 1) {
546 probe >>= 1;
547 if ((uint16_t)(startCodes[index + probe]) <= aCh) {
548 index += probe;
549 }
550 }
551
552 if (aCh >= (uint16_t)(startCodes[index]) && aCh <= (uint16_t)(endCodes[index])) {
553 uint16_t result;
554 if ((uint16_t)(idRangeOffset[index]) == 0) {
555 result = aCh;
556 } else {
557 uint16_t offset = aCh - (uint16_t)(startCodes[index]);
558 const AutoSwap_PRUint16 *glyphIndexTable =
559 (const AutoSwap_PRUint16*)((const char*)&idRangeOffset[index] +
560 (uint16_t)(idRangeOffset[index]));
561 result = glyphIndexTable[offset];
562 }
563
564 // note that this is unsigned 16-bit arithmetic, and may wrap around
565 result += (uint16_t)(idDelta[index]);
566 return result;
567 }
568
569 return 0;
570 }
571
572 uint32_t
573 gfxFontUtils::MapCharToGlyphFormat12(const uint8_t *aBuf, uint32_t aCh)
574 {
575 const Format12CmapHeader *cmap12 =
576 reinterpret_cast<const Format12CmapHeader*>(aBuf);
577
578 // We know that numGroups is within range for the subtable size
579 // because it was checked by ReadCMAPTableFormat12.
580 uint32_t numGroups = cmap12->numGroups;
581
582 // The array of groups immediately follows the subtable header.
583 const Format12Group *groups =
584 reinterpret_cast<const Format12Group*>(aBuf + sizeof(Format12CmapHeader));
585
586 // For most efficient binary search, we want to work on a range that
587 // is a power of 2 so that we can always halve it by shifting.
588 // So we find the largest power of 2 that is <= numGroups.
589 // We will offset this range by rangeOffset so as to reach the end
590 // of the table, provided that doesn't put us beyond the target
591 // value from the outset.
592 uint32_t powerOf2 = mozilla::FindHighestBit(numGroups);
593 uint32_t rangeOffset = numGroups - powerOf2;
594 uint32_t range = 0;
595 uint32_t startCharCode;
596
597 if (groups[rangeOffset].startCharCode <= aCh) {
598 range = rangeOffset;
599 }
600
601 // Repeatedly halve the size of the range until we find the target group
602 while (powerOf2 > 1) {
603 powerOf2 >>= 1;
604 if (groups[range + powerOf2].startCharCode <= aCh) {
605 range += powerOf2;
606 }
607 }
608
609 // Check if the character is actually present in the range and return
610 // the corresponding glyph ID
611 startCharCode = groups[range].startCharCode;
612 if (startCharCode <= aCh && groups[range].endCharCode >= aCh) {
613 return groups[range].startGlyphId + aCh - startCharCode;
614 }
615
616 // Else it's not present, so return the .notdef glyph
617 return 0;
618 }
619
620 uint16_t
621 gfxFontUtils::MapUVSToGlyphFormat14(const uint8_t *aBuf, uint32_t aCh, uint32_t aVS)
622 {
623 const Format14Cmap *cmap14 = reinterpret_cast<const Format14Cmap*>(aBuf);
624
625 // binary search in varSelectorRecords
626 uint32_t min = 0;
627 uint32_t max = cmap14->numVarSelectorRecords;
628 uint32_t nonDefUVSOffset = 0;
629 while (min < max) {
630 uint32_t index = (min + max) >> 1;
631 uint32_t varSelector = cmap14->varSelectorRecords[index].varSelector;
632 if (aVS == varSelector) {
633 nonDefUVSOffset = cmap14->varSelectorRecords[index].nonDefaultUVSOffset;
634 break;
635 }
636 if (aVS < varSelector) {
637 max = index;
638 } else {
639 min = index + 1;
640 }
641 }
642 if (!nonDefUVSOffset) {
643 return 0;
644 }
645
646 const NonDefUVSTable *table = reinterpret_cast<const NonDefUVSTable*>
647 (aBuf + nonDefUVSOffset);
648
649 // binary search in uvsMappings
650 min = 0;
651 max = table->numUVSMappings;
652 while (min < max) {
653 uint32_t index = (min + max) >> 1;
654 uint32_t unicodeValue = table->uvsMappings[index].unicodeValue;
655 if (aCh == unicodeValue) {
656 return table->uvsMappings[index].glyphID;
657 }
658 if (aCh < unicodeValue) {
659 max = index;
660 } else {
661 min = index + 1;
662 }
663 }
664
665 return 0;
666 }
667
668 uint32_t
669 gfxFontUtils::MapCharToGlyph(const uint8_t *aCmapBuf, uint32_t aBufLength,
670 uint32_t aUnicode, uint32_t aVarSelector)
671 {
672 uint32_t offset, uvsOffset;
673 bool symbol;
674 uint32_t format = FindPreferredSubtable(aCmapBuf, aBufLength, &offset,
675 &uvsOffset, &symbol);
676
677 uint32_t gid;
678 switch (format) {
679 case 4:
680 gid = aUnicode < UNICODE_BMP_LIMIT ?
681 MapCharToGlyphFormat4(aCmapBuf + offset, char16_t(aUnicode)) : 0;
682 break;
683 case 12:
684 gid = MapCharToGlyphFormat12(aCmapBuf + offset, aUnicode);
685 break;
686 default:
687 NS_WARNING("unsupported cmap format, glyphs will be missing");
688 gid = 0;
689 }
690
691 if (aVarSelector && uvsOffset && gid) {
692 uint32_t varGID =
693 gfxFontUtils::MapUVSToGlyphFormat14(aCmapBuf + uvsOffset,
694 aUnicode, aVarSelector);
695 if (!varGID) {
696 aUnicode = gfxFontUtils::GetUVSFallback(aUnicode, aVarSelector);
697 if (aUnicode) {
698 switch (format) {
699 case 4:
700 if (aUnicode < UNICODE_BMP_LIMIT) {
701 varGID = MapCharToGlyphFormat4(aCmapBuf + offset,
702 char16_t(aUnicode));
703 }
704 break;
705 case 12:
706 varGID = MapCharToGlyphFormat12(aCmapBuf + offset,
707 aUnicode);
708 break;
709 }
710 }
711 }
712 if (varGID) {
713 gid = varGID;
714 }
715
716 // else the variation sequence was not supported, use default mapping
717 // of the character code alone
718 }
719
720 return gid;
721 }
722
723 void gfxFontUtils::GetPrefsFontList(const char *aPrefName, nsTArray<nsString>& aFontList)
724 {
725 const char16_t kComma = char16_t(',');
726
727 aFontList.Clear();
728
729 // get the list of single-face font families
730 nsAdoptingString fontlistValue = Preferences::GetString(aPrefName);
731 if (!fontlistValue) {
732 return;
733 }
734
735 // append each font name to the list
736 nsAutoString fontname;
737 const char16_t *p, *p_end;
738 fontlistValue.BeginReading(p);
739 fontlistValue.EndReading(p_end);
740
741 while (p < p_end) {
742 const char16_t *nameStart = p;
743 while (++p != p_end && *p != kComma)
744 /* nothing */ ;
745
746 // pull out a single name and clean out leading/trailing whitespace
747 fontname = Substring(nameStart, p);
748 fontname.CompressWhitespace(true, true);
749
750 // append it to the list
751 aFontList.AppendElement(fontname);
752 ++p;
753 }
754
755 }
756
757 // produce a unique font name that is (1) a valid Postscript name and (2) less
758 // than 31 characters in length. Using AddFontMemResourceEx on Windows fails
759 // for names longer than 30 characters in length.
760
761 #define MAX_B64_LEN 32
762
763 nsresult gfxFontUtils::MakeUniqueUserFontName(nsAString& aName)
764 {
765 nsCOMPtr<nsIUUIDGenerator> uuidgen =
766 do_GetService("@mozilla.org/uuid-generator;1");
767 NS_ENSURE_TRUE(uuidgen, NS_ERROR_OUT_OF_MEMORY);
768
769 nsID guid;
770
771 NS_ASSERTION(sizeof(guid) * 2 <= MAX_B64_LEN, "size of nsID has changed!");
772
773 nsresult rv = uuidgen->GenerateUUIDInPlace(&guid);
774 NS_ENSURE_SUCCESS(rv, rv);
775
776 char guidB64[MAX_B64_LEN] = {0};
777
778 if (!PL_Base64Encode(reinterpret_cast<char*>(&guid), sizeof(guid), guidB64))
779 return NS_ERROR_FAILURE;
780
781 // all b64 characters except for '/' are allowed in Postscript names, so convert / ==> -
782 char *p;
783 for (p = guidB64; *p; p++) {
784 if (*p == '/')
785 *p = '-';
786 }
787
788 aName.Assign(NS_LITERAL_STRING("uf"));
789 aName.AppendASCII(guidB64);
790 return NS_OK;
791 }
792
793
794 // TrueType/OpenType table handling code
795
796 // need byte aligned structs
797 #pragma pack(1)
798
799 // name table stores set of name record structures, followed by
800 // large block containing all the strings. name record offset and length
801 // indicates the offset and length within that block.
802 // http://www.microsoft.com/typography/otspec/name.htm
803 struct NameRecordData {
804 uint32_t offset;
805 uint32_t length;
806 };
807
808 #pragma pack()
809
810 static bool
811 IsValidSFNTVersion(uint32_t version)
812 {
813 // normally 0x00010000, CFF-style OT fonts == 'OTTO' and Apple TT fonts = 'true'
814 // 'typ1' is also possible for old Type 1 fonts in a SFNT container but not supported
815 return version == 0x10000 ||
816 version == TRUETYPE_TAG('O','T','T','O') ||
817 version == TRUETYPE_TAG('t','r','u','e');
818 }
819
820 // copy and swap UTF-16 values, assume no surrogate pairs, can be in place
821 static void
822 CopySwapUTF16(const uint16_t *aInBuf, uint16_t *aOutBuf, uint32_t aLen)
823 {
824 const uint16_t *end = aInBuf + aLen;
825 while (aInBuf < end) {
826 uint16_t value = *aInBuf;
827 *aOutBuf = (value >> 8) | (value & 0xff) << 8;
828 aOutBuf++;
829 aInBuf++;
830 }
831 }
832
833 gfxUserFontType
834 gfxFontUtils::DetermineFontDataType(const uint8_t *aFontData, uint32_t aFontDataLength)
835 {
836 // test for OpenType font data
837 // problem: EOT-Lite with 0x10000 length will look like TrueType!
838 if (aFontDataLength >= sizeof(SFNTHeader)) {
839 const SFNTHeader *sfntHeader = reinterpret_cast<const SFNTHeader*>(aFontData);
840 uint32_t sfntVersion = sfntHeader->sfntVersion;
841 if (IsValidSFNTVersion(sfntVersion)) {
842 return GFX_USERFONT_OPENTYPE;
843 }
844 }
845
846 // test for WOFF
847 if (aFontDataLength >= sizeof(AutoSwap_PRUint32)) {
848 const AutoSwap_PRUint32 *version =
849 reinterpret_cast<const AutoSwap_PRUint32*>(aFontData);
850 if (uint32_t(*version) == TRUETYPE_TAG('w','O','F','F')) {
851 return GFX_USERFONT_WOFF;
852 }
853 }
854
855 // tests for other formats here
856
857 return GFX_USERFONT_UNKNOWN;
858 }
859
860 nsresult
861 gfxFontUtils::RenameFont(const nsAString& aName, const uint8_t *aFontData,
862 uint32_t aFontDataLength, FallibleTArray<uint8_t> *aNewFont)
863 {
864 NS_ASSERTION(aNewFont, "null font data array");
865
866 uint64_t dataLength(aFontDataLength);
867
868 // new name table
869 static const uint32_t neededNameIDs[] = {NAME_ID_FAMILY,
870 NAME_ID_STYLE,
871 NAME_ID_UNIQUE,
872 NAME_ID_FULL,
873 NAME_ID_POSTSCRIPT};
874
875 // calculate new name table size
876 uint16_t nameCount = ArrayLength(neededNameIDs);
877
878 // leave room for null-terminator
879 uint16_t nameStrLength = (aName.Length() + 1) * sizeof(char16_t);
880
881 // round name table size up to 4-byte multiple
882 uint32_t nameTableSize = (sizeof(NameHeader) +
883 sizeof(NameRecord) * nameCount +
884 nameStrLength +
885 3) & ~3;
886
887 if (dataLength + nameTableSize > UINT32_MAX)
888 return NS_ERROR_FAILURE;
889
890 // bug 505386 - need to handle unpadded font length
891 uint32_t paddedFontDataSize = (aFontDataLength + 3) & ~3;
892 uint32_t adjFontDataSize = paddedFontDataSize + nameTableSize;
893
894 // create new buffer: old font data plus new name table
895 if (!aNewFont->AppendElements(adjFontDataSize))
896 return NS_ERROR_OUT_OF_MEMORY;
897
898 // copy the old font data
899 uint8_t *newFontData = reinterpret_cast<uint8_t*>(aNewFont->Elements());
900
901 // null the last four bytes in case the font length is not a multiple of 4
902 memset(newFontData + aFontDataLength, 0, paddedFontDataSize - aFontDataLength);
903
904 // copy font data
905 memcpy(newFontData, aFontData, aFontDataLength);
906
907 // null out the last 4 bytes for checksum calculations
908 memset(newFontData + adjFontDataSize - 4, 0, 4);
909
910 NameHeader *nameHeader = reinterpret_cast<NameHeader*>(newFontData +
911 paddedFontDataSize);
912
913 // -- name header
914 nameHeader->format = 0;
915 nameHeader->count = nameCount;
916 nameHeader->stringOffset = sizeof(NameHeader) + nameCount * sizeof(NameRecord);
917
918 // -- name records
919 uint32_t i;
920 NameRecord *nameRecord = reinterpret_cast<NameRecord*>(nameHeader + 1);
921
922 for (i = 0; i < nameCount; i++, nameRecord++) {
923 nameRecord->platformID = PLATFORM_ID_MICROSOFT;
924 nameRecord->encodingID = ENCODING_ID_MICROSOFT_UNICODEBMP;
925 nameRecord->languageID = LANG_ID_MICROSOFT_EN_US;
926 nameRecord->nameID = neededNameIDs[i];
927 nameRecord->offset = 0;
928 nameRecord->length = nameStrLength;
929 }
930
931 // -- string data, located after the name records, stored in big-endian form
932 char16_t *strData = reinterpret_cast<char16_t*>(nameRecord);
933
934 mozilla::NativeEndian::copyAndSwapToBigEndian(strData,
935 aName.BeginReading(),
936 aName.Length());
937 strData[aName.Length()] = 0; // add null termination
938
939 // adjust name table header to point to the new name table
940 SFNTHeader *sfntHeader = reinterpret_cast<SFNTHeader*>(newFontData);
941
942 // table directory entries begin immediately following SFNT header
943 TableDirEntry *dirEntry =
944 reinterpret_cast<TableDirEntry*>(newFontData + sizeof(SFNTHeader));
945
946 uint32_t numTables = sfntHeader->numTables;
947
948 for (i = 0; i < numTables; i++, dirEntry++) {
949 if (dirEntry->tag == TRUETYPE_TAG('n','a','m','e')) {
950 break;
951 }
952 }
953
954 // function only called if font validates, so this should always be true
955 NS_ASSERTION(i < numTables, "attempt to rename font with no name table");
956
957 // note: dirEntry now points to name record
958
959 // recalculate name table checksum
960 uint32_t checkSum = 0;
961 AutoSwap_PRUint32 *nameData = reinterpret_cast<AutoSwap_PRUint32*> (nameHeader);
962 AutoSwap_PRUint32 *nameDataEnd = nameData + (nameTableSize >> 2);
963
964 while (nameData < nameDataEnd)
965 checkSum = checkSum + *nameData++;
966
967 // adjust name table entry to point to new name table
968 dirEntry->offset = paddedFontDataSize;
969 dirEntry->length = nameTableSize;
970 dirEntry->checkSum = checkSum;
971
972 // fix up checksums
973 uint32_t checksum = 0;
974
975 // checksum for font = (checksum of header) + (checksum of tables)
976 uint32_t headerLen = sizeof(SFNTHeader) + sizeof(TableDirEntry) * numTables;
977 const AutoSwap_PRUint32 *headerData =
978 reinterpret_cast<const AutoSwap_PRUint32*>(newFontData);
979
980 // header length is in bytes, checksum calculated in longwords
981 for (i = 0; i < (headerLen >> 2); i++, headerData++) {
982 checksum += *headerData;
983 }
984
985 uint32_t headOffset = 0;
986 dirEntry = reinterpret_cast<TableDirEntry*>(newFontData + sizeof(SFNTHeader));
987
988 for (i = 0; i < numTables; i++, dirEntry++) {
989 if (dirEntry->tag == TRUETYPE_TAG('h','e','a','d')) {
990 headOffset = dirEntry->offset;
991 }
992 checksum += dirEntry->checkSum;
993 }
994
995 NS_ASSERTION(headOffset != 0, "no head table for font");
996
997 HeadTable *headData = reinterpret_cast<HeadTable*>(newFontData + headOffset);
998
999 headData->checkSumAdjustment = HeadTable::HEAD_CHECKSUM_CALC_CONST - checksum;
1000
1001 return NS_OK;
1002 }
1003
1004 // This is only called after the basic validity of the downloaded sfnt
1005 // data has been checked, so it should never fail to find the name table
1006 // (though it might fail to read it, if memory isn't available);
1007 // other checks here are just for extra paranoia.
1008 nsresult
1009 gfxFontUtils::GetFullNameFromSFNT(const uint8_t* aFontData, uint32_t aLength,
1010 nsAString& aFullName)
1011 {
1012 aFullName.AssignLiteral("(MISSING NAME)"); // should always get replaced
1013
1014 NS_ENSURE_TRUE(aLength >= sizeof(SFNTHeader), NS_ERROR_UNEXPECTED);
1015 const SFNTHeader *sfntHeader =
1016 reinterpret_cast<const SFNTHeader*>(aFontData);
1017 const TableDirEntry *dirEntry =
1018 reinterpret_cast<const TableDirEntry*>(aFontData + sizeof(SFNTHeader));
1019 uint32_t numTables = sfntHeader->numTables;
1020 NS_ENSURE_TRUE(aLength >=
1021 sizeof(SFNTHeader) + numTables * sizeof(TableDirEntry),
1022 NS_ERROR_UNEXPECTED);
1023 bool foundName = false;
1024 for (uint32_t i = 0; i < numTables; i++, dirEntry++) {
1025 if (dirEntry->tag == TRUETYPE_TAG('n','a','m','e')) {
1026 foundName = true;
1027 break;
1028 }
1029 }
1030
1031 // should never fail, as we're only called after font validation succeeded
1032 NS_ENSURE_TRUE(foundName, NS_ERROR_NOT_AVAILABLE);
1033
1034 uint32_t len = dirEntry->length;
1035 NS_ENSURE_TRUE(aLength > len && aLength - len >= dirEntry->offset,
1036 NS_ERROR_UNEXPECTED);
1037
1038 hb_blob_t *nameBlob =
1039 hb_blob_create((const char*)aFontData + dirEntry->offset, len,
1040 HB_MEMORY_MODE_READONLY, nullptr, nullptr);
1041 nsresult rv = GetFullNameFromTable(nameBlob, aFullName);
1042 hb_blob_destroy(nameBlob);
1043
1044 return rv;
1045 }
1046
1047 nsresult
1048 gfxFontUtils::GetFullNameFromTable(hb_blob_t *aNameTable,
1049 nsAString& aFullName)
1050 {
1051 nsAutoString name;
1052 nsresult rv =
1053 gfxFontUtils::ReadCanonicalName(aNameTable,
1054 gfxFontUtils::NAME_ID_FULL,
1055 name);
1056 if (NS_SUCCEEDED(rv) && !name.IsEmpty()) {
1057 aFullName = name;
1058 return NS_OK;
1059 }
1060 rv = gfxFontUtils::ReadCanonicalName(aNameTable,
1061 gfxFontUtils::NAME_ID_FAMILY,
1062 name);
1063 if (NS_SUCCEEDED(rv) && !name.IsEmpty()) {
1064 nsAutoString styleName;
1065 rv = gfxFontUtils::ReadCanonicalName(aNameTable,
1066 gfxFontUtils::NAME_ID_STYLE,
1067 styleName);
1068 if (NS_SUCCEEDED(rv) && !styleName.IsEmpty()) {
1069 name.AppendLiteral(" ");
1070 name.Append(styleName);
1071 aFullName = name;
1072 }
1073 return NS_OK;
1074 }
1075
1076 return NS_ERROR_NOT_AVAILABLE;
1077 }
1078
1079 nsresult
1080 gfxFontUtils::GetFamilyNameFromTable(hb_blob_t *aNameTable,
1081 nsAString& aFullName)
1082 {
1083 nsAutoString name;
1084 nsresult rv =
1085 gfxFontUtils::ReadCanonicalName(aNameTable,
1086 gfxFontUtils::NAME_ID_FAMILY,
1087 name);
1088 if (NS_SUCCEEDED(rv) && !name.IsEmpty()) {
1089 aFullName = name;
1090 return NS_OK;
1091 }
1092 return NS_ERROR_NOT_AVAILABLE;
1093 }
1094
1095 enum {
1096 #if defined(XP_MACOSX)
1097 CANONICAL_LANG_ID = gfxFontUtils::LANG_ID_MAC_ENGLISH,
1098 PLATFORM_ID = gfxFontUtils::PLATFORM_ID_MAC
1099 #else
1100 CANONICAL_LANG_ID = gfxFontUtils::LANG_ID_MICROSOFT_EN_US,
1101 PLATFORM_ID = gfxFontUtils::PLATFORM_ID_MICROSOFT
1102 #endif
1103 };
1104
1105 nsresult
1106 gfxFontUtils::ReadNames(const char *aNameData, uint32_t aDataLen,
1107 uint32_t aNameID, int32_t aPlatformID,
1108 nsTArray<nsString>& aNames)
1109 {
1110 return ReadNames(aNameData, aDataLen, aNameID, LANG_ALL,
1111 aPlatformID, aNames);
1112 }
1113
1114 nsresult
1115 gfxFontUtils::ReadCanonicalName(hb_blob_t *aNameTable, uint32_t aNameID,
1116 nsString& aName)
1117 {
1118 uint32_t nameTableLen;
1119 const char *nameTable = hb_blob_get_data(aNameTable, &nameTableLen);
1120 return ReadCanonicalName(nameTable, nameTableLen, aNameID, aName);
1121 }
1122
1123 nsresult
1124 gfxFontUtils::ReadCanonicalName(const char *aNameData, uint32_t aDataLen,
1125 uint32_t aNameID, nsString& aName)
1126 {
1127 nsresult rv;
1128
1129 nsTArray<nsString> names;
1130
1131 // first, look for the English name (this will succeed 99% of the time)
1132 rv = ReadNames(aNameData, aDataLen, aNameID, CANONICAL_LANG_ID,
1133 PLATFORM_ID, names);
1134 NS_ENSURE_SUCCESS(rv, rv);
1135
1136 // otherwise, grab names for all languages
1137 if (names.Length() == 0) {
1138 rv = ReadNames(aNameData, aDataLen, aNameID, LANG_ALL,
1139 PLATFORM_ID, names);
1140 NS_ENSURE_SUCCESS(rv, rv);
1141 }
1142
1143 #if defined(XP_MACOSX)
1144 // may be dealing with font that only has Microsoft name entries
1145 if (names.Length() == 0) {
1146 rv = ReadNames(aNameData, aDataLen, aNameID, LANG_ID_MICROSOFT_EN_US,
1147 PLATFORM_ID_MICROSOFT, names);
1148 NS_ENSURE_SUCCESS(rv, rv);
1149
1150 // getting really desperate now, take anything!
1151 if (names.Length() == 0) {
1152 rv = ReadNames(aNameData, aDataLen, aNameID, LANG_ALL,
1153 PLATFORM_ID_MICROSOFT, names);
1154 NS_ENSURE_SUCCESS(rv, rv);
1155 }
1156 }
1157 #endif
1158
1159 // return the first name (99.9% of the time names will
1160 // contain a single English name)
1161 if (names.Length()) {
1162 aName.Assign(names[0]);
1163 return NS_OK;
1164 }
1165
1166 return NS_ERROR_FAILURE;
1167 }
1168
1169 // Charsets to use for decoding Mac platform font names.
1170 // This table is sorted by {encoding, language}, with the wildcard "ANY" being
1171 // greater than any defined values for each field; we use a binary search on both
1172 // fields, and fall back to matching only encoding if necessary
1173
1174 // Some "redundant" entries for specific combinations are included such as
1175 // encoding=roman, lang=english, in order that common entries will be found
1176 // on the first search.
1177
1178 #define ANY 0xffff
1179 const gfxFontUtils::MacFontNameCharsetMapping gfxFontUtils::gMacFontNameCharsets[] =
1180 {
1181 { ENCODING_ID_MAC_ROMAN, LANG_ID_MAC_ENGLISH, "macintosh" },
1182 { ENCODING_ID_MAC_ROMAN, LANG_ID_MAC_ICELANDIC, "x-mac-icelandic" },
1183 { ENCODING_ID_MAC_ROMAN, LANG_ID_MAC_TURKISH, "x-mac-turkish" },
1184 { ENCODING_ID_MAC_ROMAN, LANG_ID_MAC_POLISH, "x-mac-ce" },
1185 { ENCODING_ID_MAC_ROMAN, LANG_ID_MAC_ROMANIAN, "x-mac-romanian" },
1186 { ENCODING_ID_MAC_ROMAN, LANG_ID_MAC_CZECH, "x-mac-ce" },
1187 { ENCODING_ID_MAC_ROMAN, LANG_ID_MAC_SLOVAK, "x-mac-ce" },
1188 { ENCODING_ID_MAC_ROMAN, ANY, "macintosh" },
1189 { ENCODING_ID_MAC_JAPANESE, LANG_ID_MAC_JAPANESE, "Shift_JIS" },
1190 { ENCODING_ID_MAC_JAPANESE, ANY, "Shift_JIS" },
1191 { ENCODING_ID_MAC_TRAD_CHINESE, LANG_ID_MAC_TRAD_CHINESE, "Big5" },
1192 { ENCODING_ID_MAC_TRAD_CHINESE, ANY, "Big5" },
1193 { ENCODING_ID_MAC_KOREAN, LANG_ID_MAC_KOREAN, "EUC-KR" },
1194 { ENCODING_ID_MAC_KOREAN, ANY, "EUC-KR" },
1195 { ENCODING_ID_MAC_ARABIC, LANG_ID_MAC_ARABIC, "x-mac-arabic" },
1196 { ENCODING_ID_MAC_ARABIC, LANG_ID_MAC_URDU, "x-mac-farsi" },
1197 { ENCODING_ID_MAC_ARABIC, LANG_ID_MAC_FARSI, "x-mac-farsi" },
1198 { ENCODING_ID_MAC_ARABIC, ANY, "x-mac-arabic" },
1199 { ENCODING_ID_MAC_HEBREW, LANG_ID_MAC_HEBREW, "x-mac-hebrew" },
1200 { ENCODING_ID_MAC_HEBREW, ANY, "x-mac-hebrew" },
1201 { ENCODING_ID_MAC_GREEK, ANY, "x-mac-greek" },
1202 { ENCODING_ID_MAC_CYRILLIC, ANY, "x-mac-cyrillic" },
1203 { ENCODING_ID_MAC_DEVANAGARI, ANY, "x-mac-devanagari"},
1204 { ENCODING_ID_MAC_GURMUKHI, ANY, "x-mac-gurmukhi" },
1205 { ENCODING_ID_MAC_GUJARATI, ANY, "x-mac-gujarati" },
1206 { ENCODING_ID_MAC_SIMP_CHINESE, LANG_ID_MAC_SIMP_CHINESE, "GB2312" },
1207 { ENCODING_ID_MAC_SIMP_CHINESE, ANY, "GB2312" }
1208 };
1209
1210 const char* gfxFontUtils::gISOFontNameCharsets[] =
1211 {
1212 /* 0 */ "us-ascii" ,
1213 /* 1 */ nullptr , /* spec says "ISO 10646" but does not specify encoding form! */
1214 /* 2 */ "ISO-8859-1"
1215 };
1216
1217 const char* gfxFontUtils::gMSFontNameCharsets[] =
1218 {
1219 /* [0] ENCODING_ID_MICROSOFT_SYMBOL */ "" ,
1220 /* [1] ENCODING_ID_MICROSOFT_UNICODEBMP */ "" ,
1221 /* [2] ENCODING_ID_MICROSOFT_SHIFTJIS */ "Shift_JIS" ,
1222 /* [3] ENCODING_ID_MICROSOFT_PRC */ nullptr ,
1223 /* [4] ENCODING_ID_MICROSOFT_BIG5 */ "Big5" ,
1224 /* [5] ENCODING_ID_MICROSOFT_WANSUNG */ nullptr ,
1225 /* [6] ENCODING_ID_MICROSOFT_JOHAB */ "x-johab" ,
1226 /* [7] reserved */ nullptr ,
1227 /* [8] reserved */ nullptr ,
1228 /* [9] reserved */ nullptr ,
1229 /*[10] ENCODING_ID_MICROSOFT_UNICODEFULL */ ""
1230 };
1231
1232 // Return the name of the charset we should use to decode a font name
1233 // given the name table attributes.
1234 // Special return values:
1235 // "" charset is UTF16BE, no need for a converter
1236 // nullptr unknown charset, do not attempt conversion
1237 const char*
1238 gfxFontUtils::GetCharsetForFontName(uint16_t aPlatform, uint16_t aScript, uint16_t aLanguage)
1239 {
1240 switch (aPlatform)
1241 {
1242 case PLATFORM_ID_UNICODE:
1243 return "";
1244
1245 case PLATFORM_ID_MAC:
1246 {
1247 uint32_t lo = 0, hi = ArrayLength(gMacFontNameCharsets);
1248 MacFontNameCharsetMapping searchValue = { aScript, aLanguage, nullptr };
1249 for (uint32_t i = 0; i < 2; ++i) {
1250 // binary search; if not found, set language to ANY and try again
1251 while (lo < hi) {
1252 uint32_t mid = (lo + hi) / 2;
1253 const MacFontNameCharsetMapping& entry = gMacFontNameCharsets[mid];
1254 if (entry < searchValue) {
1255 lo = mid + 1;
1256 continue;
1257 }
1258 if (searchValue < entry) {
1259 hi = mid;
1260 continue;
1261 }
1262 // found a match
1263 return entry.mCharsetName;
1264 }
1265
1266 // no match, so reset high bound for search and re-try
1267 hi = ArrayLength(gMacFontNameCharsets);
1268 searchValue.mLanguage = ANY;
1269 }
1270 }
1271 break;
1272
1273 case PLATFORM_ID_ISO:
1274 if (aScript < ArrayLength(gISOFontNameCharsets)) {
1275 return gISOFontNameCharsets[aScript];
1276 }
1277 break;
1278
1279 case PLATFORM_ID_MICROSOFT:
1280 if (aScript < ArrayLength(gMSFontNameCharsets)) {
1281 return gMSFontNameCharsets[aScript];
1282 }
1283 break;
1284 }
1285
1286 return nullptr;
1287 }
1288
1289 // convert a raw name from the name table to an nsString, if possible;
1290 // return value indicates whether conversion succeeded
1291 bool
1292 gfxFontUtils::DecodeFontName(const char *aNameData, int32_t aByteLen,
1293 uint32_t aPlatformCode, uint32_t aScriptCode,
1294 uint32_t aLangCode, nsAString& aName)
1295 {
1296 if (aByteLen <= 0) {
1297 NS_WARNING("empty font name");
1298 aName.SetLength(0);
1299 return true;
1300 }
1301
1302 const char *csName = GetCharsetForFontName(aPlatformCode, aScriptCode, aLangCode);
1303
1304 if (!csName) {
1305 // nullptr -> unknown charset
1306 #ifdef DEBUG
1307 char warnBuf[128];
1308 if (aByteLen > 64)
1309 aByteLen = 64;
1310 sprintf(warnBuf, "skipping font name, unknown charset %d:%d:%d for <%.*s>",
1311 aPlatformCode, aScriptCode, aLangCode, aByteLen, aNameData);
1312 NS_WARNING(warnBuf);
1313 #endif
1314 return false;
1315 }
1316
1317 if (csName[0] == 0) {
1318 // empty charset name: data is utf16be, no need to instantiate a converter
1319 uint32_t strLen = aByteLen / 2;
1320 #ifdef IS_LITTLE_ENDIAN
1321 aName.SetLength(strLen);
1322 CopySwapUTF16(reinterpret_cast<const uint16_t*>(aNameData),
1323 reinterpret_cast<uint16_t*>(aName.BeginWriting()), strLen);
1324 #else
1325 aName.Assign(reinterpret_cast<const char16_t*>(aNameData), strLen);
1326 #endif
1327 return true;
1328 }
1329
1330 nsCOMPtr<nsIUnicodeDecoder> decoder =
1331 mozilla::dom::EncodingUtils::DecoderForEncoding(csName);
1332 if (!decoder) {
1333 NS_WARNING("failed to get the decoder for a font name string");
1334 return false;
1335 }
1336
1337 int32_t destLength;
1338 nsresult rv = decoder->GetMaxLength(aNameData, aByteLen, &destLength);
1339 if (NS_FAILED(rv)) {
1340 NS_WARNING("decoder->GetMaxLength failed, invalid font name?");
1341 return false;
1342 }
1343
1344 // make space for the converted string
1345 aName.SetLength(destLength);
1346 rv = decoder->Convert(aNameData, &aByteLen,
1347 aName.BeginWriting(), &destLength);
1348 if (NS_FAILED(rv)) {
1349 NS_WARNING("decoder->Convert failed, invalid font name?");
1350 return false;
1351 }
1352 aName.Truncate(destLength); // set the actual length
1353
1354 return true;
1355 }
1356
1357 nsresult
1358 gfxFontUtils::ReadNames(const char *aNameData, uint32_t aDataLen,
1359 uint32_t aNameID,
1360 int32_t aLangID, int32_t aPlatformID,
1361 nsTArray<nsString>& aNames)
1362 {
1363 NS_ASSERTION(aDataLen != 0, "null name table");
1364
1365 if (!aDataLen) {
1366 return NS_ERROR_FAILURE;
1367 }
1368
1369 // -- name table data
1370 const NameHeader *nameHeader = reinterpret_cast<const NameHeader*>(aNameData);
1371
1372 uint32_t nameCount = nameHeader->count;
1373
1374 // -- sanity check the number of name records
1375 if (uint64_t(nameCount) * sizeof(NameRecord) > aDataLen) {
1376 NS_WARNING("invalid font (name table data)");
1377 return NS_ERROR_FAILURE;
1378 }
1379
1380 // -- iterate through name records
1381 const NameRecord *nameRecord
1382 = reinterpret_cast<const NameRecord*>(aNameData + sizeof(NameHeader));
1383 uint64_t nameStringsBase = uint64_t(nameHeader->stringOffset);
1384
1385 uint32_t i;
1386 for (i = 0; i < nameCount; i++, nameRecord++) {
1387 uint32_t platformID;
1388
1389 // skip over unwanted nameID's
1390 if (uint32_t(nameRecord->nameID) != aNameID)
1391 continue;
1392
1393 // skip over unwanted platform data
1394 platformID = nameRecord->platformID;
1395 if (aPlatformID != PLATFORM_ALL
1396 && uint32_t(nameRecord->platformID) != PLATFORM_ID)
1397 continue;
1398
1399 // skip over unwanted languages
1400 if (aLangID != LANG_ALL
1401 && uint32_t(nameRecord->languageID) != uint32_t(aLangID))
1402 continue;
1403
1404 // add name to names array
1405
1406 // -- calculate string location
1407 uint32_t namelen = nameRecord->length;
1408 uint32_t nameoff = nameRecord->offset; // offset from base of string storage
1409
1410 if (nameStringsBase + uint64_t(nameoff) + uint64_t(namelen)
1411 > aDataLen) {
1412 NS_WARNING("invalid font (name table strings)");
1413 return NS_ERROR_FAILURE;
1414 }
1415
1416 // -- decode if necessary and make nsString
1417 nsAutoString name;
1418
1419 DecodeFontName(aNameData + nameStringsBase + nameoff, namelen,
1420 platformID, uint32_t(nameRecord->encodingID),
1421 uint32_t(nameRecord->languageID), name);
1422
1423 uint32_t k, numNames;
1424 bool foundName = false;
1425
1426 numNames = aNames.Length();
1427 for (k = 0; k < numNames; k++) {
1428 if (name.Equals(aNames[k])) {
1429 foundName = true;
1430 break;
1431 }
1432 }
1433
1434 if (!foundName)
1435 aNames.AppendElement(name);
1436
1437 }
1438
1439 return NS_OK;
1440 }
1441
1442 #ifdef XP_WIN
1443
1444 /* static */
1445 bool
1446 gfxFontUtils::IsCffFont(const uint8_t* aFontData)
1447 {
1448 // this is only called after aFontData has passed basic validation,
1449 // so we know there is enough data present to allow us to read the version!
1450 const SFNTHeader *sfntHeader = reinterpret_cast<const SFNTHeader*>(aFontData);
1451 return (sfntHeader->sfntVersion == TRUETYPE_TAG('O','T','T','O'));
1452 }
1453
1454 #endif
1455

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial