Xfermode: SSE2 implementation of colordodge&colorburn modes

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 SkMin32_SSE2(const __m128i& a, const __m128i& b) {
+    __m128i cmp = _mm_cmplt_epi32(a, b);
+    return _mm_or_si128(_mm_and_si128(cmp, a), _mm_andnot_si128(cmp, 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;
+}
+
+static inline __m128i colordodge_byte_SSE2(const __m128i& sc, const __m128i& dc,
+                                           const __m128i& sa, const __m128i& da) {
+    __m128i diff = _mm_sub_epi32(sa, sc);
+    __m128i ida = _mm_sub_epi32(_mm_set1_epi32(255), da);
+    __m128i isa = _mm_sub_epi32(_mm_set1_epi32(255), sa);
+
+    // if (0 == dc)
+    __m128i cmp1 = _mm_cmpeq_epi32(dc, _mm_setzero_si128());
+    __m128i rc1 = _mm_and_si128(cmp1, SkAlphaMulAlpha_SSE2(sc, ida));
+
+    // else if (0 == diff)
+    __m128i cmp2 = _mm_cmpeq_epi32(diff, _mm_setzero_si128());
+    __m128i cmp = _mm_andnot_si128(cmp1, cmp2);
+    __m128i tmp1 = _mm_mullo_epi16(sa, da);
+    __m128i tmp2 = _mm_mullo_epi16(sc, ida);
+    __m128i tmp3 = _mm_mullo_epi16(dc, isa);
+    __m128i rc2 = _mm_add_epi32(tmp1, tmp2);
+    rc2 = _mm_add_epi32(rc2, tmp3);
+    rc2 = clamp_div255round_SSE2(rc2);
+    rc2 = _mm_and_si128(cmp, rc2);
+
+    // else
+    __m128i cmp3 = _mm_or_si128(cmp1, cmp2);
+    __m128i value = _mm_mullo_epi16(dc, sa);
+    __m128 x = _mm_cvtepi32_ps(value);
+    __m128 y = _mm_cvtepi32_ps(diff);
+    diff = _mm_cvttps_epi32(_mm_div_ps(x, y));

[mtklein, 2014/04/24 18:13:31]

Think it's worth pulling these three lines out as a little static inline
function shim_mm_div_epi32 or something like that, and use it here and in
colorburn?  Took me a minute to remember SSE doesn't have integer division.

This may be a dumb question, but is there a way for us to get support for SVML
in GCC and Clang?  _mm_div_epi32 is of course what I really want.

[qiankun, 2014/04/25 09:24:38]

Done.
Sorry, I have no idea about this either.

+
+    __m128i tmp4 = SkMin32_SSE2(da, diff);
+    tmp4 = Multiply32_SSE2(sa, tmp4);
+    __m128i rc3 = _mm_add_epi32(tmp4, tmp2);
+    rc3 = _mm_add_epi32(rc3, tmp3);
+    rc3 = clamp_div255round_SSE2(rc3);
+    rc3 = _mm_andnot_si128(cmp3, rc3);
+
+    __m128i rc = _mm_or_si128(rc1, rc2);
+    rc = _mm_or_si128(rc, rc3);
+
+    return rc;
+}
+
+static __m128i colordodge_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 = colordodge_byte_SSE2(SkGetPackedR32_SSE2(src),
+                                     SkGetPackedR32_SSE2(dst), sa, da);
+    __m128i g = colordodge_byte_SSE2(SkGetPackedG32_SSE2(src),
+                                     SkGetPackedG32_SSE2(dst), sa, da);
+    __m128i b = colordodge_byte_SSE2(SkGetPackedB32_SSE2(src),
+                                     SkGetPackedB32_SSE2(dst), sa, da);
+    return SkPackARGB32_SSE2(a, r, g, b);
+}
+
+static inline __m128i colorburn_byte_SSE2(const __m128i& sc, const __m128i& dc,
+                                          const __m128i& sa, const __m128i& da) {
+    __m128i ida = _mm_sub_epi32(_mm_set1_epi32(255), da);
+    __m128i isa = _mm_sub_epi32(_mm_set1_epi32(255), sa);
+
+    // if (dc == da)
+    __m128i cmp1 = _mm_cmpeq_epi32(dc, da);
+    __m128i tmp1 = _mm_mullo_epi16(sa, da);
+    __m128i tmp2 = _mm_mullo_epi16(sc, ida);
+    __m128i tmp3 = _mm_mullo_epi16(dc, isa);
+    __m128i rc1 = _mm_add_epi32(tmp1, tmp2);
+    rc1 = _mm_add_epi32(rc1, tmp3);
+    rc1 = clamp_div255round_SSE2(rc1);
+    rc1 = _mm_and_si128(cmp1, rc1);
+
+    // else if (0 == sc)
+    __m128i cmp2 = _mm_cmpeq_epi32(sc, _mm_setzero_si128());
+    __m128i rc2 = SkAlphaMulAlpha_SSE2(dc, isa);
+    __m128i cmp = _mm_andnot_si128(cmp1, cmp2);
+    rc2 = _mm_and_si128(cmp, rc2);
+
+    // else
+    __m128i cmp3 = _mm_or_si128(cmp1, cmp2);
+    __m128i tmp4 = _mm_sub_epi32(da, dc);
+    tmp4 = Multiply32_SSE2(tmp4, sa);
+    __m128 x = _mm_cvtepi32_ps(tmp4);
+    __m128 y = _mm_cvtepi32_ps(sc);
+    tmp4 = _mm_cvttps_epi32(_mm_div_ps(x, y));
+
+    __m128i tmp5 = _mm_sub_epi32(da, SkMin32_SSE2(da, tmp4));
+    tmp5 = Multiply32_SSE2(sa, tmp5);
+    __m128i rc3 = _mm_add_epi32(tmp5, tmp2);
+    rc3 = _mm_add_epi32(rc3, tmp3);
+    rc3 = clamp_div255round_SSE2(rc3);
+    rc3 = _mm_andnot_si128(cmp3, rc3);
+
+    __m128i rc = _mm_or_si128(rc1, rc2);
+    rc = _mm_or_si128(rc, rc3);
+
+    return rc;
+}
+
+static __m128i colorburn_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 = colorburn_byte_SSE2(SkGetPackedR32_SSE2(src),
+                                    SkGetPackedR32_SSE2(dst), sa, da);
+    __m128i g = colorburn_byte_SSE2(SkGetPackedG32_SSE2(src),
+                                    SkGetPackedG32_SSE2(dst), sa, da);
+    __m128i b = colorburn_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 138 matching lines @@
     NULL, // kSrcATop_Mode
     NULL, // kDstATop_Mode
     NULL, // kXor_Mode
     NULL, // kPlus_Mode
     NULL, // kModulate_Mode
     NULL, // kScreen_Mode
 
     NULL, // kOverlay_Mode
     NULL, // kDarken_Mode
     NULL, // kLighten_Mode
-    NULL, // kColorDodge_Mode
-    NULL, // kColorBurn_Mode
+    colordodge_modeproc_SSE2,
+    colorburn_modeproc_SSE2,
     NULL, // kHardLight_Mode
     NULL, // kSoftLight_Mode
     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;
 }