1 2 /* 3 * 4 * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved 5 * 6 */ 7 8 #include "LETypes.h" 9 #include "LEScripts.h" 10 #include "LELanguages.h" 11 12 #include "LayoutEngine.h" 13 #include "CanonShaping.h" 14 #include "OpenTypeLayoutEngine.h" 15 #include "ScriptAndLanguageTags.h" 16 #include "CharSubstitutionFilter.h" 17 18 #include "GlyphSubstitutionTables.h" 19 #include "GlyphDefinitionTables.h" 20 #include "GlyphPositioningTables.h" 21 22 #include "LEGlyphStorage.h" 23 #include "GlyphPositionAdjustments.h" 24 25 #include "GDEFMarkFilter.h" 26 27 #include "KernTable.h" 28 29 U_NAMESPACE_BEGIN 30 31 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(OpenTypeLayoutEngine) 32 33 #define ccmpFeatureTag LE_CCMP_FEATURE_TAG 34 #define ligaFeatureTag LE_LIGA_FEATURE_TAG 35 #define cligFeatureTag LE_CLIG_FEATURE_TAG 36 #define kernFeatureTag LE_KERN_FEATURE_TAG 37 #define markFeatureTag LE_MARK_FEATURE_TAG 38 #define mkmkFeatureTag LE_MKMK_FEATURE_TAG 39 #define loclFeatureTag LE_LOCL_FEATURE_TAG 40 #define caltFeatureTag LE_CALT_FEATURE_TAG 41 42 // 'dlig' not used at the moment 43 #define dligFeatureTag 0x646C6967 44 45 // 'palt' 46 #define paltFeatureTag 0x70616C74 47 48 #define ccmpFeatureMask 0x80000000UL 49 #define ligaFeatureMask 0x40000000UL 50 #define cligFeatureMask 0x20000000UL 51 #define kernFeatureMask 0x10000000UL 52 #define paltFeatureMask 0x08000000UL 53 #define markFeatureMask 0x04000000UL 54 #define mkmkFeatureMask 0x02000000UL 55 #define loclFeatureMask 0x01000000UL 56 #define caltFeatureMask 0x00800000UL 57 58 #define minimalFeatures (ccmpFeatureMask | markFeatureMask | mkmkFeatureMask | loclFeatureMask | caltFeatureMask) 59 #define ligaFeatures (ligaFeatureMask | cligFeatureMask | minimalFeatures) 60 #define kernFeatures (kernFeatureMask | paltFeatureMask | minimalFeatures) 61 #define kernAndLigaFeatures (ligaFeatures | kernFeatures) 62 63 static const FeatureMap featureMap[] = 64 { 65 {ccmpFeatureTag, ccmpFeatureMask}, 66 {ligaFeatureTag, ligaFeatureMask}, 67 {cligFeatureTag, cligFeatureMask}, 68 {kernFeatureTag, kernFeatureMask}, 69 {paltFeatureTag, paltFeatureMask}, 70 {markFeatureTag, markFeatureMask}, 71 {mkmkFeatureTag, mkmkFeatureMask}, 72 {loclFeatureTag, loclFeatureMask}, 73 {caltFeatureTag, caltFeatureMask} 74 }; 75 76 static const le_int32 featureMapCount = LE_ARRAY_SIZE(featureMap); 77 78 OpenTypeLayoutEngine::OpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, 79 le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable, LEErrorCode &success) 80 : LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success), fFeatureMask(minimalFeatures), 81 fFeatureMap(featureMap), fFeatureMapCount(featureMapCount), fFeatureOrder(FALSE), 82 fGSUBTable(gsubTable), fGDEFTable(NULL), fGPOSTable(NULL), fSubstitutionFilter(NULL) 83 { 84 static const le_uint32 gdefTableTag = LE_GDEF_TABLE_TAG; 85 static const le_uint32 gposTableTag = LE_GPOS_TABLE_TAG; 86 const GlyphPositioningTableHeader *gposTable = (const GlyphPositioningTableHeader *) getFontTable(gposTableTag); 87 88 // todo: switch to more flags and bitfield rather than list of feature tags? 89 switch (typoFlags & ~0x80000000L) { 90 case 0: break; // default 91 case 1: fFeatureMask = kernFeatures; break; 92 case 2: fFeatureMask = ligaFeatures; break; 93 case 3: fFeatureMask = kernAndLigaFeatures; break; 94 default: break; 95 } 96 97 if (typoFlags & 0x80000000L) { 98 fSubstitutionFilter = new CharSubstitutionFilter(fontInstance); 99 } 100 101 setScriptAndLanguageTags(); 102 103 fGDEFTable = (const GlyphDefinitionTableHeader *) getFontTable(gdefTableTag); 104 105 // JK patch, 2008-05-30 - see Sinhala bug report and LKLUG font 106 // if (gposTable != NULL && gposTable->coversScriptAndLanguage(fScriptTag, fLangSysTag)) { 107 if (gposTable != NULL && gposTable->coversScript(fScriptTag)) { 108 fGPOSTable = gposTable; 109 } 110 } 111 112 void OpenTypeLayoutEngine::reset() 113 { 114 // NOTE: if we're called from 115 // the destructor, LayoutEngine;:reset() 116 // will have been called already by 117 // LayoutEngine::~LayoutEngine() 118 LayoutEngine::reset(); 119 } 120 121 OpenTypeLayoutEngine::OpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, 122 le_int32 typoFlags, LEErrorCode &success) 123 : LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success), fFeatureOrder(FALSE), 124 fGSUBTable(NULL), fGDEFTable(NULL), fGPOSTable(NULL), fSubstitutionFilter(NULL) 125 { 126 setScriptAndLanguageTags(); 127 } 128 129 OpenTypeLayoutEngine::~OpenTypeLayoutEngine() 130 { 131 if (fTypoFlags & 0x80000000L) { 132 delete fSubstitutionFilter; 133 } 134 135 reset(); 136 } 137 138 LETag OpenTypeLayoutEngine::getScriptTag(le_int32 scriptCode) 139 { 140 if (scriptCode < 0 || scriptCode >= scriptCodeCount) { 141 return 0xFFFFFFFF; 142 } 143 return scriptTags[scriptCode]; 144 } 145 146 LETag OpenTypeLayoutEngine::getV2ScriptTag(le_int32 scriptCode) 147 { 148 switch (scriptCode) { 149 case bengScriptCode : return bng2ScriptTag; 150 case devaScriptCode : return dev2ScriptTag; 151 case gujrScriptCode : return gjr2ScriptTag; 152 case guruScriptCode : return gur2ScriptTag; 153 case kndaScriptCode : return knd2ScriptTag; 154 case mlymScriptCode : return mlm2ScriptTag; 155 case oryaScriptCode : return ory2ScriptTag; 156 case tamlScriptCode : return tml2ScriptTag; 157 case teluScriptCode : return tel2ScriptTag; 158 default: return nullScriptTag; 159 } 160 } 161 162 LETag OpenTypeLayoutEngine::getLangSysTag(le_int32 languageCode) 163 { 164 if (languageCode < 0 || languageCode >= languageCodeCount) { 165 return 0xFFFFFFFF; 166 } 167 168 return languageTags[languageCode]; 169 } 170 171 void OpenTypeLayoutEngine::setScriptAndLanguageTags() 172 { 173 fScriptTag = getScriptTag(fScriptCode); 174 fScriptTagV2 = getV2ScriptTag(fScriptCode); 175 fLangSysTag = getLangSysTag(fLanguageCode); 176 } 177 178 le_int32 OpenTypeLayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, 179 LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success) 180 { 181 if (LE_FAILURE(success)) { 182 return 0; 183 } 184 185 if (offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) { 186 success = LE_ILLEGAL_ARGUMENT_ERROR; 187 return 0; 188 } 189 190 // This is the cheapest way to get mark reordering only for Hebrew. 191 // We could just do the mark reordering for all scripts, but most 192 // of them probably don't need it... Another option would be to 193 // add a HebrewOpenTypeLayoutEngine subclass, but the only thing it 194 // would need to do is mark reordering, so that seems like overkill. 195 if (fScriptCode == hebrScriptCode) { 196 outChars = LE_NEW_ARRAY(LEUnicode, count); 197 198 if (outChars == NULL) { 199 success = LE_MEMORY_ALLOCATION_ERROR; 200 return 0; 201 } 202 203 if (LE_FAILURE(success)) { 204 LE_DELETE_ARRAY(outChars); 205 return 0; 206 } 207 208 CanonShaping::reorderMarks(&chars[offset], count, rightToLeft, outChars, glyphStorage); 209 } 210 211 if (LE_FAILURE(success)) { 212 return 0; 213 } 214 215 glyphStorage.allocateGlyphArray(count, rightToLeft, success); 216 glyphStorage.allocateAuxData(success); 217 218 for (le_int32 i = 0; i < count; i += 1) { 219 glyphStorage.setAuxData(i, fFeatureMask, success); 220 } 221 222 return count; 223 } 224 225 // Input: characters, tags 226 // Output: glyphs, char indices 227 le_int32 OpenTypeLayoutEngine::glyphProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, 228 LEGlyphStorage &glyphStorage, LEErrorCode &success) 229 { 230 if (LE_FAILURE(success)) { 231 return 0; 232 } 233 234 if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) { 235 success = LE_ILLEGAL_ARGUMENT_ERROR; 236 return 0; 237 } 238 239 mapCharsToGlyphs(chars, offset, count, rightToLeft, rightToLeft, glyphStorage, success); 240 241 if (LE_FAILURE(success)) { 242 return 0; 243 } 244 245 if (fGSUBTable != NULL) { 246 if (fScriptTagV2 != nullScriptTag && fGSUBTable->coversScriptAndLanguage(fScriptTagV2,fLangSysTag)) { 247 count = fGSUBTable->process(glyphStorage, rightToLeft, fScriptTagV2, fLangSysTag, fGDEFTable, fSubstitutionFilter, 248 fFeatureMap, fFeatureMapCount, fFeatureOrder, success); 249 250 } else { 251 count = fGSUBTable->process(glyphStorage, rightToLeft, fScriptTag, fLangSysTag, fGDEFTable, fSubstitutionFilter, 252 fFeatureMap, fFeatureMapCount, fFeatureOrder, success); 253 } 254 } 255 256 return count; 257 } 258 // Input: characters, tags 259 // Output: glyphs, char indices 260 le_int32 OpenTypeLayoutEngine::glyphSubstitution(le_int32 count, le_int32 max, le_bool rightToLeft, 261 LEGlyphStorage &glyphStorage, LEErrorCode &success) 262 { 263 if (LE_FAILURE(success)) { 264 return 0; 265 } 266 267 if ( count < 0 || max < 0 ) { 268 success = LE_ILLEGAL_ARGUMENT_ERROR; 269 return 0; 270 } 271 272 if (fGSUBTable != NULL) { 273 if (fScriptTagV2 != nullScriptTag && fGSUBTable->coversScriptAndLanguage(fScriptTagV2,fLangSysTag)) { 274 count = fGSUBTable->process(glyphStorage, rightToLeft, fScriptTagV2, fLangSysTag, fGDEFTable, fSubstitutionFilter, 275 fFeatureMap, fFeatureMapCount, fFeatureOrder, success); 276 277 } else { 278 count = fGSUBTable->process(glyphStorage, rightToLeft, fScriptTag, fLangSysTag, fGDEFTable, fSubstitutionFilter, 279 fFeatureMap, fFeatureMapCount, fFeatureOrder, success); 280 } 281 } 282 283 return count; 284 } 285 le_int32 OpenTypeLayoutEngine::glyphPostProcessing(LEGlyphStorage &tempGlyphStorage, LEGlyphStorage &glyphStorage, LEErrorCode &success) 286 { 287 if (LE_FAILURE(success)) { 288 return 0; 289 } 290 291 glyphStorage.adoptGlyphArray(tempGlyphStorage); 292 glyphStorage.adoptCharIndicesArray(tempGlyphStorage); 293 glyphStorage.adoptAuxDataArray(tempGlyphStorage); 294 glyphStorage.adoptGlyphCount(tempGlyphStorage); 295 296 return glyphStorage.getGlyphCount(); 297 } 298 299 le_int32 OpenTypeLayoutEngine::computeGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, LEGlyphStorage &glyphStorage, LEErrorCode &success) 300 { 301 LEUnicode *outChars = NULL; 302 LEGlyphStorage fakeGlyphStorage; 303 le_int32 outCharCount, outGlyphCount, fakeGlyphCount; 304 305 if (LE_FAILURE(success)) { 306 return 0; 307 } 308 309 if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) { 310 success = LE_ILLEGAL_ARGUMENT_ERROR; 311 return 0; 312 } 313 314 outCharCount = characterProcessing(chars, offset, count, max, rightToLeft, outChars, fakeGlyphStorage, success); 315 316 if (LE_FAILURE(success)) { 317 return 0; 318 } 319 320 if (outChars != NULL) { 321 fakeGlyphCount = glyphProcessing(outChars, 0, outCharCount, outCharCount, rightToLeft, fakeGlyphStorage, success); 322 LE_DELETE_ARRAY(outChars); // FIXME: a subclass may have allocated this, in which case this delete might not work... 323 //adjustGlyphs(outChars, 0, outCharCount, rightToLeft, fakeGlyphs, fakeGlyphCount); 324 } else { 325 fakeGlyphCount = glyphProcessing(chars, offset, count, max, rightToLeft, fakeGlyphStorage, success); 326 //adjustGlyphs(chars, offset, count, rightToLeft, fakeGlyphs, fakeGlyphCount); 327 } 328 329 if (LE_FAILURE(success)) { 330 return 0; 331 } 332 333 outGlyphCount = glyphPostProcessing(fakeGlyphStorage, glyphStorage, success); 334 335 return outGlyphCount; 336 } 337 338 // apply GPOS table, if any 339 void OpenTypeLayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, 340 LEGlyphStorage &glyphStorage, LEErrorCode &success) 341 { 342 if (LE_FAILURE(success)) { 343 return; 344 } 345 346 if (chars == NULL || offset < 0 || count < 0) { 347 success = LE_ILLEGAL_ARGUMENT_ERROR; 348 return; 349 } 350 351 le_int32 glyphCount = glyphStorage.getGlyphCount(); 352 if (glyphCount == 0) { 353 return; 354 } 355 356 if (fGPOSTable != NULL) { 357 GlyphPositionAdjustments *adjustments = new GlyphPositionAdjustments(glyphCount); 358 le_int32 i; 359 360 if (adjustments == NULL) { 361 success = LE_MEMORY_ALLOCATION_ERROR; 362 return; 363 } 364 365 #if 0 366 // Don't need to do this if we allocate 367 // the adjustments array w/ new... 368 for (i = 0; i < glyphCount; i += 1) { 369 adjustments->setXPlacement(i, 0); 370 adjustments->setYPlacement(i, 0); 371 372 adjustments->setXAdvance(i, 0); 373 adjustments->setYAdvance(i, 0); 374 375 adjustments->setBaseOffset(i, -1); 376 } 377 #endif 378 379 if (fGPOSTable != NULL) { 380 if (fScriptTagV2 != nullScriptTag && fGPOSTable->coversScriptAndLanguage(fScriptTagV2,fLangSysTag)) { 381 fGPOSTable->process(glyphStorage, adjustments, reverse, fScriptTagV2, fLangSysTag, fGDEFTable, success, fFontInstance, 382 fFeatureMap, fFeatureMapCount, fFeatureOrder); 383 384 } else { 385 fGPOSTable->process(glyphStorage, adjustments, reverse, fScriptTag, fLangSysTag, fGDEFTable, success, fFontInstance, 386 fFeatureMap, fFeatureMapCount, fFeatureOrder); 387 } 388 } else if ( fTypoFlags & 0x1 ) { 389 static const le_uint32 kernTableTag = LE_KERN_TABLE_TAG; 390 KernTable kt(fFontInstance, getFontTable(kernTableTag)); 391 kt.process(glyphStorage); 392 } 393 394 float xAdjust = 0, yAdjust = 0; 395 396 for (i = 0; i < glyphCount; i += 1) { 397 float xAdvance = adjustments->getXAdvance(i); 398 float yAdvance = adjustments->getYAdvance(i); 399 float xPlacement = 0; 400 float yPlacement = 0; 401 402 403 #if 0 404 // This is where separate kerning adjustments 405 // should get applied. 406 xAdjust += xKerning; 407 yAdjust += yKerning; 408 #endif 409 410 for (le_int32 base = i; base >= 0; base = adjustments->getBaseOffset(base)) { 411 xPlacement += adjustments->getXPlacement(base); 412 yPlacement += adjustments->getYPlacement(base); 413 } 414 415 xPlacement = fFontInstance->xUnitsToPoints(xPlacement); 416 yPlacement = fFontInstance->yUnitsToPoints(yPlacement); 417 glyphStorage.adjustPosition(i, xAdjust + xPlacement, -(yAdjust + yPlacement), success); 418 419 xAdjust += fFontInstance->xUnitsToPoints(xAdvance); 420 yAdjust += fFontInstance->yUnitsToPoints(yAdvance); 421 } 422 423 glyphStorage.adjustPosition(glyphCount, xAdjust, -yAdjust, success); 424 425 delete adjustments; 426 } else { 427 // if there was no GPOS table, maybe there's non-OpenType kerning we can use 428 LayoutEngine::adjustGlyphPositions(chars, offset, count, reverse, glyphStorage, success); 429 } 430 431 LEGlyphID zwnj = fFontInstance->mapCharToGlyph(0x200C); 432 433 if (zwnj != 0x0000) { 434 for (le_int32 g = 0; g < glyphCount; g += 1) { 435 LEGlyphID glyph = glyphStorage[g]; 436 437 if (glyph == zwnj) { 438 glyphStorage[g] = LE_SET_GLYPH(glyph, 0xFFFF); 439 } 440 } 441 } 442 443 #if 0 444 // Don't know why this is here... 445 LE_DELETE_ARRAY(fFeatureTags); 446 fFeatureTags = NULL; 447 #endif 448 } 449 450 U_NAMESPACE_END 451
