Fix color order for 565,4444, and I8 samplers.

src/core/SkLinearBitmapPipeline_sample.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkLinearBitmapPipeline_sampler_DEFINED
 #define SkLinearBitmapPipeline_sampler_DEFINED
 
@@ skipping 59 matching lines @@
 
     Sk4f toSk4f(const Element pixel) const {
         return fTintColor * (pixel * (1.0f/255.0f));
     }
 
 private:
     const Sk4f fTintColor;
 };
 
 template <SkGammaType gammaType>
+static inline Sk4f pmcolor_to_rgba(SkPMColor pixel) {
+    return swizzle_rb_if_bgra(
+            (gammaType == kSRGB_SkGammaType) ? Sk4f_fromS32(pixel)
+                                             : Sk4f_fromL32(pixel));
+}
+
+template <SkGammaType gammaType>
 class PixelConverter<kRGB_565_SkColorType, gammaType> {
 public:
     using Element = uint16_t;
     PixelConverter(const SkPixmap& srcPixmap) { }
 
     Sk4f toSk4f(Element pixel) const {
-        SkPMColor pixel32 = SkPixel16ToPixel32(pixel);
-        return gammaType == kSRGB_SkGammaType
-               ? Sk4f_fromS32(pixel32)
-               : Sk4f_fromL32(pixel32);
+        return pmcolor_to_rgba<gammaType>(SkPixel16ToPixel32(pixel));
     }
 };
 
 template <SkGammaType gammaType>
 class PixelConverter<kARGB_4444_SkColorType, gammaType> {
 public:
     using Element = uint16_t;
     PixelConverter(const SkPixmap& srcPixmap) { }
 
     Sk4f toSk4f(Element pixel) const {
-        SkPMColor pixel32 = SkPixel4444ToPixel32(pixel);
-        return gammaType == kSRGB_SkGammaType
-               ? Sk4f_fromS32(pixel32)
-               : Sk4f_fromL32(pixel32);
+        return pmcolor_to_rgba<gammaType>(SkPixel4444ToPixel32(pixel));
     }
 };
 
 template <SkGammaType gammaType>
 class PixelConverter<kRGBA_8888_SkColorType, gammaType> {
 public:
     using Element = uint32_t;
     PixelConverter(const SkPixmap& srcPixmap) { }
 
     Sk4f toSk4f(Element pixel) const {
@@ skipping 18 matching lines @@
 template <SkGammaType gammaType>
 class PixelConverter<kIndex_8_SkColorType, gammaType> {
 public:
     using Element = uint8_t;
     PixelConverter(const SkPixmap& srcPixmap) {
         SkColorTable* skColorTable = srcPixmap.ctable();
         SkASSERT(skColorTable != nullptr);
 
         fColorTable = (Sk4f*)SkAlign16((intptr_t)fColorTableStorage.get());
         for (int i = 0; i < skColorTable->count(); i++) {
-            fColorTable[i] = this->convertPixel((*skColorTable)[i]);
+            fColorTable[i] = pmcolor_to_rgba<gammaType>((*skColorTable)[i]);
         }
     }
 
     PixelConverter(const PixelConverter& strategy) {
         fColorTable = (Sk4f*)SkAlign16((intptr_t)fColorTableStorage.get());
         // TODO: figure out the count.
         for (int i = 0; i < 256; i++) {
             fColorTable[i] = strategy.fColorTable[i];
         }
     }
 
     Sk4f toSk4f(Element index) const {
         return fColorTable[index];
     }
 
 private:
     static const size_t kColorTableSize = sizeof(Sk4f[256]) + 12;
-    Sk4f convertPixel(SkPMColor pmColor) {
-        Sk4f pixel = to_4f(pmColor);
-        float alpha = get_alpha(pixel);
-        if (alpha != 0.0f) {
-            float invAlpha = 1.0f / alpha;
-            Sk4f normalize = {invAlpha, invAlpha, invAlpha, 1.0f / 255.0f};
-            pixel = pixel * normalize;
-            if (gammaType == kSRGB_SkGammaType) {
-                pixel = linear_to_srgb(pixel);
-            }
-            return pixel;
-        } else {
-            return Sk4f{0.0f};
-        }
-    }
+
     SkAutoMalloc         fColorTableStorage{kColorTableSize};
     Sk4f*                fColorTable;
 };
 
 template <SkGammaType gammaType>
 class PixelConverter<kGray_8_SkColorType, gammaType> {
 public:
     using Element = uint8_t;
     PixelConverter(const SkPixmap& srcPixmap) { }
 
@@ skipping 653 matching lines @@
         }
     }
 
     Next* const fNext;
     Accessor    fAccessor;
 };
 
 }  // namespace
 
 #endif  // SkLinearBitmapPipeline_sampler_DEFINED