make pm4f be RGBA always, not pmcolor order

src/core/SkXfermode4f.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPM4fPriv.h"
 #include "SkUtils.h"
 #include "SkXfermode.h"
 
+static SkPM4f rgba_to_pmcolor_order(const SkPM4f& x) {
+#ifdef SK_PMCOLOR_IS_BGRA
+    return {{ x.fVec[2], x.fVec[1], x.fVec[0], x.fVec[3] }};
+#else
+    return x;
+#endif
+}
+
 enum DstType {
     kLinear_Dst,
     kSRGB_Dst,
 };
 
 static Sk4f scale_by_coverage(const Sk4f& x4, uint8_t coverage) {
     return x4 * Sk4f(coverage * (1/255.0f));
 }
 
 static Sk4f lerp(const Sk4f& src, const Sk4f& dst, uint8_t srcCoverage) {
@@ skipping 13 matching lines @@
 }
 
 static Sk4f linear_unit_to_srgb_255f(const Sk4f& l4) {
     return linear_to_srgb(l4) * Sk4f(255) + Sk4f(0.5f);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 template <DstType D> void general_1(const SkXfermode* xfer, uint32_t dst[],
                                     const SkPM4f* src, int count, const SkAlpha aa[]) {
+    const SkPM4f s = rgba_to_pmcolor_order(*src);
     SkXfermodeProc4f proc = xfer->getProc4f();
     SkPM4f d;
     if (aa) {
         for (int i = 0; i < count; ++i) {
             Sk4f d4 = load_dst<D>(dst[i]);
             d4.store(d.fVec);
-            Sk4f r4 = Sk4f::Load(proc(*src, d).fVec);
+            Sk4f r4 = Sk4f::Load(proc(s, d).fVec);
             dst[i] = store_dst<D>(lerp(r4, d4, aa[i]));
         }
     } else {
         for (int i = 0; i < count; ++i) {
             load_dst<D>(dst[i]).store(d.fVec);
-            Sk4f r4 = Sk4f::Load(proc(*src, d).fVec);
+            Sk4f r4 = Sk4f::Load(proc(s, d).fVec);
             dst[i] = store_dst<D>(r4);
         }
     }
 }
 
 template <DstType D> void general_n(const SkXfermode* xfer, uint32_t dst[],
                                     const SkPM4f src[], int count, const SkAlpha aa[]) {
     SkXfermodeProc4f proc = xfer->getProc4f();
     SkPM4f d;
     if (aa) {
         for (int i = 0; i < count; ++i) {
             Sk4f d4 = load_dst<D>(dst[i]);
             d4.store(d.fVec);
-            Sk4f r4 = Sk4f::Load(proc(src[i], d).fVec);
+            Sk4f r4 = Sk4f::Load(proc(rgba_to_pmcolor_order(src[i]), d).fVec);
             dst[i] = store_dst<D>(lerp(r4, d4, aa[i]));
         }
     } else {
         for (int i = 0; i < count; ++i) {
             load_dst<D>(dst[i]).store(d.fVec);
-            Sk4f r4 = Sk4f::Load(proc(src[i], d).fVec);
+            Sk4f r4 = Sk4f::Load(proc(rgba_to_pmcolor_order(src[i]), d).fVec);
             dst[i] = store_dst<D>(r4);
         }
     }
 }
 
 const SkXfermode::D32Proc gProcs_General[] = {
     general_n<kLinear_Dst>, general_n<kLinear_Dst>,
     general_1<kLinear_Dst>, general_1<kLinear_Dst>,
     general_n<kSRGB_Dst>,   general_n<kSRGB_Dst>,
     general_1<kSRGB_Dst>,   general_1<kSRGB_Dst>,
@@ skipping 46 matching lines @@
 template <DstType D> void src_n(const SkXfermode*, uint32_t dst[],
                                 const SkPM4f src[], int count, const SkAlpha aa[]) {
     for (int i = 0; i < count; ++i) {
         unsigned a = 0xFF;
         if (aa) {
             a = aa[i];
             if (0 == a) {
                 continue;
             }
         }
-        Sk4f r4 = Sk4f::Load(src[i].fVec);   // src always overrides dst
+        Sk4f r4 = src[i].to4f_pmorder();
         if (a != 0xFF) {
             Sk4f d4 = load_dst<D>(dst[i]);
             r4 = lerp(r4, d4, a);
         }
         dst[i] = store_dst<D>(r4);
     }
 }
 
 static Sk4f lerp(const Sk4f& src, const Sk4f& dst, const Sk4f& src_scale) {
     return dst + (src - dst) * src_scale;
 }
 
 template <DstType D> void src_1(const SkXfermode*, uint32_t dst[],
                                 const SkPM4f* src, int count, const SkAlpha aa[]) {
-    const Sk4f s4 = Sk4f::Load(src->fVec);
+    const Sk4f s4 = src->to4f_pmorder();
 
     if (aa) {
         if (D == kLinear_Dst) {
             // operate in bias-255 space for src and dst
             const Sk4f& s4_255 = s4 * Sk4f(255);
             while (count >= 4) {
                 Sk4f aa4 = SkNx_cast<float>(Sk4b::Load(aa)) * Sk4f(1/255.f);
                 Sk4f r0 = lerp(s4_255, to_4f(dst[0]), Sk4f(aa4[0])) + Sk4f(0.5f);
                 Sk4f r1 = lerp(s4_255, to_4f(dst[1]), Sk4f(aa4[1])) + Sk4f(0.5f);
                 Sk4f r2 = lerp(s4_255, to_4f(dst[2]), Sk4f(aa4[2])) + Sk4f(0.5f);
@@ skipping 55 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 template <DstType D> void srcover_n(const SkXfermode*, uint32_t dst[],
                                     const SkPM4f src[], int count, const SkAlpha aa[]) {
     if (aa) {
         for (int i = 0; i < count; ++i) {
             unsigned a = aa[i];
             if (0 == a) {
                 continue;
             }
-            Sk4f s4 = Sk4f::Load(src[i].fVec);
+            Sk4f s4 = src[i].to4f_pmorder();
             Sk4f d4 = load_dst<D>(dst[i]);
             if (a != 0xFF) {
                 s4 = scale_by_coverage(s4, a);
             }
             Sk4f r4 = s4 + d4 * Sk4f(1 - get_alpha(s4));
             dst[i] = store_dst<D>(r4);
         }
     } else {
         for (int i = 0; i < count; ++i) {
-            Sk4f s4 = Sk4f::Load(src[i].fVec);
+            Sk4f s4 = src[i].to4f_pmorder();
             Sk4f d4 = load_dst<D>(dst[i]);
             Sk4f r4 = s4 + d4 * Sk4f(1 - get_alpha(s4));
             dst[i] = store_dst<D>(r4);
         }
     }
 }
 
 static void srcover_linear_dst_1(const SkXfermode*, uint32_t dst[],
                                  const SkPM4f* src, int count, const SkAlpha aa[]) {
-    const Sk4f s4 = Sk4f::Load(src->fVec);
+    const Sk4f s4 = src->to4f_pmorder();
     const Sk4f dst_scale = Sk4f(1 - get_alpha(s4));
     
     if (aa) {
         for (int i = 0; i < count; ++i) {
             unsigned a = aa[i];
             if (0 == a) {
                 continue;
             }
             Sk4f d4 = Sk4f_fromL32(dst[i]);
             Sk4f r4;
@@ skipping 22 matching lines @@
         }
         for (int i = 0; i < count; ++i) {
             Sk4f d4 = to_4f(dst[i]);
             dst[i] = to_4b(s4_255 + d4 * dst_scale);
         }
     }
 }
 
 static void srcover_srgb_dst_1(const SkXfermode*, uint32_t dst[],
                                const SkPM4f* src, int count, const SkAlpha aa[]) {
-    Sk4f s4 = Sk4f::Load(src->fVec);
+    Sk4f s4 = src->to4f_pmorder();
     Sk4f dst_scale = Sk4f(1 - get_alpha(s4));
 
     if (aa) {
         for (int i = 0; i < count; ++i) {
             unsigned a = aa[i];
             if (0 == a) {
                 continue;
             }
             Sk4f d4 = srgb_4b_to_linear_unit(dst[i]);
             Sk4f r4;
@@ skipping 154 matching lines @@
 
     const LCD32Proc procs[] = {
         srcover_n_lcd<kSRGB_Dst>,   src_n_lcd<kSRGB_Dst>,
         srcover_1_lcd<kSRGB_Dst>,   src_1_lcd<kSRGB_Dst>,
 
         srcover_n_lcd<kLinear_Dst>, src_n_lcd<kLinear_Dst>,
         srcover_1_lcd<kLinear_Dst>, src_1_lcd<kLinear_Dst>,
     };
     return procs[flags];
 }