remove shadeSpan16 from shader

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 50 matching lines @@
     return SkShader::CreateBitmapShader(bm, mx, my, &lm);
 }
 
 void SkBitmapProcShader::flatten(SkWriteBuffer& buffer) const {
     buffer.writeMatrix(this->getLocalMatrix());
     buffer.writeBitmap(fRawBitmap);
     buffer.writeUInt(fTileModeX);
     buffer.writeUInt(fTileModeY);
 }
 
-static bool only_scale_and_translate(const SkMatrix& matrix) {
-    unsigned mask = SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask;
-    return (matrix.getType() & ~mask) == 0;
-}
-
 bool SkBitmapProcShader::isOpaque() const {
     return fRawBitmap.isOpaque();
 }
 
 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.
@@ skipping 17 matching lines @@
     return MakeContext(*this, (TileMode)fTileModeX, (TileMode)fTileModeY,
                        SkBitmapProvider(fRawBitmap), rec, storage);
 }
 
 SkBitmapProcShader::BitmapProcShaderContext::BitmapProcShaderContext(const SkShader& shader,
                                                                      const ContextRec& rec,
                                                                      SkBitmapProcState* state)
     : INHERITED(shader, rec)
     , fState(state)
 {
-    const SkPixmap& pixmap = fState->fPixmap;
-    bool isOpaque = pixmap.isOpaque();
-
-    // update fFlags
-    uint32_t flags = 0;
-    if (isOpaque && (255 == this->getPaintAlpha())) {
-        flags |= kOpaqueAlpha_Flag;
+    fFlags = 0;
+    if (fState->fPixmap.isOpaque() && (255 == this->getPaintAlpha())) {
+        fFlags |= kOpaqueAlpha_Flag;
     }
-
-    switch (pixmap.colorType()) {
-        case kRGB_565_SkColorType:
-            flags |= (kHasSpan16_Flag | kIntrinsicly16_Flag);
-            break;
-        case kIndex_8_SkColorType:
-        case kN32_SkColorType:
-            if (isOpaque) {
-                flags |= kHasSpan16_Flag;
-            }
-            break;
-        case kAlpha_8_SkColorType:
-            break;  // never set kHasSpan16_Flag
-        default:
-            break;
-    }
-
-    if (rec.fPaint->isDither() && pixmap.colorType() != kRGB_565_SkColorType) {
-        // gradients can auto-dither in their 16bit sampler, but we don't so
-        // we clear the flag here.
-        flags &= ~kHasSpan16_Flag;
-    }
-
-    // if we're only 1-pixel high, and we don't rotate, then we can claim this
-    if (1 == pixmap.height() &&
-            only_scale_and_translate(this->getTotalInverse())) {
-        flags |= kConstInY32_Flag;
-        if (flags & kHasSpan16_Flag) {
-            flags |= kConstInY16_Flag;
-        }
-    }
-
-    fFlags = flags;
 }
 
 SkBitmapProcShader::BitmapProcShaderContext::~BitmapProcShaderContext() {
     // The bitmap proc state has been created outside of the context on memory that will be freed
     // elsewhere. Only call the destructor but leave the freeing of the memory to the caller.
     fState->~SkBitmapProcState();
 }
 
 #define BUF_MAX     128
 
@@ skipping 50 matching lines @@
 }
 
 SkShader::Context::ShadeProc SkBitmapProcShader::BitmapProcShaderContext::asAShadeProc(void** ctx) {
     if (fState->getShaderProc32()) {
         *ctx = fState;
         return (ShadeProc)fState->getShaderProc32();
     }
     return nullptr;
 }
 
-void SkBitmapProcShader::BitmapProcShaderContext::shadeSpan16(int x, int y, uint16_t dstC[],
-                                                              int count) {
-    const SkBitmapProcState& state = *fState;
-    if (state.getShaderProc16()) {
-        state.getShaderProc16()(&state, x, y, dstC, count);
-        return;
-    }
-
-    uint32_t buffer[BUF_MAX];
-    SkBitmapProcState::MatrixProc   mproc = state.getMatrixProc();
-    SkBitmapProcState::SampleProc16 sproc = state.getSampleProc16();
-    int max = state.maxCountForBufferSize(sizeof(buffer));
-
-    SkASSERT(state.fPixmap.addr());
-
-    for (;;) {
-        int n = count;
-        if (n > max) {
-            n = max;
-        }
-        mproc(state, buffer, n, x, y);
-        sproc(state, buffer, n, dstC);
-
-        if ((count -= n) == 0) {
-            break;
-        }
-        x += n;
-        dstC += n;
-    }
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkUnPreMultiply.h"
 #include "SkColorShader.h"
 #include "SkEmptyShader.h"
 
 // returns true and set color if the bitmap can be drawn as a single color
 // (for efficiency)
 static bool can_use_color_shader(const SkBitmap& bm, SkColor* color) {
 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
@@ skipping 142 matching lines @@
         inner.reset(GrSimpleTextureEffect::Create(texture, matrix, params));
     }
 
     if (kAlpha_8_SkColorType == fRawBitmap.colorType()) {
         return GrFragmentProcessor::MulOutputByInputUnpremulColor(inner);
     }
     return GrFragmentProcessor::MulOutputByInputAlpha(inner);
 }
 
 #endif