Add Sk4f_RoundToInt

src/opts/SkColorXform_opts.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkColorXform_opts_DEFINED
 #define SkColorXform_opts_DEFINED
 
@@ skipping 66 matching lines @@
                         (kSRGB_DstGamma == kDstGamma) ? sk_linear_to_srgb : linear_to_2dot2;
 
                 dstReds   = linear_to_curve(dstReds);
                 dstGreens = linear_to_curve(dstGreens);
                 dstBlues  = linear_to_curve(dstBlues);
 
                 dstReds   = clamp_0_to_255(dstReds);
                 dstGreens = clamp_0_to_255(dstGreens);
                 dstBlues  = clamp_0_to_255(dstBlues);
 
-                auto rgba = (SkNx_cast<int>(dstReds)        )
-                          | (SkNx_cast<int>(dstGreens) <<  8)
-                          | (SkNx_cast<int>(dstBlues)  << 16)
-                          | (Sk4i{          0xFF       << 24});
+                auto rgba = (Sk4f_round(dstReds)        )
+                          | (Sk4f_round(dstGreens) <<  8)
+                          | (Sk4f_round(dstBlues)  << 16)
+                          | (Sk4i{      0xFF       << 24});
                 rgba.store(dst);
             } else {
                 Sk4f scaledReds   = Sk4f::Min(Sk4f::Max(1023.0f * dstReds,   0.0f), 1023.0f);
                 Sk4f scaledGreens = Sk4f::Min(Sk4f::Max(1023.0f * dstGreens, 0.0f), 1023.0f);
                 Sk4f scaledBlues  = Sk4f::Min(Sk4f::Max(1023.0f * dstBlues,  0.0f), 1023.0f);
 
-                Sk4i indicesReds   = SkNx_cast<int>(scaledReds + 0.5f);
-                Sk4i indicesGreens = SkNx_cast<int>(scaledGreens + 0.5f);
-                Sk4i indicesBlues  = SkNx_cast<int>(scaledBlues + 0.5f);
+                Sk4i indicesReds   = Sk4f_round(scaledReds);
+                Sk4i indicesGreens = Sk4f_round(scaledGreens);
+                Sk4i indicesBlues  = Sk4f_round(scaledBlues);
 
                 dst[0] = dstTables[0][indicesReds  [0]]
                        | dstTables[1][indicesGreens[0]] <<  8
                        | dstTables[2][indicesBlues [0]] << 16
                        | 0xFF                           << 24;
                 dst[1] = dstTables[0][indicesReds  [1]]
                        | dstTables[1][indicesGreens[1]] <<  8
                        | dstTables[2][indicesBlues [1]] << 16
                        | 0xFF                           << 24;
                 dst[2] = dstTables[0][indicesReds  [2]]
@@ skipping 32 matching lines @@
 
         if (kSRGB_DstGamma == kDstGamma || k2Dot2_DstGamma == kDstGamma) {
             Sk4f (*linear_to_curve)(const Sk4f&) =
                     (kSRGB_DstGamma == kDstGamma) ? sk_linear_to_srgb : linear_to_2dot2;
 
             dstPixel = linear_to_curve(dstPixel);
 
             dstPixel = clamp_0_to_255(dstPixel);
 
             uint32_t rgba;
-            SkNx_cast<uint8_t>(dstPixel).store(&rgba);
+            SkNx_cast<uint8_t>(Sk4f_round(dstPixel)).store(&rgba);
             rgba |= 0xFF000000;
             *dst = rgba;
         } else {
             Sk4f scaledPixel = Sk4f::Min(Sk4f::Max(1023.0f * dstPixel, 0.0f), 1023.0f);
 
-            Sk4i indices = SkNx_cast<int>(scaledPixel + 0.5f);
+            Sk4i indices = Sk4f_round(scaledPixel);
 
             *dst = dstTables[0][indices[0]]
                  | dstTables[1][indices[1]] <<  8
                  | dstTables[2][indices[2]] << 16
                  | 0xFF                     << 24;
         }
 
         dst += 1;
         src += 1;
         len -= 1;
@@ skipping 12 matching lines @@
 
 static void color_xform_RGB1_to_table(uint32_t* dst, const uint32_t* src, int len,
                                       const float* const srcTables[3], const float matrix[16],
                                       const uint8_t* const dstTables[3]) {
     color_xform_RGB1<kTable_DstGamma>(dst, src, len, srcTables, matrix, dstTables);
 }
 
 }  // namespace SK_OPTS_NS
 
 #endif // SkColorXform_opts_DEFINED