diff options
author | 2013-07-12 21:14:33 +0000 | |
---|---|---|
committer | 2013-07-12 21:14:33 +0000 | |
commit | d64d8a905a044204c5960e29cdf8adf1f130edce (patch) | |
tree | 22523a4bb1944558f181e0db29dd3a360cc1fc6b /src/core/SkBitmapProcState.cpp | |
parent | 5383a7525355dec72efa2083aeadffdd09a962b9 (diff) |
Working plumb of image scaling:
1) always generate mipmaps if we detect that we are downsampling.
2) pre-scale the image if we detect that we are upsampling
(currently valid for scale+translate only)
3) A few miscellaneous bug fixes related to image scaling.
Still need SSE/Neon versions of these image scalers.
BUG=
R=bsalomon@google.com, robertphillips@google.com
Review URL: https://codereview.chromium.org/18978014
git-svn-id: http://skia.googlecode.com/svn/trunk@10056 2bbb7eff-a529-9590-31e7-b0007b416f81
Diffstat (limited to 'src/core/SkBitmapProcState.cpp')
-rw-r--r-- | src/core/SkBitmapProcState.cpp | 508 |
1 files changed, 318 insertions, 190 deletions
diff --git a/src/core/SkBitmapProcState.cpp b/src/core/SkBitmapProcState.cpp index a2c7f990c2..0567cf3990 100644 --- a/src/core/SkBitmapProcState.cpp +++ b/src/core/SkBitmapProcState.cpp @@ -90,220 +90,346 @@ static bool valid_for_filtering(unsigned dimension) { return (dimension & ~0x3FFF) == 0; } +// TODO -- we may want to pass the clip into this function so we only scale +// the portion of the image that we're going to need. This will complicate +// the interface to the cache, but might be well worth it. + +void SkBitmapProcState::possiblyScaleImage() { + + if (fFilterQuality != kHQ_BitmapFilter) { + return; + } + + // STEP 1: UPSAMPLE? + + // Check to see if the transformation matrix is scaling up, and if + // the matrix is simple, and if we're doing high quality scaling. + // If so, do the bitmap scale here and remove the scaling component from the matrix. + + if (fInvMatrix.getType() <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask) && + (fInvMatrix.getScaleX() < 1 || fInvMatrix.getScaleY() < 1) && + fOrigBitmap.config() == SkBitmap::kARGB_8888_Config) { + + // All the criteria are met; let's make a new bitmap. + fScaledBitmap.setConfig(SkBitmap::kARGB_8888_Config, + (int)(fOrigBitmap.width() / fInvMatrix.getScaleX()), + (int)(fOrigBitmap.height() / fInvMatrix.getScaleY())); + fScaledBitmap.allocPixels(); + fOrigBitmap.scale(&fScaledBitmap); + fBitmap = &fScaledBitmap; + + // set the inv matrix type to translate-only; + + fInvMatrix.setTranslate( 1/fInvMatrix.getScaleX() * fInvMatrix.getTranslateX(), + 1/fInvMatrix.getScaleY() * fInvMatrix.getTranslateY() ); + + // no need for any further filtering; we just did it! + + fFilterQuality = kNone_BitmapFilter; + + return; + } + + if (!fOrigBitmap.hasMipMap()) { + + // STEP 2: DOWNSAMPLE + + // Check to see if the transformation matrix is scaling *down*. + // If so, automatically build mipmaps. + + SkPoint v1, v2; + + // conservatively estimate if the matrix is scaling down by seeing + // what its upper left 2x2 portion does to two unit vectors. + + v1.fX = fInvMatrix.getScaleX(); + v1.fY = fInvMatrix.getSkewY(); + + v2.fX = fInvMatrix.getSkewX(); + v2.fY = fInvMatrix.getScaleY(); + + if (v1.fX * v1.fX + v1.fY * v1.fY > 1 || + v2.fX * v2.fX + v2.fY * v2.fY > 1) { + fOrigBitmap.buildMipMap(); + + // Now that we've built the mipmaps and we know we're downsampling, + // downgrade to bilinear interpolation for the mip level. + + fFilterQuality = kBilerp_BitmapFilter; + } + } + + if (fOrigBitmap.hasMipMap()) { + + // STEP 3: We've got mipmaps, let's choose the closest level as our render + // source and adjust the matrix accordingly. + + int shift = fOrigBitmap.extractMipLevel(&fScaledBitmap, + SkScalarToFixed(fInvMatrix.getScaleX()), + SkScalarToFixed(fInvMatrix.getSkewY())); + + if (shift > 0) { + SkScalar scale = SkFixedToScalar(SK_Fixed1 >> shift); + fInvMatrix.postScale(scale, scale); + fBitmap = &fScaledBitmap; + } + } +} + +void SkBitmapProcState::endContext() { + SkDELETE(fBitmapFilter); + fBitmapFilter = NULL; + fScaledBitmap.reset(); +} + bool SkBitmapProcState::chooseProcs(const SkMatrix& inv, const SkPaint& paint) { if (fOrigBitmap.width() == 0 || fOrigBitmap.height() == 0) { return false; } - const SkMatrix* m; - bool trivial_matrix = (inv.getType() & ~SkMatrix::kTranslate_Mask) == 0; - bool clamp_clamp = SkShader::kClamp_TileMode == fTileModeX && + bool trivialMatrix = (inv.getType() & ~SkMatrix::kTranslate_Mask) == 0; + bool clampClamp = SkShader::kClamp_TileMode == fTileModeX && SkShader::kClamp_TileMode == fTileModeY; - if (clamp_clamp || trivial_matrix) { - m = &inv; - } else { - fUnitInvMatrix = inv; - fUnitInvMatrix.postIDiv(fOrigBitmap.width(), fOrigBitmap.height()); - m = &fUnitInvMatrix; + fInvMatrix = inv; + if (!(clampClamp || trivialMatrix)) { + fInvMatrix.postIDiv(fOrigBitmap.width(), fOrigBitmap.height()); } fBitmap = &fOrigBitmap; - if (fOrigBitmap.hasMipMap()) { - int shift = fOrigBitmap.extractMipLevel(&fMipBitmap, - SkScalarToFixed(m->getScaleX()), - SkScalarToFixed(m->getSkewY())); - - if (shift > 0) { - if (m != &fUnitInvMatrix) { - fUnitInvMatrix = *m; - m = &fUnitInvMatrix; - } - - SkScalar scale = SkFixedToScalar(SK_Fixed1 >> shift); - fUnitInvMatrix.postScale(scale, scale); - - // now point here instead of fOrigBitmap - fBitmap = &fMipBitmap; + + // initialize our filter quality to the one requested by the caller. + // We may downgrade it later if we determine that we either don't need + // or can't provide as high a quality filtering as the user requested. + + fFilterQuality = kNone_BitmapFilter; + if (paint.isFilterBitmap()) { + if (paint.getFlags() & SkPaint::kHighQualityFilterBitmap_Flag) { + fFilterQuality = kHQ_BitmapFilter; + } else { + fFilterQuality = kBilerp_BitmapFilter; } } - // wack our matrix to exactly no-scale, if we're really close to begin with - if (matrix_only_scale_translate(*m)) { +#ifndef SK_IGNORE_IMAGE_PRESCALE + // possiblyScaleImage will look to see if it can rescale the image as a + // preprocess; either by scaling up to the target size, or by selecting + // a nearby mipmap level. If it does, it will adjust the working + // matrix as well as the working bitmap. It may also adjust the filter + // quality to avoid re-filtering an already perfectly scaled image. + + this->possiblyScaleImage(); +#endif + + // 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 (m->invert(&forward)) { - if (clamp_clamp ? just_trans_clamp(forward, *fBitmap) + if (fInvMatrix.invert(&forward)) { + if (clampClamp ? just_trans_clamp(forward, *fBitmap) : just_trans_general(forward)) { SkScalar tx = -SkScalarRoundToScalar(forward.getTranslateX()); SkScalar ty = -SkScalarRoundToScalar(forward.getTranslateY()); - fUnitInvMatrix.setTranslate(tx, ty); - m = &fUnitInvMatrix; - // now the following code will sniff m, and decide to take the - // fast case (since m is purely translate). + fInvMatrix.setTranslate(tx, ty); + } } } - // Below this point, we should never refer to the inv parameter, since we - // may be using a munged version for "our" inverse. - - fInvMatrix = m; - fInvProc = m->getMapXYProc(); - fInvType = m->getType(); - fInvSx = SkScalarToFixed(m->getScaleX()); - fInvSxFractionalInt = SkScalarToFractionalInt(m->getScaleX()); - fInvKy = SkScalarToFixed(m->getSkewY()); - fInvKyFractionalInt = SkScalarToFractionalInt(m->getSkewY()); + 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()); - - // pick-up filtering from the paint, but only if the matrix is - // more complex than identity/translate (i.e. no need to pay the cost - // of filtering if we're not scaled etc.). - // note: we explicitly check inv, since m might be scaled due to unitinv - // trickery, but we don't want to see that for this test - fDoFilter = paint.isFilterBitmap() && - (fInvType > SkMatrix::kTranslate_Mask && - valid_for_filtering(fBitmap->width() | fBitmap->height())); - + fShaderProc32 = NULL; fShaderProc16 = NULL; fSampleProc32 = NULL; fSampleProc16 = NULL; + + // recompute the triviality of the matrix here because we may have + // changed it! + + trivialMatrix = (fInvMatrix.getType() & ~SkMatrix::kTranslate_Mask) == 0; + + if (kHQ_BitmapFilter == fFilterQuality) { + // If this is still set, that means we wanted HQ sampling + // but couldn't do it as a preprocess. Let's try to install + // the scanline version of the HQ sampler. If that process fails, + // downgrade to bilerp. + + // NOTE: Might need to be careful here in the future when we want + // to have the platform proc have a shot at this; it's possible that + // the chooseBitmapFilterProc will fail to install a shader but a + // platform-specific one might succeed, so it might be premature here + // to fall back to bilerp. This needs thought. + + SkASSERT(fInvType > SkMatrix::kTranslate_Mask); + + fShaderProc32 = this->chooseBitmapFilterProc(); + if (!fShaderProc32) { + fFilterQuality = kBilerp_BitmapFilter; + } + } + + if (kBilerp_BitmapFilter == fFilterQuality) { + // 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())) { + fFilterQuality = kNone_BitmapFilter; + } + } + + // At this point, we know exactly what kind of sampling the per-scanline + // shader will perform. - fMatrixProc = this->chooseMatrixProc(trivial_matrix); + fMatrixProc = this->chooseMatrixProc(trivialMatrix); if (NULL == fMatrixProc) { return false; } /////////////////////////////////////////////////////////////////////// - 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 (fDoFilter) { - index |= 4; - } - // bits 3,4,5 encoding the source bitmap format - switch (fBitmap->config()) { - case SkBitmap::kARGB_8888_Config: - index |= 0; - break; - case SkBitmap::kRGB_565_Config: - index |= 8; - break; - case SkBitmap::kIndex8_Config: - index |= 16; - break; - case SkBitmap::kARGB_4444_Config: - index |= 24; - break; - case SkBitmap::kA8_Config: - index |= 32; - fPaintPMColor = SkPreMultiplyColor(paint.getColor()); - break; - default: - return false; - } + // 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 proc above and can skip all this. -#if !SK_ARM_NEON_IS_ALWAYS - static const SampleProc32 gSkBitmapProcStateSample32[] = { - S32_opaque_D32_nofilter_DXDY, - S32_alpha_D32_nofilter_DXDY, - S32_opaque_D32_nofilter_DX, - S32_alpha_D32_nofilter_DX, - S32_opaque_D32_filter_DXDY, - S32_alpha_D32_filter_DXDY, - S32_opaque_D32_filter_DX, - S32_alpha_D32_filter_DX, - - S16_opaque_D32_nofilter_DXDY, - S16_alpha_D32_nofilter_DXDY, - S16_opaque_D32_nofilter_DX, - S16_alpha_D32_nofilter_DX, - S16_opaque_D32_filter_DXDY, - S16_alpha_D32_filter_DXDY, - S16_opaque_D32_filter_DX, - S16_alpha_D32_filter_DX, - - SI8_opaque_D32_nofilter_DXDY, - SI8_alpha_D32_nofilter_DXDY, - SI8_opaque_D32_nofilter_DX, - SI8_alpha_D32_nofilter_DX, - SI8_opaque_D32_filter_DXDY, - SI8_alpha_D32_filter_DXDY, - SI8_opaque_D32_filter_DX, - SI8_alpha_D32_filter_DX, - - S4444_opaque_D32_nofilter_DXDY, - S4444_alpha_D32_nofilter_DXDY, - S4444_opaque_D32_nofilter_DX, - S4444_alpha_D32_nofilter_DX, - S4444_opaque_D32_filter_DXDY, - S4444_alpha_D32_filter_DXDY, - S4444_opaque_D32_filter_DX, - S4444_alpha_D32_filter_DX, - - // A8 treats alpha/opaque the same (equally efficient) - SA8_alpha_D32_nofilter_DXDY, - SA8_alpha_D32_nofilter_DXDY, - SA8_alpha_D32_nofilter_DX, - SA8_alpha_D32_nofilter_DX, - SA8_alpha_D32_filter_DXDY, - SA8_alpha_D32_filter_DXDY, - SA8_alpha_D32_filter_DX, - SA8_alpha_D32_filter_DX - }; - - static const SampleProc16 gSkBitmapProcStateSample16[] = { - S32_D16_nofilter_DXDY, - S32_D16_nofilter_DX, - S32_D16_filter_DXDY, - S32_D16_filter_DX, - - S16_D16_nofilter_DXDY, - S16_D16_nofilter_DX, - S16_D16_filter_DXDY, - S16_D16_filter_DX, - - SI8_D16_nofilter_DXDY, - SI8_D16_nofilter_DX, - SI8_D16_filter_DXDY, - SI8_D16_filter_DX, - - // Don't support 4444 -> 565 - NULL, NULL, NULL, NULL, - // Don't support A8 -> 565 - NULL, NULL, NULL, NULL - }; -#endif - - fSampleProc32 = SK_ARM_NEON_WRAP(gSkBitmapProcStateSample32)[index]; - index >>= 1; // shift away any opaque/alpha distinction - fSampleProc16 = SK_ARM_NEON_WRAP(gSkBitmapProcStateSample16)[index]; - - // our special-case shaderprocs - if (SK_ARM_NEON_WRAP(S16_D16_filter_DX) == fSampleProc16) { - if (clamp_clamp) { - fShaderProc16 = SK_ARM_NEON_WRAP(Clamp_S16_D16_filter_DX_shaderproc); - } else if (SkShader::kRepeat_TileMode == fTileModeX && - SkShader::kRepeat_TileMode == fTileModeY) { - fShaderProc16 = SK_ARM_NEON_WRAP(Repeat_S16_D16_filter_DX_shaderproc); + if (fFilterQuality < kHQ_BitmapFilter) { + + 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 (fFilterQuality != kNone_BitmapFilter) { + index |= 4; + } + // bits 3,4,5 encoding the source bitmap format + switch (fBitmap->config()) { + case SkBitmap::kARGB_8888_Config: + index |= 0; + break; + case SkBitmap::kRGB_565_Config: + index |= 8; + break; + case SkBitmap::kIndex8_Config: + index |= 16; + break; + case SkBitmap::kARGB_4444_Config: + index |= 24; + break; + case SkBitmap::kA8_Config: + index |= 32; + fPaintPMColor = SkPreMultiplyColor(paint.getColor()); + break; + default: + return false; } - } else if (SK_ARM_NEON_WRAP(SI8_opaque_D32_filter_DX) == fSampleProc32 && clamp_clamp) { - fShaderProc32 = SK_ARM_NEON_WRAP(Clamp_SI8_opaque_D32_filter_DX_shaderproc); - } - if (NULL == fShaderProc32) { - fShaderProc32 = this->chooseShaderProc32(); - } + #if !SK_ARM_NEON_IS_ALWAYS + static const SampleProc32 gSkBitmapProcStateSample32[] = { + S32_opaque_D32_nofilter_DXDY, + S32_alpha_D32_nofilter_DXDY, + S32_opaque_D32_nofilter_DX, + S32_alpha_D32_nofilter_DX, + S32_opaque_D32_filter_DXDY, + S32_alpha_D32_filter_DXDY, + S32_opaque_D32_filter_DX, + S32_alpha_D32_filter_DX, + + S16_opaque_D32_nofilter_DXDY, + S16_alpha_D32_nofilter_DXDY, + S16_opaque_D32_nofilter_DX, + S16_alpha_D32_nofilter_DX, + S16_opaque_D32_filter_DXDY, + S16_alpha_D32_filter_DXDY, + S16_opaque_D32_filter_DX, + S16_alpha_D32_filter_DX, + + SI8_opaque_D32_nofilter_DXDY, + SI8_alpha_D32_nofilter_DXDY, + SI8_opaque_D32_nofilter_DX, + SI8_alpha_D32_nofilter_DX, + SI8_opaque_D32_filter_DXDY, + SI8_alpha_D32_filter_DXDY, + SI8_opaque_D32_filter_DX, + SI8_alpha_D32_filter_DX, + + S4444_opaque_D32_nofilter_DXDY, + S4444_alpha_D32_nofilter_DXDY, + S4444_opaque_D32_nofilter_DX, + S4444_alpha_D32_nofilter_DX, + S4444_opaque_D32_filter_DXDY, + S4444_alpha_D32_filter_DXDY, + S4444_opaque_D32_filter_DX, + S4444_alpha_D32_filter_DX, + + // A8 treats alpha/opaque the same (equally efficient) + SA8_alpha_D32_nofilter_DXDY, + SA8_alpha_D32_nofilter_DXDY, + SA8_alpha_D32_nofilter_DX, + SA8_alpha_D32_nofilter_DX, + SA8_alpha_D32_filter_DXDY, + SA8_alpha_D32_filter_DXDY, + SA8_alpha_D32_filter_DX, + SA8_alpha_D32_filter_DX + }; + + static const SampleProc16 gSkBitmapProcStateSample16[] = { + S32_D16_nofilter_DXDY, + S32_D16_nofilter_DX, + S32_D16_filter_DXDY, + S32_D16_filter_DX, + + S16_D16_nofilter_DXDY, + S16_D16_nofilter_DX, + S16_D16_filter_DXDY, + S16_D16_filter_DX, + + SI8_D16_nofilter_DXDY, + SI8_D16_nofilter_DX, + SI8_D16_filter_DXDY, + SI8_D16_filter_DX, + + // Don't support 4444 -> 565 + NULL, NULL, NULL, NULL, + // Don't support A8 -> 565 + NULL, NULL, NULL, NULL + }; + #endif + + fSampleProc32 = SK_ARM_NEON_WRAP(gSkBitmapProcStateSample32)[index]; + index >>= 1; // shift away any opaque/alpha distinction + fSampleProc16 = SK_ARM_NEON_WRAP(gSkBitmapProcStateSample16)[index]; + + // our special-case shaderprocs + if (SK_ARM_NEON_WRAP(S16_D16_filter_DX) == fSampleProc16) { + if (clampClamp) { + fShaderProc16 = SK_ARM_NEON_WRAP(Clamp_S16_D16_filter_DX_shaderproc); + } else if (SkShader::kRepeat_TileMode == fTileModeX && + SkShader::kRepeat_TileMode == fTileModeY) { + fShaderProc16 = SK_ARM_NEON_WRAP(Repeat_S16_D16_filter_DX_shaderproc); + } + } else if (SK_ARM_NEON_WRAP(SI8_opaque_D32_filter_DX) == fSampleProc32 && clampClamp) { + fShaderProc32 = SK_ARM_NEON_WRAP(Clamp_SI8_opaque_D32_filter_DX_shaderproc); + } - if (NULL == fShaderProc32) { - fShaderProc32 = this->chooseBitmapFilterProc(paint); + if (NULL == fShaderProc32) { + fShaderProc32 = this->chooseShaderProc32(); + } } // see if our platform has any accelerated overrides @@ -319,7 +445,7 @@ static void Clamp_S32_D32_nofilter_trans_shaderproc(const SkBitmapProcState& s, SkASSERT(((s.fInvType & ~SkMatrix::kTranslate_Mask)) == 0); SkASSERT(s.fInvKy == 0); SkASSERT(count > 0 && colors != NULL); - SkASSERT(!s.fDoFilter); + SkASSERT(SkBitmapProcState::kNone_BitmapFilter == s.fFilterQuality); const int maxX = s.fBitmap->width() - 1; const int maxY = s.fBitmap->height() - 1; @@ -328,7 +454,7 @@ static void Clamp_S32_D32_nofilter_trans_shaderproc(const SkBitmapProcState& s, #ifdef SK_DEBUG { SkPoint pt; - s.fInvProc(*s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf, + 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); @@ -393,7 +519,7 @@ static void Repeat_S32_D32_nofilter_trans_shaderproc(const SkBitmapProcState& s, SkASSERT(((s.fInvType & ~SkMatrix::kTranslate_Mask)) == 0); SkASSERT(s.fInvKy == 0); SkASSERT(count > 0 && colors != NULL); - SkASSERT(!s.fDoFilter); + SkASSERT(SkBitmapProcState::kNone_BitmapFilter == s.fFilterQuality); const int stopX = s.fBitmap->width(); const int stopY = s.fBitmap->height(); @@ -402,7 +528,7 @@ static void Repeat_S32_D32_nofilter_trans_shaderproc(const SkBitmapProcState& s, #ifdef SK_DEBUG { SkPoint pt; - s.fInvProc(*s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf, + 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); @@ -439,7 +565,7 @@ static void S32_D32_constX_shaderproc(const SkBitmapProcState& s, int iY1 SK_INIT_TO_AVOID_WARNING; int iSubY SK_INIT_TO_AVOID_WARNING; - if (s.fDoFilter) { + if (s.fFilterQuality != SkBitmapProcState::kNone_BitmapFilter) { SkBitmapProcState::MatrixProc mproc = s.getMatrixProc(); uint32_t xy[2]; @@ -453,7 +579,7 @@ static void S32_D32_constX_shaderproc(const SkBitmapProcState& s, if (s.fInvType > SkMatrix::kTranslate_Mask) { SkPoint pt; - s.fInvProc(*s.fInvMatrix, + s.fInvProc(s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf, SkIntToScalar(y) + SK_ScalarHalf, &pt); @@ -488,7 +614,7 @@ static void S32_D32_constX_shaderproc(const SkBitmapProcState& s, #ifdef SK_DEBUG { SkPoint pt; - s.fInvProc(*s.fInvMatrix, + s.fInvProc(s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf, SkIntToScalar(y) + SK_ScalarHalf, &pt); @@ -520,7 +646,7 @@ static void S32_D32_constX_shaderproc(const SkBitmapProcState& s, const SkPMColor* row0 = s.fBitmap->getAddr32(0, iY0); SkPMColor color; - if (s.fDoFilter) { + if (s.fFilterQuality != SkBitmapProcState::kNone_BitmapFilter) { const SkPMColor* row1 = s.fBitmap->getAddr32(0, iY1); if (s.fAlphaScale < 256) { @@ -547,7 +673,7 @@ static void DoNothing_shaderproc(const SkBitmapProcState&, int x, int y, bool SkBitmapProcState::setupForTranslate() { SkPoint pt; - fInvProc(*fInvMatrix, SK_ScalarHalf, SK_ScalarHalf, &pt); + fInvProc(fInvMatrix, SK_ScalarHalf, SK_ScalarHalf, &pt); /* * if the translate is larger than our ints, we can get random results, or @@ -576,7 +702,9 @@ SkBitmapProcState::ShaderProc32 SkBitmapProcState::chooseShaderProc32() { static const unsigned kMask = SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask; if (1 == fBitmap->width() && 0 == (fInvType & ~kMask)) { - if (!fDoFilter && fInvType <= SkMatrix::kTranslate_Mask && !this->setupForTranslate()) { + if (kNone_BitmapFilter == fFilterQuality && + fInvType <= SkMatrix::kTranslate_Mask && + !this->setupForTranslate()) { return DoNothing_shaderproc; } return S32_D32_constX_shaderproc; @@ -588,7 +716,7 @@ SkBitmapProcState::ShaderProc32 SkBitmapProcState::chooseShaderProc32() { if (fInvType > SkMatrix::kTranslate_Mask) { return NULL; } - if (fDoFilter) { + if (fFilterQuality != kNone_BitmapFilter) { return NULL; } @@ -684,9 +812,9 @@ void SkBitmapProcState::DebugMatrixProc(const SkBitmapProcState& state, // scale -vs- affine // filter -vs- nofilter if (state.fInvType <= (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)) { - proc = state.fDoFilter ? check_scale_filter : check_scale_nofilter; + proc = state.fFilterQuality != kNone_BitmapFilter ? check_scale_filter : check_scale_nofilter; } else { - proc = state.fDoFilter ? check_affine_filter : check_affine_nofilter; + proc = state.fFilterQuality != kNone_BitmapFilter ? check_affine_filter : check_affine_nofilter; } proc(bitmapXY, count, state.fBitmap->width(), state.fBitmap->height()); } @@ -721,7 +849,7 @@ int SkBitmapProcState::maxCountForBufferSize(size_t bufferSize) const { size >>= 2; } - if (fDoFilter) { + if (fFilterQuality != kNone_BitmapFilter) { size >>= 1; } |