remove shadeSpan16 from shader

src/core/SkBlitter_RGB16.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBlitRow.h"
 #include "SkCoreBlitters.h"
 #include "SkColorPriv.h"
@@ skipping 116 matching lines @@
     SkBlitRow::Proc16   fOpaqueProc;
     SkBlitRow::Proc16   fAlphaProc;
 
 private:
     // illegal
     SkRGB16_Shader_Blitter& operator=(const SkRGB16_Shader_Blitter&);
 
     typedef SkShaderBlitter INHERITED;
 };
 
-// used only if the shader can perform shadSpan16
-class SkRGB16_Shader16_Blitter : public SkRGB16_Shader_Blitter {
-public:
-    SkRGB16_Shader16_Blitter(const SkPixmap& device, const SkPaint& paint,
-                             SkShader::Context* shaderContext);
-    void blitH(int x, int y, int width) override;
-    virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
-                           const int16_t* runs) override;
-    void blitRect(int x, int y, int width, int height) override;
-
-private:
-    typedef SkRGB16_Shader_Blitter INHERITED;
-};
-
 class SkRGB16_Shader_Xfermode_Blitter : public SkShaderBlitter {
 public:
     SkRGB16_Shader_Xfermode_Blitter(const SkPixmap& device, const SkPaint& paint,
                                     SkShader::Context* shaderContext);
     virtual ~SkRGB16_Shader_Xfermode_Blitter();
     void blitH(int x, int y, int width) override;
     virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
                            const int16_t* runs) override;
 
 private:
@@ skipping 524 matching lines @@
     size_t    deviceRB = fDevice.rowBytes();
 
     while (--height >= 0) {
         fColorProc16(device, fSrcColor32, width, x, y);
         device = (uint16_t*)((char*)device + deviceRB);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkRGB16_Shader16_Blitter::SkRGB16_Shader16_Blitter(const SkPixmap& device,
-                                                   const SkPaint& paint,
-                                                   SkShader::Context* shaderContext)
-    : SkRGB16_Shader_Blitter(device, paint, shaderContext)
-{
-    SkASSERT(SkShader::CanCallShadeSpan16(fShaderFlags));
-}
-
-void SkRGB16_Shader16_Blitter::blitH(int x, int y, int width) {
-    SkASSERT(x + width <= fDevice.width());
-
-    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
-    SkShader::Context*    shaderContext = fShaderContext;
-
-    int alpha = shaderContext->getSpan16Alpha();
-    if (0xFF == alpha) {
-        shaderContext->shadeSpan16(x, y, device, width);
-    } else {
-        uint16_t* span16 = (uint16_t*)fBuffer;
-        shaderContext->shadeSpan16(x, y, span16, width);
-        SkBlendRGB16(span16, device, SkAlpha255To256(alpha), width);
-    }
-}
-
-void SkRGB16_Shader16_Blitter::blitRect(int x, int y, int width, int height) {
-    SkShader::Context* shaderContext = fShaderContext;
-    uint16_t*          dst = fDevice.writable_addr16(x, y);
-    size_t             dstRB = fDevice.rowBytes();
-    int                alpha = shaderContext->getSpan16Alpha();
-
-    if (0xFF == alpha) {
-        if (fShaderFlags & SkShader::kConstInY16_Flag) {
-            // have the shader blit directly into the device the first time
-            shaderContext->shadeSpan16(x, y, dst, width);
-            // and now just memcpy that line on the subsequent lines
-            if (--height > 0) {
-                const uint16_t* orig = dst;
-                do {
-                    dst = (uint16_t*)((char*)dst + dstRB);
-                    memcpy(dst, orig, width << 1);
-                } while (--height);
-            }
-        } else {    // need to call shadeSpan16 for every line
-            do {
-                shaderContext->shadeSpan16(x, y, dst, width);
-                y += 1;
-                dst = (uint16_t*)((char*)dst + dstRB);
-            } while (--height);
-        }
-    } else {
-        int scale = SkAlpha255To256(alpha);
-        uint16_t* span16 = (uint16_t*)fBuffer;
-        if (fShaderFlags & SkShader::kConstInY16_Flag) {
-            shaderContext->shadeSpan16(x, y, span16, width);
-            do {
-                SkBlendRGB16(span16, dst, scale, width);
-                dst = (uint16_t*)((char*)dst + dstRB);
-            } while (--height);
-        } else {
-            do {
-                shaderContext->shadeSpan16(x, y, span16, width);
-                SkBlendRGB16(span16, dst, scale, width);
-                y += 1;
-                dst = (uint16_t*)((char*)dst + dstRB);
-            } while (--height);
-        }
-    }
-}
-
-void SkRGB16_Shader16_Blitter::blitAntiH(int x, int y,
-                                         const SkAlpha* SK_RESTRICT antialias,
-                                         const int16_t* SK_RESTRICT runs) {
-    SkShader::Context*     shaderContext = fShaderContext;
-    SkPMColor* SK_RESTRICT span = fBuffer;
-    uint16_t* SK_RESTRICT  device = fDevice.writable_addr16(x, y);
-
-    int alpha = shaderContext->getSpan16Alpha();
-    uint16_t* span16 = (uint16_t*)span;
-
-    if (0xFF == alpha) {
-        for (;;) {
-            int count = *runs;
-            if (count <= 0) {
-                break;
-            }
-            SkASSERT(count <= fDevice.width()); // don't overrun fBuffer
-
-            int aa = *antialias;
-            if (aa == 255) {
-                // go direct to the device!
-                shaderContext->shadeSpan16(x, y, device, count);
-            } else if (aa) {
-                shaderContext->shadeSpan16(x, y, span16, count);
-                SkBlendRGB16(span16, device, SkAlpha255To256(aa), count);
-            }
-            device += count;
-            runs += count;
-            antialias += count;
-            x += count;
-        }
-    } else {  // span alpha is < 255
-        alpha = SkAlpha255To256(alpha);
-        for (;;) {
-            int count = *runs;
-            if (count <= 0) {
-                break;
-            }
-            SkASSERT(count <= fDevice.width()); // don't overrun fBuffer
-
-            int aa = SkAlphaMul(*antialias, alpha);
-            if (aa) {
-                shaderContext->shadeSpan16(x, y, span16, count);
-                SkBlendRGB16(span16, device, SkAlpha255To256(aa), count);
-            }
-
-            device += count;
-            runs += count;
-            antialias += count;
-            x += count;
-        }
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
 SkRGB16_Shader_Blitter::SkRGB16_Shader_Blitter(const SkPixmap& device,
                                                const SkPaint& paint,
                                                SkShader::Context* shaderContext)
     : INHERITED(device, paint, shaderContext)
 {
     SkASSERT(paint.getXfermode() == nullptr);
 
     fBuffer = (SkPMColor*)sk_malloc_throw(device.width() * sizeof(SkPMColor));
 
     // compute SkBlitRow::Procs
     unsigned flags = 0;
 
     uint32_t shaderFlags = fShaderFlags;
     // shaders take care of global alpha, so we never set it in SkBlitRow
     if (!(shaderFlags & SkShader::kOpaqueAlpha_Flag)) {
         flags |= SkBlitRow::kSrcPixelAlpha_Flag;
     }
-    // don't dither if the shader is really 16bit
-    if (paint.isDither() && !(shaderFlags & SkShader::kIntrinsicly16_Flag)) {
+    if (paint.isDither()) {
         flags |= SkBlitRow::kDither_Flag;
     }
     // used when we know our global alpha is 0xFF
     fOpaqueProc = SkBlitRow::Factory16(flags);
     // used when we know our global alpha is < 0xFF
     fAlphaProc  = SkBlitRow::Factory16(flags | SkBlitRow::kGlobalAlpha_Flag);
 }
 
 SkRGB16_Shader_Blitter::~SkRGB16_Shader_Blitter() {
     sk_free(fBuffer);
@@ skipping 191 matching lines @@
     SkXfermode* mode = paint.getXfermode();
 
     // we require a shader if there is an xfermode, handled by our caller
     SkASSERT(nullptr == mode || shader);
 
     if (shader) {
         SkASSERT(shaderContext != nullptr);
         if (mode) {
             blitter = allocator->createT<SkRGB16_Shader_Xfermode_Blitter>(device, paint,
                                                                           shaderContext);
-        } else if (shaderContext->canCallShadeSpan16()) {
-            blitter = allocator->createT<SkRGB16_Shader16_Blitter>(device, paint, shaderContext);
         } else {
             blitter = allocator->createT<SkRGB16_Shader_Blitter>(device, paint, shaderContext);
         }
     } else {
         // no shader, no xfermode, (and we always ignore colorfilter)
         SkColor color = paint.getColor();
         if (0 == SkColorGetA(color)) {
             blitter = allocator->createT<SkNullBlitter>();
 #ifdef USE_BLACK_BLITTER
         } else if (SK_ColorBLACK == color) {
             blitter = allocator->createT<SkRGB16_Black_Blitter>(device, paint);
 #endif
         } else if (0xFF == SkColorGetA(color)) {
             blitter = allocator->createT<SkRGB16_Opaque_Blitter>(device, paint);
         } else {
             blitter = allocator->createT<SkRGB16_Blitter>(device, paint);
         }
     }
 
     return blitter;
 }