Revert of use templates instead of macros to build blitters

src/core/SkBitmapProcState_matrixProcs.cpp

 /* NEON optimized code (C) COPYRIGHT 2009 Motorola
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapProcState.h"
 #include "SkPerspIter.h"
 #include "SkShader.h"
 #include "SkUtils.h"
@@ skipping 15 matching lines @@
         } else {
             x = x % n;
         }
     }
     return x;
 }
 
 void decal_nofilter_scale(uint32_t dst[], SkFixed fx, SkFixed dx, int count);
 void decal_filter_scale(uint32_t dst[], SkFixed fx, SkFixed dx, int count);
 
-#include "SkBitmapProcState_matrix_template.h"
-
-///////////////////////////////////////////////////////////////////////////////
-
 // Compile neon code paths if needed
 #if !SK_ARM_NEON_IS_NONE
 
 // These are defined in src/opts/SkBitmapProcState_matrixProcs_neon.cpp
 extern const SkBitmapProcState::MatrixProc ClampX_ClampY_Procs_neon[];
 extern const SkBitmapProcState::MatrixProc RepeatX_RepeatY_Procs_neon[];
 
 #endif // !SK_ARM_NEON_IS_NONE
 
 // Compile non-neon code path if needed
 #if !SK_ARM_NEON_IS_ALWAYS
 #define MAKENAME(suffix)        ClampX_ClampY ## suffix
 #define TILEX_PROCF(fx, max)    SkClampMax((fx) >> 16, max)
 #define TILEY_PROCF(fy, max)    SkClampMax((fy) >> 16, max)
 #define TILEX_LOW_BITS(fx, max) (((fx) >> 12) & 0xF)
 #define TILEY_LOW_BITS(fy, max) (((fy) >> 12) & 0xF)
 #define CHECK_FOR_DECAL
 #include "SkBitmapProcState_matrix.h"
 
-struct ClampTileProcs {
-    static unsigned X(const SkBitmapProcState&, SkFixed fx, int max) {
-        return SkClampMax(fx >> 16, max);
-    }
-    static unsigned Y(const SkBitmapProcState&, SkFixed fy, int max) {
-        return SkClampMax(fy >> 16, max);
-    }
-};
-
-// Referenced in opts_check_SSE2.cpp
-void ClampX_ClampY_nofilter_scale(const SkBitmapProcState& s, uint32_t xy[],
-                                  int count, int x, int y) {
-    return NoFilterProc_Scale<ClampTileProcs, true>(s, xy, count, x, y);
-}
-void ClampX_ClampY_nofilter_affine(const SkBitmapProcState& s, uint32_t xy[],
-                                  int count, int x, int y) {
-    return NoFilterProc_Affine<ClampTileProcs>(s, xy, count, x, y);
-}
-
-static SkBitmapProcState::MatrixProc ClampX_ClampY_Procs[] = {
-    // only clamp lives in the right coord space to check for decal
-    ClampX_ClampY_nofilter_scale,
-    ClampX_ClampY_filter_scale,
-    ClampX_ClampY_nofilter_affine,
-    ClampX_ClampY_filter_affine,
-    NoFilterProc_Persp<ClampTileProcs>,
-    ClampX_ClampY_filter_persp
-};
-
 #define MAKENAME(suffix)        RepeatX_RepeatY ## suffix
 #define TILEX_PROCF(fx, max)    SK_USHIFT16(((fx) & 0xFFFF) * ((max) + 1))
 #define TILEY_PROCF(fy, max)    SK_USHIFT16(((fy) & 0xFFFF) * ((max) + 1))
 #define TILEX_LOW_BITS(fx, max) ((((fx) & 0xFFFF) * ((max) + 1) >> 12) & 0xF)
 #define TILEY_LOW_BITS(fy, max) ((((fy) & 0xFFFF) * ((max) + 1) >> 12) & 0xF)
 #include "SkBitmapProcState_matrix.h"
 #endif
 
-struct RepeatTileProcs {
-    static unsigned X(const SkBitmapProcState&, SkFixed fx, int max) {
-        return SK_USHIFT16(((fx) & 0xFFFF) * ((max) + 1));
-    }
-    static unsigned Y(const SkBitmapProcState&, SkFixed fy, int max) {
-        return SK_USHIFT16(((fy) & 0xFFFF) * ((max) + 1));
-    }
-};
-
-static SkBitmapProcState::MatrixProc RepeatX_RepeatY_Procs[] = {
-    NoFilterProc_Scale<RepeatTileProcs, false>,
-    RepeatX_RepeatY_filter_scale,
-    NoFilterProc_Affine<RepeatTileProcs>,
-    RepeatX_RepeatY_filter_affine,
-    NoFilterProc_Persp<RepeatTileProcs>,
-    RepeatX_RepeatY_filter_persp
-};
-
 #define MAKENAME(suffix)        GeneralXY ## suffix
 #define PREAMBLE(state)         SkBitmapProcState::FixedTileProc tileProcX = (state).fTileProcX; (void) tileProcX; \
                                 SkBitmapProcState::FixedTileProc tileProcY = (state).fTileProcY; (void) tileProcY; \
                                 SkBitmapProcState::FixedTileLowBitsProc tileLowBitsProcX = (state).fTileLowBitsProcX; (void) tileLowBitsProcX; \
                                 SkBitmapProcState::FixedTileLowBitsProc tileLowBitsProcY = (state).fTileLowBitsProcY; (void) tileLowBitsProcY
 #define PREAMBLE_PARAM_X        , SkBitmapProcState::FixedTileProc tileProcX, SkBitmapProcState::FixedTileLowBitsProc tileLowBitsProcX
 #define PREAMBLE_PARAM_Y        , SkBitmapProcState::FixedTileProc tileProcY, SkBitmapProcState::FixedTileLowBitsProc tileLowBitsProcY
 #define PREAMBLE_ARG_X          , tileProcX, tileLowBitsProcX
 #define PREAMBLE_ARG_Y          , tileProcY, tileLowBitsProcY
 #define TILEX_PROCF(fx, max)    SK_USHIFT16(tileProcX(fx) * ((max) + 1))
 #define TILEY_PROCF(fy, max)    SK_USHIFT16(tileProcY(fy) * ((max) + 1))
 #define TILEX_LOW_BITS(fx, max) tileLowBitsProcX(fx, (max) + 1)
 #define TILEY_LOW_BITS(fy, max) tileLowBitsProcY(fy, (max) + 1)
 #include "SkBitmapProcState_matrix.h"
 
-struct GeneralTileProcs {
-    static unsigned X(const SkBitmapProcState& s, SkFixed fx, int max) {
-        return SK_USHIFT16(s.fTileProcX(fx) * ((max) + 1));
-    }
-    static unsigned Y(const SkBitmapProcState& s, SkFixed fy, int max) {
-        return SK_USHIFT16(s.fTileProcY(fy) * ((max) + 1));
-    }
-};
-
-static SkBitmapProcState::MatrixProc GeneralXY_Procs[] = {
-    NoFilterProc_Scale<GeneralTileProcs, false>,
-    GeneralXY_filter_scale,
-    NoFilterProc_Affine<GeneralTileProcs>,
-    GeneralXY_filter_affine,
-    NoFilterProc_Persp<GeneralTileProcs>,
-    GeneralXY_filter_persp
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-static inline U16CPU fixed_clamp(SkFixed x) {
+static inline U16CPU fixed_clamp(SkFixed x)
+{
     if (x < 0) {
         x = 0;
     }
     if (x >> 16) {
         x = 0xFFFF;
     }
     return x;
 }
 
-static inline U16CPU fixed_repeat(SkFixed x) {
+static inline U16CPU fixed_repeat(SkFixed x)
+{
     return x & 0xFFFF;
 }
 
 // Visual Studio 2010 (MSC_VER=1600) optimizes bit-shift code incorrectly.
 // See http://code.google.com/p/skia/issues/detail?id=472
 #if defined(_MSC_VER) && (_MSC_VER >= 1600)
 #pragma optimize("", off)
 #endif
 
-static inline U16CPU fixed_mirror(SkFixed x) {
+static inline U16CPU fixed_mirror(SkFixed x)
+{
     SkFixed s = x << 15 >> 31;
     // s is FFFFFFFF if we're on an odd interval, or 0 if an even interval
     return (x ^ s) & 0xFFFF;
 }
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1600)
 #pragma optimize("", on)
 #endif
 
-static SkBitmapProcState::FixedTileProc choose_tile_proc(unsigned m) {
-    if (SkShader::kClamp_TileMode == m) {
+static SkBitmapProcState::FixedTileProc choose_tile_proc(unsigned m)
+{
+    if (SkShader::kClamp_TileMode == m)
         return fixed_clamp;
-    }
-    if (SkShader::kRepeat_TileMode == m) {
+    if (SkShader::kRepeat_TileMode == m)
         return fixed_repeat;
-    }
     SkASSERT(SkShader::kMirror_TileMode == m);
     return fixed_mirror;
 }
 
 static inline U16CPU fixed_clamp_lowbits(SkFixed x, int) {
     return (x >> 12) & 0xF;
 }
 
 static inline U16CPU fixed_repeat_or_mirrow_lowbits(SkFixed x, int scale) {
     return ((x * scale) >> 12) & 0xF;
@@ skipping 44 matching lines @@
     if (SkShader::kClamp_TileMode == tm)
         return int_clamp;
     if (SkShader::kRepeat_TileMode == tm)
         return int_repeat;
     SkASSERT(SkShader::kMirror_TileMode == tm);
     return int_mirror;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-void decal_nofilter_scale(uint32_t dst[], SkFixed fx, SkFixed dx, int count) {
+void decal_nofilter_scale(uint32_t dst[], SkFixed fx, SkFixed dx, int count)
+{
     int i;
 
-    for (i = (count >> 2); i > 0; --i) {
+    for (i = (count >> 2); i > 0; --i)
+    {
         *dst++ = pack_two_shorts(fx >> 16, (fx + dx) >> 16);
         fx += dx+dx;
         *dst++ = pack_two_shorts(fx >> 16, (fx + dx) >> 16);
         fx += dx+dx;
     }
     count &= 3;
 
     uint16_t* xx = (uint16_t*)dst;
     for (i = count; i > 0; --i) {
         *xx++ = SkToU16(fx >> 16); fx += dx;
     }
 }
 
-void decal_filter_scale(uint32_t dst[], SkFixed fx, SkFixed dx, int count) {
-    if (count & 1) {
+void decal_filter_scale(uint32_t dst[], SkFixed fx, SkFixed dx, int count)
+{
+
+
+    if (count & 1)
+    {
         SkASSERT((fx >> (16 + 14)) == 0);
         *dst++ = (fx >> 12 << 14) | ((fx >> 16) + 1);
         fx += dx;
     }
-    while ((count -= 2) >= 0) {
+    while ((count -= 2) >= 0)
+    {
         SkASSERT((fx >> (16 + 14)) == 0);
         *dst++ = (fx >> 12 << 14) | ((fx >> 16) + 1);
         fx += dx;
 
         *dst++ = (fx >> 12 << 14) | ((fx >> 16) + 1);
         fx += dx;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 183 matching lines @@
         if (forward) {
             fill_sequential(xptr, 0, count);
         } else {
             fill_backwards(xptr, width - 1, count);
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkBitmapProcState::MatrixProc SkBitmapProcState::chooseMatrixProc(bool trivial_matrix) {
+SkBitmapProcState::MatrixProc
+SkBitmapProcState::chooseMatrixProc(bool trivial_matrix) {
 //    test_int_tileprocs();
     // check for our special case when there is no scale/affine/perspective
     if (trivial_matrix) {
         SkASSERT(SkPaint::kNone_FilterLevel == fFilterLevel);
         fIntTileProcY = choose_int_tile_proc(fTileModeY);
         switch (fTileModeX) {
             case SkShader::kClamp_TileMode:
                 return clampx_nofilter_trans;
             case SkShader::kRepeat_TileMode:
                 return repeatx_nofilter_trans;
             case SkShader::kMirror_TileMode:
                 return mirrorx_nofilter_trans;
         }
     }
 
     int index = 0;
     if (fFilterLevel != SkPaint::kNone_FilterLevel) {
         index = 1;
     }
     if (fInvType & SkMatrix::kPerspective_Mask) {
         index += 4;
     } else if (fInvType & SkMatrix::kAffine_Mask) {
         index += 2;
     }
 
-    if (SkShader::kClamp_TileMode == fTileModeX && SkShader::kClamp_TileMode == fTileModeY) {
+    if (SkShader::kClamp_TileMode == fTileModeX &&
+        SkShader::kClamp_TileMode == fTileModeY)
+    {
         // clamp gets special version of filterOne
         fFilterOneX = SK_Fixed1;
         fFilterOneY = SK_Fixed1;
         return SK_ARM_NEON_WRAP(ClampX_ClampY_Procs)[index];
     }
 
     // all remaining procs use this form for filterOne
     fFilterOneX = SK_Fixed1 / fBitmap->width();
     fFilterOneY = SK_Fixed1 / fBitmap->height();
 
-    if (SkShader::kRepeat_TileMode == fTileModeX && SkShader::kRepeat_TileMode == fTileModeY) {
+    if (SkShader::kRepeat_TileMode == fTileModeX &&
+        SkShader::kRepeat_TileMode == fTileModeY)
+    {
         return SK_ARM_NEON_WRAP(RepeatX_RepeatY_Procs)[index];
     }
 
     fTileProcX = choose_tile_proc(fTileModeX);
     fTileProcY = choose_tile_proc(fTileModeY);
     fTileLowBitsProcX = choose_tile_lowbits_proc(fTileModeX);
     fTileLowBitsProcY = choose_tile_lowbits_proc(fTileModeY);
     return GeneralXY_Procs[index];
 }