Add F16 source to the linear pipelin.

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 531 matching lines @@
     }
 
     void bilerpSpan(Span span, SkScalar y) override {
         fSampler.bilerpSpanWithY(span, y);
     }
 
 private:
     GeneralSampler<SourceStrategy, Next> fSampler;
 };
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Specialized Samplers
+
 // RGBA8888UnitRepeatSrc - A sampler that takes advantage of the fact the the src and destination
 // are the same format and do not need in transformations in pixel space. Therefore, there is no
 // need to convert them to HiFi pixel format.
 class RGBA8888UnitRepeat final : public SkLinearBitmapPipeline::SampleProcessorInterface,
                                  public SkLinearBitmapPipeline::DestinationInterface {
 public:
     RGBA8888UnitRepeat(const uint32_t* src, int32_t width)
         : fSrc{src}, fWidth{width} { }
 
     void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
@@ skipping 82 matching lines @@
                 sampleStage->initStage<Sampler<Pixel8888LBGR, Blender>>(next, srcPixmap);
             }
             break;
         case kIndex_8_SkColorType:
             if (imageInfo.profileType() == kSRGB_SkColorProfileType) {
                 sampleStage->initStage<Sampler<PixelIndex8SRGB, Blender>>(next, srcPixmap);
             } else {
                 sampleStage->initStage<Sampler<PixelIndex8LRGB, Blender>>(next, srcPixmap);
             }
             break;
+        case kRGBA_F16_SkColorType:
+            sampleStage->initStage<Sampler<PixelHalfLinear, Blender>>(next, srcPixmap);
+            break;
         default:
             SkFAIL("Not implemented. Unsupported src");
             break;
     }
     return sampleStage->get();
 }
 
 SkLinearBitmapPipeline::SampleProcessorInterface* choose_pixel_sampler(
     Blender* next,
     SkFilterQuality filterQuality,
@@ skipping 47 matching lines @@
     static Sk4f VECTORCALL Premultiply(Sk4f pixel) {
         float alpha = pixel[3];
         return pixel * Sk4f{alpha, alpha, alpha, 1.0f};
     }
 
     SkPM4f* fDst;
     SkPM4f* fEnd;
     Sk4f fPostAlpha;
 };
 
-static SkLinearBitmapPipeline::BlendProcessorInterface* choose_blender(
+static SkLinearBitmapPipeline::BlendProcessorInterface* choose_blender_for_shading(
     SkAlphaType alphaType,
     float postAlpha,
     SkLinearBitmapPipeline::BlenderStage* blenderStage) {
     if (alphaType == kUnpremul_SkAlphaType) {
         blenderStage->initSink<SrcFPPixel<kUnpremul_SkAlphaType>>(postAlpha);
     } else {
         // kOpaque_SkAlphaType is treated the same as kPremul_SkAlphaType
         blenderStage->initSink<SrcFPPixel<kPremul_SkAlphaType>>(postAlpha);
     }
     return blenderStage->get();
 }
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // SkLinearBitmapPipeline
 SkLinearBitmapPipeline::~SkLinearBitmapPipeline() {}
 
 SkLinearBitmapPipeline::SkLinearBitmapPipeline(
     const SkMatrix& inverse,
     SkFilterQuality filterQuality,
     SkShader::TileMode xTile, SkShader::TileMode yTile,
@@ skipping 18 matching lines @@
     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;
     }
 
     // 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(alphaType, postAlpha, &fBlenderStage);
+    auto blenderStage = choose_blender_for_shading(alphaType, postAlpha, &fBlenderStage);
     auto samplerStage = choose_pixel_sampler(blenderStage, filterQuality, srcPixmap, &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,
@@ skipping 58 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});
 }