1 /* 2 * (C) Copyright IBM Corp. 1998-2008 - All Rights Reserved 3 * 4 */ 5 6 #include "LETypes.h" 7 #include "LEFontInstance.h" 8 #include "OpenTypeTables.h" 9 #include "GlyphSubstitutionTables.h" 10 #include "ContextualSubstSubtables.h" 11 #include "GlyphIterator.h" 12 #include "LookupProcessor.h" 13 #include "CoverageTables.h" 14 #include "LESwaps.h" 15 16 U_NAMESPACE_BEGIN 17 18 /* 19 NOTE: This could be optimized somewhat by keeping track 20 of the previous sequenceIndex in the loop and doing next() 21 or prev() of the delta between that and the current 22 sequenceIndex instead of always resetting to the front. 23 */ 24 void ContextualSubstitutionBase::applySubstitutionLookups( 25 const LookupProcessor *lookupProcessor, 26 const SubstitutionLookupRecord *substLookupRecordArray, 27 le_uint16 substCount, 28 GlyphIterator *glyphIterator, 29 const LEFontInstance *fontInstance, 30 le_int32 position, 31 LEErrorCode& success) 32 { 33 if (LE_FAILURE(success)) { 34 return; 35 } 36 37 GlyphIterator tempIterator(*glyphIterator); 38 39 for (le_int16 subst = 0; subst < substCount && LE_SUCCESS(success); subst += 1) { 40 le_uint16 sequenceIndex = SWAPW(substLookupRecordArray[subst].sequenceIndex); 41 le_uint16 lookupListIndex = SWAPW(substLookupRecordArray[subst].lookupListIndex); 42 43 tempIterator.setCurrStreamPosition(position); 44 tempIterator.next(sequenceIndex); 45 46 lookupProcessor->applySingleLookup(lookupListIndex, &tempIterator, fontInstance, success); 47 } 48 } 49 50 le_bool ContextualSubstitutionBase::matchGlyphIDs(const TTGlyphID *glyphArray, le_uint16 glyphCount, 51 GlyphIterator *glyphIterator, le_bool backtrack) 52 { 53 le_int32 direction = 1; 54 le_int32 match = 0; 55 56 if (backtrack) { 57 match = glyphCount -1; 58 direction = -1; 59 } 60 61 while (glyphCount > 0) { 62 if (! glyphIterator->next()) { 63 return FALSE; 64 } 65 66 TTGlyphID glyph = (TTGlyphID) glyphIterator->getCurrGlyphID(); 67 68 if (glyph != SWAPW(glyphArray[match])) { 69 return FALSE; 70 } 71 72 glyphCount -= 1; 73 match += direction; 74 } 75 76 return TRUE; 77 } 78 79 le_bool ContextualSubstitutionBase::matchGlyphClasses(const le_uint16 *classArray, le_uint16 glyphCount, 80 GlyphIterator *glyphIterator, 81 const ClassDefinitionTable *classDefinitionTable, 82 le_bool backtrack) 83 { 84 le_int32 direction = 1; 85 le_int32 match = 0; 86 87 if (backtrack) { 88 match = glyphCount - 1; 89 direction = -1; 90 } 91 92 while (glyphCount > 0) { 93 if (! glyphIterator->next()) { 94 return FALSE; 95 } 96 97 LEGlyphID glyph = glyphIterator->getCurrGlyphID(); 98 le_int32 glyphClass = classDefinitionTable->getGlyphClass(glyph); 99 le_int32 matchClass = SWAPW(classArray[match]); 100 101 if (glyphClass != matchClass) { 102 // Some fonts, e.g. Traditional Arabic, have classes 103 // in the class array which aren't in the class definition 104 // table. If we're looking for such a class, pretend that 105 // we found it. 106 if (classDefinitionTable->hasGlyphClass(matchClass)) { 107 return FALSE; 108 } 109 } 110 111 glyphCount -= 1; 112 match += direction; 113 } 114 115 return TRUE; 116 } 117 118 le_bool ContextualSubstitutionBase::matchGlyphCoverages(const Offset *coverageTableOffsetArray, le_uint16 glyphCount, 119 GlyphIterator *glyphIterator, const char *offsetBase, le_bool backtrack) 120 { 121 le_int32 direction = 1; 122 le_int32 glyph = 0; 123 124 if (backtrack) { 125 glyph = glyphCount - 1; 126 direction = -1; 127 } 128 129 while (glyphCount > 0) { 130 Offset coverageTableOffset = SWAPW(coverageTableOffsetArray[glyph]); 131 const CoverageTable *coverageTable = (const CoverageTable *) (offsetBase + coverageTableOffset); 132 133 if (! glyphIterator->next()) { 134 return FALSE; 135 } 136 137 if (coverageTable->getGlyphCoverage((LEGlyphID) glyphIterator->getCurrGlyphID()) < 0) { 138 return FALSE; 139 } 140 141 glyphCount -= 1; 142 glyph += direction; 143 } 144 145 return TRUE; 146 } 147 148 le_uint32 ContextualSubstitutionSubtable::process(const LookupProcessor *lookupProcessor, 149 GlyphIterator *glyphIterator, 150 const LEFontInstance *fontInstance, 151 LEErrorCode& success) const 152 { 153 if (LE_FAILURE(success)) { 154 return 0; 155 } 156 157 switch(SWAPW(subtableFormat)) 158 { 159 case 0: 160 return 0; 161 162 case 1: 163 { 164 const ContextualSubstitutionFormat1Subtable *subtable = (const ContextualSubstitutionFormat1Subtable *) this; 165 return subtable->process(lookupProcessor, glyphIterator, fontInstance, success); 166 } 167 168 case 2: 169 { 170 const ContextualSubstitutionFormat2Subtable *subtable = (const ContextualSubstitutionFormat2Subtable *) this; 171 return subtable->process(lookupProcessor, glyphIterator, fontInstance, success); 172 } 173 174 case 3: 175 { 176 const ContextualSubstitutionFormat3Subtable *subtable = (const ContextualSubstitutionFormat3Subtable *) this; 177 return subtable->process(lookupProcessor, glyphIterator, fontInstance, success); 178 } 179 180 default: 181 return 0; 182 } 183 } 184 185 le_uint32 ContextualSubstitutionFormat1Subtable::process(const LookupProcessor *lookupProcessor, 186 GlyphIterator *glyphIterator, 187 const LEFontInstance *fontInstance, 188 LEErrorCode& success) const 189 { 190 if (LE_FAILURE(success)) { 191 return 0; 192 } 193 194 LEGlyphID glyph = glyphIterator->getCurrGlyphID(); 195 le_int32 coverageIndex = getGlyphCoverage(glyph); 196 197 if (coverageIndex >= 0) { 198 le_uint16 srSetCount = SWAPW(subRuleSetCount); 199 200 if (coverageIndex < srSetCount) { 201 Offset subRuleSetTableOffset = SWAPW(subRuleSetTableOffsetArray[coverageIndex]); 202 const SubRuleSetTable *subRuleSetTable = 203 (const SubRuleSetTable *) ((char *) this + subRuleSetTableOffset); 204 le_uint16 subRuleCount = SWAPW(subRuleSetTable->subRuleCount); 205 le_int32 position = glyphIterator->getCurrStreamPosition(); 206 207 for (le_uint16 subRule = 0; subRule < subRuleCount; subRule += 1) { 208 Offset subRuleTableOffset = 209 SWAPW(subRuleSetTable->subRuleTableOffsetArray[subRule]); 210 const SubRuleTable *subRuleTable = 211 (const SubRuleTable *) ((char *) subRuleSetTable + subRuleTableOffset); 212 le_uint16 matchCount = SWAPW(subRuleTable->glyphCount) - 1; 213 le_uint16 substCount = SWAPW(subRuleTable->substCount); 214 215 if (matchGlyphIDs(subRuleTable->inputGlyphArray, matchCount, glyphIterator)) { 216 const SubstitutionLookupRecord *substLookupRecordArray = 217 (const SubstitutionLookupRecord *) &subRuleTable->inputGlyphArray[matchCount]; 218 219 applySubstitutionLookups(lookupProcessor, substLookupRecordArray, substCount, glyphIterator, fontInstance, position, success); 220 221 return matchCount + 1; 222 } 223 224 glyphIterator->setCurrStreamPosition(position); 225 } 226 } 227 228 // XXX If we get here, the table is mal-formed... 229 } 230 231 return 0; 232 } 233 234 le_uint32 ContextualSubstitutionFormat2Subtable::process(const LookupProcessor *lookupProcessor, 235 GlyphIterator *glyphIterator, 236 const LEFontInstance *fontInstance, 237 LEErrorCode& success) const 238 { 239 if (LE_FAILURE(success)) { 240 return 0; 241 } 242 243 LEGlyphID glyph = glyphIterator->getCurrGlyphID(); 244 le_int32 coverageIndex = getGlyphCoverage(glyph); 245 246 if (coverageIndex >= 0) { 247 const ClassDefinitionTable *classDefinitionTable = 248 (const ClassDefinitionTable *) ((char *) this + SWAPW(classDefTableOffset)); 249 le_uint16 scSetCount = SWAPW(subClassSetCount); 250 le_int32 setClass = classDefinitionTable->getGlyphClass(glyphIterator->getCurrGlyphID()); 251 252 if (setClass < scSetCount && subClassSetTableOffsetArray[setClass] != 0) { 253 Offset subClassSetTableOffset = SWAPW(subClassSetTableOffsetArray[setClass]); 254 const SubClassSetTable *subClassSetTable = 255 (const SubClassSetTable *) ((char *) this + subClassSetTableOffset); 256 le_uint16 subClassRuleCount = SWAPW(subClassSetTable->subClassRuleCount); 257 le_int32 position = glyphIterator->getCurrStreamPosition(); 258 259 for (le_uint16 scRule = 0; scRule < subClassRuleCount; scRule += 1) { 260 Offset subClassRuleTableOffset = 261 SWAPW(subClassSetTable->subClassRuleTableOffsetArray[scRule]); 262 const SubClassRuleTable *subClassRuleTable = 263 (const SubClassRuleTable *) ((char *) subClassSetTable + subClassRuleTableOffset); 264 le_uint16 matchCount = SWAPW(subClassRuleTable->glyphCount) - 1; 265 le_uint16 substCount = SWAPW(subClassRuleTable->substCount); 266 267 if (matchGlyphClasses(subClassRuleTable->classArray, matchCount, glyphIterator, classDefinitionTable)) { 268 const SubstitutionLookupRecord *substLookupRecordArray = 269 (const SubstitutionLookupRecord *) &subClassRuleTable->classArray[matchCount]; 270 271 applySubstitutionLookups(lookupProcessor, substLookupRecordArray, substCount, glyphIterator, fontInstance, position, success); 272 273 return matchCount + 1; 274 } 275 276 glyphIterator->setCurrStreamPosition(position); 277 } 278 } 279 280 // XXX If we get here, the table is mal-formed... 281 } 282 283 return 0; 284 } 285 286 le_uint32 ContextualSubstitutionFormat3Subtable::process(const LookupProcessor *lookupProcessor, 287 GlyphIterator *glyphIterator, 288 const LEFontInstance *fontInstance, 289 LEErrorCode& success)const 290 { 291 if (LE_FAILURE(success)) { 292 return 0; 293 } 294 295 le_uint16 gCount = SWAPW(glyphCount); 296 le_uint16 subCount = SWAPW(substCount); 297 le_int32 position = glyphIterator->getCurrStreamPosition(); 298 299 // Back up the glyph iterator so that we 300 // can call next() before the check, which 301 // will leave it pointing at the last glyph 302 // that matched when we're done. 303 glyphIterator->prev(); 304 305 if (ContextualSubstitutionBase::matchGlyphCoverages(coverageTableOffsetArray, gCount, glyphIterator, (const char *) this)) { 306 const SubstitutionLookupRecord *substLookupRecordArray = 307 (const SubstitutionLookupRecord *) &coverageTableOffsetArray[gCount]; 308 309 ContextualSubstitutionBase::applySubstitutionLookups(lookupProcessor, substLookupRecordArray, subCount, glyphIterator, fontInstance, position, success); 310 311 return gCount + 1; 312 } 313 314 glyphIterator->setCurrStreamPosition(position); 315 316 return 0; 317 } 318 319 le_uint32 ChainingContextualSubstitutionSubtable::process(const LookupProcessor *lookupProcessor, 320 GlyphIterator *glyphIterator, 321 const LEFontInstance *fontInstance, 322 LEErrorCode& success) const 323 { 324 if (LE_FAILURE(success)) { 325 return 0; 326 } 327 328 switch(SWAPW(subtableFormat)) 329 { 330 case 0: 331 return 0; 332 333 case 1: 334 { 335 const ChainingContextualSubstitutionFormat1Subtable *subtable = (const ChainingContextualSubstitutionFormat1Subtable *) this; 336 return subtable->process(lookupProcessor, glyphIterator, fontInstance, success); 337 } 338 339 case 2: 340 { 341 const ChainingContextualSubstitutionFormat2Subtable *subtable = (const ChainingContextualSubstitutionFormat2Subtable *) this; 342 return subtable->process(lookupProcessor, glyphIterator, fontInstance, success); 343 } 344 345 case 3: 346 { 347 const ChainingContextualSubstitutionFormat3Subtable *subtable = (const ChainingContextualSubstitutionFormat3Subtable *) this; 348 return subtable->process(lookupProcessor, glyphIterator, fontInstance, success); 349 } 350 351 default: 352 return 0; 353 } 354 } 355 356 // NOTE: This could be a #define, but that seems to confuse 357 // the Visual Studio .NET 2003 compiler on the calls to the 358 // GlyphIterator constructor. It somehow can't decide if 359 // emptyFeatureList matches an le_uint32 or an le_uint16... 360 static const FeatureMask emptyFeatureList = 0x00000000UL; 361 362 le_uint32 ChainingContextualSubstitutionFormat1Subtable::process(const LookupProcessor *lookupProcessor, 363 GlyphIterator *glyphIterator, 364 const LEFontInstance *fontInstance, 365 LEErrorCode& success) const 366 { 367 if (LE_FAILURE(success)) { 368 return 0; 369 } 370 371 LEGlyphID glyph = glyphIterator->getCurrGlyphID(); 372 le_int32 coverageIndex = getGlyphCoverage(glyph); 373 374 if (coverageIndex >= 0) { 375 le_uint16 srSetCount = SWAPW(chainSubRuleSetCount); 376 377 if (coverageIndex < srSetCount) { 378 Offset chainSubRuleSetTableOffset = SWAPW(chainSubRuleSetTableOffsetArray[coverageIndex]); 379 const ChainSubRuleSetTable *chainSubRuleSetTable = 380 (const ChainSubRuleSetTable *) ((char *) this + chainSubRuleSetTableOffset); 381 le_uint16 chainSubRuleCount = SWAPW(chainSubRuleSetTable->chainSubRuleCount); 382 le_int32 position = glyphIterator->getCurrStreamPosition(); 383 GlyphIterator tempIterator(*glyphIterator, emptyFeatureList); 384 385 for (le_uint16 subRule = 0; subRule < chainSubRuleCount; subRule += 1) { 386 Offset chainSubRuleTableOffset = 387 SWAPW(chainSubRuleSetTable->chainSubRuleTableOffsetArray[subRule]); 388 const ChainSubRuleTable *chainSubRuleTable = 389 (const ChainSubRuleTable *) ((char *) chainSubRuleSetTable + chainSubRuleTableOffset); 390 le_uint16 backtrackGlyphCount = SWAPW(chainSubRuleTable->backtrackGlyphCount); 391 le_uint16 inputGlyphCount = (le_uint16) SWAPW(chainSubRuleTable->backtrackGlyphArray[backtrackGlyphCount]) - 1; 392 const TTGlyphID *inputGlyphArray = &chainSubRuleTable->backtrackGlyphArray[backtrackGlyphCount + 1]; 393 le_uint16 lookaheadGlyphCount = (le_uint16) SWAPW(inputGlyphArray[inputGlyphCount]); 394 const TTGlyphID *lookaheadGlyphArray = &inputGlyphArray[inputGlyphCount + 1]; 395 le_uint16 substCount = (le_uint16) SWAPW(lookaheadGlyphArray[lookaheadGlyphCount]); 396 397 tempIterator.setCurrStreamPosition(position); 398 399 if (! tempIterator.prev(backtrackGlyphCount)) { 400 continue; 401 } 402 403 tempIterator.prev(); 404 if (! matchGlyphIDs(chainSubRuleTable->backtrackGlyphArray, backtrackGlyphCount, &tempIterator, TRUE)) { 405 continue; 406 } 407 408 tempIterator.setCurrStreamPosition(position); 409 tempIterator.next(inputGlyphCount); 410 if (!matchGlyphIDs(lookaheadGlyphArray, lookaheadGlyphCount, &tempIterator)) { 411 continue; 412 } 413 414 if (matchGlyphIDs(inputGlyphArray, inputGlyphCount, glyphIterator)) { 415 const SubstitutionLookupRecord *substLookupRecordArray = 416 (const SubstitutionLookupRecord *) &lookaheadGlyphArray[lookaheadGlyphCount + 1]; 417 418 applySubstitutionLookups(lookupProcessor, substLookupRecordArray, substCount, glyphIterator, fontInstance, position, success); 419 420 return inputGlyphCount + 1; 421 } 422 423 glyphIterator->setCurrStreamPosition(position); 424 } 425 } 426 427 // XXX If we get here, the table is mal-formed... 428 } 429 430 return 0; 431 } 432 433 le_uint32 ChainingContextualSubstitutionFormat2Subtable::process(const LookupProcessor *lookupProcessor, 434 GlyphIterator *glyphIterator, 435 const LEFontInstance *fontInstance, 436 LEErrorCode& success) const 437 { 438 if (LE_FAILURE(success)) { 439 return 0; 440 } 441 442 LEGlyphID glyph = glyphIterator->getCurrGlyphID(); 443 le_int32 coverageIndex = getGlyphCoverage(glyph); 444 445 if (coverageIndex >= 0) { 446 const ClassDefinitionTable *backtrackClassDefinitionTable = 447 (const ClassDefinitionTable *) ((char *) this + SWAPW(backtrackClassDefTableOffset)); 448 const ClassDefinitionTable *inputClassDefinitionTable = 449 (const ClassDefinitionTable *) ((char *) this + SWAPW(inputClassDefTableOffset)); 450 const ClassDefinitionTable *lookaheadClassDefinitionTable = 451 (const ClassDefinitionTable *) ((char *) this + SWAPW(lookaheadClassDefTableOffset)); 452 le_uint16 scSetCount = SWAPW(chainSubClassSetCount); 453 le_int32 setClass = inputClassDefinitionTable->getGlyphClass(glyphIterator->getCurrGlyphID()); 454 455 if (setClass < scSetCount && chainSubClassSetTableOffsetArray[setClass] != 0) { 456 Offset chainSubClassSetTableOffset = SWAPW(chainSubClassSetTableOffsetArray[setClass]); 457 const ChainSubClassSetTable *chainSubClassSetTable = 458 (const ChainSubClassSetTable *) ((char *) this + chainSubClassSetTableOffset); 459 le_uint16 chainSubClassRuleCount = SWAPW(chainSubClassSetTable->chainSubClassRuleCount); 460 le_int32 position = glyphIterator->getCurrStreamPosition(); 461 GlyphIterator tempIterator(*glyphIterator, emptyFeatureList); 462 463 for (le_uint16 scRule = 0; scRule < chainSubClassRuleCount; scRule += 1) { 464 Offset chainSubClassRuleTableOffset = 465 SWAPW(chainSubClassSetTable->chainSubClassRuleTableOffsetArray[scRule]); 466 const ChainSubClassRuleTable *chainSubClassRuleTable = 467 (const ChainSubClassRuleTable *) ((char *) chainSubClassSetTable + chainSubClassRuleTableOffset); 468 le_uint16 backtrackGlyphCount = SWAPW(chainSubClassRuleTable->backtrackGlyphCount); 469 le_uint16 inputGlyphCount = SWAPW(chainSubClassRuleTable->backtrackClassArray[backtrackGlyphCount]) - 1; 470 const le_uint16 *inputClassArray = &chainSubClassRuleTable->backtrackClassArray[backtrackGlyphCount + 1]; 471 le_uint16 lookaheadGlyphCount = SWAPW(inputClassArray[inputGlyphCount]); 472 const le_uint16 *lookaheadClassArray = &inputClassArray[inputGlyphCount + 1]; 473 le_uint16 substCount = SWAPW(lookaheadClassArray[lookaheadGlyphCount]); 474 475 476 tempIterator.setCurrStreamPosition(position); 477 478 if (! tempIterator.prev(backtrackGlyphCount)) { 479 continue; 480 } 481 482 tempIterator.prev(); 483 if (! matchGlyphClasses(chainSubClassRuleTable->backtrackClassArray, backtrackGlyphCount, 484 &tempIterator, backtrackClassDefinitionTable, TRUE)) { 485 continue; 486 } 487 488 tempIterator.setCurrStreamPosition(position); 489 tempIterator.next(inputGlyphCount); 490 if (! matchGlyphClasses(lookaheadClassArray, lookaheadGlyphCount, &tempIterator, lookaheadClassDefinitionTable)) { 491 continue; 492 } 493 494 if (matchGlyphClasses(inputClassArray, inputGlyphCount, glyphIterator, inputClassDefinitionTable)) { 495 const SubstitutionLookupRecord *substLookupRecordArray = 496 (const SubstitutionLookupRecord *) &lookaheadClassArray[lookaheadGlyphCount + 1]; 497 498 applySubstitutionLookups(lookupProcessor, substLookupRecordArray, substCount, glyphIterator, fontInstance, position, success); 499 500 return inputGlyphCount + 1; 501 } 502 503 glyphIterator->setCurrStreamPosition(position); 504 } 505 } 506 507 // XXX If we get here, the table is mal-formed... 508 } 509 510 return 0; 511 } 512 513 le_uint32 ChainingContextualSubstitutionFormat3Subtable::process(const LookupProcessor *lookupProcessor, 514 GlyphIterator *glyphIterator, 515 const LEFontInstance *fontInstance, 516 LEErrorCode & success) const 517 { 518 if (LE_FAILURE(success)) { 519 return 0; 520 } 521 522 le_uint16 backtrkGlyphCount = SWAPW(backtrackGlyphCount); 523 le_uint16 inputGlyphCount = (le_uint16) SWAPW(backtrackCoverageTableOffsetArray[backtrkGlyphCount]); 524 const Offset *inputCoverageTableOffsetArray = &backtrackCoverageTableOffsetArray[backtrkGlyphCount + 1]; 525 const le_uint16 lookaheadGlyphCount = (le_uint16) SWAPW(inputCoverageTableOffsetArray[inputGlyphCount]); 526 const Offset *lookaheadCoverageTableOffsetArray = &inputCoverageTableOffsetArray[inputGlyphCount + 1]; 527 le_uint16 substCount = (le_uint16) SWAPW(lookaheadCoverageTableOffsetArray[lookaheadGlyphCount]); 528 le_int32 position = glyphIterator->getCurrStreamPosition(); 529 GlyphIterator tempIterator(*glyphIterator, emptyFeatureList); 530 531 if (! tempIterator.prev(backtrkGlyphCount)) { 532 return 0; 533 } 534 535 tempIterator.prev(); 536 if (! ContextualSubstitutionBase::matchGlyphCoverages(backtrackCoverageTableOffsetArray, 537 backtrkGlyphCount, &tempIterator, (const char *) this, TRUE)) { 538 return 0; 539 } 540 541 tempIterator.setCurrStreamPosition(position); 542 tempIterator.next(inputGlyphCount - 1); 543 if (! ContextualSubstitutionBase::matchGlyphCoverages(lookaheadCoverageTableOffsetArray, 544 lookaheadGlyphCount, &tempIterator, (const char *) this)) { 545 return 0; 546 } 547 548 // Back up the glyph iterator so that we 549 // can call next() before the check, which 550 // will leave it pointing at the last glyph 551 // that matched when we're done. 552 glyphIterator->prev(); 553 554 if (ContextualSubstitutionBase::matchGlyphCoverages(inputCoverageTableOffsetArray, 555 inputGlyphCount, glyphIterator, (const char *) this)) { 556 const SubstitutionLookupRecord *substLookupRecordArray = 557 (const SubstitutionLookupRecord *) &lookaheadCoverageTableOffsetArray[lookaheadGlyphCount + 1]; 558 559 ContextualSubstitutionBase::applySubstitutionLookups(lookupProcessor, substLookupRecordArray, substCount, glyphIterator, fontInstance, position, success); 560 561 return inputGlyphCount; 562 } 563 564 glyphIterator->setCurrStreamPosition(position); 565 566 return 0; 567 } 568 569 U_NAMESPACE_END 570
