fission bitmapprocstate

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 18 matching lines @@
 extern void  SI8_opaque_D32_filter_DX_shaderproc_neon(const void *, int, int, uint32_t*, int);
 extern void  Clamp_SI8_opaque_D32_filter_DX_shaderproc_neon(const void*, int, int, uint32_t*, int);
 #endif
 
 extern void Clamp_S32_opaque_D32_nofilter_DX_shaderproc(const void*, int, int, uint32_t*, int);
 
 #define   NAME_WRAP(x)  x
 #include "SkBitmapProcState_filter.h"
 #include "SkBitmapProcState_procs.h"
 
-SkBitmapProcState::SkBitmapProcState(const SkBitmapProvider& provider,
-                                     SkShader::TileMode tmx, SkShader::TileMode tmy)
+SkBitmapProcInfo::SkBitmapProcInfo(const SkBitmapProvider& provider,
+                                   SkShader::TileMode tmx, SkShader::TileMode tmy)
     : fProvider(provider)
+    , fTileModeX(tmx)
+    , fTileModeY(tmy)
     , fBMState(nullptr)
-{
-    fTileModeX = tmx;
-    fTileModeY = tmy;
-}
+{}
 
-SkBitmapProcState::SkBitmapProcState(const SkBitmap& bm,
-                                     SkShader::TileMode tmx, SkShader::TileMode tmy)
+SkBitmapProcInfo::SkBitmapProcInfo(const SkBitmap& bm,
+                                   SkShader::TileMode tmx, SkShader::TileMode tmy)
     : fProvider(SkBitmapProvider(bm))
+    , fTileModeX(tmx)
+    , fTileModeY(tmy)
     , fBMState(nullptr)
-{
-    fTileModeX = tmx;
-    fTileModeY = tmy;
-}
+{}
 
-SkBitmapProcState::~SkBitmapProcState() {
+SkBitmapProcInfo::~SkBitmapProcInfo() {
     SkInPlaceDeleteCheck(fBMState, fBMStateStorage.get());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // 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);
 }
 
@@ skipping 43 matching lines @@
     // if we got here, treat us as either kTranslate_Mask or identity
     return true;
 }
 
 static bool valid_for_filtering(unsigned dimension) {
     // for filtering, width and height must fit in 14bits, since we use steal
     // 2 bits from each to store our 4bit subpixel data
     return (dimension & ~0x3FFF) == 0;
 }
 
