Expand pixelref to return SkImageInfo and rowbytes

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 345 matching lines @@
             SkASSERT(0 == fPixelLockCount);
             fPixels = NULL;
             if (fColorTable) {
                 fColorTable->unref();
                 fColorTable = NULL;
             }
         }
     }
 }
 
+bool SkBitmap::asImageInfo(SkImageInfo* info) const {
+    SkColorType ct;
+    switch (this->config()) {
+        case kNo_Config:
+            return false;
+        case kA8_Config:
+            ct = kAlpha_8_SkColorType;
+            break;
+        case kIndex8_Config:
+            ct = kIndex8_SkColorType;
+            break;
+        case kRGB_565_Config:
+            ct = kRGB_565_SkColorType;
+            break;
+        case kARGB_4444_Config:
+            ct = kARGB_4444_SkColorType;
+            break;
+        case kARGB_8888_Config:
+            ct = kPMColor_SkColorType;
+            break;
+    }
+    if (info) {
+        info->fWidth = fWidth;
+        info->fHeight = fHeight;
+        info->fAlphaType = this->alphaType();
+        info->fColorType = ct;
+    }
+    return true;
+}
+
 SkPixelRef* SkBitmap::setPixelRef(SkPixelRef* pr, size_t offset) {
     // do this first, we that we never have a non-zero offset with a null ref
     if (NULL == pr) {
         offset = 0;
     }
 
     if (fPixelRef != pr || fPixelRefOffset != offset) {
         if (fPixelRef != pr) {
             this->freePixels();
             SkASSERT(NULL == fPixelRef);
@@ skipping 30 matching lines @@
 bool SkBitmap::lockPixelsAreWritable() const {
     return (fPixelRef) ? fPixelRef->lockPixelsAreWritable() : false;
 }
 
 void SkBitmap::setPixels(void* p, SkColorTable* ctable) {
     if (NULL == p) {
         this->setPixelRef(NULL, 0);
         return;
     }
 
-    Sk64 size = this->getSize64();
-    SkASSERT(!size.isNeg() && size.is32());
+    SkImageInfo info;
+    if (!this->asImageInfo(&info)) {
+        this->setPixelRef(NULL, 0);
+        return;
+    }
 
-    this->setPixelRef(new SkMallocPixelRef(p, size.get32(), ctable, false))->unref();
+    SkPixelRef* pr = SkMallocPixelRef::NewDirect(info, p, fRowBytes, ctable);
+    if (NULL == pr) {
+        this->setPixelRef(NULL, 0);
+        return;
+    }
+
+    this->setPixelRef(pr)->unref();
+
     // since we're already allocated, we lockPixels right away
     this->lockPixels();
     SkDEBUGCODE(this->validate();)
 }
 
 bool SkBitmap::allocPixels(Allocator* allocator, SkColorTable* ctable) {
     HeapAllocator stdalloc;
 
     if (NULL == allocator) {
         allocator = &stdalloc;
@@ skipping 44 matching lines @@
     return fPixelRef ? fPixelRef->getTexture() : NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /** We explicitly use the same allocator for our pixels that SkMask does,
  so that we can freely assign memory allocated by one class to the other.
  */
 bool SkBitmap::HeapAllocator::allocPixelRef(SkBitmap* dst,
                                             SkColorTable* ctable) {
-    Sk64 size = dst->getSize64();
-    if (size.isNeg() || !size.is32()) {
+    SkImageInfo info;
+    if (!dst->asImageInfo(&info)) {
+//        SkDebugf("unsupported config for info %d\n", dst->config());
+        return false;
+    }
+    
+    SkPixelRef* pr = SkMallocPixelRef::NewAllocate(info, dst->rowBytes(),
+                                                   ctable);
+    if (NULL == pr) {
         return false;
     }
 
-    void* addr = sk_malloc_flags(size.get32(), 0);  // returns NULL on failure
-    if (NULL == addr) {
-        return false;
-    }
-
-    dst->setPixelRef(new SkMallocPixelRef(addr, size.get32(), ctable))->unref();
+    dst->setPixelRef(pr, 0)->unref();
     // since we're already allocated, we lockPixels right away
     dst->lockPixels();
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 size_t SkBitmap::getSafeSize() const {
     // This is intended to be a size_t version of ComputeSafeSize64(), just
     // faster. The computation is meant to be identical.
@@ skipping 1081 matching lines @@
     fHeight = height;
     fYPtrs = (uint8_t**)sk_calloc_throw(height * sizeof(uint8_t*));
 }
 
 SkBitmap::RLEPixels::~RLEPixels() {
     sk_free(fYPtrs);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+void SkImageInfo::read(SkFlattenableReadBuffer& buffer) {
+    fWidth = buffer.read32();
+    fHeight = buffer.read32();
+
+    uint32_t packed = buffer.read32();
+    SkASSERT(0 == (packed >> 16));
+    fAlphaType = (SkAlphaType)((packed >> 8) & 0xFF);
+    fColorType = (SkColorType)((packed >> 0) & 0xFF);
+}
+
+void SkImageInfo::write(SkFlattenableWriteBuffer& buffer) const {
+    buffer.write32(fWidth);
+    buffer.write32(fHeight);
+
+    SkASSERT(0 == (fAlphaType & ~0xFF));
+    SkASSERT(0 == (fColorType & ~0xFF));
+    uint32_t packed = (fAlphaType << 8) | fColorType;
+    buffer.write32(packed);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 #ifdef SK_DEBUG
 void SkBitmap::validate() const {
     SkASSERT(fConfig < kConfigCount);
     SkASSERT(fRowBytes >= (unsigned)ComputeRowBytes((Config)fConfig, fWidth));
     uint8_t allFlags = kImageIsOpaque_Flag | kImageIsVolatile_Flag | kImageIsImmutable_Flag;
 #ifdef SK_BUILD_FOR_ANDROID
     allFlags |= kHasHardwareMipMap_Flag;
 #endif
     SkASSERT(fFlags <= allFlags);
     SkASSERT(fPixelLockCount >= 0);
@@ skipping 45 matching lines @@
         if (NULL != uri) {
             str->appendf(" uri:\"%s\"", uri);
         } else {
             str->appendf(" pixelref:%p", pr);
         }
     }
 
     str->append(")");
 }
 #endif