Revert of Xfermode: SSE2 implementation of multiply_modeproc

src/opts/SkBlitRow_opts_SSE2.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkBlitRow_opts_SSE2.h"
 #include "SkBitmapProcState_opts_SSE2.h"
@@ skipping 896 matching lines @@
             // Calculate result b.
             __m128i b1 = _mm_srli_epi32(src_pixel1,
                                         SK_B32_SHIFT + (8 - SK_B16_BITS));
             b1 = _mm_and_si128(b1, b16_mask);
             __m128i b2 = _mm_srli_epi32(src_pixel2,
                                         SK_B32_SHIFT + (8 - SK_B16_BITS));
             b2 = _mm_and_si128(b2, b16_mask);
             __m128i b = _mm_packs_epi32(b1, b2);
 
             // Store 8 16-bit colors in dst.
-            __m128i d_pixel = SkPackRGB16_SSE2(r, g, b);
+            __m128i d_pixel = SkPackRGB16_SSE(r, g, b);
             _mm_store_si128(d++, d_pixel);
             count -= 8;
         }
         src = reinterpret_cast<const SkPMColor*>(s);
         dst = reinterpret_cast<uint16_t*>(d);
     }
 
     if (count > 0) {
         do {
             SkPMColor c = *src++;
@@ skipping 48 matching lines @@
             if (src_cmp1 == 0xFFFF && src_cmp2 == 0xFFFF) {
                 d++;
                 count -= 8;
                 continue;
             }
 
             // Load 8 pixels of dst.
             __m128i dst_pixel = _mm_load_si128(d);
 
             // Extract A from src.
-            __m128i sa1 = _mm_slli_epi32(src_pixel1, (24 - SK_A32_SHIFT));
+            __m128i sa1 = _mm_slli_epi32(src_pixel1,(24 - SK_A32_SHIFT));
             sa1 = _mm_srli_epi32(sa1, 24);
-            __m128i sa2 = _mm_slli_epi32(src_pixel2, (24 - SK_A32_SHIFT));
+            __m128i sa2 = _mm_slli_epi32(src_pixel2,(24 - SK_A32_SHIFT));
             sa2 = _mm_srli_epi32(sa2, 24);
             __m128i sa = _mm_packs_epi32(sa1, sa2);
 
             // Extract R from src.
-            __m128i sr1 = _mm_slli_epi32(src_pixel1, (24 - SK_R32_SHIFT));
+            __m128i sr1 = _mm_slli_epi32(src_pixel1,(24 - SK_R32_SHIFT));
             sr1 = _mm_srli_epi32(sr1, 24);
-            __m128i sr2 = _mm_slli_epi32(src_pixel2, (24 - SK_R32_SHIFT));
+            __m128i sr2 = _mm_slli_epi32(src_pixel2,(24 - SK_R32_SHIFT));
             sr2 = _mm_srli_epi32(sr2, 24);
             __m128i sr = _mm_packs_epi32(sr1, sr2);
 
             // Extract G from src.
-            __m128i sg1 = _mm_slli_epi32(src_pixel1, (24 - SK_G32_SHIFT));
+            __m128i sg1 = _mm_slli_epi32(src_pixel1,(24 - SK_G32_SHIFT));
             sg1 = _mm_srli_epi32(sg1, 24);
-            __m128i sg2 = _mm_slli_epi32(src_pixel2, (24 - SK_G32_SHIFT));
+            __m128i sg2 = _mm_slli_epi32(src_pixel2,(24 - SK_G32_SHIFT));
             sg2 = _mm_srli_epi32(sg2, 24);
             __m128i sg = _mm_packs_epi32(sg1, sg2);
 
             // Extract B from src.
-            __m128i sb1 = _mm_slli_epi32(src_pixel1, (24 - SK_B32_SHIFT));
+            __m128i sb1 = _mm_slli_epi32(src_pixel1,(24 - SK_B32_SHIFT));
             sb1 = _mm_srli_epi32(sb1, 24);
-            __m128i sb2 = _mm_slli_epi32(src_pixel2, (24 - SK_B32_SHIFT));
+            __m128i sb2 = _mm_slli_epi32(src_pixel2,(24 - SK_B32_SHIFT));
             sb2 = _mm_srli_epi32(sb2, 24);
             __m128i sb = _mm_packs_epi32(sb1, sb2);
 
             // Extract R G B from dst.
-            __m128i dr = _mm_srli_epi16(dst_pixel, SK_R16_SHIFT);
+            __m128i dr = _mm_srli_epi16(dst_pixel,SK_R16_SHIFT);
             dr = _mm_and_si128(dr, r16_mask);
-            __m128i dg = _mm_srli_epi16(dst_pixel, SK_G16_SHIFT);
+            __m128i dg = _mm_srli_epi16(dst_pixel,SK_G16_SHIFT);
             dg = _mm_and_si128(dg, g16_mask);
-            __m128i db = _mm_srli_epi16(dst_pixel, SK_B16_SHIFT);
+            __m128i db = _mm_srli_epi16(dst_pixel,SK_B16_SHIFT);
             db = _mm_and_si128(db, b16_mask);
 
             __m128i isa = _mm_sub_epi16(var255, sa); // 255 -sa
 
             // Calculate R G B of result.
             // Original algorithm is in SkSrcOver32To16().
-            dr = _mm_add_epi16(sr, SkMul16ShiftRound_SSE2(dr, isa, SK_R16_BITS));
+            dr = _mm_add_epi16(sr, SkMul16ShiftRound_SSE(dr, isa, SK_R16_BITS));
             dr = _mm_srli_epi16(dr, 8 - SK_R16_BITS);
-            dg = _mm_add_epi16(sg, SkMul16ShiftRound_SSE2(dg, isa, SK_G16_BITS));
+            dg = _mm_add_epi16(sg, SkMul16ShiftRound_SSE(dg, isa, SK_G16_BITS));
             dg = _mm_srli_epi16(dg, 8 - SK_G16_BITS);
-            db = _mm_add_epi16(sb, SkMul16ShiftRound_SSE2(db, isa, SK_B16_BITS));
+            db = _mm_add_epi16(sb, SkMul16ShiftRound_SSE(db, isa, SK_B16_BITS));
             db = _mm_srli_epi16(db, 8 - SK_B16_BITS);
 
             // Pack R G B into 16-bit color.
-            __m128i d_pixel = SkPackRGB16_SSE2(dr, dg, db);
+            __m128i d_pixel = SkPackRGB16_SSE(dr, dg, db);
 
             // Store 8 16-bit colors in dst.
             _mm_store_si128(d++, d_pixel);
             count -= 8;
         }
 
         src = reinterpret_cast<const SkPMColor*>(s);
         dst = reinterpret_cast<uint16_t*>(d);
     }
 
