Hide fields in SkImageInfo

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 76 matching lines @@
 }
 
 void SkBitmap::reset() {
     this->freePixels();
     sk_bzero(this, sizeof(*this));
 }
 
 void SkBitmap::getBounds(SkRect* bounds) const {
     SkASSERT(bounds);
     bounds->set(0, 0,
-                SkIntToScalar(fInfo.fWidth), SkIntToScalar(fInfo.fHeight));
+                SkIntToScalar(fInfo.width()), SkIntToScalar(fInfo.height()));
 }
 
 void SkBitmap::getBounds(SkIRect* bounds) const {
     SkASSERT(bounds);
-    bounds->set(0, 0, fInfo.fWidth, fInfo.fHeight);
+    bounds->set(0, 0, fInfo.width(), fInfo.height());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-bool SkBitmap::setInfo(const SkImageInfo& origInfo, size_t rowBytes) {
-    SkImageInfo info = origInfo;
-
-    if (!SkColorTypeValidateAlphaType(info.fColorType, info.fAlphaType,
-                                      &info.fAlphaType)) {
+bool SkBitmap::setInfo(const SkImageInfo& info, size_t rowBytes) {
+    SkAlphaType newAT = info.alphaType();
+    if (!SkColorTypeValidateAlphaType(info.colorType(), info.alphaType(), &newAT)) {
         return reset_return_false(this);
     }
+    // don't look at info.alphaType(), since newAT is the real value...
 
     // require that rowBytes fit in 31bits
     int64_t mrb = info.minRowBytes64();
     if ((int32_t)mrb != mrb) {
         return reset_return_false(this);
     }
     if ((int64_t)rowBytes != (int32_t)rowBytes) {
         return reset_return_false(this);
     }
 
     if (info.width() < 0 || info.height() < 0) {
         return reset_return_false(this);
     }
 
     if (kUnknown_SkColorType == info.colorType()) {
         rowBytes = 0;
     } else if (0 == rowBytes) {
         rowBytes = (size_t)mrb;
     } else if (!info.validRowBytes(rowBytes)) {
         return reset_return_false(this);
     }
 
     this->freePixels();
 
-    fInfo = info;
+    fInfo = info.makeAlphaType(newAT);
     fRowBytes = SkToU32(rowBytes);
     return true;
 }
 
-bool SkBitmap::setAlphaType(SkAlphaType alphaType) {
-    if (!SkColorTypeValidateAlphaType(fInfo.fColorType, alphaType, &alphaType)) {
+bool SkBitmap::setAlphaType(SkAlphaType newAlphaType) {
+    if (!SkColorTypeValidateAlphaType(fInfo.colorType(), newAlphaType, &newAlphaType)) {
         return false;
     }
-    if (fInfo.fAlphaType != alphaType) {
-        fInfo.fAlphaType = alphaType;
+    if (fInfo.alphaType() != newAlphaType) {
+        fInfo = fInfo.makeAlphaType(newAlphaType);
         if (fPixelRef) {
-            fPixelRef->changeAlphaType(alphaType);
+            fPixelRef->changeAlphaType(newAlphaType);
         }
     }
     return true;
 }
 
 void SkBitmap::updatePixelsFromRef() const {
     if (NULL != fPixelRef) {
         if (fPixelLockCount > 0) {
             SkASSERT(fPixelRef->isLocked());
 
@@ skipping 11 matching lines @@
             fColorTable = NULL;
         }
     }
 }
 
 SkPixelRef* SkBitmap::setPixelRef(SkPixelRef* pr, int dx, int dy) {
 #ifdef SK_DEBUG
     if (pr) {
         if (kUnknown_SkColorType != fInfo.colorType()) {
             const SkImageInfo& prInfo = pr->info();
-            SkASSERT(fInfo.fWidth <= prInfo.fWidth);
-            SkASSERT(fInfo.fHeight <= prInfo.fHeight);
-            SkASSERT(fInfo.fColorType == prInfo.fColorType);
-            switch (prInfo.fAlphaType) {
+            SkASSERT(fInfo.width() <= prInfo.width());
+            SkASSERT(fInfo.height() <= prInfo.height());
+            SkASSERT(fInfo.colorType() == prInfo.colorType());
+            switch (prInfo.alphaType()) {
                 case kIgnore_SkAlphaType:
-                    SkASSERT(fInfo.fAlphaType == kIgnore_SkAlphaType);
+                    SkASSERT(fInfo.alphaType() == kIgnore_SkAlphaType);
                     break;
                 case kOpaque_SkAlphaType:
                 case kPremul_SkAlphaType:
-                    SkASSERT(fInfo.fAlphaType == kOpaque_SkAlphaType ||
-                             fInfo.fAlphaType == kPremul_SkAlphaType);
+                    SkASSERT(fInfo.alphaType() == kOpaque_SkAlphaType ||
+                             fInfo.alphaType() == kPremul_SkAlphaType);
                     break;
                 case kUnpremul_SkAlphaType:
-                    SkASSERT(fInfo.fAlphaType == kOpaque_SkAlphaType ||
-                             fInfo.fAlphaType == kUnpremul_SkAlphaType);
+                    SkASSERT(fInfo.alphaType() == kOpaque_SkAlphaType ||
+                             fInfo.alphaType() == kUnpremul_SkAlphaType);
                     break;
             }
         }
     }
 #endif
 
     if (pr) {
         const SkImageInfo& info = pr->info();
-        fPixelRefOrigin.set(SkPin32(dx, 0, info.fWidth),
-                            SkPin32(dy, 0, info.fHeight));
+        fPixelRefOrigin.set(SkPin32(dx, 0, info.width()), SkPin32(dy, 0, info.height()));
     } else {
         // ignore dx,dy if there is no pixelref
         fPixelRefOrigin.setZero();
     }
 
     if (fPixelRef != pr) {
         this->freePixels();
         SkASSERT(NULL == fPixelRef);
 
         SkSafeRef(pr);
@@ skipping 86 matching lines @@
     // TODO: lockPixels could/should return bool or void*/NULL
     this->lockPixels();
     if (NULL == this->getPixels()) {
         return reset_return_false(this);
     }
     return true;
 }
 
 bool SkBitmap::tryAllocPixels(const SkImageInfo& requestedInfo, SkPixelRefFactory* factory,
                                 SkColorTable* ctable) {
-    if (kIndex_8_SkColorType == requestedInfo.fColorType && NULL == ctable) {
+    if (kIndex_8_SkColorType == requestedInfo.colorType() && NULL == ctable) {
         return reset_return_false(this);
     }
     if (!this->setInfo(requestedInfo)) {
         return reset_return_false(this);
     }
 
     // setInfo may have corrected info (e.g. 565 is always opaque).
     const SkImageInfo& correctedInfo = this->info();
 
     SkMallocPixelRef::PRFactory defaultFactory;
@@ skipping 136 matching lines @@
     } else {
         // If destination has different stride than us, then copy line by line.
         if (fInfo.getSafeSize(dstRowBytes) > dstSize) {
             return false;
         } else {
             // Just copy what we need on each line.
             size_t rowBytes = fInfo.minRowBytes();
             SkAutoLockPixels lock(*this);
             const uint8_t* srcP = reinterpret_cast<const uint8_t*>(getPixels());
             uint8_t* dstP = reinterpret_cast<uint8_t*>(dst);
-            for (int row = 0; row < fInfo.fHeight;
-                 row++, srcP += fRowBytes, dstP += dstRowBytes) {
+            for (int row = 0; row < fInfo.height(); row++, srcP += fRowBytes, dstP += dstRowBytes) {
                 memcpy(dstP, srcP, rowBytes);
             }
 
             return true;
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 368 matching lines @@
     }
     if (0 == requestedDstInfo.width() || 0 == requestedDstInfo.height()) {
         return false;
     }
     
     SkIRect srcR = SkIRect::MakeXYWH(x, y, requestedDstInfo.width(), requestedDstInfo.height());
     if (!srcR.intersect(0, 0, this->width(), this->height())) {
         return false;
     }
     
-    SkImageInfo dstInfo = requestedDstInfo;
     // the intersect may have shrunk info's logical size
-    dstInfo.fWidth = srcR.width();
-    dstInfo.fHeight = srcR.height();
+    const SkImageInfo dstInfo = requestedDstInfo.makeWH(srcR.width(), srcR.height());
     
     // if x or y are negative, then we have to adjust pixels
     if (x > 0) {
         x = 0;
     }
     if (y > 0) {
         y = 0;
     }
     // here x,y are either 0 or negative
     dstPixels = ((char*)dstPixels - y * dstRB - x * dstInfo.bytesPerPixel());
 
     //////////////
     
     SkAutoLockPixels alp(*this);
     
     // since we don't stop creating un-pixeled devices yet, check for no pixels here
     if (NULL == this->getPixels()) {
         return false;
     }
     
-    SkImageInfo srcInfo = this->info();
-    srcInfo.fWidth = dstInfo.width();
-    srcInfo.fHeight = dstInfo.height();
+    const SkImageInfo srcInfo = this->info().makeWH(dstInfo.width(), dstInfo.height());
     
     const void* srcPixels = this->getAddr(srcR.x(), srcR.y());
     return SkPixelInfo::CopyPixels(dstInfo, dstPixels, dstRB, srcInfo, srcPixels, this->rowBytes(),
                                    this->getColorTable());
 }
 
 bool SkBitmap::copyTo(SkBitmap* dst, SkColorType dstColorType, Allocator* alloc) const {
     if (!this->canCopyTo(dstColorType)) {
         return false;
     }
@@ skipping 32 matching lines @@
 
     // 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;
+    const SkImageInfo dstInfo = src->info().makeColorType(dstColorType);
 
     SkBitmap tmpDst;
     if (!tmpDst.setInfo(dstInfo)) {
         return false;
     }
 
     // allocate colortable if srcConfig == kIndex8_Config
     SkAutoTUnref<SkColorTable> ctable;
     if (dstColorType == kIndex_8_SkColorType) {
         // TODO: can we just ref() the src colortable? Is it reentrant-safe?
@@ skipping 51 matching lines @@
                 // succeeded, the new pixel ref must be identical.
                 SkASSERT(fPixelRef->info() == pixelRef->info());
                 pixelRef->cloneGenID(*fPixelRef);
                 // Use the same rowBytes as the original.
                 rowBytes = fRowBytes;
             } else {
                 // With the new config, an appropriate fRowBytes will be computed by setInfo.
                 rowBytes = 0;
             }
 
-            SkImageInfo info = fInfo;
-            info.fColorType = dstCT;
+            const SkImageInfo info = fInfo.makeColorType(dstCT);
             if (!dst->setInfo(info, rowBytes)) {
                 return false;
             }
             dst->setPixelRef(pixelRef, fPixelRefOrigin)->unref();
             return true;
         }
     }
 
     if (this->getTexture()) {
         return false;
@@ skipping 307 matching lines @@
     SkASSERT(fPixelLockCount >= 0);
 
     if (fPixels) {
         SkASSERT(fPixelRef);
         SkASSERT(fPixelLockCount > 0);
         SkASSERT(fPixelRef->isLocked());
         SkASSERT(fPixelRef->rowBytes() == fRowBytes);
         SkASSERT(fPixelRefOrigin.fX >= 0);
         SkASSERT(fPixelRefOrigin.fY >= 0);
         SkASSERT(fPixelRef->info().width() >= (int)this->width() + fPixelRefOrigin.fX);
-        SkASSERT(fPixelRef->info().fHeight >= (int)this->height() + fPixelRefOrigin.fY);
+        SkASSERT(fPixelRef->info().height() >= (int)this->height() + fPixelRefOrigin.fY);
         SkASSERT(fPixelRef->rowBytes() >= fInfo.minRowBytes());
     } else {
         SkASSERT(NULL == fColorTable);
     }
 }
 #endif
 
 #ifndef SK_IGNORE_TO_STRING
 void SkBitmap::toString(SkString* str) const {
 
@@ skipping 37 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 void SkImageInfo::validate() const {
     SkASSERT(fWidth >= 0);
     SkASSERT(fHeight >= 0);
     SkASSERT(SkColorTypeIsValid(fColorType));
     SkASSERT(SkAlphaTypeIsValid(fAlphaType));
 }
 #endif