The Tor Browser / file comparison
comparison: gfx/skia/trunk/src/sfnt/SkOTUtils.cpp
gfx/skia/trunk/src/sfnt/SkOTUtils.cpp
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
equal
deleted
inserted
replaced
| -1:000000000000 | 0:4f4e23c7ee15 |
|---|---|
| 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 | |
| 8 #include "SkData.h" | |
| 9 #include "SkEndian.h" | |
| 10 #include "SkSFNTHeader.h" | |
| 11 #include "SkStream.h" | |
| 12 #include "SkOTTable_head.h" | |
| 13 #include "SkOTTable_name.h" | |
| 14 #include "SkOTTableTypes.h" | |
| 15 #include "SkOTUtils.h" | |
| 16 | |
| 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 | |
| 24 0x0,0x0, //SkOTTableGlyphDataInstructions::length | |
| 25 }; | |
| 26 | |
| 27 uint32_t SkOTUtils::CalcTableChecksum(SK_OT_ULONG *data, size_t length) { | |
| 28 uint32_t sum = 0; | |
| 29 SK_OT_ULONG *dataEnd = data + ((length + 3) & ~3) / sizeof(SK_OT_ULONG); | |
| 30 for (; data < dataEnd; ++data) { | |
| 31 sum += SkEndian_SwapBE32(*data); | |
| 32 } | |
| 33 return sum; | |
| 34 } | |
| 35 | |
| 36 SkData* SkOTUtils::RenameFont(SkStream* fontData, const char* fontName, int fontNameLen) { | |
| 37 | |
| 38 // Get the sfnt header. | |
| 39 SkSFNTHeader sfntHeader; | |
| 40 if (fontData->read(&sfntHeader, sizeof(sfntHeader)) < sizeof(sfntHeader)) { | |
| 41 return NULL; | |
| 42 } | |
| 43 | |
| 44 // Find the existing 'name' table. | |
| 45 int tableIndex; | |
| 46 SkSFNTHeader::TableDirectoryEntry tableEntry; | |
| 47 int numTables = SkEndian_SwapBE16(sfntHeader.numTables); | |
| 48 for (tableIndex = 0; tableIndex < numTables; ++tableIndex) { | |
| 49 if (fontData->read(&tableEntry, sizeof(tableEntry)) < sizeof(tableEntry)) { | |
| 50 return NULL; | |
| 51 } | |
| 52 if (SkOTTableName::TAG == tableEntry.tag) { | |
| 53 break; | |
| 54 } | |
| 55 } | |
| 56 if (tableIndex == numTables) { | |
| 57 return NULL; | |
| 58 } | |
| 59 | |
| 60 if (!fontData->rewind()) { | |
| 61 return NULL; | |
| 62 } | |
| 63 | |
| 64 // The required 'name' record types: Family, Style, Unique, Full and PostScript. | |
| 65 const SkOTTableName::Record::NameID::Predefined::Value namesToCreate[] = { | |
| 66 SkOTTableName::Record::NameID::Predefined::FontFamilyName, | |
| 67 SkOTTableName::Record::NameID::Predefined::FontSubfamilyName, | |
| 68 SkOTTableName::Record::NameID::Predefined::UniqueFontIdentifier, | |
| 69 SkOTTableName::Record::NameID::Predefined::FullFontName, | |
| 70 SkOTTableName::Record::NameID::Predefined::PostscriptName, | |
| 71 }; | |
| 72 const int namesCount = SK_ARRAY_COUNT(namesToCreate); | |
| 73 | |
| 74 // Copy the data, leaving out the old name table. | |
| 75 // In theory, we could also remove the DSIG table if it exists. | |
| 76 size_t nameTableLogicalSize = sizeof(SkOTTableName) + (namesCount * sizeof(SkOTTableName::Record)) + (fontNameLen * sizeof(wchar_t)); | |
| 77 size_t nameTablePhysicalSize = (nameTableLogicalSize + 3) & ~3; // Rounded up to a multiple of 4. | |
| 78 | |
| 79 size_t oldNameTablePhysicalSize = (SkEndian_SwapBE32(tableEntry.logicalLength) + 3) & ~3; // Rounded up to a multiple of 4. | |
| 80 size_t oldNameTableOffset = SkEndian_SwapBE32(tableEntry.offset); | |
| 81 | |
| 82 //originalDataSize is the size of the original data without the name table. | |
| 83 size_t originalDataSize = fontData->getLength() - oldNameTablePhysicalSize; | |
| 84 size_t newDataSize = originalDataSize + nameTablePhysicalSize; | |
| 85 | |
| 86 SK_OT_BYTE* data = static_cast<SK_OT_BYTE*>(sk_malloc_throw(newDataSize)); | |
| 87 SkAutoTUnref<SkData> rewrittenFontData(SkData::NewFromMalloc(data, newDataSize)); | |
| 88 | |
| 89 if (fontData->read(data, oldNameTableOffset) < oldNameTableOffset) { | |
| 90 return NULL; | |
| 91 } | |
| 92 if (fontData->skip(oldNameTablePhysicalSize) < oldNameTablePhysicalSize) { | |
| 93 return NULL; | |
| 94 } | |
| 95 if (fontData->read(data + oldNameTableOffset, originalDataSize - oldNameTableOffset) < originalDataSize - oldNameTableOffset) { | |
| 96 return NULL; | |
| 97 } | |
| 98 | |
| 99 //Fix up the offsets of the directory entries after the old 'name' table entry. | |
| 100 SkSFNTHeader::TableDirectoryEntry* currentEntry = reinterpret_cast<SkSFNTHeader::TableDirectoryEntry*>(data + sizeof(SkSFNTHeader)); | |
| 101 SkSFNTHeader::TableDirectoryEntry* endEntry = currentEntry + numTables; | |
| 102 SkSFNTHeader::TableDirectoryEntry* headTableEntry = NULL; | |
| 103 for (; currentEntry < endEntry; ++currentEntry) { | |
| 104 uint32_t oldOffset = SkEndian_SwapBE32(currentEntry->offset); | |
| 105 if (oldOffset > oldNameTableOffset) { | |
| 106 currentEntry->offset = SkEndian_SwapBE32(oldOffset - oldNameTablePhysicalSize); | |
| 107 } | |
| 108 if (SkOTTableHead::TAG == currentEntry->tag) { | |
| 109 headTableEntry = currentEntry; | |
| 110 } | |
| 111 } | |
| 112 | |
| 113 // Make the table directory entry point to the new 'name' table. | |
| 114 SkSFNTHeader::TableDirectoryEntry* nameTableEntry = reinterpret_cast<SkSFNTHeader::TableDirectoryEntry*>(data + sizeof(SkSFNTHeader)) + tableIndex; | |
| 115 nameTableEntry->logicalLength = SkEndian_SwapBE32(nameTableLogicalSize); | |
| 116 nameTableEntry->offset = SkEndian_SwapBE32(originalDataSize); | |
| 117 | |
| 118 // Write the new 'name' table after the original font data. | |
| 119 SkOTTableName* nameTable = reinterpret_cast<SkOTTableName*>(data + originalDataSize); | |
| 120 unsigned short stringOffset = sizeof(SkOTTableName) + (namesCount * sizeof(SkOTTableName::Record)); | |
| 121 nameTable->format = SkOTTableName::format_0; | |
| 122 nameTable->count = SkEndian_SwapBE16(namesCount); | |
| 123 nameTable->stringOffset = SkEndian_SwapBE16(stringOffset); | |
| 124 | |
| 125 SkOTTableName::Record* nameRecords = reinterpret_cast<SkOTTableName::Record*>(data + originalDataSize + sizeof(SkOTTableName)); | |
| 126 for (int i = 0; i < namesCount; ++i) { | |
| 127 nameRecords[i].platformID.value = SkOTTableName::Record::PlatformID::Windows; | |
| 128 nameRecords[i].encodingID.windows.value = SkOTTableName::Record::EncodingID::Windows::UnicodeBMPUCS2; | |
| 129 nameRecords[i].languageID.windows.value = SkOTTableName::Record::LanguageID::Windows::English_UnitedStates; | |
| 130 nameRecords[i].nameID.predefined.value = namesToCreate[i]; | |
| 131 nameRecords[i].offset = SkEndian_SwapBE16(0); | |
| 132 nameRecords[i].length = SkEndian_SwapBE16(fontNameLen * sizeof(wchar_t)); | |
| 133 } | |
| 134 | |
| 135 SK_OT_USHORT* nameString = reinterpret_cast<SK_OT_USHORT*>(data + originalDataSize + stringOffset); | |
| 136 for (int i = 0; i < fontNameLen; ++i) { | |
| 137 nameString[i] = SkEndian_SwapBE16(fontName[i]); | |
| 138 } | |
| 139 | |
| 140 unsigned char* logical = data + originalDataSize + nameTableLogicalSize; | |
| 141 unsigned char* physical = data + originalDataSize + nameTablePhysicalSize; | |
| 142 for (; logical < physical; ++logical) { | |
| 143 *logical = 0; | |
| 144 } | |
| 145 | |
| 146 // Update the table checksum in the directory entry. | |
| 147 nameTableEntry->checksum = SkEndian_SwapBE32(SkOTUtils::CalcTableChecksum(reinterpret_cast<SK_OT_ULONG*>(nameTable), nameTableLogicalSize)); | |
| 148 | |
| 149 // Update the checksum adjustment in the head table. | |
| 150 if (headTableEntry) { | |
| 151 size_t headTableOffset = SkEndian_SwapBE32(headTableEntry->offset); | |
| 152 if (headTableOffset + sizeof(SkOTTableHead) < originalDataSize) { | |
| 153 SkOTTableHead* headTable = reinterpret_cast<SkOTTableHead*>(data + headTableOffset); | |
| 154 headTable->checksumAdjustment = SkEndian_SwapBE32(0); | |
| 155 uint32_t unadjustedFontChecksum = SkOTUtils::CalcTableChecksum(reinterpret_cast<SK_OT_ULONG*>(data), originalDataSize + nameTablePhysicalSize); | |
| 156 headTable->checksumAdjustment = SkEndian_SwapBE32(SkOTTableHead::fontChecksum - unadjustedFontChecksum); | |
| 157 } | |
| 158 } | |
| 159 | |
| 160 return rewrittenFontData.detach(); | |
| 161 } | |
| 162 | |
| 163 | |
| 164 SkOTUtils::LocalizedStrings_NameTable* | |
| 165 SkOTUtils::LocalizedStrings_NameTable::CreateForFamilyNames(const SkTypeface& typeface) { | |
| 166 static const SkFontTableTag nameTag = SkSetFourByteTag('n','a','m','e'); | |
| 167 size_t nameTableSize = typeface.getTableSize(nameTag); | |
| 168 if (0 == nameTableSize) { | |
| 169 return NULL; | |
| 170 } | |
| 171 SkAutoTDeleteArray<uint8_t> nameTableData(new uint8_t[nameTableSize]); | |
| 172 size_t copied = typeface.getTableData(nameTag, 0, nameTableSize, nameTableData.get()); | |
| 173 if (copied != nameTableSize) { | |
| 174 return NULL; | |
| 175 } | |
| 176 | |
| 177 return new SkOTUtils::LocalizedStrings_NameTable((SkOTTableName*)nameTableData.detach(), | |
| 178 SkOTUtils::LocalizedStrings_NameTable::familyNameTypes, | |
| 179 SK_ARRAY_COUNT(SkOTUtils::LocalizedStrings_NameTable::familyNameTypes)); | |
| 180 } | |
| 181 | |
| 182 bool SkOTUtils::LocalizedStrings_NameTable::next(SkTypeface::LocalizedString* localizedString) { | |
| 183 do { | |
| 184 SkOTTableName::Iterator::Record record; | |
| 185 if (fFamilyNameIter.next(record)) { | |
| 186 localizedString->fString = record.name; | |
| 187 localizedString->fLanguage = record.language; | |
| 188 return true; | |
| 189 } | |
| 190 if (fTypesCount == fTypesIndex + 1) { | |
| 191 return false; | |
| 192 } | |
| 193 ++fTypesIndex; | |
| 194 fFamilyNameIter.reset(fTypes[fTypesIndex]); | |
| 195 } while (true); | |
| 196 } | |
| 197 | |
| 198 SkOTTableName::Record::NameID::Predefined::Value | |
| 199 SkOTUtils::LocalizedStrings_NameTable::familyNameTypes[3] = { | |
| 200 SkOTTableName::Record::NameID::Predefined::FontFamilyName, | |
| 201 SkOTTableName::Record::NameID::Predefined::PreferredFamily, | |
| 202 SkOTTableName::Record::NameID::Predefined::WWSFamilyName, | |
| 203 }; |
