All source types working for linear pipeline.

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 <algorithm>
@@ skipping 690 matching lines @@
     };
 
     const uint32_t* const fSrc;
     const int32_t         fWidth;
     uint32_t*             fDest;
     uint32_t*             fEnd;
 };
 
 using Blender = SkLinearBitmapPipeline::BlendProcessorInterface;
 
+template <SkColorType colorType, template <SkColorType, SkColorProfileType, typename> class Sampler>
+static void choose_specific_sampler(
+    Blender* next,
+    const SkPixmap& srcPixmap,
+    SkLinearBitmapPipeline::SampleStage* sampleStage)
+{
+    if (srcPixmap.info().profileType() == kSRGB_SkColorProfileType) {
+        using S = Sampler<colorType, kSRGB_SkColorProfileType, Blender>;
+        sampleStage->initStage<S>(next, srcPixmap);
+    } else {
+        using S = Sampler<colorType, kLinear_SkColorProfileType, Blender>;
+        sampleStage->initStage<S>(next, srcPixmap);
+    }
+}
+
 template<template <SkColorType, SkColorProfileType, typename> class Sampler>
 static SkLinearBitmapPipeline::SampleProcessorInterface* choose_pixel_sampler_base(
     Blender* next,
     const SkPixmap& srcPixmap,
-    SkLinearBitmapPipeline::SampleStage* sampleStage) {
+    const SkColor A8TintColor,
+    SkLinearBitmapPipeline::SampleStage* sampleStage)
+{
     const SkImageInfo& imageInfo = srcPixmap.info();
     switch (imageInfo.colorType()) {
-        case kRGBA_8888_SkColorType:
-            if (imageInfo.profileType() == kSRGB_SkColorProfileType) {
-                using S = Sampler<kRGBA_8888_SkColorType, kSRGB_SkColorProfileType, Blender>;
-                sampleStage->initStage<S>(next, srcPixmap);
-            } else {
-                using S = Sampler<kRGBA_8888_SkColorType, kLinear_SkColorProfileType, Blender>;
-                sampleStage->initStage<S>(next, srcPixmap);
+        case kAlpha_8_SkColorType: {
+                using S = Sampler<kAlpha_8_SkColorType, kLinear_SkColorProfileType, Blender>;
+                sampleStage->initStage<S>(next, srcPixmap, A8TintColor);
             }
             break;
+        case kARGB_4444_SkColorType:
+            choose_specific_sampler<kARGB_4444_SkColorType, Sampler>(next, srcPixmap, sampleStage);
+            break;
+        case kRGB_565_SkColorType:
+            choose_specific_sampler<kRGB_565_SkColorType, Sampler>(next, srcPixmap, sampleStage);
+            break;
+        case kRGBA_8888_SkColorType:
+            choose_specific_sampler<kRGBA_8888_SkColorType, Sampler>(next, srcPixmap, sampleStage);
+            break;
         case kBGRA_8888_SkColorType:
-            if (imageInfo.profileType() == kSRGB_SkColorProfileType) {
-                using S = Sampler<kBGRA_8888_SkColorType, kSRGB_SkColorProfileType, Blender>;
-                sampleStage->initStage<S>(next, srcPixmap);
-            } else {
-                using S = Sampler<kBGRA_8888_SkColorType, kLinear_SkColorProfileType, Blender>;
-                sampleStage->initStage<S>(next, srcPixmap);
-            }
+            choose_specific_sampler<kBGRA_8888_SkColorType, Sampler>(next, srcPixmap, sampleStage);
             break;
         case kIndex_8_SkColorType:
-            if (imageInfo.profileType() == kSRGB_SkColorProfileType) {
-                using S = Sampler<kIndex_8_SkColorType, kSRGB_SkColorProfileType, Blender>;
-                sampleStage->initStage<S>(next, srcPixmap);
-            } else {
-                using S = Sampler<kIndex_8_SkColorType, kLinear_SkColorProfileType, Blender>;
-                sampleStage->initStage<S>(next, srcPixmap);
-            }
+            choose_specific_sampler<kIndex_8_SkColorType, Sampler>(next, srcPixmap, sampleStage);
+            break;
+        case kGray_8_SkColorType:
+            choose_specific_sampler<kGray_8_SkColorType, Sampler>(next, srcPixmap, sampleStage);
             break;
         case kRGBA_F16_SkColorType: {
                 using S = Sampler<kRGBA_F16_SkColorType, kLinear_SkColorProfileType, Blender>;
                 sampleStage->initStage<S>(next, srcPixmap);
             }
             break;
         default:
             SkFAIL("Not implemented. Unsupported src");
             break;
     }
     return sampleStage->get();
 }
 
 SkLinearBitmapPipeline::SampleProcessorInterface* choose_pixel_sampler(
     Blender* next,
     SkFilterQuality filterQuality,
     const SkPixmap& srcPixmap,
+    const SkColor A8TintColor,
     SkLinearBitmapPipeline::SampleStage* sampleStage)
 {
     if (filterQuality == kNone_SkFilterQuality) {
-        return choose_pixel_sampler_base<NearestNeighborSampler>(next, srcPixmap, sampleStage);
+        return choose_pixel_sampler_base<NearestNeighborSampler>(
+            next, srcPixmap, A8TintColor, sampleStage);
     } else {
-        return choose_pixel_sampler_base<BilerpSampler>(next, srcPixmap, sampleStage);
+        return choose_pixel_sampler_base<BilerpSampler>(next, srcPixmap, A8TintColor, sampleStage);
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Pixel Blender Stage
 template <SkAlphaType alphaType>
 class SrcFPPixel final : public SkLinearBitmapPipeline::BlendProcessorInterface {
 public:
     SrcFPPixel(float postAlpha) : fPostAlpha{postAlpha} { }
     SrcFPPixel(const SrcFPPixel& Blender) : fPostAlpha(Blender.fPostAlpha) {}
@@ skipping 53 matching lines @@
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // SkLinearBitmapPipeline
 SkLinearBitmapPipeline::~SkLinearBitmapPipeline() {}
 
 SkLinearBitmapPipeline::SkLinearBitmapPipeline(
     const SkMatrix& inverse,
     SkFilterQuality filterQuality,
     SkShader::TileMode xTile, SkShader::TileMode yTile,
-    float postAlpha,
+    SkColor paintColor,
     const SkPixmap& srcPixmap)
 {
     SkISize dimensions = srcPixmap.info().dimensions();
     const SkImageInfo& srcImageInfo = srcPixmap.info();
 
     SkMatrix adjustedInverse = inverse;
     if (filterQuality == kNone_SkFilterQuality) {
         if (inverse.getScaleX() >= 0.0f) {
             adjustedInverse.setTranslateX(
                 nextafterf(inverse.getTranslateX(), std::floor(inverse.getTranslateX())));
         }
         if (inverse.getScaleY() >= 0.0f) {
             adjustedInverse.setTranslateY(
                 nextafterf(inverse.getTranslateY(), std::floor(inverse.getTranslateY())));
         }
     }
 
     SkScalar dx = adjustedInverse.getScaleX();
 
     // If it is an index 8 color type, the sampler converts to unpremul for better fidelity.
     SkAlphaType alphaType = srcImageInfo.alphaType();
     if (srcPixmap.colorType() == kIndex_8_SkColorType) {
         alphaType = kUnpremul_SkAlphaType;
     }
 
+    float postAlpha = SkColorGetA(paintColor) * (1.0f / 255.0f);
     // As the stages are built, the chooser function may skip a stage. For example, with the
     // identity matrix, the matrix stage is skipped, and the tilerStage is the first stage.
     auto blenderStage = choose_blender_for_shading(alphaType, postAlpha, &fBlenderStage);
-    auto samplerStage = choose_pixel_sampler(blenderStage, filterQuality, srcPixmap, &fSampleStage);
+    auto samplerStage = choose_pixel_sampler(
+        blenderStage, filterQuality, srcPixmap, paintColor, &fSampleStage);
     auto tilerStage   = choose_tiler(samplerStage, dimensions, xTile, yTile,
                                      filterQuality, dx, &fTileStage);
     fFirstStage       = choose_matrix(tilerStage, adjustedInverse, &fMatrixStage);
     fLastStage        = blenderStage;
 }
 
 bool SkLinearBitmapPipeline::ClonePipelineForBlitting(
     void* blitterStorage,
     const SkLinearBitmapPipeline& pipeline,
     SkMatrix::TypeMask matrixMask,
@@ skipping 64 matching lines @@
 void SkLinearBitmapPipeline::blitSpan(int x, int y, void* dst, int count) {
     SkASSERT(count > 0);
     fLastStage->setDestination(dst, count);
 
     // 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{{x + 0.5f, y + 0.5f}, count - 1.0f, count});
 }