@@ skipping 92 matching lines @@
             sb2 = _mm_srli_epi32(sb2, 24);
             __m128i sb = _mm_packs_epi32(sb1, sb2);
 
             // SkDITHER_R32To565(sb, dither)
             __m128i sb_offset = _mm_srli_epi16(sb, 5);
             sb = _mm_add_epi16(sb, dither);
             sb = _mm_sub_epi16(sb, sb_offset);
             sb = _mm_srli_epi16(sb, SK_B32_BITS - SK_B16_BITS);
 
             // Pack and store 16-bit dst pixel.
-            __m128i d_pixel = SkPackRGB16_SSE2(sr, sg, sb);
+            __m128i d_pixel = SkPackRGB16_SSE(sr, sg, sb);
             _mm_store_si128(d++, d_pixel);
 
             count -= 8;
             x += 8;
         }
 
         src = reinterpret_cast<const SkPMColor*>(s);
         dst = reinterpret_cast<uint16_t*>(d);
     }
 
@@ skipping 78 matching lines @@
         __m128i g16_mask = _mm_set1_epi16(SK_G16_MASK);
         __m128i b16_mask = _mm_set1_epi16(SK_B16_MASK);
 
         while (count >= 8) {
             // Load 8 pixels of src and dst.
             __m128i src_pixel1 = _mm_loadu_si128(s++);
             __m128i src_pixel2 = _mm_loadu_si128(s++);
             __m128i dst_pixel = _mm_load_si128(d);
 
             // Extract A from src.
-            __m128i sa1 = _mm_slli_epi32(src_pixel1, (24 - SK_A32_SHIFT));
+            __m128i sa1 = _mm_slli_epi32(src_pixel1,(24 - SK_A32_SHIFT));
             sa1 = _mm_srli_epi32(sa1, 24);
-            __m128i sa2 = _mm_slli_epi32(src_pixel2, (24 - SK_A32_SHIFT));
+            __m128i sa2 = _mm_slli_epi32(src_pixel2,(24 - SK_A32_SHIFT));
             sa2 = _mm_srli_epi32(sa2, 24);
             __m128i sa = _mm_packs_epi32(sa1, sa2);
 
             // Calculate current dither value.
             dither_cur = _mm_mullo_epi16(dither,
                                          _mm_add_epi16(sa, _mm_set1_epi16(1)));
             dither_cur = _mm_srli_epi16(dither_cur, 8);
 
             // Extract R from src.
             __m128i sr1 = _mm_slli_epi32(src_pixel1, (24 - SK_R32_SHIFT));
@@ skipping 58 matching lines @@
 
             dg = _mm_mullo_epi16(dg, isa);
             dg = _mm_add_epi16(dg, sg);
             dg = _mm_srli_epi16(dg, 5);
 
             db = _mm_mullo_epi16(db, isa);
             db = _mm_add_epi16(db, sb);
             db = _mm_srli_epi16(db, 5);
 
             // Package and store dst pixel.
-            __m128i d_pixel = SkPackRGB16_SSE2(dr, dg, db);
+            __m128i d_pixel = SkPackRGB16_SSE(dr, dg, db);
             _mm_store_si128(d++, d_pixel);
 
             count -= 8;
             x += 8;
         }
 
         src = reinterpret_cast<const SkPMColor*>(s);
         dst = reinterpret_cast<uint16_t*>(d);
     }
 
@@ skipping 18 matching lines @@
                 uint32_t dst_expanded = SkExpand_rgb_16(*dst);
                 dst_expanded = dst_expanded * (SkAlpha255To256(255 - a) >> 3);
                 // now src and dst expanded are in g:11 r:10 x:1 b:10
                 *dst = SkCompact_rgb_16((src_expanded + dst_expanded) >> 5);
             }
             dst += 1;
             DITHER_INC_X(x);
         } while (--count != 0);
     }
 }