add new copyTo version to SkBitmap, which takes SkColorType

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 964 matching lines @@
     // we know we're good, so commit to result
     result->swap(dst);
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkCanvas.h"
 #include "SkPaint.h"
 
-bool SkBitmap::canCopyTo(Config dstConfig) const {
-    if (this->config() == kNo_Config) {
+#ifdef SK_SUPPORT_LEGACY_COPYTO_CONFIG
+bool SkBitmap::copyTo(SkBitmap* dst, Config c, Allocator* allocator) const {
+    return this->copyTo(dst, SkBitmapConfigToSkColorType(c), allocator);
+}
+
+bool SkBitmap::canCopyTo(Config newConfig) const {
+    return this->canCopyTo(SkBitmapConfigToSkColorType(c));
+}
+#endif
+
+bool SkBitmap::canCopyTo(SkColorType dstColorType) const {
+    if (this->colorType() == kUnknown_SkColorType) {
         return false;
     }
 
-    bool sameConfigs = (this->config() == dstConfig);
-    switch (dstConfig) {
-        case kA8_Config:
-        case kRGB_565_Config:
-        case kARGB_8888_Config:
+    bool sameConfigs = (this->colorType() == dstColorType);
+    switch (dstColorType) {
+        case kAlpha_8_SkColorType:
+        case kRGB_565_SkColorType:
+        case kPMColor_SkColorType:
             break;
-        case kIndex8_Config:
+        case kIndex_8_SkColorType:
             if (!sameConfigs) {
                 return false;
             }
             break;
-        case kARGB_4444_Config:
-            return sameConfigs || kARGB_8888_Config == this->config();
+        case kARGB_4444_SkColorType:
+            return sameConfigs || kPMColor_SkColorType == this->colorType();
         default:
             return false;
     }
     return true;
 }
 
-bool SkBitmap::copyTo(SkBitmap* dst, Config dstConfig, Allocator* alloc) const {
-    if (!this->canCopyTo(dstConfig)) {
+bool SkBitmap::copyTo(SkBitmap* dst, SkColorType dstColorType,
+                      Allocator* alloc) const {
+    if (!this->canCopyTo(dstColorType)) {
         return false;
     }
 
     // if we have a texture, first get those pixels
     SkBitmap tmpSrc;
     const SkBitmap* src = this;
 
     if (fPixelRef) {
         SkIRect subset;
         subset.setXYWH(fPixelRefOrigin.fX, fPixelRefOrigin.fY,
                        fInfo.width(), fInfo.height());
         if (fPixelRef->readPixels(&tmpSrc, &subset)) {
             SkASSERT(tmpSrc.width() == this->width());
             SkASSERT(tmpSrc.height() == this->height());
 
             // did we get lucky and we can just return tmpSrc?
-            if (tmpSrc.config() == dstConfig && NULL == alloc) {
+            if (tmpSrc.colorType() == dstColorType && NULL == alloc) {
                 dst->swap(tmpSrc);
                 // If the result is an exact copy, clone the gen ID.
                 if (dst->pixelRef() && dst->pixelRef()->info() == fPixelRef->info()) {
                     dst->pixelRef()->cloneGenID(*fPixelRef);
                 }
                 return true;
             }
 
             // fall through to the raster case
             src = &tmpSrc;
         }
     }
 
     // we lock this now, since we may need its colortable
     SkAutoLockPixels srclock(*src);
     if (!src->readyToDraw()) {
         return false;
     }
 
     // The only way to be readyToDraw is if fPixelRef is non NULL.
     SkASSERT(fPixelRef != NULL);
 
+    SkImageInfo dstInfo = src->info();
+    dstInfo.fColorType = dstColorType;
+
     SkBitmap tmpDst;
-    tmpDst.setConfig(dstConfig, src->width(), src->height(), 0,
-                     src->alphaType());
+    if (!tmpDst.setConfig(dstInfo)) {
+        return false;
+    }
 
     // allocate colortable if srcConfig == kIndex8_Config
-    SkColorTable* ctable = (dstConfig == kIndex8_Config) ?
-    new SkColorTable(*src->getColorTable()) : NULL;
-    SkAutoUnref au(ctable);
+    SkAutoTUnref<SkColorTable> ctable;
+    if (dstColorType == kIndex_8_SkColorType) {
+        // TODO: can we just ref() the src colortable? Is it reentrant-safe?
+        ctable.reset(SkNEW_ARGS(SkColorTable, (*src->getColorTable())));
+    }
     if (!tmpDst.allocPixels(alloc, ctable)) {
         return false;
     }
 
     if (!tmpDst.readyToDraw()) {
         // allocator/lock failed
         return false;
     }
 
     // pixelRef must be non NULL or tmpDst.readyToDraw() would have
     // returned false.
     SkASSERT(tmpDst.pixelRef() != NULL);
 
     /* do memcpy for the same configs cases, else use drawing
     */
-    if (src->config() == dstConfig) {
+    if (src->colorType() == dstColorType) {
         if (tmpDst.getSize() == src->getSize()) {
             memcpy(tmpDst.getPixels(), src->getPixels(), src->getSafeSize());
             SkPixelRef* pixelRef = tmpDst.pixelRef();
 
             // In order to reach this point, we know that the width, config and
             // rowbytes of the SkPixelRefs are the same, but it is possible for
             // the heights to differ, if this SkBitmap's height is a subset of
             // fPixelRef. Only if the SkPixelRefs' heights match are we
             // guaranteed that this is an exact copy, meaning we should clone
             // the genID.
@@ skipping 11 matching lines @@
             const char* srcP = reinterpret_cast<const char*>(src->getPixels());
             char* dstP = reinterpret_cast<char*>(tmpDst.getPixels());
             // to be sure we don't read too much, only copy our logical pixels
             size_t bytesToCopy = tmpDst.width() * tmpDst.bytesPerPixel();
             for (int y = 0; y < tmpDst.height(); y++) {
                 memcpy(dstP, srcP, bytesToCopy);
                 srcP += src->rowBytes();
                 dstP += tmpDst.rowBytes();
             }
         }
-    } else if (SkBitmap::kARGB_4444_Config == dstConfig
-               && SkBitmap::kARGB_8888_Config == src->config()) {
+    } else if (kARGB_4444_SkColorType == dstColorType
+               && kPMColor_SkColorType == src->colorType()) {
         SkASSERT(src->height() == tmpDst.height());
         SkASSERT(src->width() == tmpDst.width());
         for (int y = 0; y < src->height(); ++y) {
             SkPMColor16* SK_RESTRICT dstRow = (SkPMColor16*) tmpDst.getAddr16(0, y);
             SkPMColor* SK_RESTRICT srcRow = (SkPMColor*) src->getAddr32(0, y);
             DITHER_4444_SCAN(y);
             for (int x = 0; x < src->width(); ++x) {
                 dstRow[x] = SkDitherARGB32To4444(srcRow[x],
                                                  DITHER_VALUE(x));
             }
@@ skipping 10 matching lines @@
         canvas.drawBitmap(*src, 0, 0, &paint);
     }
 
     dst->swap(tmpDst);
     return true;
 }
 
 bool SkBitmap::deepCopyTo(SkBitmap* dst, Config dstConfig) const {
     const SkColorType dstCT = SkBitmapConfigToColorType(dstConfig);
 
-    if (!this->canCopyTo(dstConfig)) {
+    if (!this->canCopyTo(dstCT)) {
         return false;
     }
 
     // If we have a PixelRef, and it supports deep copy, use it.
     // Currently supported only by texture-backed bitmaps.
     if (fPixelRef) {
         SkPixelRef* pixelRef = fPixelRef->deepCopy(dstConfig);
         if (pixelRef) {
             uint32_t rowBytes;
             if (this->colorType() == dstCT) {
@@ skipping 14 matching lines @@
                 return false;
             }
             dst->setPixelRef(pixelRef, fPixelRefOrigin)->unref();
             return true;
         }
     }
 
     if (this->getTexture()) {
         return false;
     } else {
-        return this->copyTo(dst, dstConfig, NULL);
+        return this->copyTo(dst, dstCT, NULL);
     }
 }
 
 bool SkBitmap::deepCopyTo(SkBitmap* dst) const {
     return this->deepCopyTo(dst, this->config());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 535 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 void SkImageInfo::validate() const {
     SkASSERT(fWidth >= 0);
     SkASSERT(fHeight >= 0);
     SkASSERT(SkColorTypeIsValid(fColorType));
     SkASSERT(SkAlphaTypeIsValid(fAlphaType));
 }
 #endif