src/third_party/skia/src/core/SkBitmapProcState.cpp

   1
   2 /*
   3  * Copyright 2011 Google Inc.
   4  *
   5  * Use of this source code is governed by a BSD-style license that can be
   6  * found in the LICENSE file.
   7  */
   8 #include "SkBitmapProcState.h"
   9 #include "SkColorPriv.h"
  10 #include "SkFilterProc.h"
  11 #include "SkPaint.h"
  12 #include "SkShader.h"   // for tilemodes
  13 #include "SkUtilsArm.h"
  14 #include "SkBitmapScaler.h"
  15 #include "SkMipMap.h"
  16 #include "SkPixelRef.h"
  17 #include "SkScaledImageCache.h"
  18 #include "SkImageEncoder.h"
  19
  20 #if !SK_ARM_NEON_IS_NONE
  21 // These are defined in src/opts/SkBitmapProcState_arm_neon.cpp
  22 extern const SkBitmapProcState::SampleProc16 gSkBitmapProcStateSample16_neon[];
  23 extern const SkBitmapProcState::SampleProc32 gSkBitmapProcStateSample32_neon[];
  24 extern void  S16_D16_filter_DX_neon(const SkBitmapProcState&, const uint32_t*, int, uint16_t*);
  25 extern void  Clamp_S16_D16_filter_DX_shaderproc_neon(const SkBitmapProcState&, int, int, uint16_t*, int);
  26 extern void  Repeat_S16_D16_filter_DX_shaderproc_neon(const SkBitmapProcState&, int, int, uint16_t*, int);
  27 extern void  SI8_opaque_D32_filter_DX_neon(const SkBitmapProcState&, const uint32_t*, int, SkPMColor*);
  28 extern void  SI8_opaque_D32_filter_DX_shaderproc_neon(const SkBitmapProcState&, int, int, uint32_t*, int);
  29 extern void  Clamp_SI8_opaque_D32_filter_DX_shaderproc_neon(const SkBitmapProcState&, int, int, uint32_t*, int);
  30 #endif
  31
  32 #define   NAME_WRAP(x)  x
  33 #include "SkBitmapProcState_filter.h"
  34 #include "SkBitmapProcState_procs.h"
  35
  36 ///////////////////////////////////////////////////////////////////////////////
  37
  38 // true iff the matrix contains, at most, scale and translate elements
  39 static bool matrix_only_scale_translate(const SkMatrix& m) {
  40     return m.getType() <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask);
  41 }
  42
  43 /**
  44  *  For the purposes of drawing bitmaps, if a matrix is "almost" translate
  45  *  go ahead and treat it as if it were, so that subsequent code can go fast.
  46  */
  47 static bool just_trans_clamp(const SkMatrix& matrix, const SkBitmap& bitmap) {
  48     SkASSERT(matrix_only_scale_translate(matrix));
  49
  50     if (matrix.getType() & SkMatrix::kScale_Mask) {
  51         SkRect src, dst;
  52         bitmap.getBounds(&src);
  53
  54         // Can't call mapRect(), since that will fix up inverted rectangles,
  55         // e.g. when scale is negative, and we don't want to return true for
  56         // those.
  57         matrix.mapPoints(SkTCast<SkPoint*>(&dst),
  58                          SkTCast<const SkPoint*>(&src),
  59                          2);
  60
  61         // Now round all 4 edges to device space, and then compare the device
  62         // width/height to the original. Note: we must map all 4 and subtract
  63         // rather than map the "width" and compare, since we care about the
  64         // phase (in pixel space) that any translate in the matrix might impart.
  65         SkIRect idst;
  66         dst.round(&idst);
  67         return idst.width() == bitmap.width() && idst.height() == bitmap.height();
  68     }
  69     // if we got here, we're either kTranslate_Mask or identity
  70     return true;
  71 }
  72
  73 static bool just_trans_general(const SkMatrix& matrix) {
  74     SkASSERT(matrix_only_scale_translate(matrix));
  75
  76     if (matrix.getType() & SkMatrix::kScale_Mask) {
  77         const SkScalar tol = SK_Scalar1 / 32768;
  78
  79         if (!SkScalarNearlyZero(matrix[SkMatrix::kMScaleX] - SK_Scalar1, tol)) {
  80             return false;
  81         }
  82         if (!SkScalarNearlyZero(matrix[SkMatrix::kMScaleY] - SK_Scalar1, tol)) {
  83             return false;
  84         }
  85     }
  86     // if we got here, treat us as either kTranslate_Mask or identity
  87     return true;
  88 }
  89
  90 ///////////////////////////////////////////////////////////////////////////////
  91
  92 static bool valid_for_filtering(unsigned dimension) {
  93     // for filtering, width and height must fit in 14bits, since we use steal
  94     // 2 bits from each to store our 4bit subpixel data
  95     return (dimension & ~0x3FFF) == 0;
  96 }
  97
  98 static SkScalar effective_matrix_scale_sqrd(const SkMatrix& mat) {
  99     SkPoint v1, v2;
 100
 101     v1.fX = mat.getScaleX();
 102     v1.fY = mat.getSkewY();
 103
 104     v2.fX = mat.getSkewX();
 105     v2.fY = mat.getScaleY();
 106
 107     return SkMaxScalar(v1.lengthSqd(), v2.lengthSqd());
 108 }
 109
 110 class AutoScaledCacheUnlocker {
 111 public:
 112     AutoScaledCacheUnlocker(SkScaledImageCache::ID** idPtr) : fIDPtr(idPtr) {}
 113     ~AutoScaledCacheUnlocker() {
 114         if (fIDPtr && *fIDPtr) {
 115             SkScaledImageCache::Unlock(*fIDPtr);
 116             *fIDPtr = NULL;
 117         }
 118     }
 119
 120     // forgets the ID, so it won't call Unlock
 121     void release() {
 122         fIDPtr = NULL;
 123     }
 124
 125 private:
 126     SkScaledImageCache::ID** fIDPtr;
 127 };
 128 #define AutoScaledCacheUnlocker(...) SK_REQUIRE_LOCAL_VAR(AutoScaledCacheUnlocker)
 129
 130 // Check to see that the size of the bitmap that would be produced by
 131 // scaling by the given inverted matrix is less than the maximum allowed.
 132 static inline bool cache_size_okay(const SkBitmap& bm, const SkMatrix& invMat) {
 133     size_t maximumAllocation
 134         = SkScaledImageCache::GetSingleAllocationByteLimit();
 135     if (0 == maximumAllocation) {
 136         return true;
 137     }
 138     // float matrixScaleFactor = 1.0 / (invMat.scaleX * invMat.scaleY);
 139     // return ((origBitmapSize * matrixScaleFactor) < maximumAllocationSize);
 140     // Skip the division step:
 141     return bm.info().getSafeSize(bm.info().minRowBytes())
 142         < (maximumAllocation * invMat.getScaleX() * invMat.getScaleY());
 143 }
 144
 145 // TODO -- we may want to pass the clip into this function so we only scale
 146 // the portion of the image that we're going to need.  This will complicate
 147 // the interface to the cache, but might be well worth it.
 148
 149 bool SkBitmapProcState::possiblyScaleImage() {
 150     AutoScaledCacheUnlocker unlocker(&fScaledCacheID);
 151
 152     SkASSERT(NULL == fBitmap);
 153     SkASSERT(NULL == fScaledCacheID);
 154
 155     if (fFilterLevel <= SkPaint::kLow_FilterLevel) {
 156         return false;
 157     }
 158     // Check to see if the transformation matrix is simple, and if we're
 159     // doing high quality scaling.  If so, do the bitmap scale here and
 160     // remove the scaling component from the matrix.
 161
 162     if (SkPaint::kHigh_FilterLevel == fFilterLevel &&
 163         fInvMatrix.getType() <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask) &&
 164         kN32_SkColorType == fOrigBitmap.colorType() &&
 165         cache_size_okay(fOrigBitmap, fInvMatrix)) {
 166
 167         SkScalar invScaleX = fInvMatrix.getScaleX();
 168         SkScalar invScaleY = fInvMatrix.getScaleY();
 169
 170         fScaledCacheID = SkScaledImageCache::FindAndLock(fOrigBitmap,
 171                                                          invScaleX, invScaleY,
 172                                                          &fScaledBitmap);
 173         if (fScaledCacheID) {
 174             fScaledBitmap.lockPixels();
 175             if (!fScaledBitmap.getPixels()) {
 176                 fScaledBitmap.unlockPixels();
 177                 // found a purged entry (discardablememory?), release it
 178                 SkScaledImageCache::Unlock(fScaledCacheID);
 179                 fScaledCacheID = NULL;
 180                 // fall through to rebuild
 181             }
 182         }
 183
 184         if (NULL == fScaledCacheID) {
 185             float dest_width  = fOrigBitmap.width() / invScaleX;
 186             float dest_height = fOrigBitmap.height() / invScaleY;
 187
 188             // All the criteria are met; let's make a new bitmap.
 189
 190             SkConvolutionProcs simd;
 191             sk_bzero(&simd, sizeof(simd));
 192             this->platformConvolutionProcs(&simd);
 193
 194             if (!SkBitmapScaler::Resize(&fScaledBitmap,
 195                                         fOrigBitmap,
 196                                         SkBitmapScaler::RESIZE_BEST,
 197                                         dest_width,
 198                                         dest_height,
 199                                         simd,
 200                                         SkScaledImageCache::GetAllocator())) {
 201                 // we failed to create fScaledBitmap, so just return and let
 202                 // the scanline proc handle it.
 203                 return false;
 204
 205             }
 206
 207             SkASSERT(NULL != fScaledBitmap.getPixels());
 208             fScaledCacheID = SkScaledImageCache::AddAndLock(fOrigBitmap,
 209                                                             invScaleX,
 210                                                             invScaleY,
 211                                                             fScaledBitmap);
 212             if (!fScaledCacheID) {
 213                 fScaledBitmap.reset();
 214                 return false;
 215             }
 216             SkASSERT(NULL != fScaledBitmap.getPixels());
 217         }
 218
 219         SkASSERT(NULL != fScaledBitmap.getPixels());
 220         fBitmap = &fScaledBitmap;
 221
 222         // set the inv matrix type to translate-only;
 223         fInvMatrix.setTranslate(fInvMatrix.getTranslateX() / fInvMatrix.getScaleX(),
 224                                 fInvMatrix.getTranslateY() / fInvMatrix.getScaleY());
 225
 226         // no need for any further filtering; we just did it!
 227         fFilterLevel = SkPaint::kNone_FilterLevel;
 228         unlocker.release();
 229         return true;
 230     }
 231
 232     /*
 233      *  If High, then our special-case for scale-only did not take, and so we
 234      *  have to make a choice:
 235      *      1. fall back on mipmaps + bilerp
 236      *      2. fall back on scanline bicubic filter
 237      *  For now, we compute the "scale" value from the matrix, and have a
 238      *  threshold to decide when bicubic is better, and when mips are better.
 239      *  No doubt a fancier decision tree could be used uere.
 240      *
 241      *  If Medium, then we just try to build a mipmap and select a level,
 242      *  setting the filter-level to kLow to signal that we just need bilerp
 243      *  to process the selected level.
 244      */
 245
 246     SkScalar scaleSqd = effective_matrix_scale_sqrd(fInvMatrix);
 247
 248     if (SkPaint::kHigh_FilterLevel == fFilterLevel) {
 249         // Set the limit at 0.25 for the CTM... if the CTM is scaling smaller
 250         // than this, then the mipmaps quality may be greater (certainly faster)
 251         // so we only keep High quality if the scale is greater than this.
 252         //
 253         // Since we're dealing with the inverse, we compare against its inverse.
 254         const SkScalar bicubicLimit = 4.0f;
 255         const SkScalar bicubicLimitSqd = bicubicLimit * bicubicLimit;
 256         if (scaleSqd < bicubicLimitSqd) {  // use bicubic scanline
 257             return false;
 258         }
 259
 260         // else set the filter-level to Medium, since we're scaling down and
 261         // want to reqeust mipmaps
 262         fFilterLevel = SkPaint::kMedium_FilterLevel;
 263     }
 264
 265     SkASSERT(SkPaint::kMedium_FilterLevel == fFilterLevel);
 266
 267     /**
 268      *  Medium quality means use a mipmap for down-scaling, and just bilper
 269      *  for upscaling. Since we're examining the inverse matrix, we look for
 270      *  a scale > 1 to indicate down scaling by the CTM.
 271      */
 272     if (scaleSqd > SK_Scalar1) {
 273         const SkMipMap* mip = NULL;
 274
 275         SkASSERT(NULL == fScaledCacheID);
 276         fScaledCacheID = SkScaledImageCache::FindAndLockMip(fOrigBitmap, &mip);
 277         if (!fScaledCacheID) {
 278             SkASSERT(NULL == mip);
 279             mip = SkMipMap::Build(fOrigBitmap);
 280             if (mip) {
 281                 fScaledCacheID = SkScaledImageCache::AddAndLockMip(fOrigBitmap,
 282                                                                    mip);
 283                 SkASSERT(mip->getRefCnt() > 1);
 284                 mip->unref();   // the cache took a ref
 285                 SkASSERT(fScaledCacheID);
 286             }
 287         } else {
 288             SkASSERT(mip);
 289         }
 290
 291         if (mip) {
 292             SkScalar levelScale = SkScalarInvert(SkScalarSqrt(scaleSqd));
 293             SkMipMap::Level level;
 294             if (mip->extractLevel(levelScale, &level)) {
 295                 SkScalar invScaleFixup = level.fScale;
 296                 fInvMatrix.postScale(invScaleFixup, invScaleFixup);
 297
 298                 SkImageInfo info = fOrigBitmap.info();
 299                 info.fWidth = level.fWidth;
 300                 info.fHeight = level.fHeight;
 301                 fScaledBitmap.installPixels(info, level.fPixels, level.fRowBytes);
 302                 fBitmap = &fScaledBitmap;
 303                 fFilterLevel = SkPaint::kLow_FilterLevel;
 304                 unlocker.release();
 305                 return true;
 306             }
 307         }
 308     }
 309
 310     return false;
 311 }
 312
 313 static bool get_locked_pixels(const SkBitmap& src, int pow2, SkBitmap* dst) {
 314     SkPixelRef* pr = src.pixelRef();
 315     if (pr && pr->decodeInto(pow2, dst)) {
 316         return true;
 317     }
 318
 319     /*
 320      *  If decodeInto() fails, it is possibe that we have an old subclass that
 321      *  does not, or cannot, implement that. In that case we fall back to the
 322      *  older protocol of having the pixelRef handle the caching for us.
 323      */
 324     *dst = src;
 325     dst->lockPixels();
 326     return SkToBool(dst->getPixels());
 327 }
 328
 329 bool SkBitmapProcState::lockBaseBitmap() {
 330     AutoScaledCacheUnlocker unlocker(&fScaledCacheID);
 331
 332     SkPixelRef* pr = fOrigBitmap.pixelRef();
 333
 334     SkASSERT(NULL == fScaledCacheID);
 335
 336     if (pr->isLocked() || !pr->implementsDecodeInto()) {
 337         // fast-case, no need to look in our cache
 338         fScaledBitmap = fOrigBitmap;
 339         fScaledBitmap.lockPixels();
 340         if (NULL == fScaledBitmap.getPixels()) {
 341             return false;
 342         }
 343     } else {
 344         fScaledCacheID = SkScaledImageCache::FindAndLock(fOrigBitmap,
 345                                                          SK_Scalar1, SK_Scalar1,
 346                                                          &fScaledBitmap);
 347         if (fScaledCacheID) {
 348             fScaledBitmap.lockPixels();
 349             if (!fScaledBitmap.getPixels()) {
 350                 fScaledBitmap.unlockPixels();
 351                 // found a purged entry (discardablememory?), release it
 352                 SkScaledImageCache::Unlock(fScaledCacheID);
 353                 fScaledCacheID = NULL;
 354                 // fall through to rebuild
 355             }
 356         }
 357
 358         if (NULL == fScaledCacheID) {
 359             if (!get_locked_pixels(fOrigBitmap, 0, &fScaledBitmap)) {
 360                 return false;
 361             }
 362
 363             // TODO: if fScaled comes back at a different width/height than fOrig,
 364             // we need to update the matrix we are using to sample from this guy.
 365
 366             fScaledCacheID = SkScaledImageCache::AddAndLock(fOrigBitmap,
 367                                                             SK_Scalar1, SK_Scalar1,
 368                                                             fScaledBitmap);
 369             if (!fScaledCacheID) {
 370                 fScaledBitmap.reset();
 371                 return false;
 372             }
 373         }
 374     }
 375     fBitmap = &fScaledBitmap;
 376     unlocker.release();
 377     return true;
 378 }
 379
 380 SkBitmapProcState::~SkBitmapProcState() {
 381     if (fScaledCacheID) {
 382         SkScaledImageCache::Unlock(fScaledCacheID);
 383     }
 384     SkDELETE(fBitmapFilter);
 385 }
 386
 387 bool SkBitmapProcState::chooseProcs(const SkMatrix& inv, const SkPaint& paint) {
 388     SkASSERT(fOrigBitmap.width() && fOrigBitmap.height());
 389
 390     fBitmap = NULL;
 391     fInvMatrix = inv;
 392     fFilterLevel = paint.getFilterLevel();
 393
 394     SkASSERT(NULL == fScaledCacheID);
 395
 396     // possiblyScaleImage will look to see if it can rescale the image as a
 397     // preprocess; either by scaling up to the target size, or by selecting
 398     // a nearby mipmap level.  If it does, it will adjust the working
 399     // matrix as well as the working bitmap.  It may also adjust the filter
 400     // quality to avoid re-filtering an already perfectly scaled image.
 401     if (!this->possiblyScaleImage()) {
 402         if (!this->lockBaseBitmap()) {
 403             return false;
 404         }
 405     }
 406     // The above logic should have always assigned fBitmap, but in case it
 407     // didn't, we check for that now...
 408     // TODO(dominikg): Ask humper@ if we can just use an SkASSERT(fBitmap)?
 409     if (NULL == fBitmap) {
 410         return false;
 411     }
 412
 413     // If we are "still" kMedium_FilterLevel, then the request was not fulfilled by possiblyScale,
 414     // so we downgrade to kLow (so the rest of the sniffing code can assume that)
 415     if (SkPaint::kMedium_FilterLevel == fFilterLevel) {
 416         fFilterLevel = SkPaint::kLow_FilterLevel;
 417     }
 418
 419     bool trivialMatrix = (fInvMatrix.getType() & ~SkMatrix::kTranslate_Mask) == 0;
 420     bool clampClamp = SkShader::kClamp_TileMode == fTileModeX &&
 421                       SkShader::kClamp_TileMode == fTileModeY;
 422
 423     if (!(clampClamp || trivialMatrix)) {
 424         fInvMatrix.postIDiv(fOrigBitmap.width(), fOrigBitmap.height());
 425     }
 426
 427     // Now that all possible changes to the matrix have taken place, check
 428     // to see if we're really close to a no-scale matrix.  If so, explicitly
 429     // set it to be so.  Subsequent code may inspect this matrix to choose
 430     // a faster path in this case.
 431
 432     // This code will only execute if the matrix has some scale component;
 433     // if it's already pure translate then we won't do this inversion.
 434
 435     if (matrix_only_scale_translate(fInvMatrix)) {
 436         SkMatrix forward;
 437         if (fInvMatrix.invert(&forward)) {
 438             if (clampClamp ? just_trans_clamp(forward, *fBitmap)
 439                             : just_trans_general(forward)) {
 440                 SkScalar tx = -SkScalarRoundToScalar(forward.getTranslateX());
 441                 SkScalar ty = -SkScalarRoundToScalar(forward.getTranslateY());
 442                 fInvMatrix.setTranslate(tx, ty);
 443             }
 444         }
 445     }
 446
 447     fInvProc        = fInvMatrix.getMapXYProc();
 448     fInvType        = fInvMatrix.getType();
 449     fInvSx          = SkScalarToFixed(fInvMatrix.getScaleX());
 450     fInvSxFractionalInt = SkScalarToFractionalInt(fInvMatrix.getScaleX());
 451     fInvKy          = SkScalarToFixed(fInvMatrix.getSkewY());
 452     fInvKyFractionalInt = SkScalarToFractionalInt(fInvMatrix.getSkewY());
 453
 454     fAlphaScale = SkAlpha255To256(paint.getAlpha());
 455
 456     fShaderProc32 = NULL;
 457     fShaderProc16 = NULL;
 458     fSampleProc32 = NULL;
 459     fSampleProc16 = NULL;
 460
 461     // recompute the triviality of the matrix here because we may have
 462     // changed it!
 463
 464     trivialMatrix = (fInvMatrix.getType() & ~SkMatrix::kTranslate_Mask) == 0;
 465
 466     if (SkPaint::kHigh_FilterLevel == fFilterLevel) {
 467         // If this is still set, that means we wanted HQ sampling
 468         // but couldn't do it as a preprocess.  Let's try to install
 469         // the scanline version of the HQ sampler.  If that process fails,
 470         // downgrade to bilerp.
 471
 472         // NOTE: Might need to be careful here in the future when we want
 473         // to have the platform proc have a shot at this; it's possible that
 474         // the chooseBitmapFilterProc will fail to install a shader but a
 475         // platform-specific one might succeed, so it might be premature here
 476         // to fall back to bilerp.  This needs thought.
 477
 478         if (!this->setBitmapFilterProcs()) {
 479             fFilterLevel = SkPaint::kLow_FilterLevel;
 480         }
 481     }
 482
 483     if (SkPaint::kLow_FilterLevel == fFilterLevel) {
 484         // Only try bilerp if the matrix is "interesting" and
 485         // the image has a suitable size.
 486
 487         if (fInvType <= SkMatrix::kTranslate_Mask ||
 488                 !valid_for_filtering(fBitmap->width() | fBitmap->height())) {
 489             fFilterLevel = SkPaint::kNone_FilterLevel;
 490         }
 491     }
 492
 493     // At this point, we know exactly what kind of sampling the per-scanline
 494     // shader will perform.
 495
 496     fMatrixProc = this->chooseMatrixProc(trivialMatrix);
 497     // TODO(dominikg): SkASSERT(fMatrixProc) instead? chooseMatrixProc never returns NULL.
 498     if (NULL == fMatrixProc) {
 499         return false;
 500     }
 501
 502     ///////////////////////////////////////////////////////////////////////
 503
 504     // No need to do this if we're doing HQ sampling; if filter quality is
 505     // still set to HQ by the time we get here, then we must have installed
 506     // the shader procs above and can skip all this.
 507
 508     if (fFilterLevel < SkPaint::kHigh_FilterLevel) {
 509
 510         int index = 0;
 511         if (fAlphaScale < 256) {  // note: this distinction is not used for D16
 512             index |= 1;
 513         }
 514         if (fInvType <= (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)) {
 515             index |= 2;
 516         }
 517         if (fFilterLevel > SkPaint::kNone_FilterLevel) {
 518             index |= 4;
 519         }
 520         // bits 3,4,5 encoding the source bitmap format
 521         switch (fBitmap->colorType()) {
 522             case kN32_SkColorType:
 523                 index |= 0;
 524                 break;
 525             case kRGB_565_SkColorType:
 526                 index |= 8;
 527                 break;
 528             case kIndex_8_SkColorType:
 529                 index |= 16;
 530                 break;
 531             case kARGB_4444_SkColorType:
 532                 index |= 24;
 533                 break;
 534             case kAlpha_8_SkColorType:
 535                 index |= 32;
 536                 fPaintPMColor = SkPreMultiplyColor(paint.getColor());
 537                 break;
 538             default:
 539                 // TODO(dominikg): Should we ever get here? SkASSERT(false) instead?
 540                 return false;
 541         }
 542
 543     #if !SK_ARM_NEON_IS_ALWAYS
 544         static const SampleProc32 gSkBitmapProcStateSample32[] = {
 545             S32_opaque_D32_nofilter_DXDY,
 546             S32_alpha_D32_nofilter_DXDY,
 547             S32_opaque_D32_nofilter_DX,
 548             S32_alpha_D32_nofilter_DX,
 549             S32_opaque_D32_filter_DXDY,
 550             S32_alpha_D32_filter_DXDY,
 551             S32_opaque_D32_filter_DX,
 552             S32_alpha_D32_filter_DX,
 553
 554             S16_opaque_D32_nofilter_DXDY,
 555             S16_alpha_D32_nofilter_DXDY,
 556             S16_opaque_D32_nofilter_DX,
 557             S16_alpha_D32_nofilter_DX,
 558             S16_opaque_D32_filter_DXDY,
 559             S16_alpha_D32_filter_DXDY,
 560             S16_opaque_D32_filter_DX,
 561             S16_alpha_D32_filter_DX,
 562
 563             SI8_opaque_D32_nofilter_DXDY,
 564             SI8_alpha_D32_nofilter_DXDY,
 565             SI8_opaque_D32_nofilter_DX,
 566             SI8_alpha_D32_nofilter_DX,
 567             SI8_opaque_D32_filter_DXDY,
 568             SI8_alpha_D32_filter_DXDY,
 569             SI8_opaque_D32_filter_DX,
 570             SI8_alpha_D32_filter_DX,
 571
 572             S4444_opaque_D32_nofilter_DXDY,
 573             S4444_alpha_D32_nofilter_DXDY,
 574             S4444_opaque_D32_nofilter_DX,
 575             S4444_alpha_D32_nofilter_DX,
 576             S4444_opaque_D32_filter_DXDY,
 577             S4444_alpha_D32_filter_DXDY,
 578             S4444_opaque_D32_filter_DX,
 579             S4444_alpha_D32_filter_DX,
 580
 581             // A8 treats alpha/opaque the same (equally efficient)
 582             SA8_alpha_D32_nofilter_DXDY,
 583             SA8_alpha_D32_nofilter_DXDY,
 584             SA8_alpha_D32_nofilter_DX,
 585             SA8_alpha_D32_nofilter_DX,
 586             SA8_alpha_D32_filter_DXDY,
 587             SA8_alpha_D32_filter_DXDY,
 588             SA8_alpha_D32_filter_DX,
 589             SA8_alpha_D32_filter_DX
 590         };
 591
 592         static const SampleProc16 gSkBitmapProcStateSample16[] = {
 593             S32_D16_nofilter_DXDY,
 594             S32_D16_nofilter_DX,
 595             S32_D16_filter_DXDY,
 596             S32_D16_filter_DX,
 597
 598             S16_D16_nofilter_DXDY,
 599             S16_D16_nofilter_DX,
 600             S16_D16_filter_DXDY,
 601             S16_D16_filter_DX,
 602
 603             SI8_D16_nofilter_DXDY,
 604             SI8_D16_nofilter_DX,
 605             SI8_D16_filter_DXDY,
 606             SI8_D16_filter_DX,
 607
 608             // Don't support 4444 -> 565
 609             NULL, NULL, NULL, NULL,
 610             // Don't support A8 -> 565
 611             NULL, NULL, NULL, NULL
 612         };
 613     #endif
 614
 615         fSampleProc32 = SK_ARM_NEON_WRAP(gSkBitmapProcStateSample32)[index];
 616         index >>= 1;    // shift away any opaque/alpha distinction
 617         fSampleProc16 = SK_ARM_NEON_WRAP(gSkBitmapProcStateSample16)[index];
 618
 619         // our special-case shaderprocs
 620         if (SK_ARM_NEON_WRAP(S16_D16_filter_DX) == fSampleProc16) {
 621             if (clampClamp) {
 622                 fShaderProc16 = SK_ARM_NEON_WRAP(Clamp_S16_D16_filter_DX_shaderproc);
 623             } else if (SkShader::kRepeat_TileMode == fTileModeX &&
 624                        SkShader::kRepeat_TileMode == fTileModeY) {
 625                 fShaderProc16 = SK_ARM_NEON_WRAP(Repeat_S16_D16_filter_DX_shaderproc);
 626             }
 627         } else if (SK_ARM_NEON_WRAP(SI8_opaque_D32_filter_DX) == fSampleProc32 && clampClamp) {
 628             fShaderProc32 = SK_ARM_NEON_WRAP(Clamp_SI8_opaque_D32_filter_DX_shaderproc);
 629         }
 630
 631         if (NULL == fShaderProc32) {
 632             fShaderProc32 = this->chooseShaderProc32();
 633         }
 634     }
 635
 636     // see if our platform has any accelerated overrides
 637     this->platformProcs();
 638
 639     return true;
 640 }
 641
 642 static void Clamp_S32_D32_nofilter_trans_shaderproc(const SkBitmapProcState& s,
 643                                                     int x, int y,
 644                                                     SkPMColor* SK_RESTRICT colors,
 645                                                     int count) {
 646     SkASSERT(((s.fInvType & ~SkMatrix::kTranslate_Mask)) == 0);
 647     SkASSERT(s.fInvKy == 0);
 648     SkASSERT(count > 0 && colors != NULL);
 649     SkASSERT(SkPaint::kNone_FilterLevel == s.fFilterLevel);
 650
 651     const int maxX = s.fBitmap->width() - 1;
 652     const int maxY = s.fBitmap->height() - 1;
 653     int ix = s.fFilterOneX + x;
 654     int iy = SkClampMax(s.fFilterOneY + y, maxY);
 655 #ifdef SK_DEBUG
 656     {
 657         SkPoint pt;
 658         s.fInvProc(s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf,
 659                    SkIntToScalar(y) + SK_ScalarHalf, &pt);
 660         int iy2 = SkClampMax(SkScalarFloorToInt(pt.fY), maxY);
 661         int ix2 = SkScalarFloorToInt(pt.fX);
 662
 663         SkASSERT(iy == iy2);
 664         SkASSERT(ix == ix2);
 665     }
 666 #endif
 667     const SkPMColor* row = s.fBitmap->getAddr32(0, iy);
 668
 669     // clamp to the left
 670     if (ix < 0) {
 671         int n = SkMin32(-ix, count);
 672         sk_memset32(colors, row[0], n);
 673         count -= n;
 674         if (0 == count) {
 675             return;
 676         }
 677         colors += n;
 678         SkASSERT(-ix == n);
 679         ix = 0;
 680     }
 681     // copy the middle
 682     if (ix <= maxX) {
 683         int n = SkMin32(maxX - ix + 1, count);
 684         memcpy(colors, row + ix, n * sizeof(SkPMColor));
 685         count -= n;
 686         if (0 == count) {
 687             return;
 688         }
 689         colors += n;
 690     }
 691     SkASSERT(count > 0);
 692     // clamp to the right
 693     sk_memset32(colors, row[maxX], count);
 694 }
 695
 696 static inline int sk_int_mod(int x, int n) {
 697     SkASSERT(n > 0);
 698     if ((unsigned)x >= (unsigned)n) {
 699         if (x < 0) {
 700             x = n + ~(~x % n);
 701         } else {
 702             x = x % n;
 703         }
 704     }
 705     return x;
 706 }
 707
 708 static inline int sk_int_mirror(int x, int n) {
 709     x = sk_int_mod(x, 2 * n);
 710     if (x >= n) {
 711         x = n + ~(x - n);
 712     }
 713     return x;
 714 }
 715
 716 static void Repeat_S32_D32_nofilter_trans_shaderproc(const SkBitmapProcState& s,
 717                                                      int x, int y,
 718                                                      SkPMColor* SK_RESTRICT colors,
 719                                                      int count) {
 720     SkASSERT(((s.fInvType & ~SkMatrix::kTranslate_Mask)) == 0);
 721     SkASSERT(s.fInvKy == 0);
 722     SkASSERT(count > 0 && colors != NULL);
 723     SkASSERT(SkPaint::kNone_FilterLevel == s.fFilterLevel);
 724
 725     const int stopX = s.fBitmap->width();
 726     const int stopY = s.fBitmap->height();
 727     int ix = s.fFilterOneX + x;
 728     int iy = sk_int_mod(s.fFilterOneY + y, stopY);
 729 #ifdef SK_DEBUG
 730     {
 731         SkPoint pt;
 732         s.fInvProc(s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf,
 733                    SkIntToScalar(y) + SK_ScalarHalf, &pt);
 734         int iy2 = sk_int_mod(SkScalarFloorToInt(pt.fY), stopY);
 735         int ix2 = SkScalarFloorToInt(pt.fX);
 736
 737         SkASSERT(iy == iy2);
 738         SkASSERT(ix == ix2);
 739     }
 740 #endif
 741     const SkPMColor* row = s.fBitmap->getAddr32(0, iy);
 742
 743     ix = sk_int_mod(ix, stopX);
 744     for (;;) {
 745         int n = SkMin32(stopX - ix, count);
 746         memcpy(colors, row + ix, n * sizeof(SkPMColor));
 747         count -= n;
 748         if (0 == count) {
 749             return;
 750         }
 751         colors += n;
 752         ix = 0;
 753     }
 754 }
 755
 756 static void S32_D32_constX_shaderproc(const SkBitmapProcState& s,
 757                                       int x, int y,
 758                                       SkPMColor* SK_RESTRICT colors,
 759                                       int count) {
 760     SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)) == 0);
 761     SkASSERT(s.fInvKy == 0);
 762     SkASSERT(count > 0 && colors != NULL);
 763     SkASSERT(1 == s.fBitmap->width());
 764
 765     int iY0;
 766     int iY1   SK_INIT_TO_AVOID_WARNING;
 767     int iSubY SK_INIT_TO_AVOID_WARNING;
 768
 769     if (SkPaint::kNone_FilterLevel != s.fFilterLevel) {
 770         SkBitmapProcState::MatrixProc mproc = s.getMatrixProc();
 771         uint32_t xy[2];
 772
 773         mproc(s, xy, 1, x, y);
 774
 775         iY0 = xy[0] >> 18;
 776         iY1 = xy[0] & 0x3FFF;
 777         iSubY = (xy[0] >> 14) & 0xF;
 778     } else {
 779         int yTemp;
 780
 781         if (s.fInvType > SkMatrix::kTranslate_Mask) {
 782             SkPoint pt;
 783             s.fInvProc(s.fInvMatrix,
 784                        SkIntToScalar(x) + SK_ScalarHalf,
 785                        SkIntToScalar(y) + SK_ScalarHalf,
 786                        &pt);
 787             // When the matrix has a scale component the setup code in
 788             // chooseProcs multiples the inverse matrix by the inverse of the
 789             // bitmap's width and height. Since this method is going to do
 790             // its own tiling and sampling we need to undo that here.
 791             if (SkShader::kClamp_TileMode != s.fTileModeX ||
 792                 SkShader::kClamp_TileMode != s.fTileModeY) {
 793                 yTemp = SkScalarFloorToInt(pt.fY * s.fBitmap->height());
 794             } else {
 795                 yTemp = SkScalarFloorToInt(pt.fY);
 796             }
 797         } else {
 798             yTemp = s.fFilterOneY + y;
 799         }
 800
 801         const int stopY = s.fBitmap->height();
 802         switch (s.fTileModeY) {
 803             case SkShader::kClamp_TileMode:
 804                 iY0 = SkClampMax(yTemp, stopY-1);
 805                 break;
 806             case SkShader::kRepeat_TileMode:
 807                 iY0 = sk_int_mod(yTemp, stopY);
 808                 break;
 809             case SkShader::kMirror_TileMode:
 810             default:
 811                 iY0 = sk_int_mirror(yTemp, stopY);
 812                 break;
 813         }
 814
 815 #ifdef SK_DEBUG
 816         {
 817             SkPoint pt;
 818             s.fInvProc(s.fInvMatrix,
 819                        SkIntToScalar(x) + SK_ScalarHalf,
 820                        SkIntToScalar(y) + SK_ScalarHalf,
 821                        &pt);
 822             if (s.fInvType > SkMatrix::kTranslate_Mask &&
 823                 (SkShader::kClamp_TileMode != s.fTileModeX ||
 824                  SkShader::kClamp_TileMode != s.fTileModeY)) {
 825                 pt.fY *= s.fBitmap->height();
 826             }
 827             int iY2;
 828
 829             switch (s.fTileModeY) {
 830             case SkShader::kClamp_TileMode:
 831                 iY2 = SkClampMax(SkScalarFloorToInt(pt.fY), stopY-1);
 832                 break;
 833             case SkShader::kRepeat_TileMode:
 834                 iY2 = sk_int_mod(SkScalarFloorToInt(pt.fY), stopY);
 835                 break;
 836             case SkShader::kMirror_TileMode:
 837             default:
 838                 iY2 = sk_int_mirror(SkScalarFloorToInt(pt.fY), stopY);
 839                 break;
 840             }
 841
 842             SkASSERT(iY0 == iY2);
 843         }
 844 #endif
 845     }
 846
 847     const SkPMColor* row0 = s.fBitmap->getAddr32(0, iY0);
 848     SkPMColor color;
 849
 850     if (SkPaint::kNone_FilterLevel != s.fFilterLevel) {
 851         const SkPMColor* row1 = s.fBitmap->getAddr32(0, iY1);
 852
 853         if (s.fAlphaScale < 256) {
 854             Filter_32_alpha(iSubY, *row0, *row1, &color, s.fAlphaScale);
 855         } else {
 856             Filter_32_opaque(iSubY, *row0, *row1, &color);
 857         }
 858     } else {
 859         if (s.fAlphaScale < 256) {
 860             color = SkAlphaMulQ(*row0, s.fAlphaScale);
 861         } else {
 862             color = *row0;
 863         }
 864     }
 865
 866     sk_memset32(colors, color, count);
 867 }
 868
 869 static void DoNothing_shaderproc(const SkBitmapProcState&, int x, int y,
 870                                  SkPMColor* SK_RESTRICT colors, int count) {
 871     // if we get called, the matrix is too tricky, so we just draw nothing
 872     sk_memset32(colors, 0, count);
 873 }
 874
 875 bool SkBitmapProcState::setupForTranslate() {
 876     SkPoint pt;
 877     fInvProc(fInvMatrix, SK_ScalarHalf, SK_ScalarHalf, &pt);
 878
 879     /*
 880      *  if the translate is larger than our ints, we can get random results, or
 881      *  worse, we might get 0x80000000, which wreaks havoc on us, since we can't
 882      *  negate it.
 883      */
 884     const SkScalar too_big = SkIntToScalar(1 << 30);
 885     if (SkScalarAbs(pt.fX) > too_big || SkScalarAbs(pt.fY) > too_big) {
 886         return false;
 887     }
 888
 889     // Since we know we're not filtered, we re-purpose these fields allow
 890     // us to go from device -> src coordinates w/ just an integer add,
 891     // rather than running through the inverse-matrix
 892     fFilterOneX = SkScalarFloorToInt(pt.fX);
 893     fFilterOneY = SkScalarFloorToInt(pt.fY);
 894     return true;
 895 }
 896
 897 SkBitmapProcState::ShaderProc32 SkBitmapProcState::chooseShaderProc32() {
 898
 899     if (kN32_SkColorType != fBitmap->colorType()) {
 900         return NULL;
 901     }
 902
 903     static const unsigned kMask = SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask;
 904
 905     if (1 == fBitmap->width() && 0 == (fInvType & ~kMask)) {
 906         if (SkPaint::kNone_FilterLevel == fFilterLevel &&
 907             fInvType <= SkMatrix::kTranslate_Mask &&
 908             !this->setupForTranslate()) {
 909             return DoNothing_shaderproc;
 910         }
 911         return S32_D32_constX_shaderproc;
 912     }
 913
 914     if (fAlphaScale < 256) {
 915         return NULL;
 916     }
 917     if (fInvType > SkMatrix::kTranslate_Mask) {
 918         return NULL;
 919     }
 920     if (SkPaint::kNone_FilterLevel != fFilterLevel) {
 921         return NULL;
 922     }
 923
 924     SkShader::TileMode tx = (SkShader::TileMode)fTileModeX;
 925     SkShader::TileMode ty = (SkShader::TileMode)fTileModeY;
 926
 927     if (SkShader::kClamp_TileMode == tx && SkShader::kClamp_TileMode == ty) {
 928         if (this->setupForTranslate()) {
 929             return Clamp_S32_D32_nofilter_trans_shaderproc;
 930         }
 931         return DoNothing_shaderproc;
 932     }
 933     if (SkShader::kRepeat_TileMode == tx && SkShader::kRepeat_TileMode == ty) {
 934         if (this->setupForTranslate()) {
 935             return Repeat_S32_D32_nofilter_trans_shaderproc;
 936         }
 937         return DoNothing_shaderproc;
 938     }
 939     return NULL;
 940 }
 941
 942 ///////////////////////////////////////////////////////////////////////////////
 943
 944 #ifdef SK_DEBUG
 945
 946 static void check_scale_nofilter(uint32_t bitmapXY[], int count,
 947                                  unsigned mx, unsigned my) {
 948     unsigned y = *bitmapXY++;
 949     SkASSERT(y < my);
 950
 951     const uint16_t* xptr = reinterpret_cast<const uint16_t*>(bitmapXY);
 952     for (int i = 0; i < count; ++i) {
 953         SkASSERT(xptr[i] < mx);
 954     }
 955 }
 956
 957 static void check_scale_filter(uint32_t bitmapXY[], int count,
 958                                  unsigned mx, unsigned my) {
 959     uint32_t YY = *bitmapXY++;
 960     unsigned y0 = YY >> 18;
 961     unsigned y1 = YY & 0x3FFF;
 962     SkASSERT(y0 < my);
 963     SkASSERT(y1 < my);
 964
 965     for (int i = 0; i < count; ++i) {
 966         uint32_t XX = bitmapXY[i];
 967         unsigned x0 = XX >> 18;
 968         unsigned x1 = XX & 0x3FFF;
 969         SkASSERT(x0 < mx);
 970         SkASSERT(x1 < mx);
 971     }
 972 }
 973
 974 static void check_affine_nofilter(uint32_t bitmapXY[], int count,
 975                                  unsigned mx, unsigned my) {
 976     for (int i = 0; i < count; ++i) {
 977         uint32_t XY = bitmapXY[i];
 978         unsigned x = XY & 0xFFFF;
 979         unsigned y = XY >> 16;
 980         SkASSERT(x < mx);
 981         SkASSERT(y < my);
 982     }
 983 }
 984
 985 static void check_affine_filter(uint32_t bitmapXY[], int count,
 986                                  unsigned mx, unsigned my) {
 987     for (int i = 0; i < count; ++i) {
 988         uint32_t YY = *bitmapXY++;
 989         unsigned y0 = YY >> 18;
 990         unsigned y1 = YY & 0x3FFF;
 991         SkASSERT(y0 < my);
 992         SkASSERT(y1 < my);
 993
 994         uint32_t XX = *bitmapXY++;
 995         unsigned x0 = XX >> 18;
 996         unsigned x1 = XX & 0x3FFF;
 997         SkASSERT(x0 < mx);
 998         SkASSERT(x1 < mx);
 999     }
1000 }
1001
1002 void SkBitmapProcState::DebugMatrixProc(const SkBitmapProcState& state,
1003                                         uint32_t bitmapXY[], int count,
1004                                         int x, int y) {
1005     SkASSERT(bitmapXY);
1006     SkASSERT(count > 0);
1007
1008     state.fMatrixProc(state, bitmapXY, count, x, y);
1009
1010     void (*proc)(uint32_t bitmapXY[], int count, unsigned mx, unsigned my);
1011
1012     // There are four formats possible:
1013     //  scale -vs- affine
1014     //  filter -vs- nofilter
1015     if (state.fInvType <= (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)) {
1016         proc = state.fFilterLevel != SkPaint::kNone_FilterLevel ? check_scale_filter : check_scale_nofilter;
1017     } else {
1018         proc = state.fFilterLevel != SkPaint::kNone_FilterLevel ? check_affine_filter : check_affine_nofilter;
1019     }
1020     proc(bitmapXY, count, state.fBitmap->width(), state.fBitmap->height());
1021 }
1022
1023 SkBitmapProcState::MatrixProc SkBitmapProcState::getMatrixProc() const {
1024     return DebugMatrixProc;
1025 }
1026
1027 #endif
1028
1029 ///////////////////////////////////////////////////////////////////////////////
1030 /*
1031     The storage requirements for the different matrix procs are as follows,
1032     where each X or Y is 2 bytes, and N is the number of pixels/elements:
1033
1034     scale/translate     nofilter      Y(4bytes) + N * X
1035     affine/perspective  nofilter      N * (X Y)
1036     scale/translate     filter        Y Y + N * (X X)
1037     affine/perspective  filter        N * (Y Y X X)
1038  */
1039 int SkBitmapProcState::maxCountForBufferSize(size_t bufferSize) const {
1040     int32_t size = static_cast<int32_t>(bufferSize);
1041
1042     size &= ~3; // only care about 4-byte aligned chunks
1043     if (fInvType <= (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)) {
1044         size -= 4;   // the shared Y (or YY) coordinate
1045         if (size < 0) {
1046             size = 0;
1047         }
1048         size >>= 1;
1049     } else {
1050         size >>= 2;
1051     }
1052
1053     if (fFilterLevel != SkPaint::kNone_FilterLevel) {
1054         size >>= 1;
1055     }
1056
1057     return size;
1058 }