/*
|
* Copyright 2018 Google Inc.
|
*
|
* Use of this source code is governed by a BSD-style license that can be
|
* found in the LICENSE file.
|
*/
|
|
#include "Test.h"
|
|
#include "GrBackendSurface.h"
|
#include "GrContextPriv.h"
|
#include "GrGpu.h"
|
#include "GrTexture.h"
|
#include "SkImage_Gpu.h"
|
#include "SkPromiseImageTexture.h"
|
|
using namespace sk_gpu_test;
|
|
struct PromiseTextureChecker {
|
// shared indicates whether the backend texture is used to fulfill more than one promise
|
// image.
|
explicit PromiseTextureChecker(const GrBackendTexture& tex, skiatest::Reporter* reporter,
|
bool shared)
|
: fTexture(SkPromiseImageTexture::Make(tex))
|
, fReporter(reporter)
|
, fShared(shared)
|
, fFulfillCount(0)
|
, fReleaseCount(0)
|
, fDoneCount(0) {}
|
sk_sp<SkPromiseImageTexture> fTexture;
|
skiatest::Reporter* fReporter;
|
bool fShared;
|
int fFulfillCount;
|
int fReleaseCount;
|
int fDoneCount;
|
|
/**
|
* Releases the SkPromiseImageTexture. Used to test that cached GrTexture representations
|
* in the cache are freed.
|
*/
|
void releaseTexture() { fTexture.reset(); }
|
|
SkTArray<GrUniqueKey> uniqueKeys() const {
|
return fTexture->testingOnly_uniqueKeysToInvalidate();
|
}
|
|
static sk_sp<SkPromiseImageTexture> Fulfill(void* self) {
|
auto checker = static_cast<PromiseTextureChecker*>(self);
|
checker->fFulfillCount++;
|
return checker->fTexture;
|
}
|
static void Release(void* self) {
|
auto checker = static_cast<PromiseTextureChecker*>(self);
|
checker->fReleaseCount++;
|
if (!checker->fShared) {
|
// This is only used in a single threaded fashion with a single promise image. So
|
// every fulfill should be balanced by a release before the next fulfill.
|
REPORTER_ASSERT(checker->fReporter, checker->fReleaseCount == checker->fFulfillCount);
|
}
|
}
|
static void Done(void* self) {
|
static_cast<PromiseTextureChecker*>(self)->fDoneCount++;
|
}
|
};
|
|
enum class ReleaseBalanceExpecation {
|
kBalanced,
|
kBalancedOrPlusOne,
|
kAny
|
};
|
|
static bool check_fulfill_and_release_cnts(const PromiseTextureChecker& promiseChecker,
|
ReleaseBalanceExpecation balanceExpecation,
|
int expectedFulfillCnt,
|
int expectedReleaseCnt,
|
bool expectedRequired,
|
int expectedDoneCnt,
|
skiatest::Reporter* reporter) {
|
bool result = true;
|
int countDiff = promiseChecker.fFulfillCount - promiseChecker.fReleaseCount;
|
// FulfillCount should always equal ReleaseCount or be at most one higher
|
if (countDiff != 0) {
|
if (balanceExpecation == ReleaseBalanceExpecation::kBalanced) {
|
result = false;
|
REPORTER_ASSERT(reporter, 0 == countDiff);
|
} else if (countDiff != 1 &&
|
balanceExpecation == ReleaseBalanceExpecation::kBalancedOrPlusOne) {
|
result = false;
|
REPORTER_ASSERT(reporter, 0 == countDiff || 1 == countDiff);
|
} else if (countDiff < 0) {
|
result = false;
|
REPORTER_ASSERT(reporter, countDiff >= 0);
|
}
|
}
|
|
int fulfillDiff = expectedFulfillCnt - promiseChecker.fFulfillCount;
|
REPORTER_ASSERT(reporter, fulfillDiff >= 0);
|
if (fulfillDiff != 0) {
|
if (expectedRequired) {
|
result = false;
|
REPORTER_ASSERT(reporter, expectedFulfillCnt == promiseChecker.fFulfillCount);
|
} else if (fulfillDiff > 1) {
|
result = false;
|
REPORTER_ASSERT(reporter, fulfillDiff <= 1);
|
}
|
}
|
|
int releaseDiff = expectedReleaseCnt - promiseChecker.fReleaseCount;
|
REPORTER_ASSERT(reporter, releaseDiff >= 0);
|
if (releaseDiff != 0) {
|
if (expectedRequired) {
|
result = false;
|
REPORTER_ASSERT(reporter, expectedReleaseCnt == promiseChecker.fReleaseCount);
|
} else if (releaseDiff > 1) {
|
result = false;
|
REPORTER_ASSERT(reporter, releaseDiff <= 1);
|
}
|
}
|
|
if (expectedDoneCnt != promiseChecker.fDoneCount) {
|
result = false;
|
REPORTER_ASSERT(reporter, expectedDoneCnt == promiseChecker.fDoneCount);
|
}
|
|
return result;
|
}
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(PromiseImageTest, reporter, ctxInfo) {
|
const int kWidth = 10;
|
const int kHeight = 10;
|
|
GrContext* ctx = ctxInfo.grContext();
|
GrGpu* gpu = ctx->priv().getGpu();
|
|
GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture(
|
nullptr, kWidth, kHeight, GrColorType::kRGBA_8888, true, GrMipMapped::kNo);
|
REPORTER_ASSERT(reporter, backendTex.isValid());
|
|
GrBackendFormat backendFormat = backendTex.getBackendFormat();
|
REPORTER_ASSERT(reporter, backendFormat.isValid());
|
|
PromiseTextureChecker promiseChecker(backendTex, reporter, false);
|
GrSurfaceOrigin texOrigin = kTopLeft_GrSurfaceOrigin;
|
sk_sp<SkImage> refImg(
|
SkImage_Gpu::MakePromiseTexture(
|
ctx, backendFormat, kWidth, kHeight,
|
GrMipMapped::kNo, texOrigin,
|
kRGBA_8888_SkColorType, kPremul_SkAlphaType,
|
nullptr,
|
PromiseTextureChecker::Fulfill,
|
PromiseTextureChecker::Release,
|
PromiseTextureChecker::Done,
|
&promiseChecker));
|
|
SkImageInfo info = SkImageInfo::MakeN32Premul(kWidth, kHeight);
|
sk_sp<SkSurface> surface = SkSurface::MakeRenderTarget(ctx, SkBudgeted::kNo, info);
|
SkCanvas* canvas = surface->getCanvas();
|
|
int expectedFulfillCnt = 0;
|
int expectedReleaseCnt = 0;
|
int expectedDoneCnt = 0;
|
ReleaseBalanceExpecation balanceExpecation = ReleaseBalanceExpecation::kBalanced;
|
|
canvas->drawImage(refImg, 0, 0);
|
REPORTER_ASSERT(reporter, check_fulfill_and_release_cnts(promiseChecker,
|
balanceExpecation,
|
expectedFulfillCnt,
|
expectedReleaseCnt,
|
true,
|
expectedDoneCnt,
|
reporter));
|
|
bool isVulkan = GrBackendApi::kVulkan == ctx->backend();
|
surface->flush();
|
expectedFulfillCnt++;
|
// Because we've delayed release, we expect a +1 balance.
|
balanceExpecation = ReleaseBalanceExpecation::kBalancedOrPlusOne;
|
REPORTER_ASSERT(reporter, check_fulfill_and_release_cnts(promiseChecker,
|
balanceExpecation,
|
expectedFulfillCnt,
|
expectedReleaseCnt,
|
!isVulkan,
|
expectedDoneCnt,
|
reporter));
|
|
gpu->testingOnly_flushGpuAndSync();
|
REPORTER_ASSERT(reporter, check_fulfill_and_release_cnts(promiseChecker,
|
balanceExpecation,
|
expectedFulfillCnt,
|
expectedReleaseCnt,
|
true,
|
expectedDoneCnt,
|
reporter));
|
|
canvas->drawImage(refImg, 0, 0);
|
canvas->drawImage(refImg, 0, 0);
|
|
surface->flush();
|
|
gpu->testingOnly_flushGpuAndSync();
|
REPORTER_ASSERT(reporter, check_fulfill_and_release_cnts(promiseChecker,
|
balanceExpecation,
|
expectedFulfillCnt,
|
expectedReleaseCnt,
|
true,
|
expectedDoneCnt,
|
reporter));
|
|
canvas->drawImage(refImg, 0, 0);
|
surface->flush();
|
REPORTER_ASSERT(reporter, check_fulfill_and_release_cnts(promiseChecker,
|
balanceExpecation,
|
expectedFulfillCnt,
|
expectedReleaseCnt,
|
!isVulkan,
|
expectedDoneCnt,
|
reporter));
|
|
canvas->drawImage(refImg, 0, 0);
|
|
refImg.reset();
|
|
REPORTER_ASSERT(reporter, check_fulfill_and_release_cnts(promiseChecker,
|
balanceExpecation,
|
expectedFulfillCnt,
|
expectedReleaseCnt,
|
!isVulkan,
|
expectedDoneCnt,
|
reporter));
|
|
surface->flush();
|
gpu->testingOnly_flushGpuAndSync();
|
// We released the image already and we flushed and synced.
|
balanceExpecation = ReleaseBalanceExpecation::kBalanced;
|
expectedReleaseCnt++;
|
expectedDoneCnt++;
|
REPORTER_ASSERT(reporter, check_fulfill_and_release_cnts(promiseChecker,
|
balanceExpecation,
|
expectedFulfillCnt,
|
expectedReleaseCnt,
|
!isVulkan,
|
expectedDoneCnt,
|
reporter));
|
|
gpu->deleteTestingOnlyBackendTexture(backendTex);
|
}
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(PromiseImageTextureReuseDifferentConfig, reporter, ctxInfo) {
|
// Try making two promise SkImages backed by the same texture but with different configs.
|
// This will only be testable on backends where a single texture format (8bit red unorm) can
|
// be used for alpha and gray image color types.
|
|
const int kWidth = 10;
|
const int kHeight = 10;
|
|
GrContext* ctx = ctxInfo.grContext();
|
GrGpu* gpu = ctx->priv().getGpu();
|
|
GrBackendTexture backendTex1 = gpu->createTestingOnlyBackendTexture(
|
nullptr, kWidth, kHeight, GrColorType::kGray_8, false, GrMipMapped::kNo);
|
REPORTER_ASSERT(reporter, backendTex1.isValid());
|
|
GrBackendTexture backendTex2 = gpu->createTestingOnlyBackendTexture(
|
nullptr, kWidth, kHeight, GrColorType::kAlpha_8, false, GrMipMapped::kNo);
|
REPORTER_ASSERT(reporter, backendTex2.isValid());
|
if (backendTex1.getBackendFormat() != backendTex2.getBackendFormat()) {
|
gpu->deleteTestingOnlyBackendTexture(backendTex1);
|
return;
|
}
|
// We only needed this texture to check that alpha and gray color types use the same format.
|
gpu->deleteTestingOnlyBackendTexture(backendTex2);
|
|
SkImageInfo info =
|
SkImageInfo::Make(kWidth, kHeight, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
|
sk_sp<SkSurface> surface = SkSurface::MakeRenderTarget(ctx, SkBudgeted::kNo, info);
|
SkCanvas* canvas = surface->getCanvas();
|
|
PromiseTextureChecker promiseChecker(backendTex1, reporter, true);
|
sk_sp<SkImage> alphaImg(SkImage_Gpu::MakePromiseTexture(
|
ctx, backendTex1.getBackendFormat(), kWidth, kHeight, GrMipMapped::kNo,
|
kTopLeft_GrSurfaceOrigin, kAlpha_8_SkColorType, kPremul_SkAlphaType, nullptr,
|
PromiseTextureChecker::Fulfill, PromiseTextureChecker::Release,
|
PromiseTextureChecker::Done, &promiseChecker));
|
REPORTER_ASSERT(reporter, alphaImg);
|
|
sk_sp<SkImage> grayImg(SkImage_Gpu::MakePromiseTexture(
|
ctx, backendTex1.getBackendFormat(), kWidth, kHeight, GrMipMapped::kNo,
|
kBottomLeft_GrSurfaceOrigin, kGray_8_SkColorType, kOpaque_SkAlphaType, nullptr,
|
PromiseTextureChecker::Fulfill, PromiseTextureChecker::Release,
|
PromiseTextureChecker::Done, &promiseChecker));
|
REPORTER_ASSERT(reporter, grayImg);
|
|
canvas->drawImage(alphaImg, 0, 0);
|
canvas->drawImage(grayImg, 1, 1);
|
surface->flush();
|
gpu->testingOnly_flushGpuAndSync();
|
|
int expectedFulfillCnt = 2;
|
int expectedReleaseCnt = 0;
|
int expectedDoneCnt = 0;
|
ReleaseBalanceExpecation balanceExpecation = ReleaseBalanceExpecation::kAny;
|
REPORTER_ASSERT(reporter, check_fulfill_and_release_cnts(promiseChecker,
|
balanceExpecation,
|
expectedFulfillCnt,
|
expectedReleaseCnt,
|
true,
|
expectedDoneCnt,
|
reporter));
|
|
// Because they use different configs, each image should have created a different GrTexture
|
// and they both should still be cached.
|
ctx->priv().getResourceCache()->purgeAsNeeded();
|
|
auto keys = promiseChecker.uniqueKeys();
|
REPORTER_ASSERT(reporter, keys.count() == 2);
|
for (const auto& key : keys) {
|
auto surf = ctx->priv().resourceProvider()->findByUniqueKey<GrSurface>(key);
|
REPORTER_ASSERT(reporter, surf && surf->asTexture());
|
if (surf && surf->asTexture()) {
|
REPORTER_ASSERT(reporter,
|
!GrBackendTexture::TestingOnly_Equals(
|
backendTex1, surf->asTexture()->getBackendTexture()));
|
}
|
}
|
|
// Change the backing texture, this should invalidate the keys.
|
promiseChecker.releaseTexture();
|
ctx->priv().getResourceCache()->purgeAsNeeded();
|
|
for (const auto& key : keys) {
|
auto surf = ctx->priv().resourceProvider()->findByUniqueKey<GrSurface>(key);
|
REPORTER_ASSERT(reporter, !surf);
|
}
|
|
// Must do this to ensure all callbacks occur before the PromiseImageChecker goes out of scope.
|
alphaImg.reset();
|
grayImg.reset();
|
ctx->flush();
|
ctx->priv().getGpu()->testingOnly_flushGpuAndSync();
|
|
gpu->deleteTestingOnlyBackendTexture(backendTex1);
|
}
|
|
DEF_GPUTEST(PromiseImageTextureShutdown, reporter, ctxInfo) {
|
const int kWidth = 10;
|
const int kHeight = 10;
|
|
// Different ways of killing contexts.
|
using DeathFn = std::function<void(sk_gpu_test::GrContextFactory*, GrContext*)>;
|
DeathFn destroy = [](sk_gpu_test::GrContextFactory* factory, GrContext* context) {
|
factory->destroyContexts();
|
};
|
DeathFn abandon = [](sk_gpu_test::GrContextFactory* factory, GrContext* context) {
|
context->abandonContext();
|
};
|
DeathFn releaseResourcesAndAbandon = [](sk_gpu_test::GrContextFactory* factory,
|
GrContext* context) {
|
context->releaseResourcesAndAbandonContext();
|
};
|
|
for (int type = 0; type < sk_gpu_test::GrContextFactory::kContextTypeCnt; ++type) {
|
auto contextType = static_cast<sk_gpu_test::GrContextFactory::ContextType>(type);
|
// These tests are difficult to get working with Vulkan. See http://skbug.com/8705
|
// and http://skbug.com/8275
|
GrBackendApi api = sk_gpu_test::GrContextFactory::ContextTypeBackend(contextType);
|
if (api == GrBackendApi::kVulkan) {
|
continue;
|
}
|
DeathFn contextKillers[] = {destroy, abandon, releaseResourcesAndAbandon};
|
for (auto contextDeath : contextKillers) {
|
sk_gpu_test::GrContextFactory factory;
|
auto ctx = factory.get(contextType);
|
if (!ctx) {
|
continue;
|
}
|
GrGpu* gpu = ctx->priv().getGpu();
|
|
GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture(
|
nullptr, kWidth, kHeight, GrColorType::kAlpha_8, false, GrMipMapped::kNo);
|
REPORTER_ASSERT(reporter, backendTex.isValid());
|
|
SkImageInfo info = SkImageInfo::Make(kWidth, kHeight, kRGBA_8888_SkColorType,
|
kPremul_SkAlphaType);
|
sk_sp<SkSurface> surface = SkSurface::MakeRenderTarget(ctx, SkBudgeted::kNo, info);
|
SkCanvas* canvas = surface->getCanvas();
|
|
PromiseTextureChecker promiseChecker(backendTex, reporter, false);
|
sk_sp<SkImage> image(SkImage_Gpu::MakePromiseTexture(
|
ctx, backendTex.getBackendFormat(), kWidth, kHeight, GrMipMapped::kNo,
|
kTopLeft_GrSurfaceOrigin, kAlpha_8_SkColorType, kPremul_SkAlphaType, nullptr,
|
PromiseTextureChecker::Fulfill, PromiseTextureChecker::Release,
|
PromiseTextureChecker::Done, &promiseChecker));
|
REPORTER_ASSERT(reporter, image);
|
|
canvas->drawImage(image, 0, 0);
|
image.reset();
|
// If the surface still holds a ref to the context then the factory will not be able
|
// to destroy the context (and instead will release-all-and-abandon).
|
surface.reset();
|
|
ctx->flush();
|
contextDeath(&factory, ctx);
|
|
int expectedFulfillCnt = 1;
|
int expectedReleaseCnt = 1;
|
int expectedDoneCnt = 1;
|
ReleaseBalanceExpecation balanceExpecation = ReleaseBalanceExpecation::kBalanced;
|
REPORTER_ASSERT(reporter, check_fulfill_and_release_cnts(promiseChecker,
|
balanceExpecation,
|
expectedFulfillCnt,
|
expectedReleaseCnt,
|
true,
|
expectedDoneCnt,
|
reporter));
|
}
|
}
|
}
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(PromiseImageTextureFullCache, reporter, ctxInfo) {
|
const int kWidth = 10;
|
const int kHeight = 10;
|
|
GrContext* ctx = ctxInfo.grContext();
|
GrGpu* gpu = ctx->priv().getGpu();
|
|
GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture(
|
nullptr, kWidth, kHeight, GrColorType::kAlpha_8, false, GrMipMapped::kNo);
|
REPORTER_ASSERT(reporter, backendTex.isValid());
|
|
SkImageInfo info =
|
SkImageInfo::Make(kWidth, kHeight, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
|
sk_sp<SkSurface> surface = SkSurface::MakeRenderTarget(ctx, SkBudgeted::kNo, info);
|
SkCanvas* canvas = surface->getCanvas();
|
|
PromiseTextureChecker promiseChecker(backendTex, reporter, false);
|
sk_sp<SkImage> image(SkImage_Gpu::MakePromiseTexture(
|
ctx, backendTex.getBackendFormat(), kWidth, kHeight, GrMipMapped::kNo,
|
kTopLeft_GrSurfaceOrigin, kAlpha_8_SkColorType, kPremul_SkAlphaType, nullptr,
|
PromiseTextureChecker::Fulfill, PromiseTextureChecker::Release,
|
PromiseTextureChecker::Done, &promiseChecker));
|
REPORTER_ASSERT(reporter, image);
|
|
// Make the cache full. This tests that we don't preemptively purge cached textures for
|
// fulfillment due to cache pressure.
|
static constexpr int kMaxResources = 10;
|
static constexpr int kMaxBytes = 100;
|
ctx->setResourceCacheLimits(kMaxResources, kMaxBytes);
|
sk_sp<GrTexture> textures[2 * kMaxResources];
|
for (int i = 0; i < 2 * kMaxResources; ++i) {
|
GrSurfaceDesc desc;
|
desc.fConfig = kRGBA_8888_GrPixelConfig;
|
desc.fWidth = desc.fHeight = 100;
|
textures[i] = ctx->priv().resourceProvider()->createTexture(desc, SkBudgeted::kYes);
|
REPORTER_ASSERT(reporter, textures[i]);
|
}
|
|
// Relying on the asserts in the promiseImageChecker to ensure that fulfills and releases are
|
// properly ordered.
|
canvas->drawImage(image, 0, 0);
|
surface->flush();
|
canvas->drawImage(image, 1, 0);
|
surface->flush();
|
canvas->drawImage(image, 2, 0);
|
surface->flush();
|
canvas->drawImage(image, 3, 0);
|
surface->flush();
|
canvas->drawImage(image, 4, 0);
|
surface->flush();
|
canvas->drawImage(image, 5, 0);
|
surface->flush();
|
// Must call these to ensure that all callbacks are performed before the checker is destroyed.
|
image.reset();
|
ctx->flush();
|
gpu->testingOnly_flushGpuAndSync();
|
|
gpu->deleteTestingOnlyBackendTexture(backendTex);
|
}
|
