From e683c56115a210b5993df9294260bb147b408bfa Mon Sep 17 00:00:00 2001 From: robertphillips Date: Thu, 10 Mar 2016 16:18:46 -0800 Subject: Revert of add Make variations to return SkImage by sk_sp (patchset #5 id:80001 of https://codereview.chromium.org/1778393002/ ) Reason for revert: Experimental revert to try to clear up ASAN failures Original issue's description: > add Make variations to return SkImage by sk_sp > > some internal call-sites update, but not. Will follow-up in future to complete that. > > BUG=skia: > GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1778393002 > > Committed: https://skia.googlesource.com/skia/+/bd73ffb83022f1f6b1997e2a91c049949e88a8a2 TBR=fmalita@chromium.org,bsalomon@google.com,reed@google.com # Skipping CQ checks because original CL landed less than 1 days ago. NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true BUG=skia: Review URL: https://codereview.chromium.org/1783063002 --- include/core/SkImage.h | 100 ++++++++++------------------ include/core/SkShader.h | 2 +- src/c/sk_surface.cpp | 6 +- src/core/SkPictureShader.cpp | 8 +-- src/core/SkPictureShader.h | 10 +-- src/core/SkReadBuffer.cpp | 12 ++-- src/core/SkShader.cpp | 5 +- src/image/SkImage.cpp | 110 ++++++------------------------- src/image/SkImagePriv.h | 9 ++- src/image/SkImage_Base.h | 2 +- src/image/SkImage_Generator.cpp | 13 ++-- src/image/SkImage_Gpu.cpp | 64 +++++++++--------- src/image/SkImage_Gpu.h | 2 +- src/image/SkImage_Raster.cpp | 57 ++++++++-------- src/image/SkSurface_Raster.cpp | 2 +- src/utils/SkBitmapSourceDeserializer.cpp | 3 +- 16 files changed, 148 insertions(+), 257 deletions(-) diff --git a/include/core/SkImage.h b/include/core/SkImage.h index 1b4aeb68d6..832ff9dea1 100644 --- a/include/core/SkImage.h +++ b/include/core/SkImage.h @@ -27,8 +27,6 @@ class SkSurface; class GrContext; class GrTexture; -#define SK_SUPPORT_LEGACY_IMAGEFACTORY - /** * SkImage is an abstraction for drawing a rectagle of pixels, though the * particular type of image could be actually storing its data on the GPU, or @@ -48,8 +46,9 @@ public: typedef SkImageInfo Info; typedef void* ReleaseContext; - static sk_sp MakeRasterCopy(const SkPixmap&); - static sk_sp MakeRasterData(const Info&, sk_sp pixels, size_t rowBytes); + static SkImage* NewRasterCopy(const Info&, const void* pixels, size_t rowBytes, + SkColorTable* ctable = NULL); + static SkImage* NewRasterData(const Info&, SkData* pixels, size_t rowBytes); typedef void (*RasterReleaseProc)(const void* pixels, ReleaseContext); @@ -58,31 +57,36 @@ public: * until the specified release-proc is called, indicating that Skia no longer has a reference * to the pixels. * - * Returns NULL if the requested pixmap info is unsupported. + * Returns NULL if the requested Info is unsupported. */ - static sk_sp MakeFromRaster(const SkPixmap&, RasterReleaseProc, ReleaseContext); + static SkImage* NewFromRaster(const Info&, const void* pixels, size_t rowBytes, + RasterReleaseProc, ReleaseContext); /** * Construct a new image from the specified bitmap. If the bitmap is marked immutable, and * its pixel memory is shareable, it may be shared instead of copied. */ - static sk_sp MakeFromBitmap(const SkBitmap&); + static SkImage* NewFromBitmap(const SkBitmap&); /** - * Construct a new SkImage based on the given ImageGenerator. Returns NULL on error. - * This function will always take ownership of the passed generator. + * Construct a new SkImage based on the given ImageGenerator. + * This function will always take ownership of the passed + * ImageGenerator. Returns NULL on error. * * If a subset is specified, it must be contained within the generator's bounds. */ - static sk_sp MakeFromGenerator(SkImageGenerator*, const SkIRect* subset = NULL); + static SkImage* NewFromGenerator(SkImageGenerator*, const SkIRect* subset = NULL); /** * Construct a new SkImage based on the specified encoded data. Returns NULL on failure, * which can mean that the format of the encoded data was not recognized/supported. * * If a subset is specified, it must be contained within the encoded data's bounds. + * + * Regardless of success or failure, the caller is responsible for managing their ownership + * of the data. */ - static sk_sp MakeFromEncoded(sk_sp encoded, const SkIRect* subset = NULL); + static SkImage* NewFromEncoded(SkData* encoded, const SkIRect* subset = NULL); /** * Create a new image from the specified descriptor. Note - the caller is responsible for @@ -90,13 +94,12 @@ public: * * Will return NULL if the specified descriptor is unsupported. */ - static sk_sp MakeFromTexture(GrContext* ctx, const GrBackendTextureDesc& desc) { - return MakeFromTexture(ctx, desc, kPremul_SkAlphaType, NULL, NULL); + static SkImage* NewFromTexture(GrContext* ctx, const GrBackendTextureDesc& desc) { + return NewFromTexture(ctx, desc, kPremul_SkAlphaType, NULL, NULL); } - static sk_sp MakeFromTexture(GrContext* ctx, const GrBackendTextureDesc& de, - SkAlphaType at) { - return MakeFromTexture(ctx, de, at, NULL, NULL); + static SkImage* NewFromTexture(GrContext* ctx, const GrBackendTextureDesc& de, SkAlphaType at) { + return NewFromTexture(ctx, de, at, NULL, NULL); } typedef void (*TextureReleaseProc)(ReleaseContext); @@ -108,8 +111,8 @@ public: * * Will return NULL if the specified descriptor is unsupported. */ - static sk_sp MakeFromTexture(GrContext*, const GrBackendTextureDesc&, SkAlphaType, - TextureReleaseProc, ReleaseContext); + static SkImage* NewFromTexture(GrContext*, const GrBackendTextureDesc&, SkAlphaType, + TextureReleaseProc, ReleaseContext); /** * Create a new image from the specified descriptor. Note - Skia will delete or recycle the @@ -117,8 +120,8 @@ public: * * Will return NULL if the specified descriptor is unsupported. */ - static sk_sp MakeFromAdoptedTexture(GrContext*, const GrBackendTextureDesc&, - SkAlphaType = kPremul_SkAlphaType); + static SkImage* NewFromAdoptedTexture(GrContext*, const GrBackendTextureDesc&, + SkAlphaType = kPremul_SkAlphaType); /** * Create a new image by copying the pixels from the specified descriptor. No reference is @@ -126,23 +129,23 @@ public: * * Will return NULL if the specified descriptor is unsupported. */ - static sk_sp MakeFromTextureCopy(GrContext*, const GrBackendTextureDesc&, - SkAlphaType = kPremul_SkAlphaType); + static SkImage* NewFromTextureCopy(GrContext*, const GrBackendTextureDesc&, + SkAlphaType = kPremul_SkAlphaType); /** * Create a new image by copying the pixels from the specified y, u, v textures. The data * from the textures is immediately ingested into the image and the textures can be modified or * deleted after the function returns. The image will have the dimensions of the y texture. */ - static sk_sp MakeFromYUVTexturesCopy(GrContext*, SkYUVColorSpace, - const GrBackendObject yuvTextureHandles[3], - const SkISize yuvSizes[3], - GrSurfaceOrigin); + static SkImage* NewFromYUVTexturesCopy(GrContext*, SkYUVColorSpace, + const GrBackendObject yuvTextureHandles[3], + const SkISize yuvSizes[3], + GrSurfaceOrigin); - static sk_sp MakeFromPicture(sk_sp, const SkISize& dimensions, - const SkMatrix*, const SkPaint*); + static SkImage* NewFromPicture(const SkPicture*, const SkISize& dimensions, + const SkMatrix*, const SkPaint*); - static sk_sp MakeTextureFromPixmap(GrContext*, const SkPixmap&, SkBudgeted budgeted); + static SkImage* NewTextureFromPixmap(GrContext*, const SkPixmap&, SkBudgeted budgeted); /////////////////////////////////////////////////////////////////////////////////////////////// @@ -312,14 +315,14 @@ public: * If subset does not intersect the bounds of this image, or the copy/share cannot be made, * NULL will be returned. */ - sk_sp makeSubset(const SkIRect& subset) const; + SkImage* newSubset(const SkIRect& subset) const; /** * Ensures that an image is backed by a texture (when GrContext is non-null). If no * transformation is required, the returned image may be the same as this image. If the this * image is from a different GrContext, this will fail. */ - sk_sp makeTextureImage(GrContext*) const; + SkImage* newTextureImage(GrContext*) const; // Helper functions to convert to SkBitmap @@ -345,41 +348,6 @@ public: */ bool isLazyGenerated() const; - -#ifdef SK_SUPPORT_LEGACY_IMAGEFACTORY - static SkImage* NewRasterCopy(const Info&, const void* pixels, size_t rowBytes, - SkColorTable* ctable = nullptr); - static SkImage* NewRasterData(const Info&, SkData* pixels, size_t rowBytes); - static SkImage* NewFromRaster(const Info&, const void* pixels, size_t rowBytes, - RasterReleaseProc, ReleaseContext); - static SkImage* NewFromBitmap(const SkBitmap&); - static SkImage* NewFromGenerator(SkImageGenerator*, const SkIRect* subset = NULL); - static SkImage* NewFromEncoded(SkData* encoded, const SkIRect* subset = NULL); - static SkImage* NewFromTexture(GrContext* ctx, const GrBackendTextureDesc& desc) { - return NewFromTexture(ctx, desc, kPremul_SkAlphaType, NULL, NULL); - } - - static SkImage* NewFromTexture(GrContext* ctx, const GrBackendTextureDesc& de, SkAlphaType at) { - return NewFromTexture(ctx, de, at, NULL, NULL); - } - static SkImage* NewFromTexture(GrContext*, const GrBackendTextureDesc&, SkAlphaType, - TextureReleaseProc, ReleaseContext); - static SkImage* NewFromAdoptedTexture(GrContext*, const GrBackendTextureDesc&, - SkAlphaType = kPremul_SkAlphaType); - static SkImage* NewFromTextureCopy(GrContext*, const GrBackendTextureDesc&, - SkAlphaType = kPremul_SkAlphaType); - static SkImage* NewFromYUVTexturesCopy(GrContext*, SkYUVColorSpace, - const GrBackendObject yuvTextureHandles[3], - const SkISize yuvSizes[3], - GrSurfaceOrigin); - static SkImage* NewFromPicture(const SkPicture*, const SkISize& dimensions, - const SkMatrix*, const SkPaint*); - static SkImage* NewTextureFromPixmap(GrContext*, const SkPixmap&, SkBudgeted budgeted); - - SkImage* newSubset(const SkIRect& subset) const { return this->makeSubset(subset).release(); } - SkImage* newTextureImage(GrContext* ctx) const { return this->makeTextureImage(ctx).release(); } -#endif - protected: SkImage(int width, int height, uint32_t uniqueID); diff --git a/include/core/SkShader.h b/include/core/SkShader.h index 158d526e44..0bcb98a07e 100644 --- a/include/core/SkShader.h +++ b/include/core/SkShader.h @@ -411,7 +411,7 @@ public: * bounds. * @return Returns a new shader object. Note: this function never returns null. */ - static sk_sp MakePictureShader(sk_sp src, TileMode tmx, TileMode tmy, + static sk_sp MakePictureShader(sk_sp src, TileMode tmx, TileMode tmy, const SkMatrix* localMatrix, const SkRect* tile); /** diff --git a/src/c/sk_surface.cpp b/src/c/sk_surface.cpp index 6bd62a9aa9..f7fa30f28a 100644 --- a/src/c/sk_surface.cpp +++ b/src/c/sk_surface.cpp @@ -224,12 +224,12 @@ sk_image_t* sk_image_new_raster_copy(const sk_imageinfo_t* cinfo, const void* pi if (!from_c_info(*cinfo, &info)) { return NULL; } - return (sk_image_t*)SkImage::MakeRasterCopy(SkPixmap(info, pixels, rowBytes)).release(); + return (sk_image_t*)SkImage::NewRasterCopy(info, pixels, rowBytes); } sk_image_t* sk_image_new_from_encoded(const sk_data_t* cdata, const sk_irect_t* subset) { - return ToImage(SkImage::MakeFromEncoded(sk_ref_sp(AsData(cdata)), - reinterpret_cast(subset)).release()); + return ToImage(SkImage::NewFromEncoded(AsData(cdata), + reinterpret_cast(subset))); } sk_data_t* sk_image_encode(const sk_image_t* cimage) { diff --git a/src/core/SkPictureShader.cpp b/src/core/SkPictureShader.cpp index 30dc47ffd9..c2a0b74e23 100644 --- a/src/core/SkPictureShader.cpp +++ b/src/core/SkPictureShader.cpp @@ -93,7 +93,7 @@ struct BitmapShaderRec : public SkResourceCache::Rec { } // namespace -SkPictureShader::SkPictureShader(sk_sp picture, TileMode tmx, TileMode tmy, +SkPictureShader::SkPictureShader(sk_sp picture, TileMode tmx, TileMode tmy, const SkMatrix* localMatrix, const SkRect* tile) : INHERITED(localMatrix) , fPicture(std::move(picture)) @@ -102,7 +102,7 @@ SkPictureShader::SkPictureShader(sk_sp picture, TileMode tmx, TileMod , fTmy(tmy) { } -sk_sp SkPictureShader::Make(sk_sp picture, TileMode tmx, TileMode tmy, +sk_sp SkPictureShader::Make(sk_sp picture, TileMode tmx, TileMode tmy, const SkMatrix* localMatrix, const SkRect* tile) { if (!picture || picture->cullRect().isEmpty() || (tile && tile->isEmpty())) { return SkShader::MakeEmptyShader(); @@ -223,8 +223,8 @@ sk_sp SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix, con tileMatrix.setRectToRect(fTile, SkRect::MakeIWH(tileSize.width(), tileSize.height()), SkMatrix::kFill_ScaleToFit); - sk_sp tileImage( - SkImage::MakeFromPicture(fPicture, tileSize, &tileMatrix, nullptr)); + SkAutoTUnref tileImage( + SkImage::NewFromPicture(fPicture.get(), tileSize, &tileMatrix, nullptr)); if (!tileImage) { return nullptr; } diff --git a/src/core/SkPictureShader.h b/src/core/SkPictureShader.h index 8f167b815e..eb9c38b95b 100644 --- a/src/core/SkPictureShader.h +++ b/src/core/SkPictureShader.h @@ -22,7 +22,7 @@ class SkPicture; */ class SkPictureShader : public SkShader { public: - static sk_sp Make(sk_sp, TileMode, TileMode, const SkMatrix*, + static sk_sp Make(sk_sp, TileMode, TileMode, const SkMatrix*, const SkRect*); SK_TO_STRING_OVERRIDE() @@ -42,14 +42,14 @@ protected: Context* onCreateContext(const ContextRec&, void* storage) const override; private: - SkPictureShader(sk_sp, TileMode, TileMode, const SkMatrix*, const SkRect*); + SkPictureShader(sk_sp, TileMode, TileMode, const SkMatrix*, const SkRect*); sk_sp refBitmapShader(const SkMatrix&, const SkMatrix* localMatrix, const int maxTextureSize = 0) const; - sk_sp fPicture; - SkRect fTile; - TileMode fTmx, fTmy; + sk_sp fPicture; + SkRect fTile; + TileMode fTmx, fTmy; class PictureShaderContext : public SkShader::Context { public: diff --git a/src/core/SkReadBuffer.cpp b/src/core/SkReadBuffer.cpp index 59d5172f81..6823a6cd8e 100644 --- a/src/core/SkReadBuffer.cpp +++ b/src/core/SkReadBuffer.cpp @@ -298,11 +298,11 @@ SkImage* SkReadBuffer::readImage() { return nullptr; } - sk_sp encoded(this->readByteArrayAsData()); + SkAutoTUnref encoded(this->readByteArrayAsData()); if (encoded->size() == 0) { // The image could not be encoded at serialization time - return an empty placeholder. - return SkImage::MakeFromGenerator( - new EmptyImageGenerator(SkImageInfo::MakeN32Premul(width, height))).release(); + return SkImage::NewFromGenerator( + new EmptyImageGenerator(SkImageInfo::MakeN32Premul(width, height))); } int originX = this->read32(); @@ -313,13 +313,13 @@ SkImage* SkReadBuffer::readImage() { } const SkIRect subset = SkIRect::MakeXYWH(originX, originY, width, height); - SkImage* image = SkImage::MakeFromEncoded(std::move(encoded), &subset).release(); + SkImage* image = SkImage::NewFromEncoded(encoded, &subset); if (image) { return image; } - return SkImage::MakeFromGenerator( - new EmptyImageGenerator(SkImageInfo::MakeN32Premul(width, height))).release(); + return SkImage::NewFromGenerator( + new EmptyImageGenerator(SkImageInfo::MakeN32Premul(width, height))); } SkTypeface* SkReadBuffer::readTypeface() { diff --git a/src/core/SkShader.cpp b/src/core/SkShader.cpp index 1413a6ee73..7b322fb627 100644 --- a/src/core/SkShader.cpp +++ b/src/core/SkShader.cpp @@ -238,7 +238,7 @@ sk_sp SkShader::MakeBitmapShader(const SkBitmap& src, TileMode tmx, Ti return SkMakeBitmapShader(src, tmx, tmy, localMatrix, nullptr); } -sk_sp SkShader::MakePictureShader(sk_sp src, TileMode tmx, TileMode tmy, +sk_sp SkShader::MakePictureShader(sk_sp src, TileMode tmx, TileMode tmy, const SkMatrix* localMatrix, const SkRect* tile) { return SkPictureShader::Make(std::move(src), tmx, tmy, localMatrix, tile); } @@ -388,7 +388,6 @@ SkShader* SkShader::CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode } SkShader* SkShader::CreatePictureShader(const SkPicture* src, TileMode tmx, TileMode tmy, const SkMatrix* localMatrix, const SkRect* tile) { - return MakePictureShader(sk_ref_sp(const_cast(src)), tmx, tmy, - localMatrix, tile).release(); + return MakePictureShader(sk_ref_sp(src), tmx, tmy, localMatrix, tile).release(); } #endif diff --git a/src/image/SkImage.cpp b/src/image/SkImage.cpp index ee4491e0b1..a41ac83d19 100644 --- a/src/image/SkImage.cpp +++ b/src/image/SkImage.cpp @@ -15,7 +15,6 @@ #include "SkImageShader.h" #include "SkImage_Base.h" #include "SkNextID.h" -#include "SkPicture.h" #include "SkPixelRef.h" #include "SkPixelSerializer.h" #include "SkReadPixelsRec.h" @@ -151,12 +150,12 @@ SkData* SkImage::refEncoded() const { return as_IB(this)->onRefEncoded(ctx); } -sk_sp SkImage::MakeFromEncoded(sk_sp encoded, const SkIRect* subset) { +SkImage* SkImage::NewFromEncoded(SkData* encoded, const SkIRect* subset) { if (nullptr == encoded || 0 == encoded->size()) { return nullptr; } - SkImageGenerator* generator = SkImageGenerator::NewFromEncoded(encoded.get()); - return SkImage::MakeFromGenerator(generator, subset); + SkImageGenerator* generator = SkImageGenerator::NewFromEncoded(encoded); + return generator ? SkImage::NewFromGenerator(generator, subset) : nullptr; } const char* SkImage::toString(SkString* str) const { @@ -165,7 +164,7 @@ const char* SkImage::toString(SkString* str) const { return str->c_str(); } -sk_sp SkImage::makeSubset(const SkIRect& subset) const { +SkImage* SkImage::newSubset(const SkIRect& subset) const { if (subset.isEmpty()) { return nullptr; } @@ -177,9 +176,9 @@ sk_sp SkImage::makeSubset(const SkIRect& subset) const { // optimization : return self if the subset == our bounds if (bounds == subset) { - return sk_ref_sp(const_cast(this)); + return SkRef(const_cast(this)); } - return as_IB(this)->onMakeSubset(subset); + return as_IB(this)->onNewSubset(subset); } #if SK_SUPPORT_GPU @@ -284,7 +283,7 @@ bool SkImage::readYUV8Planes(const SkISize sizes[3], void* const planes[3], /////////////////////////////////////////////////////////////////////////////////////////////////// -sk_sp SkImage::MakeFromBitmap(const SkBitmap& bm) { +SkImage* SkImage::NewFromBitmap(const SkBitmap& bm) { SkPixelRef* pr = bm.pixelRef(); if (nullptr == pr) { return nullptr; @@ -301,13 +300,13 @@ sk_sp SkImage::MakeFromBitmap(const SkBitmap& bm) { unrefCopy.reset(tex); } const SkImageInfo info = bm.info(); - return sk_make_sp(info.width(), info.height(), bm.getGenerationID(), - info.alphaType(), tex, SkBudgeted::kNo); + return new SkImage_Gpu(info.width(), info.height(), bm.getGenerationID(), info.alphaType(), + tex, SkBudgeted::kNo); } #endif // This will check for immutable (share or copy) - return SkMakeImageFromRasterBitmap(bm); + return SkNewImageFromRasterBitmap(bm); } bool SkImage::asLegacyBitmap(SkBitmap* bitmap, LegacyBitmapMode mode) const { @@ -333,13 +332,12 @@ bool SkImage_Base::onAsLegacyBitmap(SkBitmap* bitmap, LegacyBitmapMode mode) con return true; } -sk_sp SkImage::MakeFromPicture(sk_sp picture, const SkISize& dimensions, - const SkMatrix* matrix, const SkPaint* paint) { +SkImage* SkImage::NewFromPicture(const SkPicture* picture, const SkISize& dimensions, + const SkMatrix* matrix, const SkPaint* paint) { if (!picture) { return nullptr; } - return MakeFromGenerator(SkImageGenerator::NewFromPicture(dimensions, picture.release(), - matrix, paint)); + return NewFromGenerator(SkImageGenerator::NewFromPicture(dimensions, picture, matrix, paint)); } bool SkImage::isLazyGenerated() const { @@ -350,95 +348,25 @@ bool SkImage::isLazyGenerated() const { #if !SK_SUPPORT_GPU -sk_sp SkImage::MakeTextureFromPixmap(GrContext*, const SkPixmap&, SkBudgeted budgeted) { - return nullptr; -} - -sk_sp SkImage::MakeFromTexture(GrContext*, const GrBackendTextureDesc&, SkAlphaType, - TextureReleaseProc, ReleaseContext) { +SkImage* SkImage::NewTextureFromPixmap(GrContext*, const SkPixmap&, SkBudgeted budgeted) { return nullptr; } -sk_sp SkImage::MakeFromAdoptedTexture(GrContext*, const GrBackendTextureDesc&, - SkAlphaType) { +SkImage* SkImage::NewFromTexture(GrContext*, const GrBackendTextureDesc&, SkAlphaType, + TextureReleaseProc, ReleaseContext) { return nullptr; } -sk_sp SkImage::MakeFromTextureCopy(GrContext*, const GrBackendTextureDesc&, SkAlphaType) { +SkImage* SkImage::NewFromAdoptedTexture(GrContext*, const GrBackendTextureDesc&, SkAlphaType) { return nullptr; } -sk_sp SkImage::MakeFromYUVTexturesCopy(GrContext* ctx, SkYUVColorSpace space, - const GrBackendObject yuvTextureHandles[3], - const SkISize yuvSizes[3], - GrSurfaceOrigin origin) { +SkImage* SkImage::NewFromTextureCopy(GrContext*, const GrBackendTextureDesc&, SkAlphaType) { return nullptr; } -sk_sp SkImage::makeTextureImage(GrContext*) const { +SkImage* SkImage::newTextureImage(GrContext*) const { return nullptr; } #endif - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -#ifdef SK_SUPPORT_LEGACY_IMAGEFACTORY -SkImage* SkImage::NewRasterCopy(const Info& info, const void* pixels, size_t rowBytes, - SkColorTable* ctable) { - return MakeRasterCopy(SkPixmap(info, pixels, rowBytes, ctable)).release(); -} - -SkImage* SkImage::NewRasterData(const Info& info, SkData* pixels, size_t rowBytes) { - return MakeRasterData(info, sk_ref_sp(pixels), rowBytes).release(); -} - -SkImage* SkImage::NewFromRaster(const Info& info, const void* pixels, size_t rowBytes, - RasterReleaseProc proc, ReleaseContext releasectx) { - return MakeFromRaster(SkPixmap(info, pixels, rowBytes), proc, releasectx).release(); -} - -SkImage* SkImage::NewFromBitmap(const SkBitmap& bm) { - return MakeFromBitmap(bm).release(); -} - -SkImage* SkImage::NewFromGenerator(SkImageGenerator* gen, const SkIRect* subset) { - return MakeFromGenerator(gen, subset).release(); -} - -SkImage* SkImage::NewFromEncoded(SkData* encoded, const SkIRect* subset) { - return MakeFromEncoded(sk_ref_sp(encoded), subset).release(); -} - -SkImage* SkImage::NewFromTexture(GrContext* ctx, const GrBackendTextureDesc& desc, SkAlphaType at, - TextureReleaseProc proc, ReleaseContext releasectx) { - return MakeFromTexture(ctx, desc, at, proc, releasectx).release(); -} - -SkImage* SkImage::NewFromAdoptedTexture(GrContext* ctx, const GrBackendTextureDesc& desc, - SkAlphaType at) { - return MakeFromAdoptedTexture(ctx, desc, at).release(); -} - -SkImage* SkImage::NewFromTextureCopy(GrContext* ctx, const GrBackendTextureDesc& desc, - SkAlphaType at) { - return MakeFromTextureCopy(ctx, desc, at).release(); -} - -SkImage* SkImage::NewFromYUVTexturesCopy(GrContext* ctx, SkYUVColorSpace space, - const GrBackendObject yuvTextureHandles[3], - const SkISize yuvSizes[3], - GrSurfaceOrigin origin) { - return MakeFromYUVTexturesCopy(ctx, space, yuvTextureHandles, yuvSizes, origin).release(); -} - -SkImage* SkImage::NewFromPicture(const SkPicture* picture, const SkISize& dimensions, - const SkMatrix* matrix, const SkPaint* paint) { - return MakeFromPicture(sk_ref_sp(const_cast(picture)), dimensions, - matrix, paint).release(); -} - -SkImage* SkImage::NewTextureFromPixmap(GrContext* ctx, const SkPixmap& pmap, SkBudgeted budgeted) { - return MakeTextureFromPixmap(ctx, pmap, budgeted).release(); -} -#endif diff --git a/src/image/SkImagePriv.h b/src/image/SkImagePriv.h index a625472eaa..acd0beb475 100644 --- a/src/image/SkImagePriv.h +++ b/src/image/SkImagePriv.h @@ -12,9 +12,9 @@ #include "SkSurface.h" // Call this if you explicitly want to use/share this pixelRef in the image -extern sk_sp SkMakeImageFromPixelRef(const SkImageInfo&, SkPixelRef*, - const SkIPoint& pixelRefOrigin, - size_t rowBytes); +extern SkImage* SkNewImageFromPixelRef(const SkImageInfo&, SkPixelRef*, + const SkIPoint& pixelRefOrigin, + size_t rowBytes); /** * Examines the bitmap to decide if it can share the existing pixelRef, or @@ -38,8 +38,7 @@ enum ForceCopyMode { kNo_ForceCopyMode, kYes_ForceCopyMode, // must copy the pixels even if the bitmap is immutable }; -extern sk_sp SkMakeImageFromRasterBitmap(const SkBitmap&, - ForceCopyMode = kNo_ForceCopyMode); +extern SkImage* SkNewImageFromRasterBitmap(const SkBitmap&, ForceCopyMode = kNo_ForceCopyMode); // Given an image created from SkNewImageFromBitmap, return its pixelref. This // may be called to see if the surface and the image share the same pixelref, diff --git a/src/image/SkImage_Base.h b/src/image/SkImage_Base.h index ade891f4cb..9e2efe98b5 100644 --- a/src/image/SkImage_Base.h +++ b/src/image/SkImage_Base.h @@ -46,7 +46,7 @@ public: // Caller must call unref when they are done. virtual GrTexture* asTextureRef(GrContext*, const GrTextureParams&) const = 0; - virtual sk_sp onMakeSubset(const SkIRect&) const = 0; + virtual SkImage* onNewSubset(const SkIRect&) const = 0; // If a ctx is specified, then only gpu-specific formats are requested. virtual SkData* onRefEncoded(GrContext*) const { return nullptr; } diff --git a/src/image/SkImage_Generator.cpp b/src/image/SkImage_Generator.cpp index 62b492e288..95cc426a43 100644 --- a/src/image/SkImage_Generator.cpp +++ b/src/image/SkImage_Generator.cpp @@ -25,7 +25,7 @@ public: SkImageCacherator* peekCacherator() const override { return fCache; } SkData* onRefEncoded(GrContext*) const override; bool isOpaque() const override { return fCache->info().isOpaque(); } - sk_sp onMakeSubset(const SkIRect&) const override; + SkImage* onNewSubset(const SkIRect&) const override; bool getROPixels(SkBitmap*, CachingHint) const override; GrTexture* asTextureRef(GrContext*, const GrTextureParams&) const override; bool onIsLazyGenerated() const override { return true; } @@ -73,7 +73,7 @@ GrTexture* SkImage_Generator::asTextureRef(GrContext* ctx, const GrTextureParams return fCache->lockAsTexture(ctx, params, this); } -sk_sp SkImage_Generator::onMakeSubset(const SkIRect& subset) const { +SkImage* SkImage_Generator::onNewSubset(const SkIRect& subset) const { // TODO: make this lazy, by wrapping the subset inside a new generator or something // For now, we do effectively what we did before, make it a raster @@ -86,16 +86,13 @@ sk_sp SkImage_Generator::onMakeSubset(const SkIRect& subset) const { surface->getCanvas()->clear(0); surface->getCanvas()->drawImage(this, SkIntToScalar(-subset.x()), SkIntToScalar(-subset.y()), nullptr); - return sk_sp(surface->newImageSnapshot()); + return surface->newImageSnapshot(); } -sk_sp SkImage::MakeFromGenerator(SkImageGenerator* generator, const SkIRect* subset) { - if (!generator) { - return nullptr; - } +SkImage* SkImage::NewFromGenerator(SkImageGenerator* generator, const SkIRect* subset) { SkImageCacherator* cache = SkImageCacherator::NewFromGenerator(generator, subset); if (!cache) { return nullptr; } - return sk_make_sp(cache); + return new SkImage_Generator(cache); } diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp index 6494fd1a17..b87e50ba0a 100644 --- a/src/image/SkImage_Gpu.cpp +++ b/src/image/SkImage_Gpu.cpp @@ -134,7 +134,7 @@ bool SkImage_Gpu::onReadPixels(const SkImageInfo& info, void* pixels, size_t row return true; } -sk_sp SkImage_Gpu::onMakeSubset(const SkIRect& subset) const { +SkImage* SkImage_Gpu::onNewSubset(const SkIRect& subset) const { GrContext* ctx = fTexture->getContext(); GrSurfaceDesc desc = fTexture->desc(); desc.fWidth = subset.width(); @@ -145,16 +145,16 @@ sk_sp SkImage_Gpu::onMakeSubset(const SkIRect& subset) const { return nullptr; } ctx->copySurface(subTx, fTexture, subset, SkIPoint::Make(0, 0)); - return sk_make_sp(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID, - fAlphaType, subTx, fBudgeted); + return new SkImage_Gpu(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID, fAlphaType, subTx, + fBudgeted); } /////////////////////////////////////////////////////////////////////////////////////////////////// -static sk_sp new_wrapped_texture_common(GrContext* ctx, const GrBackendTextureDesc& desc, - SkAlphaType at, GrWrapOwnership ownership, - SkImage::TextureReleaseProc releaseProc, - SkImage::ReleaseContext releaseCtx) { +static SkImage* new_wrapped_texture_common(GrContext* ctx, const GrBackendTextureDesc& desc, + SkAlphaType at, GrWrapOwnership ownership, + SkImage::TextureReleaseProc releaseProc, + SkImage::ReleaseContext releaseCtx) { if (desc.fWidth <= 0 || desc.fHeight <= 0) { return nullptr; } @@ -167,23 +167,21 @@ static sk_sp new_wrapped_texture_common(GrContext* ctx, const GrBackend } const SkBudgeted budgeted = SkBudgeted::kNo; - return sk_make_sp(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID, - at, tex, budgeted); + return new SkImage_Gpu(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID, at, tex, budgeted); } -sk_sp SkImage::MakeFromTexture(GrContext* ctx, const GrBackendTextureDesc& desc, - SkAlphaType at, TextureReleaseProc releaseP, - ReleaseContext releaseC) { +SkImage* SkImage::NewFromTexture(GrContext* ctx, const GrBackendTextureDesc& desc, SkAlphaType at, + TextureReleaseProc releaseP, ReleaseContext releaseC) { return new_wrapped_texture_common(ctx, desc, at, kBorrow_GrWrapOwnership, releaseP, releaseC); } -sk_sp SkImage::MakeFromAdoptedTexture(GrContext* ctx, const GrBackendTextureDesc& desc, - SkAlphaType at) { +SkImage* SkImage::NewFromAdoptedTexture(GrContext* ctx, const GrBackendTextureDesc& desc, + SkAlphaType at) { return new_wrapped_texture_common(ctx, desc, at, kAdopt_GrWrapOwnership, nullptr, nullptr); } -sk_sp SkImage::MakeFromTextureCopy(GrContext* ctx, const GrBackendTextureDesc& desc, - SkAlphaType at) { +SkImage* SkImage::NewFromTextureCopy(GrContext* ctx, const GrBackendTextureDesc& desc, + SkAlphaType at) { if (desc.fWidth <= 0 || desc.fHeight <= 0) { return nullptr; } @@ -199,14 +197,14 @@ sk_sp SkImage::MakeFromTextureCopy(GrContext* ctx, const GrBackendTextu return nullptr; } - return sk_make_sp(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID, at, dst, - SkBudgeted::kYes); + return new SkImage_Gpu(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID, at, dst, + SkBudgeted::kYes); } -sk_sp SkImage::MakeFromYUVTexturesCopy(GrContext* ctx , SkYUVColorSpace colorSpace, - const GrBackendObject yuvTextureHandles[3], - const SkISize yuvSizes[3], - GrSurfaceOrigin origin) { +SkImage* SkImage::NewFromYUVTexturesCopy(GrContext* ctx , SkYUVColorSpace colorSpace, + const GrBackendObject yuvTextureHandles[3], + const SkISize yuvSizes[3], + GrSurfaceOrigin origin) { const SkBudgeted budgeted = SkBudgeted::kYes; if (yuvSizes[0].fWidth <= 0 || yuvSizes[0].fHeight <= 0 || @@ -277,25 +275,25 @@ sk_sp SkImage::MakeFromYUVTexturesCopy(GrContext* ctx , SkYUVColorSpace drawContext->drawRect(GrClip::WideOpen(), paint, SkMatrix::I(), rect); ctx->flushSurfaceWrites(dst); - return sk_make_sp(dstDesc.fWidth, dstDesc.fHeight, kNeedNewImageUniqueID, - kOpaque_SkAlphaType, dst, budgeted); + return new SkImage_Gpu(dstDesc.fWidth, dstDesc.fHeight, kNeedNewImageUniqueID, + kOpaque_SkAlphaType, dst, budgeted); } -static sk_sp create_image_from_maker(GrTextureMaker* maker, SkAlphaType at, uint32_t id) { +static SkImage* create_image_from_maker(GrTextureMaker* maker, SkAlphaType at, uint32_t id) { SkAutoTUnref texture(maker->refTextureForParams(GrTextureParams::ClampNoFilter())); if (!texture) { return nullptr; } - return sk_make_sp(texture->width(), texture->height(), id, at, texture, - SkBudgeted::kNo); + return new SkImage_Gpu(texture->width(), texture->height(), id, at, texture, + SkBudgeted::kNo); } -sk_sp SkImage::makeTextureImage(GrContext *context) const { +SkImage* SkImage::newTextureImage(GrContext *context) const { if (!context) { return nullptr; } if (GrTexture* peek = as_IB(this)->peekTexture()) { - return peek->getContext() == context ? sk_ref_sp(const_cast(this)) : nullptr; + return peek->getContext() == context ? SkRef(const_cast(this)) : nullptr; } // No way to check whether a image is premul or not? SkAlphaType at = this->isOpaque() ? kOpaque_SkAlphaType : kPremul_SkAlphaType; @@ -312,8 +310,8 @@ sk_sp SkImage::makeTextureImage(GrContext *context) const { return create_image_from_maker(&maker, at, this->uniqueID()); } -sk_sp SkImage::MakeTextureFromPixmap(GrContext* ctx, const SkPixmap& pixmap, - SkBudgeted budgeted) { +SkImage* SkImage::NewTextureFromPixmap(GrContext* ctx, const SkPixmap& pixmap, + SkBudgeted budgeted) { if (!ctx) { return nullptr; } @@ -321,8 +319,8 @@ sk_sp SkImage::MakeTextureFromPixmap(GrContext* ctx, const SkPixmap& pi if (!texture) { return nullptr; } - return sk_make_sp(texture->width(), texture->height(), kNeedNewImageUniqueID, - pixmap.alphaType(), texture, budgeted); + return new SkImage_Gpu(texture->width(), texture->height(), kNeedNewImageUniqueID, + pixmap.alphaType(), texture, budgeted); } /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/image/SkImage_Gpu.h b/src/image/SkImage_Gpu.h index 8f59af14a4..c640322a65 100644 --- a/src/image/SkImage_Gpu.h +++ b/src/image/SkImage_Gpu.h @@ -35,7 +35,7 @@ public: bool getROPixels(SkBitmap*, CachingHint) const override; GrTexture* asTextureRef(GrContext* ctx, const GrTextureParams& params) const override; - sk_sp onMakeSubset(const SkIRect&) const override; + SkImage* onNewSubset(const SkIRect&) const override; GrTexture* peekTexture() const override { return fTexture; } bool isOpaque() const override; diff --git a/src/image/SkImage_Raster.cpp b/src/image/SkImage_Raster.cpp index 7f2f5c07ef..5bd0e1d8f1 100644 --- a/src/image/SkImage_Raster.cpp +++ b/src/image/SkImage_Raster.cpp @@ -63,7 +63,7 @@ public: return true; } - SkImage_Raster(const SkImageInfo&, sk_sp, size_t rb, SkColorTable*); + SkImage_Raster(const SkImageInfo&, SkData*, size_t rb, SkColorTable*); virtual ~SkImage_Raster(); bool onReadPixels(const SkImageInfo&, void*, size_t, int srcX, int srcY, CachingHint) const override; @@ -71,7 +71,7 @@ public: SkData* onRefEncoded(GrContext*) const override; bool getROPixels(SkBitmap*, CachingHint) const override; GrTexture* asTextureRef(GrContext*, const GrTextureParams&) const override; - sk_sp onMakeSubset(const SkIRect&) const override; + SkImage* onNewSubset(const SkIRect&) const override; // exposed for SkSurface_Raster via SkNewImageFromPixelRef SkImage_Raster(const SkImageInfo&, SkPixelRef*, const SkIPoint& origin, size_t rowBytes); @@ -110,13 +110,14 @@ static void release_data(void* addr, void* context) { data->unref(); } -SkImage_Raster::SkImage_Raster(const Info& info, sk_sp data, size_t rowBytes, +SkImage_Raster::SkImage_Raster(const Info& info, SkData* data, size_t rowBytes, SkColorTable* ctable) : INHERITED(info.width(), info.height(), kNeedNewImageUniqueID) { + data->ref(); void* addr = const_cast(data->data()); - fBitmap.installPixels(info, addr, rowBytes, ctable, release_data, data.release()); + fBitmap.installPixels(info, addr, rowBytes, ctable, release_data, data); fBitmap.setImmutable(); fBitmap.lockPixels(); } @@ -172,7 +173,7 @@ GrTexture* SkImage_Raster::asTextureRef(GrContext* ctx, const GrTextureParams& p return nullptr; } -sk_sp SkImage_Raster::onMakeSubset(const SkIRect& subset) const { +SkImage* SkImage_Raster::onNewSubset(const SkIRect& subset) const { // TODO : could consider heurist of sharing pixels, if subset is pretty close to complete SkImageInfo info = SkImageInfo::MakeN32(subset.width(), subset.height(), fBitmap.alphaType()); @@ -183,26 +184,25 @@ sk_sp SkImage_Raster::onMakeSubset(const SkIRect& subset) const { surface->getCanvas()->clear(0); surface->getCanvas()->drawImage(this, SkIntToScalar(-subset.x()), SkIntToScalar(-subset.y()), nullptr); - return sk_sp(surface->newImageSnapshot()); + return surface->newImageSnapshot(); } /////////////////////////////////////////////////////////////////////////////// -sk_sp SkImage::MakeRasterCopy(const SkPixmap& pmap) { +SkImage* SkImage::NewRasterCopy(const SkImageInfo& info, const void* pixels, size_t rowBytes, + SkColorTable* ctable) { size_t size; - if (!SkImage_Raster::ValidArgs(pmap.info(), pmap.rowBytes(), - pmap.ctable() != nullptr, &size) || !pmap.addr()) { + if (!SkImage_Raster::ValidArgs(info, rowBytes, ctable != nullptr, &size) || !pixels) { return nullptr; } // Here we actually make a copy of the caller's pixel data - sk_sp data(SkData::NewWithCopy(pmap.addr(), size)); - return sk_make_sp(pmap.info(), std::move(data), pmap.rowBytes(), pmap.ctable()); + SkAutoDataUnref data(SkData::NewWithCopy(pixels, size)); + return new SkImage_Raster(info, data, rowBytes, ctable); } -sk_sp SkImage::MakeRasterData(const SkImageInfo& info, sk_sp data, - size_t rowBytes) { +SkImage* SkImage::NewRasterData(const SkImageInfo& info, SkData* data, size_t rowBytes) { size_t size; if (!SkImage_Raster::ValidArgs(info, rowBytes, false, &size) || !data) { return nullptr; @@ -214,29 +214,30 @@ sk_sp SkImage::MakeRasterData(const SkImageInfo& info, sk_sp da } SkColorTable* ctable = nullptr; - return sk_make_sp(info, std::move(data), rowBytes, ctable); + return new SkImage_Raster(info, data, rowBytes, ctable); } -sk_sp SkImage::MakeFromRaster(const SkPixmap& pmap, RasterReleaseProc proc, - ReleaseContext ctx) { +SkImage* SkImage::NewFromRaster(const SkImageInfo& info, const void* pixels, size_t rowBytes, + RasterReleaseProc proc, ReleaseContext ctx) { size_t size; - if (!SkImage_Raster::ValidArgs(pmap.info(), pmap.rowBytes(), false, &size) || !pmap.addr()) { + if (!SkImage_Raster::ValidArgs(info, rowBytes, false, &size) || !pixels) { return nullptr; } - sk_sp data(SkData::NewWithProc(pmap.addr(), size, proc, ctx)); - return sk_make_sp(pmap.info(), std::move(data), pmap.rowBytes(), pmap.ctable()); + SkColorTable* ctable = nullptr; + SkAutoDataUnref data(SkData::NewWithProc(pixels, size, proc, ctx)); + return new SkImage_Raster(info, data, rowBytes, ctable); } -sk_sp SkMakeImageFromPixelRef(const SkImageInfo& info, SkPixelRef* pr, - const SkIPoint& pixelRefOrigin, size_t rowBytes) { +SkImage* SkNewImageFromPixelRef(const SkImageInfo& info, SkPixelRef* pr, + const SkIPoint& pixelRefOrigin, size_t rowBytes) { if (!SkImage_Raster::ValidArgs(info, rowBytes, false, nullptr)) { return nullptr; } - return sk_make_sp(info, pr, pixelRefOrigin, rowBytes); + return new SkImage_Raster(info, pr, pixelRefOrigin, rowBytes); } -sk_sp SkMakeImageFromRasterBitmap(const SkBitmap& bm, ForceCopyMode forceCopy) { +SkImage* SkNewImageFromRasterBitmap(const SkBitmap& bm, ForceCopyMode forceCopy) { SkASSERT(nullptr == bm.getTexture()); bool hasColorTable = false; @@ -249,16 +250,16 @@ sk_sp SkMakeImageFromRasterBitmap(const SkBitmap& bm, ForceCopyMode for return nullptr; } - sk_sp image; + SkImage* image = nullptr; if (kYes_ForceCopyMode == forceCopy || !bm.isImmutable()) { SkBitmap tmp(bm); tmp.lockPixels(); - SkPixmap pmap; - if (tmp.getPixels() && tmp.peekPixels(&pmap)) { - image = SkImage::MakeRasterCopy(pmap); + if (tmp.getPixels()) { + image = SkImage::NewRasterCopy(tmp.info(), tmp.getPixels(), tmp.rowBytes(), + tmp.getColorTable()); } } else { - image = sk_make_sp(bm); + image = new SkImage_Raster(bm); } return image; } diff --git a/src/image/SkSurface_Raster.cpp b/src/image/SkSurface_Raster.cpp index 192415341f..d07e94998f 100644 --- a/src/image/SkSurface_Raster.cpp +++ b/src/image/SkSurface_Raster.cpp @@ -131,7 +131,7 @@ SkImage* SkSurface_Raster::onNewImageSnapshot(SkBudgeted, ForceCopyMode forceCop // Our pixels are in memory, so read access on the snapshot SkImage could be cheap. // Lock the shared pixel ref to ensure peekPixels() is usable. - return SkMakeImageFromRasterBitmap(fBitmap, forceCopyMode).release(); + return SkNewImageFromRasterBitmap(fBitmap, forceCopyMode); } void SkSurface_Raster::onRestoreBackingMutability() { diff --git a/src/utils/SkBitmapSourceDeserializer.cpp b/src/utils/SkBitmapSourceDeserializer.cpp index eb66fd909d..bb783bfeef 100644 --- a/src/utils/SkBitmapSourceDeserializer.cpp +++ b/src/utils/SkBitmapSourceDeserializer.cpp @@ -29,5 +29,6 @@ SkFlattenable* SkBitmapSourceDeserializer::CreateProc(SkReadBuffer& buffer) { } bitmap.setImmutable(); - return SkImageSource::Create(SkImage::MakeFromBitmap(bitmap).get(), src, dst, filterQuality); + SkAutoTUnref image(SkImage::NewFromBitmap(bitmap)); + return SkImageSource::Create(image, src, dst, filterQuality); } -- cgit v1.2.3