AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert of https://codereview.chromium.org/108773003/

Browse Source 
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
This commit is contained in:
commit-bot@chromium.org 2013-12-11 20:55:41 +00:00
parent 7dd5d6e5d7
commit ff9c6c92e5
18 changed files with 141 additions and 354 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/core/SkBitmapDevice.h
View File

@ -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.

51
include/core/SkMallocPixelRef.h
View File

@ -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;
};

3
include/core/SkPicture.h
View File

@ -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

76
include/core/SkPixelRef.h
View File

@ -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;

3
include/gpu/GrSurface.h
View File

@ -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.
*/

1
include/gpu/SkGr.h
View File

@ -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);

10
include/gpu/SkGrPixelRef.h
View File

@ -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();

7
include/images/SkImageRef.h
View File

@ -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;

2
include/images/SkImageRef_GlobalPool.h
View File

@ -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();

4
samplecode/SamplePicture.cpp
View File

@ -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();
}
}

34
src/core/SkBitmap.cpp
View File

@ -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());
return false;
}
SkPixelRef* pr = SkMallocPixelRef::NewAllocate(info, dst->rowBytes(),
ctable);
if (NULL == pr) {
Sk64 size = dst->getSize64();
if (size.isNeg() || !size.is32()) {
return false;
}
dst->setPixelRef(pr, 0)->unref();
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();
// since we're already allocated, we lockPixels right away
dst->lockPixels();
return true;

35
src/core/SkBitmapDevice.cpp
View File

@ -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() {

16
src/core/SkImageFilterUtils.cpp
View File

@ -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;

131
src/core/SkMallocPixelRef.cpp
View File

@ -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;
SkMallocPixelRef::SkMallocPixelRef(void* storage, size_t size,
SkColorTable* ctable, bool ownPixels) {
if (NULL == storage) {
SkASSERT(ownPixels);
storage = sk_malloc_throw(size);
}
// 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;
}
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);
}

8
src/core/SkMaskFilter.cpp
View File

@ -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;
}

88
src/core/SkPixelRef.cpp
View File

@ -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) {
this->setMutex(NULL);
fInfo = info;
fRec.zero();
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& info, SkBaseMutex* mutex) {
this->setMutex(mutex);
fInfo = info;
fRec.zero();
SkPixelRef::SkPixelRef(const SkImageInfo&) {
this->setMutex(NULL);
fPixels = NULL;
fColorTable = NULL; // we do not track ownership of this
fLockCount = 0;
this->needsNewGenID();
fIsImmutable = false;
fPreLocked = false;
}
#ifdef SK_SUPPORT_LEGACY_PIXELREF_CONSTRUCTOR
// THIS GUY IS DEPRECATED -- don't use me!
SkPixelRef::SkPixelRef(SkBaseMutex* mutex) {
this->setMutex(mutex);
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();

14
src/effects/gradients/SkGradientShader.cpp
View File

@ -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;

10
src/gpu/GrSurface.cpp
View File

@ -8,19 +8,9 @@
#include "GrSurface.h"
#include "SkBitmap.h"
#include "SkGr.h"
#include "SkImageEncoder.h"
#include <stdio.h>
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());