DEF_GPUTEST_FOR_NATIVE_CONTEXT(SkImage_newTextureImage, reporter, context, glContext) {
GrContextFactory otherFactory;
GrContextFactory::ContextInfo otherContextInfo =
otherFactory.getContextInfo(GrContextFactory::kNative_GLContextType);
glContext->makeCurrent();
std::function<SkImage*()> imageFactories[] = {
create_image,
create_codec_image,
create_data_image,
// Create an image from a picture.
create_picture_image,
// Create a texture image.
[context] { return create_gpu_image(context); },
// Create a texture image in a another GrContext.
[glContext, otherContextInfo] {
otherContextInfo.fGLContext->makeCurrent();
SkImage* otherContextImage = create_gpu_image(otherContextInfo.fGrContext);
glContext->makeCurrent();
return otherContextImage;
}
};
for (auto factory : imageFactories) {
SkAutoTUnref<SkImage> image(factory());
if (!image) {
ERRORF(reporter, "Error creating image.");
continue;
}
GrTexture* origTexture = as_IB(image)->peekTexture();
SkAutoTUnref<SkImage> texImage(image->newTextureImage(context));
if (!texImage) {
// We execpt to fail if image comes from a different GrContext.
if (!origTexture || origTexture->getContext() == context) {
ERRORF(reporter, "newTextureImage failed.");
}
continue;
}
GrTexture* copyTexture = as_IB(texImage)->peekTexture();
if (!copyTexture) {
ERRORF(reporter, "newTextureImage returned non-texture image.");
continue;
}
if (origTexture) {
if (origTexture != copyTexture) {
ERRORF(reporter, "newTextureImage made unnecessary texture copy.");
}
}
if (image->width() != texImage->width() || image->height() != texImage->height()) {
ERRORF(reporter, "newTextureImage changed the image size.");
}
if (image->isOpaque() != texImage->isOpaque()) {
ERRORF(reporter, "newTextureImage changed image opaqueness.");
}
}
}
/*
* This tests the caching (and preemptive purge) of the raster equivalent of a gpu-image.
* We cache it for performance when drawing into a raster surface.
*
* A cleaner test would know if each drawImage call triggered a read-back from the gpu,
* but we don't have that facility (at the moment) so we use a little internal knowledge
* of *how* the raster version is cached, and look for that.
*/
DEF_GPUTEST_FOR_NATIVE_CONTEXT(SkImage_Gpu2Cpu, reporter, context) {
SkImageInfo info = SkImageInfo::MakeN32(20, 20, kOpaque_SkAlphaType);
SkAutoTUnref<SkImage> image(create_gpu_image(context));
const uint32_t uniqueID = image->uniqueID();
SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info));
// now we can test drawing a gpu-backed image into a cpu-backed surface
{
SkBitmap cachedBitmap;
REPORTER_ASSERT(reporter, !SkBitmapCache::Find(uniqueID, &cachedBitmap));
}
surface->getCanvas()->drawImage(image, 0, 0);
{
SkBitmap cachedBitmap;
if (SkBitmapCache::Find(uniqueID, &cachedBitmap)) {
REPORTER_ASSERT(reporter, cachedBitmap.getGenerationID() == uniqueID);
REPORTER_ASSERT(reporter, cachedBitmap.isImmutable());
REPORTER_ASSERT(reporter, cachedBitmap.getPixels());
} else {
// unexpected, but not really a bug, since the cache is global and this test may be
// run w/ other threads competing for its budget.
SkDebugf("SkImage_Gpu2Cpu : cachedBitmap was already purged\n");
}
}
image.reset(nullptr);
{
SkBitmap cachedBitmap;
REPORTER_ASSERT(reporter, !SkBitmapCache::Find(uniqueID, &cachedBitmap));
}
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageLegacyBitmap_Gpu, reporter, context) {
const SkImage::LegacyBitmapMode modes[] = {
SkImage::kRO_LegacyBitmapMode,
SkImage::kRW_LegacyBitmapMode,
};
for (auto& mode : modes) {
SkAutoTUnref<SkImage> image(create_gpu_image(context));
test_legacy_bitmap(reporter, image, mode);
}
}
void draw(SkCanvas* canvas) {
GrContext* grContext = canvas->getGrContext();
if (!grContext) {
return;
}
sk_sp<SkImage> backEndImage = create_gpu_image(grContext);
canvas->drawImage(backEndImage, 0, 0);
GrBackendTexture texture;
SkImage::BackendTextureReleaseProc proc;
if (!SkImage::MakeBackendTextureFromSkImage(grContext, std::move(backEndImage),
&texture, &proc)) {
return;
}
sk_sp<SkImage> i2 = SkImage::MakeFromTexture(grContext, texture, kTopLeft_GrSurfaceOrigin,
kN32_SkColorType, kOpaque_SkAlphaType, nullptr);
canvas->drawImage(i2, 30, 30);
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImagePeek_Gpu, reporter, context) {
SkAutoTUnref<SkImage> image(create_gpu_image(context));
test_peek(reporter, image, false);
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageReadPixels_Gpu, reporter, context) {
SkAutoTUnref<SkImage> image(create_gpu_image(context));
test_read_pixels(reporter, image);
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageEncode_Gpu, reporter, context) {
SkAutoTUnref<SkImage> image(create_gpu_image(context));
test_encode(reporter, image);
}