add blitprocs to shaders

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> class SkState_Shader_Blitter : public SkShaderBlitter {
+template <typename State, bool UseBProc> class SkState_Shader_Blitter : public SkShaderBlitter {
 public:
     SkState_Shader_Blitter(const SkPixmap& device, const SkPaint& paint,
-                           SkShader::Context* shaderContext)
-        : INHERITED(device, paint, shaderContext)
-        , fState(device.info(), paint, shaderContext)
+                           const SkShader::Context::BlitState& bstate,
+                           SkShader::Context::BlitProc bproc)
+        : INHERITED(device, paint, bstate.fCtx)
+        , fState(device.info(), paint, bstate.fCtx)
+        , fBState(bstate)
+        , fBProc(bproc)
     {}
     
     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);
+            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) {
+            for (const int bottom = y + height; y < bottom; ++y) {
+                fBProc(&fBState, x, y, fDevice, 1, &alpha);
+            }
+            return;
+        }
+
         typename State::DstType* device = State::WritableAddr(fDevice, x, y);
-        size_t      deviceRB = fDevice.rowBytes();
-        const int   bottom = y + height;
+        size_t                   deviceRB = fDevice.rowBytes();
         
         if (fConstInY) {
             fShaderContext->shadeSpan4f(x, y, fState.fBuffer, 1);
         }
-        for (; y < bottom; ++y) {
+        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) {
+            for (const int bottom = y + height; y < bottom; ++y) {
+                fBProc(&fBState, x, y, fDevice, width, nullptr);
+            }
+            return;
+        }
+        
         typename State::DstType* device = State::WritableAddr(fDevice, x, y);
-        size_t        deviceRB = fDevice.rowBytes();
-        const int       bottom = y + height;
+        size_t                   deviceRB = fDevice.rowBytes();
         
         if (fConstInY) {
             fShaderContext->shadeSpan4f(x, y, fState.fBuffer, width);
         }
-        for (; y < bottom; ++y) {
+        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) {
-                fShaderContext->shadeSpan4f(x, y, fState.fBuffer, count);
-                if (aa == 255) {
-                    fState.fProcN(fState.fXfer, device, fState.fBuffer, count, nullptr);
+                if (UseBProc && (aa == 255)) {
+                    fBProc(&fBState, x, y, fDevice, count, nullptr);
                 } else {
-                    for (int i = 0; i < count; ++i) {
-                        fState.fProcN(fState.fXfer, &device[i], &fState.fBuffer[i], 1, antialias);
+                    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);
+                        }
                     }
                 }
             }
             device += count;
             runs += count;
             antialias += count;
             x += count;
         }
     }
 
@@ skipping 24 matching lines @@
 
     void blitMask(const SkMask& mask, const SkIRect& clip) override {
         if (SkMask::kLCD16_Format == mask.fFormat) {
             this->blitLCDMask(mask, clip);
             return;
         }
         if (SkMask::kA8_Format != mask.fFormat) {
             this->INHERITED::blitMask(mask, clip);
             return;
         }
-        
+
         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) {
+            for (; y < clip.fBottom; ++y) {
+                fBProc(&fBState, x, y, fDevice, width, maskRow);
+                maskRow += maskRB;
+            }
+            return;
+        }
+
         typename State::DstType* device = State::WritableAddr(fDevice, x, y);
         const size_t deviceRB = fDevice.rowBytes();
-        const uint8_t* maskRow = (const uint8_t*)mask.getAddr(x, y);
-        const size_t maskRB = mask.fRowBytes;
         
         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;
         }
     }
     
-private:
-    State   fState;
+protected:
+    State                        fState;
+    SkShader::Context::BlitState fBState;
+    SkShader::Context::BlitProc  fBProc;
 
     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;
 };
 
 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 50 matching lines @@
     
     static DstType* WritableAddr(const SkPixmap& device, int x, int y) {
         return device.writable_addr64(x, y);
     }
 };
 
 template <typename State> SkBlitter* create(const SkPixmap& device, const SkPaint& paint,
                                             SkShader::Context* shaderContext,
                                             SkTBlitterAllocator* allocator) {
     SkASSERT(allocator != nullptr);
-    
+
     if (shaderContext) {
-        return allocator->createT<SkState_Shader_Blitter<State>>(device, paint, shaderContext);
+        SkShader::Context::BlitState 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);
+        }
     } 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);
 }