Xfermode: SSE2 implementation of softlight_modeproc

src/opts/SkXfermode_opts_SSE2.cpp

 #include "SkColorPriv.h"
 #include "SkColor_opts_SSE2.h"
 #include "SkMathPriv.h"
 #include "SkXfermode.h"
 #include "SkXfermode_opts_SSE2.h"
 #include "SkXfermode_proccoeff.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // 4 pixels SSE2 version functions
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 66 matching lines @@
     __m128i g = blendfunc_multiply_byte_SSE2(sg, dg, sa, da);
 
 
     __m128i sb = SkGetPackedB32_SSE2(src);
     __m128i db = SkGetPackedB32_SSE2(dst);
     __m128i b = blendfunc_multiply_byte_SSE2(sb, db, sa, da);
 
     return SkPackARGB32_SSE2(a, r, g, b);
 }
 
-////////////////////////////////////////////////////////////////////////////////
+static inline  __m128i Multiply32_SSE2(const __m128i& a, const __m128i& b) {
+    __m128i r1 = _mm_mul_epu32(a, b);
+    __m128i r2 = _mm_mul_epu32(_mm_srli_si128(a, 4), _mm_srli_si128(b, 4));
+    __m128i r = _mm_unpacklo_epi32(_mm_shuffle_epi32(r1, _MM_SHUFFLE(0,0,2,0)),
+                                   _mm_shuffle_epi32(r2, _MM_SHUFFLE(0,0,2,0)));
+    return r;
+}
+
+// Portable version of SkSqrtBits is in SkMath.cpp.
+static inline __m128i SkSqrtBits_SSE2(const __m128i& x, int count) {

[mtklein, 2014/04/24 17:24:11]

Think it's worth spinning off an SkMath_SSE2?

[qiankun, 2014/04/25 08:13:06]

Done. Create a new file SkMath_opts_SSE2.h to hold math related functions.

+    __m128i root =  _mm_setzero_si128();
+    __m128i remHi = _mm_setzero_si128();
+    __m128i remLo = x;
+    __m128i one128 = _mm_set1_epi32(1);
+
+    do {
+        root = _mm_slli_epi32(root, 1);
+
+        remHi = _mm_or_si128(_mm_slli_epi32(remHi, 2),
+                             _mm_srli_epi32(remLo, 30));
+        remLo = _mm_slli_epi32(remLo, 2);
+
+        __m128i testDiv = _mm_slli_epi32(root, 1);
+        testDiv = _mm_add_epi32(testDiv, _mm_set1_epi32(1));
+
+        __m128i cmp = _mm_cmplt_epi32(remHi, testDiv);
+        __m128i remHi1 = _mm_and_si128(cmp, remHi);
+        __m128i root1 = _mm_and_si128(cmp, root);
+        __m128i remHi2 = _mm_andnot_si128(cmp, _mm_sub_epi32(remHi, testDiv));
+        __m128i root2 = _mm_andnot_si128(cmp, _mm_add_epi32(root, one128));
+
+        remHi = _mm_or_si128(remHi1, remHi2);
+        root = _mm_or_si128(root1, root2);
+    } while (--count >= 0);
+
+    return root;
+}
+
+static __m128i sqrt_unit_byte_SSE2(const __m128i& n) {
+    return SkSqrtBits_SSE2(n, 15+4);
+}
+
+static inline __m128i softlight_byte_SSE2(const __m128i& sc, const __m128i& dc,
+                                          const __m128i& sa, const __m128i& da) {
+    __m128i tmp1, tmp2, tmp3;
+
+    // int m = da ? dc * 256 / da : 0;
+    __m128i cmp = _mm_cmpeq_epi32(da, _mm_setzero_si128());
+    __m128i m = _mm_slli_epi32(dc, 8);
+    __m128 x = _mm_cvtepi32_ps(m);
+    __m128 y = _mm_cvtepi32_ps(da);
+    m = _mm_cvttps_epi32(_mm_div_ps(x, y));
+    m = _mm_andnot_si128(cmp, m);
+
+    // if (2 * sc <= sa)
+    tmp1 = _mm_slli_epi32(sc, 1);                      // 2 * sc
+    __m128i cmp1 = _mm_cmpgt_epi32(tmp1, sa);
+    tmp1 = _mm_sub_epi32(tmp1, sa);                    // 2*sc - sa
+    tmp2 = _mm_sub_epi32(_mm_set1_epi32(256), m);      // 256 - m
+    tmp1 = Multiply32_SSE2(tmp1, tmp2);
+    tmp1 = _mm_srai_epi32(tmp1, 8);
+    tmp1 = _mm_add_epi32(sa, tmp1);
+    tmp1 = Multiply32_SSE2(dc, tmp1);
+    __m128i rc1 = _mm_andnot_si128(cmp1, tmp1);
+
+    // else if (4 * dc <= da)
+    tmp2 = _mm_slli_epi32(dc, 2);                      // dc * 4
+    __m128i cmp2 = _mm_cmpgt_epi32(tmp2, da);
+    __m128i i = _mm_slli_epi32(m, 2);                  // 4 * m
+    __m128i j = _mm_add_epi32(i, _mm_set1_epi32(256)); // 4 * m + 256
+    __m128i k = Multiply32_SSE2(i, j);                 // 4 * m * (4 * m + 256)
+    __m128i t = _mm_sub_epi32(m, _mm_set1_epi32(256)); // m - 256
+    i = Multiply32_SSE2(k, t);                         // 4 * m * (4 * m + 256) * (m - 256)
+    i = _mm_srai_epi32(i, 16);                         // >> 16
+    j = Multiply32_SSE2(_mm_set1_epi32(7), m);         // 7 * m
+    tmp2 = _mm_add_epi32(i, j);
+    i = Multiply32_SSE2(dc, sa);                       // dc * sa
+    j = _mm_slli_epi32(sc, 1);                         // 2 * sc
+    j = _mm_sub_epi32(j, sa);                          // 2 * sc - sa
+    j = Multiply32_SSE2(da, j);                        // da * (2 * sc - sa)
+    tmp2 = Multiply32_SSE2(j, tmp2);                   // * tmp
+    tmp2 = _mm_srai_epi32(tmp2, 8);                    // >> 8
+    tmp2 = _mm_add_epi32(i, tmp2);
+    cmp = _mm_andnot_si128(cmp2, cmp1);
+    __m128i rc2 = _mm_and_si128(cmp, tmp2);
+    __m128i rc = _mm_or_si128(rc1, rc2);
+
+    // else
+    tmp3 = sqrt_unit_byte_SSE2(m);
+    tmp3 = _mm_sub_epi32(tmp3, m);
+    tmp3 = Multiply32_SSE2(j, tmp3);                   // j = da * (2 * sc - sa)
+    tmp3 = _mm_srai_epi32(tmp3, 8);
+    tmp3 = _mm_add_epi32(i, tmp3);                     // i = dc * sa
+    cmp = _mm_and_si128(cmp1, cmp2);
+    __m128i rc3 = _mm_and_si128(cmp, tmp3);
+    rc = _mm_or_si128(rc, rc3);
+
+    tmp1 = _mm_sub_epi32(_mm_set1_epi32(255), da);     // 255 - da
+    tmp1 = _mm_mullo_epi16(sc, tmp1);
+    tmp2 = _mm_sub_epi32(_mm_set1_epi32(255), sa);     // 255 - sa
+    tmp2 = _mm_mullo_epi16(dc, tmp2);
+    rc = _mm_add_epi32(rc, tmp1);
+    rc = _mm_add_epi32(rc, tmp2);
+    return clamp_div255round_SSE2(rc);
+}
+
+static __m128i softlight_modeproc_SSE2(const __m128i& src, const __m128i& dst) {
+    __m128i sa = SkGetPackedA32_SSE2(src);
+    __m128i da = SkGetPackedA32_SSE2(dst);
+
+    __m128i a = srcover_byte_SSE2(sa, da);
+    __m128i r = softlight_byte_SSE2(SkGetPackedR32_SSE2(src),
+                                    SkGetPackedR32_SSE2(dst), sa, da);
+    __m128i g = softlight_byte_SSE2(SkGetPackedG32_SSE2(src),
+                                    SkGetPackedG32_SSE2(dst), sa, da);
+    __m128i b = softlight_byte_SSE2(SkGetPackedB32_SSE2(src),
+                                    SkGetPackedB32_SSE2(dst), sa, da);
+    return SkPackARGB32_SSE2(a, r, g, b);
+}
+///////////////////////////////////////////////////////////////////////////////
 
 typedef __m128i (*SkXfermodeProcSIMD)(const __m128i& src, const __m128i& dst);
 
 extern SkXfermodeProcSIMD gSSE2XfermodeProcs[];
 
 SkSSE2ProcCoeffXfermode::SkSSE2ProcCoeffXfermode(SkReadBuffer& buffer)
     : INHERITED(buffer) {
     fProcSIMD = reinterpret_cast<void*>(gSSE2XfermodeProcs[this->getMode()]);
 }
 
@@ skipping 140 matching lines @@
     NULL, // kPlus_Mode
     NULL, // kModulate_Mode
     NULL, // kScreen_Mode
 
     NULL, // kOverlay_Mode
     NULL, // kDarken_Mode
     NULL, // kLighten_Mode
     NULL, // kColorDodge_Mode
     NULL, // kColorBurn_Mode
     NULL, // kHardLight_Mode
-    NULL, // kSoftLight_Mode
+    softlight_modeproc_SSE2,
     NULL, // kDifference_Mode
     NULL, // kExclusion_Mode
     multiply_modeproc_SSE2,
 
     NULL, // kHue_Mode
     NULL, // kSaturation_Mode
     NULL, // kColor_Mode
     NULL, // kLuminosity_Mode
 };
 
 SkProcCoeffXfermode* SkPlatformXfermodeFactory_impl_SSE2(const ProcCoeff& rec,
                                                          SkXfermode::Mode mode) {
     void* procSIMD = reinterpret_cast<void*>(gSSE2XfermodeProcs[mode]);
 
     if (procSIMD != NULL) {
         return SkNEW_ARGS(SkSSE2ProcCoeffXfermode, (rec, mode, procSIMD));
     }
     return NULL;
 }