summaryrefslogtreecommitdiffstats
path: root/gfx/thebes/gfxFontUtils.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/thebes/gfxFontUtils.cpp')
-rw-r--r--gfx/thebes/gfxFontUtils.cpp1809
1 files changed, 1809 insertions, 0 deletions
diff --git a/gfx/thebes/gfxFontUtils.cpp b/gfx/thebes/gfxFontUtils.cpp
new file mode 100644
index 000000000..cb505e87b
--- /dev/null
+++ b/gfx/thebes/gfxFontUtils.cpp
@@ -0,0 +1,1809 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/BinarySearch.h"
+
+#include "gfxFontUtils.h"
+
+#include "nsServiceManagerUtils.h"
+
+#include "mozilla/dom/EncodingUtils.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/Services.h"
+#include "mozilla/BinarySearch.h"
+#include "mozilla/Sprintf.h"
+
+#include "nsCOMPtr.h"
+#include "nsIUUIDGenerator.h"
+#include "nsIUnicodeDecoder.h"
+
+#include "harfbuzz/hb.h"
+
+#include "plbase64.h"
+#include "mozilla/Logging.h"
+
+#define LOG(log, args) MOZ_LOG(gfxPlatform::GetLog(log), \
+ LogLevel::Debug, args)
+
+#define UNICODE_BMP_LIMIT 0x10000
+
+using namespace mozilla;
+
+#pragma pack(1)
+
+typedef struct {
+ AutoSwap_PRUint16 format;
+ AutoSwap_PRUint16 reserved;
+ AutoSwap_PRUint32 length;
+ AutoSwap_PRUint32 language;
+ AutoSwap_PRUint32 startCharCode;
+ AutoSwap_PRUint32 numChars;
+} Format10CmapHeader;
+
+typedef struct {
+ AutoSwap_PRUint16 format;
+ AutoSwap_PRUint16 reserved;
+ AutoSwap_PRUint32 length;
+ AutoSwap_PRUint32 language;
+ AutoSwap_PRUint32 numGroups;
+} Format12CmapHeader;
+
+typedef struct {
+ AutoSwap_PRUint32 startCharCode;
+ AutoSwap_PRUint32 endCharCode;
+ AutoSwap_PRUint32 startGlyphId;
+} Format12Group;
+
+#pragma pack()
+
+void
+gfxSparseBitSet::Dump(const char* aPrefix, eGfxLog aWhichLog) const
+{
+ NS_ASSERTION(mBlocks.DebugGetHeader(), "mHdr is null, this is bad");
+ uint32_t b, numBlocks = mBlocks.Length();
+
+ for (b = 0; b < numBlocks; b++) {
+ Block *block = mBlocks[b].get();
+ if (!block) {
+ continue;
+ }
+ const int BUFSIZE = 256;
+ char outStr[BUFSIZE];
+ int index = 0;
+ index += snprintf(&outStr[index], BUFSIZE - index, "%s u+%6.6x [", aPrefix, (b << BLOCK_INDEX_SHIFT));
+ for (int i = 0; i < 32; i += 4) {
+ for (int j = i; j < i + 4; j++) {
+ uint8_t bits = block->mBits[j];
+ uint8_t flip1 = ((bits & 0xaa) >> 1) | ((bits & 0x55) << 1);
+ uint8_t flip2 = ((flip1 & 0xcc) >> 2) | ((flip1 & 0x33) << 2);
+ uint8_t flipped = ((flip2 & 0xf0) >> 4) | ((flip2 & 0x0f) << 4);
+
+ index += snprintf(&outStr[index], BUFSIZE - index, "%2.2x", flipped);
+ }
+ if (i + 4 != 32) index += snprintf(&outStr[index], BUFSIZE - index, " ");
+ }
+ index += snprintf(&outStr[index], BUFSIZE - index, "]");
+ LOG(aWhichLog, ("%s", outStr));
+ }
+}
+
+nsresult
+gfxFontUtils::ReadCMAPTableFormat10(const uint8_t *aBuf, uint32_t aLength,
+ gfxSparseBitSet& aCharacterMap)
+{
+ // Ensure table is large enough that we can safely read the header
+ NS_ENSURE_TRUE(aLength >= sizeof(Format10CmapHeader),
+ NS_ERROR_GFX_CMAP_MALFORMED);
+
+ // Sanity-check header fields
+ const Format10CmapHeader *cmap10 =
+ reinterpret_cast<const Format10CmapHeader*>(aBuf);
+ NS_ENSURE_TRUE(uint16_t(cmap10->format) == 10,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+ NS_ENSURE_TRUE(uint16_t(cmap10->reserved) == 0,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+
+ uint32_t tablelen = cmap10->length;
+ NS_ENSURE_TRUE(tablelen >= sizeof(Format10CmapHeader) &&
+ tablelen <= aLength, NS_ERROR_GFX_CMAP_MALFORMED);
+
+ NS_ENSURE_TRUE(cmap10->language == 0, NS_ERROR_GFX_CMAP_MALFORMED);
+
+ uint32_t numChars = cmap10->numChars;
+ NS_ENSURE_TRUE(tablelen == sizeof(Format10CmapHeader) +
+ numChars * sizeof(uint16_t), NS_ERROR_GFX_CMAP_MALFORMED);
+
+ uint32_t charCode = cmap10->startCharCode;
+ NS_ENSURE_TRUE(charCode <= CMAP_MAX_CODEPOINT &&
+ charCode + numChars <= CMAP_MAX_CODEPOINT,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+
+ // glyphs[] array immediately follows the subtable header
+ const AutoSwap_PRUint16 *glyphs =
+ reinterpret_cast<const AutoSwap_PRUint16 *>(cmap10 + 1);
+
+ for (uint32_t i = 0; i < numChars; ++i) {
+ if (uint16_t(*glyphs) != 0) {
+ aCharacterMap.set(charCode);
+ }
+ ++charCode;
+ ++glyphs;
+ }
+
+ aCharacterMap.Compact();
+
+ return NS_OK;
+}
+
+nsresult
+gfxFontUtils::ReadCMAPTableFormat12(const uint8_t *aBuf, uint32_t aLength,
+ gfxSparseBitSet& aCharacterMap)
+{
+ // Ensure table is large enough that we can safely read the header
+ NS_ENSURE_TRUE(aLength >= sizeof(Format12CmapHeader),
+ NS_ERROR_GFX_CMAP_MALFORMED);
+
+ // Sanity-check header fields
+ const Format12CmapHeader *cmap12 =
+ reinterpret_cast<const Format12CmapHeader*>(aBuf);
+ NS_ENSURE_TRUE(uint16_t(cmap12->format) == 12,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+ NS_ENSURE_TRUE(uint16_t(cmap12->reserved) == 0,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+
+ uint32_t tablelen = cmap12->length;
+ NS_ENSURE_TRUE(tablelen >= sizeof(Format12CmapHeader) &&
+ tablelen <= aLength, NS_ERROR_GFX_CMAP_MALFORMED);
+
+ NS_ENSURE_TRUE(cmap12->language == 0, NS_ERROR_GFX_CMAP_MALFORMED);
+
+ // Check that the table is large enough for the group array
+ const uint32_t numGroups = cmap12->numGroups;
+ NS_ENSURE_TRUE((tablelen - sizeof(Format12CmapHeader)) /
+ sizeof(Format12Group) >= numGroups,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+
+ // The array of groups immediately follows the subtable header.
+ const Format12Group *group =
+ reinterpret_cast<const Format12Group*>(aBuf + sizeof(Format12CmapHeader));
+
+ // Check that groups are in correct order and do not overlap,
+ // and record character coverage in aCharacterMap.
+ uint32_t prevEndCharCode = 0;
+ for (uint32_t i = 0; i < numGroups; i++, group++) {
+ uint32_t startCharCode = group->startCharCode;
+ const uint32_t endCharCode = group->endCharCode;
+ NS_ENSURE_TRUE((prevEndCharCode < startCharCode || i == 0) &&
+ startCharCode <= endCharCode &&
+ endCharCode <= CMAP_MAX_CODEPOINT,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+ // don't include a character that maps to glyph ID 0 (.notdef)
+ if (group->startGlyphId == 0) {
+ startCharCode++;
+ }
+ if (startCharCode <= endCharCode) {
+ aCharacterMap.SetRange(startCharCode, endCharCode);
+ }
+ prevEndCharCode = endCharCode;
+ }
+
+ aCharacterMap.Compact();
+
+ return NS_OK;
+}
+
+nsresult
+gfxFontUtils::ReadCMAPTableFormat4(const uint8_t *aBuf, uint32_t aLength,
+ gfxSparseBitSet& aCharacterMap)
+{
+ enum {
+ OffsetFormat = 0,
+ OffsetLength = 2,
+ OffsetLanguage = 4,
+ OffsetSegCountX2 = 6
+ };
+
+ NS_ENSURE_TRUE(ReadShortAt(aBuf, OffsetFormat) == 4,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+ uint16_t tablelen = ReadShortAt(aBuf, OffsetLength);
+ NS_ENSURE_TRUE(tablelen <= aLength, NS_ERROR_GFX_CMAP_MALFORMED);
+ NS_ENSURE_TRUE(tablelen > 16, NS_ERROR_GFX_CMAP_MALFORMED);
+
+ // This field should normally (except for Mac platform subtables) be zero according to
+ // the OT spec, but some buggy fonts have lang = 1 (which would be English for MacOS).
+ // E.g. Arial Narrow Bold, v. 1.1 (Tiger), Arial Unicode MS (see bug 530614).
+ // So accept either zero or one here; the error should be harmless.
+ NS_ENSURE_TRUE((ReadShortAt(aBuf, OffsetLanguage) & 0xfffe) == 0,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+
+ uint16_t segCountX2 = ReadShortAt(aBuf, OffsetSegCountX2);
+ NS_ENSURE_TRUE(tablelen >= 16 + (segCountX2 * 4),
+ NS_ERROR_GFX_CMAP_MALFORMED);
+
+ const uint16_t segCount = segCountX2 / 2;
+
+ const uint16_t *endCounts = reinterpret_cast<const uint16_t*>(aBuf + 14);
+ const uint16_t *startCounts = endCounts + 1 /* skip one uint16_t for reservedPad */ + segCount;
+ const uint16_t *idDeltas = startCounts + segCount;
+ const uint16_t *idRangeOffsets = idDeltas + segCount;
+ uint16_t prevEndCount = 0;
+ for (uint16_t i = 0; i < segCount; i++) {
+ const uint16_t endCount = ReadShortAt16(endCounts, i);
+ const uint16_t startCount = ReadShortAt16(startCounts, i);
+ const uint16_t idRangeOffset = ReadShortAt16(idRangeOffsets, i);
+
+ // sanity-check range
+ // This permits ranges to overlap by 1 character, which is strictly
+ // incorrect but occurs in Baskerville on OS X 10.7 (see bug 689087),
+ // and appears to be harmless in practice
+ NS_ENSURE_TRUE(startCount >= prevEndCount && startCount <= endCount,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+ prevEndCount = endCount;
+
+ if (idRangeOffset == 0) {
+ // figure out if there's a code in the range that would map to
+ // glyph ID 0 (.notdef); if so, we need to skip setting that
+ // character code in the map
+ const uint16_t skipCode = 65536 - ReadShortAt16(idDeltas, i);
+ if (startCount < skipCode) {
+ aCharacterMap.SetRange(startCount,
+ std::min<uint16_t>(skipCode - 1,
+ endCount));
+ }
+ if (skipCode < endCount) {
+ aCharacterMap.SetRange(std::max<uint16_t>(startCount,
+ skipCode + 1),
+ endCount);
+ }
+ } else {
+ // const uint16_t idDelta = ReadShortAt16(idDeltas, i); // Unused: self-documenting.
+ for (uint32_t c = startCount; c <= endCount; ++c) {
+ if (c == 0xFFFF)
+ break;
+
+ const uint16_t *gdata = (idRangeOffset/2
+ + (c - startCount)
+ + &idRangeOffsets[i]);
+
+ NS_ENSURE_TRUE((uint8_t*)gdata > aBuf &&
+ (uint8_t*)gdata < aBuf + aLength,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+
+ // make sure we have a glyph
+ if (*gdata != 0) {
+ // The glyph index at this point is:
+ uint16_t glyph = ReadShortAt16(idDeltas, i) + *gdata;
+ if (glyph) {
+ aCharacterMap.set(c);
+ }
+ }
+ }
+ }
+ }
+
+ aCharacterMap.Compact();
+
+ return NS_OK;
+}
+
+nsresult
+gfxFontUtils::ReadCMAPTableFormat14(const uint8_t *aBuf, uint32_t aLength,
+ UniquePtr<uint8_t[]>& aTable)
+{
+ enum {
+ OffsetFormat = 0,
+ OffsetTableLength = 2,
+ OffsetNumVarSelectorRecords = 6,
+ OffsetVarSelectorRecords = 10,
+
+ SizeOfVarSelectorRecord = 11,
+ VSRecOffsetVarSelector = 0,
+ VSRecOffsetDefUVSOffset = 3,
+ VSRecOffsetNonDefUVSOffset = 7,
+
+ SizeOfDefUVSTable = 4,
+ DefUVSOffsetStartUnicodeValue = 0,
+ DefUVSOffsetAdditionalCount = 3,
+
+ SizeOfNonDefUVSTable = 5,
+ NonDefUVSOffsetUnicodeValue = 0,
+ NonDefUVSOffsetGlyphID = 3
+ };
+ NS_ENSURE_TRUE(aLength >= OffsetVarSelectorRecords,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+
+ NS_ENSURE_TRUE(ReadShortAt(aBuf, OffsetFormat) == 14,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+
+ uint32_t tablelen = ReadLongAt(aBuf, OffsetTableLength);
+ NS_ENSURE_TRUE(tablelen <= aLength, NS_ERROR_GFX_CMAP_MALFORMED);
+ NS_ENSURE_TRUE(tablelen >= OffsetVarSelectorRecords,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+
+ const uint32_t numVarSelectorRecords = ReadLongAt(aBuf, OffsetNumVarSelectorRecords);
+ NS_ENSURE_TRUE((tablelen - OffsetVarSelectorRecords) /
+ SizeOfVarSelectorRecord >= numVarSelectorRecords,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+
+ const uint8_t *records = aBuf + OffsetVarSelectorRecords;
+ for (uint32_t i = 0; i < numVarSelectorRecords;
+ i++, records += SizeOfVarSelectorRecord) {
+ const uint32_t varSelector = ReadUint24At(records, VSRecOffsetVarSelector);
+ const uint32_t defUVSOffset = ReadLongAt(records, VSRecOffsetDefUVSOffset);
+ const uint32_t nonDefUVSOffset = ReadLongAt(records, VSRecOffsetNonDefUVSOffset);
+ NS_ENSURE_TRUE(varSelector <= CMAP_MAX_CODEPOINT &&
+ defUVSOffset <= tablelen - 4 &&
+ nonDefUVSOffset <= tablelen - 4,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+
+ if (defUVSOffset) {
+ const uint32_t numUnicodeValueRanges = ReadLongAt(aBuf, defUVSOffset);
+ NS_ENSURE_TRUE((tablelen - defUVSOffset) /
+ SizeOfDefUVSTable >= numUnicodeValueRanges,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+ const uint8_t *tables = aBuf + defUVSOffset + 4;
+ uint32_t prevEndUnicode = 0;
+ for (uint32_t j = 0; j < numUnicodeValueRanges; j++, tables += SizeOfDefUVSTable) {
+ const uint32_t startUnicode = ReadUint24At(tables, DefUVSOffsetStartUnicodeValue);
+ const uint32_t endUnicode = startUnicode + tables[DefUVSOffsetAdditionalCount];
+ NS_ENSURE_TRUE((prevEndUnicode < startUnicode || j == 0) &&
+ endUnicode <= CMAP_MAX_CODEPOINT,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+ prevEndUnicode = endUnicode;
+ }
+ }
+
+ if (nonDefUVSOffset) {
+ const uint32_t numUVSMappings = ReadLongAt(aBuf, nonDefUVSOffset);
+ NS_ENSURE_TRUE((tablelen - nonDefUVSOffset) /
+ SizeOfNonDefUVSTable >= numUVSMappings,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+ const uint8_t *tables = aBuf + nonDefUVSOffset + 4;
+ uint32_t prevUnicode = 0;
+ for (uint32_t j = 0; j < numUVSMappings; j++, tables += SizeOfNonDefUVSTable) {
+ const uint32_t unicodeValue = ReadUint24At(tables, NonDefUVSOffsetUnicodeValue);
+ NS_ENSURE_TRUE((prevUnicode < unicodeValue || j == 0) &&
+ unicodeValue <= CMAP_MAX_CODEPOINT,
+ NS_ERROR_GFX_CMAP_MALFORMED);
+ prevUnicode = unicodeValue;
+ }
+ }
+ }
+
+ aTable = MakeUnique<uint8_t[]>(tablelen);
+ memcpy(aTable.get(), aBuf, tablelen);
+
+ return NS_OK;
+}
+
+// For fonts with two format-4 tables, the first one (Unicode platform) is preferred on the Mac;
+// on other platforms we allow the Microsoft-platform subtable to replace it.
+
+#if defined(XP_MACOSX)
+ #define acceptableFormat4(p,e,k) (((p) == PLATFORM_ID_MICROSOFT && (e) == EncodingIDMicrosoft && !(k)) || \
+ ((p) == PLATFORM_ID_UNICODE))
+
+ #define acceptableUCS4Encoding(p, e, k) \
+ (((p) == PLATFORM_ID_MICROSOFT && (e) == EncodingIDUCS4ForMicrosoftPlatform) && (k) != 12 || \
+ ((p) == PLATFORM_ID_UNICODE && \
+ ((e) != EncodingIDUVSForUnicodePlatform)))
+#else
+ #define acceptableFormat4(p,e,k) (((p) == PLATFORM_ID_MICROSOFT && (e) == EncodingIDMicrosoft) || \
+ ((p) == PLATFORM_ID_UNICODE))
+
+ #define acceptableUCS4Encoding(p, e, k) \
+ ((p) == PLATFORM_ID_MICROSOFT && (e) == EncodingIDUCS4ForMicrosoftPlatform)
+#endif
+
+#define acceptablePlatform(p) ((p) == PLATFORM_ID_UNICODE || (p) == PLATFORM_ID_MICROSOFT)
+#define isSymbol(p,e) ((p) == PLATFORM_ID_MICROSOFT && (e) == EncodingIDSymbol)
+#define isUVSEncoding(p, e) ((p) == PLATFORM_ID_UNICODE && (e) == EncodingIDUVSForUnicodePlatform)
+
+uint32_t
+gfxFontUtils::FindPreferredSubtable(const uint8_t *aBuf, uint32_t aBufLength,
+ uint32_t *aTableOffset,
+ uint32_t *aUVSTableOffset,
+ bool *aSymbolEncoding)
+{
+ enum {
+ OffsetVersion = 0,
+ OffsetNumTables = 2,
+ SizeOfHeader = 4,
+
+ TableOffsetPlatformID = 0,
+ TableOffsetEncodingID = 2,
+ TableOffsetOffset = 4,
+ SizeOfTable = 8,
+
+ SubtableOffsetFormat = 0
+ };
+ enum {
+ EncodingIDSymbol = 0,
+ EncodingIDMicrosoft = 1,
+ EncodingIDDefaultForUnicodePlatform = 0,
+ EncodingIDUCS4ForUnicodePlatform = 3,
+ EncodingIDUVSForUnicodePlatform = 5,
+ EncodingIDUCS4ForMicrosoftPlatform = 10
+ };
+
+ if (aUVSTableOffset) {
+ *aUVSTableOffset = 0;
+ }
+
+ if (!aBuf || aBufLength < SizeOfHeader) {
+ // cmap table is missing, or too small to contain header fields!
+ return 0;
+ }
+
+ // uint16_t version = ReadShortAt(aBuf, OffsetVersion); // Unused: self-documenting.
+ uint16_t numTables = ReadShortAt(aBuf, OffsetNumTables);
+ if (aBufLength < uint32_t(SizeOfHeader + numTables * SizeOfTable)) {
+ return 0;
+ }
+
+ // save the format we want here
+ uint32_t keepFormat = 0;
+
+ const uint8_t *table = aBuf + SizeOfHeader;
+ for (uint16_t i = 0; i < numTables; ++i, table += SizeOfTable) {
+ const uint16_t platformID = ReadShortAt(table, TableOffsetPlatformID);
+ if (!acceptablePlatform(platformID))
+ continue;
+
+ const uint16_t encodingID = ReadShortAt(table, TableOffsetEncodingID);
+ const uint32_t offset = ReadLongAt(table, TableOffsetOffset);
+ if (aBufLength - 2 < offset) {
+ // this subtable is not valid - beyond end of buffer
+ return 0;
+ }
+
+ const uint8_t *subtable = aBuf + offset;
+ const uint16_t format = ReadShortAt(subtable, SubtableOffsetFormat);
+
+ if (isSymbol(platformID, encodingID)) {
+ keepFormat = format;
+ *aTableOffset = offset;
+ *aSymbolEncoding = true;
+ break;
+ } else if (format == 4 && acceptableFormat4(platformID, encodingID, keepFormat)) {
+ keepFormat = format;
+ *aTableOffset = offset;
+ *aSymbolEncoding = false;
+ } else if ((format == 10 || format == 12) &&
+ acceptableUCS4Encoding(platformID, encodingID, keepFormat)) {
+ keepFormat = format;
+ *aTableOffset = offset;
+ *aSymbolEncoding = false;
+ if (platformID > PLATFORM_ID_UNICODE || !aUVSTableOffset || *aUVSTableOffset) {
+ break; // we don't want to try anything else when this format is available.
+ }
+ } else if (format == 14 && isUVSEncoding(platformID, encodingID) && aUVSTableOffset) {
+ *aUVSTableOffset = offset;
+ if (keepFormat == 10 || keepFormat == 12) {
+ break;
+ }
+ }
+ }
+
+ return keepFormat;
+}
+
+nsresult
+gfxFontUtils::ReadCMAP(const uint8_t *aBuf, uint32_t aBufLength,
+ gfxSparseBitSet& aCharacterMap,
+ uint32_t& aUVSOffset,
+ bool& aUnicodeFont, bool& aSymbolFont)
+{
+ uint32_t offset;
+ bool symbol;
+ uint32_t format = FindPreferredSubtable(aBuf, aBufLength,
+ &offset, &aUVSOffset, &symbol);
+
+ switch (format) {
+ case 4:
+ if (symbol) {
+ aUnicodeFont = false;
+ aSymbolFont = true;
+ } else {
+ aUnicodeFont = true;
+ aSymbolFont = false;
+ }
+ return ReadCMAPTableFormat4(aBuf + offset, aBufLength - offset,
+ aCharacterMap);
+
+ case 10:
+ aUnicodeFont = true;
+ aSymbolFont = false;
+ return ReadCMAPTableFormat10(aBuf + offset, aBufLength - offset,
+ aCharacterMap);
+
+ case 12:
+ aUnicodeFont = true;
+ aSymbolFont = false;
+ return ReadCMAPTableFormat12(aBuf + offset, aBufLength - offset,
+ aCharacterMap);
+
+ default:
+ break;
+ }
+
+ return NS_ERROR_FAILURE;
+}
+
+#pragma pack(1)
+
+typedef struct {
+ AutoSwap_PRUint16 format;
+ AutoSwap_PRUint16 length;
+ AutoSwap_PRUint16 language;
+ AutoSwap_PRUint16 segCountX2;
+ AutoSwap_PRUint16 searchRange;
+ AutoSwap_PRUint16 entrySelector;
+ AutoSwap_PRUint16 rangeShift;
+
+ AutoSwap_PRUint16 arrays[1];
+} Format4Cmap;
+
+typedef struct {
+ AutoSwap_PRUint16 format;
+ AutoSwap_PRUint32 length;
+ AutoSwap_PRUint32 numVarSelectorRecords;
+
+ typedef struct {
+ AutoSwap_PRUint24 varSelector;
+ AutoSwap_PRUint32 defaultUVSOffset;
+ AutoSwap_PRUint32 nonDefaultUVSOffset;
+ } VarSelectorRecord;
+
+ VarSelectorRecord varSelectorRecords[1];
+} Format14Cmap;
+
+typedef struct {
+ AutoSwap_PRUint32 numUVSMappings;
+
+ typedef struct {
+ AutoSwap_PRUint24 unicodeValue;
+ AutoSwap_PRUint16 glyphID;
+ } UVSMapping;
+
+ UVSMapping uvsMappings[1];
+} NonDefUVSTable;
+
+#pragma pack()
+
+uint32_t
+gfxFontUtils::MapCharToGlyphFormat4(const uint8_t *aBuf, char16_t aCh)
+{
+ const Format4Cmap *cmap4 = reinterpret_cast<const Format4Cmap*>(aBuf);
+ uint16_t segCount;
+ const AutoSwap_PRUint16 *endCodes;
+ const AutoSwap_PRUint16 *startCodes;
+ const AutoSwap_PRUint16 *idDelta;
+ const AutoSwap_PRUint16 *idRangeOffset;
+ uint16_t probe;
+ uint16_t rangeShiftOver2;
+ uint16_t index;
+
+ segCount = (uint16_t)(cmap4->segCountX2) / 2;
+
+ endCodes = &cmap4->arrays[0];
+ startCodes = &cmap4->arrays[segCount + 1]; // +1 for reserved word between arrays
+ idDelta = &startCodes[segCount];
+ idRangeOffset = &idDelta[segCount];
+
+ probe = 1 << (uint16_t)(cmap4->entrySelector);
+ rangeShiftOver2 = (uint16_t)(cmap4->rangeShift) / 2;
+
+ if ((uint16_t)(startCodes[rangeShiftOver2]) <= aCh) {
+ index = rangeShiftOver2;
+ } else {
+ index = 0;
+ }
+
+ while (probe > 1) {
+ probe >>= 1;
+ if ((uint16_t)(startCodes[index + probe]) <= aCh) {
+ index += probe;
+ }
+ }
+
+ if (aCh >= (uint16_t)(startCodes[index]) && aCh <= (uint16_t)(endCodes[index])) {
+ uint16_t result;
+ if ((uint16_t)(idRangeOffset[index]) == 0) {
+ result = aCh;
+ } else {
+ uint16_t offset = aCh - (uint16_t)(startCodes[index]);
+ const AutoSwap_PRUint16 *glyphIndexTable =
+ (const AutoSwap_PRUint16*)((const char*)&idRangeOffset[index] +
+ (uint16_t)(idRangeOffset[index]));
+ result = glyphIndexTable[offset];
+ }
+
+ // note that this is unsigned 16-bit arithmetic, and may wrap around
+ result += (uint16_t)(idDelta[index]);
+ return result;
+ }
+
+ return 0;
+}
+
+uint32_t
+gfxFontUtils::MapCharToGlyphFormat10(const uint8_t *aBuf, uint32_t aCh)
+{
+ const Format10CmapHeader *cmap10 =
+ reinterpret_cast<const Format10CmapHeader*>(aBuf);
+
+ uint32_t startChar = cmap10->startCharCode;
+ uint32_t numChars = cmap10->numChars;
+
+ if (aCh < startChar || aCh >= startChar + numChars) {
+ return 0;
+ }
+
+ const AutoSwap_PRUint16 *glyphs =
+ reinterpret_cast<const AutoSwap_PRUint16 *>(cmap10 + 1);
+
+ uint16_t glyph = glyphs[aCh - startChar];
+ return glyph;
+}
+
+uint32_t
+gfxFontUtils::MapCharToGlyphFormat12(const uint8_t *aBuf, uint32_t aCh)
+{
+ const Format12CmapHeader *cmap12 =
+ reinterpret_cast<const Format12CmapHeader*>(aBuf);
+
+ // We know that numGroups is within range for the subtable size
+ // because it was checked by ReadCMAPTableFormat12.
+ uint32_t numGroups = cmap12->numGroups;
+
+ // The array of groups immediately follows the subtable header.
+ const Format12Group *groups =
+ reinterpret_cast<const Format12Group*>(aBuf + sizeof(Format12CmapHeader));
+
+ // For most efficient binary search, we want to work on a range that
+ // is a power of 2 so that we can always halve it by shifting.
+ // So we find the largest power of 2 that is <= numGroups.
+ // We will offset this range by rangeOffset so as to reach the end
+ // of the table, provided that doesn't put us beyond the target
+ // value from the outset.
+ uint32_t powerOf2 = mozilla::FindHighestBit(numGroups);
+ uint32_t rangeOffset = numGroups - powerOf2;
+ uint32_t range = 0;
+ uint32_t startCharCode;
+
+ if (groups[rangeOffset].startCharCode <= aCh) {
+ range = rangeOffset;
+ }
+
+ // Repeatedly halve the size of the range until we find the target group
+ while (powerOf2 > 1) {
+ powerOf2 >>= 1;
+ if (groups[range + powerOf2].startCharCode <= aCh) {
+ range += powerOf2;
+ }
+ }
+
+ // Check if the character is actually present in the range and return
+ // the corresponding glyph ID
+ startCharCode = groups[range].startCharCode;
+ if (startCharCode <= aCh && groups[range].endCharCode >= aCh) {
+ return groups[range].startGlyphId + aCh - startCharCode;
+ }
+
+ // Else it's not present, so return the .notdef glyph
+ return 0;
+}
+
+namespace {
+
+struct Format14CmapWrapper
+{
+ const Format14Cmap& mCmap14;
+ explicit Format14CmapWrapper(const Format14Cmap& cmap14) : mCmap14(cmap14) {}
+ uint32_t operator[](size_t index) const {
+ return mCmap14.varSelectorRecords[index].varSelector;
+ }
+};
+
+struct NonDefUVSTableWrapper
+{
+ const NonDefUVSTable& mTable;
+ explicit NonDefUVSTableWrapper(const NonDefUVSTable& table) : mTable(table) {}
+ uint32_t operator[](size_t index) const {
+ return mTable.uvsMappings[index].unicodeValue;
+ }
+};
+
+} // namespace
+
+uint16_t
+gfxFontUtils::MapUVSToGlyphFormat14(const uint8_t *aBuf, uint32_t aCh, uint32_t aVS)
+{
+ using mozilla::BinarySearch;
+ const Format14Cmap *cmap14 = reinterpret_cast<const Format14Cmap*>(aBuf);
+
+ size_t index;
+ if (!BinarySearch(Format14CmapWrapper(*cmap14),
+ 0, cmap14->numVarSelectorRecords, aVS, &index)) {
+ return 0;
+ }
+
+ const uint32_t nonDefUVSOffset = cmap14->varSelectorRecords[index].nonDefaultUVSOffset;
+ if (!nonDefUVSOffset) {
+ return 0;
+ }
+
+ const NonDefUVSTable *table = reinterpret_cast<const NonDefUVSTable*>
+ (aBuf + nonDefUVSOffset);
+
+ if (BinarySearch(NonDefUVSTableWrapper(*table), 0, table->numUVSMappings,
+ aCh, &index)) {
+ return table->uvsMappings[index].glyphID;
+ }
+
+ return 0;
+}
+
+uint32_t
+gfxFontUtils::MapCharToGlyph(const uint8_t *aCmapBuf, uint32_t aBufLength,
+ uint32_t aUnicode, uint32_t aVarSelector)
+{
+ uint32_t offset, uvsOffset;
+ bool symbol;
+ uint32_t format = FindPreferredSubtable(aCmapBuf, aBufLength, &offset,
+ &uvsOffset, &symbol);
+
+ uint32_t gid;
+ switch (format) {
+ case 4:
+ gid = aUnicode < UNICODE_BMP_LIMIT ?
+ MapCharToGlyphFormat4(aCmapBuf + offset, char16_t(aUnicode)) : 0;
+ break;
+ case 10:
+ gid = MapCharToGlyphFormat10(aCmapBuf + offset, aUnicode);
+ break;
+ case 12:
+ gid = MapCharToGlyphFormat12(aCmapBuf + offset, aUnicode);
+ break;
+ default:
+ NS_WARNING("unsupported cmap format, glyphs will be missing");
+ gid = 0;
+ }
+
+ if (aVarSelector && uvsOffset && gid) {
+ uint32_t varGID =
+ gfxFontUtils::MapUVSToGlyphFormat14(aCmapBuf + uvsOffset,
+ aUnicode, aVarSelector);
+ if (!varGID) {
+ aUnicode = gfxFontUtils::GetUVSFallback(aUnicode, aVarSelector);
+ if (aUnicode) {
+ switch (format) {
+ case 4:
+ if (aUnicode < UNICODE_BMP_LIMIT) {
+ varGID = MapCharToGlyphFormat4(aCmapBuf + offset,
+ char16_t(aUnicode));
+ }
+ break;
+ case 10:
+ varGID = MapCharToGlyphFormat10(aCmapBuf + offset,
+ aUnicode);
+ break;
+ case 12:
+ varGID = MapCharToGlyphFormat12(aCmapBuf + offset,
+ aUnicode);
+ break;
+ }
+ }
+ }
+ if (varGID) {
+ gid = varGID;
+ }
+
+ // else the variation sequence was not supported, use default mapping
+ // of the character code alone
+ }
+
+ return gid;
+}
+
+void gfxFontUtils::ParseFontList(const nsAString& aFamilyList,
+ nsTArray<nsString>& aFontList)
+{
+ const char16_t kComma = char16_t(',');
+
+ // append each font name to the list
+ nsAutoString fontname;
+ const char16_t *p, *p_end;
+ aFamilyList.BeginReading(p);
+ aFamilyList.EndReading(p_end);
+
+ while (p < p_end) {
+ const char16_t *nameStart = p;
+ while (++p != p_end && *p != kComma)
+ /* nothing */ ;
+
+ // pull out a single name and clean out leading/trailing whitespace
+ fontname = Substring(nameStart, p);
+ fontname.CompressWhitespace(true, true);
+
+ // append it to the list
+ aFontList.AppendElement(fontname);
+ ++p;
+ }
+}
+
+void gfxFontUtils::AppendPrefsFontList(const char *aPrefName,
+ nsTArray<nsString>& aFontList)
+{
+ // get the list of single-face font families
+ nsAdoptingString fontlistValue = Preferences::GetString(aPrefName);
+ if (!fontlistValue) {
+ return;
+ }
+
+ ParseFontList(fontlistValue, aFontList);
+}
+
+void gfxFontUtils::GetPrefsFontList(const char *aPrefName,
+ nsTArray<nsString>& aFontList)
+{
+ aFontList.Clear();
+ AppendPrefsFontList(aPrefName, aFontList);
+}
+
+// produce a unique font name that is (1) a valid Postscript name and (2) less
+// than 31 characters in length. Using AddFontMemResourceEx on Windows fails
+// for names longer than 30 characters in length.
+
+#define MAX_B64_LEN 32
+
+nsresult gfxFontUtils::MakeUniqueUserFontName(nsAString& aName)
+{
+ nsCOMPtr<nsIUUIDGenerator> uuidgen =
+ do_GetService("@mozilla.org/uuid-generator;1");
+ NS_ENSURE_TRUE(uuidgen, NS_ERROR_OUT_OF_MEMORY);
+
+ nsID guid;
+
+ NS_ASSERTION(sizeof(guid) * 2 <= MAX_B64_LEN, "size of nsID has changed!");
+
+ nsresult rv = uuidgen->GenerateUUIDInPlace(&guid);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ char guidB64[MAX_B64_LEN] = {0};
+
+ if (!PL_Base64Encode(reinterpret_cast<char*>(&guid), sizeof(guid), guidB64))
+ return NS_ERROR_FAILURE;
+
+ // all b64 characters except for '/' are allowed in Postscript names, so convert / ==> -
+ char *p;
+ for (p = guidB64; *p; p++) {
+ if (*p == '/')
+ *p = '-';
+ }
+
+ aName.AssignLiteral(u"uf");
+ aName.AppendASCII(guidB64);
+ return NS_OK;
+}
+
+
+// TrueType/OpenType table handling code
+
+// need byte aligned structs
+#pragma pack(1)
+
+// name table stores set of name record structures, followed by
+// large block containing all the strings. name record offset and length
+// indicates the offset and length within that block.
+// http://www.microsoft.com/typography/otspec/name.htm
+struct NameRecordData {
+ uint32_t offset;
+ uint32_t length;
+};
+
+#pragma pack()
+
+static bool
+IsValidSFNTVersion(uint32_t version)
+{
+ // normally 0x00010000, CFF-style OT fonts == 'OTTO' and Apple TT fonts = 'true'
+ // 'typ1' is also possible for old Type 1 fonts in a SFNT container but not supported
+ return version == 0x10000 ||
+ version == TRUETYPE_TAG('O','T','T','O') ||
+ version == TRUETYPE_TAG('t','r','u','e');
+}
+
+// Copy and swap UTF-16 values, assume no surrogate pairs, can be in place.
+// aInBuf and aOutBuf are NOT necessarily 16-bit-aligned, so we should avoid
+// accessing them directly as uint16_t* values.
+// aLen is count of UTF-16 values, so the byte buffers are twice that.
+static void
+CopySwapUTF16(const char* aInBuf, char* aOutBuf, uint32_t aLen)
+{
+ const char* end = aInBuf + aLen * 2;
+ while (aInBuf < end) {
+ uint8_t b0 = *aInBuf++;
+ *aOutBuf++ = *aInBuf++;
+ *aOutBuf++ = b0;
+ }
+}
+
+gfxUserFontType
+gfxFontUtils::DetermineFontDataType(const uint8_t *aFontData, uint32_t aFontDataLength)
+{
+ // test for OpenType font data
+ // problem: EOT-Lite with 0x10000 length will look like TrueType!
+ if (aFontDataLength >= sizeof(SFNTHeader)) {
+ const SFNTHeader *sfntHeader = reinterpret_cast<const SFNTHeader*>(aFontData);
+ uint32_t sfntVersion = sfntHeader->sfntVersion;
+ if (IsValidSFNTVersion(sfntVersion)) {
+ return GFX_USERFONT_OPENTYPE;
+ }
+ }
+
+ // test for WOFF
+ if (aFontDataLength >= sizeof(AutoSwap_PRUint32)) {
+ const AutoSwap_PRUint32 *version =
+ reinterpret_cast<const AutoSwap_PRUint32*>(aFontData);
+ if (uint32_t(*version) == TRUETYPE_TAG('w','O','F','F')) {
+ return GFX_USERFONT_WOFF;
+ }
+ if (Preferences::GetBool(GFX_PREF_WOFF2_ENABLED) &&
+ uint32_t(*version) == TRUETYPE_TAG('w','O','F','2')) {
+ return GFX_USERFONT_WOFF2;
+ }
+ }
+
+ // tests for other formats here
+
+ return GFX_USERFONT_UNKNOWN;
+}
+
+static int
+DirEntryCmp(const void* aKey, const void* aItem)
+{
+ int32_t tag = *static_cast<const int32_t*>(aKey);
+ const TableDirEntry* entry = static_cast<const TableDirEntry*>(aItem);
+ return tag - int32_t(entry->tag);
+}
+
+/* static */
+TableDirEntry*
+gfxFontUtils::FindTableDirEntry(const void* aFontData, uint32_t aTableTag)
+{
+ const SFNTHeader* header =
+ reinterpret_cast<const SFNTHeader*>(aFontData);
+ const TableDirEntry* dir =
+ reinterpret_cast<const TableDirEntry*>(header + 1);
+ return static_cast<TableDirEntry*>
+ (bsearch(&aTableTag, dir, uint16_t(header->numTables),
+ sizeof(TableDirEntry), DirEntryCmp));
+}
+
+/* static */
+hb_blob_t*
+gfxFontUtils::GetTableFromFontData(const void* aFontData, uint32_t aTableTag)
+{
+ const TableDirEntry* dir = FindTableDirEntry(aFontData, aTableTag);
+ if (dir) {
+ return hb_blob_create(reinterpret_cast<const char*>(aFontData) +
+ dir->offset, dir->length,
+ HB_MEMORY_MODE_READONLY, nullptr, nullptr);
+
+ }
+ return nullptr;
+}
+
+nsresult
+gfxFontUtils::RenameFont(const nsAString& aName, const uint8_t *aFontData,
+ uint32_t aFontDataLength, FallibleTArray<uint8_t> *aNewFont)
+{
+ NS_ASSERTION(aNewFont, "null font data array");
+
+ uint64_t dataLength(aFontDataLength);
+
+ // new name table
+ static const uint32_t neededNameIDs[] = {NAME_ID_FAMILY,
+ NAME_ID_STYLE,
+ NAME_ID_UNIQUE,
+ NAME_ID_FULL,
+ NAME_ID_POSTSCRIPT};
+
+ // calculate new name table size
+ uint16_t nameCount = ArrayLength(neededNameIDs);
+
+ // leave room for null-terminator
+ uint32_t nameStrLength = (aName.Length() + 1) * sizeof(char16_t);
+ if (nameStrLength > 65535) {
+ // The name length _in bytes_ must fit in an unsigned short field;
+ // therefore, a name longer than this cannot be used.
+ return NS_ERROR_FAILURE;
+ }
+
+ // round name table size up to 4-byte multiple
+ uint32_t nameTableSize = (sizeof(NameHeader) +
+ sizeof(NameRecord) * nameCount +
+ nameStrLength +
+ 3) & ~3;
+
+ if (dataLength + nameTableSize > UINT32_MAX)
+ return NS_ERROR_FAILURE;
+
+ // bug 505386 - need to handle unpadded font length
+ uint32_t paddedFontDataSize = (aFontDataLength + 3) & ~3;
+ uint32_t adjFontDataSize = paddedFontDataSize + nameTableSize;
+
+ // create new buffer: old font data plus new name table
+ if (!aNewFont->AppendElements(adjFontDataSize, fallible))
+ return NS_ERROR_OUT_OF_MEMORY;
+
+ // copy the old font data
+ uint8_t *newFontData = reinterpret_cast<uint8_t*>(aNewFont->Elements());
+
+ // null the last four bytes in case the font length is not a multiple of 4
+ memset(newFontData + aFontDataLength, 0, paddedFontDataSize - aFontDataLength);
+
+ // copy font data
+ memcpy(newFontData, aFontData, aFontDataLength);
+
+ // null out the last 4 bytes for checksum calculations
+ memset(newFontData + adjFontDataSize - 4, 0, 4);
+
+ NameHeader *nameHeader = reinterpret_cast<NameHeader*>(newFontData +
+ paddedFontDataSize);
+
+ // -- name header
+ nameHeader->format = 0;
+ nameHeader->count = nameCount;
+ nameHeader->stringOffset = sizeof(NameHeader) + nameCount * sizeof(NameRecord);
+
+ // -- name records
+ uint32_t i;
+ NameRecord *nameRecord = reinterpret_cast<NameRecord*>(nameHeader + 1);
+
+ for (i = 0; i < nameCount; i++, nameRecord++) {
+ nameRecord->platformID = PLATFORM_ID_MICROSOFT;
+ nameRecord->encodingID = ENCODING_ID_MICROSOFT_UNICODEBMP;
+ nameRecord->languageID = LANG_ID_MICROSOFT_EN_US;
+ nameRecord->nameID = neededNameIDs[i];
+ nameRecord->offset = 0;
+ nameRecord->length = nameStrLength;
+ }
+
+ // -- string data, located after the name records, stored in big-endian form
+ char16_t *strData = reinterpret_cast<char16_t*>(nameRecord);
+
+ mozilla::NativeEndian::copyAndSwapToBigEndian(strData,
+ aName.BeginReading(),
+ aName.Length());
+ strData[aName.Length()] = 0; // add null termination
+
+ // adjust name table header to point to the new name table
+ SFNTHeader *sfntHeader = reinterpret_cast<SFNTHeader*>(newFontData);
+
+ // table directory entries begin immediately following SFNT header
+ TableDirEntry *dirEntry =
+ FindTableDirEntry(newFontData, TRUETYPE_TAG('n','a','m','e'));
+ // function only called if font validates, so this should always be true
+ MOZ_ASSERT(dirEntry, "attempt to rename font with no name table");
+
+ uint32_t numTables = sfntHeader->numTables;
+
+ // note: dirEntry now points to 'name' table record
+
+ // recalculate name table checksum
+ uint32_t checkSum = 0;
+ AutoSwap_PRUint32 *nameData = reinterpret_cast<AutoSwap_PRUint32*> (nameHeader);
+ AutoSwap_PRUint32 *nameDataEnd = nameData + (nameTableSize >> 2);
+
+ while (nameData < nameDataEnd)
+ checkSum = checkSum + *nameData++;
+
+ // adjust name table entry to point to new name table
+ dirEntry->offset = paddedFontDataSize;
+ dirEntry->length = nameTableSize;
+ dirEntry->checkSum = checkSum;
+
+ // fix up checksums
+ uint32_t checksum = 0;
+
+ // checksum for font = (checksum of header) + (checksum of tables)
+ uint32_t headerLen = sizeof(SFNTHeader) + sizeof(TableDirEntry) * numTables;
+ const AutoSwap_PRUint32 *headerData =
+ reinterpret_cast<const AutoSwap_PRUint32*>(newFontData);
+
+ // header length is in bytes, checksum calculated in longwords
+ for (i = 0; i < (headerLen >> 2); i++, headerData++) {
+ checksum += *headerData;
+ }
+
+ uint32_t headOffset = 0;
+ dirEntry = reinterpret_cast<TableDirEntry*>(newFontData + sizeof(SFNTHeader));
+
+ for (i = 0; i < numTables; i++, dirEntry++) {
+ if (dirEntry->tag == TRUETYPE_TAG('h','e','a','d')) {
+ headOffset = dirEntry->offset;
+ }
+ checksum += dirEntry->checkSum;
+ }
+
+ NS_ASSERTION(headOffset != 0, "no head table for font");
+
+ HeadTable *headData = reinterpret_cast<HeadTable*>(newFontData + headOffset);
+
+ headData->checkSumAdjustment = HeadTable::HEAD_CHECKSUM_CALC_CONST - checksum;
+
+ return NS_OK;
+}
+
+// This is only called after the basic validity of the downloaded sfnt
+// data has been checked, so it should never fail to find the name table
+// (though it might fail to read it, if memory isn't available);
+// other checks here are just for extra paranoia.
+nsresult
+gfxFontUtils::GetFullNameFromSFNT(const uint8_t* aFontData, uint32_t aLength,
+ nsAString& aFullName)
+{
+ aFullName.AssignLiteral("(MISSING NAME)"); // should always get replaced
+
+ const TableDirEntry *dirEntry =
+ FindTableDirEntry(aFontData, TRUETYPE_TAG('n','a','m','e'));
+
+ // should never fail, as we're only called after font validation succeeded
+ NS_ENSURE_TRUE(dirEntry, NS_ERROR_NOT_AVAILABLE);
+
+ uint32_t len = dirEntry->length;
+ NS_ENSURE_TRUE(aLength > len && aLength - len >= dirEntry->offset,
+ NS_ERROR_UNEXPECTED);
+
+ hb_blob_t *nameBlob =
+ hb_blob_create((const char*)aFontData + dirEntry->offset, len,
+ HB_MEMORY_MODE_READONLY, nullptr, nullptr);
+ nsresult rv = GetFullNameFromTable(nameBlob, aFullName);
+ hb_blob_destroy(nameBlob);
+
+ return rv;
+}
+
+nsresult
+gfxFontUtils::GetFullNameFromTable(hb_blob_t *aNameTable,
+ nsAString& aFullName)
+{
+ nsAutoString name;
+ nsresult rv =
+ gfxFontUtils::ReadCanonicalName(aNameTable,
+ gfxFontUtils::NAME_ID_FULL,
+ name);
+ if (NS_SUCCEEDED(rv) && !name.IsEmpty()) {
+ aFullName = name;
+ return NS_OK;
+ }
+ rv = gfxFontUtils::ReadCanonicalName(aNameTable,
+ gfxFontUtils::NAME_ID_FAMILY,
+ name);
+ if (NS_SUCCEEDED(rv) && !name.IsEmpty()) {
+ nsAutoString styleName;
+ rv = gfxFontUtils::ReadCanonicalName(aNameTable,
+ gfxFontUtils::NAME_ID_STYLE,
+ styleName);
+ if (NS_SUCCEEDED(rv) && !styleName.IsEmpty()) {
+ name.Append(' ');
+ name.Append(styleName);
+ aFullName = name;
+ }
+ return NS_OK;
+ }
+
+ return NS_ERROR_NOT_AVAILABLE;
+}
+
+nsresult
+gfxFontUtils::GetFamilyNameFromTable(hb_blob_t *aNameTable,
+ nsAString& aFullName)
+{
+ nsAutoString name;
+ nsresult rv =
+ gfxFontUtils::ReadCanonicalName(aNameTable,
+ gfxFontUtils::NAME_ID_FAMILY,
+ name);
+ if (NS_SUCCEEDED(rv) && !name.IsEmpty()) {
+ aFullName = name;
+ return NS_OK;
+ }
+ return NS_ERROR_NOT_AVAILABLE;
+}
+
+enum {
+#if defined(XP_MACOSX)
+ CANONICAL_LANG_ID = gfxFontUtils::LANG_ID_MAC_ENGLISH,
+ PLATFORM_ID = gfxFontUtils::PLATFORM_ID_MAC
+#else
+ CANONICAL_LANG_ID = gfxFontUtils::LANG_ID_MICROSOFT_EN_US,
+ PLATFORM_ID = gfxFontUtils::PLATFORM_ID_MICROSOFT
+#endif
+};
+
+nsresult
+gfxFontUtils::ReadNames(const char *aNameData, uint32_t aDataLen,
+ uint32_t aNameID, int32_t aPlatformID,
+ nsTArray<nsString>& aNames)
+{
+ return ReadNames(aNameData, aDataLen, aNameID, LANG_ALL,
+ aPlatformID, aNames);
+}
+
+nsresult
+gfxFontUtils::ReadCanonicalName(hb_blob_t *aNameTable, uint32_t aNameID,
+ nsString& aName)
+{
+ uint32_t nameTableLen;
+ const char *nameTable = hb_blob_get_data(aNameTable, &nameTableLen);
+ return ReadCanonicalName(nameTable, nameTableLen, aNameID, aName);
+}
+
+nsresult
+gfxFontUtils::ReadCanonicalName(const char *aNameData, uint32_t aDataLen,
+ uint32_t aNameID, nsString& aName)
+{
+ nsresult rv;
+
+ nsTArray<nsString> names;
+
+ // first, look for the English name (this will succeed 99% of the time)
+ rv = ReadNames(aNameData, aDataLen, aNameID, CANONICAL_LANG_ID,
+ PLATFORM_ID, names);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // otherwise, grab names for all languages
+ if (names.Length() == 0) {
+ rv = ReadNames(aNameData, aDataLen, aNameID, LANG_ALL,
+ PLATFORM_ID, names);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+#if defined(XP_MACOSX)
+ // may be dealing with font that only has Microsoft name entries
+ if (names.Length() == 0) {
+ rv = ReadNames(aNameData, aDataLen, aNameID, LANG_ID_MICROSOFT_EN_US,
+ PLATFORM_ID_MICROSOFT, names);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // getting really desperate now, take anything!
+ if (names.Length() == 0) {
+ rv = ReadNames(aNameData, aDataLen, aNameID, LANG_ALL,
+ PLATFORM_ID_MICROSOFT, names);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ }
+#endif
+
+ // return the first name (99.9% of the time names will
+ // contain a single English name)
+ if (names.Length()) {
+ aName.Assign(names[0]);
+ return NS_OK;
+ }
+
+ return NS_ERROR_FAILURE;
+}
+
+// Charsets to use for decoding Mac platform font names.
+// This table is sorted by {encoding, language}, with the wildcard "ANY" being
+// greater than any defined values for each field; we use a binary search on both
+// fields, and fall back to matching only encoding if necessary
+
+// Some "redundant" entries for specific combinations are included such as
+// encoding=roman, lang=english, in order that common entries will be found
+// on the first search.
+
+#define ANY 0xffff
+const gfxFontUtils::MacFontNameCharsetMapping gfxFontUtils::gMacFontNameCharsets[] =
+{
+ { ENCODING_ID_MAC_ROMAN, LANG_ID_MAC_ENGLISH, "macintosh" },
+ { ENCODING_ID_MAC_ROMAN, LANG_ID_MAC_ICELANDIC, "x-mac-icelandic" },
+ { ENCODING_ID_MAC_ROMAN, LANG_ID_MAC_TURKISH, "x-mac-turkish" },
+ { ENCODING_ID_MAC_ROMAN, LANG_ID_MAC_POLISH, "x-mac-ce" },
+ { ENCODING_ID_MAC_ROMAN, LANG_ID_MAC_ROMANIAN, "x-mac-romanian" },
+ { ENCODING_ID_MAC_ROMAN, LANG_ID_MAC_CZECH, "x-mac-ce" },
+ { ENCODING_ID_MAC_ROMAN, LANG_ID_MAC_SLOVAK, "x-mac-ce" },
+ { ENCODING_ID_MAC_ROMAN, ANY, "macintosh" },
+ { ENCODING_ID_MAC_JAPANESE, LANG_ID_MAC_JAPANESE, "Shift_JIS" },
+ { ENCODING_ID_MAC_JAPANESE, ANY, "Shift_JIS" },
+ { ENCODING_ID_MAC_TRAD_CHINESE, LANG_ID_MAC_TRAD_CHINESE, "Big5" },
+ { ENCODING_ID_MAC_TRAD_CHINESE, ANY, "Big5" },
+ { ENCODING_ID_MAC_KOREAN, LANG_ID_MAC_KOREAN, "EUC-KR" },
+ { ENCODING_ID_MAC_KOREAN, ANY, "EUC-KR" },
+ { ENCODING_ID_MAC_ARABIC, LANG_ID_MAC_ARABIC, "x-mac-arabic" },
+ { ENCODING_ID_MAC_ARABIC, LANG_ID_MAC_URDU, "x-mac-farsi" },
+ { ENCODING_ID_MAC_ARABIC, LANG_ID_MAC_FARSI, "x-mac-farsi" },
+ { ENCODING_ID_MAC_ARABIC, ANY, "x-mac-arabic" },
+ { ENCODING_ID_MAC_HEBREW, LANG_ID_MAC_HEBREW, "x-mac-hebrew" },
+ { ENCODING_ID_MAC_HEBREW, ANY, "x-mac-hebrew" },
+ { ENCODING_ID_MAC_GREEK, ANY, "x-mac-greek" },
+ { ENCODING_ID_MAC_CYRILLIC, ANY, "x-mac-cyrillic" },
+ { ENCODING_ID_MAC_DEVANAGARI, ANY, "x-mac-devanagari"},
+ { ENCODING_ID_MAC_GURMUKHI, ANY, "x-mac-gurmukhi" },
+ { ENCODING_ID_MAC_GUJARATI, ANY, "x-mac-gujarati" },
+ { ENCODING_ID_MAC_SIMP_CHINESE, LANG_ID_MAC_SIMP_CHINESE, "gb18030" },
+ { ENCODING_ID_MAC_SIMP_CHINESE, ANY, "gb18030" }
+};
+
+const char* gfxFontUtils::gISOFontNameCharsets[] =
+{
+ /* 0 */ "windows-1252", /* US-ASCII */
+ /* 1 */ nullptr , /* spec says "ISO 10646" but does not specify encoding form! */
+ /* 2 */ "windows-1252" /* ISO-8859-1 */
+};
+
+const char* gfxFontUtils::gMSFontNameCharsets[] =
+{
+ /* [0] ENCODING_ID_MICROSOFT_SYMBOL */ "" ,
+ /* [1] ENCODING_ID_MICROSOFT_UNICODEBMP */ "" ,
+ /* [2] ENCODING_ID_MICROSOFT_SHIFTJIS */ "Shift_JIS" ,
+ /* [3] ENCODING_ID_MICROSOFT_PRC */ nullptr ,
+ /* [4] ENCODING_ID_MICROSOFT_BIG5 */ "Big5" ,
+ /* [5] ENCODING_ID_MICROSOFT_WANSUNG */ nullptr ,
+ /* [6] ENCODING_ID_MICROSOFT_JOHAB */ nullptr ,
+ /* [7] reserved */ nullptr ,
+ /* [8] reserved */ nullptr ,
+ /* [9] reserved */ nullptr ,
+ /*[10] ENCODING_ID_MICROSOFT_UNICODEFULL */ ""
+};
+
+struct MacCharsetMappingComparator
+{
+ typedef gfxFontUtils::MacFontNameCharsetMapping MacFontNameCharsetMapping;
+ const MacFontNameCharsetMapping& mSearchValue;
+ explicit MacCharsetMappingComparator(const MacFontNameCharsetMapping& aSearchValue)
+ : mSearchValue(aSearchValue) {}
+ int operator()(const MacFontNameCharsetMapping& aEntry) const {
+ if (mSearchValue < aEntry) {
+ return -1;
+ }
+ if (aEntry < mSearchValue) {
+ return 1;
+ }
+ return 0;
+ }
+};
+
+// Return the name of the charset we should use to decode a font name
+// given the name table attributes.
+// Special return values:
+// "" charset is UTF16BE, no need for a converter
+// nullptr unknown charset, do not attempt conversion
+const char*
+gfxFontUtils::GetCharsetForFontName(uint16_t aPlatform, uint16_t aScript, uint16_t aLanguage)
+{
+ switch (aPlatform)
+ {
+ case PLATFORM_ID_UNICODE:
+ return "";
+
+ case PLATFORM_ID_MAC:
+ {
+ MacFontNameCharsetMapping searchValue = { aScript, aLanguage, nullptr };
+ for (uint32_t i = 0; i < 2; ++i) {
+ size_t idx;
+ if (BinarySearchIf(gMacFontNameCharsets, 0, ArrayLength(gMacFontNameCharsets),
+ MacCharsetMappingComparator(searchValue), &idx)) {
+ return gMacFontNameCharsets[idx].mCharsetName;
+ }
+
+ // no match, so try again finding one in any language
+ searchValue.mLanguage = ANY;
+ }
+ }
+ break;
+
+ case PLATFORM_ID_ISO:
+ if (aScript < ArrayLength(gISOFontNameCharsets)) {
+ return gISOFontNameCharsets[aScript];
+ }
+ break;
+
+ case PLATFORM_ID_MICROSOFT:
+ if (aScript < ArrayLength(gMSFontNameCharsets)) {
+ return gMSFontNameCharsets[aScript];
+ }
+ break;
+ }
+
+ return nullptr;
+}
+
+// convert a raw name from the name table to an nsString, if possible;
+// return value indicates whether conversion succeeded
+bool
+gfxFontUtils::DecodeFontName(const char *aNameData, int32_t aByteLen,
+ uint32_t aPlatformCode, uint32_t aScriptCode,
+ uint32_t aLangCode, nsAString& aName)
+{
+ if (aByteLen <= 0) {
+ NS_WARNING("empty font name");
+ aName.SetLength(0);
+ return true;
+ }
+
+ const char *csName = GetCharsetForFontName(aPlatformCode, aScriptCode, aLangCode);
+
+ if (!csName) {
+ // nullptr -> unknown charset
+#ifdef DEBUG
+ char warnBuf[128];
+ if (aByteLen > 64)
+ aByteLen = 64;
+ SprintfLiteral(warnBuf, "skipping font name, unknown charset %d:%d:%d for <%.*s>",
+ aPlatformCode, aScriptCode, aLangCode, aByteLen, aNameData);
+ NS_WARNING(warnBuf);
+#endif
+ return false;
+ }
+
+ if (csName[0] == 0) {
+ // empty charset name: data is utf16be, no need to instantiate a converter
+ uint32_t strLen = aByteLen / 2;
+ aName.SetLength(strLen);
+#ifdef IS_LITTLE_ENDIAN
+ CopySwapUTF16(aNameData, reinterpret_cast<char*>(aName.BeginWriting()),
+ strLen);
+#else
+ memcpy(aName.BeginWriting(), aNameData, strLen * 2);
+#endif
+ return true;
+ }
+
+ nsCOMPtr<nsIUnicodeDecoder> decoder =
+ mozilla::dom::EncodingUtils::DecoderForEncoding(csName);
+ if (!decoder) {
+ NS_WARNING("failed to get the decoder for a font name string");
+ return false;
+ }
+
+ int32_t destLength;
+ nsresult rv = decoder->GetMaxLength(aNameData, aByteLen, &destLength);
+ if (NS_FAILED(rv)) {
+ NS_WARNING("decoder->GetMaxLength failed, invalid font name?");
+ return false;
+ }
+
+ // make space for the converted string
+ aName.SetLength(destLength);
+ rv = decoder->Convert(aNameData, &aByteLen,
+ aName.BeginWriting(), &destLength);
+ if (NS_FAILED(rv)) {
+ NS_WARNING("decoder->Convert failed, invalid font name?");
+ return false;
+ }
+ aName.Truncate(destLength); // set the actual length
+
+ return true;
+}
+
+nsresult
+gfxFontUtils::ReadNames(const char *aNameData, uint32_t aDataLen,
+ uint32_t aNameID,
+ int32_t aLangID, int32_t aPlatformID,
+ nsTArray<nsString>& aNames)
+{
+ NS_ASSERTION(aDataLen != 0, "null name table");
+
+ if (!aDataLen) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // -- name table data
+ const NameHeader *nameHeader = reinterpret_cast<const NameHeader*>(aNameData);
+
+ uint32_t nameCount = nameHeader->count;
+
+ // -- sanity check the number of name records
+ if (uint64_t(nameCount) * sizeof(NameRecord) > aDataLen) {
+ NS_WARNING("invalid font (name table data)");
+ return NS_ERROR_FAILURE;
+ }
+
+ // -- iterate through name records
+ const NameRecord *nameRecord
+ = reinterpret_cast<const NameRecord*>(aNameData + sizeof(NameHeader));
+ uint64_t nameStringsBase = uint64_t(nameHeader->stringOffset);
+
+ uint32_t i;
+ for (i = 0; i < nameCount; i++, nameRecord++) {
+ uint32_t platformID;
+
+ // skip over unwanted nameID's
+ if (uint32_t(nameRecord->nameID) != aNameID) {
+ continue;
+ }
+
+ // skip over unwanted platform data
+ platformID = nameRecord->platformID;
+ if (aPlatformID != PLATFORM_ALL &&
+ platformID != uint32_t(aPlatformID)) {
+ continue;
+ }
+
+ // skip over unwanted languages
+ if (aLangID != LANG_ALL &&
+ uint32_t(nameRecord->languageID) != uint32_t(aLangID)) {
+ continue;
+ }
+
+ // add name to names array
+
+ // -- calculate string location
+ uint32_t namelen = nameRecord->length;
+ uint32_t nameoff = nameRecord->offset; // offset from base of string storage
+
+ if (nameStringsBase + uint64_t(nameoff) + uint64_t(namelen)
+ > aDataLen) {
+ NS_WARNING("invalid font (name table strings)");
+ return NS_ERROR_FAILURE;
+ }
+
+ // -- decode if necessary and make nsString
+ nsAutoString name;
+
+ DecodeFontName(aNameData + nameStringsBase + nameoff, namelen,
+ platformID, uint32_t(nameRecord->encodingID),
+ uint32_t(nameRecord->languageID), name);
+
+ uint32_t k, numNames;
+ bool foundName = false;
+
+ numNames = aNames.Length();
+ for (k = 0; k < numNames; k++) {
+ if (name.Equals(aNames[k])) {
+ foundName = true;
+ break;
+ }
+ }
+
+ if (!foundName)
+ aNames.AppendElement(name);
+
+ }
+
+ return NS_OK;
+}
+
+#pragma pack(1)
+
+struct COLRBaseGlyphRecord {
+ AutoSwap_PRUint16 glyphId;
+ AutoSwap_PRUint16 firstLayerIndex;
+ AutoSwap_PRUint16 numLayers;
+};
+
+struct COLRLayerRecord {
+ AutoSwap_PRUint16 glyphId;
+ AutoSwap_PRUint16 paletteEntryIndex;
+};
+
+struct CPALColorRecord {
+ uint8_t blue;
+ uint8_t green;
+ uint8_t red;
+ uint8_t alpha;
+};
+
+#pragma pack()
+
+bool
+gfxFontUtils::ValidateColorGlyphs(hb_blob_t* aCOLR, hb_blob_t* aCPAL)
+{
+ unsigned int colrLength;
+ const COLRHeader* colr =
+ reinterpret_cast<const COLRHeader*>(hb_blob_get_data(aCOLR, &colrLength));
+ unsigned int cpalLength;
+ const CPALHeaderVersion0* cpal =
+ reinterpret_cast<const CPALHeaderVersion0*>(hb_blob_get_data(aCPAL, &cpalLength));
+
+ if (!colr || !cpal || !colrLength || !cpalLength) {
+ return false;
+ }
+
+ if (uint16_t(colr->version) != 0 || uint16_t(cpal->version) != 0) {
+ // We only support version 0 headers.
+ return false;
+ }
+
+ const uint32_t offsetBaseGlyphRecord = colr->offsetBaseGlyphRecord;
+ const uint16_t numBaseGlyphRecord = colr->numBaseGlyphRecord;
+ const uint32_t offsetLayerRecord = colr->offsetLayerRecord;
+ const uint16_t numLayerRecords = colr->numLayerRecords;
+
+ const uint32_t offsetFirstColorRecord = cpal->offsetFirstColorRecord;
+ const uint16_t numColorRecords = cpal->numColorRecords;
+ const uint32_t numPaletteEntries = cpal->numPaletteEntries;
+
+ if (offsetBaseGlyphRecord >= colrLength) {
+ return false;
+ }
+
+ if (offsetLayerRecord >= colrLength) {
+ return false;
+ }
+
+ if (offsetFirstColorRecord >= cpalLength) {
+ return false;
+ }
+
+ if (!numPaletteEntries) {
+ return false;
+ }
+
+ if (sizeof(COLRBaseGlyphRecord) * numBaseGlyphRecord >
+ colrLength - offsetBaseGlyphRecord) {
+ // COLR base glyph record will be overflow
+ return false;
+ }
+
+ if (sizeof(COLRLayerRecord) * numLayerRecords >
+ colrLength - offsetLayerRecord) {
+ // COLR layer record will be overflow
+ return false;
+ }
+
+ if (sizeof(CPALColorRecord) * numColorRecords >
+ cpalLength - offsetFirstColorRecord) {
+ // CPAL color record will be overflow
+ return false;
+ }
+
+ if (numPaletteEntries * uint16_t(cpal->numPalettes) != numColorRecords ) {
+ // palette of CPAL color record will be overflow.
+ return false;
+ }
+
+ uint16_t lastGlyphId = 0;
+ const COLRBaseGlyphRecord* baseGlyph =
+ reinterpret_cast<const COLRBaseGlyphRecord*>(
+ reinterpret_cast<const uint8_t*>(colr) + offsetBaseGlyphRecord);
+
+ for (uint16_t i = 0; i < numBaseGlyphRecord; i++, baseGlyph++) {
+ const uint32_t firstLayerIndex = baseGlyph->firstLayerIndex;
+ const uint16_t numLayers = baseGlyph->numLayers;
+ const uint16_t glyphId = baseGlyph->glyphId;
+
+ if (lastGlyphId && lastGlyphId >= glyphId) {
+ // glyphId must be sorted
+ return false;
+ }
+ lastGlyphId = glyphId;
+
+ if (!numLayers) {
+ // no layer
+ return false;
+ }
+ if (firstLayerIndex + numLayers > numLayerRecords) {
+ // layer length of target glyph is overflow
+ return false;
+ }
+ }
+
+ const COLRLayerRecord* layer =
+ reinterpret_cast<const COLRLayerRecord*>(
+ reinterpret_cast<const uint8_t*>(colr) + offsetLayerRecord);
+
+ for (uint16_t i = 0; i < numLayerRecords; i++, layer++) {
+ if (uint16_t(layer->paletteEntryIndex) >= numPaletteEntries &&
+ uint16_t(layer->paletteEntryIndex) != 0xFFFF) {
+ // CPAL palette entry record is overflow
+ return false;
+ }
+ }
+
+ return true;
+}
+
+static int
+CompareBaseGlyph(const void* key, const void* data)
+{
+ uint32_t glyphId = (uint32_t)(uintptr_t)key;
+ const COLRBaseGlyphRecord* baseGlyph =
+ reinterpret_cast<const COLRBaseGlyphRecord*>(data);
+ uint32_t baseGlyphId = uint16_t(baseGlyph->glyphId);
+
+ if (baseGlyphId == glyphId) {
+ return 0;
+ }
+
+ return baseGlyphId > glyphId ? -1 : 1;
+}
+
+static
+COLRBaseGlyphRecord*
+LookForBaseGlyphRecord(const COLRHeader* aCOLR, uint32_t aGlyphId)
+{
+ const uint8_t* baseGlyphRecords =
+ reinterpret_cast<const uint8_t*>(aCOLR) +
+ uint32_t(aCOLR->offsetBaseGlyphRecord);
+ // BaseGlyphRecord is sorted by glyphId
+ return reinterpret_cast<COLRBaseGlyphRecord*>(
+ bsearch((void*)(uintptr_t)aGlyphId,
+ baseGlyphRecords,
+ uint16_t(aCOLR->numBaseGlyphRecord),
+ sizeof(COLRBaseGlyphRecord),
+ CompareBaseGlyph));
+}
+
+bool
+gfxFontUtils::GetColorGlyphLayers(hb_blob_t* aCOLR,
+ hb_blob_t* aCPAL,
+ uint32_t aGlyphId,
+ const mozilla::gfx::Color& aDefaultColor,
+ nsTArray<uint16_t>& aGlyphs,
+ nsTArray<mozilla::gfx::Color>& aColors)
+{
+ unsigned int blobLength;
+ const COLRHeader* colr =
+ reinterpret_cast<const COLRHeader*>(hb_blob_get_data(aCOLR,
+ &blobLength));
+ MOZ_ASSERT(colr, "Cannot get COLR raw data");
+ MOZ_ASSERT(blobLength, "Found COLR data, but length is 0");
+
+ COLRBaseGlyphRecord* baseGlyph = LookForBaseGlyphRecord(colr, aGlyphId);
+ if (!baseGlyph) {
+ return false;
+ }
+
+ const CPALHeaderVersion0* cpal =
+ reinterpret_cast<const CPALHeaderVersion0*>(
+ hb_blob_get_data(aCPAL, &blobLength));
+ MOZ_ASSERT(cpal, "Cannot get CPAL raw data");
+ MOZ_ASSERT(blobLength, "Found CPAL data, but length is 0");
+
+ const COLRLayerRecord* layer =
+ reinterpret_cast<const COLRLayerRecord*>(
+ reinterpret_cast<const uint8_t*>(colr) +
+ uint32_t(colr->offsetLayerRecord) +
+ sizeof(COLRLayerRecord) * uint16_t(baseGlyph->firstLayerIndex));
+ const uint16_t numLayers = baseGlyph->numLayers;
+ const uint32_t offsetFirstColorRecord = cpal->offsetFirstColorRecord;
+
+ for (uint16_t layerIndex = 0; layerIndex < numLayers; layerIndex++) {
+ aGlyphs.AppendElement(uint16_t(layer->glyphId));
+ if (uint16_t(layer->paletteEntryIndex) == 0xFFFF) {
+ aColors.AppendElement(aDefaultColor);
+ } else {
+ const CPALColorRecord* color =
+ reinterpret_cast<const CPALColorRecord*>(
+ reinterpret_cast<const uint8_t*>(cpal) +
+ offsetFirstColorRecord +
+ sizeof(CPALColorRecord) * uint16_t(layer->paletteEntryIndex));
+ aColors.AppendElement(mozilla::gfx::Color(color->red / 255.0,
+ color->green / 255.0,
+ color->blue / 255.0,
+ color->alpha / 255.0));
+ }
+ layer++;
+ }
+ return true;
+}
+
+#ifdef XP_WIN
+
+/* static */
+bool
+gfxFontUtils::IsCffFont(const uint8_t* aFontData)
+{
+ // this is only called after aFontData has passed basic validation,
+ // so we know there is enough data present to allow us to read the version!
+ const SFNTHeader *sfntHeader = reinterpret_cast<const SFNTHeader*>(aFontData);
+ return (sfntHeader->sfntVersion == TRUETYPE_TAG('O','T','T','O'));
+}
+
+#endif
+
+#undef acceptablePlatform
+#undef isSymbol
+#undef isUVSEncoding
+#undef LOG
+#undef LOG_ENABLED