Add BGRA as input format to SkColorSpaceXform

src/core/SkColorSpaceXform.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 "SkColorPriv.h"
 #include "SkColorSpace_Base.h"
 #include "SkColorSpacePriv.h"
@@ skipping 598 matching lines @@
 }
 
 static inline void load_matrix(const float matrix[16],
                                Sk4f& rXgXbX, Sk4f& rYgYbY, Sk4f& rZgZbZ, Sk4f& rTgTbT) {
     rXgXbX = Sk4f::Load(matrix +  0);
     rYgYbY = Sk4f::Load(matrix +  4);
     rZgZbZ = Sk4f::Load(matrix +  8);
     rTgTbT = Sk4f::Load(matrix + 12);
 }
 
+enum Order {
+    kRGBA_Order,
+    kBGRA_Order,
+};
+
+#define SET_SHIFTS               \

[mtklein, 2016/09/22 13:57:00]

Let's see if we can get close to what you want here without a macro...

    int kRShift, kGShift = 8, kBShift, kAShift = 24;
    set_rb_shifts(kOrder, &kRShift, &kBShift);

?

[msarett, 2016/09/22 17:06:54]

Done.

+    int kRShift = 0;             \
+    int kGShift = 8;             \
+    int kBShift = 16;            \
+    if (kBGRA_Order == kOrder) { \
+        kBShift = 0;             \
+        kRShift = 16;            \
+    }
+
+template <Order kOrder>
 static inline void load_rgb_from_tables(const uint32_t* src,
                                         Sk4f& r, Sk4f& g, Sk4f& b, Sk4f& a,
                                         const float* const srcTables[3]) {
-    r = { srcTables[0][(src[0] >>  0) & 0xFF],
-          srcTables[0][(src[1] >>  0) & 0xFF],
-          srcTables[0][(src[2] >>  0) & 0xFF],
-          srcTables[0][(src[3] >>  0) & 0xFF], };
-    g = { srcTables[1][(src[0] >>  8) & 0xFF],
-          srcTables[1][(src[1] >>  8) & 0xFF],
-          srcTables[1][(src[2] >>  8) & 0xFF],
-          srcTables[1][(src[3] >>  8) & 0xFF], };
-    b = { srcTables[2][(src[0] >> 16) & 0xFF],
-          srcTables[2][(src[1] >> 16) & 0xFF],
-          srcTables[2][(src[2] >> 16) & 0xFF],
-          srcTables[2][(src[3] >> 16) & 0xFF], };
+    SET_SHIFTS;
+    r = { srcTables[0][(src[0] >> kRShift) & 0xFF],
+          srcTables[0][(src[1] >> kRShift) & 0xFF],
+          srcTables[0][(src[2] >> kRShift) & 0xFF],
+          srcTables[0][(src[3] >> kRShift) & 0xFF], };
+    g = { srcTables[1][(src[0] >> kGShift) & 0xFF],
+          srcTables[1][(src[1] >> kGShift) & 0xFF],
+          srcTables[1][(src[2] >> kGShift) & 0xFF],
+          srcTables[1][(src[3] >> kGShift) & 0xFF], };
+    b = { srcTables[2][(src[0] >> kBShift) & 0xFF],
+          srcTables[2][(src[1] >> kBShift) & 0xFF],
+          srcTables[2][(src[2] >> kBShift) & 0xFF],
+          srcTables[2][(src[3] >> kBShift) & 0xFF], };
     a = 0.0f; // Don't let the compiler complain that |a| is uninitialized.
 }
 
+template <Order kOrder>
 static inline void load_rgba_from_tables(const uint32_t* src,
                                          Sk4f& r, Sk4f& g, Sk4f& b, Sk4f& a,
                                          const float* const srcTables[3]) {
-    r = { srcTables[0][(src[0] >>  0) & 0xFF],
-          srcTables[0][(src[1] >>  0) & 0xFF],
-          srcTables[0][(src[2] >>  0) & 0xFF],
-          srcTables[0][(src[3] >>  0) & 0xFF], };
-    g = { srcTables[1][(src[0] >>  8) & 0xFF],
-          srcTables[1][(src[1] >>  8) & 0xFF],
-          srcTables[1][(src[2] >>  8) & 0xFF],
-          srcTables[1][(src[3] >>  8) & 0xFF], };
-    b = { srcTables[2][(src[0] >> 16) & 0xFF],
-          srcTables[2][(src[1] >> 16) & 0xFF],
-          srcTables[2][(src[2] >> 16) & 0xFF],
-          srcTables[2][(src[3] >> 16) & 0xFF], };
+    SET_SHIFTS;
+    r = { srcTables[0][(src[0] >> kRShift) & 0xFF],
+          srcTables[0][(src[1] >> kRShift) & 0xFF],
+          srcTables[0][(src[2] >> kRShift) & 0xFF],
+          srcTables[0][(src[3] >> kRShift) & 0xFF], };
+    g = { srcTables[1][(src[0] >> kRShift) & 0xFF],
+          srcTables[1][(src[1] >> kGShift) & 0xFF],
+          srcTables[1][(src[2] >> kGShift) & 0xFF],
+          srcTables[1][(src[3] >> kGShift) & 0xFF], };
+    b = { srcTables[2][(src[0] >> kBShift) & 0xFF],
+          srcTables[2][(src[1] >> kBShift) & 0xFF],
+          srcTables[2][(src[2] >> kBShift) & 0xFF],
+          srcTables[2][(src[3] >> kBShift) & 0xFF], };
     a = (1.0f / 255.0f) * SkNx_cast<float>(Sk4u::Load(src) >> 24);
 }
 
