add bitmap::eraseArea

src/core/SkBitmap.cpp

 
 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkBitmap.h"
@@ skipping 721 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 static uint16_t pack_8888_to_4444(unsigned a, unsigned r, unsigned g, unsigned b) {
     unsigned pixel = (SkA32To4444(a) << SK_A4444_SHIFT) |
                      (SkR32To4444(r) << SK_R4444_SHIFT) |
                      (SkG32To4444(g) << SK_G4444_SHIFT) |
                      (SkB32To4444(b) << SK_B4444_SHIFT);
     return SkToU16(pixel);
 }
 
-void SkBitmap::eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) const {
+void SkBitmap::internalErase(const SkIRect& area,
+                             U8CPU a, U8CPU r, U8CPU g, U8CPU b) const {
+#ifdef SK_DEBUG
     SkDEBUGCODE(this->validate();)
+    SkASSERT(!area.isEmpty());
+    {
+        SkIRect total = { 0, 0, fWidth, fHeight };
+        SkASSERT(total.contains(area));
+    }
+#endif
 
-    if (0 == fWidth || 0 == fHeight ||
-            kNo_Config == fConfig || kIndex8_Config == fConfig) {
+    if (kNo_Config == fConfig || kIndex8_Config == fConfig) {
         return;
     }
 
     SkAutoLockPixels alp(*this);
     // perform this check after the lock call
     if (!this->readyToDraw()) {
         return;
     }
 
-    int height = fHeight;
-    const int width = fWidth;
+    int height = area.height();
+    const int width = area.width();
     const int rowBytes = fRowBytes;
 
     // make rgb premultiplied
     if (255 != a) {
         r = SkAlphaMul(r, a);
         g = SkAlphaMul(g, a);
         b = SkAlphaMul(b, a);
     }
 
     switch (fConfig) {
         case kA1_Config: {
-            uint8_t* p = (uint8_t*)fPixels;
-            const int count = (width + 7) >> 3;
+            uint8_t* p = this->getAddr1(area.fLeft, area.fTop);
+            const int left = area.fLeft >> 3;
+            const int right = area.fRight >> 3;
+            
+            int middle = right - left - 1;
+
+            uint8_t leftMask = 0xFF >> (area.fLeft & 7);
+            uint8_t rightMask = ~(0xFF >> (area.fRight & 7));
+            if (left == right) {
+                leftMask &= rightMask;
+                rightMask = 0;
+            }
+
             a = (a >> 7) ? 0xFF : 0;
-            SkASSERT(count <= rowBytes);
             while (--height >= 0) {
-                memset(p, a, count);
-                p += rowBytes;
+                uint8_t* startP = p;
+
+                *p = (*p & ~leftMask) | (a & leftMask);
+                p++;
+                if (middle > 0) {
+                    memset(p, a, middle);
+                    p += middle;
+                }
+                if (rightMask) {
+                    *p = (*p & ~rightMask) | (a & rightMask);
+                }
+                
+                p = startP + rowBytes;
             }
             break;
         }
         case kA8_Config: {
-            uint8_t* p = (uint8_t*)fPixels;
+            uint8_t* p = this->getAddr8(area.fLeft, area.fTop);
             while (--height >= 0) {
                 memset(p, a, width);
                 p += rowBytes;
             }
             break;
         }
         case kARGB_4444_Config:
         case kRGB_565_Config: {
-            uint16_t* p = (uint16_t*)fPixels;
+            uint16_t* p = this->getAddr16(area.fLeft, area.fTop);;
             uint16_t v;
 
             if (kARGB_4444_Config == fConfig) {
                 v = pack_8888_to_4444(a, r, g, b);
             } else {
                 v = SkPackRGB16(r >> (8 - SK_R16_BITS),
                                 g >> (8 - SK_G16_BITS),
                                 b >> (8 - SK_B16_BITS));
             }
             while (--height >= 0) {
                 sk_memset16(p, v, width);
                 p = (uint16_t*)((char*)p + rowBytes);
             }
             break;
         }
         case kARGB_8888_Config: {
-            uint32_t* p = (uint32_t*)fPixels;
+            uint32_t* p = this->getAddr32(area.fLeft, area.fTop);
             uint32_t  v = SkPackARGB32(a, r, g, b);
 
             while (--height >= 0) {
                 sk_memset32(p, v, width);
                 p = (uint32_t*)((char*)p + rowBytes);
             }
             break;
         }
     }
 
     this->notifyPixelsChanged();
 }
 
+void SkBitmap::eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) const {
+    SkIRect area = { 0, 0, fWidth, fHeight };
+    if (!area.isEmpty()) {
+        this->internalErase(area, a, r, g, b);
+    }
+}
+
+void SkBitmap::eraseArea(const SkIRect& rect, SkColor c) const {
+    SkIRect area = { 0, 0, fWidth, fHeight };
+    if (area.intersect(rect)) {
+        this->internalErase(area, SkColorGetA(c), SkColorGetR(c),
+                            SkColorGetG(c), SkColorGetB(c));
+    }
+}
+
 //////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////
 
 #define SUB_OFFSET_FAILURE  ((size_t)-1)
 
 /**
  *  Based on the Config and rowBytes() of bm, return the offset into an SkPixelRef of the pixel at
  *  (x, y).
  *  Note that the SkPixelRef does not need to be set yet. deepCopyTo takes advantage of this fact.
  *  Also note that (x, y) may be outside the range of (0 - width(), 0 - height()), so long as it is
@@ skipping 813 matching lines @@
         if (NULL != uri) {
             str->appendf(" uri:\"%s\"", uri);
         } else {
             str->appendf(" pixelref:%p", pr);
         }
     }
 
     str->append(")");
 }
 #endif