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_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; }
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; }