+template <Order kOrder>
 static inline void load_rgb_linear(const uint32_t* src,
                                    Sk4f& r, Sk4f& g, Sk4f& b, Sk4f& a,
                                    const float* const[3]) {
-    r = (1.0f / 255.0f) * SkNx_cast<float>((Sk4u::Load(src)      ) & 0xFF);
-    g = (1.0f / 255.0f) * SkNx_cast<float>((Sk4u::Load(src) >>  8) & 0xFF);
-    b = (1.0f / 255.0f) * SkNx_cast<float>((Sk4u::Load(src) >> 16) & 0xFF);
+    SET_SHIFTS;
+    r = (1.0f / 255.0f) * SkNx_cast<float>((Sk4u::Load(src) >> kRShift) & 0xFF);
+    g = (1.0f / 255.0f) * SkNx_cast<float>((Sk4u::Load(src) >> kGShift) & 0xFF);
+    b = (1.0f / 255.0f) * SkNx_cast<float>((Sk4u::Load(src) >> kBShift) & 0xFF);
     a = 0.0f; // Don't let the compiler complain that |a| is uninitialized.
 }
 
+template <Order kOrder>
 static inline void load_rgba_linear(const uint32_t* src,
                                     Sk4f& r, Sk4f& g, Sk4f& b, Sk4f& a,
                                     const float* const[3]) {
-    r = (1.0f / 255.0f) * SkNx_cast<float>((Sk4u::Load(src)      ) & 0xFF);
-    g = (1.0f / 255.0f) * SkNx_cast<float>((Sk4u::Load(src) >>  8) & 0xFF);
-    b = (1.0f / 255.0f) * SkNx_cast<float>((Sk4u::Load(src) >> 16) & 0xFF);
-    a = (1.0f / 255.0f) * SkNx_cast<float>((Sk4u::Load(src) >> 24)       );
+    SET_SHIFTS;
+    r = (1.0f / 255.0f) * SkNx_cast<float>((Sk4u::Load(src) >> kRShift) & 0xFF);
+    g = (1.0f / 255.0f) * SkNx_cast<float>((Sk4u::Load(src) >> kGShift) & 0xFF);
+    b = (1.0f / 255.0f) * SkNx_cast<float>((Sk4u::Load(src) >> kBShift) & 0xFF);
+    a = (1.0f / 255.0f) * SkNx_cast<float>((Sk4u::Load(src) >> 24));
 }
 
+template <Order kOrder>
 static inline void load_rgb_from_tables_1(const uint32_t* src,
                                           Sk4f& r, Sk4f& g, Sk4f& b, Sk4f&,
                                           const float* const srcTables[3]) {
-    // Splat r,g,b across a register each.
-    r = Sk4f(srcTables[0][(*src >>  0) & 0xFF]);
-    g = Sk4f(srcTables[1][(*src >>  8) & 0xFF]);
-    b = Sk4f(srcTables[2][(*src >> 16) & 0xFF]);
+    SET_SHIFTS;
+    r = Sk4f(srcTables[0][(*src >> kRShift) & 0xFF]);
+    g = Sk4f(srcTables[1][(*src >> kGShift) & 0xFF]);
+    b = Sk4f(srcTables[2][(*src >> kBShift) & 0xFF]);
 }
 
+template <Order kOrder>
 static inline void load_rgba_from_tables_1(const uint32_t* src,
                                            Sk4f& r, Sk4f& g, Sk4f& b, Sk4f& a,
                                            const float* const srcTables[3]) {
-    // Splat r,g,b across a register each.
-    r = Sk4f(srcTables[0][(*src >>  0) & 0xFF]);
-    g = Sk4f(srcTables[1][(*src >>  8) & 0xFF]);
-    b = Sk4f(srcTables[2][(*src >> 16) & 0xFF]);
+    SET_SHIFTS;
+    r = Sk4f(srcTables[0][(*src >> kRShift) & 0xFF]);
+    g = Sk4f(srcTables[1][(*src >> kGShift) & 0xFF]);
+    b = Sk4f(srcTables[2][(*src >> kBShift) & 0xFF]);
     a = (1.0f / 255.0f) * Sk4f(*src >> 24);
 }
 
+template <Order kOrder>
 static inline void load_rgb_linear_1(const uint32_t* src,
                                      Sk4f& r, Sk4f& g, Sk4f& b, Sk4f&,
                                      const float* const srcTables[3]) {
-    // Splat r,g,b across a register each.
-    r = Sk4f((1.0f / 255.0f) * ((*src      ) & 0xFF));
-    g = Sk4f((1.0f / 255.0f) * ((*src >>  8) & 0xFF));
-    b = Sk4f((1.0f / 255.0f) * ((*src >> 16) & 0xFF));
+    SET_SHIFTS;
+    r = Sk4f((1.0f / 255.0f) * ((*src >> kRShift) & 0xFF));
+    g = Sk4f((1.0f / 255.0f) * ((*src >> kGShift) & 0xFF));
+    b = Sk4f((1.0f / 255.0f) * ((*src >> kBShift) & 0xFF));
 }
 
