All source types working for linear pipeline.

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 114 matching lines @@
         fSrcPixmap = info->fPixmap;
         fAlpha = SkColorGetA(info->fPaintColor) / 255.0f;
         fXMode = info->fTileModeX;
         fYMode = info->fTileModeY;
         fFilterQuality = info->fFilterQuality;
         fMatrixTypeMask = info->fRealInvMatrix.getType();
 
         // Need to ensure that our pipeline is created at a 16byte aligned address
         fShaderPipeline = (SkLinearBitmapPipeline*)SkAlign16((intptr_t)fShaderStorage);
         new (fShaderPipeline) SkLinearBitmapPipeline(info->fRealInvMatrix, info->fFilterQuality,
-                                               info->fTileModeX, info->fTileModeY,
-                                               fAlpha,
-                                               info->fPixmap);
+                                                     info->fTileModeX, info->fTileModeY,
+                                                     info->fPaintColor,
+                                                     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::Make(SkXfermode::kSrc_Mode));
         fXferProc = SkXfermode::GetD32Proc(xfer.get(), 0);
     }
 
     ~LinearPipelineContext() override {
         // since we did a manual new, we need to manually destroy as well.
@@ skipping 68 matching lines @@
     SkShader::TileMode      fYMode;
     SkMatrix::TypeMask      fMatrixTypeMask;
     SkFilterQuality         fFilterQuality;
 
     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.profileType() != kSRGB_SkColorProfileType) { return false; }
-    if (srcInfo.colorType() != kRGBA_8888_SkColorType
-        && srcInfo.colorType() != kBGRA_8888_SkColorType
-        && srcInfo.colorType() != kIndex_8_SkColorType
-        && srcInfo.colorType() != kRGBA_F16_SkColorType) {
-        return false;
-    }
-
     // If we get here, we can reasonably use either context, respect the caller's preference
     //
     return SkShader::ContextRec::kPM4f_DstType == rec.fPreferredDstType;
 }
 
 size_t SkBitmapProcShader::ContextSize(const ContextRec& rec, const SkImageInfo& srcInfo) {
     size_t size0 = sizeof(BitmapProcShaderContext) + sizeof(SkBitmapProcState);
     size_t size1 = sizeof(LinearPipelineContext) + sizeof(SkBitmapProcInfo);
     return SkTMax(size0, size1);
 }
@@ skipping 11 matching lines @@
     // Decide if we can/want to use the new linear pipeline
     bool useLinearPipeline = choose_linear_pipeline(rec, provider.info());
 
     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
-            && info->fPixmap.colorType() != kIndex_8_SkColorType
-            && info->fPixmap.colorType() != kRGBA_F16_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