U_NAMESPACE_BEGIN le_uint32 SingleSubstitutionSubtable::process(const LEReferenceTo<SingleSubstitutionSubtable> &base, GlyphIterator *glyphIterator, LEErrorCode &success, const LEGlyphFilter *filter) const { switch(SWAPW(subtableFormat)) { case 0: return 0; case 1: { const LEReferenceTo<SingleSubstitutionFormat1Subtable> subtable(base, success, (const SingleSubstitutionFormat1Subtable *) this); return subtable->process(subtable, glyphIterator, success, filter); } case 2: { const LEReferenceTo<SingleSubstitutionFormat2Subtable> subtable(base, success, (const SingleSubstitutionFormat2Subtable *) this); return subtable->process(subtable, glyphIterator, success, filter); } default: return 0; } }
U_NAMESPACE_BEGIN le_uint32 PairPositioningSubtable::process(const LEReferenceTo<PairPositioningSubtable> &base, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode &success) const { switch(SWAPW(subtableFormat)) { case 0: return 0; case 1: { const LEReferenceTo<PairPositioningFormat1Subtable> subtable(base, success, (const PairPositioningFormat1Subtable *) this); if(LE_SUCCESS(success)) return subtable->process(subtable, glyphIterator, fontInstance, success); else return 0; } case 2: { const LEReferenceTo<PairPositioningFormat2Subtable> subtable(base, success, (const PairPositioningFormat2Subtable *) this); if(LE_SUCCESS(success)) return subtable->process(subtable, glyphIterator, fontInstance, success); else return 0; } default: return 0; } }
void CanonShaping::reorderMarks(const LEUnicode *inChars, le_int32 charCount, le_bool rightToLeft, LEUnicode *outChars, LEGlyphStorage &glyphStorage) { LEErrorCode success = LE_NO_ERROR; LEReferenceTo<GlyphDefinitionTableHeader> gdefTable(LETableReference::kStaticData, CanonShaping::glyphDefinitionTable, CanonShaping::glyphDefinitionTableLen); LEReferenceTo<ClassDefinitionTable> classTable = gdefTable->getMarkAttachClassDefinitionTable(gdefTable, success); le_int32 *combiningClasses = LE_NEW_ARRAY(le_int32, charCount); le_int32 *indices = LE_NEW_ARRAY(le_int32, charCount); le_int32 i; if (combiningClasses == NULL || indices == NULL) { if (combiningClasses != NULL) { LE_DELETE_ARRAY(combiningClasses); } if (indices != NULL) { LE_DELETE_ARRAY(indices); } return; } for (i = 0; i < charCount; i += 1) { combiningClasses[i] = classTable->getGlyphClass(classTable, (LEGlyphID) inChars[i], success); indices[i] = i; } for (i = 0; i < charCount; i += 1) { if (combiningClasses[i] != 0) { le_int32 mark; for (mark = i; mark < charCount; mark += 1) { if (combiningClasses[mark] == 0) { break; } } sortMarks(indices, combiningClasses, i, mark); } } le_int32 out = 0, dir = 1; if (rightToLeft) { out = charCount - 1; dir = -1; } for (i = 0; i < charCount; i += 1, out += dir) { le_int32 index = indices[i]; outChars[i] = inChars[index]; glyphStorage.setCharIndex(out, index, success); } LE_DELETE_ARRAY(indices); LE_DELETE_ARRAY(combiningClasses); }
LEReferenceTo<LangSysTable> ScriptListTable::findLanguage(const LETableReference &base, LETag scriptTag, LETag languageTag, LEErrorCode &success, le_bool exactMatch) const { const LEReferenceTo<ScriptTable> scriptTable = findScript(base, scriptTag, success); if (scriptTable.isEmpty()) { return LEReferenceTo<LangSysTable>(); } return scriptTable->findLanguage(scriptTable, languageTag, success, exactMatch).reparent(base); }
le_bool GlyphLookupTableHeader::coversScriptAndLanguage(const LETableReference &base, LETag scriptTag, LETag languageTag, LEErrorCode &success, le_bool exactMatch) const { LEReferenceTo<ScriptListTable> scriptListTable(base, success, SWAPW(scriptListOffset)); LEReferenceTo<LangSysTable> langSysTable = scriptListTable->findLanguage(scriptListTable, scriptTag, languageTag, success, exactMatch); // FIXME: could check featureListOffset, lookupListOffset, and lookup count... // Note: don't have to SWAPW langSysTable->featureCount to check for non-zero. return LE_SUCCESS(success)&&langSysTable.isValid() && langSysTable->featureCount != 0; }
le_uint32 PairPositioningFormat1Subtable::process(const LEReferenceTo<PairPositioningFormat1Subtable> &base, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode &success) const { LEGlyphID firstGlyph = glyphIterator->getCurrGlyphID(); le_int32 coverageIndex = getGlyphCoverage(base, firstGlyph, success); if (LE_FAILURE(success)) { return 0; } GlyphIterator tempIterator(*glyphIterator); if (coverageIndex >= 0 && glyphIterator->next()) { Offset pairSetTableOffset = SWAPW(pairSetTableOffsetArray[coverageIndex]); LEReferenceTo<PairSetTable> pairSetTable(base, success, ((char *) this + pairSetTableOffset)); if (LE_FAILURE(success)) { return 0; } le_uint16 pairValueCount = SWAPW(pairSetTable->pairValueCount); le_int16 valueRecord1Size = ValueRecord::getSize(SWAPW(valueFormat1)); le_int16 valueRecord2Size = ValueRecord::getSize(SWAPW(valueFormat2)); le_int16 recordSize = sizeof(PairValueRecord) - sizeof(ValueRecord) + valueRecord1Size + valueRecord2Size; LEGlyphID secondGlyph = glyphIterator->getCurrGlyphID(); LEReferenceTo<PairValueRecord> pairValueRecord; if (pairValueCount != 0) { pairValueRecord = findPairValueRecord(base, (TTGlyphID) LE_GET_GLYPH(secondGlyph), pairSetTable->pairValueRecordArray, pairValueCount, recordSize, success); } if (pairValueRecord.isEmpty()) { return 0; } if (valueFormat1 != 0) { pairValueRecord->valueRecord1.adjustPosition(SWAPW(valueFormat1), (char *) this, tempIterator, fontInstance); } if (valueFormat2 != 0) { const ValueRecord *valueRecord2 = (const ValueRecord *) ((char *) &pairValueRecord->valueRecord1 + valueRecord1Size); valueRecord2->adjustPosition(SWAPW(valueFormat2), (char *) this, *glyphIterator, fontInstance); } // back up glyphIterator so second glyph can be // first glyph in the next pair glyphIterator->prev(); return 1; } return 0; }
le_int32 LookupProcessor::process(LEGlyphStorage &glyphStorage, GlyphPositionAdjustments *glyphPositionAdjustments, le_bool rightToLeft, const LEReferenceTo<GlyphDefinitionTableHeader> &glyphDefinitionTableHeader, const LEFontInstance *fontInstance, LEErrorCode& success) const { if (LE_FAILURE(success)) { return 0; } le_int32 glyphCount = glyphStorage.getGlyphCount(); if (lookupSelectArray == NULL) { return glyphCount; } GlyphIterator glyphIterator(glyphStorage, glyphPositionAdjustments, rightToLeft, 0, 0, glyphDefinitionTableHeader, success); le_int32 newGlyphCount = glyphCount; for (le_uint16 order = 0; order < lookupOrderCount && LE_SUCCESS(success); order += 1) { le_uint16 lookup = lookupOrderArray[order]; FeatureMask selectMask = lookupSelectArray[lookup]; if (selectMask != 0) { _LETRACE("Processing order#%d/%d", order, lookupOrderCount); const LEReferenceTo<LookupTable> lookupTable = lookupListTable->getLookupTable(lookupListTable, lookup, success); if (!lookupTable.isValid() ||LE_FAILURE(success) ) { continue; } le_uint16 lookupFlags = SWAPW(lookupTable->lookupFlags); glyphIterator.reset(lookupFlags, selectMask); while (glyphIterator.findFeatureTag()) { applyLookupTable(lookupTable, &glyphIterator, fontInstance, success); if (LE_FAILURE(success)) { #if LE_TRACE _LETRACE("Failure for lookup 0x%x - %s\n", lookup, u_errorName((UErrorCode)success)); #endif return 0; } } newGlyphCount = glyphIterator.applyInsertions(); } } return newGlyphCount; }
U_NAMESPACE_BEGIN GlyphIterator::GlyphIterator(LEGlyphStorage &theGlyphStorage, GlyphPositionAdjustments *theGlyphPositionAdjustments, le_bool rightToLeft, le_uint16 theLookupFlags, FeatureMask theFeatureMask, const LEReferenceTo<GlyphDefinitionTableHeader> &theGlyphDefinitionTableHeader) : direction(1), position(-1), nextLimit(-1), prevLimit(-1), glyphStorage(theGlyphStorage), glyphPositionAdjustments(theGlyphPositionAdjustments), srcIndex(-1), destIndex(-1), lookupFlags(theLookupFlags), featureMask(theFeatureMask), glyphGroup(0), glyphClassDefinitionTable(), markAttachClassDefinitionTable() { LEErrorCode success = LE_NO_ERROR; // TODO le_int32 glyphCount = glyphStorage.getGlyphCount(); if (theGlyphDefinitionTableHeader.isValid()) { glyphClassDefinitionTable = theGlyphDefinitionTableHeader -> getGlyphClassDefinitionTable(theGlyphDefinitionTableHeader, success); markAttachClassDefinitionTable = theGlyphDefinitionTableHeader ->getMarkAttachClassDefinitionTable(theGlyphDefinitionTableHeader, success); } nextLimit = glyphCount; if (rightToLeft) { direction = -1; position = glyphCount; nextLimit = -1; prevLimit = glyphCount; } filterResetCache(); }
le_bool CanonMarkFilter::accept(LEGlyphID glyph) const { LEErrorCode success = LE_NO_ERROR; le_int32 glyphClass = classDefTable->getGlyphClass(classDefTable, glyph, success); if(LE_FAILURE(success)) return false; return glyphClass != 0; }
U_NAMESPACE_BEGIN le_uint32 LookupProcessor::applyLookupTable(const LEReferenceTo<LookupTable> &lookupTable, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode& success) const { if (LE_FAILURE(success)) { return 0; } le_uint16 lookupType = SWAPW(lookupTable->lookupType); le_uint16 subtableCount = SWAPW(lookupTable->subTableCount); le_int32 startPosition = glyphIterator->getCurrStreamPosition(); le_uint32 delta; for (le_uint16 subtable = 0; subtable < subtableCount; subtable += 1) { LEReferenceTo<LookupSubtable> lookupSubtable = lookupTable->getLookupSubtable(lookupTable, subtable, success); delta = applySubtable(lookupSubtable, lookupType, glyphIterator, fontInstance, success); if (delta > 0 && LE_FAILURE(success)) { #if LE_TRACE _LETRACE("Posn #%d, type %X, applied subtable #%d/%d - %s\n", startPosition, lookupType, subtable, subtableCount, u_errorName((UErrorCode)success)); #endif return 1; } glyphIterator->setCurrStreamPosition(startPosition); } return 1; }
U_NAMESPACE_BEGIN le_uint32 LookupProcessor::applyLookupTable(const LEReferenceTo<LookupTable> &lookupTable, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode& success) const { if (LE_FAILURE(success)) { return 0; } le_uint16 lookupType = SWAPW(lookupTable->lookupType); le_uint16 subtableCount = SWAPW(lookupTable->subTableCount); le_int32 startPosition = glyphIterator->getCurrStreamPosition(); le_uint32 delta; for (le_uint16 subtable = 0; subtable < subtableCount; subtable += 1) { LEReferenceTo<LookupSubtable> lookupSubtable = lookupTable->getLookupSubtable(lookupTable, subtable, success); delta = applySubtable(lookupSubtable, lookupType, glyphIterator, fontInstance, success); if (delta > 0 || LE_FAILURE(success)) { // Google patch: && -> || return 1; } glyphIterator->setCurrStreamPosition(startPosition); } return 1; }
U_NAMESPACE_BEGIN GDEFMarkFilter::GDEFMarkFilter(const LEReferenceTo<GlyphDefinitionTableHeader> &gdefTable, LEErrorCode &success) : classDefTable(gdefTable->getGlyphClassDefinitionTable(gdefTable, success)) { if(!classDefTable.isValid()) { success = LE_INTERNAL_ERROR; } }
le_uint32 LookupProcessor::applySingleLookup(le_uint16 lookupTableIndex, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode& success) const { if (LE_FAILURE(success)) { return 0; } const LEReferenceTo<LookupTable> lookupTable = lookupListTable->getLookupTable(lookupListTable, lookupTableIndex, success); if (!lookupTable.isValid()) { success = LE_INTERNAL_ERROR; return 0; } le_uint16 lookupFlags = SWAPW(lookupTable->lookupFlags); GlyphIterator tempIterator(*glyphIterator, lookupFlags); le_uint32 delta = applyLookupTable(lookupTable, &tempIterator, fontInstance, success); return delta; }
U_NAMESPACE_BEGIN void MorphTableHeader::process(const LETableReference &base, LEGlyphStorage &glyphStorage, LEErrorCode &success) const { le_uint32 chainCount = SWAPL(this->nChains); LEReferenceTo<ChainHeader> chainHeader(base, success, chains); // moving header LEReferenceToArrayOf<ChainHeader> chainHeaderArray(base, success, chains, chainCount); le_uint32 chain; for (chain = 0; LE_SUCCESS(success) && (chain < chainCount); chain += 1) { if (chain > 0) { le_uint32 chainLength = SWAPL(chainHeader->chainLength); if (chainLength & 0x03) { // incorrect alignment for 32 bit tables success = LE_MEMORY_ALLOCATION_ERROR; // as good a choice as any return; } chainHeader.addOffset(chainLength, success); } FeatureFlags defaultFlags = SWAPL(chainHeader->defaultFlags); le_int16 nFeatureEntries = SWAPW(chainHeader->nFeatureEntries); le_int16 nSubtables = SWAPW(chainHeader->nSubtables); LEReferenceTo<MorphSubtableHeader> subtableHeader = LEReferenceTo<MorphSubtableHeader>(chainHeader,success, &(chainHeader->featureTable[nFeatureEntries])); le_int16 subtable; for (subtable = 0; LE_SUCCESS(success) && (subtable < nSubtables); subtable += 1) { if (subtable > 0) { le_int16 length = SWAPW(subtableHeader->length); if (length & 0x03) { // incorrect alignment for 32 bit tables success = LE_MEMORY_ALLOCATION_ERROR; // as good a choice as any return; } subtableHeader.addOffset(length, success); } SubtableCoverage coverage = SWAPW(subtableHeader->coverage); FeatureFlags subtableFeatures = SWAPL(subtableHeader->subtableFeatures); // should check coverage more carefully... if ((coverage & scfVertical) == 0 && (subtableFeatures & defaultFlags) != 0 && LE_SUCCESS(success)) { subtableHeader->process(subtableHeader, glyphStorage, success); } } } }
le_bool ContextualSubstitutionBase::matchGlyphClasses( const LEReferenceToArrayOf<le_uint16> &classArray, le_uint16 glyphCount, GlyphIterator *glyphIterator, const LEReferenceTo<ClassDefinitionTable> &classDefinitionTable, LEErrorCode &success, le_bool backtrack) { if (LE_FAILURE(success)) { return FALSE; } le_int32 direction = 1; le_int32 match = 0; if (backtrack) { match = glyphCount - 1; direction = -1; } while (glyphCount > 0) { if (! glyphIterator->next()) { return FALSE; } LEGlyphID glyph = glyphIterator->getCurrGlyphID(); le_int32 glyphClass = classDefinitionTable->getGlyphClass(classDefinitionTable, glyph, success); le_int32 matchClass = SWAPW(classArray[match]); if (glyphClass != matchClass) { // Some fonts, e.g. Traditional Arabic, have classes // in the class array which aren't in the class definition // table. If we're looking for such a class, pretend that // we found it. if (classDefinitionTable->hasGlyphClass(classDefinitionTable, matchClass, success)) { return FALSE; } } glyphCount -= 1; match += direction; } return TRUE; }
le_int32 LookupProcessor::selectLookups(const LEReferenceTo<FeatureTable> &featureTable, FeatureMask featureMask, le_int32 order, LEErrorCode &success) { le_uint16 lookupCount = featureTable.isValid()? SWAPW(featureTable->lookupCount) : 0; le_int32 store = order; LEReferenceToArrayOf<le_uint16> lookupListIndexArray(featureTable, success, featureTable->lookupListIndexArray, lookupCount); for (le_uint16 lookup = 0; LE_SUCCESS(success) && lookup < lookupCount; lookup += 1) { le_uint16 lookupListIndex = SWAPW(lookupListIndexArray.getObject(lookup,success)); if (lookupListIndex >= lookupSelectCount) { continue; } lookupSelectArray[lookupListIndex] |= featureMask; lookupOrderArray[store++] = lookupListIndex; } return store - order; }
CanonMarkFilter::CanonMarkFilter(const LEReferenceTo<GlyphDefinitionTableHeader> &gdefTable, LEErrorCode &success) : classDefTable(gdefTable->getMarkAttachClassDefinitionTable(gdefTable, success)) { }
LookupProcessor::LookupProcessor(const LETableReference &baseAddress, Offset scriptListOffset, Offset featureListOffset, Offset lookupListOffset, LETag scriptTag, LETag languageTag, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool orderFeatures, LEErrorCode& success) : lookupListTable(), featureListTable(), lookupSelectArray(NULL), lookupSelectCount(0), lookupOrderArray(NULL), lookupOrderCount(0), fReference(baseAddress) { LEReferenceTo<ScriptListTable> scriptListTable; LEReferenceTo<LangSysTable> langSysTable; le_uint16 featureCount = 0; le_uint16 lookupListCount = 0; le_uint16 requiredFeatureIndex = 0xFFFF; if (LE_FAILURE(success)) { return; } if (scriptListOffset != 0) { scriptListTable = LEReferenceTo<ScriptListTable>(baseAddress, success, scriptListOffset); langSysTable = scriptListTable->findLanguage(scriptListTable, scriptTag, languageTag, success); if (langSysTable.isValid() && LE_SUCCESS(success)) { featureCount = SWAPW(langSysTable->featureCount); } } if (featureListOffset != 0) { featureListTable = LEReferenceTo<FeatureListTable>(baseAddress, success, featureListOffset); } if (lookupListOffset != 0) { lookupListTable = LEReferenceTo<LookupListTable>(baseAddress,success, lookupListOffset); if(LE_SUCCESS(success) && lookupListTable.isValid()) { lookupListCount = SWAPW(lookupListTable->lookupCount); } } if (langSysTable.isEmpty() || featureListTable.isEmpty() || lookupListTable.isEmpty() || featureCount == 0 || lookupListCount == 0) { return; } if(langSysTable.isValid()) { requiredFeatureIndex = SWAPW(langSysTable->reqFeatureIndex); } lookupSelectArray = LE_NEW_ARRAY(FeatureMask, lookupListCount); if (lookupSelectArray == NULL) { success = LE_MEMORY_ALLOCATION_ERROR; return; } for (int i = 0; i < lookupListCount; i += 1) { lookupSelectArray[i] = 0; } lookupSelectCount = lookupListCount; le_int32 count, order = 0; le_uint32 featureReferences = 0; LEReferenceTo<FeatureTable> featureTable; LETag featureTag; LEReferenceTo<FeatureTable> requiredFeatureTable; LETag requiredFeatureTag = 0x00000000U; // Count the total number of lookups referenced by all features. This will // be the maximum number of entries in the lookupOrderArray. We can't use // lookupListCount because some lookups might be referenced by more than // one feature. if(featureListTable.isValid() && LE_SUCCESS(success)) { LEReferenceToArrayOf<le_uint16> featureIndexArray(langSysTable, success, langSysTable->featureIndexArray, featureCount); for (le_uint32 feature = 0; LE_SUCCESS(success)&&(feature < featureCount); feature += 1) { le_uint16 featureIndex = SWAPW(featureIndexArray.getObject(feature, success)); featureTable = featureListTable->getFeatureTable(featureListTable, featureIndex, &featureTag, success); if (!featureTable.isValid() || LE_FAILURE(success)) { continue; } featureReferences += SWAPW(featureTable->lookupCount); } } if (!featureTable.isValid() || LE_FAILURE(success)) { success = LE_INTERNAL_ERROR; return; } if (requiredFeatureIndex != 0xFFFF) { requiredFeatureTable = featureListTable->getFeatureTable(featureListTable, requiredFeatureIndex, &requiredFeatureTag, success); if (LE_FAILURE(success)) return; featureReferences += SWAPW(requiredFeatureTable->lookupCount); } lookupOrderArray = LE_NEW_ARRAY(le_uint16, featureReferences); if (lookupOrderArray == NULL) { success = LE_MEMORY_ALLOCATION_ERROR; return; } lookupOrderCount = featureReferences; for (le_int32 f = 0; f < featureMapCount; f += 1) { FeatureMap fm = featureMap[f]; count = 0; // If this is the required feature, add its lookups if (requiredFeatureTag == fm.tag) { count += selectLookups(requiredFeatureTable, fm.mask, order, success); } if (orderFeatures) { // If we added lookups from the required feature, sort them if (count > 1) { OpenTypeUtilities::sort(lookupOrderArray, order); } for (le_uint16 feature = 0; feature < featureCount; feature += 1) { LEReferenceToArrayOf<le_uint16> featureIndexArray(langSysTable, success, langSysTable->featureIndexArray, featureCount); if (LE_FAILURE(success)) { continue; } le_uint16 featureIndex = SWAPW(featureIndexArray.getObject(feature,success)); // don't add the required feature to the list more than once... // TODO: Do we need this check? (Spec. says required feature won't be in feature list...) if (featureIndex == requiredFeatureIndex) { continue; } featureTable = featureListTable->getFeatureTable(featureListTable, featureIndex, &featureTag, success); if (LE_FAILURE(success)) continue; if (featureTag == fm.tag) { count += selectLookups(featureTable, fm.mask, order + count, success); } } if (count > 1) { OpenTypeUtilities::sort(&lookupOrderArray[order], count); } order += count; } else if(langSysTable.isValid()) { LEReferenceToArrayOf<le_uint16> featureIndexArray(langSysTable, success, langSysTable->featureIndexArray, featureCount); for (le_uint16 feature = 0; LE_SUCCESS(success)&& (feature < featureCount); feature += 1) { le_uint16 featureIndex = SWAPW(featureIndexArray.getObject(feature,success)); // don't add the required feature to the list more than once... // NOTE: This check is commented out because the spec. says that // the required feature won't be in the feature list, and because // any duplicate entries will be removed below. #if 0 if (featureIndex == requiredFeatureIndex) { continue; } #endif featureTable = featureListTable->getFeatureTable(featureListTable, featureIndex, &featureTag, success); if (LE_FAILURE(success)) continue; if (featureTag == fm.tag) { order += selectLookups(featureTable, fm.mask, order, success); } } } } if (!orderFeatures && (order > 1)) { OpenTypeUtilities::sort(lookupOrderArray, order); // If there's no specified feature order, // we will apply the lookups in the order // that they're in the font. If a particular // lookup may be referenced by more than one feature, // it will apprear in the lookupOrderArray more than // once, so remove any duplicate entries in the sorted array. le_int32 out = 1; for (le_int32 in = 1; in < order; in += 1) { if (lookupOrderArray[out - 1] != lookupOrderArray[in]) { if (out != in) { lookupOrderArray[out] = lookupOrderArray[in]; } out += 1; } } order = out; } lookupOrderCount = order; }