+template <Order kOrder>
 static inline void load_rgba_linear_1(const uint32_t* src,
                                       Sk4f& r, Sk4f& g, Sk4f& b, Sk4f& a,
                                       const float* const srcTables[3]) {
-    // Splat r,g,b,a across a register each.
-    r = Sk4f((1.0f / 255.0f) * ((*src      ) & 0xFF));
-    g = Sk4f((1.0f / 255.0f) * ((*src >>  8) & 0xFF));
-    b = Sk4f((1.0f / 255.0f) * ((*src >> 16) & 0xFF));
-    a = Sk4f((1.0f / 255.0f) * ((*src >> 24)       ));
+    SET_SHIFTS;
+    r = Sk4f((1.0f / 255.0f) * ((*src >> kRShift) & 0xFF));
+    g = Sk4f((1.0f / 255.0f) * ((*src >> kGShift) & 0xFF));
+    b = Sk4f((1.0f / 255.0f) * ((*src >> kBShift) & 0xFF));
+    a = Sk4f((1.0f / 255.0f) * ((*src >> 24)));
 }
 
 static inline void transform_gamut(const Sk4f& r, const Sk4f& g, const Sk4f& b, const Sk4f& a,
                                    const Sk4f& rXgXbX, const Sk4f& rYgYbY, const Sk4f& rZgZbZ,
                                    Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f& da) {
     dr = rXgXbX[0]*r + rYgYbY[0]*g + rZgZbZ[0]*b;
     dg = rXgXbX[1]*r + rYgYbY[1]*g + rZgZbZ[1]*b;
     db = rXgXbX[2]*r + rYgYbY[2]*g + rZgZbZ[2]*b;
     da = a;
 }
@@ skipping 17 matching lines @@
 static inline void premultiply(Sk4f& dr, Sk4f& dg, Sk4f& db, const Sk4f& da) {
     dr = da * dr;
     dg = da * dg;
     db = da * db;
 }
 
 static inline void premultiply_1(const Sk4f& a, Sk4f& rgba) {
     rgba = a * rgba;
 }
 
-enum SwapRB {
-    kNo_SwapRB,
-    kYes_SwapRB,
-};
-
-template <SwapRB kSwapRB>
+template <Order kOrder>
 static inline void store_srgb(void* dst, const uint32_t* src,
                               Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f&,
                               const uint8_t* const[3]) {
-    int kRShift = 0;
-    int kGShift = 8;
-    int kBShift = 16;
-    if (kYes_SwapRB == kSwapRB) {
-        kBShift = 0;
-        kRShift = 16;
-    }
-
+    SET_SHIFTS;
     dr = sk_linear_to_srgb_needs_trunc(dr);
     dg = sk_linear_to_srgb_needs_trunc(dg);
     db = sk_linear_to_srgb_needs_trunc(db);
 
     dr = sk_clamp_0_255(dr);
     dg = sk_clamp_0_255(dg);
     db = sk_clamp_0_255(db);
 
     Sk4i da = Sk4i::Load(src) & 0xFF000000;
 
     Sk4i rgba = (SkNx_cast<int>(dr) << kRShift)
               | (SkNx_cast<int>(dg) << kGShift)
               | (SkNx_cast<int>(db) << kBShift)
               | (da                           );
     rgba.store(dst);
 }
 
