From: commit-bot@chromium.org Date: Wed, 11 Dec 2013 20:55:41 +0000 (+0000) Subject: Revert of https://codereview.chromium.org/108773003/ X-Git-Tag: submit/tizen/20180928.044319~9712 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=ff9c6c92e5f962b34f7421e67ac112f81a018bd3;p=platform%2Fupstream%2FlibSkiaSharp.git Revert of https://codereview.chromium.org/108773003/ Reason for revert: breaks chrome-mac-tests TBR= NOTREECHECKS=true NOTRY=true Author: reed@google.com Review URL: https://codereview.chromium.org/113193003 git-svn-id: http://skia.googlecode.com/svn/trunk@12629 2bbb7eff-a529-9590-31e7-b0007b416f81 --- diff --git a/include/core/SkBitmapDevice.h b/include/core/SkBitmapDevice.h index f3d40d0ce8..83f480c60c 100644 --- a/include/core/SkBitmapDevice.h +++ b/include/core/SkBitmapDevice.h @@ -258,8 +258,6 @@ private: friend class SkSurface_Raster; - void init(SkBitmap::Config config, int width, int height, bool isOpaque); - // used to change the backend's pixels (and possibly config/rowbytes) // but cannot change the width/height, so there should be no change to // any clip information. diff --git a/include/core/SkMallocPixelRef.h b/include/core/SkMallocPixelRef.h index 5ef70d69bc..100a15d90a 100644 --- a/include/core/SkMallocPixelRef.h +++ b/include/core/SkMallocPixelRef.h @@ -17,52 +17,33 @@ */ class SkMallocPixelRef : public SkPixelRef { public: - /** - * Return a new SkMallocPixelRef with the provided pixel storage, rowBytes, - * and optional colortable. The caller is responsible for managing the - * lifetime of the pixel storage buffer, as the pixelref will not try - * to delete the storage. - * - * This pixelref will ref() the specified colortable (if not NULL). - * - * Returns NULL on failure. + /** Allocate the specified buffer for pixels. The memory is freed when the + last owner of this pixelref is gone. If addr is NULL, sk_malloc_throw() + is called to allocate it. */ - static SkMallocPixelRef* NewDirect(const SkImageInfo&, void* addr, - size_t rowBytes, SkColorTable*); - - /** - * Return a new SkMallocPixelRef, automatically allocating storage for the - * pixels. If rowBytes are 0, an optimal value will be chosen automatically. - * If rowBytes is > 0, then it will be respected, or NULL will be returned - * if rowBytes is invalid for the specified info. - * - * This pixelref will ref() the specified colortable (if not NULL). - * - * Returns NULL on failure. - */ - static SkMallocPixelRef* NewAllocate(const SkImageInfo& info, - size_t rowBytes, SkColorTable*); + SkMallocPixelRef(void* addr, size_t size, SkColorTable* ctable, bool ownPixels = true); + virtual ~SkMallocPixelRef(); void* getAddr() const { return fStorage; } SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkMallocPixelRef) protected: - virtual bool onNewLockPixels(LockRec*) SK_OVERRIDE; - virtual void onUnlockPixels() SK_OVERRIDE; - virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE; - virtual size_t getAllocatedSizeInBytes() const SK_OVERRIDE; + // overrides from SkPixelRef + virtual void* onLockPixels(SkColorTable**); + virtual void onUnlockPixels(); SkMallocPixelRef(SkFlattenableReadBuffer& buffer); - SkMallocPixelRef(const SkImageInfo&, void* addr, size_t rb, SkColorTable*, - bool ownsPixels); - virtual ~SkMallocPixelRef(); + virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE; + + // Returns the allocation size for the pixels + virtual size_t getAllocatedSizeInBytes() const SK_OVERRIDE { return fSize; } private: - void* fStorage; - SkColorTable* fCTable; - size_t fRB; - const bool fOwnPixels; + void* fStorage; + size_t fSize; + SkColorTable* fCTable; + bool fOwnPixels; typedef SkPixelRef INHERITED; }; diff --git a/include/core/SkPicture.h b/include/core/SkPicture.h index cd6b3bcbb1..bce343ec04 100644 --- a/include/core/SkPicture.h +++ b/include/core/SkPicture.h @@ -220,11 +220,10 @@ protected: // V14: Add flags word to PathRef serialization // V15: Remove A1 bitmpa config (and renumber remaining configs) // V16: Move SkPath's isOval flag to SkPathRef - // V17: Changes to PixelRef to store SkImageInfo #ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V16_AND_ALL_OTHER_INSTANCES_TOO static const uint32_t PRIOR_PICTURE_VERSION = 15; // TODO: remove when .skps regenerated #endif - static const uint32_t PICTURE_VERSION = 17; + static const uint32_t PICTURE_VERSION = 16; // fPlayback, fRecord, fWidth & fHeight are protected to allow derived classes to // install their own SkPicturePlayback-derived players,SkPictureRecord-derived diff --git a/include/core/SkPixelRef.h b/include/core/SkPixelRef.h index 472599eeb3..b87b0dc114 100644 --- a/include/core/SkPixelRef.h +++ b/include/core/SkPixelRef.h @@ -14,12 +14,9 @@ #include "SkRefCnt.h" #include "SkString.h" #include "SkFlattenable.h" -#include "SkImageInfo.h" #include "SkTDArray.h" -//#define SK_SUPPORT_LEGACY_PIXELREF_CONSTRUCTOR - -#define SK_SUPPORT_LEGACY_ONLOCKPIXELS +#define SK_SUPPORT_LEGACY_PIXELREF_CONSTRUCTOR #ifdef SK_DEBUG /** @@ -70,24 +67,12 @@ public: /** Return the pixel memory returned from lockPixels, or null if the lockCount is 0. */ - void* pixels() const { return fRec.fPixels; } + void* pixels() const { return fPixels; } /** Return the current colorTable (if any) if pixels are locked, or null. */ - SkColorTable* colorTable() const { return fRec.fColorTable; } + SkColorTable* colorTable() const { return fColorTable; } - /** - * To access the actual pixels of a pixelref, it must be "locked". - * Calling lockPixels returns a LockRec struct (on success). - */ - struct LockRec { - void* fPixels; - SkColorTable* fColorTable; - size_t fRowBytes; - - void zero() { sk_bzero(this, sizeof(*this)); } - }; - /** * Returns true if the lockcount > 0 */ @@ -95,19 +80,10 @@ public: SkDEBUGCODE(int getLockCount() const { return fLockCount; }) - /** - * Call to access the pixel memory. Return true on success. Balance this - * with a call to unlockPixels(). - */ - bool lockPixels(); - - /** - * Call to access the pixel memory. On success, return true and fill out - * the specified rec. On failure, return false and ignore the rec parameter. - * Balance this with a call to unlockPixels(). - */ - bool lockPixels(LockRec* rec); - + /** Call to access the pixel memory, which is returned. Balance with a call + to unlockPixels(). + */ + void lockPixels(); /** Call to balanace a previous call to lockPixels(). Returns the pixels (or null) after the unlock. NOTE: lock calls can be nested, but the matching number of unlock calls must be made in order to free the @@ -264,28 +240,14 @@ public: void addGenIDChangeListener(GenIDChangeListener* listener); protected: -#ifdef SK_SUPPORT_LEGACY_ONLOCKPIXELS - virtual void* onLockPixels(SkColorTable**); - virtual bool onNewLockPixels(LockRec*); -#else - /** - * On success, returns true and fills out the LockRec for the pixels. On - * failure returns false and ignores the LockRec parameter. - * - * The caller will have already acquired a mutex for thread safety, so this - * method need not do that. - */ - virtual bool onNewLockPixels(LockRec*) = 0; -#endif - - /** - * Balancing the previous successful call to onNewLockPixels. The locked - * pixel address will no longer be referenced, so the subclass is free to - * move or discard that memory. - * - * The caller will have already acquired a mutex for thread safety, so this - * method need not do that. - */ + /** Called when the lockCount goes from 0 to 1. The caller will have already + acquire a mutex for thread safety, so this method need not do that. + */ + virtual void* onLockPixels(SkColorTable**) = 0; + /** Called when the lock count goes from 1 to 0. The caller will have + already acquire a mutex for thread safety, so this method need not do + that. + */ virtual void onUnlockPixels() = 0; /** Default impl returns true */ @@ -329,14 +291,14 @@ protected: // only call from constructor. Flags this to always be locked, removing // the need to grab the mutex and call onLockPixels/onUnlockPixels. // Performance tweak to avoid those calls (esp. in multi-thread use case). - void setPreLocked(void*, size_t rowBytes, SkColorTable*); + void setPreLocked(void* pixels, SkColorTable* ctable); private: SkBaseMutex* fMutex; // must remain in scope for the life of this object SkImageInfo fInfo; - - // LockRec is only valid if we're in a locked state (isLocked()) - LockRec fRec; + + void* fPixels; + SkColorTable* fColorTable; // we do not track ownership, subclass does int fLockCount; mutable uint32_t fGenerationID; diff --git a/include/gpu/GrSurface.h b/include/gpu/GrSurface.h index 15e44ab593..c401a905ff 100644 --- a/include/gpu/GrSurface.h +++ b/include/gpu/GrSurface.h @@ -15,7 +15,6 @@ class GrTexture; class GrRenderTarget; -struct SkImageInfo; class GrSurface : public GrResource { public: @@ -59,8 +58,6 @@ public: */ const GrTextureDesc& desc() const { return fDesc; } - void asImageInfo(SkImageInfo*) const; - /** * @return the texture associated with the surface, may be NULL. */ diff --git a/include/gpu/SkGr.h b/include/gpu/SkGr.h index db08548f5d..5e5ca4b72c 100644 --- a/include/gpu/SkGr.h +++ b/include/gpu/SkGr.h @@ -50,7 +50,6 @@ GR_STATIC_ASSERT((int)kIDA_GrBlendCoeff == (int)SkXfermode::kIDA_Coeff); * kUnknown_PixelConfig if the conversion cannot be done. */ GrPixelConfig SkBitmapConfig2GrPixelConfig(SkBitmap::Config); -bool GrPixelConfig2ColorType(GrPixelConfig, SkColorType*); static inline GrColor SkColor2GrColor(SkColor c) { SkPMColor pm = SkPreMultiplyColor(c); diff --git a/include/gpu/SkGrPixelRef.h b/include/gpu/SkGrPixelRef.h index 4d33b9d06b..c29c27fb3b 100644 --- a/include/gpu/SkGrPixelRef.h +++ b/include/gpu/SkGrPixelRef.h @@ -23,13 +23,14 @@ */ class SK_API SkROLockPixelsPixelRef : public SkPixelRef { public: - SkROLockPixelsPixelRef(const SkImageInfo&); + SkROLockPixelsPixelRef(); virtual ~SkROLockPixelsPixelRef(); protected: - virtual bool onNewLockPixels(LockRec*) SK_OVERRIDE; - virtual void onUnlockPixels() SK_OVERRIDE; - virtual bool onLockPixelsAreWritable() const SK_OVERRIDE; // return false; + // override from SkPixelRef + virtual void* onLockPixels(SkColorTable** ptr); + virtual void onUnlockPixels(); + virtual bool onLockPixelsAreWritable() const; // return false; private: SkBitmap fBitmap; @@ -46,6 +47,7 @@ public: * cache and would like the pixel ref to unlock it in its destructor then transferCacheLock * should be set to true. */ + SkGrPixelRef(GrSurface*, bool transferCacheLock = false); SkGrPixelRef(const SkImageInfo&, GrSurface*, bool transferCacheLock = false); virtual ~SkGrPixelRef(); diff --git a/include/images/SkImageRef.h b/include/images/SkImageRef.h index 36f95e64b2..0599a8d963 100644 --- a/include/images/SkImageRef.h +++ b/include/images/SkImageRef.h @@ -34,7 +34,7 @@ public: @param config The preferred config of the decoded bitmap. @param sampleSize Requested sampleSize for decoding. Defaults to 1. */ - SkImageRef(const SkImageInfo&, SkStreamRewindable*, int sampleSize = 1, + SkImageRef(SkStreamRewindable*, SkBitmap::Config config, int sampleSize = 1, SkBaseMutex* mutex = NULL); virtual ~SkImageRef(); @@ -72,9 +72,9 @@ protected: When these are called, we will have already acquired the mutex! */ - virtual bool onNewLockPixels(LockRec*) SK_OVERRIDE; + virtual void* onLockPixels(SkColorTable**); // override this in your subclass to clean up when we're unlocking pixels - virtual void onUnlockPixels() SK_OVERRIDE {} + virtual void onUnlockPixels() {} SkImageRef(SkFlattenableReadBuffer&, SkBaseMutex* mutex = NULL); virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE; @@ -89,6 +89,7 @@ private: SkImageDecoderFactory* fFactory; // may be null SkStreamRewindable* fStream; + SkBitmap::Config fConfig; int fSampleSize; bool fDoDither; bool fErrorInDecoding; diff --git a/include/images/SkImageRef_GlobalPool.h b/include/images/SkImageRef_GlobalPool.h index caaf2487de..3adc0f6150 100644 --- a/include/images/SkImageRef_GlobalPool.h +++ b/include/images/SkImageRef_GlobalPool.h @@ -15,7 +15,7 @@ class SkImageRef_GlobalPool : public SkImageRef { public: // if pool is null, use the global pool - SkImageRef_GlobalPool(const SkImageInfo&, SkStreamRewindable*, + SkImageRef_GlobalPool(SkStreamRewindable*, SkBitmap::Config, int sampleSize = 1); virtual ~SkImageRef_GlobalPool(); diff --git a/samplecode/SamplePicture.cpp b/samplecode/SamplePicture.cpp index 2f7d691d17..66289affe0 100644 --- a/samplecode/SamplePicture.cpp +++ b/samplecode/SamplePicture.cpp @@ -40,9 +40,7 @@ static SkBitmap load_bitmap() { if (SkImageDecoder::DecodeStream(stream, &bm, SkBitmap::kNo_Config, SkImageDecoder::kDecodeBounds_Mode)) { - SkImageInfo info; - bm.asImageInfo(&info); - SkPixelRef* pr = new SkImageRef_GlobalPool(info, stream, 1); + SkPixelRef* pr = new SkImageRef_GlobalPool(stream, bm.config(), 1); bm.setPixelRef(pr)->unref(); } } diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp index 7a7f690b2a..25a6b1dba4 100644 --- a/src/core/SkBitmap.cpp +++ b/src/core/SkBitmap.cpp @@ -453,20 +453,10 @@ void SkBitmap::setPixels(void* p, SkColorTable* ctable) { return; } - SkImageInfo info; - if (!this->asImageInfo(&info)) { - this->setPixelRef(NULL, 0); - return; - } - - SkPixelRef* pr = SkMallocPixelRef::NewDirect(info, p, fRowBytes, ctable); - if (NULL == pr) { - this->setPixelRef(NULL, 0); - return; - } - - this->setPixelRef(pr)->unref(); + Sk64 size = this->getSize64(); + SkASSERT(!size.isNeg() && size.is32()); + this->setPixelRef(new SkMallocPixelRef(p, size.get32(), ctable, false))->unref(); // since we're already allocated, we lockPixels right away this->lockPixels(); SkDEBUGCODE(this->validate();) @@ -531,19 +521,17 @@ GrTexture* SkBitmap::getTexture() const { */ bool SkBitmap::HeapAllocator::allocPixelRef(SkBitmap* dst, SkColorTable* ctable) { - SkImageInfo info; - if (!dst->asImageInfo(&info)) { -// SkDebugf("unsupported config for info %d\n", dst->config()); + Sk64 size = dst->getSize64(); + if (size.isNeg() || !size.is32()) { return false; } - - SkPixelRef* pr = SkMallocPixelRef::NewAllocate(info, dst->rowBytes(), - ctable); - if (NULL == pr) { + + void* addr = sk_malloc_flags(size.get32(), 0); // returns NULL on failure + if (NULL == addr) { return false; } - dst->setPixelRef(pr, 0)->unref(); + dst->setPixelRef(new SkMallocPixelRef(addr, size.get32(), ctable))->unref(); // since we're already allocated, we lockPixels right away dst->lockPixels(); return true; diff --git a/src/core/SkBitmapDevice.cpp b/src/core/SkBitmapDevice.cpp index 368c807511..1668618cf7 100644 --- a/src/core/SkBitmapDevice.cpp +++ b/src/core/SkBitmapDevice.cpp @@ -24,30 +24,31 @@ SkBitmapDevice::SkBitmapDevice(const SkBitmap& bitmap, const SkDeviceProperties& , fBitmap(bitmap) { } -void SkBitmapDevice::init(SkBitmap::Config config, int width, int height, bool isOpaque) { +SkBitmapDevice::SkBitmapDevice(SkBitmap::Config config, int width, int height, bool isOpaque) { fBitmap.setConfig(config, width, height, 0, isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType); - - if (SkBitmap::kNo_Config != config) { - if (!fBitmap.allocPixels()) { - // indicate failure by zeroing our bitmap - fBitmap.setConfig(config, 0, 0, 0, isOpaque ? - kOpaque_SkAlphaType : kPremul_SkAlphaType); - } else if (!isOpaque) { - fBitmap.eraseColor(SK_ColorTRANSPARENT); - } + if (!fBitmap.allocPixels()) { + fBitmap.setConfig(config, 0, 0, 0, isOpaque ? + kOpaque_SkAlphaType : kPremul_SkAlphaType); + } + if (!isOpaque) { + fBitmap.eraseColor(SK_ColorTRANSPARENT); } -} - -SkBitmapDevice::SkBitmapDevice(SkBitmap::Config config, int width, int height, bool isOpaque) { - this->init(config, width, height, isOpaque); } SkBitmapDevice::SkBitmapDevice(SkBitmap::Config config, int width, int height, bool isOpaque, const SkDeviceProperties& deviceProperties) - : SkBaseDevice(deviceProperties) -{ - this->init(config, width, height, isOpaque); + : SkBaseDevice(deviceProperties) { + + fBitmap.setConfig(config, width, height, 0, isOpaque ? + kOpaque_SkAlphaType : kPremul_SkAlphaType); + if (!fBitmap.allocPixels()) { + fBitmap.setConfig(config, 0, 0, 0, isOpaque ? + kOpaque_SkAlphaType : kPremul_SkAlphaType); + } + if (!isOpaque) { + fBitmap.eraseColor(SK_ColorTRANSPARENT); + } } SkBitmapDevice::~SkBitmapDevice() { diff --git a/src/core/SkImageFilterUtils.cpp b/src/core/SkImageFilterUtils.cpp index e535d934f8..8385fb446a 100644 --- a/src/core/SkImageFilterUtils.cpp +++ b/src/core/SkImageFilterUtils.cpp @@ -15,14 +15,8 @@ #include "SkGr.h" bool SkImageFilterUtils::WrapTexture(GrTexture* texture, int width, int height, SkBitmap* result) { - SkImageInfo info; - info.fWidth = width; - info.fHeight = height; - info.fColorType = kPMColor_SkColorType; - info.fAlphaType = kPremul_SkAlphaType; - - result->setConfig(info); - result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref(); + result->setConfig(SkBitmap::kARGB_8888_Config, width, height); + result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (texture)))->unref(); return true; } @@ -42,12 +36,8 @@ bool SkImageFilterUtils::GetInputResultGPU(SkImageFilter* filter, SkImageFilter: } else { if (filter->filterImage(proxy, src, ctm, result, offset)) { if (!result->getTexture()) { - SkImageInfo info; - if (!result->asImageInfo(&info)) { - return false; - } GrTexture* resultTex = GrLockAndRefCachedBitmapTexture(context, *result, NULL); - result->setPixelRef(new SkGrPixelRef(info, resultTex))->unref(); + result->setPixelRef(new SkGrPixelRef(resultTex))->unref(); GrUnlockAndUnrefCachedBitmapTexture(resultTex); } return true; diff --git a/src/core/SkMallocPixelRef.cpp b/src/core/SkMallocPixelRef.cpp index 613491a3aa..f229e9de34 100644 --- a/src/core/SkMallocPixelRef.cpp +++ b/src/core/SkMallocPixelRef.cpp @@ -1,105 +1,27 @@ + /* * 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 "SkMallocPixelRef.h" #include "SkBitmap.h" #include "SkFlattenableBuffers.h" -static bool check_info(const SkImageInfo& info, SkColorTable* ctable) { - if (info.fWidth < 0 || - info.fHeight < 0 || - (unsigned)info.fColorType > (unsigned)kLastEnum_SkColorType || - (unsigned)info.fAlphaType > (unsigned)kLastEnum_SkAlphaType) - { - return false; - } - - // these seem like good checks, but currently we have (at least) tests - // that expect the pixelref to succeed even when there is a mismatch - // with colortables. fix? -#if 0 - if (kIndex8_SkColorType == info.fColorType && NULL == ctable) { - return false; - } - if (kIndex8_SkColorType != info.fColorType && NULL != ctable) { - return false; - } -#endif - return true; -} - -SkMallocPixelRef* SkMallocPixelRef::NewDirect(const SkImageInfo& info, - void* addr, - size_t rowBytes, - SkColorTable* ctable) { - if (!check_info(info, ctable)) { - return NULL; - } - return SkNEW_ARGS(SkMallocPixelRef, (info, addr, rowBytes, ctable, false)); -} - -SkMallocPixelRef* SkMallocPixelRef::NewAllocate(const SkImageInfo& info, - size_t requestedRowBytes, - SkColorTable* ctable) { - if (!check_info(info, ctable)) { - return NULL; - } - - int32_t minRB = info.minRowBytes(); - if (minRB < 0) { - return NULL; // allocation will be too large - } - if (requestedRowBytes > 0 && (int32_t)requestedRowBytes < minRB) { - return NULL; // cannot meet requested rowbytes - } - - int32_t rowBytes; - if (requestedRowBytes) { - rowBytes = requestedRowBytes; - } else { - rowBytes = minRB; +SkMallocPixelRef::SkMallocPixelRef(void* storage, size_t size, + SkColorTable* ctable, bool ownPixels) { + if (NULL == storage) { + SkASSERT(ownPixels); + storage = sk_malloc_throw(size); } - - Sk64 bigSize; - bigSize.setMul(info.fHeight, rowBytes); - if (!bigSize.is32()) { - return NULL; - } - - size_t size = bigSize.get32(); - void* addr = sk_malloc_flags(size, 0); - if (NULL == addr) { - return NULL; - } - - return SkNEW_ARGS(SkMallocPixelRef, (info, addr, rowBytes, ctable, true)); -} - -/////////////////////////////////////////////////////////////////////////////// - -SkMallocPixelRef::SkMallocPixelRef(const SkImageInfo& info, void* storage, - size_t rowBytes, SkColorTable* ctable, - bool ownsPixels) - : SkPixelRef(info) - , fOwnPixels(ownsPixels) -{ - SkASSERT(check_info(info, ctable)); - SkASSERT(rowBytes >= info.minRowBytes()); - - if (kIndex_8_SkColorType != info.fColorType) { - ctable = NULL; - } - fStorage = storage; + fSize = size; fCTable = ctable; - fRB = rowBytes; SkSafeRef(ctable); - - this->setPreLocked(fStorage, fRB, fCTable); + fOwnPixels = ownPixels; + + this->setPreLocked(fStorage, fCTable); } SkMallocPixelRef::~SkMallocPixelRef() { @@ -109,30 +31,19 @@ SkMallocPixelRef::~SkMallocPixelRef() { } } -bool SkMallocPixelRef::onNewLockPixels(LockRec* rec) { - rec->fPixels = fStorage; - rec->fRowBytes = fRB; - rec->fColorTable = fCTable; - return true; +void* SkMallocPixelRef::onLockPixels(SkColorTable** ct) { + *ct = fCTable; + return fStorage; } void SkMallocPixelRef::onUnlockPixels() { // nothing to do } -size_t SkMallocPixelRef::getAllocatedSizeInBytes() const { - return this->info().getSafeSize(fRB); -} - void SkMallocPixelRef::flatten(SkFlattenableWriteBuffer& buffer) const { this->INHERITED::flatten(buffer); - buffer.write32(fRB); - - // TODO: replace this bulk write with a chunky one that can trim off any - // trailing bytes on each scanline (in case rowbytes > width*size) - size_t size = this->info().getSafeSize(fRB); - buffer.writeByteArray(fStorage, size); + buffer.writeByteArray(fStorage, fSize); buffer.writeBool(fCTable != NULL); if (fCTable) { fCTable->writeToBuffer(buffer); @@ -140,18 +51,16 @@ void SkMallocPixelRef::flatten(SkFlattenableWriteBuffer& buffer) const { } SkMallocPixelRef::SkMallocPixelRef(SkFlattenableReadBuffer& buffer) - : INHERITED(buffer, NULL) - , fOwnPixels(true) -{ - fRB = buffer.read32(); - size_t size = this->info().getSafeSize(fRB); - fStorage = sk_malloc_throw(size); - buffer.readByteArray(fStorage, size); + : INHERITED(buffer, NULL) { + fSize = buffer.getArrayCount(); + fStorage = sk_malloc_throw(fSize); + buffer.readByteArray(fStorage, fSize); if (buffer.readBool()) { fCTable = SkNEW_ARGS(SkColorTable, (buffer)); } else { fCTable = NULL; } + fOwnPixels = true; - this->setPreLocked(fStorage, fRB, fCTable); + this->setPreLocked(fStorage, fCTable); } diff --git a/src/core/SkMaskFilter.cpp b/src/core/SkMaskFilter.cpp index adfed41098..f062f135fd 100644 --- a/src/core/SkMaskFilter.cpp +++ b/src/core/SkMaskFilter.cpp @@ -349,14 +349,10 @@ bool SkMaskFilter::filterMaskGPU(GrContext* context, if (!result) { return false; } - SkAutoUnref aur(dst); - SkImageInfo info; resultBM->setConfig(srcBM.config(), dst->width(), dst->height()); - if (resultBM->asImageInfo(&info)) { - return false; - } - resultBM->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, dst)))->unref(); + resultBM->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (dst)))->unref(); + dst->unref(); return true; } diff --git a/src/core/SkPixelRef.cpp b/src/core/SkPixelRef.cpp index 60b5cfb26c..b5daf0b57a 100644 --- a/src/core/SkPixelRef.cpp +++ b/src/core/SkPixelRef.cpp @@ -82,32 +82,44 @@ void SkPixelRef::setMutex(SkBaseMutex* mutex) { // just need a > 0 value, so pick a funny one to aid in debugging #define SKPIXELREF_PRELOCKED_LOCKCOUNT 123456789 -SkPixelRef::SkPixelRef(const SkImageInfo& info) { +SkPixelRef::SkPixelRef(const SkImageInfo&, SkBaseMutex* mutex) { + this->setMutex(mutex); + fPixels = NULL; + fColorTable = NULL; // we do not track ownership of this + fLockCount = 0; + this->needsNewGenID(); + fIsImmutable = false; + fPreLocked = false; +} + +SkPixelRef::SkPixelRef(const SkImageInfo&) { this->setMutex(NULL); - fInfo = info; - fRec.zero(); + fPixels = NULL; + fColorTable = NULL; // we do not track ownership of this fLockCount = 0; this->needsNewGenID(); fIsImmutable = false; fPreLocked = false; } -SkPixelRef::SkPixelRef(const SkImageInfo& info, SkBaseMutex* mutex) { +#ifdef SK_SUPPORT_LEGACY_PIXELREF_CONSTRUCTOR +// THIS GUY IS DEPRECATED -- don't use me! +SkPixelRef::SkPixelRef(SkBaseMutex* mutex) { this->setMutex(mutex); - fInfo = info; - fRec.zero(); + fPixels = NULL; + fColorTable = NULL; // we do not track ownership of this fLockCount = 0; this->needsNewGenID(); fIsImmutable = false; fPreLocked = false; } +#endif SkPixelRef::SkPixelRef(SkFlattenableReadBuffer& buffer, SkBaseMutex* mutex) : INHERITED(buffer) { this->setMutex(mutex); - - fInfo.unflatten(buffer); - fRec.zero(); + fPixels = NULL; + fColorTable = NULL; // we do not track ownership of this fLockCount = 0; fIsImmutable = buffer.readBool(); fGenerationID = buffer.readUInt(); @@ -131,13 +143,12 @@ void SkPixelRef::cloneGenID(const SkPixelRef& that) { that.fUniqueGenerationID = false; } -void SkPixelRef::setPreLocked(void* pixels, size_t rowBytes, SkColorTable* ctable) { +void SkPixelRef::setPreLocked(void* pixels, SkColorTable* ctable) { #ifndef SK_IGNORE_PIXELREF_SETPRELOCKED // only call me in your constructor, otherwise fLockCount tracking can get // out of sync. - fRec.fPixels = pixels; - fRec.fColorTable = ctable; - fRec.fRowBytes = rowBytes; + fPixels = pixels; + fColorTable = ctable; fLockCount = SKPIXELREF_PRELOCKED_LOCKCOUNT; fPreLocked = true; #endif @@ -145,8 +156,6 @@ void SkPixelRef::setPreLocked(void* pixels, size_t rowBytes, SkColorTable* ctabl void SkPixelRef::flatten(SkFlattenableWriteBuffer& buffer) const { this->INHERITED::flatten(buffer); - - fInfo.flatten(buffer); buffer.writeBool(fIsImmutable); // We write the gen ID into the picture for within-process recording. This // is safe since the same genID will never refer to two different sets of @@ -161,27 +170,16 @@ void SkPixelRef::flatten(SkFlattenableWriteBuffer& buffer) const { } } -bool SkPixelRef::lockPixels(LockRec* rec) { +void SkPixelRef::lockPixels() { SkASSERT(!fPreLocked || SKPIXELREF_PRELOCKED_LOCKCOUNT == fLockCount); - + if (!fPreLocked) { SkAutoMutexAcquire ac(*fMutex); - + if (1 == ++fLockCount) { - LockRec rec; - if (!this->onNewLockPixels(&rec)) { - return false; - } - fRec = rec; + fPixels = this->onLockPixels(&fColorTable); } } - *rec = fRec; - return true; -} - -bool SkPixelRef::lockPixels() { - LockRec rec; - return this->lockPixels(&rec); } void SkPixelRef::unlockPixels() { @@ -193,7 +191,8 @@ void SkPixelRef::unlockPixels() { SkASSERT(fLockCount > 0); if (0 == --fLockCount) { this->onUnlockPixels(); - fRec.zero(); + fPixels = NULL; + fColorTable = NULL; } } } @@ -274,29 +273,6 @@ size_t SkPixelRef::getAllocatedSizeInBytes() const { /////////////////////////////////////////////////////////////////////////////// -#ifdef SK_SUPPORT_LEGACY_ONLOCKPIXELS - -void* SkPixelRef::onLockPixels(SkColorTable** ctable) { - return NULL; -} - -bool SkPixelRef::onNewLockPixels(LockRec* rec) { - SkColorTable* ctable; - void* pixels = this->onLockPixels(&ctable); - if (!pixels) { - return false; - } - - rec->fPixels = pixels; - rec->fColorTable = ctable; - rec->fRowBytes = 0; // callers don't currently need this (thank goodness) - return true; -} - -#endif - -/////////////////////////////////////////////////////////////////////////////// - #ifdef SK_BUILD_FOR_ANDROID void SkPixelRef::globalRef(void* data) { this->ref(); diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp index 5d200d18d3..2776199346 100644 --- a/src/effects/gradients/SkGradientShader.cpp +++ b/src/effects/gradients/SkGradientShader.cpp @@ -513,14 +513,13 @@ const uint16_t* SkGradientShaderBase::getCache16() const { const SkPMColor* SkGradientShaderBase::getCache32() const { if (fCache32 == NULL) { - SkImageInfo info; - info.fWidth = kCache32Count; - info.fHeight = 4; // for our 4 dither rows - info.fAlphaType = kPremul_SkAlphaType; - info.fColorType = kPMColor_SkColorType; + // double the count for dither entries + const int entryCount = kCache32Count * 4; + const size_t allocSize = sizeof(SkPMColor) * entryCount; if (NULL == fCache32PixelRef) { - fCache32PixelRef = SkMallocPixelRef::NewAllocate(info, 0, NULL); + fCache32PixelRef = SkNEW_ARGS(SkMallocPixelRef, + (NULL, allocSize, NULL)); } fCache32 = (SkPMColor*)fCache32PixelRef->getAddr(); if (fColorCount == 2) { @@ -542,7 +541,8 @@ const SkPMColor* SkGradientShaderBase::getCache32() const { } if (fMapper) { - SkMallocPixelRef* newPR = SkMallocPixelRef::NewAllocate(info, 0, NULL); + SkMallocPixelRef* newPR = SkNEW_ARGS(SkMallocPixelRef, + (NULL, allocSize, NULL)); SkPMColor* linear = fCache32; // just computed linear data SkPMColor* mapped = (SkPMColor*)newPR->getAddr(); // storage for mapped data SkUnitMapper* map = fMapper; diff --git a/src/gpu/GrSurface.cpp b/src/gpu/GrSurface.cpp index 1fcc4ff18b..fed95f232f 100644 --- a/src/gpu/GrSurface.cpp +++ b/src/gpu/GrSurface.cpp @@ -8,19 +8,9 @@ #include "GrSurface.h" #include "SkBitmap.h" -#include "SkGr.h" #include "SkImageEncoder.h" #include -void GrSurface::asImageInfo(SkImageInfo* info) const { - if (!GrPixelConfig2ColorType(this->config(), &info->fColorType)) { - sk_throw(); - } - info->fWidth = this->width(); - info->fHeight = this->height(); - info->fAlphaType = kPremul_SkAlphaType; -} - bool GrSurface::savePixels(const char* filename) { SkBitmap bm; bm.setConfig(SkBitmap::kARGB_8888_Config, this->width(), this->height());