switch bitmapshader internals over to pixmap

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 "SkColorPriv.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
@@ skipping 99 matching lines @@
     // The SkBitmapProcState is stored outside of the context object, with the context holding
     // a pointer to it.
     return sizeof(BitmapProcShaderContext) + sizeof(SkBitmapProcState);
 }
 
 SkBitmapProcShader::BitmapProcShaderContext::BitmapProcShaderContext(
         const SkBitmapProcShader& shader, const ContextRec& rec, SkBitmapProcState* state)
     : INHERITED(shader, rec)
     , fState(state)
 {
-    const SkBitmap& bitmap = *fState->fBitmap;
-    bool bitmapIsOpaque = bitmap.isOpaque();
+    const SkPixmap& pixmap = fState->fPixmap;
+    bool isOpaque = pixmap.isOpaque();
 
     // update fFlags
     uint32_t flags = 0;
-    if (bitmapIsOpaque && (255 == this->getPaintAlpha())) {
+    if (isOpaque && (255 == this->getPaintAlpha())) {
         flags |= kOpaqueAlpha_Flag;
     }
 
-    switch (bitmap.colorType()) {
+    switch (pixmap.colorType()) {
         case kRGB_565_SkColorType:
             flags |= (kHasSpan16_Flag | kIntrinsicly16_Flag);
             break;
         case kIndex_8_SkColorType:
         case kN32_SkColorType:
-            if (bitmapIsOpaque) {
+            if (isOpaque) {
                 flags |= kHasSpan16_Flag;
             }
             break;
         case kAlpha_8_SkColorType:
             break;  // never set kHasSpan16_Flag
         default:
             break;
     }
 
-    if (rec.fPaint->isDither() && bitmap.colorType() != kRGB_565_SkColorType) {
+    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 == bitmap.height() &&
+    if (1 == pixmap.height() &&
             only_scale_and_translate(this->getTotalInverse())) {
         flags |= kConstInY32_Flag;
         if (flags & kHasSpan16_Flag) {
             flags |= kConstInY16_Flag;
         }
     }
 
     fFlags = flags;
 }
 
@@ skipping 20 matching lines @@
     if (state.getShaderProc32()) {
         state.getShaderProc32()(state, x, y, dstC, count);
         return;
     }
 
     uint32_t buffer[BUF_MAX + TEST_BUFFER_EXTRA];
     SkBitmapProcState::MatrixProc   mproc = state.getMatrixProc();
     SkBitmapProcState::SampleProc32 sproc = state.getSampleProc32();
     int max = state.maxCountForBufferSize(sizeof(buffer[0]) * BUF_MAX);
 
-    SkASSERT(state.fBitmap->getPixels());
-    SkASSERT(state.fBitmap->pixelRef() == NULL ||
-             state.fBitmap->pixelRef()->isLocked());
+    SkASSERT(state.fPixmap.addr());
 
     for (;;) {
         int n = count;
         if (n > max) {
             n = max;
         }
         SkASSERT(n > 0 && n < BUF_MAX*2);
 #ifdef TEST_BUFFER_OVERRITE
         for (int i = 0; i < TEST_BUFFER_EXTRA; i++) {
             buffer[BUF_MAX + i] = TEST_PATTERN;
@@ skipping 30 matching lines @@
     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.fBitmap->getPixels());
-    SkASSERT(state.fBitmap->pixelRef() == NULL ||
-             state.fBitmap->pixelRef()->isLocked());
+    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) {
@@ skipping 196 matching lines @@
 #else
 
 bool SkBitmapProcShader::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
                                              const SkMatrix*, GrColor*,
                                              GrFragmentProcessor**) const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
 
 #endif