-template <SwapRB kSwapRB>
+template <Order kOrder>
 static inline void store_srgb_1(void* dst, const uint32_t* src,
                                 Sk4f& rgba, const Sk4f&,
                                 const uint8_t* const[3]) {
     rgba = sk_clamp_0_255(sk_linear_to_srgb_needs_trunc(rgba));
 
     uint32_t tmp;
     SkNx_cast<uint8_t>(SkNx_cast<int32_t>(rgba)).store(&tmp);
     tmp = (*src & 0xFF000000) | (tmp & 0x00FFFFFF);
-    if (kYes_SwapRB == kSwapRB) {
+    if (kBGRA_Order == kOrder) {
         tmp = SkSwizzle_RB(tmp);
     }
 
     *(uint32_t*)dst = tmp;
 }
 
 static inline Sk4f linear_to_2dot2(const Sk4f& x) {
     // x^(29/64) is a very good approximation of the true value, x^(1/2.2).
     auto x2  = x.rsqrt(),                            // x^(-1/2)
          x32 = x2.rsqrt().rsqrt().rsqrt().rsqrt(),   // x^(-1/32)
          x64 = x32.rsqrt();                          // x^(+1/64)
 
     // 29 = 32 - 2 - 1
     return 255.0f * x2.invert() * x32 * x64.invert();
 }
 
-template <SwapRB kSwapRB>
+template <Order kOrder>
 static inline void store_2dot2(void* dst, const uint32_t* src,
                                Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f&,
                                const uint8_t* const[3]) {
-    int kRShift = 0;
-    int kGShift = 8;
-    int kBShift = 16;
-    if (kYes_SwapRB == kSwapRB) {
-        kBShift = 0;
-        kRShift = 16;
-    }
-
+    SET_SHIFTS;
     dr = linear_to_2dot2(dr);
     dg = linear_to_2dot2(dg);
     db = linear_to_2dot2(db);
 
     dr = sk_clamp_0_255(dr);
     dg = sk_clamp_0_255(dg);
     db = sk_clamp_0_255(db);
 
     Sk4i da = Sk4i::Load(src) & 0xFF000000;
 
     Sk4i rgba = (Sk4f_round(dr) << kRShift)
               | (Sk4f_round(dg) << kGShift)
               | (Sk4f_round(db) << kBShift)
               | (da                       );
     rgba.store(dst);
 }
 
-template <SwapRB kSwapRB>
+template <Order kOrder>
 static inline void store_2dot2_1(void* dst, const uint32_t* src,
                                  Sk4f& rgba, const Sk4f&,
                                  const uint8_t* const[3]) {
     rgba = sk_clamp_0_255(linear_to_2dot2(rgba));
 
     uint32_t tmp;
     SkNx_cast<uint8_t>(Sk4f_round(rgba)).store(&tmp);
     tmp = (*src & 0xFF000000) | (tmp & 0x00FFFFFF);
-    if (kYes_SwapRB == kSwapRB) {
+    if (kBGRA_Order == kOrder) {
         tmp = SkSwizzle_RB(tmp);
     }
 
     *(uint32_t*)dst = tmp;
 }
 
-template <SwapRB kSwapRB>
+template <Order kOrder>
 static inline void store_linear(void* dst, const uint32_t* src,
                                Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f&,
                                const uint8_t* const[3]) {
-    int kRShift = 0;
-    int kGShift = 8;
-    int kBShift = 16;
-    if (kYes_SwapRB == kSwapRB) {
-        kBShift = 0;
-        kRShift = 16;
-    }
-
+    SET_SHIFTS;
     dr = sk_clamp_0_255(255.0f * dr);
     dg = sk_clamp_0_255(255.0f * dg);
     db = sk_clamp_0_255(255.0f * db);
 
     Sk4i da = Sk4i::Load(src) & 0xFF000000;
 
     Sk4i rgba = (Sk4f_round(dr) << kRShift)
               | (Sk4f_round(dg) << kGShift)
               | (Sk4f_round(db) << kBShift)
               | (da                       );
     rgba.store(dst);
 }
 
-template <SwapRB kSwapRB>
+template <Order kOrder>
 static inline void store_linear_1(void* dst, const uint32_t* src,
                                   Sk4f& rgba, const Sk4f&,
                                   const uint8_t* const[3]) {
     rgba = sk_clamp_0_255(255.0f * rgba);
 
     uint32_t tmp;
     SkNx_cast<uint8_t>(Sk4f_round(rgba)).store(&tmp);
     tmp = (*src & 0xFF000000) | (tmp & 0x00FFFFFF);
-    if (kYes_SwapRB == kSwapRB) {
+    if (kBGRA_Order == kOrder) {
         tmp = SkSwizzle_RB(tmp);
     }
 
     *(uint32_t*)dst = tmp;
 }
 
-template <SwapRB kSwapRB>
+template <Order kOrder>
 static inline void store_f16(void* dst, const uint32_t* src,
                              Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f& da,
                              const uint8_t* const[3]) {
     Sk4h_store4(dst, SkFloatToHalf_finite_ftz(dr),
                      SkFloatToHalf_finite_ftz(dg),
                      SkFloatToHalf_finite_ftz(db),
                      SkFloatToHalf_finite_ftz(da));
 }
 
-template <SwapRB kSwapRB>
+template <Order kOrder>
 static inline void store_f16_1(void* dst, const uint32_t* src,
                                Sk4f& rgba, const Sk4f& a,
                                const uint8_t* const[3]) {
     rgba = Sk4f(rgba[0], rgba[1], rgba[2], a[3]);
     SkFloatToHalf_finite_ftz(rgba).store((uint64_t*) dst);
 }
 
-template <SwapRB kSwapRB>
+template <Order kOrder>
 static inline void store_f32(void* dst, const uint32_t* src,
                              Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f& da,
                              const uint8_t* const[3]) {
     Sk4f_store4(dst, dr, dg, db, da);
 }
 
-template <SwapRB kSwapRB>
+template <Order kOrder>
 static inline void store_f32_1(void* dst, const uint32_t* src,
                                Sk4f& rgba, const Sk4f& a,
                                const uint8_t* const[3]) {
     rgba = Sk4f(rgba[0], rgba[1], rgba[2], a[3]);
     rgba.store((float*) dst);
 }
 
-template <SwapRB kSwapRB>
+template <Order kOrder>
 static inline void store_f16_opaque(void* dst, const uint32_t* src,
                                     Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f&,
                                     const uint8_t* const[3]) {
     Sk4h_store4(dst, SkFloatToHalf_finite_ftz(dr),
                      SkFloatToHalf_finite_ftz(dg),
                      SkFloatToHalf_finite_ftz(db),
                      SK_Half1);
 }
 
-template <SwapRB kSwapRB>
+template <Order kOrder>
 static inline void store_f16_1_opaque(void* dst, const uint32_t* src,
                                       Sk4f& rgba, const Sk4f&,
                                       const uint8_t* const[3]) {
     uint64_t tmp;
     SkFloatToHalf_finite_ftz(rgba).store(&tmp);
     tmp |= static_cast<uint64_t>(SK_Half1) << 48;
     *((uint64_t*) dst) = tmp;
 }
 
-template <SwapRB kSwapRB>
+template <Order kOrder>
 static inline void store_generic(void* dst, const uint32_t* src,
                                  Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f&,
                                  const uint8_t* const dstTables[3]) {
-    int kRShift = 0;
-    int kGShift = 8;
-    int kBShift = 16;
-    if (kYes_SwapRB == kSwapRB) {
-        kBShift = 0;
-        kRShift = 16;
-    }
-
+    SET_SHIFTS;
     dr = Sk4f::Min(Sk4f::Max(1023.0f * dr, 0.0f), 1023.0f);
     dg = Sk4f::Min(Sk4f::Max(1023.0f * dg, 0.0f), 1023.0f);
     db = Sk4f::Min(Sk4f::Max(1023.0f * db, 0.0f), 1023.0f);
 
     Sk4i ir = Sk4f_round(dr);
     Sk4i ig = Sk4f_round(dg);
     Sk4i ib = Sk4f_round(db);
 
     Sk4i da = Sk4i::Load(src) & 0xFF000000;
 
     uint32_t* dst32 = (uint32_t*) dst;
     dst32[0] = dstTables[0][ir[0]] << kRShift
              | dstTables[1][ig[0]] << kGShift
              | dstTables[2][ib[0]] << kBShift
              | da[0];
     dst32[1] = dstTables[0][ir[1]] << kRShift
              | dstTables[1][ig[1]] << kGShift
              | dstTables[2][ib[1]] << kBShift
              | da[1];
     dst32[2] = dstTables[0][ir[2]] << kRShift
              | dstTables[1][ig[2]] << kGShift
              | dstTables[2][ib[2]] << kBShift
              | da[2];
     dst32[3] = dstTables[0][ir[3]] << kRShift
              | dstTables[1][ig[3]] << kGShift
              | dstTables[2][ib[3]] << kBShift
              | da[3];
 }
 
-template <SwapRB kSwapRB>
+template <Order kOrder>
 static inline void store_generic_1(void* dst, const uint32_t* src,
                                    Sk4f& rgba, const Sk4f&,
                                    const uint8_t* const dstTables[3]) {
-    int kRShift = 0;
-    int kGShift = 8;
-    int kBShift = 16;
-    if (kYes_SwapRB == kSwapRB) {
-        kBShift = 0;
-        kRShift = 16;
-    }
-
+    SET_SHIFTS;
     rgba = Sk4f::Min(Sk4f::Max(1023.0f * rgba, 0.0f), 1023.0f);
 
     Sk4i indices = Sk4f_round(rgba);
 
     *((uint32_t*) dst) = dstTables[0][indices[0]] << kRShift
                        | dstTables[1][indices[1]] << kGShift
                        | dstTables[2][indices[2]] << kBShift
                        | (*src & 0xFF000000);
 }
 
-typedef decltype(load_rgb_from_tables       )* LoadFn;
-typedef decltype(load_rgb_from_tables_1     )* Load1Fn;
-typedef decltype(store_generic<kNo_SwapRB>  )* StoreFn;
-typedef decltype(store_generic_1<kNo_SwapRB>)* Store1Fn;
+#undef SET_SHIFTS
+
+typedef decltype(load_rgb_from_tables<kRGBA_Order>  )* LoadFn;
+typedef decltype(load_rgb_from_tables_1<kRGBA_Order>)* Load1Fn;
+typedef decltype(store_generic<kRGBA_Order>         )* StoreFn;
+typedef decltype(store_generic_1<kRGBA_Order>       )* Store1Fn;
 
 template <SkAlphaType kAlphaType,
           ColorSpaceMatch kCSM>
 static inline void do_color_xform(void* dst, const uint32_t* src, int len,
                                   const float* const srcTables[3], const float matrix[16],
                                   const uint8_t* const dstTables[3], LoadFn load, Load1Fn load_1,
                                   StoreFn store, Store1Fn store_1, size_t sizeOfDstPixel) {
     Sk4f rXgXbX, rYgYbY, rZgZbZ, rTgTbT;
     load_matrix(matrix, rXgXbX, rYgYbY, rZgZbZ, rTgTbT);
 
@@ skipping 67 matching lines @@
 
         src += 1;
         len -= 1;
         dst = SkTAddOffset<void>(dst, sizeOfDstPixel);
     }
 }
 
 enum SrcFormat {
     kRGBA_8888_Linear_SrcFormat,
     kRGBA_8888_Table_SrcFormat,
+    kBGRA_8888_Linear_SrcFormat,
+    kBGRA_8888_Table_SrcFormat,
 };
 
 enum DstFormat {
-    k8888_Linear_DstFormat,
-    k8888_SRGB_DstFormat,
-    k8888_2Dot2_DstFormat,
-    k8888_Table_DstFormat,
+    kRGBA_8888_Linear_DstFormat,
+    kRGBA_8888_SRGB_DstFormat,
+    kRGBA_8888_2Dot2_DstFormat,
+    kRGBA_8888_Table_DstFormat,
+    kBGRA_8888_Linear_DstFormat,
+    kBGRA_8888_SRGB_DstFormat,
+    kBGRA_8888_2Dot2_DstFormat,
+    kBGRA_8888_Table_DstFormat,
     kF16_Linear_DstFormat,
     kF32_Linear_DstFormat,
 };
 
 template <SrcFormat kSrc,
           DstFormat kDst,
           SkAlphaType kAlphaType,
-          ColorSpaceMatch kCSM,
-          SwapRB kSwapRB>
+          ColorSpaceMatch kCSM>
 static void color_xform_RGBA(void* dst, const uint32_t* src, int len,
                              const float* const srcTables[3], const float matrix[16],
                              const uint8_t* const dstTables[3]) {
     LoadFn load;
     Load1Fn load_1;
     static constexpr bool loadAlpha = (kPremul_SkAlphaType == kAlphaType) ||
                                       (kF16_Linear_DstFormat == kDst) ||
                                       (kF32_Linear_DstFormat == kDst);
     switch (kSrc) {
         case kRGBA_8888_Linear_SrcFormat:
             if (loadAlpha) {
-                load = load_rgba_linear;
-                load_1 = load_rgba_linear_1;
+                load = load_rgba_linear<kRGBA_Order>;
+                load_1 = load_rgba_linear_1<kRGBA_Order>;
             } else {
-                load = load_rgb_linear;
-                load_1 = load_rgb_linear_1;
+                load = load_rgb_linear<kRGBA_Order>;
+                load_1 = load_rgb_linear_1<kRGBA_Order>;
             }
             break;
         case kRGBA_8888_Table_SrcFormat:
             if (loadAlpha) {
-                load = load_rgba_from_tables;
-                load_1 = load_rgba_from_tables_1;
+                load = load_rgba_from_tables<kRGBA_Order>;
+                load_1 = load_rgba_from_tables_1<kRGBA_Order>;
             } else {
-                load = load_rgb_from_tables;
-                load_1 = load_rgb_from_tables_1;
+                load = load_rgb_from_tables<kRGBA_Order>;
+                load_1 = load_rgb_from_tables_1<kRGBA_Order>;
+            }
+            break;
+        case kBGRA_8888_Linear_SrcFormat:
+            if (loadAlpha) {
+                load = load_rgba_linear<kBGRA_Order>;
+                load_1 = load_rgba_linear_1<kBGRA_Order>;
+            } else {
+                load = load_rgb_linear<kBGRA_Order>;
+                load_1 = load_rgb_linear_1<kBGRA_Order>;
+            }
+            break;
+        case kBGRA_8888_Table_SrcFormat:
+            if (loadAlpha) {
+                load = load_rgba_from_tables<kBGRA_Order>;
+                load_1 = load_rgba_from_tables_1<kBGRA_Order>;
+            } else {
+                load = load_rgb_from_tables<kBGRA_Order>;
+                load_1 = load_rgb_from_tables_1<kBGRA_Order>;
             }
             break;
     }
 
     StoreFn store;
     Store1Fn store_1;
     size_t sizeOfDstPixel;
     switch (kDst) {
-        case k8888_Linear_DstFormat:
-            store   = store_linear<kSwapRB>;
-            store_1 = store_linear_1<kSwapRB>;
+        case kRGBA_8888_Linear_DstFormat:
+            store   = store_linear<kRGBA_Order>;
+            store_1 = store_linear_1<kRGBA_Order>;
             sizeOfDstPixel = 4;
             break;
-        case k8888_SRGB_DstFormat:
-            store   = store_srgb<kSwapRB>;
-            store_1 = store_srgb_1<kSwapRB>;
+        case kRGBA_8888_SRGB_DstFormat:
+            store   = store_srgb<kRGBA_Order>;
+            store_1 = store_srgb_1<kRGBA_Order>;
             sizeOfDstPixel = 4;
             break;
-        case k8888_2Dot2_DstFormat:
-            store   = store_2dot2<kSwapRB>;
-            store_1 = store_2dot2_1<kSwapRB>;
+        case kRGBA_8888_2Dot2_DstFormat:
+            store   = store_2dot2<kRGBA_Order>;
+            store_1 = store_2dot2_1<kRGBA_Order>;
             sizeOfDstPixel = 4;
             break;
-        case k8888_Table_DstFormat:
-            store   = store_generic<kSwapRB>;
-            store_1 = store_generic_1<kSwapRB>;
+        case kRGBA_8888_Table_DstFormat:
+            store   = store_generic<kRGBA_Order>;
+            store_1 = store_generic_1<kRGBA_Order>;
+            sizeOfDstPixel = 4;
+            break;
+        case kBGRA_8888_Linear_DstFormat:
+            store   = store_linear<kBGRA_Order>;
+            store_1 = store_linear_1<kBGRA_Order>;
+            sizeOfDstPixel = 4;
+            break;
+        case kBGRA_8888_SRGB_DstFormat:
+            store   = store_srgb<kBGRA_Order>;
+            store_1 = store_srgb_1<kBGRA_Order>;
+            sizeOfDstPixel = 4;
+            break;
+        case kBGRA_8888_2Dot2_DstFormat:
+            store   = store_2dot2<kBGRA_Order>;
+            store_1 = store_2dot2_1<kBGRA_Order>;
+            sizeOfDstPixel = 4;
+            break;
+        case kBGRA_8888_Table_DstFormat:
+            store   = store_generic<kBGRA_Order>;
+            store_1 = store_generic_1<kBGRA_Order>;
             sizeOfDstPixel = 4;
             break;
         case kF16_Linear_DstFormat:
-            store   = (kOpaque_SkAlphaType == kAlphaType) ? store_f16_opaque<kSwapRB> :
-                                                            store_f16<kSwapRB>;
-            store_1 = (kOpaque_SkAlphaType == kAlphaType) ? store_f16_1_opaque<kSwapRB> :
-                                                            store_f16_1<kSwapRB>;
+            store   = (kOpaque_SkAlphaType == kAlphaType) ? store_f16_opaque<kRGBA_Order> :
+                                                            store_f16<kRGBA_Order>;
+            store_1 = (kOpaque_SkAlphaType == kAlphaType) ? store_f16_1_opaque<kRGBA_Order> :
+                                                            store_f16_1<kRGBA_Order>;
             sizeOfDstPixel = 8;
             break;
         case kF32_Linear_DstFormat:
-            store   = store_f32<kSwapRB>;
-            store_1 = store_f32_1<kSwapRB>;
+            store   = store_f32<kRGBA_Order>;
+            store_1 = store_f32_1<kRGBA_Order>;
             sizeOfDstPixel = 16;
             break;
     }
 
     do_color_xform<kAlphaType, kCSM>
             (dst, src, len, srcTables, matrix, dstTables, load, load_1, store, store_1,
              sizeOfDstPixel);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ skipping 37 matching lines @@
 
     const bool srcGammasAreMatching = (1 >= numSrcTables);
     const bool dstGammasAreMatching = (1 >= numDstTables);
     build_gamma_tables(fSrcGammaTables, srcStorage, 256, srcSpace, kToLinear, srcGammasAreMatching);
     build_gamma_tables(fDstGammaTables, dstStorage, kDstGammaTableSize, dstSpace, kFromLinear,
                        dstGammasAreMatching);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-template <SrcFormat kSrc, DstFormat kDst, ColorSpaceMatch kCSM, SwapRB kSwap>
+template <SrcFormat kSrc, DstFormat kDst, ColorSpaceMatch kCSM>
 static inline void apply_set_alpha(void* dst, const uint32_t* src, int len, SkAlphaType alphaType,
                                    const float* const srcTables[3], const float matrix[16],
                                    const uint8_t* const dstTables[3]) {
     switch (alphaType) {
         case kOpaque_SkAlphaType:
-            return color_xform_RGBA<kSrc, kDst, kOpaque_SkAlphaType, kCSM, kSwap>
+            return color_xform_RGBA<kSrc, kDst, kOpaque_SkAlphaType, kCSM>
                     (dst, src, len, srcTables, matrix, dstTables);
         case kPremul_SkAlphaType:
-            return color_xform_RGBA<kSrc, kDst, kPremul_SkAlphaType, kCSM, kSwap>
+            return color_xform_RGBA<kSrc, kDst, kPremul_SkAlphaType, kCSM>
                     (dst, src, len, srcTables, matrix, dstTables);
         case kUnpremul_SkAlphaType:
-            return color_xform_RGBA<kSrc, kDst, kUnpremul_SkAlphaType, kCSM, kSwap>
+            return color_xform_RGBA<kSrc, kDst, kUnpremul_SkAlphaType, kCSM>
                     (dst, src, len, srcTables, matrix, dstTables);
         default:
             SkASSERT(false);
             return;
     }
 }
 
-template <SrcGamma kSrc, DstFormat kDst, ColorSpaceMatch kCSM, SwapRB kSwap>
+template <SrcGamma kSrc, DstFormat kDst, ColorSpaceMatch kCSM>
 static inline void apply_set_src(void* dst, const uint32_t* src, int len, SkAlphaType alphaType,
                                  const float* const srcTables[3], const float matrix[16],
-                                 const uint8_t* const dstTables[3]) {
-    switch (kSrc) {
-        case kLinear_SrcGamma:
-            return apply_set_alpha<kRGBA_8888_Linear_SrcFormat, kDst, kCSM, kSwap>
-                    (dst, src, len, alphaType, nullptr, matrix, dstTables);
-        case kTable_SrcGamma:
-            return apply_set_alpha<kRGBA_8888_Table_SrcFormat, kDst, kCSM, kSwap>
-                    (dst, src, len, alphaType, srcTables, matrix, dstTables);
+                                 const uint8_t* const dstTables[3],
+                                 SkColorSpaceXform::ColorFormat srcColorFormat) {
+    switch (srcColorFormat) {
+        case SkColorSpaceXform::kRGBA_8888_ColorFormat:
+            switch (kSrc) {
+                case kLinear_SrcGamma:
+                    return apply_set_alpha<kRGBA_8888_Linear_SrcFormat, kDst, kCSM>
+                            (dst, src, len, alphaType, nullptr, matrix, dstTables);
+                case kTable_SrcGamma:
+                    return apply_set_alpha<kRGBA_8888_Table_SrcFormat, kDst, kCSM>
+                            (dst, src, len, alphaType, srcTables, matrix, dstTables);
+            }
+        case SkColorSpaceXform::kBGRA_8888_ColorFormat:
+            switch (kSrc) {
+                case kLinear_SrcGamma:
+                    return apply_set_alpha<kBGRA_8888_Linear_SrcFormat, kDst, kCSM>
+                            (dst, src, len, alphaType, nullptr, matrix, dstTables);
+                case kTable_SrcGamma:
+                    return apply_set_alpha<kBGRA_8888_Table_SrcFormat, kDst, kCSM>
+                            (dst, src, len, alphaType, srcTables, matrix, dstTables);
+            }
+        default:
+            SkASSERT(false);
     }
 }
 
 template <SrcGamma kSrc, DstGamma kDst, ColorSpaceMatch kCSM>
 void SkColorSpaceXform_Base<kSrc, kDst, kCSM>
-::apply(void* dst, const uint32_t* src, int len, ColorFormat dstColorFormat, SkAlphaType alphaType)
+::apply(void* dst, const uint32_t* src, int len, ColorFormat dstColorFormat,
+        ColorFormat srcColorFormat, SkAlphaType alphaType)
 const
 {
     if (kFull_ColorSpaceMatch == kCSM) {
         switch (alphaType) {
             case kPremul_SkAlphaType:
                 // We can't skip the xform since we need to perform a premultiply in the
                 // linear space.
                 break;
             default:
                 switch (dstColorFormat) {
@@ skipping 22 matching lines @@
 #endif
 
         handle_color_lut((uint32_t*) storage.get(), src, len, fColorLUT.get());
         src = (const uint32_t*) storage.get();
     }
 
     switch (dstColorFormat) {
         case kRGBA_8888_ColorFormat:
             switch (kDst) {
                 case kLinear_DstGamma:
-                    return apply_set_src<kSrc, k8888_Linear_DstFormat, kCSM, kNo_SwapRB>
-                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr);
+                    return apply_set_src<kSrc, kRGBA_8888_Linear_DstFormat, kCSM>
+                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr,
+                             srcColorFormat);
                 case kSRGB_DstGamma:
-                    return apply_set_src<kSrc, k8888_SRGB_DstFormat, kCSM, kNo_SwapRB>
-                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr);
+                    return apply_set_src<kSrc, kRGBA_8888_SRGB_DstFormat, kCSM>
+                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr,
+                             srcColorFormat);
                 case k2Dot2_DstGamma:
-                    return apply_set_src<kSrc, k8888_2Dot2_DstFormat, kCSM, kNo_SwapRB>
-                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr);
+                    return apply_set_src<kSrc, kRGBA_8888_2Dot2_DstFormat, kCSM>
+                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr,
+                             srcColorFormat);
                 case kTable_DstGamma:
-                    return apply_set_src<kSrc, k8888_Table_DstFormat, kCSM, kNo_SwapRB>
-                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, fDstGammaTables);
+                    return apply_set_src<kSrc, kRGBA_8888_Table_DstFormat, kCSM>
+                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, fDstGammaTables,
+                             srcColorFormat);
             }
         case kBGRA_8888_ColorFormat:
             switch (kDst) {
                 case kLinear_DstGamma:
-                    return apply_set_src<kSrc, k8888_Linear_DstFormat, kCSM, kYes_SwapRB>
-                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr);
+                    return apply_set_src<kSrc, kBGRA_8888_Linear_DstFormat, kCSM>
+                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr,
+                             srcColorFormat);
                 case kSRGB_DstGamma:
