Use ARM fixes for SDF encoding.

src/core/SkDistanceFieldGen.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDistanceFieldGen.h"
 #include "SkPoint.h"
 
@@ skipping 298 matching lines @@
         distVec.fY += 1.0f;
         curr->fDistSq = distSq;
         curr->fDistVector = distVec;
     }
 }
 
 // enable this to output edge data rather than the distance field
 #define DUMP_EDGE 0
 
 #if !DUMP_EDGE
-static unsigned char pack_distance_field_val(float dist, float distanceMagnitude) {
-    if (dist <= -distanceMagnitude) {
-        return 255;
-    } else if (dist > distanceMagnitude) {
-        return 0;
-    } else {
-        return (unsigned char)((distanceMagnitude-dist)*128.0f/distanceMagnitude);
-    }
+template <int distanceMagnitude>
+static unsigned char pack_distance_field_val(float dist) {
+    // The distance field is constructed as unsigned char values, so that the zero value is at 128,
+    // Beside 128, we have 128 values in range [0, 128), but only 127 values in range (128, 255].
+    // So we multiply distanceMagnitude by 127/128 at the latter range to avoid overflow.
+    dist = SkScalarPin(-dist, -distanceMagnitude, distanceMagnitude * 127.0f / 128.0f);
+
+    // Scale into the positive range for unsigned distance.
+    dist += distanceMagnitude;
+
+    // Scale into unsigned char range.
+    // Round to place negative and positive values as equally as possible around 128
+    // (which represents zero).
+    return (unsigned char)SkScalarRoundToInt(dist / (2 * distanceMagnitude) * 256.0f);
 }
 #endif
 
 // assumes a padded 8-bit image and distance field
 // width and height are the original width and height of the image
 static bool generate_distance_field_from_image(unsigned char* distanceField,
                                                const unsigned char* copyPtr,
                                                int width, int height) {
     SkASSERT(distanceField);
     SkASSERT(copyPtr);
@@ skipping 97 matching lines @@
             float result = alpha + (1.0f-alpha)*edge;
             unsigned char val = sk_float_round2int(255*result);
             *dfPtr++ = val;
 #else
             float dist;
             if (currData->fAlpha > 0.5f) {
                 dist = -SkScalarSqrt(currData->fDistSq);
             } else {
                 dist = SkScalarSqrt(currData->fDistSq);
             }
-            *dfPtr++ = pack_distance_field_val(dist, (float)SK_DistanceFieldMagnitude);
+            *dfPtr++ = pack_distance_field_val<SK_DistanceFieldMagnitude>(dist);
 #endif
             ++currData;
             ++currEdge;
         }
         currData += 2;
         currEdge += 2;
     }
 
     return true;
 }
@@ skipping 52 matching lines @@
                 *currDestPtr++ = (mask & (1 << i)) ? 0xff : 0;
             }
         }
         currSrcScanLine += rowBytes;
         *currDestPtr++ = 0;
     }
     sk_bzero(currDestPtr, (width+2)*sizeof(char));
 
     return generate_distance_field_from_image(distanceField, copyPtr, width, height);
 }