Change type of SkGlyph::fAdvance[XY] to float.

src/core/SkPaint.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPaint.h"
 #include "SkAutoKern.h"
 #include "SkChecksum.h"
@@ skipping 715 matching lines @@
     SkTLazy<SkPaint> fLazy;
 };
 
 static void set_bounds(const SkGlyph& g, SkRect* bounds) {
     bounds->set(SkIntToScalar(g.fLeft),
                 SkIntToScalar(g.fTop),
                 SkIntToScalar(g.fLeft + g.fWidth),
                 SkIntToScalar(g.fTop + g.fHeight));
 }
 
-static void join_bounds_x(const SkGlyph& g, SkRect* bounds, Sk48Dot16 dx) {
-    SkScalar sx = Sk48Dot16ToScalar(dx);
-    bounds->join(SkIntToScalar(g.fLeft) + sx,
+static void join_bounds_x(const SkGlyph& g, SkRect* bounds, SkScalar dx) {
+    bounds->join(SkIntToScalar(g.fLeft) + dx,
                  SkIntToScalar(g.fTop),
-                 SkIntToScalar(g.fLeft + g.fWidth) + sx,
+                 SkIntToScalar(g.fLeft + g.fWidth) + dx,
                  SkIntToScalar(g.fTop + g.fHeight));
 }
 
-static void join_bounds_y(const SkGlyph& g, SkRect* bounds, Sk48Dot16 dy) {
-    SkScalar sy = Sk48Dot16ToScalar(dy);
+static void join_bounds_y(const SkGlyph& g, SkRect* bounds, SkScalar dy) {
     bounds->join(SkIntToScalar(g.fLeft),
-                 SkIntToScalar(g.fTop) + sy,
+                 SkIntToScalar(g.fTop) + dy,
                  SkIntToScalar(g.fLeft + g.fWidth),
-                 SkIntToScalar(g.fTop + g.fHeight) + sy);
+                 SkIntToScalar(g.fTop + g.fHeight) + dy);
 }
 
-typedef void (*JoinBoundsProc)(const SkGlyph&, SkRect*, Sk48Dot16);
+typedef void (*JoinBoundsProc)(const SkGlyph&, SkRect*, SkScalar);
 
 // xyIndex is 0 for fAdvanceX or 1 for fAdvanceY
-static SkFixed advance(const SkGlyph& glyph, int xyIndex) {
+static SkScalar advance(const SkGlyph& glyph, int xyIndex) {
     SkASSERT(0 == xyIndex || 1 == xyIndex);
-    return (&glyph.fAdvanceX)[xyIndex];
+    return SkFloatToScalar((&glyph.fAdvanceX)[xyIndex]);
 }
 
 SkScalar SkPaint::measure_text(SkGlyphCache* cache,
                                const char* text, size_t byteLength,
                                int* count, SkRect* bounds) const {
     SkASSERT(count);
     if (byteLength == 0) {
         *count = 0;
         if (bounds) {
             bounds->setEmpty();
         }
         return 0;
     }
 
     GlyphCacheProc glyphCacheProc = this->getGlyphCacheProc(nullptr != bounds);
 
     int xyIndex;
     JoinBoundsProc joinBoundsProc;
     if (this->isVerticalText()) {
         xyIndex = 1;
         joinBoundsProc = join_bounds_y;
     } else {
         xyIndex = 0;
         joinBoundsProc = join_bounds_x;
     }
 
     int         n = 1;
     const char* stop = (const char*)text + byteLength;
     const SkGlyph* g = &glyphCacheProc(cache, &text);
-    // our accumulated fixed-point advances might overflow 16.16, so we use
-    // a 48.16 (64bit) accumulator, and then convert that to scalar at the
-    // very end.
-    Sk48Dot16 x = advance(*g, xyIndex);
-
-    SkAutoKern  autokern;
+    SkScalar x = advance(*g, xyIndex);
 
     if (nullptr == bounds) {
         if (this->isDevKernText()) {
-            int rsb;
             for (; text < stop; n++) {
-                rsb = g->fRsbDelta;
+                const int rsb = g->fRsbDelta;
                 g = &glyphCacheProc(cache, &text);
-                x += SkAutoKern_AdjustF(rsb, g->fLsbDelta) + advance(*g, xyIndex);
+                x += SkAutoKern_Adjust(rsb, g->fLsbDelta) + advance(*g, xyIndex);
             }
         } else {
             for (; text < stop; n++) {
                 x += advance(glyphCacheProc(cache, &text), xyIndex);
             }
         }
     } else {
         set_bounds(*g, bounds);
         if (this->isDevKernText()) {
-            int rsb;
             for (; text < stop; n++) {
-                rsb = g->fRsbDelta;
+                const int rsb = g->fRsbDelta;
                 g = &glyphCacheProc(cache, &text);
-                x += SkAutoKern_AdjustF(rsb, g->fLsbDelta);
+                x += SkAutoKern_Adjust(rsb, g->fLsbDelta);
                 joinBoundsProc(*g, bounds, x);
                 x += advance(*g, xyIndex);
             }
         } else {
             for (; text < stop; n++) {
                 g = &glyphCacheProc(cache, &text);
                 joinBoundsProc(*g, bounds, x);
                 x += advance(*g, xyIndex);
             }
         }
     }
     SkASSERT(text == stop);
 
     *count = n;
-    return Sk48Dot16ToScalar(x);
+    return x;
 }
 
 SkScalar SkPaint::measureText(const void* textData, size_t length, SkRect* bounds) const {
     const char* text = (const char*)textData;
     SkASSERT(text != nullptr || length == 0);
 
     SkCanonicalizePaint canon(*this);
     const SkPaint& paint = canon.getPaint();
     SkScalar scale = canon.getScale();
 
@@ skipping 49 matching lines @@
     // adjust max in case we changed the textSize in paint
     if (scale) {
         maxWidth /= scale;
     }
 
     SkAutoGlyphCache    autoCache(paint, nullptr, nullptr);
     SkGlyphCache*       cache = autoCache.getCache();
 
     GlyphCacheProc   glyphCacheProc = paint.getGlyphCacheProc(false);
     const int        xyIndex = paint.isVerticalText() ? 1 : 0;
-    // use 64bits for our accumulator, to avoid overflowing 16.16
-    Sk48Dot16        max = SkScalarTo48Dot16(maxWidth);
-    Sk48Dot16        width = 0;
-
-    SkAutoKern  autokern;
+    SkScalar         width = 0;
 
     if (this->isDevKernText()) {
         int rsb = 0;
         while (text < stop) {
             const char* curr = text;
             const SkGlyph& g = glyphCacheProc(cache, &text);
-            SkFixed x = SkAutoKern_AdjustF(rsb, g.fLsbDelta) + advance(g, xyIndex);
-            if ((width += x) > max) {
+            SkScalar x = SkAutoKern_Adjust(rsb, g.fLsbDelta) + advance(g, xyIndex);
+            if ((width += x) > maxWidth) {
                 width -= x;
                 text = curr;
                 break;
             }
             rsb = g.fRsbDelta;
         }
     } else {
         while (text < stop) {
             const char* curr = text;
-            SkFixed x = advance(glyphCacheProc(cache, &text), xyIndex);
-            if ((width += x) > max) {
+            SkScalar x = advance(glyphCacheProc(cache, &text), xyIndex);
+            if ((width += x) > maxWidth) {
                 width -= x;
                 text = curr;
                 break;
             }
         }
     }
 
     if (measuredWidth) {
-        SkScalar scalarWidth = Sk48Dot16ToScalar(width);
         if (scale) {
-            scalarWidth = SkScalarMul(scalarWidth, scale);
+            width *= scale;
         }
-        *measuredWidth = scalarWidth;
+        *measuredWidth = width;
     }
 
     // return the number of bytes measured
     return text - stop + length;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static bool FontMetricsCacheProc(const SkGlyphCache* cache, void* context) {
     *(SkPaint::FontMetrics*)context = cache->getFontMetrics();
@@ skipping 69 matching lines @@
     GlyphCacheProc      glyphCacheProc = paint.getGlyphCacheProc(nullptr != bounds);
 
     const char* text = (const char*)textData;
     const char* stop = text + byteLength;
     int         count = 0;
     const int   xyIndex = paint.isVerticalText() ? 1 : 0;
 
     if (this->isDevKernText()) {
         // we adjust the widths returned here through auto-kerning
         SkAutoKern  autokern;
-        SkFixed     prevWidth = 0;
+        SkScalar    prevWidth = 0;
 
         if (scale) {
             while (text < stop) {
                 const SkGlyph& g = glyphCacheProc(cache, &text);
                 if (widths) {
-                    SkFixed  adjust = autokern.adjust(g);
+                    SkScalar adjust = autokern.adjust(g);
 
                     if (count > 0) {
-                        SkScalar w = SkFixedToScalar(prevWidth + adjust);
-                        *widths++ = SkScalarMul(w, scale);
+                        *widths++ = SkScalarMul(prevWidth + adjust, scale);
                     }
                     prevWidth = advance(g, xyIndex);
                 }
                 if (bounds) {
                     set_bounds(g, bounds++, scale);
                 }
                 ++count;
             }
             if (count > 0 && widths) {
-                *widths = SkScalarMul(SkFixedToScalar(prevWidth), scale);
+                *widths = SkScalarMul(prevWidth, scale);
             }
         } else {
             while (text < stop) {
                 const SkGlyph& g = glyphCacheProc(cache, &text);
                 if (widths) {
-                    SkFixed  adjust = autokern.adjust(g);
+                    SkScalar adjust = autokern.adjust(g);
 
                     if (count > 0) {
-                        *widths++ = SkFixedToScalar(prevWidth + adjust);
+                        *widths++ = prevWidth + adjust;
                     }
                     prevWidth = advance(g, xyIndex);
                 }
                 if (bounds) {
                     set_bounds(g, bounds++);
                 }
                 ++count;
             }
             if (count > 0 && widths) {
-                *widths = SkFixedToScalar(prevWidth);
+                *widths = prevWidth;
             }
         }
     } else {    // no devkern
         if (scale) {
             while (text < stop) {
                 const SkGlyph& g = glyphCacheProc(cache, &text);
                 if (widths) {
-                    *widths++ = SkScalarMul(SkFixedToScalar(advance(g, xyIndex)),
+                    *widths++ = SkScalarMul(advance(g, xyIndex),
                                             scale);
                 }
                 if (bounds) {
                     set_bounds(g, bounds++, scale);
                 }
                 ++count;
             }
         } else {
             while (text < stop) {
                 const SkGlyph& g = glyphCacheProc(cache, &text);
                 if (widths) {
-                    *widths++ = SkFixedToScalar(advance(g, xyIndex));
+                    *widths++ = advance(g, xyIndex);
                 }
                 if (bounds) {
                     set_bounds(g, bounds++);
                 }
                 ++count;
             }
         }
     }
 
     SkASSERT(text == stop);
@@ skipping 1195 matching lines @@
 }
 
 SkTextBaseIter::~SkTextBaseIter() {
     SkGlyphCache::AttachCache(fCache);
 }
 
 bool SkTextToPathIter::next(const SkPath** path, SkScalar* xpos) {
     if (fText < fStop) {
         const SkGlyph& glyph = fGlyphCacheProc(fCache, &fText);
 
-        fXPos += SkScalarMul(SkFixedToScalar(fPrevAdvance + fAutoKern.adjust(glyph)), fScale);
+        fXPos += SkScalarMul(fPrevAdvance + fAutoKern.adjust(glyph), fScale);
         fPrevAdvance = advance(glyph, fXYIndex);   // + fPaint.getTextTracking();
 
         if (glyph.fWidth) {
             if (path) {
                 *path = fCache->findPath(glyph);
             }
         } else {
             if (path) {
                 *path = nullptr;
             }
         }
         if (xpos) {
             *xpos = fXPos;
         }
         return true;
     }
     return false;
 }
 
 bool SkTextInterceptsIter::next(SkScalar* array, int* count) {
     const SkGlyph& glyph = fGlyphCacheProc(fCache, &fText);
-    fXPos += SkScalarMul(SkFixedToScalar(fPrevAdvance + fAutoKern.adjust(glyph)), fScale);
+    fXPos += SkScalarMul(fPrevAdvance + fAutoKern.adjust(glyph), fScale);
     fPrevAdvance = advance(glyph, fXYIndex);   // + fPaint.getTextTracking();
     if (fCache->findPath(glyph)) {
         fCache->findIntercepts(fBounds, fScale, fXPos, SkToBool(fXYIndex),
                 const_cast<SkGlyph*>(&glyph), array, count);
     }
     return fText < fStop;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 35 matching lines @@
 }
 
 uint32_t SkPaint::getHash() const {
     // We're going to hash 10 pointers and 7 32-bit values, finishing up with fBitfields,
     // so fBitfields should be 10 pointers and 6 32-bit values from the start.
     static_assert(offsetof(SkPaint, fBitfields) == 9 * sizeof(void*) + 6 * sizeof(uint32_t),
                   "SkPaint_notPackedTightly");
     return SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(this),
                                offsetof(SkPaint, fBitfields) + sizeof(fBitfields));
 }