void HarfBuzzShaper::prependHolesQueue(HolesQueueItemAction action,
unsigned startIndex,
unsigned numCharacters)
{
m_holesQueue.prepend(HolesQueueItem(action, startIndex, numCharacters));
}
bool HarfBuzzShaper::extractShapeResults(hb_buffer_t* harfBuzzBuffer,
ShapeResult* shapeResult,
bool& fontCycleQueued,
Deque<HolesQueueItem>* holesQueue,
const HolesQueueItem& currentQueueItem,
const Font* font,
const SimpleFontData* currentFont,
UScriptCode currentRunScript,
bool isLastResort) const {
enum ClusterResult { Shaped, NotDef, Unknown };
ClusterResult currentClusterResult = Unknown;
ClusterResult previousClusterResult = Unknown;
unsigned previousCluster = 0;
unsigned currentCluster = 0;
// Find first notdef glyph in harfBuzzBuffer.
unsigned numGlyphs = hb_buffer_get_length(harfBuzzBuffer);
hb_glyph_info_t* glyphInfo = hb_buffer_get_glyph_infos(harfBuzzBuffer, 0);
unsigned lastChangePosition = 0;
if (!numGlyphs) {
DLOG(ERROR) << "HarfBuzz returned empty glyph buffer after shaping.";
return false;
}
for (unsigned glyphIndex = 0; glyphIndex <= numGlyphs; ++glyphIndex) {
// Iterating by clusters, check for when the state switches from shaped
// to non-shaped and vice versa. Taking into account the edge cases of
// beginning of the run and end of the run.
previousCluster = currentCluster;
currentCluster = glyphInfo[glyphIndex].cluster;
if (glyphIndex < numGlyphs) {
// Still the same cluster, merge shaping status.
if (previousCluster == currentCluster && glyphIndex != 0) {
if (glyphInfo[glyphIndex].codepoint == 0) {
currentClusterResult = NotDef;
} else {
// We can only call the current cluster fully shapped, if
// all characters that are part of it are shaped, so update
// currentClusterResult to Shaped only if the previous
// characters have been shaped, too.
currentClusterResult =
currentClusterResult == Shaped ? Shaped : NotDef;
}
continue;
}
// We've moved to a new cluster.
previousClusterResult = currentClusterResult;
currentClusterResult =
glyphInfo[glyphIndex].codepoint == 0 ? NotDef : Shaped;
} else {
// The code below operates on the "flanks"/changes between NotDef
// and Shaped. In order to keep the code below from explictly
// dealing with character indices and run end, we explicitly
// terminate the cluster/run here by setting the result value to the
// opposite of what it was, leading to atChange turning true.
previousClusterResult = currentClusterResult;
currentClusterResult = currentClusterResult == NotDef ? Shaped : NotDef;
}
bool atChange = (previousClusterResult != currentClusterResult) &&
previousClusterResult != Unknown;
if (!atChange)
continue;
// Compute the range indices of consecutive shaped or .notdef glyphs.
// Cluster information for RTL runs becomes reversed, e.g. character 0
// has cluster index 5 in a run of 6 characters.
unsigned numCharacters = 0;
unsigned numGlyphsToInsert = 0;
unsigned startIndex = 0;
if (HB_DIRECTION_IS_FORWARD(hb_buffer_get_direction(harfBuzzBuffer))) {
startIndex = glyphInfo[lastChangePosition].cluster;
if (glyphIndex == numGlyphs) {
numCharacters = currentQueueItem.m_startIndex +
currentQueueItem.m_numCharacters -
glyphInfo[lastChangePosition].cluster;
numGlyphsToInsert = numGlyphs - lastChangePosition;
} else {
numCharacters = glyphInfo[glyphIndex].cluster -
glyphInfo[lastChangePosition].cluster;
numGlyphsToInsert = glyphIndex - lastChangePosition;
}
} else {
// Direction Backwards
startIndex = glyphInfo[glyphIndex - 1].cluster;
if (lastChangePosition == 0) {
numCharacters = currentQueueItem.m_startIndex +
currentQueueItem.m_numCharacters -
glyphInfo[glyphIndex - 1].cluster;
} else {
numCharacters = glyphInfo[lastChangePosition - 1].cluster -
glyphInfo[glyphIndex - 1].cluster;
}
numGlyphsToInsert = glyphIndex - lastChangePosition;
}
if (currentClusterResult == Shaped && !isLastResort) {
// Now it's clear that we need to continue processing.
if (!fontCycleQueued) {
holesQueue->append(HolesQueueItem(HolesQueueNextFont, 0, 0));
fontCycleQueued = true;
}
// Here we need to put character positions.
ASSERT(numCharacters);
holesQueue->append(
HolesQueueItem(HolesQueueRange, startIndex, numCharacters));
}
// If numCharacters is 0, that means we hit a NotDef before shaping the
// whole grapheme. We do not append it here. For the next glyph we
// encounter, atChange will be true, and the characters corresponding to
// the grapheme will be added to the TODO queue again, attempting to
// shape the whole grapheme with the next font.
// When we're getting here with the last resort font, we have no other
// choice than adding boxes to the ShapeResult.
if ((currentClusterResult == NotDef && numCharacters) || isLastResort) {
hb_direction_t direction = TextDirectionToHBDirection(
m_textDirection, font->getFontDescription().orientation(),
currentFont);
// Here we need to specify glyph positions.
ShapeResult::RunInfo* run = new ShapeResult::RunInfo(
currentFont, direction, ICUScriptToHBScript(currentRunScript),
startIndex, numGlyphsToInsert, numCharacters);
shapeResult->insertRun(WTF::wrapUnique(run), lastChangePosition,
numGlyphsToInsert, harfBuzzBuffer);
}
lastChangePosition = glyphIndex;
}
return true;
}