Add pinned versions of *ToFixed.

include/core/SkFixed.h

 /*
  * 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.
  */
 
 #ifndef SkFixed_DEFINED
 #define SkFixed_DEFINED
 
@@ skipping 10 matching lines @@
 #define SK_Fixed1           (1 << 16)
 #define SK_FixedHalf        (1 << 15)
 #define SK_FixedMax         (0x7FFFFFFF)
 #define SK_FixedMin         (-SK_FixedMax)
 #define SK_FixedPI          (0x3243F)
 #define SK_FixedSqrt2       (92682)
 #define SK_FixedTanPIOver8  (0x6A0A)
 #define SK_FixedRoot2Over2  (0xB505)
 
 #define SkFixedToFloat(x)   ((x) * 1.52587890625e-5f)
-#if 1
-    #define SkFloatToFixed(x)   ((SkFixed)((x) * SK_Fixed1))
-#else
-    // pins over/under flows to max/min int32 (slower than just a cast)
-    static inline SkFixed SkFloatToFixed(float x) {
-        int64_t n = x * SK_Fixed1;
-        return (SkFixed)n;
-    }
-#endif
+#define SkFloatToFixed(x)   ((SkFixed)((x) * SK_Fixed1))
+
+// Maximum input value for SkFloatToFixed. (-SK_FloatToFixedMax is the minimum.)
+// SkFixed has more precision than float near SK_FixedMax/SK_FixedMin. Values higher than

[mtklein, 2016/03/11 15:01:29]

Let's write "near SK_FixedMax and SK_FixedMin".  Best to avoid confusion about
division.

[dogben, 2016/03/11 16:33:19]

Removed.

+// SK_FloatToFixedMax will overflow SkFixed.
+// This must be a macro because MSVC doesn't like constexpr float.
+#define SK_FloatToFixedMax SkFixedToFloat(SK_FixedMax - 0x7f)

[mtklein, 2016/03/11 15:01:29]

Walk me through this math / logic?  I'm curious if we can write both float and
double limits in terms of (1<<31), which is really the fundamental limit of the
underlying int type, int32_t. 

Just a recap to make sure we're on the same page:
Float to int conversion works by truncating the float's fractional part, then
converting that remaining integral part to integer.
It's undefined if that integral part does not fit into the underlying integer.

So, for float -> int32_t, we get:
    0x00000000 --> 0.0f --> 0, ok
    ... skip many boring values ...
    0x4effffff --> 2147483520.0f --> 2147483520, which fits in int32_t
    0x4f000000 --> 2147483648.0f  --> 2147483648, does not fit in int32_t

And in negative, we get
    0x80000000 --> -0.0f --> 0, ok
    ... skip many boring values ...
    0xcf000000  --> -2147483648.0f --> -2147483648, which fits in int32_t
    0xcf000001  --> -2147483904.0f  --> -2147483904, does not fit in int32_t

This makes me wonder if we can write these like this:

static inline SkFixed SkFloatPinToFixed(float x) {
    x *= SK_Fixed1;
    // We're trying to avoid UB, which happens if we truncate x and its integral
part cannot fit into our underlying type (int32_t).
    if (x >= 2147483648) { return ... }
    if (x < -2147483648) { return ... }
    SkASSERT(truncf(x) == (float)(int32_t)x);
    return x;
}

[dogben, 2016/03/11 16:33:19]

Done, except it feels wrong to return values less than SK_FixedMin, so I changed
the < to <=.

My thinking was, "If I multiply first, I'll lose precision." But (obviously)
although epsilon will be larger, the amount of precision is the same.

+
+// Pins over/under flows to SK_FixedMax/SK_FixedMin (slower than just a cast).
+static inline SkFixed SkFloatPinToFixed(float x) {
+    static_assert(SkFixedToFloat(SkFloatToFixed(SK_FloatToFixedMax)) == SK_FloatToFixedMax,
+                  "SK_FloatToFixedMax is not the real max.");
+    static_assert(SkFixedToFloat(SkFloatToFixed(-SK_FloatToFixedMax)) == -SK_FloatToFixedMax,
+                  "-SK_FloatToFixedMax is not the real min.");
+    // Unlike SkDoublePinToFixed, we don't use SkTPin, because that would
+    // produce SkFloatToFixed(SK_FloatToFixedMax), which is less than SK_FixedMax.
+    if (x > SK_FloatToFixedMax) return SK_FixedMax;
+    if (x < -SK_FloatToFixedMax) return SK_FixedMin;
+    return SkFloatToFixed(x);
+}
 
 #ifdef SK_DEBUG
     static inline SkFixed SkFloatToFixed_Check(float x) {
         int64_t n64 = (int64_t)(x * SK_Fixed1);
         SkFixed n32 = (SkFixed)n64;
         SkASSERT(n64 == n32);
         return n32;
     }
 #else
     #define SkFloatToFixed_Check(x) SkFloatToFixed(x)
 #endif
 
 #define SkFixedToDouble(x)  ((x) * 1.52587890625e-5)
 #define SkDoubleToFixed(x)  ((SkFixed)((x) * SK_Fixed1))
 
+// Maximum input value for SkDoubleToFixed. (-SK_DoubleToFixedMax is the minimum.)
+// This must be a macro because MSVC doesn't like constexpr float.
+#define SK_DoubleToFixedMax SkFixedToDouble(SK_FixedMax)
+
+// Pins over/under flows to SK_FixedMax/SK_FixedMin (slower than just a cast).
+static inline SkFixed SkDoublePinToFixed(double x) {
+    static_assert(SkFixedToDouble(SkDoubleToFixed(SK_DoubleToFixedMax)) == SK_DoubleToFixedMax,
+                  "SK_DoubleToFixedMax is not the real max.");
+    static_assert(SkFixedToDouble(SkDoubleToFixed(-SK_DoubleToFixedMax)) == -SK_DoubleToFixedMax,
+                  "-SK_DoubleToFixedMax is not the real min.");
+    return static_cast<SkFixed>(SkTPin(x, -SK_DoubleToFixedMax, SK_DoubleToFixedMax) * SK_Fixed1);
+}
+
 /** Converts an integer to a SkFixed, asserting that the result does not overflow
     a 32 bit signed integer
 */
 #ifdef SK_DEBUG
     inline SkFixed SkIntToFixed(int n)
     {
         SkASSERT(n >= -32768 && n <= 32767);
         // Left shifting a negative value has undefined behavior in C, so we cast to unsigned before
         // shifting.
         return (unsigned)n << 16;
@@ skipping 96 matching lines @@
 #define Sk48Dot16FloorToInt(x)    static_cast<int>((x) >> 16)
 
 static inline float Sk48Dot16ToScalar(Sk48Dot16 x) {
     return static_cast<float>(x * 1.5258789e-5);  // x * (1.0f / (1 << 16))
 }
 #define SkFloatTo48Dot16(x)       (static_cast<Sk48Dot16>((x) * (1 << 16)))
 
 #define SkScalarTo48Dot16(x)      SkFloatTo48Dot16(x)
 
 #endif