switch bitmapshader internals over to pixmap

src/core/SkBitmapProcState.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 "SkBitmapCache.h"
 #include "SkBitmapController.h"
 #include "SkBitmapProcState.h"
@@ skipping 36 matching lines @@
 
 // true iff the matrix contains, at most, scale and translate elements
 static bool matrix_only_scale_translate(const SkMatrix& m) {
     return m.getType() <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask);
 }
 
 /**
  *  For the purposes of drawing bitmaps, if a matrix is "almost" translate
  *  go ahead and treat it as if it were, so that subsequent code can go fast.
  */
-static bool just_trans_clamp(const SkMatrix& matrix, const SkBitmap& bitmap) {
+static bool just_trans_clamp(const SkMatrix& matrix, const SkPixmap& pixmap) {
     SkASSERT(matrix_only_scale_translate(matrix));
 
     if (matrix.getType() & SkMatrix::kScale_Mask) {
-        SkRect src, dst;
-        bitmap.getBounds(&src);
+        SkRect dst;
+        SkRect src = SkRect::Make(pixmap.bounds());
 
         // Can't call mapRect(), since that will fix up inverted rectangles,
         // e.g. when scale is negative, and we don't want to return true for
         // those.
         matrix.mapPoints(SkTCast<SkPoint*>(&dst),
                          SkTCast<const SkPoint*>(&src),
                          2);
 
         // Now round all 4 edges to device space, and then compare the device
         // width/height to the original. Note: we must map all 4 and subtract
         // rather than map the "width" and compare, since we care about the
         // phase (in pixel space) that any translate in the matrix might impart.
         SkIRect idst;
         dst.round(&idst);
-        return idst.width() == bitmap.width() && idst.height() == bitmap.height();
+        return idst.width() == pixmap.width() && idst.height() == pixmap.height();
     }
     // if we got here, we're either kTranslate_Mask or identity
     return true;
 }
 
 static bool just_trans_general(const SkMatrix& matrix) {
     SkASSERT(matrix_only_scale_translate(matrix));
 
     if (matrix.getType() & SkMatrix::kScale_Mask) {
         const SkScalar tol = SK_Scalar1 / 32768;
@@ skipping 19 matching lines @@
  *  Analyze filter-quality and matrix, and decide how to implement that.
  *
  *  In general, we cascade down the request level [ High ... None ]
  *  - for a given level, if we can fulfill it, fine, else
  *    - else we downgrade to the next lower level and try again.
  *  We can always fulfill requests for Low and None
  *  - sometimes we will "ignore" Low and give None, but this is likely a legacy perf hack
  *    and may be removed.
  */
 bool SkBitmapProcState::chooseProcs(const SkMatrix& inv, const SkPaint& paint) {
-    fBitmap = NULL;
+    fPixmap.reset();
     fInvMatrix = inv;
     fFilterLevel = paint.getFilterQuality();
 
     SkDefaultBitmapController controller;
     fBMState = controller.requestBitmap(fOrigBitmap, inv, paint.getFilterQuality(),
                                         fBMStateStorage.get(), fBMStateStorage.size());
-    if (NULL == fBMState) {
+    // Note : we allow the controller to return an empty (zero-dimension) result. Should we?
+    if (NULL == fBMState || fBMState->pixmap().info().isEmpty()) {
         return false;
     }
-    fBitmap = &fBMState->lockedBitmap();
+    fPixmap = fBMState->pixmap();
     fInvMatrix = fBMState->invMatrix();
     fFilterLevel = fBMState->quality();
-    SkASSERT(fBitmap->getPixels());
+    SkASSERT(fPixmap.addr());
     
     bool trivialMatrix = (fInvMatrix.getType() & ~SkMatrix::kTranslate_Mask) == 0;
     bool clampClamp = SkShader::kClamp_TileMode == fTileModeX &&
                       SkShader::kClamp_TileMode == fTileModeY;
 
     // Most of the scanline procs deal with "unit" texture coordinates, as this
     // makes it easy to perform tiling modes (repeat = (x & 0xFFFF)). To generate
     // those, we divide the matrix by its dimensions here.
     //
     // We don't do this if we're either trivial (can ignore the matrix) or clamping
     // in both X and Y since clamping to width,height is just as easy as to 0xFFFF.
 
     if (!(clampClamp || trivialMatrix)) {
-        fInvMatrix.postIDiv(fBitmap->width(), fBitmap->height());
+        fInvMatrix.postIDiv(fPixmap.width(), fPixmap.height());
     }
 
     // Now that all possible changes to the matrix have taken place, check
     // to see if we're really close to a no-scale matrix.  If so, explicitly
     // set it to be so.  Subsequent code may inspect this matrix to choose
     // a faster path in this case.
 
     // This code will only execute if the matrix has some scale component;
     // if it's already pure translate then we won't do this inversion.
 
     if (matrix_only_scale_translate(fInvMatrix)) {
         SkMatrix forward;
         if (fInvMatrix.invert(&forward)) {
-            if (clampClamp ? just_trans_clamp(forward, *fBitmap)
+            if (clampClamp ? just_trans_clamp(forward, fPixmap)
                            : just_trans_general(forward)) {
                 SkScalar tx = -SkScalarRoundToScalar(forward.getTranslateX());
                 SkScalar ty = -SkScalarRoundToScalar(forward.getTranslateY());
                 fInvMatrix.setTranslate(tx, ty);
             }
         }
     }
 
     fInvProc        = fInvMatrix.getMapXYProc();
     fInvType        = fInvMatrix.getType();
@@ skipping 12 matching lines @@
     // recompute the triviality of the matrix here because we may have
     // changed it!
 
     trivialMatrix = (fInvMatrix.getType() & ~SkMatrix::kTranslate_Mask) == 0;
 
     if (kLow_SkFilterQuality == fFilterLevel) {
         // Only try bilerp if the matrix is "interesting" and
         // the image has a suitable size.
 
         if (fInvType <= SkMatrix::kTranslate_Mask ||
-            !valid_for_filtering(fBitmap->width() | fBitmap->height()))
+            !valid_for_filtering(fPixmap.width() | fPixmap.height()))
         {
             fFilterLevel = kNone_SkFilterQuality;
         }
     }
 
     return this->chooseScanlineProcs(trivialMatrix, clampClamp, paint);
 }
 
 bool SkBitmapProcState::chooseScanlineProcs(bool trivialMatrix, bool clampClamp,
                                             const SkPaint& paint) {
     fMatrixProc = this->chooseMatrixProc(trivialMatrix);
     // TODO(dominikg): SkASSERT(fMatrixProc) instead? chooseMatrixProc never returns NULL.
     if (NULL == fMatrixProc) {
         return false;
     }
 
     ///////////////////////////////////////////////////////////////////////
 
-    const SkAlphaType at = fBitmap->alphaType();
+    const SkAlphaType at = fPixmap.alphaType();
 
     // No need to do this if we're doing HQ sampling; if filter quality is
     // still set to HQ by the time we get here, then we must have installed
     // the shader procs above and can skip all this.
 
     if (fFilterLevel < kHigh_SkFilterQuality) {
 
         int index = 0;
         if (fAlphaScale < 256) {  // note: this distinction is not used for D16
             index |= 1;
         }
         if (fInvType <= (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)) {
             index |= 2;
         }
         if (fFilterLevel > kNone_SkFilterQuality) {
             index |= 4;
         }
         // bits 3,4,5 encoding the source bitmap format
-        switch (fBitmap->colorType()) {
+        switch (fPixmap.colorType()) {
             case kN32_SkColorType:
                 if (kPremul_SkAlphaType != at && kOpaque_SkAlphaType != at) {
                     return false;
                 }
                 index |= 0;
                 break;
             case kRGB_565_SkColorType:
                 index |= 8;
                 break;
             case kIndex_8_SkColorType:
@@ skipping 136 matching lines @@
 
 static void Clamp_S32_D32_nofilter_trans_shaderproc(const SkBitmapProcState& s,
                                                     int x, int y,
                                                     SkPMColor* SK_RESTRICT colors,
                                                     int count) {
     SkASSERT(((s.fInvType & ~SkMatrix::kTranslate_Mask)) == 0);
     SkASSERT(s.fInvKy == 0);
     SkASSERT(count > 0 && colors != NULL);
     SkASSERT(kNone_SkFilterQuality == s.fFilterLevel);
 
-    const int maxX = s.fBitmap->width() - 1;
-    const int maxY = s.fBitmap->height() - 1;
+    const int maxX = s.fPixmap.width() - 1;
+    const int maxY = s.fPixmap.height() - 1;
     int ix = s.fFilterOneX + x;
     int iy = SkClampMax(s.fFilterOneY + y, maxY);
 #ifdef SK_DEBUG
     {
         SkPoint pt;
         s.fInvProc(s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf,
                    SkIntToScalar(y) + SK_ScalarHalf, &pt);
         int iy2 = SkClampMax(SkScalarFloorToInt(pt.fY), maxY);
         int ix2 = SkScalarFloorToInt(pt.fX);
 
         SkASSERT(iy == iy2);
         SkASSERT(ix == ix2);
     }
 #endif
-    const SkPMColor* row = s.fBitmap->getAddr32(0, iy);
+    const SkPMColor* row = s.fPixmap.addr32(0, iy);
 
     // clamp to the left
     if (ix < 0) {
         int n = SkMin32(-ix, count);
         sk_memset32(colors, row[0], n);
         count -= n;
         if (0 == count) {
             return;
         }
         colors += n;
@@ skipping 37 matching lines @@
 
 static void Repeat_S32_D32_nofilter_trans_shaderproc(const SkBitmapProcState& s,
                                                      int x, int y,
                                                      SkPMColor* SK_RESTRICT colors,
                                                      int count) {
     SkASSERT(((s.fInvType & ~SkMatrix::kTranslate_Mask)) == 0);
     SkASSERT(s.fInvKy == 0);
     SkASSERT(count > 0 && colors != NULL);
     SkASSERT(kNone_SkFilterQuality == s.fFilterLevel);
 
-    const int stopX = s.fBitmap->width();
-    const int stopY = s.fBitmap->height();
+    const int stopX = s.fPixmap.width();
+    const int stopY = s.fPixmap.height();
     int ix = s.fFilterOneX + x;
     int iy = sk_int_mod(s.fFilterOneY + y, stopY);
 #ifdef SK_DEBUG
     {
         SkPoint pt;
         s.fInvProc(s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf,
                    SkIntToScalar(y) + SK_ScalarHalf, &pt);
         int iy2 = sk_int_mod(SkScalarFloorToInt(pt.fY), stopY);
         int ix2 = SkScalarFloorToInt(pt.fX);
 
         SkASSERT(iy == iy2);
         SkASSERT(ix == ix2);
     }
 #endif
-    const SkPMColor* row = s.fBitmap->getAddr32(0, iy);
+    const SkPMColor* row = s.fPixmap.addr32(0, iy);
 
     ix = sk_int_mod(ix, stopX);
     for (;;) {
         int n = SkMin32(stopX - ix, count);
         memcpy(colors, row + ix, n * sizeof(SkPMColor));
         count -= n;
         if (0 == count) {
             return;
         }
         colors += n;
         ix = 0;
     }
 }
 
 static void S32_D32_constX_shaderproc(const SkBitmapProcState& s,
                                       int x, int y,
                                       SkPMColor* SK_RESTRICT colors,
                                       int count) {
     SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)) == 0);
     SkASSERT(s.fInvKy == 0);
     SkASSERT(count > 0 && colors != NULL);
-    SkASSERT(1 == s.fBitmap->width());
+    SkASSERT(1 == s.fPixmap.width());
 
     int iY0;
     int iY1   SK_INIT_TO_AVOID_WARNING;
     int iSubY SK_INIT_TO_AVOID_WARNING;
 
     if (kNone_SkFilterQuality != s.fFilterLevel) {
         SkBitmapProcState::MatrixProc mproc = s.getMatrixProc();
         uint32_t xy[2];
 
         mproc(s, xy, 1, x, y);
 
         iY0 = xy[0] >> 18;
         iY1 = xy[0] & 0x3FFF;
         iSubY = (xy[0] >> 14) & 0xF;
     } else {
         int yTemp;
 
         if (s.fInvType > SkMatrix::kTranslate_Mask) {
             SkPoint pt;
             s.fInvProc(s.fInvMatrix,
                        SkIntToScalar(x) + SK_ScalarHalf,
                        SkIntToScalar(y) + SK_ScalarHalf,
                        &pt);
             // When the matrix has a scale component the setup code in
             // chooseProcs multiples the inverse matrix by the inverse of the
             // bitmap's width and height. Since this method is going to do
             // its own tiling and sampling we need to undo that here.
             if (SkShader::kClamp_TileMode != s.fTileModeX ||
                 SkShader::kClamp_TileMode != s.fTileModeY) {
-                yTemp = SkScalarFloorToInt(pt.fY * s.fBitmap->height());
+                yTemp = SkScalarFloorToInt(pt.fY * s.fPixmap.height());
             } else {
                 yTemp = SkScalarFloorToInt(pt.fY);
             }
         } else {
             yTemp = s.fFilterOneY + y;
         }
 
-        const int stopY = s.fBitmap->height();
+        const int stopY = s.fPixmap.height();
         switch (s.fTileModeY) {
             case SkShader::kClamp_TileMode:
                 iY0 = SkClampMax(yTemp, stopY-1);
                 break;
             case SkShader::kRepeat_TileMode:
                 iY0 = sk_int_mod(yTemp, stopY);
                 break;
             case SkShader::kMirror_TileMode:
             default:
                 iY0 = sk_int_mirror(yTemp, stopY);
                 break;
         }
 
 #ifdef SK_DEBUG
         {
             SkPoint pt;
             s.fInvProc(s.fInvMatrix,
                        SkIntToScalar(x) + SK_ScalarHalf,
                        SkIntToScalar(y) + SK_ScalarHalf,
                        &pt);
             if (s.fInvType > SkMatrix::kTranslate_Mask &&
                 (SkShader::kClamp_TileMode != s.fTileModeX ||
                  SkShader::kClamp_TileMode != s.fTileModeY)) {
-                pt.fY *= s.fBitmap->height();
+                pt.fY *= s.fPixmap.height();
             }
             int iY2;
 
             switch (s.fTileModeY) {
             case SkShader::kClamp_TileMode:
                 iY2 = SkClampMax(SkScalarFloorToInt(pt.fY), stopY-1);
                 break;
             case SkShader::kRepeat_TileMode:
                 iY2 = sk_int_mod(SkScalarFloorToInt(pt.fY), stopY);
                 break;
             case SkShader::kMirror_TileMode:
             default:
                 iY2 = sk_int_mirror(SkScalarFloorToInt(pt.fY), stopY);
                 break;
             }
 
             SkASSERT(iY0 == iY2);
         }
 #endif
     }
 
-    const SkPMColor* row0 = s.fBitmap->getAddr32(0, iY0);
+    const SkPMColor* row0 = s.fPixmap.addr32(0, iY0);
     SkPMColor color;
 
     if (kNone_SkFilterQuality != s.fFilterLevel) {
-        const SkPMColor* row1 = s.fBitmap->getAddr32(0, iY1);
+        const SkPMColor* row1 = s.fPixmap.addr32(0, iY1);
 
         if (s.fAlphaScale < 256) {
             Filter_32_alpha(iSubY, *row0, *row1, &color, s.fAlphaScale);
         } else {
             Filter_32_opaque(iSubY, *row0, *row1, &color);
         }
     } else {
         if (s.fAlphaScale < 256) {
             color = SkAlphaMulQ(*row0, s.fAlphaScale);
         } else {
@@ skipping 27 matching lines @@
     // Since we know we're not filtered, we re-purpose these fields allow
     // us to go from device -> src coordinates w/ just an integer add,
     // rather than running through the inverse-matrix
     fFilterOneX = SkScalarFloorToInt(pt.fX);
     fFilterOneY = SkScalarFloorToInt(pt.fY);
     return true;
 }
 
 SkBitmapProcState::ShaderProc32 SkBitmapProcState::chooseShaderProc32() {
 
-    if (kN32_SkColorType != fBitmap->colorType()) {
+    if (kN32_SkColorType != fPixmap.colorType()) {
         return NULL;
     }
 
     static const unsigned kMask = SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask;
 
-    if (1 == fBitmap->width() && 0 == (fInvType & ~kMask)) {
+    if (1 == fPixmap.width() && 0 == (fInvType & ~kMask)) {
         if (kNone_SkFilterQuality == fFilterLevel &&
             fInvType <= SkMatrix::kTranslate_Mask &&
             !this->setupForTranslate()) {
             return DoNothing_shaderproc;
         }
         return S32_D32_constX_shaderproc;
     }
 
     if (fAlphaScale < 256) {
         return NULL;
@@ skipping 94 matching lines @@
     void (*proc)(uint32_t bitmapXY[], int count, unsigned mx, unsigned my);
 
     // There are four formats possible:
     //  scale -vs- affine
     //  filter -vs- nofilter
     if (state.fInvType <= (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)) {
         proc = state.fFilterLevel != kNone_SkFilterQuality ? check_scale_filter : check_scale_nofilter;
     } else {
         proc = state.fFilterLevel != kNone_SkFilterQuality ? check_affine_filter : check_affine_nofilter;
     }
-    proc(bitmapXY, count, state.fBitmap->width(), state.fBitmap->height());
+    proc(bitmapXY, count, state.fPixmap.width(), state.fPixmap.height());
 }
 
 SkBitmapProcState::MatrixProc SkBitmapProcState::getMatrixProc() const {
     return DebugMatrixProc;
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 /*
@@ skipping 26 matching lines @@
     return size;
 }
 
 ///////////////////////
 
 void  Clamp_S32_opaque_D32_nofilter_DX_shaderproc(const SkBitmapProcState& s, int x, int y,
                                                   SkPMColor* SK_RESTRICT dst, int count) {
     SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
                              SkMatrix::kScale_Mask)) == 0);
 
-    const unsigned maxX = s.fBitmap->width() - 1;
+    const unsigned maxX = s.fPixmap.width() - 1;
     SkFractionalInt fx;
     int dstY;
     {
         SkPoint pt;
         s.fInvProc(s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf, SkIntToScalar(y) + SK_ScalarHalf,
                    &pt);
         fx = SkScalarToFractionalInt(pt.fY);
-        const unsigned maxY = s.fBitmap->height() - 1;
+        const unsigned maxY = s.fPixmap.height() - 1;
         dstY = SkClampMax(SkFractionalIntToInt(fx), maxY);
         fx = SkScalarToFractionalInt(pt.fX);
     }
 
-    const SkPMColor* SK_RESTRICT src = s.fBitmap->getAddr32(0, dstY);
+    const SkPMColor* SK_RESTRICT src = s.fPixmap.addr32(0, dstY);
     const SkFractionalInt dx = s.fInvSxFractionalInt;
 
     // Check if we're safely inside [0...maxX] so no need to clamp each computed index.
     //
     if ((uint64_t)SkFractionalIntToInt(fx) <= maxX &&
         (uint64_t)SkFractionalIntToInt(fx + dx * (count - 1)) <= maxX)
     {
         int count4 = count >> 2;
         for (int i = 0; i < count4; ++i) {
             SkPMColor src0 = src[SkFractionalIntToInt(fx)]; fx += dx;
@@ skipping 13 matching lines @@
             fx += dx;
         }
     } else {
         for (int i = 0; i < count; ++i) {
             dst[i] = src[SkClampMax(SkFractionalIntToInt(fx), maxX)];
             fx += dx;
         }
     }
 }