Xfermode: SSE2 implementation of difference_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
 ////////////////////////////////////////////////////////////////////////////////
 
 static inline __m128i SkDiv255Round_SSE2(const __m128i& a) {
     __m128i prod = _mm_add_epi32(a, _mm_set1_epi32(128)); // prod += 128;
     prod = _mm_add_epi32(prod, _mm_srli_epi32(prod, 8));  // prod + (prod >> 8)
     prod = _mm_srli_epi32(prod, 8);                       // >> 8
 
     return prod;
 }
 
 static inline __m128i saturated_add_SSE2(const __m128i& a, const __m128i& b) {
     __m128i sum = _mm_add_epi32(a, b);
     __m128i cmp = _mm_cmpgt_epi32(sum, _mm_set1_epi32(255));
 
     sum = _mm_or_si128(_mm_and_si128(cmp, _mm_set1_epi32(255)),
                        _mm_andnot_si128(cmp, sum));
     return sum;
 }
 
+static inline __m128i clamp_signed_byte_SSE2(const __m128i& n) {
+    __m128i cmp1 = _mm_cmplt_epi32(n, _mm_setzero_si128());
+    __m128i cmp2 = _mm_cmpgt_epi32(n, _mm_set1_epi32(255));
+    __m128i ret = _mm_and_si128(cmp2, _mm_set1_epi32(255));
+
+    __m128i cmp = _mm_or_si128(cmp1, cmp2);
+    ret = _mm_or_si128(_mm_and_si128(cmp, ret), _mm_andnot_si128(cmp, n));
+
+    return ret;
+}
+
 static inline __m128i clamp_div255round_SSE2(const __m128i& prod) {
     // test if > 0
     __m128i cmp1 = _mm_cmpgt_epi32(prod, _mm_setzero_si128());
     // test if < 255*255
     __m128i cmp2 = _mm_cmplt_epi32(prod, _mm_set1_epi32(255*255));
 
     __m128i ret = _mm_setzero_si128();
 
     // if value >= 255*255, value = 255
     ret = _mm_andnot_si128(cmp2,  _mm_set1_epi32(255));
@@ skipping 125 matching lines @@
                                      SkGetPackedA32_SSE2(dst));
     __m128i r = SkAlphaMulAlpha_SSE2(SkGetPackedR32_SSE2(src),
                                      SkGetPackedR32_SSE2(dst));
     __m128i g = SkAlphaMulAlpha_SSE2(SkGetPackedG32_SSE2(src),
                                      SkGetPackedG32_SSE2(dst));
     __m128i b = SkAlphaMulAlpha_SSE2(SkGetPackedB32_SSE2(src),
                                      SkGetPackedB32_SSE2(dst));
     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 srcover_byte_SSE2(const __m128i& a, const __m128i& b) {
     // a + b - SkAlphaMulAlpha(a, b);
     return _mm_sub_epi32(_mm_add_epi32(a, b), SkAlphaMulAlpha_SSE2(a, b));
 
 }
 
 static inline __m128i blendfunc_multiply_byte_SSE2(const __m128i& sc, const __m128i& dc,
                                                    const __m128i& sa, const __m128i& da) {
     // sc * (255 - da)
     __m128i ret1 = _mm_sub_epi32(_mm_set1_epi32(255), da);
@@ skipping 117 matching lines @@
     __m128i a = srcover_byte_SSE2(sa, da);
     __m128i r = hardlight_byte_SSE2(SkGetPackedR32_SSE2(src),
                                     SkGetPackedR32_SSE2(dst), sa, da);
     __m128i g = hardlight_byte_SSE2(SkGetPackedG32_SSE2(src),
                                     SkGetPackedG32_SSE2(dst), sa, da);
     __m128i b = hardlight_byte_SSE2(SkGetPackedB32_SSE2(src),
                                     SkGetPackedB32_SSE2(dst), sa, da);
     return SkPackARGB32_SSE2(a, r, g, b);
 }
 
+
+static inline __m128i difference_byte_SSE2(const __m128i& sc, const __m128i& dc,
+                                           const __m128i& sa, const __m128i& da) {
+    __m128i tmp1 = _mm_mullo_epi16(sc, da);
+    __m128i tmp2 = _mm_mullo_epi16(dc, sa);
+    __m128i tmp = SkMin32_SSE2(tmp1, tmp2);
+
+    __m128i ret1 = _mm_add_epi32(sc, dc);
+    __m128i ret2 = _mm_slli_epi32(SkDiv255Round_SSE2(tmp), 1);
+    __m128i ret = _mm_sub_epi32(ret1, ret2);
+
+    ret = clamp_signed_byte_SSE2(ret);
+    return ret;
+}
+
+static __m128i difference_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 = difference_byte_SSE2(SkGetPackedR32_SSE2(src),
+                                     SkGetPackedR32_SSE2(dst), sa, da);
+    __m128i g = difference_byte_SSE2(SkGetPackedG32_SSE2(src),
+                                     SkGetPackedG32_SSE2(dst), sa, da);
+    __m128i b = difference_byte_SSE2(SkGetPackedB32_SSE2(src),
+                                     SkGetPackedB32_SSE2(dst), sa, da);
+    return SkPackARGB32_SSE2(a, r, g, b);
+}
 static inline __m128i exclusion_byte_SSE2(const __m128i& sc, const __m128i& dc,
                                           const __m128i&, __m128i&) {
     __m128i tmp1 = _mm_mullo_epi16(_mm_set1_epi32(255), sc); // 255 * sc
     __m128i tmp2 = _mm_mullo_epi16(_mm_set1_epi32(255), dc); // 255 * dc
     tmp1 = _mm_add_epi32(tmp1, tmp2);
     tmp2 = _mm_mullo_epi16(sc, dc);                          // sc * dc
     tmp2 = _mm_slli_epi32(tmp2, 1);                          // 2 * sc * dc
 
     __m128i r = _mm_sub_epi32(tmp1, tmp2);
     return clamp_div255round_SSE2(r);
@@ skipping 168 matching lines @@
     modulate_modeproc_SSE2,
     screen_modeproc_SSE2,
 
     overlay_modeproc_SSE2,
     NULL, // kDarken_Mode
     NULL, // kLighten_Mode
     NULL, // kColorDodge_Mode
     NULL, // kColorBurn_Mode
     hardlight_modeproc_SSE2,
     NULL, // kSoftLight_Mode
-    NULL, // kDifference_Mode
+    difference_modeproc_SSE2,
     exclusion_modeproc_SSE2,
     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;
 }