Add swizzle for rgb8888.

src/core/SkLinearBitmapPipeline.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 "SkLinearBitmapPipeline.h"
 #include "SkPM4f.h"
 
@@ skipping 695 matching lines @@
 }
 
 class sRGBFast {
 public:
     static Sk4s VECTORCALL sRGBToLinear(Sk4s pixel) {
         Sk4s l = pixel * pixel;
         return Sk4s{l[0], l[1], l[2], pixel[3]};
     }
 };
 
-template <SkColorProfileType colorProfile>
+enum ShouldSizzle {
+    kPassthrough = false,
+    kSwizzle = true,

[mtklein_C, 2016/02/29 20:15:54]

Let's call this kSwapRB or kSwap02?  It'd be nice to make explicit what swizzle
we're up to.

[herb_g, 2016/02/29 21:30:58]

Done.

+};
+template <SkColorProfileType colorProfile, ShouldSizzle swizzle = kPassthrough>
 class RGBA8888 {
 public:
     RGBA8888(int width, const uint32_t* src)
         : fSrc{src}, fWidth{width}{ }
 
     void VECTORCALL getFewPixels(int n, Sk4s xs, Sk4s ys, Sk4f* px0, Sk4f* px1, Sk4f* px2) {
         Sk4i XIs = SkNx_cast<int, SkScalar>(xs);
         Sk4i YIs = SkNx_cast<int, SkScalar>(ys);
         Sk4i bufferLoc = YIs * fWidth + XIs;
         switch (n) {
@@ skipping 20 matching lines @@
 
     void get4Pixels(const uint32_t* src, int index, Sk4f* px0, Sk4f* px1, Sk4f* px2, Sk4f* px3) {
         *px0 = this->getPixel(src, index + 0);
         *px1 = this->getPixel(src, index + 1);
         *px2 = this->getPixel(src, index + 2);
         *px3 = this->getPixel(src, index + 3);
     }
 
     Sk4f getPixel(const uint32_t* src, int index) {
         Sk4b bytePixel = Sk4b::Load((uint8_t *)(&src[index]));
+        if (kSwizzle == swizzle) {
+            bytePixel = SkNx_shuffle<2, 1, 0, 3>(bytePixel);

[mtklein_C, 2016/02/29 20:15:54]

Is there some reason we need to swap the bytes before converting to float?
It's probably simpler to swap the floats, and faster on more machines.

[herb_g, 2016/02/29 21:30:58]

Done.

+        }
         Sk4f pixel = SkNx_cast<float, uint8_t>(bytePixel);
         pixel = pixel * Sk4f{1.0f/255.0f};
-        if (colorProfile == kSRGB_SkColorProfileType) {
+        if (kSRGB_SkColorProfileType == colorProfile) {

[mtklein_C, 2016/02/29 20:15:54]

This seems fine if you like this style, but I think we've got plenty enough
warnings to catch a typo here that it doesn't matter.

[herb_g, 2016/02/29 21:30:58]

Great. I do not like yoda ==.

             pixel = sRGBFast::sRGBToLinear(pixel);
         }
         return pixel;
     }
 
     const uint32_t* row(int y) { return fSrc + y * fWidth[0]; }
 
 private:
     const uint32_t* const fSrc;
     const Sk4i fWidth;
@@ skipping 142 matching lines @@
     SourceStrategy fStrategy;
 };
 
 static SkLinearBitmapPipeline::BilerpProcessorInterface* choose_pixel_sampler(
     SkLinearBitmapPipeline::PixelPlacerInterface* next,
     const SkPixmap& srcPixmap,
     SkLinearBitmapPipeline::SampleStage* sampleStage) {
     const SkImageInfo& imageInfo = srcPixmap.info();
     switch (imageInfo.colorType()) {
         case kRGBA_8888_SkColorType:
+            if (imageInfo.profileType() == kSRGB_SkColorProfileType) {
+                sampleStage->Initialize<Sampler<RGBA8888<kSRGB_SkColorProfileType>>>(
+                    next, static_cast<int>(srcPixmap.rowBytes() / 4),
+                    srcPixmap.addr32());
+            } else {
+                sampleStage->Initialize<Sampler<RGBA8888<kLinear_SkColorProfileType>>>(
+                    next, static_cast<int>(srcPixmap.rowBytes() / 4),
+                    srcPixmap.addr32());
+            }
+            break;
         case kBGRA_8888_SkColorType:
             if (kN32_SkColorType == imageInfo.colorType()) {

[mtklein_C, 2016/02/29 20:15:54]

remove

[herb_g, 2016/02/29 21:30:58]

Done.

                 if (imageInfo.profileType() == kSRGB_SkColorProfileType) {
-                    sampleStage->Initialize<Sampler<RGBA8888<kSRGB_SkColorProfileType>>>(
+                    sampleStage->Initialize<Sampler<RGBA8888<kSRGB_SkColorProfileType, kSwizzle>>>(
                         next, static_cast<int>(srcPixmap.rowBytes() / 4),
                         srcPixmap.addr32());
                 } else {
-                    sampleStage->Initialize<Sampler<RGBA8888<kLinear_SkColorProfileType>>>(
+                    sampleStage->Initialize<Sampler<RGBA8888<kLinear_SkColorProfileType, kSwizzle>>>(
                         next, static_cast<int>(srcPixmap.rowBytes() / 4),
                         srcPixmap.addr32());
                 }
-            } else {
-                SkFAIL("Not implemented. No 8888 Swizzle");
             }
             break;
         default:
             SkFAIL("Not implemented. Unsupported src");
             break;
     }
     return sampleStage->get();
 }
 
 template <SkAlphaType alphaType>
@@ skipping 68 matching lines @@
 
 void SkLinearBitmapPipeline::shadeSpan4f(int x, int y, SkPM4f* dst, int count) {
     SkASSERT(count > 0);
     fPixelStage->setDestination(dst);
     // The count and length arguments start out in a precise relation in order to keep the
     // math correct through the different stages. Count is the number of pixel to produce.
     // Since the code samples at pixel centers, length is the distance from the center of the
     // first pixel to the center of the last pixel. This implies that length is count-1.
     fFirstStage->pointSpan(Span{SkPoint{x + 0.5f, y + 0.5f}, count - 1.0f, count});
 }