-                    return apply_set_src<kSrc, k8888_SRGB_DstFormat, kCSM, kYes_SwapRB>
-                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr);
+                    return apply_set_src<kSrc, kBGRA_8888_SRGB_DstFormat, kCSM>
+                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr,
+                             srcColorFormat);
                 case k2Dot2_DstGamma:
-                    return apply_set_src<kSrc, k8888_2Dot2_DstFormat, kCSM, kYes_SwapRB>
-                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr);
+                    return apply_set_src<kSrc, kBGRA_8888_2Dot2_DstFormat, kCSM>
+                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr,
+                             srcColorFormat);
                 case kTable_DstGamma:
-                    return apply_set_src<kSrc, k8888_Table_DstFormat, kCSM, kYes_SwapRB>
-                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, fDstGammaTables);
+                    return apply_set_src<kSrc, kBGRA_8888_Table_DstFormat, kCSM>
+                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, fDstGammaTables,
+                             srcColorFormat);
             }
         case kRGBA_F16_ColorFormat:
             switch (kDst) {
                 case kLinear_DstGamma:
-                    return apply_set_src<kSrc, kF16_Linear_DstFormat, kCSM, kNo_SwapRB>
-                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr);
+                    return apply_set_src<kSrc, kF16_Linear_DstFormat, kCSM>
+                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr,
+                             srcColorFormat);
                 default:
                     SkASSERT(false);
                     return;
             }
         case kRGBA_F32_ColorFormat:
             switch (kDst) {
                 case kLinear_DstGamma:
-                    return apply_set_src<kSrc, kF32_Linear_DstFormat, kCSM, kNo_SwapRB>
-                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr);
+                    return apply_set_src<kSrc, kF32_Linear_DstFormat, kCSM>
+                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr,
+                             srcColorFormat);
                 default:
                     SkASSERT(false);
                     return;
             }
         default:
             SkASSERT(false);
             return;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 std::unique_ptr<SkColorSpaceXform> SlowIdentityXform(SkColorSpace* space) {
         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
                 <kTable_SrcGamma, kTable_DstGamma, kNone_ColorSpaceMatch>
                 (space, SkMatrix::I(), space));
 }