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

Make SkImageCacherator be deferred (take 2)

Browse Source 
Split out of: https://skia-review.googlesource.com/c/8823/ (Remove GrFragmentProcessor-derived class' GrTexture-based ctors)

This is a second pass at: https://skia-review.googlesource.com/c/9945/ (Make SkImageCacherator be deferred)

Change-Id: I3451383eed497d1235686e8961087859c7c7bd30
Reviewed-on: https://skia-review.googlesource.com/10034
Reviewed-by: Robert Phillips <robertphillips@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>
This commit is contained in:
Robert Phillips 2017-03-23 08:21:00 -04:00 committed by Skia Commit-Bot
parent 5df93de8ad
commit 4f358be6b7
7 changed files with 78 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
gm/image_pict.cpp
View File

@ -344,12 +344,11 @@ protected:
static void draw_as_tex(SkCanvas* canvas, SkImageCacherator* cache, SkScalar x, SkScalar y) {
#if SK_SUPPORT_GPU
sk_sp<SkColorSpace> texColorSpace;
// MDB TODO: this should be lockAsTextureRef
sk_sp<GrTexture> texture(
cache->lockAsTexture(canvas->getGrContext(), GrSamplerParams::ClampBilerp(),
canvas->imageInfo().colorSpace(), &texColorSpace,
nullptr, nullptr));
if (!texture) {
sk_sp<GrTextureProxy> proxy(
cache->lockAsTextureProxy(canvas->getGrContext(), GrSamplerParams::ClampBilerp(),
canvas->imageInfo().colorSpace(), &texColorSpace,
nullptr, nullptr));
if (!proxy) {
// show placeholder if we have no texture
SkPaint paint;
paint.setStyle(SkPaint::kStroke_Style);
@ -361,8 +360,6 @@ protected:
return;
}
sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeWrapped(std::move(texture));
// No API to draw a GrTexture directly, so we cheat and create a private image subclass
sk_sp<SkImage> image(new SkImage_Gpu(canvas->getGrContext(),
cache->uniqueID(), kPremul_SkAlphaType,

80
src/core/SkImageCacherator.cpp
View File

@ -485,22 +485,12 @@ public:
}
};
static GrTexture* set_key_and_return(GrResourceProvider* resourceProvider,
GrTexture* tex, const GrUniqueKey& key) {
if (key.isValid()) {
resourceProvider->assignUniqueKeyToTexture(key, tex);
}
return tex;
}
#if 0
static void set_key_on_proxy(GrResourceProvider* resourceProvider,
GrTextureProxy* proxy, const GrUniqueKey& key) {
if (key.isValid()) {
resourceProvider->assignUniqueKeyToProxy(key, proxy);
}
}
#endif
sk_sp<SkColorSpace> SkImageCacherator::getColorSpace(GrContext* ctx, SkColorSpace* dstColorSpace) {
// TODO: This isn't always correct. Picture generator currently produces textures in N32,
@ -520,9 +510,12 @@ sk_sp<SkColorSpace> SkImageCacherator::getColorSpace(GrContext* ctx, SkColorSpac
* 4. Ask the generator to return YUV planes, which the GPU can convert
* 5. Ask the generator to return RGB(A) data, which the GPU can convert
*/
GrTexture* SkImageCacherator::lockTexture(GrContext* ctx, const GrUniqueKey& origKey,
const SkImage* client, SkImage::CachingHint chint,
bool willBeMipped, SkColorSpace* dstColorSpace) {
sk_sp<GrTextureProxy> SkImageCacherator::lockTextureProxy(GrContext* ctx,
const GrUniqueKey& origKey,
const SkImage* client,
SkImage::CachingHint chint,
bool willBeMipped,
SkColorSpace* dstColorSpace) {
// Values representing the various texture lock paths we can take. Used for logging the path
// taken to a histogram.
enum LockTexturePath {
@ -546,10 +539,10 @@ GrTexture* SkImageCacherator::lockTexture(GrContext* ctx, const GrUniqueKey& ori
// 1. Check the cache for a pre-existing one
if (key.isValid()) {
if (GrTexture* tex = ctx->resourceProvider()->findAndRefTextureByUniqueKey(key)) {
if (sk_sp<GrTextureProxy> proxy = ctx->resourceProvider()->findProxyByUniqueKey(key)) {
SK_HISTOGRAM_ENUMERATION("LockTexturePath", kPreExisting_LockTexturePath,
kLockTexturePathCount);
return tex;
return proxy;
}
}
@ -564,10 +557,8 @@ GrTexture* SkImageCacherator::lockTexture(GrContext* ctx, const GrUniqueKey& ori
if (sk_sp<GrTextureProxy> proxy = generator->generateTexture(ctx, cacheInfo, fOrigin)) {
SK_HISTOGRAM_ENUMERATION("LockTexturePath", kNative_LockTexturePath,
kLockTexturePathCount);
GrTexture* tex2 = proxy->instantiate(ctx->resourceProvider());
if (tex2) {
return set_key_and_return(ctx->resourceProvider(), SkRef(tex2), key);
}
set_key_on_proxy(ctx->resourceProvider(), proxy.get(), key);
return proxy;
}
}
@ -593,27 +584,26 @@ GrTexture* SkImageCacherator::lockTexture(GrContext* ctx, const GrUniqueKey& ori
if (sk_sp<GrTextureProxy> proxy = provider.refAsTextureProxy(ctx, desc, true)) {
SK_HISTOGRAM_ENUMERATION("LockTexturePath", kYUV_LockTexturePath,
kLockTexturePathCount);
GrTexture* tex2 = proxy->instantiate(ctx->resourceProvider());
if (tex2) {
return set_key_and_return(ctx->resourceProvider(), SkRef(tex2), key);
}
set_key_on_proxy(ctx->resourceProvider(), proxy.get(), key);
return proxy;
}
}
// 5. Ask the generator to return RGB(A) data, which the GPU can convert
SkBitmap bitmap;
if (this->tryLockAsBitmap(&bitmap, client, chint, format, cacheInfo)) {
GrTexture* tex = nullptr;
sk_sp<GrTextureProxy> proxy;
if (willBeMipped) {
tex = GrGenerateMipMapsAndUploadToTexture(ctx, bitmap, dstColorSpace);
proxy = GrGenerateMipMapsAndUploadToTextureProxy(ctx, bitmap, dstColorSpace);
}
if (!tex) {
tex = GrUploadBitmapToTexture(ctx, bitmap);
if (!proxy) {
proxy = GrUploadBitmapToTextureProxy(ctx->resourceProvider(), bitmap);
}
if (tex) {
if (proxy) {
SK_HISTOGRAM_ENUMERATION("LockTexturePath", kRGBA_LockTexturePath,
kLockTexturePathCount);
return set_key_and_return(ctx->resourceProvider(), tex, key);
set_key_on_proxy(ctx->resourceProvider(), proxy.get(), key);
return proxy;
}
}
SK_HISTOGRAM_ENUMERATION("LockTexturePath", kFailure_LockTexturePath,
@ -623,29 +613,23 @@ GrTexture* SkImageCacherator::lockTexture(GrContext* ctx, const GrUniqueKey& ori
///////////////////////////////////////////////////////////////////////////////////////////////////
GrTexture* SkImageCacherator::lockAsTexture(GrContext* ctx, const GrSamplerParams& params,
SkColorSpace* dstColorSpace,
sk_sp<SkColorSpace>* texColorSpace,
const SkImage* client,
SkScalar scaleAdjust[2],
SkImage::CachingHint chint) {
sk_sp<GrTextureProxy> SkImageCacherator::lockAsTextureProxy(GrContext* ctx,
const GrSamplerParams& params,
SkColorSpace* dstColorSpace,
sk_sp<SkColorSpace>* texColorSpace,
const SkImage* client,
SkScalar scaleAdjust[2],
SkImage::CachingHint chint) {
if (!ctx) {
return nullptr;
}
return GrImageTextureMaker(ctx, this, client, chint).refTextureForParams(params, dstColorSpace,
texColorSpace,
scaleAdjust);
}
#else
GrTexture* SkImageCacherator::lockAsTexture(GrContext* ctx, const GrSamplerParams&,
SkColorSpace* dstColorSpace,
sk_sp<SkColorSpace>* texColorSpace,
const SkImage* client,
SkScalar scaleAdjust[2], SkImage::CachingHint) {
return nullptr;
sk_sp<GrTexture> tex(GrImageTextureMaker(ctx, this, client, chint).refTextureForParams(
params,
dstColorSpace,
texColorSpace,
scaleAdjust));
return GrSurfaceProxy::MakeWrapped(std::move(tex));
}
#endif

25
src/core/SkImageCacherator.h
View File

@ -15,6 +15,7 @@
class GrCaps;
class GrContext;
class GrSamplerParams;
class GrTextureProxy;
class GrUniqueKey;
class SkBitmap;
class SkImage;
@ -51,6 +52,7 @@ public:
bool lockAsBitmap(GrContext*, SkBitmap*, const SkImage* client, SkColorSpace* dstColorSpace,
SkImage::CachingHint = SkImage::kAllow_CachingHint);
#if SK_SUPPORT_GPU
/**
* Returns a ref() on the texture produced by this generator. The caller must call unref()
* when it is done. Will return nullptr on failure.
@ -58,17 +60,20 @@ public:
* If not NULL, the client will be notified (->notifyAddedToCache()) when resources are
* added to the cache on its behalf.
*
* The caller is responsible for calling texture->unref() when they are done.
* The caller is responsible for calling proxy->unref() when they are done.
*
* The scaleAdjust in/out parameter will return any scale adjustment that needs
* to be applied to the absolute texture coordinates in the case where the image
* was resized to meet the sampling requirements (e.g., resized out to the next power of 2).
* It can be null if the caller knows resizing will not be required.
*/
GrTexture* lockAsTexture(GrContext*, const GrSamplerParams&, SkColorSpace* dstColorSpace,
sk_sp<SkColorSpace>* texColorSpace, const SkImage* client,
SkScalar scaleAdjust[2],
SkImage::CachingHint = SkImage::kAllow_CachingHint);
sk_sp<GrTextureProxy> lockAsTextureProxy(GrContext*, const GrSamplerParams&,
SkColorSpace* dstColorSpace,
sk_sp<SkColorSpace>* texColorSpace,
const SkImage* client,
SkScalar scaleAdjust[2],
SkImage::CachingHint = SkImage::kAllow_CachingHint);
#endif
/**
* If the underlying src naturally is represented by an encoded blob (in SkData), this returns
@ -129,10 +134,14 @@ private:
bool tryLockAsBitmap(SkBitmap*, const SkImage*, SkImage::CachingHint, CachedFormat,
const SkImageInfo&);
#if SK_SUPPORT_GPU
// Returns the texture. If the cacherator is generating the texture and wants to cache it,
// Returns the texture proxy. If the cacherator is generating the texture and wants to cache it,
// it should use the passed in key (if the key is valid).
GrTexture* lockTexture(GrContext*, const GrUniqueKey& key, const SkImage* client,
SkImage::CachingHint, bool willBeMipped, SkColorSpace* dstColorSpace);
sk_sp<GrTextureProxy> lockTextureProxy(GrContext*,
const GrUniqueKey& key,
const SkImage* client,
SkImage::CachingHint,
bool willBeMipped,
SkColorSpace* dstColorSpace);
// Returns the color space of the texture that would be returned if you called lockTexture.
// Separate code path to allow querying of the color space for textures that cached (even
// externally).

17
src/gpu/GrImageTextureMaker.cpp
View File

@ -32,16 +32,21 @@ GrImageTextureMaker::GrImageTextureMaker(GrContext* context, SkImageCacherator*
}
GrTexture* GrImageTextureMaker::refOriginalTexture(bool willBeMipped, SkColorSpace* dstColorSpace) {
return fCacher->lockTexture(this->context(), fOriginalKey, fClient, fCachingHint, willBeMipped,
dstColorSpace);
sk_sp<GrTextureProxy> proxy = fCacher->lockTextureProxy(this->context(), fOriginalKey,
fClient, fCachingHint, willBeMipped,
dstColorSpace);
if (!proxy) {
return nullptr;
}
sk_sp<GrTexture> tex(SkSafeRef(proxy->instantiate(this->context()->resourceProvider())));
return tex.release();
}
sk_sp<GrTextureProxy> GrImageTextureMaker::refOriginalTextureProxy(bool willBeMipped,
SkColorSpace* dstColorSpace) {
sk_sp<GrTexture> tex(fCacher->lockTexture(this->context(), fOriginalKey, fClient, fCachingHint,
willBeMipped, dstColorSpace));
return GrSurfaceProxy::MakeWrapped(std::move(tex));
return fCacher->lockTextureProxy(this->context(), fOriginalKey, fClient, fCachingHint,
willBeMipped, dstColorSpace);
}
void GrImageTextureMaker::makeCopyKey(const CopyParams& stretch, GrUniqueKey* paramsCopyKey,

11
src/gpu/GrTextureMaker.cpp
View File

@ -102,9 +102,16 @@ sk_sp<GrFragmentProcessor> GrTextureMaker::createFragmentProcessor(
GrTexture* GrTextureMaker::generateTextureForParams(const CopyParams& copyParams, bool willBeMipped,
SkColorSpace* dstColorSpace) {
sk_sp<GrTexture> original(this->refOriginalTexture(willBeMipped, dstColorSpace));
sk_sp<GrTextureProxy> original(this->refOriginalTextureProxy(willBeMipped, dstColorSpace));
if (!original) {
return nullptr;
}
return CopyOnGpu(original.get(), nullptr, copyParams);
sk_sp<GrTextureProxy> copy = CopyOnGpu(fContext, std::move(original), nullptr, copyParams);
if (!copy) {
return nullptr;
}
sk_sp<GrTexture> tex(SkSafeRef(copy->instantiate(fContext->resourceProvider())));
return tex.release();
}

3
src/gpu/GrTextureProducer.cpp
View File

@ -95,7 +95,8 @@ sk_sp<GrTextureProxy> GrTextureProducer::CopyOnGpu(GrContext* context,
bool needsDomain = false;
if (copyParams.fFilter != GrSamplerParams::kNone_FilterMode) {
bool resizing = subset->width() != dstRect.width() || subset->height() != dstRect.height();
bool resizing = localRect.width() != dstRect.width() ||
localRect.height() != dstRect.height();
if (GrResourceProvider::IsFunctionallyExact(inputProxy.get())) {
needsDomain = subset && resizing;

9
src/image/SkImage_Generator.cpp
View File

@ -88,13 +88,8 @@ sk_sp<GrTextureProxy> SkImage_Generator::asTextureProxyRef(GrContext* context,
SkColorSpace* dstColorSpace,
sk_sp<SkColorSpace>* texColorSpace,
SkScalar scaleAdjust[2]) const {
sk_sp<GrTexture> tex(fCache.lockAsTexture(context, params, dstColorSpace,
texColorSpace, this, scaleAdjust));
if (!tex) {
return nullptr;
}
return GrSurfaceProxy::MakeWrapped(std::move(tex));
return fCache.lockAsTextureProxy(context, params, dstColorSpace,
texColorSpace, this, scaleAdjust);
}
#endif