96be9df130
This reverts commit 467022b186.
Reason for revert: GrAHardwareBufferImageGenerator.cpp
Original change's description:
> Reduce dependence on GrSurface's origin field
>
> Unfortunately, GrGPU and its ilk are still using the GrSurface's origin a lot. I will clean that up in a second CL.
>
> Change-Id: Iba729440ce8ea8d24bb7f4e5de55ed576a0f176d
> Reviewed-on: https://skia-review.googlesource.com/24700
> Commit-Queue: Robert Phillips <robertphillips@google.com>
> Reviewed-by: Brian Salomon <bsalomon@google.com>
TBR=bsalomon@google.com,robertphillips@google.com
Change-Id: I1b3f5c3b82d250ac164beb1d5c83abb6c3c6ab3b
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://skia-review.googlesource.com/25620
Reviewed-by: Robert Phillips <robertphillips@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>
279 lines
11 KiB
C++
279 lines
11 KiB
C++
/*
|
|
* Copyright 2016 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 "SkBitmap.h"
|
|
#include "SkImage.h"
|
|
#include "SkImageFilter.h"
|
|
#include "SkImageFilterCache.h"
|
|
#include "SkMatrix.h"
|
|
#include "SkSpecialImage.h"
|
|
|
|
static const int kSmallerSize = 10;
|
|
static const int kPad = 3;
|
|
static const int kFullSize = kSmallerSize + 2 * kPad;
|
|
|
|
static SkBitmap create_bm() {
|
|
SkBitmap bm;
|
|
bm.allocN32Pixels(kFullSize, kFullSize, true);
|
|
bm.eraseColor(SK_ColorTRANSPARENT);
|
|
return bm;
|
|
}
|
|
|
|
// Ensure the cache can return a cached image
|
|
static void test_find_existing(skiatest::Reporter* reporter,
|
|
const sk_sp<SkSpecialImage>& image,
|
|
const sk_sp<SkSpecialImage>& subset) {
|
|
static const size_t kCacheSize = 1000000;
|
|
sk_sp<SkImageFilterCache> cache(SkImageFilterCache::Create(kCacheSize));
|
|
|
|
SkIRect clip = SkIRect::MakeWH(100, 100);
|
|
SkImageFilterCacheKey key1(0, SkMatrix::I(), clip, image->uniqueID(), image->subset());
|
|
SkImageFilterCacheKey key2(0, SkMatrix::I(), clip, subset->uniqueID(), subset->subset());
|
|
|
|
SkIPoint offset = SkIPoint::Make(3, 4);
|
|
cache->set(key1, image.get(), offset, nullptr);
|
|
|
|
SkIPoint foundOffset;
|
|
|
|
sk_sp<SkSpecialImage> foundImage = cache->get(key1, &foundOffset);
|
|
REPORTER_ASSERT(reporter, foundImage);
|
|
REPORTER_ASSERT(reporter, offset == foundOffset);
|
|
|
|
REPORTER_ASSERT(reporter, !cache->get(key2, &foundOffset));
|
|
}
|
|
|
|
// If either id is different or the clip or the matrix are different the
|
|
// cached image won't be found. Even if it is caching the same bitmap.
|
|
static void test_dont_find_if_diff_key(skiatest::Reporter* reporter,
|
|
const sk_sp<SkSpecialImage>& image,
|
|
const sk_sp<SkSpecialImage>& subset) {
|
|
static const size_t kCacheSize = 1000000;
|
|
sk_sp<SkImageFilterCache> cache(SkImageFilterCache::Create(kCacheSize));
|
|
|
|
SkIRect clip1 = SkIRect::MakeWH(100, 100);
|
|
SkIRect clip2 = SkIRect::MakeWH(200, 200);
|
|
SkImageFilterCacheKey key0(0, SkMatrix::I(), clip1, image->uniqueID(), image->subset());
|
|
SkImageFilterCacheKey key1(1, SkMatrix::I(), clip1, image->uniqueID(), image->subset());
|
|
SkImageFilterCacheKey key2(0, SkMatrix::MakeTrans(5, 5), clip1,
|
|
image->uniqueID(), image->subset());
|
|
SkImageFilterCacheKey key3(0, SkMatrix::I(), clip2, image->uniqueID(), image->subset());
|
|
SkImageFilterCacheKey key4(0, SkMatrix::I(), clip1, subset->uniqueID(), subset->subset());
|
|
|
|
SkIPoint offset = SkIPoint::Make(3, 4);
|
|
cache->set(key0, image.get(), offset, nullptr);
|
|
|
|
SkIPoint foundOffset;
|
|
REPORTER_ASSERT(reporter, !cache->get(key1, &foundOffset));
|
|
REPORTER_ASSERT(reporter, !cache->get(key2, &foundOffset));
|
|
REPORTER_ASSERT(reporter, !cache->get(key3, &foundOffset));
|
|
REPORTER_ASSERT(reporter, !cache->get(key4, &foundOffset));
|
|
}
|
|
|
|
// Test purging when the max cache size is exceeded
|
|
static void test_internal_purge(skiatest::Reporter* reporter, const sk_sp<SkSpecialImage>& image) {
|
|
SkASSERT(image->getSize());
|
|
const size_t kCacheSize = image->getSize() + 10;
|
|
sk_sp<SkImageFilterCache> cache(SkImageFilterCache::Create(kCacheSize));
|
|
|
|
SkIRect clip = SkIRect::MakeWH(100, 100);
|
|
SkImageFilterCacheKey key1(0, SkMatrix::I(), clip, image->uniqueID(), image->subset());
|
|
SkImageFilterCacheKey key2(1, SkMatrix::I(), clip, image->uniqueID(), image->subset());
|
|
|
|
SkIPoint offset = SkIPoint::Make(3, 4);
|
|
cache->set(key1, image.get(), offset, nullptr);
|
|
|
|
SkIPoint foundOffset;
|
|
|
|
REPORTER_ASSERT(reporter, cache->get(key1, &foundOffset));
|
|
|
|
// This should knock the first one out of the cache
|
|
cache->set(key2, image.get(), offset, nullptr);
|
|
|
|
REPORTER_ASSERT(reporter, cache->get(key2, &foundOffset));
|
|
REPORTER_ASSERT(reporter, !cache->get(key1, &foundOffset));
|
|
}
|
|
|
|
// Exercise the purgeByKey and purge methods
|
|
static void test_explicit_purging(skiatest::Reporter* reporter,
|
|
const sk_sp<SkSpecialImage>& image,
|
|
const sk_sp<SkSpecialImage>& subset) {
|
|
static const size_t kCacheSize = 1000000;
|
|
sk_sp<SkImageFilterCache> cache(SkImageFilterCache::Create(kCacheSize));
|
|
|
|
SkIRect clip = SkIRect::MakeWH(100, 100);
|
|
SkImageFilterCacheKey key1(0, SkMatrix::I(), clip, image->uniqueID(), image->subset());
|
|
SkImageFilterCacheKey key2(1, SkMatrix::I(), clip, subset->uniqueID(), image->subset());
|
|
|
|
SkIPoint offset = SkIPoint::Make(3, 4);
|
|
cache->set(key1, image.get(), offset, nullptr);
|
|
cache->set(key2, image.get(), offset, nullptr);
|
|
SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache->count());)
|
|
|
|
SkIPoint foundOffset;
|
|
|
|
REPORTER_ASSERT(reporter, cache->get(key1, &foundOffset));
|
|
REPORTER_ASSERT(reporter, cache->get(key2, &foundOffset));
|
|
|
|
cache->purgeByKeys(&key1, 1);
|
|
SkDEBUGCODE(REPORTER_ASSERT(reporter, 1 == cache->count());)
|
|
|
|
REPORTER_ASSERT(reporter, !cache->get(key1, &foundOffset));
|
|
REPORTER_ASSERT(reporter, cache->get(key2, &foundOffset));
|
|
|
|
cache->purge();
|
|
SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache->count());)
|
|
|
|
REPORTER_ASSERT(reporter, !cache->get(key1, &foundOffset));
|
|
REPORTER_ASSERT(reporter, !cache->get(key2, &foundOffset));
|
|
}
|
|
|
|
DEF_TEST(ImageFilterCache_RasterBacked, reporter) {
|
|
SkBitmap srcBM = create_bm();
|
|
|
|
const SkIRect& full = SkIRect::MakeWH(kFullSize, kFullSize);
|
|
|
|
sk_sp<SkSpecialImage> fullImg(SkSpecialImage::MakeFromRaster(full, srcBM));
|
|
|
|
const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
|
|
|
|
sk_sp<SkSpecialImage> subsetImg(SkSpecialImage::MakeFromRaster(subset, srcBM));
|
|
|
|
test_find_existing(reporter, fullImg, subsetImg);
|
|
test_dont_find_if_diff_key(reporter, fullImg, subsetImg);
|
|
test_internal_purge(reporter, fullImg);
|
|
test_explicit_purging(reporter, fullImg, subsetImg);
|
|
}
|
|
|
|
|
|
// Shared test code for both the raster and gpu-backed image cases
|
|
static void test_image_backed(skiatest::Reporter* reporter, const sk_sp<SkImage>& srcImage) {
|
|
const SkIRect& full = SkIRect::MakeWH(kFullSize, kFullSize);
|
|
SkColorSpace* legacyColorSpace = nullptr;
|
|
|
|
sk_sp<SkSpecialImage> fullImg(SkSpecialImage::MakeFromImage(full, srcImage, legacyColorSpace));
|
|
|
|
const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
|
|
|
|
sk_sp<SkSpecialImage> subsetImg(SkSpecialImage::MakeFromImage(subset, srcImage,
|
|
legacyColorSpace));
|
|
|
|
test_find_existing(reporter, fullImg, subsetImg);
|
|
test_dont_find_if_diff_key(reporter, fullImg, subsetImg);
|
|
test_internal_purge(reporter, fullImg);
|
|
test_explicit_purging(reporter, fullImg, subsetImg);
|
|
}
|
|
|
|
DEF_TEST(ImageFilterCache_ImageBackedRaster, reporter) {
|
|
SkBitmap srcBM = create_bm();
|
|
|
|
sk_sp<SkImage> srcImage(SkImage::MakeFromBitmap(srcBM));
|
|
|
|
test_image_backed(reporter, srcImage);
|
|
}
|
|
|
|
#if SK_SUPPORT_GPU
|
|
#include "GrContext.h"
|
|
#include "GrContextPriv.h"
|
|
#include "GrResourceProvider.h"
|
|
#include "GrSurfaceProxyPriv.h"
|
|
#include "GrTest.h"
|
|
#include "GrTexture.h"
|
|
#include "GrTextureProxy.h"
|
|
|
|
static sk_sp<GrTextureProxy> create_proxy(GrResourceProvider* resourceProvider) {
|
|
SkBitmap srcBM = create_bm();
|
|
|
|
GrSurfaceDesc desc;
|
|
desc.fConfig = kRGBA_8888_GrPixelConfig;
|
|
desc.fFlags = kNone_GrSurfaceFlags;
|
|
desc.fWidth = kFullSize;
|
|
desc.fHeight = kFullSize;
|
|
|
|
return GrSurfaceProxy::MakeDeferred(resourceProvider,
|
|
desc, SkBudgeted::kYes,
|
|
srcBM.getPixels(),
|
|
srcBM.rowBytes());
|
|
}
|
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, ctxInfo) {
|
|
GrContext* context = ctxInfo.grContext();
|
|
|
|
sk_sp<GrTextureProxy> srcProxy(create_proxy(context->resourceProvider()));
|
|
if (!srcProxy) {
|
|
return;
|
|
}
|
|
|
|
if (!srcProxy->instantiate(context->resourceProvider())) {
|
|
return;
|
|
}
|
|
GrTexture* tex = srcProxy->priv().peekTexture();
|
|
|
|
GrBackendTexture backendTex = GrTest::CreateBackendTexture(context->contextPriv().getBackend(),
|
|
kFullSize,
|
|
kFullSize,
|
|
kRGBA_8888_GrPixelConfig,
|
|
tex->getTextureHandle());
|
|
GrSurfaceOrigin texOrigin = kTopLeft_GrSurfaceOrigin;
|
|
sk_sp<SkImage> srcImage(SkImage::MakeFromTexture(context,
|
|
backendTex,
|
|
texOrigin,
|
|
kPremul_SkAlphaType, nullptr));
|
|
if (!srcImage) {
|
|
return;
|
|
}
|
|
|
|
GrSurfaceOrigin readBackOrigin;
|
|
GrBackendObject readBackHandle = srcImage->getTextureHandle(false, &readBackOrigin);
|
|
// TODO: Make it so we can check this (see skbug.com/5019)
|
|
#if 0
|
|
if (readBackHandle != tex->getTextureHandle()) {
|
|
ERRORF(reporter, "backend mismatch %d %d\n",
|
|
(int)readBackHandle, (int)tex->getTextureHandle());
|
|
}
|
|
REPORTER_ASSERT(reporter, readBackHandle == tex->getTextureHandle());
|
|
#else
|
|
REPORTER_ASSERT(reporter, SkToBool(readBackHandle));
|
|
#endif
|
|
if (readBackOrigin != texOrigin) {
|
|
ERRORF(reporter, "origin mismatch %d %d\n", readBackOrigin, texOrigin);
|
|
}
|
|
REPORTER_ASSERT(reporter, readBackOrigin == texOrigin);
|
|
|
|
test_image_backed(reporter, srcImage);
|
|
}
|
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_GPUBacked, reporter, ctxInfo) {
|
|
GrContext* context = ctxInfo.grContext();
|
|
|
|
sk_sp<GrTextureProxy> srcProxy(create_proxy(context->resourceProvider()));
|
|
if (!srcProxy) {
|
|
return;
|
|
}
|
|
|
|
const SkIRect& full = SkIRect::MakeWH(kFullSize, kFullSize);
|
|
|
|
sk_sp<SkSpecialImage> fullImg(SkSpecialImage::MakeDeferredFromGpu(
|
|
context, full,
|
|
kNeedNewImageUniqueID_SpecialImage,
|
|
srcProxy, nullptr));
|
|
|
|
const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
|
|
|
|
sk_sp<SkSpecialImage> subsetImg(SkSpecialImage::MakeDeferredFromGpu(
|
|
context, subset,
|
|
kNeedNewImageUniqueID_SpecialImage,
|
|
srcProxy, nullptr));
|
|
|
|
test_find_existing(reporter, fullImg, subsetImg);
|
|
test_dont_find_if_diff_key(reporter, fullImg, subsetImg);
|
|
test_internal_purge(reporter, fullImg);
|
|
test_explicit_purging(reporter, fullImg, subsetImg);
|
|
}
|
|
#endif
|