allow more options for shader blitprocs

src/core/SkBlitter_PM4f.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 "SkCoreBlitters.h"
 #include "SkColorPriv.h"
 #include "SkShader.h"
@@ skipping 116 matching lines @@
         for (int i = 0; i < height; ++i) {
             fState.fProc1(fState.fXfer, device, &fState.fPM4f, width, maskRow);
             device = (typename State::DstType*)((char*)device + dstRB);
             maskRow += maskRB;
         }
     }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-template <typename State, bool UseBProc> class SkState_Shader_Blitter : public SkShaderBlitter {
+template <typename State> class SkState_Shader_Blitter : public SkShaderBlitter {
 public:
     SkState_Shader_Blitter(const SkPixmap& device, const SkPaint& paint,
-                           const SkShader::Context::BlitState& bstate,
-                           SkShader::Context::BlitProc bproc)
+                           const SkShader::Context::BlitState& bstate)
         : INHERITED(device, paint, bstate.fCtx)
         , fState(device.info(), paint, bstate.fCtx)
         , fBState(bstate)
-        , fBProc(bproc)
+        , fBlitBW(bstate.fBlitBW)
+        , fBlitAA(bstate.fBlitAA)
     {}
     
     void blitH(int x, int y, int width) override {
         SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width());
         
-        if (UseBProc) {
-            fBProc(&fBState, x, y, fDevice, width, nullptr);
+        if (fBlitBW) {
+            fBlitBW(&fBState, x, y, fDevice, width);
             return;
         }
 
         typename State::DstType* device = State::WritableAddr(fDevice, x, y);
         fShaderContext->shadeSpan4f(x, y, fState.fBuffer, width);
         fState.fProcN(fState.fXfer, device, fState.fBuffer, width, nullptr);
     }
 
     void blitV(int x, int y, int height, SkAlpha alpha) override {
         SkASSERT(x >= 0 && y >= 0 && y + height <= fDevice.height());
 
-        if (UseBProc) {
+        if (fBlitAA) {
             for (const int bottom = y + height; y < bottom; ++y) {
-                fBProc(&fBState, x, y, fDevice, 1, &alpha);
+                fBlitAA(&fBState, x, y, fDevice, 1, &alpha);
             }
             return;
         }
 
         typename State::DstType* device = State::WritableAddr(fDevice, x, y);
         size_t                   deviceRB = fDevice.rowBytes();
         
         if (fConstInY) {
             fShaderContext->shadeSpan4f(x, y, fState.fBuffer, 1);
         }
         for (const int bottom = y + height; y < bottom; ++y) {
             if (!fConstInY) {
                 fShaderContext->shadeSpan4f(x, y, fState.fBuffer, 1);
             }
             fState.fProcN(fState.fXfer, device, fState.fBuffer, 1, &alpha);
             device = (typename State::DstType*)((char*)device + deviceRB);
         }
     }
 
     void blitRect(int x, int y, int width, int height) override {
         SkASSERT(x >= 0 && y >= 0 &&
                  x + width <= fDevice.width() && y + height <= fDevice.height());
         
-        if (UseBProc) {
+        if (fBlitBW) {
             for (const int bottom = y + height; y < bottom; ++y) {
-                fBProc(&fBState, x, y, fDevice, width, nullptr);
+                fBlitBW(&fBState, x, y, fDevice, width);
             }
             return;
         }
         
         typename State::DstType* device = State::WritableAddr(fDevice, x, y);
         size_t                   deviceRB = fDevice.rowBytes();
         
         if (fConstInY) {
             fShaderContext->shadeSpan4f(x, y, fState.fBuffer, width);
         }
         for (const int bottom = y + height; y < bottom; ++y) {
             if (!fConstInY) {
                 fShaderContext->shadeSpan4f(x, y, fState.fBuffer, width);
             }
             fState.fProcN(fState.fXfer, device, fState.fBuffer, width, nullptr);
             device = (typename State::DstType*)((char*)device + deviceRB);
         }
     }
 
     void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]) override {
         typename State::DstType* device = State::WritableAddr(fDevice, x, y);
         
         for (;;) {
             int count = *runs;
             if (count <= 0) {
                 break;
             }
             int aa = *antialias;
             if (aa) {
-                if (UseBProc && (aa == 255)) {
-                    fBProc(&fBState, x, y, fDevice, count, nullptr);
+                if (fBlitBW && (aa == 255)) {
+                    fBlitBW(&fBState, x, y, fDevice, count);
                 } else {
                     fShaderContext->shadeSpan4f(x, y, fState.fBuffer, count);
                     if (aa == 255) {
                         fState.fProcN(fState.fXfer, device, fState.fBuffer, count, nullptr);
                     } else {
                         for (int i = 0; i < count; ++i) {
                             fState.fProcN(fState.fXfer, &device[i], &fState.fBuffer[i], 1, antialias);
                         }
                     }
                 }
@@ skipping 41 matching lines @@
         }
 
         SkASSERT(mask.fBounds.contains(clip));
 
         const int x = clip.fLeft;
         const int width = clip.width();
         int y = clip.fTop;
         const uint8_t* maskRow = (const uint8_t*)mask.getAddr(x, y);
         const size_t maskRB = mask.fRowBytes;
 
-        if (UseBProc) {
+        if (fBlitAA) {
             for (; y < clip.fBottom; ++y) {
-                fBProc(&fBState, x, y, fDevice, width, maskRow);
+                fBlitAA(&fBState, x, y, fDevice, width, maskRow);
                 maskRow += maskRB;
             }
             return;
         }
 
         typename State::DstType* device = State::WritableAddr(fDevice, x, y);
         const size_t deviceRB = fDevice.rowBytes();
         
         if (fConstInY) {
             fShaderContext->shadeSpan4f(x, y, fState.fBuffer, width);
         }
         for (; y < clip.fBottom; ++y) {
             if (!fConstInY) {
                 fShaderContext->shadeSpan4f(x, y, fState.fBuffer, width);
             }
             fState.fProcN(fState.fXfer, device, fState.fBuffer, width, maskRow);
             device = (typename State::DstType*)((char*)device + deviceRB);
             maskRow += maskRB;
         }
     }
     
 protected:
     State                        fState;
     SkShader::Context::BlitState fBState;
-    SkShader::Context::BlitProc  fBProc;
+    SkShader::Context::BlitBW    fBlitBW;
+    SkShader::Context::BlitAA    fBlitAA;
 
     typedef SkShaderBlitter INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 static bool is_opaque(const SkPaint& paint, const SkShader::Context* shaderContext) {
     return shaderContext ? SkToBool(shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag)
     : 0xFF == paint.getAlpha();
 }
 
 struct State4f {
     State4f(const SkImageInfo& info, const SkPaint& paint, const SkShader::Context* shaderContext) {
         fXfer = paint.getXfermode();
         if (shaderContext) {
             fBuffer.reset(info.width());
         } else {
             fPM4f = SkColor4f::FromColor(paint.getColor()).premul();
         }
         fFlags = 0;
     }
 
     SkXfermode*             fXfer;
     SkPM4f                  fPM4f;
     SkAutoTMalloc<SkPM4f>   fBuffer;
     uint32_t                fFlags;
 
-    SkShader::Context::BlitState    fBState;
-    SkShader::Context::BlitProc     fBProc;
+    SkShader::Context::BlitState fBState;
 };
 
 struct State32 : State4f {
     typedef uint32_t    DstType;
     
     SkXfermode::D32Proc fProc1;
     SkXfermode::D32Proc fProcN;
     
     State32(const SkImageInfo& info, const SkPaint& paint, const SkShader::Context* shaderContext)
         : State4f(info, paint, shaderContext)
@@ skipping 53 matching lines @@
     }
 };
 
 template <typename State> SkBlitter* create(const SkPixmap& device, const SkPaint& paint,
                                             SkShader::Context* shaderContext,
                                             SkTBlitterAllocator* allocator) {
     SkASSERT(allocator != nullptr);
 
     if (shaderContext) {
         SkShader::Context::BlitState bstate;
+        sk_bzero(&bstate, sizeof(bstate));
         bstate.fCtx = shaderContext;
         bstate.fXfer = paint.getXfermode();
 
-        auto bproc = shaderContext->chooseBlitProc(device.info(), &bstate);
-        if (bproc) {
-            return allocator->createT<SkState_Shader_Blitter<State, true>>(device, paint, bstate,
-                                                                           bproc);
-        } else {
-            return allocator->createT<SkState_Shader_Blitter<State, false>>(device, paint, bstate,
-                                                                            bproc);
-        }
+        (void)shaderContext->chooseBlitProcs(device.info(), &bstate);
+        return allocator->createT<SkState_Shader_Blitter<State>>(device, paint, bstate);
     } else {
         SkColor color = paint.getColor();
         if (0 == SkColorGetA(color)) {
             return nullptr;
         }
         return allocator->createT<SkState_Blitter<State>>(device, paint);
     }
 }
 
 SkBlitter* SkBlitter_ARGB32_Create(const SkPixmap& device, const SkPaint& paint,
                                    SkShader::Context* shaderContext,
                                    SkTBlitterAllocator* allocator) {
     return create<State32>(device, paint, shaderContext, allocator);
 }
 
 SkBlitter* SkBlitter_ARGB64_Create(const SkPixmap& device, const SkPaint& paint,
                                    SkShader::Context* shaderContext,
                                    SkTBlitterAllocator* allocator) {
     return create<State64>(device, paint, shaderContext, allocator);
 }