-/*
- *  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) {
+bool SkBitmapProcInfo::init(const SkMatrix& inv, const SkPaint& paint) {
+    const int origW = fProvider.info().width();
+    const int origH = fProvider.info().height();
+
     fPixmap.reset();
     fInvMatrix = inv;
-    fFilterLevel = paint.getFilterQuality();
+    fFilterQuality = paint.getFilterQuality();
 
-    const int origW = fProvider.info().width();
-    const int origH = fProvider.info().height();
     bool allow_ignore_fractional_translate = true;  // historical default
-    if (kMedium_SkFilterQuality == fFilterLevel) {
+    if (kMedium_SkFilterQuality == fFilterQuality) {
         allow_ignore_fractional_translate = false;
     }
 
     SkDefaultBitmapController controller;
     fBMState = controller.requestBitmap(fProvider, inv, paint.getFilterQuality(),
                                         fBMStateStorage.get(), fBMStateStorage.size());
     // Note : we allow the controller to return an empty (zero-dimension) result. Should we?
     if (nullptr == fBMState || fBMState->pixmap().info().isEmpty()) {
         return false;
     }
     fPixmap = fBMState->pixmap();
     fInvMatrix = fBMState->invMatrix();
-    fFilterLevel = fBMState->quality();
+    fPaintColor = paint.getColor();
+    fFilterQuality = fBMState->quality();
     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(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 && allow_ignore_fractional_translate)
-                           ? just_trans_clamp(forward, fPixmap)
-                           : just_trans_general(forward)) {
+                ? just_trans_clamp(forward, fPixmap)
+                : just_trans_general(forward)) {
                 fInvMatrix.setTranslate(-forward.getTranslateX(), -forward.getTranslateY());
             }
         }
     }
 
-    fInvProc        = fInvMatrix.getMapXYProc();
-    fInvType        = fInvMatrix.getType();
-    fInvSx          = SkScalarToFixed(fInvMatrix.getScaleX());
-    fInvSxFractionalInt = SkScalarToFractionalInt(fInvMatrix.getScaleX());
-    fInvKy          = SkScalarToFixed(fInvMatrix.getSkewY());
-    fInvKyFractionalInt = SkScalarToFractionalInt(fInvMatrix.getSkewY());
-
-    fAlphaScale = SkAlpha255To256(paint.getAlpha());
-
-    fShaderProc32 = nullptr;
-    fShaderProc16 = nullptr;
-    fSampleProc32 = nullptr;
-
-    // recompute the triviality of the matrix here because we may have
-    // changed it!
-
-    trivialMatrix = (fInvMatrix.getType() & ~SkMatrix::kTranslate_Mask) == 0;
+    fInvType = fInvMatrix.getType();
 
     // If our target pixmap is the same as the original, then we revert back to legacy behavior
     // and allow the code to ignore fractional translate.
     //
     // The width/height check allows allow_ignore_fractional_translate to stay false if we
     // previously set it that way (e.g. we started in kMedium).
     //
     if (fPixmap.width() == origW && fPixmap.height() == origH) {
         allow_ignore_fractional_translate = true;
     }
 
-    if (kLow_SkFilterQuality == fFilterLevel && allow_ignore_fractional_translate) {
+    if (kLow_SkFilterQuality == fFilterQuality && allow_ignore_fractional_translate) {
         // Only try bilerp if the matrix is "interesting" and
         // the image has a suitable size.
 
         if (fInvType <= SkMatrix::kTranslate_Mask ||
             !valid_for_filtering(fPixmap.width() | fPixmap.height()))
         {
-            fFilterLevel = kNone_SkFilterQuality;
+            fFilterQuality = kNone_SkFilterQuality;
         }
     }
-
-    return this->chooseScanlineProcs(trivialMatrix, clampClamp, paint);
+    
+    return true;
 }
 
-bool SkBitmapProcState::chooseScanlineProcs(bool trivialMatrix, bool clampClamp,
-                                            const SkPaint& paint) {
+/*
+ *  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() {
+    fInvProc            = fInvMatrix.getMapXYProc();
+    fInvSx              = SkScalarToFixed(fInvMatrix.getScaleX());
+    fInvSxFractionalInt = SkScalarToFractionalInt(fInvMatrix.getScaleX());
+    fInvKy              = SkScalarToFixed(fInvMatrix.getSkewY());
+    fInvKyFractionalInt = SkScalarToFractionalInt(fInvMatrix.getSkewY());
+
+    fAlphaScale = SkAlpha255To256(SkColorGetA(fPaintColor));
+
+    fShaderProc32 = nullptr;
+    fShaderProc16 = nullptr;
+    fSampleProc32 = nullptr;
+
+    const bool trivialMatrix = (fInvMatrix.getType() & ~SkMatrix::kTranslate_Mask) == 0;
+    const bool clampClamp = SkShader::kClamp_TileMode == fTileModeX &&
+                            SkShader::kClamp_TileMode == fTileModeY;
+
+    return this->chooseScanlineProcs(trivialMatrix, clampClamp);
+}
+
+bool SkBitmapProcState::chooseScanlineProcs(bool trivialMatrix, bool clampClamp) {
     fMatrixProc = this->chooseMatrixProc(trivialMatrix);
     // TODO(dominikg): SkASSERT(fMatrixProc) instead? chooseMatrixProc never returns nullptr.
     if (nullptr == fMatrixProc) {
         return false;
     }
 
     ///////////////////////////////////////////////////////////////////////
 
     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) {
+    if (fFilterQuality < 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) {
+        if (fFilterQuality > kNone_SkFilterQuality) {
             index |= 4;
         }
         // bits 3,4,5 encoding the source bitmap format
         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:
                 if (kPremul_SkAlphaType != at && kOpaque_SkAlphaType != at) {
                     return false;
                 }
                 index |= 16;
                 break;
             case kARGB_4444_SkColorType:
                 if (kPremul_SkAlphaType != at && kOpaque_SkAlphaType != at) {
                     return false;
                 }
                 index |= 24;
                 break;
             case kAlpha_8_SkColorType:
                 index |= 32;
-                fPaintPMColor = SkPreMultiplyColor(paint.getColor());
+                fPaintPMColor = SkPreMultiplyColor(fPaintColor);
                 break;
             case kGray_8_SkColorType:
                 index |= 40;
-                fPaintPMColor = SkPreMultiplyColor(paint.getColor());
+                fPaintPMColor = SkPreMultiplyColor(fPaintColor);
                 break;
             default:
                 // TODO(dominikg): Should we ever get here? SkASSERT(false) instead?
                 return false;
         }
 
 #if !SK_ARM_NEON_IS_ALWAYS
         static const SampleProc32 gSkBitmapProcStateSample32[] = {
             S32_opaque_D32_nofilter_DXDY,
             S32_alpha_D32_nofilter_DXDY,
@@ skipping 75 matching lines @@
 }
 
 static void Clamp_S32_D32_nofilter_trans_shaderproc(const void* sIn,
                                                     int x, int y,
                                                     SkPMColor* SK_RESTRICT colors,
                                                     int count) {
     const SkBitmapProcState& s = *static_cast<const SkBitmapProcState*>(sIn);
     SkASSERT(((s.fInvType & ~SkMatrix::kTranslate_Mask)) == 0);
     SkASSERT(s.fInvKy == 0);
     SkASSERT(count > 0 && colors != nullptr);
-    SkASSERT(kNone_SkFilterQuality == s.fFilterLevel);
+    SkASSERT(kNone_SkFilterQuality == s.fFilterQuality);
 
     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);
     const SkPMColor* row = s.fPixmap.addr32(0, iy);
 
     // clamp to the left
     if (ix < 0) {
         int n = SkMin32(-ix, count);
@@ skipping 42 matching lines @@
 }
 
 static void Repeat_S32_D32_nofilter_trans_shaderproc(const void* sIn,
                                                      int x, int y,
                                                      SkPMColor* SK_RESTRICT colors,
                                                      int count) {
     const SkBitmapProcState& s = *static_cast<const SkBitmapProcState*>(sIn);
     SkASSERT(((s.fInvType & ~SkMatrix::kTranslate_Mask)) == 0);
     SkASSERT(s.fInvKy == 0);
     SkASSERT(count > 0 && colors != nullptr);
-    SkASSERT(kNone_SkFilterQuality == s.fFilterLevel);
+    SkASSERT(kNone_SkFilterQuality == s.fFilterQuality);
 
     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);
     const SkPMColor* row = s.fPixmap.addr32(0, iy);
 
     ix = sk_int_mod(ix, stopX);
     for (;;) {
         int n = SkMin32(stopX - ix, count);
@@ skipping 14 matching lines @@
     const SkBitmapProcState& s = *static_cast<const SkBitmapProcState*>(sIn);
     SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)) == 0);
     SkASSERT(s.fInvKy == 0);
     SkASSERT(count > 0 && colors != nullptr);
     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) {
+    if (kNone_SkFilterQuality != s.fFilterQuality) {
         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;
@@ skipping 56 matching lines @@
             }
 
             SkASSERT(iY0 == iY2);
         }
 #endif
     }
 
     const SkPMColor* row0 = s.fPixmap.addr32(0, iY0);
     SkPMColor color;
 
-    if (kNone_SkFilterQuality != s.fFilterLevel) {
+    if (kNone_SkFilterQuality != s.fFilterQuality) {
         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);
@@ skipping 36 matching lines @@
 
 SkBitmapProcState::ShaderProc32 SkBitmapProcState::chooseShaderProc32() {
 
     if (kN32_SkColorType != fPixmap.colorType()) {
         return nullptr;
     }
 
     static const unsigned kMask = SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask;
 
     if (1 == fPixmap.width() && 0 == (fInvType & ~kMask)) {
-        if (kNone_SkFilterQuality == fFilterLevel &&
+        if (kNone_SkFilterQuality == fFilterQuality &&
             fInvType <= SkMatrix::kTranslate_Mask &&
             !this->setupForTranslate()) {
             return DoNothing_shaderproc;
         }
         return S32_D32_constX_shaderproc;
     }
 
     if (fAlphaScale < 256) {
         return nullptr;
     }
     if (fInvType > SkMatrix::kTranslate_Mask) {
         return nullptr;
     }
-    if (kNone_SkFilterQuality != fFilterLevel) {
+    if (kNone_SkFilterQuality != fFilterQuality) {
         return nullptr;
     }
 
     SkShader::TileMode tx = (SkShader::TileMode)fTileModeX;
     SkShader::TileMode ty = (SkShader::TileMode)fTileModeY;
 
     if (SkShader::kClamp_TileMode == tx && SkShader::kClamp_TileMode == ty) {
         if (this->setupForTranslate()) {
             return Clamp_S32_D32_nofilter_trans_shaderproc;
         }
@@ skipping 75 matching lines @@
     SkASSERT(count > 0);
 
     state.fMatrixProc(state, bitmapXY, count, x, y);
 
     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;
+        proc = state.fFilterQuality != kNone_SkFilterQuality ?
+                    check_scale_filter : check_scale_nofilter;
     } else {
-        proc = state.fFilterLevel != kNone_SkFilterQuality ? check_affine_filter : check_affine_nofilter;
+        proc = state.fFilterQuality != kNone_SkFilterQuality ?
+                    check_affine_filter : check_affine_nofilter;
     }
     proc(bitmapXY, count, state.fPixmap.width(), state.fPixmap.height());
 }
 
 SkBitmapProcState::MatrixProc SkBitmapProcState::getMatrixProc() const {
     return DebugMatrixProc;
 }
 
 #endif
 
@@ skipping 14 matching lines @@
     if (fInvType <= (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)) {
         size -= 4;   // the shared Y (or YY) coordinate
         if (size < 0) {
             size = 0;
         }
         size >>= 1;
     } else {
         size >>= 2;
     }
 
-    if (fFilterLevel != kNone_SkFilterQuality) {
+    if (fFilterQuality != kNone_SkFilterQuality) {
         size >>= 1;
     }
 
     return size;
 }
 
 ///////////////////////
 
 void  Clamp_S32_opaque_D32_nofilter_DX_shaderproc(const void* sIn, int x, int y,
                                                   SkPMColor* SK_RESTRICT dst, int count) {
@@ skipping 38 matching lines @@
             fx += dx;
         }
     } else {
         for (int i = 0; i < count; ++i) {
             dst[i] = src[SkClampMax(SkFractionalIntToInt(fx), maxX)];
             fx += dx;
         }
     }
 }