Offset-only GlyphBuffer

Source/platform/fonts/shaping/HarfBuzzShaper.cpp

 /*
  * Copyright (c) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013 BlackBerry Limited. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 931 matching lines @@
         glyphBounds.move(glyphOrigin.x(), glyphOrigin.y());
         m_glyphBoundingBox.unite(glyphBounds);
         glyphOrigin += FloatSize(advance + offsetX, offsetY);
 
         totalAdvance += advance;
     }
     currentRun->setWidth(totalAdvance > 0.0 ? totalAdvance : 0.0);
     m_totalWidth += currentRun->width();
 }
 
-void HarfBuzzShaper::fillGlyphBufferFromHarfBuzzRun(GlyphBuffer* glyphBuffer,
-    HarfBuzzRun* currentRun, float& carryAdvance)
+float HarfBuzzShaper::fillGlyphBufferFromHarfBuzzRun(GlyphBuffer* glyphBuffer,
+    HarfBuzzRun* currentRun, float initialAdvance)
 {
     FloatSize* offsets = currentRun->offsets();
     uint16_t* glyphs = currentRun->glyphs();
     float* advances = currentRun->advances();
     unsigned numGlyphs = currentRun->numGlyphs();
     uint16_t* glyphToCharacterIndexes = currentRun->glyphToCharacterIndexes();
-    FloatSize runStartOffset = FloatSize();
+    float advanceSoFar = initialAdvance;
     if (m_run.rtl()) {
         for (unsigned i = 0; i < numGlyphs; ++i) {
             uint16_t currentCharacterIndex = currentRun->startIndex() + glyphToCharacterIndexes[i];
             if (currentCharacterIndex >= m_toIndex) {
-                carryAdvance += advances[i];
+                advanceSoFar += advances[i];
             } else if (currentCharacterIndex >= m_fromIndex) {
-                runStartOffset = HB_DIRECTION_IS_HORIZONTAL(currentRun->direction()) ? FloatSize(carryAdvance, 0) : FloatSize(0, carryAdvance);
-                glyphBuffer->add(glyphs[i], currentRun->fontData(), runStartOffset + offsets[i], carryAdvance + advances[i]);
-                carryAdvance = 0;
+                FloatPoint runStartOffset = HB_DIRECTION_IS_HORIZONTAL(currentRun->direction()) ?
+                    FloatPoint(advanceSoFar, 0) : FloatPoint(0, advanceSoFar);
+                glyphBuffer->add(glyphs[i], currentRun->fontData(), runStartOffset + offsets[i]);
+                advanceSoFar += advances[i];
             }
         }
     } else {
         for (unsigned i = 0; i < numGlyphs; ++i) {
             uint16_t currentCharacterIndex = currentRun->startIndex() + glyphToCharacterIndexes[i];
             if (currentCharacterIndex < m_fromIndex) {
-                carryAdvance += advances[i];
+                advanceSoFar += advances[i];
             } else if (currentCharacterIndex < m_toIndex) {
-                runStartOffset = HB_DIRECTION_IS_HORIZONTAL(currentRun->direction()) ? FloatSize(carryAdvance, 0) : FloatSize(0, carryAdvance);
-                glyphBuffer->add(glyphs[i], currentRun->fontData(), runStartOffset + offsets[i], carryAdvance + advances[i]);
-                carryAdvance = 0;
+                FloatPoint runStartOffset = HB_DIRECTION_IS_HORIZONTAL(currentRun->direction()) ?
+                    FloatPoint(advanceSoFar, 0) : FloatPoint(0, advanceSoFar);
+                glyphBuffer->add(glyphs[i], currentRun->fontData(), runStartOffset + offsets[i]);
+                advanceSoFar += advances[i];
             }
         }
     }
+
+    return advanceSoFar - initialAdvance;
 }
 
-void HarfBuzzShaper::fillGlyphBufferForTextEmphasis(GlyphBuffer* glyphBuffer, HarfBuzzRun* currentRun)
+float HarfBuzzShaper::fillGlyphBufferForTextEmphasis(GlyphBuffer* glyphBuffer, HarfBuzzRun* currentRun, float initialAdvance)
 {
     // FIXME: Instead of generating a synthetic GlyphBuffer here which is then used by the
     // drawEmphasisMarks method of FontFastPath, we should roll our own emphasis mark drawing function.
 
     float* advances = currentRun->advances();
     unsigned numGlyphs = currentRun->numGlyphs();
     uint16_t* glyphToCharacterIndexes = currentRun->glyphToCharacterIndexes();
     unsigned graphemesInCluster = 1;
     float clusterAdvance = 0;
     uint16_t clusterStart;
 
     // A "cluster" in this context means a cluster as it is used by HarfBuzz:
     // The minimal group of characters and corresponding glyphs, that cannot be broken
     // down further from a text shaping point of view.
     // A cluster can contain multiple glyphs and grapheme clusters, with mutually
     // overlapping boundaries. Below we count grapheme clusters per HarfBuzz clusters,
     // then linearly split the sum of corresponding glyph advances by the number of
     // grapheme clusters in order to find positions for emphasis mark drawing.
 
     if (m_run.rtl())
         clusterStart = currentRun->startIndex() + currentRun->numCharacters();
     else
         clusterStart = currentRun->startIndex() + glyphToCharacterIndexes[0];
 
+    float advanceSoFar = initialAdvance;
     for (unsigned i = 0; i < numGlyphs; ++i) {
         uint16_t currentCharacterIndex = currentRun->startIndex() + glyphToCharacterIndexes[i];
         bool isRunEnd = (i + 1 == numGlyphs);
         bool isClusterEnd =  isRunEnd || (currentRun->startIndex() + glyphToCharacterIndexes[i + 1] != currentCharacterIndex);
         clusterAdvance += advances[i];
 
         if (isClusterEnd) {
             uint16_t clusterEnd;
             if (m_run.rtl())
                 clusterEnd = currentCharacterIndex;
             else
                 clusterEnd = isRunEnd ? currentRun->startIndex() + currentRun->numCharacters() : currentRun->startIndex() + glyphToCharacterIndexes[i + 1];
 
             graphemesInCluster = countGraphemesInCluster(m_normalizedBuffer.get(), m_normalizedBufferLength, clusterStart, clusterEnd);
             if (!graphemesInCluster || !clusterAdvance)
                 continue;
 
             float glyphAdvanceX = clusterAdvance / graphemesInCluster;
             for (unsigned j = 0; j < graphemesInCluster; ++j) {
                 // Do not put emphasis marks on space, separator, and control characters.
                 Glyph glyphToAdd = Character::canReceiveTextEmphasis(m_run[currentCharacterIndex]) ? 1 : 0;
-                glyphBuffer->add(glyphToAdd, currentRun->fontData(), glyphAdvanceX);
+                // The emphasis code expects mid-glyph offsets.
+                glyphBuffer->add(glyphToAdd, currentRun->fontData(), advanceSoFar + glyphAdvanceX / 2);
+                advanceSoFar += glyphAdvanceX;
             }
             clusterStart = clusterEnd;
             clusterAdvance = 0;
         }
     }
+
+    return advanceSoFar - initialAdvance;
 }
 
 bool HarfBuzzShaper::fillGlyphBuffer(GlyphBuffer* glyphBuffer)
 {
+    ASSERT(glyphBuffer);
+
     unsigned numRuns = m_harfBuzzRuns.size();
-    float carryAdvance = 0;
-    if (m_run.rtl()) {
-        for (int runIndex = numRuns - 1; runIndex >= 0; --runIndex) {
-            HarfBuzzRun* currentRun = m_harfBuzzRuns[runIndex].get();
-            if (!currentRun->hasGlyphToCharacterIndexes()) {
-                // FIXME: bug 337886, 359664
-                continue;
-            }
-            if (m_forTextEmphasis == ForTextEmphasis) {
-                fillGlyphBufferForTextEmphasis(glyphBuffer, currentRun);
-            } else {
-                fillGlyphBufferFromHarfBuzzRun(glyphBuffer, currentRun, carryAdvance);
-            }
+    float advanceSoFar = 0;
+    for (unsigned runIndex = 0; runIndex < numRuns; ++runIndex) {
+        HarfBuzzRun* currentRun = m_harfBuzzRuns[m_run.ltr() ? runIndex : numRuns - runIndex - 1].get();
+        if (!currentRun->hasGlyphToCharacterIndexes()) {
+            // FIXME: bug 337886, 359664
+            continue;
         }
-    } else {
-        for (unsigned runIndex = 0; runIndex < numRuns; ++runIndex) {
-            HarfBuzzRun* currentRun = m_harfBuzzRuns[runIndex].get();
-            if (!currentRun->hasGlyphToCharacterIndexes()) {
-                // FIXME: bug 337886, 359664
-                continue;
-            }
-            if (m_forTextEmphasis == ForTextEmphasis) {
-                fillGlyphBufferForTextEmphasis(glyphBuffer, currentRun);
-            } else {
-                fillGlyphBufferFromHarfBuzzRun(glyphBuffer, currentRun, carryAdvance);
-            }
-        }
+        advanceSoFar += (m_forTextEmphasis == ForTextEmphasis)
+            ? fillGlyphBufferForTextEmphasis(glyphBuffer, currentRun, advanceSoFar)
+            : fillGlyphBufferFromHarfBuzzRun(glyphBuffer, currentRun, advanceSoFar);
     }
     return glyphBuffer->size();
 }
 
 int HarfBuzzShaper::offsetForPosition(float targetX)
 {
     int charactersSoFar = 0;
     float currentX = 0;
 
     if (m_run.rtl()) {
@@ skipping 64 matching lines @@
         fromX = 0;
     if (!foundToX)
         toX = m_run.rtl() ? 0 : m_totalWidth;
 
     if (fromX < toX)
         return FloatRect(point.x() + fromX, point.y(), toX - fromX, height);
     return FloatRect(point.x() + toX, point.y(), fromX - toX, height);
 }
 
 } // namespace blink