replace config() with colorType()

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 "SkBitmapProcState.h"
 #include "SkColorPriv.h"
 #include "SkFilterProc.h"
@@ skipping 128 matching lines @@
     if (fFilterLevel <= SkPaint::kLow_FilterLevel) {
         return false;
     }
 
     // Check to see if the transformation 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 (SkPaint::kHigh_FilterLevel == fFilterLevel &&
         fInvMatrix.getType() <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask) &&
-        fOrigBitmap.config() == SkBitmap::kARGB_8888_Config) {
+        kN32_SkColorType == fOrigBitmap.colorType()) {
 
         SkScalar invScaleX = fInvMatrix.getScaleX();
         SkScalar invScaleY = fInvMatrix.getScaleY();
 
         fScaledCacheID = SkScaledImageCache::FindAndLock(fOrigBitmap,
                                                          invScaleX, invScaleY,
                                                          &fScaledBitmap);
         if (fScaledCacheID) {
             fScaledBitmap.lockPixels();
             if (!fScaledBitmap.getPixels()) {
@@ skipping 111 matching lines @@
             SkASSERT(mip);
         }
 
         if (mip) {
             SkScalar levelScale = SkScalarInvert(SkScalarSqrt(scaleSqd));
             SkMipMap::Level level;
             if (mip->extractLevel(levelScale, &level)) {
                 SkScalar invScaleFixup = level.fScale;
                 fInvMatrix.postScale(invScaleFixup, invScaleFixup);
 
-                fScaledBitmap.setConfig(fOrigBitmap.config(),
-                                        level.fWidth, level.fHeight,
-                                        level.fRowBytes);
-                fScaledBitmap.setPixels(level.fPixels);
+                SkImageInfo info = fOrigBitmap.info();
+                info.fWidth = level.fWidth;
+                info.fHeight = level.fHeight;
+                fScaledBitmap.installPixels(info, level.fPixels, level.fRowBytes);
                 fBitmap = &fScaledBitmap;
                 fFilterLevel = SkPaint::kLow_FilterLevel;
                 unlocker.release();
                 return true;
             }
         }
     }
 
     return false;
 }
@@ skipping 199 matching lines @@
         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 > SkPaint::kNone_FilterLevel) {
             index |= 4;
         }
         // bits 3,4,5 encoding the source bitmap format
-        switch (fBitmap->config()) {
-            case SkBitmap::kARGB_8888_Config:
+        switch (fBitmap->colorType()) {
+            case kN32_SkColorType:
                 index |= 0;
                 break;
-            case SkBitmap::kRGB_565_Config:
+            case kRGB_565_SkColorType:
                 index |= 8;
                 break;
-            case SkBitmap::kIndex8_Config:
+            case kIndex_8_SkColorType:
                 index |= 16;
                 break;
-            case SkBitmap::kARGB_4444_Config:
+            case kARGB_4444_SkColorType:
                 index |= 24;
                 break;
-            case SkBitmap::kA8_Config:
+            case kAlpha_8_SkColorType:
                 index |= 32;
                 fPaintPMColor = SkPreMultiplyColor(paint.getColor());
                 break;
             default:
                 // TODO(dominikg): Should we ever get here? SkASSERT(false) instead?
                 return false;
         }
 
     #if !SK_ARM_NEON_IS_ALWAYS
         static const SampleProc32 gSkBitmapProcStateSample32[] = {
@@ skipping 343 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() {
 

[robertphillips, 2014/05/29 12:13:42]

4?

[reed1, 2014/05/29 12:31:23]

Was waffling about supporting both swizzles of 32bit. Will change back for now.

[reed1, 2014/05/29 12:33:34]

and yes, if I'm going to count bytes, I should count bytes, not bits.

-    if (SkBitmap::kARGB_8888_Config != fBitmap->config()) {
+    if (32 != fBitmap->bytesPerPixel()) {
         return NULL;
     }
 
     static const unsigned kMask = SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask;
 
     if (1 == fBitmap->width() && 0 == (fInvType & ~kMask)) {
         if (SkPaint::kNone_FilterLevel == fFilterLevel &&
             fInvType <= SkMatrix::kTranslate_Mask &&
             !this->setupForTranslate()) {
             return DoNothing_shaderproc;
@@ skipping 139 matching lines @@
     } else {
         size >>= 2;
     }
 
     if (fFilterLevel != SkPaint::kNone_FilterLevel) {
         size >>= 1;
     }
 
     return size;
 }