Bilerp + mirror + perspective

src/core/SkBitmapProcShader.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapProcShader.h"
 #include "SkBitmapProcState.h"
 #include "SkBitmapProvider.h"
@@ skipping 28 matching lines @@
         }
 
         if (1 == fInfo->fPixmap.height() && only_scale_and_translate(this->getTotalInverse())) {
             fFlags |= SkShader::kConstInY32_Flag;
         }
     }
 
     ~BitmapProcInfoContext() override {
         fInfo->~SkBitmapProcInfo();
     }
-    
+
     uint32_t getFlags() const override { return fFlags; }
 
 private:
     SkBitmapProcInfo*   fInfo;
     uint32_t            fFlags;
 
     typedef SkShader::Context INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ skipping 56 matching lines @@
 #include "SkXfermode.h"
 
 class LinearPipelineContext : public BitmapProcInfoContext {
 public:
     LinearPipelineContext(const SkShader& shader, const SkShader::ContextRec& rec,
                           SkBitmapProcInfo* info)
         : INHERITED(shader, rec, info)
     {
         // Need to ensure that our pipeline is created at a 16byte aligned address
         fPipeline = (SkLinearBitmapPipeline*)SkAlign16((intptr_t)fStorage);
-        new (fPipeline) SkLinearBitmapPipeline(info->fInvMatrix, info->fFilterQuality,
+        float alpha = SkColorGetA(info->fPaintColor) / 255.0f;
+        new (fPipeline) SkLinearBitmapPipeline(info->fRealInvMatrix, info->fFilterQuality,
                                                info->fTileModeX, info->fTileModeY,
+                                               alpha,
                                                info->fPixmap);
 
         // To implement the old shadeSpan entry-point, we need to efficiently convert our native
         // floats into SkPMColor. The SkXfermode::D32Procs do exactly that.
         //
         sk_sp<SkXfermode> xfer(SkXfermode::Create(SkXfermode::kSrc_Mode));
         fXferProc = SkXfermode::GetD32Proc(xfer.get(), 0);
     }
 
     ~LinearPipelineContext() override {
@@ skipping 30 matching lines @@
 
     typedef BitmapProcInfoContext INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 static bool choose_linear_pipeline(const SkShader::ContextRec& rec, const SkImageInfo& srcInfo) {
     // These src attributes are not supported in the new 4f context (yet)
     //
     if (srcInfo.bytesPerPixel() < 4 ||
-        kRGBA_F16_SkColorType == srcInfo.colorType()) {
+        kRGBA_F16_SkColorType == srcInfo.colorType() ||
+        kIndex_8_SkColorType == srcInfo.colorType()) {
         return false;
     }
 
 #if 0   // later we may opt-in to the new code even if the client hasn't requested it...
     // These src attributes are only supported in the new 4f context
     //
     if (srcInfo.isSRGB() ||
         kUnpremul_SkAlphaType == srcInfo.alphaType() ||
         (4 == srcInfo.bytesPerPixel() && kN32_SkColorType != srcInfo.colorType()))
     {
@@ skipping 15 matching lines @@
 SkShader::Context* SkBitmapProcShader::MakeContext(const SkShader& shader,
                                                    TileMode tmx, TileMode tmy,
                                                    const SkBitmapProvider& provider,
                                                    const ContextRec& rec, void* storage) {
     SkMatrix totalInverse;
     // Do this first, so we know the matrix can be inverted.
     if (!shader.computeTotalInverse(rec, &totalInverse)) {
         return nullptr;
     }
 
-    // Decide if we can/want to use the new linear pipeine
+    // Decide if we can/want to use the new linear pipeline
     bool useLinearPipeline = choose_linear_pipeline(rec, provider.info());
 
-    // New code doesn't support Mirror (YET), so we detect that here.
-    //
-    if (SkShader::kMirror_TileMode == tmx || SkShader::kMirror_TileMode == tmy) {
-        useLinearPipeline = false;
-    }
-
-    // New code doesn't support Mirror (YET), so we detect that here.
-    //
-    if (totalInverse.hasPerspective()) {
-        useLinearPipeline = false;
-    }
-
     //
     // For now, only enable locally since we are hitting some crashers on the test bots
     //
-    useLinearPipeline = false;
+    //useLinearPipeline = false;
 
     if (useLinearPipeline) {
         void* infoStorage = (char*)storage + sizeof(LinearPipelineContext);
         SkBitmapProcInfo* info = new (infoStorage) SkBitmapProcInfo(provider, tmx, tmy);
         if (!info->init(totalInverse, *rec.fPaint)) {
             info->~SkBitmapProcInfo();
             return nullptr;
         }
+        if (info->fPixmap.colorType() != kRGBA_8888_SkColorType
+            && info->fPixmap.colorType() != kBGRA_8888_SkColorType) {
+            return nullptr;
+        }
         return new (storage) LinearPipelineContext(shader, rec, info);
     } else {
         void* stateStorage = (char*)storage + sizeof(BitmapProcShaderContext);
         SkBitmapProcState* state = new (stateStorage) SkBitmapProcState(provider, tmx, tmy);
         if (!state->setup(totalInverse, *rec.fPaint)) {
             state->~SkBitmapProcState();
             return nullptr;
         }
         return new (storage) BitmapProcShaderContext(shader, rec, state);
     }
@@ skipping 207 matching lines @@
         inner.reset(GrSimpleTextureEffect::Create(texture, matrix, params));
     }
 
     if (kAlpha_8_SkColorType == fRawBitmap.colorType()) {
         return GrFragmentProcessor::MulOutputByInputUnpremulColor(inner);
     }
     return GrFragmentProcessor::MulOutputByInputAlpha(inner);
 }
 
 #endif