setConfig -> setInfo
BUG=skia: R=robertphillips@google.com Author: reed@google.com Review URL: https://codereview.chromium.org/308683005 git-svn-id: http://skia.googlecode.com/svn/trunk@14978 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
parent
39e8d93337
commit
986d681f3e
@ -37,7 +37,7 @@ void GpuGMTask::draw(GrContextFactory* grFactory) {
|
||||
canvas->flush();
|
||||
|
||||
SkBitmap bitmap;
|
||||
bitmap.setConfig(info);
|
||||
bitmap.setInfo(info);
|
||||
canvas->readPixels(&bitmap, 0, 0);
|
||||
|
||||
this->spawnChild(SkNEW_ARGS(ExpectationsTask, (*this, fExpectations, bitmap)));
|
||||
|
@ -97,7 +97,7 @@ struct PngAndRaw {
|
||||
info, rowBytes, NULL/*ctable*/, subset));
|
||||
SkASSERT(pixels);
|
||||
|
||||
bitmap->setConfig(info, rowBytes);
|
||||
bitmap->setInfo(info, rowBytes);
|
||||
bitmap->setPixelRef(pixels);
|
||||
return true;
|
||||
}
|
||||
|
@ -590,7 +590,7 @@ public:
|
||||
// the device is as large as the current rendertarget, so
|
||||
// we explicitly only readback the amount we expect (in
|
||||
// size) overwrite our previous allocation
|
||||
bitmap->setConfig(SkImageInfo::MakeN32Premul(size.fWidth, size.fHeight));
|
||||
bitmap->setInfo(SkImageInfo::MakeN32Premul(size.fWidth, size.fHeight));
|
||||
canvas->readPixels(bitmap, 0, 0);
|
||||
}
|
||||
#endif
|
||||
|
@ -15,6 +15,7 @@
|
||||
'skia_for_chromium_defines': [
|
||||
'SK_SUPPORT_LEGACY_GETTOPDEVICE',
|
||||
'SK_SUPPORT_LEGACY_ASIMAGEINFO',
|
||||
'SK_SUPPORT_LEGACY_SETCONFIG_INFO',
|
||||
'SK_SUPPORT_LEGACY_N32_NAME',
|
||||
'SK_IGNORE_CORRECT_HIGH_QUALITY_IMAGE_SCALE',
|
||||
'SK_SUPPORT_LEGACY_INSTALLPIXELSPARAMS',
|
||||
|
@ -276,7 +276,13 @@ public:
|
||||
kPremul_SkAlphaType);
|
||||
}
|
||||
|
||||
bool setConfig(const SkImageInfo& info, size_t rowBytes = 0);
|
||||
bool setInfo(const SkImageInfo&, size_t rowBytes = 0);
|
||||
|
||||
#ifdef SK_SUPPORT_LEGACY_SETCONFIG_INFO
|
||||
bool setConfig(const SkImageInfo& info, size_t rowBytes = 0) {
|
||||
return this->setInfo(info, rowBytes);
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Allocate a pixelref to match the specified image info. If the Factory
|
||||
|
@ -202,7 +202,7 @@ static bool validate_alphaType(SkColorType colorType, SkAlphaType alphaType,
|
||||
return true;
|
||||
}
|
||||
|
||||
bool SkBitmap::setConfig(const SkImageInfo& origInfo, size_t rowBytes) {
|
||||
bool SkBitmap::setInfo(const SkImageInfo& origInfo, size_t rowBytes) {
|
||||
SkImageInfo info = origInfo;
|
||||
|
||||
if (!validate_alphaType(info.fColorType, info.fAlphaType,
|
||||
@ -241,8 +241,7 @@ bool SkBitmap::setConfig(const SkImageInfo& origInfo, size_t rowBytes) {
|
||||
bool SkBitmap::setConfig(Config config, int width, int height, size_t rowBytes,
|
||||
SkAlphaType alphaType) {
|
||||
SkColorType ct = SkBitmapConfigToColorType(config);
|
||||
return this->setConfig(SkImageInfo::Make(width, height, ct, alphaType),
|
||||
rowBytes);
|
||||
return this->setInfo(SkImageInfo::Make(width, height, ct, alphaType), rowBytes);
|
||||
}
|
||||
|
||||
bool SkBitmap::setAlphaType(SkAlphaType alphaType) {
|
||||
@ -419,7 +418,7 @@ bool SkBitmap::allocPixels(const SkImageInfo& info, SkPixelRefFactory* factory,
|
||||
if (kIndex_8_SkColorType == info.fColorType && NULL == ctable) {
|
||||
return reset_return_false(this);
|
||||
}
|
||||
if (!this->setConfig(info)) {
|
||||
if (!this->setInfo(info)) {
|
||||
return reset_return_false(this);
|
||||
}
|
||||
|
||||
@ -444,7 +443,7 @@ bool SkBitmap::allocPixels(const SkImageInfo& info, SkPixelRefFactory* factory,
|
||||
|
||||
bool SkBitmap::installPixels(const SkImageInfo& info, void* pixels, size_t rb, SkColorTable* ct,
|
||||
void (*releaseProc)(void* addr, void* context), void* context) {
|
||||
if (!this->setConfig(info, rb)) {
|
||||
if (!this->setInfo(info, rb)) {
|
||||
this->reset();
|
||||
return false;
|
||||
}
|
||||
@ -884,8 +883,8 @@ bool SkBitmap::extractSubset(SkBitmap* result, const SkIRect& subset) const {
|
||||
SkPixelRef* pixelRef = fPixelRef->deepCopy(this->config(), &subset);
|
||||
if (pixelRef != NULL) {
|
||||
SkBitmap dst;
|
||||
dst.setConfig(SkImageInfo::Make(subset.width(), subset.height(),
|
||||
this->colorType(), this->alphaType()));
|
||||
dst.setInfo(SkImageInfo::Make(subset.width(), subset.height(),
|
||||
this->colorType(), this->alphaType()));
|
||||
dst.setIsVolatile(this->isVolatile());
|
||||
dst.setPixelRef(pixelRef)->unref();
|
||||
SkDEBUGCODE(dst.validate());
|
||||
@ -900,8 +899,8 @@ bool SkBitmap::extractSubset(SkBitmap* result, const SkIRect& subset) const {
|
||||
SkASSERT(static_cast<unsigned>(r.fTop) < static_cast<unsigned>(this->height()));
|
||||
|
||||
SkBitmap dst;
|
||||
dst.setConfig(SkImageInfo::Make(r.width(), r.height(), this->colorType(), this->alphaType()),
|
||||
this->rowBytes());
|
||||
dst.setInfo(SkImageInfo::Make(r.width(), r.height(), this->colorType(), this->alphaType()),
|
||||
this->rowBytes());
|
||||
dst.setIsVolatile(this->isVolatile());
|
||||
|
||||
if (fPixelRef) {
|
||||
@ -994,7 +993,7 @@ bool SkBitmap::copyTo(SkBitmap* dst, SkColorType dstColorType,
|
||||
dstInfo.fColorType = dstColorType;
|
||||
|
||||
SkBitmap tmpDst;
|
||||
if (!tmpDst.setConfig(dstInfo)) {
|
||||
if (!tmpDst.setInfo(dstInfo)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -1102,13 +1101,13 @@ bool SkBitmap::deepCopyTo(SkBitmap* dst) const {
|
||||
// Use the same rowBytes as the original.
|
||||
rowBytes = fRowBytes;
|
||||
} else {
|
||||
// With the new config, an appropriate fRowBytes will be computed by setConfig.
|
||||
// With the new config, an appropriate fRowBytes will be computed by setInfo.
|
||||
rowBytes = 0;
|
||||
}
|
||||
|
||||
SkImageInfo info = fInfo;
|
||||
info.fColorType = dstCT;
|
||||
if (!dst->setConfig(info, rowBytes)) {
|
||||
if (!dst->setInfo(info, rowBytes)) {
|
||||
return false;
|
||||
}
|
||||
dst->setPixelRef(pixelRef, fPixelRefOrigin)->unref();
|
||||
@ -1218,7 +1217,7 @@ bool SkBitmap::extractAlpha(SkBitmap* dst, const SkPaint* paint,
|
||||
dstM.fRowBytes = SkAlign4(dstM.fBounds.width());
|
||||
} else {
|
||||
NO_FILTER_CASE:
|
||||
tmpBitmap.setConfig(SkImageInfo::MakeA8(this->width(), this->height()), srcM.fRowBytes);
|
||||
tmpBitmap.setInfo(SkImageInfo::MakeA8(this->width(), this->height()), srcM.fRowBytes);
|
||||
if (!tmpBitmap.allocPixels(allocator, NULL)) {
|
||||
// Allocation of pixels for alpha bitmap failed.
|
||||
SkDebugf("extractAlpha failed to allocate (%d,%d) alpha bitmap\n",
|
||||
@ -1241,8 +1240,8 @@ bool SkBitmap::extractAlpha(SkBitmap* dst, const SkPaint* paint,
|
||||
}
|
||||
SkAutoMaskFreeImage dstCleanup(dstM.fImage);
|
||||
|
||||
tmpBitmap.setConfig(SkImageInfo::MakeA8(dstM.fBounds.width(), dstM.fBounds.height()),
|
||||
dstM.fRowBytes);
|
||||
tmpBitmap.setInfo(SkImageInfo::MakeA8(dstM.fBounds.width(), dstM.fBounds.height()),
|
||||
dstM.fRowBytes);
|
||||
if (!tmpBitmap.allocPixels(allocator, NULL)) {
|
||||
// Allocation of pixels for alpha bitmap failed.
|
||||
SkDebugf("extractAlpha failed to allocate (%d,%d) alpha bitmap\n",
|
||||
@ -1332,7 +1331,7 @@ bool SkBitmap::ReadRawPixels(SkReadBuffer* buffer, SkBitmap* bitmap) {
|
||||
|
||||
SkAutoTUnref<SkPixelRef> pr(SkMallocPixelRef::NewWithData(info, info.minRowBytes(),
|
||||
ctable.get(), data.get()));
|
||||
bitmap->setConfig(pr->info());
|
||||
bitmap->setInfo(pr->info());
|
||||
bitmap->setPixelRef(pr, 0, 0);
|
||||
return true;
|
||||
}
|
||||
@ -1356,7 +1355,7 @@ void SkBitmap::legacyUnflatten(SkReadBuffer& buffer) {
|
||||
return;
|
||||
}
|
||||
|
||||
bool configIsValid = this->setConfig(info, rowBytes);
|
||||
bool configIsValid = this->setInfo(info, rowBytes);
|
||||
buffer.validate(configIsValid);
|
||||
|
||||
int reftype = buffer.readInt();
|
||||
|
@ -78,7 +78,7 @@ SkBitmapDevice* SkBitmapDevice::Create(const SkImageInfo& origInfo,
|
||||
SkBitmap bitmap;
|
||||
|
||||
if (kUnknown_SkColorType == info.colorType()) {
|
||||
if (!bitmap.setConfig(info)) {
|
||||
if (!bitmap.setInfo(info)) {
|
||||
return NULL;
|
||||
}
|
||||
} else {
|
||||
|
@ -296,9 +296,9 @@ bool SkBitmapScaler::Resize(SkBitmap* resultPtr,
|
||||
|
||||
// Convolve into the result.
|
||||
SkBitmap result;
|
||||
result.setConfig(SkImageInfo::MakeN32(SkScalarCeilToInt(destSubset.width()),
|
||||
SkScalarCeilToInt(destSubset.height()),
|
||||
source.alphaType()));
|
||||
result.setInfo(SkImageInfo::MakeN32(SkScalarCeilToInt(destSubset.width()),
|
||||
SkScalarCeilToInt(destSubset.height()),
|
||||
source.alphaType()));
|
||||
result.allocPixels(allocator, NULL);
|
||||
if (!result.readyToDraw()) {
|
||||
return false;
|
||||
|
@ -499,7 +499,7 @@ SkCanvas::SkCanvas(int width, int height)
|
||||
inc_canvas();
|
||||
|
||||
SkBitmap bitmap;
|
||||
bitmap.setConfig(SkImageInfo::MakeUnknown(width, height));
|
||||
bitmap.setInfo(SkImageInfo::MakeUnknown(width, height));
|
||||
this->init(SkNEW_ARGS(SkBitmapDevice, (bitmap)))->unref();
|
||||
}
|
||||
|
||||
|
@ -309,7 +309,7 @@ SkImageFilter::Cache* SkImageFilter::GetExternalCache() {
|
||||
|
||||
void SkImageFilter::WrapTexture(GrTexture* texture, int width, int height, SkBitmap* result) {
|
||||
SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
|
||||
result->setConfig(info);
|
||||
result->setInfo(info);
|
||||
result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref();
|
||||
}
|
||||
|
||||
|
@ -276,7 +276,7 @@ bool SkReadBuffer::readBitmap(SkBitmap* bitmap) {
|
||||
}
|
||||
}
|
||||
// Could not read the SkBitmap. Use a placeholder bitmap.
|
||||
bitmap->setConfig(SkImageInfo::MakeUnknown(width, height));
|
||||
bitmap->setInfo(SkImageInfo::MakeUnknown(width, height));
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -584,7 +584,6 @@ static void generateMask(const SkMask& mask, const SkPath& path,
|
||||
matrix.setTranslate(-SkIntToScalar(mask.fBounds.fLeft),
|
||||
-SkIntToScalar(mask.fBounds.fTop));
|
||||
|
||||
SkBitmap::Config config = SkBitmap::kA8_Config;
|
||||
paint.setAntiAlias(SkMask::kBW_Format != mask.fFormat);
|
||||
switch (mask.fFormat) {
|
||||
case SkMask::kBW_Format:
|
||||
@ -608,18 +607,17 @@ static void generateMask(const SkMask& mask, const SkPath& path,
|
||||
SkRasterClip clip;
|
||||
clip.setRect(SkIRect::MakeWH(dstW, dstH));
|
||||
|
||||
const SkImageInfo info = SkImageInfo::MakeA8(dstW, dstH);
|
||||
SkBitmap bm;
|
||||
bm.setConfig(config, dstW, dstH, dstRB);
|
||||
|
||||
if (0 == dstRB) {
|
||||
if (!bm.allocPixels()) {
|
||||
if (!bm.allocPixels(info)) {
|
||||
// can't allocate offscreen, so empty the mask and return
|
||||
sk_bzero(mask.fImage, mask.computeImageSize());
|
||||
return;
|
||||
}
|
||||
bm.lockPixels();
|
||||
} else {
|
||||
bm.setPixels(mask.fImage);
|
||||
bm.installPixels(info, mask.fImage, dstRB);
|
||||
}
|
||||
sk_bzero(bm.getPixels(), bm.getSafeSize());
|
||||
|
||||
|
@ -23,12 +23,6 @@ static inline bool SkIsValidMode(SkXfermode::Mode mode) {
|
||||
return (mode >= 0) && (mode <= SkXfermode::kLastMode);
|
||||
}
|
||||
|
||||
/** Returns true if config's value is in the SkBitmap::Config enum.
|
||||
*/
|
||||
static inline bool SkIsValidConfig(SkBitmap::Config config) {
|
||||
return (config >= 0) && (config <= static_cast<int>(SkBitmap::kConfigCount));
|
||||
}
|
||||
|
||||
/** Returns true if the rect's dimensions are between 0 and SK_MaxS32
|
||||
*/
|
||||
static inline bool SkIsValidIRect(const SkIRect& rect) {
|
||||
|
@ -92,10 +92,10 @@ struct SkPerlinNoiseShader::PaintingData {
|
||||
}
|
||||
|
||||
#if SK_SUPPORT_GPU && !defined(SK_USE_SIMPLEX_NOISE)
|
||||
fPermutationsBitmap.setConfig(SkImageInfo::MakeA8(kBlockSize, 1));
|
||||
fPermutationsBitmap.setInfo(SkImageInfo::MakeA8(kBlockSize, 1));
|
||||
fPermutationsBitmap.setPixels(fLatticeSelector);
|
||||
|
||||
fNoiseBitmap.setConfig(SkImageInfo::MakeN32Premul(kBlockSize, 4));
|
||||
fNoiseBitmap.setInfo(SkImageInfo::MakeN32Premul(kBlockSize, 4));
|
||||
fNoiseBitmap.setPixels(fNoise[0][0]);
|
||||
#endif
|
||||
}
|
||||
|
@ -619,7 +619,7 @@ void SkGradientShaderBase::getGradientTableBitmap(SkBitmap* bitmap) const {
|
||||
if (!gCache->find(storage.get(), size, bitmap)) {
|
||||
// force our cahce32pixelref to be built
|
||||
(void)cache->getCache32();
|
||||
bitmap->setConfig(SkImageInfo::MakeN32Premul(kCache32Count, 1));
|
||||
bitmap->setInfo(SkImageInfo::MakeN32Premul(kCache32Count, 1));
|
||||
bitmap->setPixelRef(cache->getCache32PixelRef());
|
||||
|
||||
gCache->add(storage.get(), size, *bitmap);
|
||||
|
@ -41,10 +41,7 @@ public:
|
||||
fInfo.fHasNestedLayers = false;
|
||||
fInfo.fIsNested = (2 == fSaveLayerDepth);
|
||||
|
||||
fEmptyBitmap.setConfig(SkImageInfo::Make(fInfo.fSize.fWidth,
|
||||
fInfo.fSize.fHeight,
|
||||
kUnknown_SkColorType,
|
||||
kIgnore_SkAlphaType));
|
||||
fEmptyBitmap.setInfo(SkImageInfo::MakeUnknown(fInfo.fSize.fWidth, fInfo.fSize.fHeight));
|
||||
fAccelData = accelData;
|
||||
fAlreadyDrawn = false;
|
||||
}
|
||||
|
@ -738,7 +738,7 @@ SkBitmap wrap_texture(GrTexture* texture) {
|
||||
texture->asImageInfo(&info);
|
||||
|
||||
SkBitmap result;
|
||||
result.setConfig(info);
|
||||
result.setInfo(info);
|
||||
result.setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref();
|
||||
return result;
|
||||
}
|
||||
@ -1818,7 +1818,7 @@ void SkGpuDevice::EXPERIMENTAL_optimize(SkPicture* picture) {
|
||||
|
||||
static void wrap_texture(GrTexture* texture, int width, int height, SkBitmap* result) {
|
||||
SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
|
||||
result->setConfig(info);
|
||||
result->setInfo(info);
|
||||
result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref();
|
||||
}
|
||||
|
||||
|
@ -11,8 +11,6 @@
|
||||
#include "SkBitmap.h"
|
||||
#include "SkImage.h"
|
||||
|
||||
extern SkBitmap::Config SkImageInfoToBitmapConfig(const SkImageInfo&);
|
||||
|
||||
// Call this if you explicitly want to use/share this pixelRef in the image
|
||||
extern SkImage* SkNewImageFromPixelRef(const SkImageInfo&, SkPixelRef*,
|
||||
size_t rowBytes);
|
||||
@ -23,7 +21,7 @@ extern SkImage* SkNewImageFromPixelRef(const SkImageInfo&, SkPixelRef*,
|
||||
* be shared if either the bitmap is marked as immutable, or canSharePixelRef
|
||||
* is true.
|
||||
*
|
||||
* If the bitmap's config cannot be converted into a corresponding
|
||||
* If the bitmap's colortype cannot be converted into a corresponding
|
||||
* SkImageInfo, or the bitmap's pixels cannot be accessed, this will return
|
||||
* NULL.
|
||||
*/
|
||||
|
@ -31,7 +31,7 @@ public:
|
||||
return false;
|
||||
}
|
||||
|
||||
if (SkImageInfoToBitmapConfig(info) == SkBitmap::kNo_Config) {
|
||||
if (kUnknown_SkColorType == info.colorType()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -104,7 +104,7 @@ SkImage_Raster::SkImage_Raster(const Info& info, SkData* data, size_t rowBytes)
|
||||
SkImage_Raster::SkImage_Raster(const Info& info, SkPixelRef* pr, size_t rowBytes)
|
||||
: INHERITED(info.fWidth, info.fHeight)
|
||||
{
|
||||
fBitmap.setConfig(info, rowBytes);
|
||||
fBitmap.setInfo(info, rowBytes);
|
||||
fBitmap.setPixelRef(pr);
|
||||
fBitmap.lockPixels();
|
||||
}
|
||||
|
@ -79,8 +79,7 @@ bool SkSurface_Raster::Valid(const SkImageInfo& info, size_t rowBytes) {
|
||||
SkSurface_Raster::SkSurface_Raster(const SkImageInfo& info, void* pixels, size_t rb)
|
||||
: INHERITED(info)
|
||||
{
|
||||
fBitmap.setConfig(info, rb);
|
||||
fBitmap.setPixels(pixels);
|
||||
fBitmap.installPixels(info, pixels, rb);
|
||||
fWeOwnThePixels = false; // We are "Direct"
|
||||
}
|
||||
|
||||
@ -89,7 +88,7 @@ SkSurface_Raster::SkSurface_Raster(SkPixelRef* pr)
|
||||
{
|
||||
const SkImageInfo& info = pr->info();
|
||||
|
||||
fBitmap.setConfig(info, info.minRowBytes());
|
||||
fBitmap.setInfo(info, info.minRowBytes());
|
||||
fBitmap.setPixelRef(pr);
|
||||
fWeOwnThePixels = true;
|
||||
|
||||
|
@ -311,7 +311,7 @@ bool SkWEBPImageDecoder::setDecodeConfig(SkBitmap* decodedBitmap,
|
||||
} else {
|
||||
info.fAlphaType = kOpaque_SkAlphaType;
|
||||
}
|
||||
return decodedBitmap->setConfig(info);
|
||||
return decodedBitmap->setInfo(info);
|
||||
}
|
||||
|
||||
bool SkWEBPImageDecoder::onBuildTileIndex(SkStreamRewindable* stream,
|
||||
|
@ -32,7 +32,7 @@ SkImageRef::SkImageRef(const SkImageInfo& info, SkStreamRewindable* stream,
|
||||
|
||||
// This sets the colortype/alphatype to exactly match our info, so that this
|
||||
// can get communicated down to the codec.
|
||||
fBitmap.setConfig(info);
|
||||
fBitmap.setInfo(info);
|
||||
|
||||
#ifdef DUMP_IMAGEREF_LIFECYCLE
|
||||
SkDebugf("add ImageRef %p [%d] data=%d\n",
|
||||
@ -190,7 +190,7 @@ SkImageRef::SkImageRef(SkReadBuffer& buffer, SkBaseMutex* mutex)
|
||||
|
||||
// This sets the colortype/alphatype to exactly match our info, so that this
|
||||
// can get communicated down to the codec.
|
||||
fBitmap.setConfig(this->info());
|
||||
fBitmap.setInfo(this->info());
|
||||
}
|
||||
|
||||
void SkImageRef::flatten(SkWriteBuffer& buffer) const {
|
||||
|
@ -14,7 +14,7 @@ bool SkCachingPixelRef::Install(SkImageGenerator* generator,
|
||||
SkASSERT(dst != NULL);
|
||||
if ((NULL == generator)
|
||||
|| !(generator->getInfo(&info))
|
||||
|| !dst->setConfig(info, 0)) {
|
||||
|| !dst->setInfo(info)) {
|
||||
SkDELETE(generator);
|
||||
return false;
|
||||
}
|
||||
@ -54,7 +54,7 @@ bool SkCachingPixelRef::onNewLockPixels(LockRec* rec) {
|
||||
&bitmap);
|
||||
if (NULL == fScaledCacheId) {
|
||||
// Cache has been purged, must re-decode.
|
||||
if ((!bitmap.setConfig(info, fRowBytes)) || !bitmap.allocPixels()) {
|
||||
if ((!bitmap.setInfo(info, fRowBytes)) || !bitmap.allocPixels()) {
|
||||
fErrorInDecoding = true;
|
||||
return false;
|
||||
}
|
||||
|
@ -102,7 +102,7 @@ bool SkInstallDiscardablePixelRef(SkImageGenerator* generator, SkBitmap* dst,
|
||||
SkAutoTDelete<SkImageGenerator> autoGenerator(generator);
|
||||
if ((NULL == autoGenerator.get())
|
||||
|| (!autoGenerator->getInfo(&info))
|
||||
|| (!dst->setConfig(info, 0))) {
|
||||
|| (!dst->setInfo(info))) {
|
||||
return false;
|
||||
}
|
||||
SkASSERT(dst->colorType() != kUnknown_SkColorType);
|
||||
|
@ -725,7 +725,7 @@ static inline SkBitmap makeContentBitmap(const SkISize& contentSize,
|
||||
}
|
||||
|
||||
SkBitmap bitmap;
|
||||
bitmap.setConfig(info);
|
||||
bitmap.setInfo(info);
|
||||
return bitmap;
|
||||
}
|
||||
|
||||
|
@ -70,7 +70,7 @@ bool SkImageDecoder_CG::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
|
||||
const int height = SkToInt(CGImageGetHeight(image));
|
||||
SkImageInfo skinfo = SkImageInfo::MakeN32Premul(width, height);
|
||||
|
||||
bm->setConfig(skinfo);
|
||||
bm->setInfo(skinfo);
|
||||
if (SkImageDecoder::kDecodeBounds_Mode == mode) {
|
||||
return true;
|
||||
}
|
||||
|
@ -28,9 +28,7 @@ public:
|
||||
fSize.set(width, height);
|
||||
fPRCont = prCont;
|
||||
SkSafeRef(fPRCont);
|
||||
fEmptyBitmap.setConfig(SkImageInfo::Make(width, height,
|
||||
kUnknown_SkColorType,
|
||||
kIgnore_SkAlphaType));
|
||||
fEmptyBitmap.setInfo(SkImageInfo::MakeUnknown(width, height));
|
||||
}
|
||||
|
||||
virtual ~SkGatherPixelRefsAndRectsDevice() {
|
||||
|
@ -54,7 +54,7 @@ public:
|
||||
|
||||
GatherPixelRefDevice(int width, int height, PixelRefSet* prset) {
|
||||
fSize.set(width, height);
|
||||
fEmptyBitmap.setConfig(SkImageInfo::MakeUnknown(width, height));
|
||||
fEmptyBitmap.setInfo(SkImageInfo::MakeUnknown(width, height));
|
||||
fPRSet = prset;
|
||||
}
|
||||
|
||||
|
@ -23,22 +23,23 @@ static void post_SkEvent_event() {
|
||||
}
|
||||
|
||||
static bool skia_setBitmapFromSurface(SkBitmap* dst, SDL_Surface* src) {
|
||||
SkBitmap::Config config;
|
||||
SkColorType ct;
|
||||
SkAlphaType at;
|
||||
|
||||
switch (src->format->BytesPerPixel) {
|
||||
case 2:
|
||||
config = SkBitmap::kRGB_565_Config;
|
||||
ct = kRGB_565_SkColorType;
|
||||
at = kOpaque_SkAlphaType;
|
||||
break;
|
||||
case 4:
|
||||
config = SkBitmap::kARGB_8888_Config;
|
||||
ct = kN32_SkColorType;
|
||||
at = kPremul_SkAlphaType;
|
||||
break;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
|
||||
dst->setConfig(config, src->w, src->h, src->pitch);
|
||||
dst->setPixels(src->pixels);
|
||||
return true;
|
||||
return dst->installPixels(SkImageInfo::Make(src->w, src->h, ct, at), src->pixels, src->pitch);
|
||||
}
|
||||
|
||||
SkOSWindow::SkOSWindow(void* screen) {
|
||||
|
@ -336,9 +336,8 @@ DEF_TEST(BitmapCopy, reporter) {
|
||||
// Test with a very large configuration without pixel buffer
|
||||
// attached.
|
||||
SkBitmap tstSafeSize;
|
||||
tstSafeSize.setConfig(SkImageInfo::Make(100000000U, 100000000U,
|
||||
gPairs[i].fColorType,
|
||||
kPremul_SkAlphaType));
|
||||
tstSafeSize.setInfo(SkImageInfo::Make(100000000U, 100000000U,
|
||||
gPairs[i].fColorType, kPremul_SkAlphaType));
|
||||
int64_t safeSize = tstSafeSize.computeSafeSize64();
|
||||
if (safeSize < 0) {
|
||||
ERRORF(reporter, "getSafeSize64() negative: %s",
|
||||
|
@ -13,11 +13,10 @@ static void test_bigwidth(skiatest::Reporter* reporter) {
|
||||
SkBitmap bm;
|
||||
int width = 1 << 29; // *4 will be the high-bit of 32bit int
|
||||
|
||||
SkImageInfo info = SkImageInfo::Make(width, 1, kAlpha_8_SkColorType,
|
||||
kPremul_SkAlphaType);
|
||||
REPORTER_ASSERT(reporter, bm.setConfig(info));
|
||||
SkImageInfo info = SkImageInfo::MakeA8(width, 1);
|
||||
REPORTER_ASSERT(reporter, bm.setInfo(info));
|
||||
info.fColorType = kRGB_565_SkColorType;
|
||||
REPORTER_ASSERT(reporter, bm.setConfig(info));
|
||||
REPORTER_ASSERT(reporter, bm.setInfo(info));
|
||||
|
||||
// for a 4-byte config, this width will compute a rowbytes of 0x80000000,
|
||||
// which does not fit in a int32_t. setConfig should detect this, and fail.
|
||||
@ -26,7 +25,7 @@ static void test_bigwidth(skiatest::Reporter* reporter) {
|
||||
// in a uint32_t (or larger), but for now this is the constraint.
|
||||
|
||||
info.fColorType = kN32_SkColorType;
|
||||
REPORTER_ASSERT(reporter, !bm.setConfig(info));
|
||||
REPORTER_ASSERT(reporter, !bm.setInfo(info));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -37,8 +36,7 @@ DEF_TEST(Bitmap, reporter) {
|
||||
for (int width = 0; width < 2; ++width) {
|
||||
for (int height = 0; height < 2; ++height) {
|
||||
SkBitmap bm;
|
||||
bool setConf = bm.setConfig(SkImageInfo::MakeN32Premul(width,
|
||||
height));
|
||||
bool setConf = bm.setInfo(SkImageInfo::MakeN32Premul(width, height));
|
||||
REPORTER_ASSERT(reporter, setConf);
|
||||
if (setConf) {
|
||||
REPORTER_ASSERT(reporter, bm.allocPixels(NULL));
|
||||
|
@ -101,7 +101,7 @@ static void test_clipVisitor(skiatest::Reporter* reporter, SkCanvas* canvas) {
|
||||
SkISize size = canvas->getDeviceSize();
|
||||
|
||||
SkBitmap bm;
|
||||
bm.setConfig(SkImageInfo::MakeN32Premul(size.width(), size.height()));
|
||||
bm.setInfo(SkImageInfo::MakeN32Premul(size.width(), size.height()));
|
||||
SkCanvas c(bm);
|
||||
|
||||
Canvas2CanvasClipVisitor visitor(&c);
|
||||
|
@ -509,7 +509,7 @@ DEF_TEST(ImprovedBitmapFactory, reporter) {
|
||||
SkStream::NewFromFile(path.c_str()));
|
||||
if (sk_exists(path.c_str())) {
|
||||
SkBitmap bm;
|
||||
SkAssertResult(bm.setConfig(SkImageInfo::MakeN32Premul(1, 1)));
|
||||
SkAssertResult(bm.setInfo(SkImageInfo::MakeN32Premul(1, 1)));
|
||||
REPORTER_ASSERT(reporter,
|
||||
NULL != install_pixel_ref(&bm, stream.detach(), 1, true));
|
||||
SkAutoLockPixels alp(bm);
|
||||
|
@ -1185,7 +1185,7 @@ static void test_bad_bitmap() {
|
||||
// This bitmap has a width and height but no pixels. As a result, attempting to record it will
|
||||
// fail.
|
||||
SkBitmap bm;
|
||||
bm.setConfig(SkImageInfo::MakeN32Premul(100, 100));
|
||||
bm.setInfo(SkImageInfo::MakeN32Premul(100, 100));
|
||||
SkPictureRecorder recorder;
|
||||
SkCanvas* recordingCanvas = recorder.beginRecording(100, 100, NULL, 0);
|
||||
recordingCanvas->drawBitmap(bm, 0, 0);
|
||||
@ -1616,7 +1616,7 @@ static void draw_bitmaps(const SkBitmap bitmap, SkCanvas* canvas) {
|
||||
static void test_draw_bitmaps(SkCanvas* canvas) {
|
||||
SkBitmap empty;
|
||||
draw_bitmaps(empty, canvas);
|
||||
empty.setConfig(SkImageInfo::MakeN32Premul(10, 10));
|
||||
empty.setInfo(SkImageInfo::MakeN32Premul(10, 10));
|
||||
draw_bitmaps(empty, canvas);
|
||||
}
|
||||
|
||||
|
@ -16,8 +16,7 @@
|
||||
// Ensures that the pipe gracefully handles drawing an invalid bitmap.
|
||||
static void testDrawingBadBitmap(SkCanvas* pipeCanvas) {
|
||||
SkBitmap badBitmap;
|
||||
badBitmap.setConfig(SkImageInfo::Make(5, 5, kUnknown_SkColorType,
|
||||
kPremul_SkAlphaType));
|
||||
badBitmap.setInfo(SkImageInfo::MakeUnknown(5, 5));
|
||||
pipeCanvas->drawBitmap(badBitmap, 0, 0);
|
||||
}
|
||||
|
||||
@ -44,7 +43,7 @@ static void testDrawingAfterEndRecording(SkCanvas* canvas) {
|
||||
|
||||
DEF_TEST(Pipe, reporter) {
|
||||
SkBitmap bitmap;
|
||||
bitmap.setConfig(SkImageInfo::MakeN32Premul(64, 64));
|
||||
bitmap.setInfo(SkImageInfo::MakeN32Premul(64, 64));
|
||||
SkCanvas canvas(bitmap);
|
||||
|
||||
PipeController pipeController(&canvas);
|
||||
|
@ -238,7 +238,7 @@ static void init_bitmap(SkBitmap* bitmap, const SkIRect& rect, BitmapInit init,
|
||||
if (alloc) {
|
||||
bitmap->allocPixels(info);
|
||||
} else {
|
||||
bitmap->setConfig(info, rowBytes);
|
||||
bitmap->setInfo(info, rowBytes);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -390,12 +390,12 @@ DEF_TEST(Serialization, reporter) {
|
||||
SkImageInfo info = SkImageInfo::MakeN32Premul(kBitmapSize, kBitmapSize);
|
||||
|
||||
SkBitmap validBitmap;
|
||||
validBitmap.setConfig(info);
|
||||
validBitmap.setInfo(info);
|
||||
|
||||
// Create a bitmap with a really large height
|
||||
info.fHeight = 1000000000;
|
||||
SkBitmap invalidBitmap;
|
||||
invalidBitmap.setConfig(info);
|
||||
invalidBitmap.setInfo(info);
|
||||
|
||||
// The deserialization should succeed, and the rendering shouldn't crash,
|
||||
// even when the device fails to initialize, due to its size
|
||||
|
@ -14,7 +14,7 @@ static void test_bitmap(skiatest::Reporter* reporter) {
|
||||
SkImageInfo info = SkImageInfo::MakeN32Premul(2, 2);
|
||||
|
||||
SkBitmap bmp;
|
||||
bmp.setConfig(info);
|
||||
bmp.setInfo(info);
|
||||
|
||||
// test 1: bitmap without pixel data
|
||||
SkShader* shader = SkShader::CreateBitmapShader(bmp,
|
||||
|
@ -290,7 +290,7 @@ static const CanvasConfig gCanvasConfigs[] = {
|
||||
// sure that the two rowBytes match (and the infos match).
|
||||
//
|
||||
static bool allocRowBytes(SkBitmap* bm, const SkImageInfo& info, size_t rowBytes) {
|
||||
if (!bm->setConfig(info, rowBytes)) {
|
||||
if (!bm->setInfo(info, rowBytes)) {
|
||||
return false;
|
||||
}
|
||||
SkPixelRef* pr = SkMallocPixelRef::NewAllocate(info, rowBytes, NULL);
|
||||
|
Loading…
Reference in New Issue
Block a user