SkOTUtils.cpp 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228
  1. /*
  2. * Copyright 2012 Google Inc.
  3. *
  4. * Use of this source code is governed by a BSD-style license that can be
  5. * found in the LICENSE file.
  6. */
  7. #include "src/sfnt/SkOTUtils.h"
  8. #include "include/core/SkData.h"
  9. #include "include/core/SkStream.h"
  10. #include "include/private/SkTo.h"
  11. #include "src/core/SkAdvancedTypefaceMetrics.h"
  12. #include "src/core/SkEndian.h"
  13. #include "src/sfnt/SkOTTableTypes.h"
  14. #include "src/sfnt/SkOTTable_head.h"
  15. #include "src/sfnt/SkOTTable_name.h"
  16. #include "src/sfnt/SkSFNTHeader.h"
  17. extern const uint8_t SK_OT_GlyphData_NoOutline[] = {
  18. 0x0,0x0, //SkOTTableGlyphData::numberOfContours
  19. 0x0,0x0, //SkOTTableGlyphData::xMin
  20. 0x0,0x0, //SkOTTableGlyphData::yMin
  21. 0x0,0x0, //SkOTTableGlyphData::xMax
  22. 0x0,0x0, //SkOTTableGlyphData::yMax
  23. 0x0,0x0, //SkOTTableGlyphDataInstructions::length
  24. };
  25. uint32_t SkOTUtils::CalcTableChecksum(SK_OT_ULONG *data, size_t length) {
  26. uint32_t sum = 0;
  27. SK_OT_ULONG *dataEnd = data + ((length + 3) & ~3) / sizeof(SK_OT_ULONG);
  28. for (; data < dataEnd; ++data) {
  29. sum += SkEndian_SwapBE32(*data);
  30. }
  31. return sum;
  32. }
  33. SkData* SkOTUtils::RenameFont(SkStreamAsset* fontData, const char* fontName, int fontNameLen) {
  34. // Get the sfnt header.
  35. SkSFNTHeader sfntHeader;
  36. if (fontData->read(&sfntHeader, sizeof(sfntHeader)) < sizeof(sfntHeader)) {
  37. return nullptr;
  38. }
  39. // Find the existing 'name' table.
  40. int tableIndex;
  41. SkSFNTHeader::TableDirectoryEntry tableEntry;
  42. int numTables = SkEndian_SwapBE16(sfntHeader.numTables);
  43. for (tableIndex = 0; tableIndex < numTables; ++tableIndex) {
  44. if (fontData->read(&tableEntry, sizeof(tableEntry)) < sizeof(tableEntry)) {
  45. return nullptr;
  46. }
  47. if (SkOTTableName::TAG == tableEntry.tag) {
  48. break;
  49. }
  50. }
  51. if (tableIndex == numTables) {
  52. return nullptr;
  53. }
  54. if (!fontData->rewind()) {
  55. return nullptr;
  56. }
  57. // The required 'name' record types: Family, Style, Unique, Full and PostScript.
  58. const SkOTTableName::Record::NameID::Predefined::Value namesToCreate[] = {
  59. SkOTTableName::Record::NameID::Predefined::FontFamilyName,
  60. SkOTTableName::Record::NameID::Predefined::FontSubfamilyName,
  61. SkOTTableName::Record::NameID::Predefined::UniqueFontIdentifier,
  62. SkOTTableName::Record::NameID::Predefined::FullFontName,
  63. SkOTTableName::Record::NameID::Predefined::PostscriptName,
  64. };
  65. const int namesCount = SK_ARRAY_COUNT(namesToCreate);
  66. // Copy the data, leaving out the old name table.
  67. // In theory, we could also remove the DSIG table if it exists.
  68. size_t nameTableLogicalSize = sizeof(SkOTTableName) + (namesCount * sizeof(SkOTTableName::Record)) + (fontNameLen * sizeof(wchar_t));
  69. size_t nameTablePhysicalSize = (nameTableLogicalSize + 3) & ~3; // Rounded up to a multiple of 4.
  70. size_t oldNameTablePhysicalSize = (SkEndian_SwapBE32(tableEntry.logicalLength) + 3) & ~3; // Rounded up to a multiple of 4.
  71. size_t oldNameTableOffset = SkEndian_SwapBE32(tableEntry.offset);
  72. //originalDataSize is the size of the original data without the name table.
  73. size_t originalDataSize = fontData->getLength() - oldNameTablePhysicalSize;
  74. size_t newDataSize = originalDataSize + nameTablePhysicalSize;
  75. auto rewrittenFontData = SkData::MakeUninitialized(newDataSize);
  76. SK_OT_BYTE* data = static_cast<SK_OT_BYTE*>(rewrittenFontData->writable_data());
  77. if (fontData->read(data, oldNameTableOffset) < oldNameTableOffset) {
  78. return nullptr;
  79. }
  80. if (fontData->skip(oldNameTablePhysicalSize) < oldNameTablePhysicalSize) {
  81. return nullptr;
  82. }
  83. if (fontData->read(data + oldNameTableOffset, originalDataSize - oldNameTableOffset) < originalDataSize - oldNameTableOffset) {
  84. return nullptr;
  85. }
  86. //Fix up the offsets of the directory entries after the old 'name' table entry.
  87. SkSFNTHeader::TableDirectoryEntry* currentEntry = reinterpret_cast<SkSFNTHeader::TableDirectoryEntry*>(data + sizeof(SkSFNTHeader));
  88. SkSFNTHeader::TableDirectoryEntry* endEntry = currentEntry + numTables;
  89. SkSFNTHeader::TableDirectoryEntry* headTableEntry = nullptr;
  90. for (; currentEntry < endEntry; ++currentEntry) {
  91. uint32_t oldOffset = SkEndian_SwapBE32(currentEntry->offset);
  92. if (oldOffset > oldNameTableOffset) {
  93. currentEntry->offset = SkEndian_SwapBE32(SkToU32(oldOffset - oldNameTablePhysicalSize));
  94. }
  95. if (SkOTTableHead::TAG == currentEntry->tag) {
  96. headTableEntry = currentEntry;
  97. }
  98. }
  99. // Make the table directory entry point to the new 'name' table.
  100. SkSFNTHeader::TableDirectoryEntry* nameTableEntry = reinterpret_cast<SkSFNTHeader::TableDirectoryEntry*>(data + sizeof(SkSFNTHeader)) + tableIndex;
  101. nameTableEntry->logicalLength = SkEndian_SwapBE32(SkToU32(nameTableLogicalSize));
  102. nameTableEntry->offset = SkEndian_SwapBE32(SkToU32(originalDataSize));
  103. // Write the new 'name' table after the original font data.
  104. SkOTTableName* nameTable = reinterpret_cast<SkOTTableName*>(data + originalDataSize);
  105. unsigned short stringOffset = sizeof(SkOTTableName) + (namesCount * sizeof(SkOTTableName::Record));
  106. nameTable->format = SkOTTableName::format_0;
  107. nameTable->count = SkEndian_SwapBE16(namesCount);
  108. nameTable->stringOffset = SkEndian_SwapBE16(stringOffset);
  109. SkOTTableName::Record* nameRecords = reinterpret_cast<SkOTTableName::Record*>(data + originalDataSize + sizeof(SkOTTableName));
  110. for (int i = 0; i < namesCount; ++i) {
  111. nameRecords[i].platformID.value = SkOTTableName::Record::PlatformID::Windows;
  112. nameRecords[i].encodingID.windows.value = SkOTTableName::Record::EncodingID::Windows::UnicodeBMPUCS2;
  113. nameRecords[i].languageID.windows.value = SkOTTableName::Record::LanguageID::Windows::English_UnitedStates;
  114. nameRecords[i].nameID.predefined.value = namesToCreate[i];
  115. nameRecords[i].offset = SkEndian_SwapBE16(0);
  116. nameRecords[i].length = SkEndian_SwapBE16(SkToU16(fontNameLen * sizeof(wchar_t)));
  117. }
  118. SK_OT_USHORT* nameString = reinterpret_cast<SK_OT_USHORT*>(data + originalDataSize + stringOffset);
  119. for (int i = 0; i < fontNameLen; ++i) {
  120. nameString[i] = SkEndian_SwapBE16(fontName[i]);
  121. }
  122. unsigned char* logical = data + originalDataSize + nameTableLogicalSize;
  123. unsigned char* physical = data + originalDataSize + nameTablePhysicalSize;
  124. for (; logical < physical; ++logical) {
  125. *logical = 0;
  126. }
  127. // Update the table checksum in the directory entry.
  128. nameTableEntry->checksum = SkEndian_SwapBE32(SkOTUtils::CalcTableChecksum(reinterpret_cast<SK_OT_ULONG*>(nameTable), nameTableLogicalSize));
  129. // Update the checksum adjustment in the head table.
  130. if (headTableEntry) {
  131. size_t headTableOffset = SkEndian_SwapBE32(headTableEntry->offset);
  132. if (headTableOffset + sizeof(SkOTTableHead) < originalDataSize) {
  133. SkOTTableHead* headTable = reinterpret_cast<SkOTTableHead*>(data + headTableOffset);
  134. headTable->checksumAdjustment = SkEndian_SwapBE32(0);
  135. uint32_t unadjustedFontChecksum = SkOTUtils::CalcTableChecksum(reinterpret_cast<SK_OT_ULONG*>(data), originalDataSize + nameTablePhysicalSize);
  136. headTable->checksumAdjustment = SkEndian_SwapBE32(SkOTTableHead::fontChecksum - unadjustedFontChecksum);
  137. }
  138. }
  139. return rewrittenFontData.release();
  140. }
  141. sk_sp<SkOTUtils::LocalizedStrings_NameTable>
  142. SkOTUtils::LocalizedStrings_NameTable::Make(const SkTypeface& typeface,
  143. SK_OT_USHORT types[],
  144. int typesCount)
  145. {
  146. static const SkFontTableTag nameTag = SkSetFourByteTag('n','a','m','e');
  147. size_t nameTableSize = typeface.getTableSize(nameTag);
  148. if (0 == nameTableSize) {
  149. return nullptr;
  150. }
  151. std::unique_ptr<uint8_t[]> nameTableData(new uint8_t[nameTableSize]);
  152. size_t copied = typeface.getTableData(nameTag, 0, nameTableSize, nameTableData.get());
  153. if (copied != nameTableSize) {
  154. return nullptr;
  155. }
  156. return sk_sp<SkOTUtils::LocalizedStrings_NameTable>(
  157. new SkOTUtils::LocalizedStrings_NameTable(std::move(nameTableData), nameTableSize,
  158. types, typesCount));
  159. }
  160. sk_sp<SkOTUtils::LocalizedStrings_NameTable>
  161. SkOTUtils::LocalizedStrings_NameTable::MakeForFamilyNames(const SkTypeface& typeface) {
  162. return Make(typeface,
  163. SkOTUtils::LocalizedStrings_NameTable::familyNameTypes,
  164. SK_ARRAY_COUNT(SkOTUtils::LocalizedStrings_NameTable::familyNameTypes));
  165. }
  166. bool SkOTUtils::LocalizedStrings_NameTable::next(SkTypeface::LocalizedString* localizedString) {
  167. do {
  168. SkOTTableName::Iterator::Record record;
  169. if (fFamilyNameIter.next(record)) {
  170. localizedString->fString = record.name;
  171. localizedString->fLanguage = record.language;
  172. return true;
  173. }
  174. if (fTypesCount == fTypesIndex + 1) {
  175. return false;
  176. }
  177. ++fTypesIndex;
  178. fFamilyNameIter.reset(fTypes[fTypesIndex]);
  179. } while (true);
  180. }
  181. SK_OT_USHORT SkOTUtils::LocalizedStrings_NameTable::familyNameTypes[3] = {
  182. SkOTTableName::Record::NameID::Predefined::FontFamilyName,
  183. SkOTTableName::Record::NameID::Predefined::PreferredFamily,
  184. SkOTTableName::Record::NameID::Predefined::WWSFamilyName,
  185. };
  186. void SkOTUtils::SetAdvancedTypefaceFlags(SkOTTableOS2_V4::Type fsType,
  187. SkAdvancedTypefaceMetrics* info) {
  188. SkASSERT(info);
  189. // The logic should be identical to SkTypeface_FreeType::onGetAdvancedMetrics().
  190. if (fsType.raw.value != 0) {
  191. if (SkToBool(fsType.field.Restricted) || SkToBool(fsType.field.Bitmap)) {
  192. info->fFlags |= SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag;
  193. }
  194. if (SkToBool(fsType.field.NoSubsetting)) {
  195. info->fFlags |= SkAdvancedTypefaceMetrics::kNotSubsettable_FontFlag;
  196. }
  197. }
  198. }