aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/core
diff options
context:
space:
mode:
authorGravatar reed@google.com <reed@google.com@2bbb7eff-a529-9590-31e7-b0007b416f81>2013-12-06 18:51:08 +0000
committerGravatar reed@google.com <reed@google.com@2bbb7eff-a529-9590-31e7-b0007b416f81>2013-12-06 18:51:08 +0000
commit5b132b28da61e89cdcb84e95f30a58f8184739fc (patch)
treee0a12eb2be846b7f2135f58de677284a3fcc6fad /src/core
parent3e89524e747b513986abfeeea00b6fac79593f26 (diff)
Revert "PixelRef now returns (nearly) everything that is currently in SkBitmap. The goal is to refactor bitmap later to remove redundancy, and more interestingly, remove the chance for a disconnect between the actual (pixelref) rowbytes and config, and the one claimed by the bitmap."
This reverts commit 154e08b2f5904ef533da694e3510befcb9a3f3e2. revert due to warnings Review URL: https://codereview.chromium.org/108513003 git-svn-id: http://skia.googlecode.com/svn/trunk@12538 2bbb7eff-a529-9590-31e7-b0007b416f81
Diffstat (limited to 'src/core')
-rw-r--r--src/core/SkBitmap.cpp93
-rw-r--r--src/core/SkBitmapDevice.cpp35
-rw-r--r--src/core/SkImageFilterUtils.cpp16
-rw-r--r--src/core/SkMallocPixelRef.cpp131
-rw-r--r--src/core/SkMaskFilter.cpp8
-rw-r--r--src/core/SkPixelRef.cpp75
6 files changed, 66 insertions, 292 deletions
diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp
index 900a3abcd0..d2a308b03a 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -361,47 +361,6 @@ void SkBitmap::updatePixelsFromRef() const {
}
}
-static bool config_to_colorType(SkBitmap::Config config, SkColorType* ctOut) {
- SkColorType ct;
- switch (config) {
- case SkBitmap::kNo_Config:
- return false;
- case SkBitmap::kA8_Config:
- ct = kAlpha_8_SkColorType;
- break;
- case SkBitmap::kIndex8_Config:
- ct = kIndex8_SkColorType;
- break;
- case SkBitmap::kRGB_565_Config:
- ct = kRGB_565_SkColorType;
- break;
- case SkBitmap::kARGB_4444_Config:
- ct = kARGB_4444_SkColorType;
- break;
- case SkBitmap::kARGB_8888_Config:
- ct = kPMColor_SkColorType;
- break;
- }
- if (ctOut) {
- *ctOut = ct;
- }
- return true;
-}
-
-bool SkBitmap::asImageInfo(SkImageInfo* info) const {
- SkColorType ct;
- if (!config_to_colorType(this->config(), &ct)) {
- return false;
- }
- 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) {
@@ -452,20 +411,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();)
@@ -530,19 +479,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;
@@ -1649,28 +1596,6 @@ SkBitmap::RLEPixels::~RLEPixels() {
///////////////////////////////////////////////////////////////////////////////
-void SkImageInfo::unflatten(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::flatten(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);
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 4ba6e049d8..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 (kIndex8_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..1afc3360a2 100644
--- a/src/core/SkPixelRef.cpp
+++ b/src/core/SkPixelRef.cpp
@@ -82,20 +82,10 @@ 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) {
- this->setMutex(NULL);
- fInfo = info;
- fRec.zero();
- fLockCount = 0;
- this->needsNewGenID();
- fIsImmutable = false;
- fPreLocked = false;
-}
-
-SkPixelRef::SkPixelRef(const SkImageInfo& info, SkBaseMutex* mutex) {
+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;
@@ -105,9 +95,8 @@ SkPixelRef::SkPixelRef(const SkImageInfo& info, SkBaseMutex* mutex) {
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 +120,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 +133,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 +147,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 +168,8 @@ void SkPixelRef::unlockPixels() {
SkASSERT(fLockCount > 0);
if (0 == --fLockCount) {
this->onUnlockPixels();
- fRec.zero();
+ fPixels = NULL;
+ fColorTable = NULL;
}
}
}
@@ -274,29 +250,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();