1 /* 2 ******************************************************************************* 3 * 4 * Copyright (C) 1999-2008, International Business Machines 5 * Corporation and others. All Rights Reserved. 6 * 7 ******************************************************************************* 8 * file name: PortableFontInstance.cpp 9 * 10 * created on: 11/22/1999 11 * created by: Eric R. Mader 12 */ 13 14 #include <stdio.h> 15 16 #include "layout/LETypes.h" 17 #include "layout/LEFontInstance.h" 18 #include "layout/LESwaps.h" 19 20 #include "PortableFontInstance.h" 21 22 #include "letest.h" 23 #include "sfnt.h" 24 25 #include <string.h> 26 27 // 28 // Finds the high bit by binary searching 29 // through the bits in n. 30 // 31 le_int8 PortableFontInstance::highBit(le_int32 value) 32 { 33 if (value <= 0) { 34 return -32; 35 } 36 37 le_uint8 bit = 0; 38 39 if (value >= 1 << 16) { 40 value >>= 16; 41 bit += 16; 42 } 43 44 if (value >= 1 << 8) { 45 value >>= 8; 46 bit += 8; 47 } 48 49 if (value >= 1 << 4) { 50 value >>= 4; 51 bit += 4; 52 } 53 54 if (value >= 1 << 2) { 55 value >>= 2; 56 bit += 2; 57 } 58 59 if (value >= 1 << 1) { 60 value >>= 1; 61 bit += 1; 62 } 63 64 return bit; 65 } 66 67 PortableFontInstance::PortableFontInstance(const char *fileName, float pointSize, LEErrorCode &status) 68 : fFile(NULL), fPointSize(pointSize), fUnitsPerEM(0), fFontChecksum(0), fAscent(0), fDescent(0), fLeading(0), 69 fDirectory(NULL), fNAMETable(NULL), fNameCount(0), fNameStringOffset(0), fCMAPMapper(NULL), fHMTXTable(NULL), fNumGlyphs(0), fNumLongHorMetrics(0) 70 { 71 if (LE_FAILURE(status)) { 72 return; 73 } 74 75 // open the font file 76 fFile = fopen(fileName, "rb"); 77 78 if (fFile == NULL) { 79 status = LE_FONT_FILE_NOT_FOUND_ERROR; 80 return; 81 } 82 83 // read in the directory 84 SFNTDirectory tempDir; 85 86 fread(&tempDir, sizeof tempDir, 1, fFile); 87 88 le_int32 dirSize = sizeof tempDir + ((SWAPW(tempDir.numTables) - ANY_NUMBER) * sizeof(DirectoryEntry)); 89 const LETag headTag = LE_HEAD_TABLE_TAG; 90 const LETag hheaTag = LE_HHEA_TABLE_TAG; 91 const HEADTable *headTable = NULL; 92 const HHEATable *hheaTable = NULL; 93 // const NAMETable *nameTable = NULL; 94 le_uint16 numTables = 0; 95 96 fDirectory = (const SFNTDirectory *) NEW_ARRAY(char, dirSize); 97 98 if (fDirectory == NULL) { 99 status = LE_MEMORY_ALLOCATION_ERROR; 100 goto error_exit; 101 } 102 103 fseek(fFile, 0L, SEEK_SET); 104 fread((void *) fDirectory, sizeof(char), dirSize, fFile); 105 106 // 107 // We calculate these numbers 'cause some fonts 108 // have bogus values for them in the directory header. 109 // 110 numTables = SWAPW(fDirectory->numTables); 111 fDirPower = 1 << highBit(numTables); 112 fDirExtra = numTables - fDirPower; 113 114 // read unitsPerEm from 'head' table 115 headTable = (const HEADTable *) readFontTable(headTag); 116 117 if (headTable == NULL) { 118 status = LE_MISSING_FONT_TABLE_ERROR; 119 goto error_exit; 120 } 121 122 fUnitsPerEM = SWAPW(headTable->unitsPerEm); 123 fFontChecksum = SWAPL(headTable->checksumAdjustment); 124 freeFontTable(headTable); 125 126 //nameTable = (NAMETable *) readFontTable(nameTag); 127 128 //if (nameTable == NULL) { 129 // status = LE_MISSING_FONT_TABLE_ERROR; 130 // goto error_exit; 131 //} 132 133 //fFontVersionString = findName(nameTable, NAME_VERSION_STRING, PLATFORM_MACINTOSH, MACINTOSH_ROMAN, MACINTOSH_ENGLISH); 134 135 //if (fFontVersionString == NULL) { 136 // status = LE_MISSING_FONT_TABLE_ERROR; 137 // goto error_exit; 138 //} 139 140 //freeFontTable(nameTable); 141 142 hheaTable = (HHEATable *) readFontTable(hheaTag); 143 144 if (hheaTable == NULL) { 145 status = LE_MISSING_FONT_TABLE_ERROR; 146 goto error_exit; 147 } 148 149 fAscent = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->ascent)); 150 fDescent = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->descent)); 151 fLeading = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->lineGap)); 152 153 fNumLongHorMetrics = SWAPW(hheaTable->numOfLongHorMetrics); 154 155 freeFontTable((void *) hheaTable); 156 157 fCMAPMapper = findUnicodeMapper(); 158 159 if (fCMAPMapper == NULL) { 160 status = LE_MISSING_FONT_TABLE_ERROR; 161 goto error_exit; 162 } 163 164 return; 165 166 error_exit: 167 fclose(fFile); 168 fFile = NULL; 169 return; 170 } 171 172 PortableFontInstance::~PortableFontInstance() 173 { 174 if (fFile != NULL) { 175 fclose(fFile); 176 177 freeFontTable(fHMTXTable); 178 freeFontTable(fNAMETable); 179 180 delete fCMAPMapper; 181 182 DELETE_ARRAY(fDirectory); 183 } 184 } 185 186 const DirectoryEntry *PortableFontInstance::findTable(LETag tag) const 187 { 188 if (fDirectory != NULL) { 189 le_uint16 table = 0; 190 le_uint16 probe = fDirPower; 191 192 if (SWAPL(fDirectory->tableDirectory[fDirExtra].tag) <= tag) { 193 table = fDirExtra; 194 } 195 196 while (probe > (1 << 0)) { 197 probe >>= 1; 198 199 if (SWAPL(fDirectory->tableDirectory[table + probe].tag) <= tag) { 200 table += probe; 201 } 202 } 203 204 if (SWAPL(fDirectory->tableDirectory[table].tag) == tag) { 205 return &fDirectory->tableDirectory[table]; 206 } 207 } 208 209 return NULL; 210 } 211 212 const void *PortableFontInstance::readTable(LETag tag, le_uint32 *length) const 213 { 214 const DirectoryEntry *entry = findTable(tag); 215 216 if (entry == NULL) { 217 *length = 0; 218 return NULL; 219 } 220 221 *length = SWAPL(entry->length); 222 223 void *table = NEW_ARRAY(char, *length); 224 225 if (table != NULL) { 226 fseek(fFile, SWAPL(entry->offset), SEEK_SET); 227 fread(table, sizeof(char), *length, fFile); 228 } 229 230 return table; 231 } 232 233 const void *PortableFontInstance::getFontTable(LETag tableTag) const 234 { 235 return FontTableCache::find(tableTag); 236 } 237 238 const void *PortableFontInstance::readFontTable(LETag tableTag) const 239 { 240 le_uint32 len; 241 242 return readTable(tableTag, &len); 243 } 244 245 CMAPMapper *PortableFontInstance::findUnicodeMapper() 246 { 247 LETag cmapTag = LE_CMAP_TABLE_TAG; 248 const CMAPTable *cmap = (CMAPTable *) readFontTable(cmapTag); 249 250 if (cmap == NULL) { 251 return NULL; 252 } 253 254 return CMAPMapper::createUnicodeMapper(cmap); 255 } 256 257 const char *PortableFontInstance::getNameString(le_uint16 nameID, le_uint16 platformID, le_uint16 encodingID, le_uint16 languageID) const 258 { 259 if (fNAMETable == NULL) { 260 LETag nameTag = LE_NAME_TABLE_TAG; 261 PortableFontInstance *realThis = (PortableFontInstance *) this; 262 263 realThis->fNAMETable = (const NAMETable *) readFontTable(nameTag); 264 265 if (realThis->fNAMETable != NULL) { 266 realThis->fNameCount = SWAPW(realThis->fNAMETable->count); 267 realThis->fNameStringOffset = SWAPW(realThis->fNAMETable->stringOffset); 268 } 269 } 270 271 for(le_int32 i = 0; i < fNameCount; i += 1) { 272 const NameRecord *nameRecord = &fNAMETable->nameRecords[i]; 273 274 if (SWAPW(nameRecord->platformID) == platformID && SWAPW(nameRecord->encodingID) == encodingID && 275 SWAPW(nameRecord->languageID) == languageID && SWAPW(nameRecord->nameID) == nameID) { 276 char *name = ((char *) fNAMETable) + fNameStringOffset + SWAPW(nameRecord->offset); 277 le_uint16 length = SWAPW(nameRecord->length); 278 char *result = NEW_ARRAY(char, length + 2); 279 280 ARRAY_COPY(result, name, length); 281 result[length] = result[length + 1] = 0; 282 283 return result; 284 } 285 } 286 287 return NULL; 288 } 289 290 const LEUnicode16 *PortableFontInstance::getUnicodeNameString(le_uint16 nameID, le_uint16 platformID, le_uint16 encodingID, le_uint16 languageID) const 291 { 292 if (fNAMETable == NULL) { 293 LETag nameTag = LE_NAME_TABLE_TAG; 294 PortableFontInstance *realThis = (PortableFontInstance *) this; 295 296 realThis->fNAMETable = (const NAMETable *) readFontTable(nameTag); 297 298 if (realThis->fNAMETable != NULL) { 299 realThis->fNameCount = SWAPW(realThis->fNAMETable->count); 300 realThis->fNameStringOffset = SWAPW(realThis->fNAMETable->stringOffset); 301 } 302 } 303 304 for(le_int32 i = 0; i < fNameCount; i += 1) { 305 const NameRecord *nameRecord = &fNAMETable->nameRecords[i]; 306 307 if (SWAPW(nameRecord->platformID) == platformID && SWAPW(nameRecord->encodingID) == encodingID && 308 SWAPW(nameRecord->languageID) == languageID && SWAPW(nameRecord->nameID) == nameID) { 309 LEUnicode16 *name = (LEUnicode16 *) (((char *) fNAMETable) + fNameStringOffset + SWAPW(nameRecord->offset)); 310 le_uint16 length = SWAPW(nameRecord->length) / 2; 311 LEUnicode16 *result = NEW_ARRAY(LEUnicode16, length + 2); 312 313 for (le_int32 c = 0; c < length; c += 1) { 314 result[c] = SWAPW(name[c]); 315 } 316 317 result[length] = 0; 318 319 return result; 320 } 321 } 322 323 return NULL; 324 } 325 326 void PortableFontInstance::deleteNameString(const char *name) const 327 { 328 DELETE_ARRAY(name); 329 } 330 331 void PortableFontInstance::deleteNameString(const LEUnicode16 *name) const 332 { 333 DELETE_ARRAY(name); 334 } 335 336 void PortableFontInstance::getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const 337 { 338 TTGlyphID ttGlyph = (TTGlyphID) LE_GET_GLYPH(glyph); 339 340 if (fHMTXTable == NULL) { 341 LETag maxpTag = LE_MAXP_TABLE_TAG; 342 LETag hmtxTag = LE_HMTX_TABLE_TAG; 343 const MAXPTable *maxpTable = (MAXPTable *) readFontTable(maxpTag); 344 PortableFontInstance *realThis = (PortableFontInstance *) this; 345 346 if (maxpTable != NULL) { 347 realThis->fNumGlyphs = SWAPW(maxpTable->numGlyphs); 348 freeFontTable(maxpTable); 349 } 350 351 realThis->fHMTXTable = (const HMTXTable *) readFontTable(hmtxTag); 352 } 353 354 le_uint16 index = ttGlyph; 355 356 if (ttGlyph >= fNumGlyphs || fHMTXTable == NULL) { 357 advance.fX = advance.fY = 0; 358 return; 359 } 360 361 if (ttGlyph >= fNumLongHorMetrics) { 362 index = fNumLongHorMetrics - 1; 363 } 364 365 advance.fX = xUnitsToPoints(SWAPW(fHMTXTable->hMetrics[index].advanceWidth)); 366 advance.fY = 0; 367 } 368 369 le_bool PortableFontInstance::getGlyphPoint(LEGlyphID /*glyph*/, le_int32 /*pointNumber*/, LEPoint &/*point*/) const 370 { 371 return FALSE; 372 } 373 374 le_int32 PortableFontInstance::getUnitsPerEM() const 375 { 376 return fUnitsPerEM; 377 } 378 379 le_uint32 PortableFontInstance::getFontChecksum() const 380 { 381 return fFontChecksum; 382 } 383 384 le_int32 PortableFontInstance::getAscent() const 385 { 386 return fAscent; 387 } 388 389 le_int32 PortableFontInstance::getDescent() const 390 { 391 return fDescent; 392 } 393 394 le_int32 PortableFontInstance::getLeading() const 395 { 396 return fLeading; 397 } 398 399 // We really want to inherit this method from the superclass, but some compilers 400 // issue a warning if we don't implement it... 401 LEGlyphID PortableFontInstance::mapCharToGlyph(LEUnicode32 ch, const LECharMapper *mapper, le_bool filterZeroWidth) const 402 { 403 return LEFontInstance::mapCharToGlyph(ch, mapper, filterZeroWidth); 404 } 405 406 // We really want to inherit this method from the superclass, but some compilers 407 // issue a warning if we don't implement it... 408 LEGlyphID PortableFontInstance::mapCharToGlyph(LEUnicode32 ch, const LECharMapper *mapper) const 409 { 410 return LEFontInstance::mapCharToGlyph(ch, mapper); 411 } 412 413 LEGlyphID PortableFontInstance::mapCharToGlyph(LEUnicode32 ch) const 414 { 415 return fCMAPMapper->unicodeToGlyph(ch); 416 } 417 418 float PortableFontInstance::getXPixelsPerEm() const 419 { 420 return fPointSize; 421 } 422 423 float PortableFontInstance::getYPixelsPerEm() const 424 { 425 return fPointSize; 426 } 427 428 float PortableFontInstance::getScaleFactorX() const 429 { 430 return 1.0; 431 } 432 433 float PortableFontInstance::getScaleFactorY() const 434 { 435 return 1.0; 436 } 437
