blob: b69dd2e1b20361332a4000730be207d08afee937 [file] [log] [blame]
reed871872f2015-06-22 12:48:26 -07001/*
2 * Copyright 2015 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
bsalomon8e74f802016-01-30 10:01:40 -08008#include <functional>
bsalomon0d996862016-03-09 18:44:43 -08009#include <initializer_list>
ericrkb4da01d2016-06-13 11:18:14 -070010#include <vector>
bsalomon8e74f802016-01-30 10:01:40 -080011
robertphillipsc5035e72016-03-17 06:58:39 -070012#include "SkAutoPixmapStorage.h"
halcanaryc56c6ef2015-09-28 11:55:28 -070013#include "SkBitmap.h"
reed871872f2015-06-22 12:48:26 -070014#include "SkCanvas.h"
Matt Sarett0bb6f382017-03-06 10:28:24 -050015#include "SkColorSpacePriv.h"
reed871872f2015-06-22 12:48:26 -070016#include "SkData.h"
reed871872f2015-06-22 12:48:26 -070017#include "SkImageEncoder.h"
kkinnunen7b94c142015-11-24 07:39:40 -080018#include "SkImageGenerator.h"
reed871872f2015-06-22 12:48:26 -070019#include "SkImage_Base.h"
reed2dad7692016-08-01 11:12:58 -070020#include "SkImagePriv.h"
Mike Reed185130c2017-02-15 15:14:16 -050021#include "SkMakeUnique.h"
fmalitac3470342015-09-04 11:36:39 -070022#include "SkPicture.h"
23#include "SkPictureRecorder.h"
reed871872f2015-06-22 12:48:26 -070024#include "SkRRect.h"
Mike Reedef038482017-12-16 08:41:28 -050025#include "SkSerialProcs.h"
fmalitac3470342015-09-04 11:36:39 -070026#include "SkStream.h"
reed871872f2015-06-22 12:48:26 -070027#include "SkSurface.h"
28#include "SkUtils.h"
29#include "Test.h"
30
Matt Sarett0bb6f382017-03-06 10:28:24 -050031#include "Resources.h"
Mike Reedc4e31092018-01-30 11:15:27 -050032#include "sk_pixel_iter.h"
Hal Canarydb683012016-11-23 08:55:18 -070033#include "sk_tool_utils.h"
34
brianosmandb2cb102016-07-22 07:22:04 -070035#if SK_SUPPORT_GPU
Greg Daniel7ef28f32017-04-20 16:41:55 +000036#include "GrContextPriv.h"
brianosmandb2cb102016-07-22 07:22:04 -070037#include "GrGpu.h"
Brian Osman13dddce2017-05-09 13:19:50 -040038#include "GrResourceCache.h"
Greg Daniel7ef28f32017-04-20 16:41:55 +000039#include "GrTest.h"
Robert Phillips646e4292017-06-13 12:44:56 -040040#include "GrTexture.h"
Brian Salomonbdecacf2018-02-02 20:32:49 -050041#include "SkGr.h"
brianosmandb2cb102016-07-22 07:22:04 -070042#endif
43
bsalomonf2f1c172016-04-05 12:59:06 -070044using namespace sk_gpu_test;
bsalomon3724e572016-03-30 18:56:19 -070045
Matt Sarettf5759932017-02-07 21:52:07 +000046SkImageInfo read_pixels_info(SkImage* image) {
47 if (as_IB(image)->onImageInfo().colorSpace()) {
48 return SkImageInfo::MakeS32(image->width(), image->height(), image->alphaType());
49 }
50
51 return SkImageInfo::MakeN32(image->width(), image->height(), image->alphaType());
52}
53
reed871872f2015-06-22 12:48:26 -070054static void assert_equal(skiatest::Reporter* reporter, SkImage* a, const SkIRect* subsetA,
55 SkImage* b) {
56 const int widthA = subsetA ? subsetA->width() : a->width();
57 const int heightA = subsetA ? subsetA->height() : a->height();
58
59 REPORTER_ASSERT(reporter, widthA == b->width());
60 REPORTER_ASSERT(reporter, heightA == b->height());
reed1cb36462016-03-09 15:21:32 -080061
62 // see https://bug.skia.org/3965
63 //REPORTER_ASSERT(reporter, a->isOpaque() == b->isOpaque());
reed871872f2015-06-22 12:48:26 -070064
reed871872f2015-06-22 12:48:26 -070065 SkAutoPixmapStorage pmapA, pmapB;
Matt Sarettf5759932017-02-07 21:52:07 +000066 pmapA.alloc(read_pixels_info(a));
67 pmapB.alloc(read_pixels_info(b));
reed871872f2015-06-22 12:48:26 -070068
69 const int srcX = subsetA ? subsetA->x() : 0;
70 const int srcY = subsetA ? subsetA->y() : 0;
71
72 REPORTER_ASSERT(reporter, a->readPixels(pmapA, srcX, srcY));
73 REPORTER_ASSERT(reporter, b->readPixels(pmapB, 0, 0));
74
Matt Sarettf5759932017-02-07 21:52:07 +000075 const size_t widthBytes = widthA * 4;
reed871872f2015-06-22 12:48:26 -070076 for (int y = 0; y < heightA; ++y) {
77 REPORTER_ASSERT(reporter, !memcmp(pmapA.addr32(0, y), pmapB.addr32(0, y), widthBytes));
78 }
79}
kkinnunen7b94c142015-11-24 07:39:40 -080080static void draw_image_test_pattern(SkCanvas* canvas) {
reed871872f2015-06-22 12:48:26 -070081 canvas->clear(SK_ColorWHITE);
reed871872f2015-06-22 12:48:26 -070082 SkPaint paint;
83 paint.setColor(SK_ColorBLACK);
kkinnunen7b94c142015-11-24 07:39:40 -080084 canvas->drawRect(SkRect::MakeXYWH(5, 5, 10, 10), paint);
85}
reed9ce9d672016-03-17 10:51:11 -070086static sk_sp<SkImage> create_image() {
kkinnunen7b94c142015-11-24 07:39:40 -080087 const SkImageInfo info = SkImageInfo::MakeN32(20, 20, kOpaque_SkAlphaType);
reede8f30622016-03-23 18:59:25 -070088 auto surface(SkSurface::MakeRaster(info));
kkinnunen7b94c142015-11-24 07:39:40 -080089 draw_image_test_pattern(surface->getCanvas());
reed9ce9d672016-03-17 10:51:11 -070090 return surface->makeImageSnapshot();
reed871872f2015-06-22 12:48:26 -070091}
bungeman38d909e2016-08-02 14:40:46 -070092static sk_sp<SkData> create_image_data(SkImageInfo* info) {
scroggo9d081722016-04-20 08:27:18 -070093 *info = SkImageInfo::MakeN32(20, 20, kOpaque_SkAlphaType);
94 const size_t rowBytes = info->minRowBytes();
bungeman38d909e2016-08-02 14:40:46 -070095 sk_sp<SkData> data(SkData::MakeUninitialized(rowBytes * info->height()));
scroggo9d081722016-04-20 08:27:18 -070096 {
97 SkBitmap bm;
98 bm.installPixels(*info, data->writable_data(), rowBytes);
99 SkCanvas canvas(bm);
100 draw_image_test_pattern(&canvas);
101 }
bungeman38d909e2016-08-02 14:40:46 -0700102 return data;
scroggo9d081722016-04-20 08:27:18 -0700103}
104static sk_sp<SkImage> create_data_image() {
105 SkImageInfo info;
106 sk_sp<SkData> data(create_image_data(&info));
bungeman38d909e2016-08-02 14:40:46 -0700107 return SkImage::MakeRasterData(info, std::move(data), info.minRowBytes());
scroggo9d081722016-04-20 08:27:18 -0700108}
109#if SK_SUPPORT_GPU // not gpu-specific but currently only used in GPU tests
Brian Salomon534cbe52017-01-03 11:35:56 -0500110static sk_sp<SkImage> create_image_large(int maxTextureSize) {
111 const SkImageInfo info = SkImageInfo::MakeN32(maxTextureSize + 1, 32, kOpaque_SkAlphaType);
bsalomond4907082016-06-13 12:13:03 -0700112 auto surface(SkSurface::MakeRaster(info));
113 surface->getCanvas()->clear(SK_ColorWHITE);
114 SkPaint paint;
115 paint.setColor(SK_ColorBLACK);
116 surface->getCanvas()->drawRect(SkRect::MakeXYWH(4000, 2, 28000, 30), paint);
117 return surface->makeImageSnapshot();
118}
reed9ce9d672016-03-17 10:51:11 -0700119static sk_sp<SkImage> create_picture_image() {
bsalomon8e74f802016-01-30 10:01:40 -0800120 SkPictureRecorder recorder;
121 SkCanvas* canvas = recorder.beginRecording(10, 10);
122 canvas->clear(SK_ColorCYAN);
reedca2622b2016-03-18 07:25:55 -0700123 return SkImage::MakeFromPicture(recorder.finishRecordingAsPicture(), SkISize::Make(10, 10),
Matt Sarette94255d2017-01-09 12:38:59 -0500124 nullptr, nullptr, SkImage::BitDepth::kU8,
Matt Sarett77a7a1b2017-02-07 13:56:11 -0500125 SkColorSpace::MakeSRGB());
bsalomon8e74f802016-01-30 10:01:40 -0800126};
127#endif
kkinnunen7b94c142015-11-24 07:39:40 -0800128// Want to ensure that our Release is called when the owning image is destroyed
129struct RasterDataHolder {
130 RasterDataHolder() : fReleaseCount(0) {}
bungeman38d909e2016-08-02 14:40:46 -0700131 sk_sp<SkData> fData;
kkinnunen7b94c142015-11-24 07:39:40 -0800132 int fReleaseCount;
133 static void Release(const void* pixels, void* context) {
134 RasterDataHolder* self = static_cast<RasterDataHolder*>(context);
135 self->fReleaseCount++;
136 self->fData.reset();
137 }
138};
reed9ce9d672016-03-17 10:51:11 -0700139static sk_sp<SkImage> create_rasterproc_image(RasterDataHolder* dataHolder) {
kkinnunen7b94c142015-11-24 07:39:40 -0800140 SkASSERT(dataHolder);
141 SkImageInfo info;
bungeman38d909e2016-08-02 14:40:46 -0700142 dataHolder->fData = create_image_data(&info);
143 return SkImage::MakeFromRaster(SkPixmap(info, dataHolder->fData->data(), info.minRowBytes()),
reed9ce9d672016-03-17 10:51:11 -0700144 RasterDataHolder::Release, dataHolder);
kkinnunen7b94c142015-11-24 07:39:40 -0800145}
reed9ce9d672016-03-17 10:51:11 -0700146static sk_sp<SkImage> create_codec_image() {
kkinnunen7b94c142015-11-24 07:39:40 -0800147 SkImageInfo info;
bungeman38d909e2016-08-02 14:40:46 -0700148 sk_sp<SkData> data(create_image_data(&info));
kkinnunen7b94c142015-11-24 07:39:40 -0800149 SkBitmap bitmap;
150 bitmap.installPixels(info, data->writable_data(), info.minRowBytes());
Hal Canarydb683012016-11-23 08:55:18 -0700151 sk_sp<SkData> src(sk_tool_utils::EncodeImageToData(bitmap, SkEncodedImageFormat::kPNG, 100));
bungeman38d909e2016-08-02 14:40:46 -0700152 return SkImage::MakeFromEncoded(std::move(src));
kkinnunen7b94c142015-11-24 07:39:40 -0800153}
154#if SK_SUPPORT_GPU
reed9ce9d672016-03-17 10:51:11 -0700155static sk_sp<SkImage> create_gpu_image(GrContext* context) {
kkinnunen7b94c142015-11-24 07:39:40 -0800156 const SkImageInfo info = SkImageInfo::MakeN32(20, 20, kOpaque_SkAlphaType);
reede8f30622016-03-23 18:59:25 -0700157 auto surface(SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info));
kkinnunen7b94c142015-11-24 07:39:40 -0800158 draw_image_test_pattern(surface->getCanvas());
reed9ce9d672016-03-17 10:51:11 -0700159 return surface->makeImageSnapshot();
kkinnunen7b94c142015-11-24 07:39:40 -0800160}
161#endif
reed871872f2015-06-22 12:48:26 -0700162
kkinnunen7b94c142015-11-24 07:39:40 -0800163static void test_encode(skiatest::Reporter* reporter, SkImage* image) {
reed871872f2015-06-22 12:48:26 -0700164 const SkIRect ir = SkIRect::MakeXYWH(5, 5, 10, 10);
Mike Reed6409f842017-07-11 16:03:13 -0400165 sk_sp<SkData> origEncoded = image->encodeToData();
reed871872f2015-06-22 12:48:26 -0700166 REPORTER_ASSERT(reporter, origEncoded);
167 REPORTER_ASSERT(reporter, origEncoded->size() > 0);
168
reed9ce9d672016-03-17 10:51:11 -0700169 sk_sp<SkImage> decoded(SkImage::MakeFromEncoded(origEncoded));
scroggo8e6c7ad2016-09-16 08:20:38 -0700170 if (!decoded) {
171 ERRORF(reporter, "failed to decode image!");
172 return;
173 }
reed871872f2015-06-22 12:48:26 -0700174 REPORTER_ASSERT(reporter, decoded);
reed9ce9d672016-03-17 10:51:11 -0700175 assert_equal(reporter, image, nullptr, decoded.get());
reed871872f2015-06-22 12:48:26 -0700176
177 // Now see if we can instantiate an image from a subset of the surface/origEncoded
mtklein5f939ab2016-03-16 10:28:35 -0700178
reed9ce9d672016-03-17 10:51:11 -0700179 decoded = SkImage::MakeFromEncoded(origEncoded, &ir);
reed871872f2015-06-22 12:48:26 -0700180 REPORTER_ASSERT(reporter, decoded);
reed9ce9d672016-03-17 10:51:11 -0700181 assert_equal(reporter, image, &ir, decoded.get());
reed871872f2015-06-22 12:48:26 -0700182}
183
kkinnunen7b94c142015-11-24 07:39:40 -0800184DEF_TEST(ImageEncode, reporter) {
reed9ce9d672016-03-17 10:51:11 -0700185 test_encode(reporter, create_image().get());
reed871872f2015-06-22 12:48:26 -0700186}
187
188#if SK_SUPPORT_GPU
bsalomon68d91342016-04-12 09:59:58 -0700189DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageEncode_Gpu, reporter, ctxInfo) {
bsalomon8b7451a2016-05-11 06:33:06 -0700190 test_encode(reporter, create_gpu_image(ctxInfo.grContext()).get());
reed871872f2015-06-22 12:48:26 -0700191}
192#endif
reed759373a2015-07-03 21:01:10 -0700193
reed2dad7692016-08-01 11:12:58 -0700194DEF_TEST(Image_MakeFromRasterBitmap, reporter) {
195 const struct {
reed1ec04d92016-08-05 12:07:41 -0700196 SkCopyPixelsMode fCPM;
197 bool fExpectSameAsMutable;
198 bool fExpectSameAsImmutable;
reed2dad7692016-08-01 11:12:58 -0700199 } recs[] = {
reed1ec04d92016-08-05 12:07:41 -0700200 { kIfMutable_SkCopyPixelsMode, false, true },
201 { kAlways_SkCopyPixelsMode, false, false },
202 { kNever_SkCopyPixelsMode, true, true },
reed2dad7692016-08-01 11:12:58 -0700203 };
204 for (auto rec : recs) {
205 SkPixmap pm;
206 SkBitmap bm;
207 bm.allocN32Pixels(100, 100);
208
reed1ec04d92016-08-05 12:07:41 -0700209 auto img = SkMakeImageFromRasterBitmap(bm, rec.fCPM);
reed2dad7692016-08-01 11:12:58 -0700210 REPORTER_ASSERT(reporter, img->peekPixels(&pm));
211 const bool sameMutable = pm.addr32(0, 0) == bm.getAddr32(0, 0);
212 REPORTER_ASSERT(reporter, rec.fExpectSameAsMutable == sameMutable);
reedae296442016-08-05 13:19:01 -0700213 REPORTER_ASSERT(reporter, (bm.getGenerationID() == img->uniqueID()) == sameMutable);
reed2dad7692016-08-01 11:12:58 -0700214
215 bm.notifyPixelsChanged(); // force a new generation ID
216
217 bm.setImmutable();
reed1ec04d92016-08-05 12:07:41 -0700218 img = SkMakeImageFromRasterBitmap(bm, rec.fCPM);
reed2dad7692016-08-01 11:12:58 -0700219 REPORTER_ASSERT(reporter, img->peekPixels(&pm));
220 const bool sameImmutable = pm.addr32(0, 0) == bm.getAddr32(0, 0);
221 REPORTER_ASSERT(reporter, rec.fExpectSameAsImmutable == sameImmutable);
reedae296442016-08-05 13:19:01 -0700222 REPORTER_ASSERT(reporter, (bm.getGenerationID() == img->uniqueID()) == sameImmutable);
reed2dad7692016-08-01 11:12:58 -0700223 }
224}
225
fmalitac3470342015-09-04 11:36:39 -0700226// Test that image encoding failures do not break picture serialization/deserialization.
227DEF_TEST(Image_Serialize_Encoding_Failure, reporter) {
reede8f30622016-03-23 18:59:25 -0700228 auto surface(SkSurface::MakeRasterN32Premul(100, 100));
fmalitac3470342015-09-04 11:36:39 -0700229 surface->getCanvas()->clear(SK_ColorGREEN);
reed9ce9d672016-03-17 10:51:11 -0700230 sk_sp<SkImage> image(surface->makeImageSnapshot());
fmalitac3470342015-09-04 11:36:39 -0700231 REPORTER_ASSERT(reporter, image);
232
233 SkPictureRecorder recorder;
234 SkCanvas* canvas = recorder.beginRecording(100, 100);
235 canvas->drawImage(image, 0, 0);
reedca2622b2016-03-18 07:25:55 -0700236 sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
fmalitac3470342015-09-04 11:36:39 -0700237 REPORTER_ASSERT(reporter, picture);
Mike Klein88d90712018-01-27 17:30:04 +0000238 REPORTER_ASSERT(reporter, picture->approximateOpCount() > 0);
fmalitac3470342015-09-04 11:36:39 -0700239
Mike Reedef038482017-12-16 08:41:28 -0500240 bool was_called = false;
241 SkSerialProcs procs;
242 procs.fImageProc = [](SkImage*, void* called) {
243 *(bool*)called = true;
244 return SkData::MakeEmpty();
245 };
246 procs.fImageCtx = &was_called;
fmalitac3470342015-09-04 11:36:39 -0700247
Mike Reedef038482017-12-16 08:41:28 -0500248 REPORTER_ASSERT(reporter, !was_called);
Mike Reed47fdf6c2017-12-20 14:12:07 -0500249 auto data = picture->serialize(&procs);
Mike Reedef038482017-12-16 08:41:28 -0500250 REPORTER_ASSERT(reporter, was_called);
251 REPORTER_ASSERT(reporter, data && data->size() > 0);
fmalitac3470342015-09-04 11:36:39 -0700252
Mike Reedef038482017-12-16 08:41:28 -0500253 auto deserialized = SkPicture::MakeFromData(data->data(), data->size());
254 REPORTER_ASSERT(reporter, deserialized);
Mike Klein88d90712018-01-27 17:30:04 +0000255 REPORTER_ASSERT(reporter, deserialized->approximateOpCount() > 0);
fmalitac3470342015-09-04 11:36:39 -0700256}
257
fmalita8c0144c2015-07-22 05:56:16 -0700258// Test that a draw that only partially covers the drawing surface isn't
259// interpreted as covering the entire drawing surface (i.e., exercise one of the
260// conditions of SkCanvas::wouldOverwriteEntireSurface()).
261DEF_TEST(Image_RetainSnapshot, reporter) {
262 const SkPMColor red = SkPackARGB32(0xFF, 0xFF, 0, 0);
263 const SkPMColor green = SkPackARGB32(0xFF, 0, 0xFF, 0);
264 SkImageInfo info = SkImageInfo::MakeN32Premul(2, 2);
reede8f30622016-03-23 18:59:25 -0700265 auto surface(SkSurface::MakeRaster(info));
fmalita8c0144c2015-07-22 05:56:16 -0700266 surface->getCanvas()->clear(0xFF00FF00);
267
268 SkPMColor pixels[4];
269 memset(pixels, 0xFF, sizeof(pixels)); // init with values we don't expect
270 const SkImageInfo dstInfo = SkImageInfo::MakeN32Premul(2, 2);
271 const size_t dstRowBytes = 2 * sizeof(SkPMColor);
272
reed9ce9d672016-03-17 10:51:11 -0700273 sk_sp<SkImage> image1(surface->makeImageSnapshot());
fmalita8c0144c2015-07-22 05:56:16 -0700274 REPORTER_ASSERT(reporter, image1->readPixels(dstInfo, pixels, dstRowBytes, 0, 0));
275 for (size_t i = 0; i < SK_ARRAY_COUNT(pixels); ++i) {
276 REPORTER_ASSERT(reporter, pixels[i] == green);
277 }
278
279 SkPaint paint;
reed374772b2016-10-05 17:33:02 -0700280 paint.setBlendMode(SkBlendMode::kSrc);
fmalita8c0144c2015-07-22 05:56:16 -0700281 paint.setColor(SK_ColorRED);
282
283 surface->getCanvas()->drawRect(SkRect::MakeXYWH(1, 1, 1, 1), paint);
284
reed9ce9d672016-03-17 10:51:11 -0700285 sk_sp<SkImage> image2(surface->makeImageSnapshot());
fmalita8c0144c2015-07-22 05:56:16 -0700286 REPORTER_ASSERT(reporter, image2->readPixels(dstInfo, pixels, dstRowBytes, 0, 0));
287 REPORTER_ASSERT(reporter, pixels[0] == green);
288 REPORTER_ASSERT(reporter, pixels[1] == green);
289 REPORTER_ASSERT(reporter, pixels[2] == green);
290 REPORTER_ASSERT(reporter, pixels[3] == red);
291}
reed80c772b2015-07-30 18:58:23 -0700292
293/////////////////////////////////////////////////////////////////////////////////////////////////
reed80c772b2015-07-30 18:58:23 -0700294
295static void make_bitmap_mutable(SkBitmap* bm) {
296 bm->allocN32Pixels(10, 10);
297}
298
299static void make_bitmap_immutable(SkBitmap* bm) {
300 bm->allocN32Pixels(10, 10);
301 bm->setImmutable();
302}
303
304DEF_TEST(image_newfrombitmap, reporter) {
305 const struct {
306 void (*fMakeProc)(SkBitmap*);
307 bool fExpectPeekSuccess;
308 bool fExpectSharedID;
fmalitaddbbdda2015-08-20 08:47:26 -0700309 bool fExpectLazy;
reed80c772b2015-07-30 18:58:23 -0700310 } rec[] = {
fmalitaddbbdda2015-08-20 08:47:26 -0700311 { make_bitmap_mutable, true, false, false },
312 { make_bitmap_immutable, true, true, false },
reed80c772b2015-07-30 18:58:23 -0700313 };
314
315 for (size_t i = 0; i < SK_ARRAY_COUNT(rec); ++i) {
316 SkBitmap bm;
317 rec[i].fMakeProc(&bm);
318
reed9ce9d672016-03-17 10:51:11 -0700319 sk_sp<SkImage> image(SkImage::MakeFromBitmap(bm));
reed80c772b2015-07-30 18:58:23 -0700320 SkPixmap pmap;
321
322 const bool sharedID = (image->uniqueID() == bm.getGenerationID());
323 REPORTER_ASSERT(reporter, sharedID == rec[i].fExpectSharedID);
324
reed80c772b2015-07-30 18:58:23 -0700325 const bool peekSuccess = image->peekPixels(&pmap);
326 REPORTER_ASSERT(reporter, peekSuccess == rec[i].fExpectPeekSuccess);
fmalitaddbbdda2015-08-20 08:47:26 -0700327
328 const bool lazy = image->isLazyGenerated();
329 REPORTER_ASSERT(reporter, lazy == rec[i].fExpectLazy);
reed80c772b2015-07-30 18:58:23 -0700330 }
331}
reed6f1216a2015-08-04 08:10:13 -0700332
333///////////////////////////////////////////////////////////////////////////////////////////////////
334#if SK_SUPPORT_GPU
335
reed6f1216a2015-08-04 08:10:13 -0700336#include "SkBitmapCache.h"
337
338/*
339 * This tests the caching (and preemptive purge) of the raster equivalent of a gpu-image.
340 * We cache it for performance when drawing into a raster surface.
341 *
342 * A cleaner test would know if each drawImage call triggered a read-back from the gpu,
343 * but we don't have that facility (at the moment) so we use a little internal knowledge
344 * of *how* the raster version is cached, and look for that.
345 */
bsalomon68d91342016-04-12 09:59:58 -0700346DEF_GPUTEST_FOR_RENDERING_CONTEXTS(c, reporter, ctxInfo) {
kkinnunen7b94c142015-11-24 07:39:40 -0800347 SkImageInfo info = SkImageInfo::MakeN32(20, 20, kOpaque_SkAlphaType);
bsalomon8b7451a2016-05-11 06:33:06 -0700348 sk_sp<SkImage> image(create_gpu_image(ctxInfo.grContext()));
reed6f1216a2015-08-04 08:10:13 -0700349 const uint32_t uniqueID = image->uniqueID();
Mike Reed5fa3d6d2017-03-25 09:51:00 -0400350 const auto desc = SkBitmapCacheDesc::Make(image.get());
reed6f1216a2015-08-04 08:10:13 -0700351
reede8f30622016-03-23 18:59:25 -0700352 auto surface(SkSurface::MakeRaster(info));
reed6f1216a2015-08-04 08:10:13 -0700353
354 // now we can test drawing a gpu-backed image into a cpu-backed surface
355
356 {
357 SkBitmap cachedBitmap;
Mike Reed5fa3d6d2017-03-25 09:51:00 -0400358 REPORTER_ASSERT(reporter, !SkBitmapCache::Find(desc, &cachedBitmap));
reed6f1216a2015-08-04 08:10:13 -0700359 }
360
361 surface->getCanvas()->drawImage(image, 0, 0);
362 {
363 SkBitmap cachedBitmap;
Mike Reed5fa3d6d2017-03-25 09:51:00 -0400364 if (SkBitmapCache::Find(desc, &cachedBitmap)) {
reed6f1216a2015-08-04 08:10:13 -0700365 REPORTER_ASSERT(reporter, cachedBitmap.getGenerationID() == uniqueID);
366 REPORTER_ASSERT(reporter, cachedBitmap.isImmutable());
367 REPORTER_ASSERT(reporter, cachedBitmap.getPixels());
368 } else {
369 // unexpected, but not really a bug, since the cache is global and this test may be
370 // run w/ other threads competing for its budget.
371 SkDebugf("SkImage_Gpu2Cpu : cachedBitmap was already purged\n");
372 }
373 }
374
375 image.reset(nullptr);
376 {
377 SkBitmap cachedBitmap;
Mike Reed5fa3d6d2017-03-25 09:51:00 -0400378 REPORTER_ASSERT(reporter, !SkBitmapCache::Find(desc, &cachedBitmap));
reed6f1216a2015-08-04 08:10:13 -0700379 }
380}
bsalomon8e74f802016-01-30 10:01:40 -0800381
Brian Osman041f7df2017-02-07 11:23:28 -0500382DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SkImage_makeTextureImage, reporter, contextInfo) {
383 GrContext* context = contextInfo.grContext();
384 sk_gpu_test::TestContext* testContext = contextInfo.testContext();
Brian Osman041f7df2017-02-07 11:23:28 -0500385 GrContextFactory otherFactory;
Robert Phillipscdabbcc2017-06-08 16:03:17 -0400386 ContextInfo otherContextInfo = otherFactory.getContextInfo(contextInfo.type());
Brian Osman041f7df2017-02-07 11:23:28 -0500387 testContext->makeCurrent();
388
389 std::function<sk_sp<SkImage>()> imageFactories[] = {
390 create_image,
391 create_codec_image,
392 create_data_image,
393 // Create an image from a picture.
394 create_picture_image,
395 // Create a texture image.
396 [context] { return create_gpu_image(context); },
397 // Create a texture image in a another GrContext.
Brian Salomon55ad7742017-11-17 09:25:23 -0500398 [otherContextInfo] {
399 auto restore = otherContextInfo.testContext()->makeCurrentAndAutoRestore();
Brian Osman041f7df2017-02-07 11:23:28 -0500400 sk_sp<SkImage> otherContextImage = create_gpu_image(otherContextInfo.grContext());
Brian Salomon55ad7742017-11-17 09:25:23 -0500401 otherContextInfo.grContext()->flush();
Brian Osman041f7df2017-02-07 11:23:28 -0500402 return otherContextImage;
403 }
404 };
405
Brian Osmane8827d22017-02-07 12:31:02 -0500406 sk_sp<SkColorSpace> dstColorSpaces[] ={
407 nullptr,
Matt Sarett77a7a1b2017-02-07 13:56:11 -0500408 SkColorSpace::MakeSRGB(),
Brian Osmane8827d22017-02-07 12:31:02 -0500409 };
Brian Osman041f7df2017-02-07 11:23:28 -0500410
Brian Osmane8827d22017-02-07 12:31:02 -0500411 for (auto& dstColorSpace : dstColorSpaces) {
412 for (auto factory : imageFactories) {
413 sk_sp<SkImage> image(factory());
414 if (!image) {
415 ERRORF(reporter, "Error creating image.");
416 continue;
Brian Osman041f7df2017-02-07 11:23:28 -0500417 }
Brian Osmane8827d22017-02-07 12:31:02 -0500418
419 sk_sp<SkImage> texImage(image->makeTextureImage(context, dstColorSpace.get()));
420 if (!texImage) {
Robert Phillips87444052017-06-23 14:09:30 -0400421 GrContext* imageContext = as_IB(image)->context();
422
Robert Phillips256c37b2017-03-01 14:32:46 -0500423 // We expect to fail if image comes from a different GrContext.
Robert Phillips87444052017-06-23 14:09:30 -0400424 if (!image->isTextureBacked() || imageContext == context) {
Brian Osmane8827d22017-02-07 12:31:02 -0500425 ERRORF(reporter, "makeTextureImage failed.");
426 }
427 continue;
Brian Osman041f7df2017-02-07 11:23:28 -0500428 }
Robert Phillips87444052017-06-23 14:09:30 -0400429 if (!texImage->isTextureBacked()) {
Brian Osmane8827d22017-02-07 12:31:02 -0500430 ERRORF(reporter, "makeTextureImage returned non-texture image.");
431 continue;
432 }
Robert Phillips87444052017-06-23 14:09:30 -0400433 if (image->isTextureBacked()) {
434 GrSurfaceProxy* origProxy = as_IB(image)->peekProxy();
435 GrSurfaceProxy* copyProxy = as_IB(texImage)->peekProxy();
436
437 if (origProxy->underlyingUniqueID() != copyProxy->underlyingUniqueID()) {
Brian Osmane8827d22017-02-07 12:31:02 -0500438 ERRORF(reporter, "makeTextureImage made unnecessary texture copy.");
439 }
440 }
441 if (image->width() != texImage->width() || image->height() != texImage->height()) {
442 ERRORF(reporter, "makeTextureImage changed the image size.");
443 }
444 if (image->alphaType() != texImage->alphaType()) {
445 ERRORF(reporter, "makeTextureImage changed image alpha type.");
446 }
Brian Osman041f7df2017-02-07 11:23:28 -0500447 }
Robert Phillipsd9971c02017-08-02 11:51:43 -0400448
Robert Phillipsd9971c02017-08-02 11:51:43 -0400449 context->flush();
Brian Osman041f7df2017-02-07 11:23:28 -0500450 }
451}
452
bsalomon634b4302016-07-12 18:11:17 -0700453DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SkImage_makeNonTextureImage, reporter, contextInfo) {
454 GrContext* context = contextInfo.grContext();
455
456 std::function<sk_sp<SkImage>()> imageFactories[] = {
457 create_image,
458 create_codec_image,
459 create_data_image,
460 create_picture_image,
461 [context] { return create_gpu_image(context); },
462 };
Brian Osman041f7df2017-02-07 11:23:28 -0500463 SkColorSpace* legacyColorSpace = nullptr;
bsalomon634b4302016-07-12 18:11:17 -0700464 for (auto factory : imageFactories) {
465 sk_sp<SkImage> image = factory();
466 if (!image->isTextureBacked()) {
467 REPORTER_ASSERT(reporter, image->makeNonTextureImage().get() == image.get());
Brian Osman041f7df2017-02-07 11:23:28 -0500468 if (!(image = image->makeTextureImage(context, legacyColorSpace))) {
469 continue;
470 }
bsalomon634b4302016-07-12 18:11:17 -0700471 }
472 auto rasterImage = image->makeNonTextureImage();
473 if (!rasterImage) {
474 ERRORF(reporter, "makeNonTextureImage failed for texture-backed image.");
475 }
476 REPORTER_ASSERT(reporter, !rasterImage->isTextureBacked());
477 assert_equal(reporter, image.get(), nullptr, rasterImage.get());
478 }
479}
480
bsalomon363bc332016-06-15 14:15:30 -0700481DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SkImage_drawAbandonedGpuImage, reporter, contextInfo) {
bsalomone5b651f2016-06-15 07:36:15 -0700482 auto context = contextInfo.grContext();
483 auto image = create_gpu_image(context);
484 auto info = SkImageInfo::MakeN32(20, 20, kOpaque_SkAlphaType);
485 auto surface(SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info));
Robert Phillips87444052017-06-23 14:09:30 -0400486 image->getTexture()->abandon();
bsalomone5b651f2016-06-15 07:36:15 -0700487 surface->getCanvas()->drawImage(image, 0, 0);
488}
489
Brian Salomonbdecacf2018-02-02 20:32:49 -0500490DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrContext_colorTypeSupportedAsImage, reporter, ctxInfo) {
491 for (int ct = 0; ct < kLastEnum_SkColorType; ++ct) {
492 static constexpr int kSize = 10;
493 SkColorType colorType = static_cast<SkColorType>(ct);
494 bool can = ctxInfo.grContext()->colorTypeSupportedAsImage(colorType);
495 auto* gpu = ctxInfo.grContext()->contextPriv().getGpu();
496 GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture(
Greg Daniel57bf4a32018-04-19 10:28:37 -0400497 nullptr, kSize, kSize, colorType, nullptr, false, GrMipMapped::kNo);
Brian Salomonbdecacf2018-02-02 20:32:49 -0500498 auto img =
499 SkImage::MakeFromTexture(ctxInfo.grContext(), backendTex, kTopLeft_GrSurfaceOrigin,
500 colorType, kOpaque_SkAlphaType, nullptr);
501 REPORTER_ASSERT(reporter, can == SkToBool(img),
Oleg Maximenko5d4604b2018-02-26 17:58:58 +0300502 "colorTypeSupportedAsImage:%d, actual:%d, ct:%d", can, SkToBool(img),
Brian Salomonbdecacf2018-02-02 20:32:49 -0500503 colorType);
504
505 img.reset();
506 ctxInfo.grContext()->flush();
507 if (backendTex.isValid()) {
Brian Salomon26102cb2018-03-09 09:33:19 -0500508 gpu->deleteTestingOnlyBackendTexture(backendTex);
Brian Salomonbdecacf2018-02-02 20:32:49 -0500509 }
510 }
511}
512
Brian Salomon9708af82018-02-05 12:57:10 -0500513DEF_GPUTEST_FOR_RENDERING_CONTEXTS(UnpremulTextureImage, reporter, ctxInfo) {
514 SkBitmap bmp;
515 bmp.allocPixels(
516 SkImageInfo::Make(256, 256, kRGBA_8888_SkColorType, kUnpremul_SkAlphaType, nullptr));
517 for (int y = 0; y < 256; ++y) {
518 for (int x = 0; x < 256; ++x) {
519 *bmp.getAddr32(x, y) =
520 SkColorSetARGB((U8CPU)y, 255 - (U8CPU)y, (U8CPU)x, 255 - (U8CPU)x);
521 }
522 }
523 auto texImage = SkImage::MakeFromBitmap(bmp)->makeTextureImage(ctxInfo.grContext(), nullptr);
524 if (!texImage || texImage->alphaType() != kUnpremul_SkAlphaType) {
525 ERRORF(reporter, "Failed to make unpremul texture image.");
526 return;
527 }
528 // The GPU backend always unpremuls the values stored in the texture because it assumes they
529 // are premul values. (skbug.com/7580).
530 if (false) {
531 SkBitmap unpremul;
532 unpremul.allocPixels(SkImageInfo::Make(256, 256, kRGBA_8888_SkColorType,
533 kUnpremul_SkAlphaType, nullptr));
534 if (!texImage->readPixels(unpremul.info(), unpremul.getPixels(), unpremul.rowBytes(), 0,
535 0)) {
536 ERRORF(reporter, "Unpremul readback failed.");
537 return;
538 }
539 for (int y = 0; y < 256; ++y) {
540 for (int x = 0; x < 256; ++x) {
541 if (*bmp.getAddr32(x, y) != *unpremul.getAddr32(x, y)) {
542 ERRORF(reporter, "unpremul(0x%08x)->unpremul(0x%08x) at %d, %d.",
543 *bmp.getAddr32(x, y), *unpremul.getAddr32(x, y), x, y);
544 return;
545 }
546 }
547 }
548 }
549 SkBitmap premul;
550 premul.allocPixels(
551 SkImageInfo::Make(256, 256, kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr));
552 if (!texImage->readPixels(premul.info(), premul.getPixels(), premul.rowBytes(), 0, 0)) {
553 ERRORF(reporter, "Unpremul readback failed.");
554 return;
555 }
556 for (int y = 0; y < 256; ++y) {
557 for (int x = 0; x < 256; ++x) {
558 // Treat bmp's color as a pm color even though it may be the r/b swap of a PM color.
559 // SkPremultiplyColor acts the same on both channels.
560 uint32_t origColor = SkPreMultiplyColor(*bmp.getAddr32(x, y));
561 int32_t origA = (origColor >> 24) & 0xff;
562 int32_t origB = (origColor >> 16) & 0xff;
563 int32_t origG = (origColor >> 8) & 0xff;
564 int32_t origR = (origColor >> 0) & 0xff;
565 uint32_t read = *premul.getAddr32(x, y);
566 int32_t readA = (read >> 24) & 0xff;
567 int32_t readB = (read >> 16) & 0xff;
568 int32_t readG = (read >> 8) & 0xff;
569 int32_t readR = (read >> 0) & 0xff;
570 // We expect that alpha=1 and alpha=0 should come out exact. Otherwise allow a little
571 // bit of tolerance for GPU vs CPU premul math.
572 int32_t tol = (origA == 0 || origA == 255) ? 0 : 1;
573 if (origA != readA || SkTAbs(readB - origB) > tol || SkTAbs(readG - origG) > tol ||
574 SkTAbs(readR - origR) > tol) {
575 ERRORF(reporter, "unpremul(0x%08x)->premul(0x%08x) at %d, %d.",
576 *bmp.getAddr32(x, y), *premul.getAddr32(x, y), x, y);
577 return;
578 }
579 }
580 }
581}
582
reed6f1216a2015-08-04 08:10:13 -0700583#endif
halcanaryc56c6ef2015-09-28 11:55:28 -0700584
kkinnunen4e184132015-11-17 22:53:28 -0800585class EmptyGenerator : public SkImageGenerator {
586public:
587 EmptyGenerator() : SkImageGenerator(SkImageInfo::MakeN32Premul(0, 0)) {}
588};
589
kkinnunen7b94c142015-11-24 07:39:40 -0800590DEF_TEST(ImageEmpty, reporter) {
kkinnunen4e184132015-11-17 22:53:28 -0800591 const SkImageInfo info = SkImageInfo::Make(0, 0, kN32_SkColorType, kPremul_SkAlphaType);
reed9ce9d672016-03-17 10:51:11 -0700592 SkPixmap pmap(info, nullptr, 0);
593 REPORTER_ASSERT(reporter, nullptr == SkImage::MakeRasterCopy(pmap));
594 REPORTER_ASSERT(reporter, nullptr == SkImage::MakeRasterData(info, nullptr, 0));
595 REPORTER_ASSERT(reporter, nullptr == SkImage::MakeFromRaster(pmap, nullptr, nullptr));
Mike Reed185130c2017-02-15 15:14:16 -0500596 REPORTER_ASSERT(reporter, nullptr == SkImage::MakeFromGenerator(
597 skstd::make_unique<EmptyGenerator>()));
kkinnunen4e184132015-11-17 22:53:28 -0800598}
599
kkinnunen7b94c142015-11-24 07:39:40 -0800600DEF_TEST(ImageDataRef, reporter) {
kkinnunen4e184132015-11-17 22:53:28 -0800601 SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1);
602 size_t rowBytes = info.minRowBytes();
Mike Reedf0ffb892017-10-03 14:47:21 -0400603 size_t size = info.computeByteSize(rowBytes);
reed9ce9d672016-03-17 10:51:11 -0700604 sk_sp<SkData> data = SkData::MakeUninitialized(size);
kkinnunen4e184132015-11-17 22:53:28 -0800605 REPORTER_ASSERT(reporter, data->unique());
reed9ce9d672016-03-17 10:51:11 -0700606 sk_sp<SkImage> image = SkImage::MakeRasterData(info, data, rowBytes);
kkinnunen4e184132015-11-17 22:53:28 -0800607 REPORTER_ASSERT(reporter, !data->unique());
reed9ce9d672016-03-17 10:51:11 -0700608 image.reset();
kkinnunen4e184132015-11-17 22:53:28 -0800609 REPORTER_ASSERT(reporter, data->unique());
kkinnunen4e184132015-11-17 22:53:28 -0800610}
611
kkinnunen4e184132015-11-17 22:53:28 -0800612static bool has_pixels(const SkPMColor pixels[], int count, SkPMColor expected) {
613 for (int i = 0; i < count; ++i) {
614 if (pixels[i] != expected) {
615 return false;
616 }
617 }
618 return true;
619}
620
Robert Phillips3500b772017-01-27 10:11:42 -0500621static void image_test_read_pixels(skiatest::Reporter* reporter, SkImage* image) {
scroggo8e6c7ad2016-09-16 08:20:38 -0700622 if (!image) {
623 ERRORF(reporter, "Failed to create image!");
624 return;
625 }
kkinnunen7b94c142015-11-24 07:39:40 -0800626 const SkPMColor expected = SkPreMultiplyColor(SK_ColorWHITE);
kkinnunen4e184132015-11-17 22:53:28 -0800627 const SkPMColor notExpected = ~expected;
628
629 const int w = 2, h = 2;
630 const size_t rowBytes = w * sizeof(SkPMColor);
631 SkPMColor pixels[w*h];
632
633 SkImageInfo info;
634
635 info = SkImageInfo::MakeUnknown(w, h);
636 REPORTER_ASSERT(reporter, !image->readPixels(info, pixels, rowBytes, 0, 0));
637
638 // out-of-bounds should fail
639 info = SkImageInfo::MakeN32Premul(w, h);
640 REPORTER_ASSERT(reporter, !image->readPixels(info, pixels, rowBytes, -w, 0));
641 REPORTER_ASSERT(reporter, !image->readPixels(info, pixels, rowBytes, 0, -h));
642 REPORTER_ASSERT(reporter, !image->readPixels(info, pixels, rowBytes, image->width(), 0));
643 REPORTER_ASSERT(reporter, !image->readPixels(info, pixels, rowBytes, 0, image->height()));
644
645 // top-left should succeed
kkinnunen7b94c142015-11-24 07:39:40 -0800646 sk_memset32(pixels, notExpected, w*h);
kkinnunen4e184132015-11-17 22:53:28 -0800647 REPORTER_ASSERT(reporter, image->readPixels(info, pixels, rowBytes, 0, 0));
648 REPORTER_ASSERT(reporter, has_pixels(pixels, w*h, expected));
649
650 // bottom-right should succeed
kkinnunen7b94c142015-11-24 07:39:40 -0800651 sk_memset32(pixels, notExpected, w*h);
kkinnunen4e184132015-11-17 22:53:28 -0800652 REPORTER_ASSERT(reporter, image->readPixels(info, pixels, rowBytes,
653 image->width() - w, image->height() - h));
654 REPORTER_ASSERT(reporter, has_pixels(pixels, w*h, expected));
655
656 // partial top-left should succeed
kkinnunen7b94c142015-11-24 07:39:40 -0800657 sk_memset32(pixels, notExpected, w*h);
kkinnunen4e184132015-11-17 22:53:28 -0800658 REPORTER_ASSERT(reporter, image->readPixels(info, pixels, rowBytes, -1, -1));
659 REPORTER_ASSERT(reporter, pixels[3] == expected);
660 REPORTER_ASSERT(reporter, has_pixels(pixels, w*h - 1, notExpected));
661
662 // partial bottom-right should succeed
kkinnunen7b94c142015-11-24 07:39:40 -0800663 sk_memset32(pixels, notExpected, w*h);
kkinnunen4e184132015-11-17 22:53:28 -0800664 REPORTER_ASSERT(reporter, image->readPixels(info, pixels, rowBytes,
665 image->width() - 1, image->height() - 1));
666 REPORTER_ASSERT(reporter, pixels[0] == expected);
667 REPORTER_ASSERT(reporter, has_pixels(&pixels[1], w*h - 1, notExpected));
668}
kkinnunen7b94c142015-11-24 07:39:40 -0800669DEF_TEST(ImageReadPixels, reporter) {
reed9ce9d672016-03-17 10:51:11 -0700670 sk_sp<SkImage> image(create_image());
Robert Phillips3500b772017-01-27 10:11:42 -0500671 image_test_read_pixels(reporter, image.get());
kkinnunen7b94c142015-11-24 07:39:40 -0800672
reed9ce9d672016-03-17 10:51:11 -0700673 image = create_data_image();
Robert Phillips3500b772017-01-27 10:11:42 -0500674 image_test_read_pixels(reporter, image.get());
kkinnunen7b94c142015-11-24 07:39:40 -0800675
676 RasterDataHolder dataHolder;
reed9ce9d672016-03-17 10:51:11 -0700677 image = create_rasterproc_image(&dataHolder);
Robert Phillips3500b772017-01-27 10:11:42 -0500678 image_test_read_pixels(reporter, image.get());
kkinnunen7b94c142015-11-24 07:39:40 -0800679 image.reset();
680 REPORTER_ASSERT(reporter, 1 == dataHolder.fReleaseCount);
681
reed9ce9d672016-03-17 10:51:11 -0700682 image = create_codec_image();
Robert Phillips3500b772017-01-27 10:11:42 -0500683 image_test_read_pixels(reporter, image.get());
kkinnunen7b94c142015-11-24 07:39:40 -0800684}
685#if SK_SUPPORT_GPU
egdanielab527a52016-06-28 08:07:26 -0700686DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageReadPixels_Gpu, reporter, ctxInfo) {
Robert Phillips3500b772017-01-27 10:11:42 -0500687 image_test_read_pixels(reporter, create_gpu_image(ctxInfo.grContext()).get());
kkinnunen7b94c142015-11-24 07:39:40 -0800688}
689#endif
kkinnunen4e184132015-11-17 22:53:28 -0800690
691static void check_legacy_bitmap(skiatest::Reporter* reporter, const SkImage* image,
Cary Clark4f5a79c2018-02-07 15:51:00 -0500692 const SkBitmap& bitmap) {
kkinnunen4e184132015-11-17 22:53:28 -0800693 REPORTER_ASSERT(reporter, image->width() == bitmap.width());
694 REPORTER_ASSERT(reporter, image->height() == bitmap.height());
brianosman69c166d2016-08-17 14:01:05 -0700695 REPORTER_ASSERT(reporter, image->alphaType() == bitmap.alphaType());
kkinnunen4e184132015-11-17 22:53:28 -0800696
Cary Clark4f5a79c2018-02-07 15:51:00 -0500697 REPORTER_ASSERT(reporter, bitmap.isImmutable());
kkinnunen4e184132015-11-17 22:53:28 -0800698
kkinnunen4e184132015-11-17 22:53:28 -0800699 REPORTER_ASSERT(reporter, bitmap.getPixels());
700
701 const SkImageInfo info = SkImageInfo::MakeN32(1, 1, bitmap.alphaType());
702 SkPMColor imageColor;
703 REPORTER_ASSERT(reporter, image->readPixels(info, &imageColor, sizeof(SkPMColor), 0, 0));
704 REPORTER_ASSERT(reporter, imageColor == *bitmap.getAddr32(0, 0));
705}
706
Cary Clark4f5a79c2018-02-07 15:51:00 -0500707static void test_legacy_bitmap(skiatest::Reporter* reporter, const SkImage* image) {
scroggo8e6c7ad2016-09-16 08:20:38 -0700708 if (!image) {
709 ERRORF(reporter, "Failed to create image.");
710 return;
711 }
kkinnunen7b94c142015-11-24 07:39:40 -0800712 SkBitmap bitmap;
Cary Clark4f5a79c2018-02-07 15:51:00 -0500713 REPORTER_ASSERT(reporter, image->asLegacyBitmap(&bitmap));
714 check_legacy_bitmap(reporter, image, bitmap);
kkinnunen7b94c142015-11-24 07:39:40 -0800715
716 // Test subsetting to exercise the rowBytes logic.
717 SkBitmap tmp;
718 REPORTER_ASSERT(reporter, bitmap.extractSubset(&tmp, SkIRect::MakeWH(image->width() / 2,
719 image->height() / 2)));
reed9ce9d672016-03-17 10:51:11 -0700720 sk_sp<SkImage> subsetImage(SkImage::MakeFromBitmap(tmp));
721 REPORTER_ASSERT(reporter, subsetImage.get());
kkinnunen7b94c142015-11-24 07:39:40 -0800722
723 SkBitmap subsetBitmap;
Cary Clark4f5a79c2018-02-07 15:51:00 -0500724 REPORTER_ASSERT(reporter, subsetImage->asLegacyBitmap(&subsetBitmap));
725 check_legacy_bitmap(reporter, subsetImage.get(), subsetBitmap);
kkinnunen7b94c142015-11-24 07:39:40 -0800726}
727DEF_TEST(ImageLegacyBitmap, reporter) {
Cary Clark4f5a79c2018-02-07 15:51:00 -0500728 sk_sp<SkImage> image(create_image());
729 test_legacy_bitmap(reporter, image.get());
kkinnunen4e184132015-11-17 22:53:28 -0800730
Cary Clark4f5a79c2018-02-07 15:51:00 -0500731 image = create_data_image();
732 test_legacy_bitmap(reporter, image.get());
kkinnunen4e184132015-11-17 22:53:28 -0800733
Cary Clark4f5a79c2018-02-07 15:51:00 -0500734 RasterDataHolder dataHolder;
735 image = create_rasterproc_image(&dataHolder);
736 test_legacy_bitmap(reporter, image.get());
737 image.reset();
738 REPORTER_ASSERT(reporter, 1 == dataHolder.fReleaseCount);
kkinnunen7b94c142015-11-24 07:39:40 -0800739
Cary Clark4f5a79c2018-02-07 15:51:00 -0500740 image = create_codec_image();
741 test_legacy_bitmap(reporter, image.get());
kkinnunen4e184132015-11-17 22:53:28 -0800742}
kkinnunen4e184132015-11-17 22:53:28 -0800743#if SK_SUPPORT_GPU
bsalomon68d91342016-04-12 09:59:58 -0700744DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageLegacyBitmap_Gpu, reporter, ctxInfo) {
Cary Clark4f5a79c2018-02-07 15:51:00 -0500745 sk_sp<SkImage> image(create_gpu_image(ctxInfo.grContext()));
746 test_legacy_bitmap(reporter, image.get());
kkinnunen7b94c142015-11-24 07:39:40 -0800747}
kkinnunen4e184132015-11-17 22:53:28 -0800748#endif
749
kkinnunen7b94c142015-11-24 07:39:40 -0800750static void test_peek(skiatest::Reporter* reporter, SkImage* image, bool expectPeekSuccess) {
scroggo8e6c7ad2016-09-16 08:20:38 -0700751 if (!image) {
752 ERRORF(reporter, "Failed to create image!");
753 return;
754 }
reed6ceeebd2016-03-09 14:26:26 -0800755 SkPixmap pm;
756 bool success = image->peekPixels(&pm);
kkinnunen7b94c142015-11-24 07:39:40 -0800757 REPORTER_ASSERT(reporter, expectPeekSuccess == success);
758 if (success) {
reed6ceeebd2016-03-09 14:26:26 -0800759 const SkImageInfo& info = pm.info();
kkinnunen7b94c142015-11-24 07:39:40 -0800760 REPORTER_ASSERT(reporter, 20 == info.width());
761 REPORTER_ASSERT(reporter, 20 == info.height());
762 REPORTER_ASSERT(reporter, kN32_SkColorType == info.colorType());
763 REPORTER_ASSERT(reporter, kPremul_SkAlphaType == info.alphaType() ||
764 kOpaque_SkAlphaType == info.alphaType());
reed6ceeebd2016-03-09 14:26:26 -0800765 REPORTER_ASSERT(reporter, info.minRowBytes() <= pm.rowBytes());
766 REPORTER_ASSERT(reporter, SkPreMultiplyColor(SK_ColorWHITE) == *pm.addr32(0, 0));
kkinnunen4e184132015-11-17 22:53:28 -0800767 }
kkinnunen7b94c142015-11-24 07:39:40 -0800768}
769DEF_TEST(ImagePeek, reporter) {
reed9ce9d672016-03-17 10:51:11 -0700770 sk_sp<SkImage> image(create_image());
771 test_peek(reporter, image.get(), true);
kkinnunen7b94c142015-11-24 07:39:40 -0800772
reed9ce9d672016-03-17 10:51:11 -0700773 image = create_data_image();
774 test_peek(reporter, image.get(), true);
kkinnunen7b94c142015-11-24 07:39:40 -0800775
776 RasterDataHolder dataHolder;
reed9ce9d672016-03-17 10:51:11 -0700777 image = create_rasterproc_image(&dataHolder);
778 test_peek(reporter, image.get(), true);
kkinnunen7b94c142015-11-24 07:39:40 -0800779 image.reset();
780 REPORTER_ASSERT(reporter, 1 == dataHolder.fReleaseCount);
781
reed9ce9d672016-03-17 10:51:11 -0700782 image = create_codec_image();
783 test_peek(reporter, image.get(), false);
kkinnunen4e184132015-11-17 22:53:28 -0800784}
785#if SK_SUPPORT_GPU
egdanielab527a52016-06-28 08:07:26 -0700786DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImagePeek_Gpu, reporter, ctxInfo) {
bsalomon8b7451a2016-05-11 06:33:06 -0700787 sk_sp<SkImage> image(create_gpu_image(ctxInfo.grContext()));
reed9ce9d672016-03-17 10:51:11 -0700788 test_peek(reporter, image.get(), false);
kkinnunen7b94c142015-11-24 07:39:40 -0800789}
790#endif
kkinnunen4e184132015-11-17 22:53:28 -0800791
kkinnunen7b94c142015-11-24 07:39:40 -0800792#if SK_SUPPORT_GPU
793struct TextureReleaseChecker {
794 TextureReleaseChecker() : fReleaseCount(0) {}
795 int fReleaseCount;
796 static void Release(void* self) {
797 static_cast<TextureReleaseChecker*>(self)->fReleaseCount++;
kkinnunen4e184132015-11-17 22:53:28 -0800798 }
799};
Brian Osman13dddce2017-05-09 13:19:50 -0400800
brianosmandb2cb102016-07-22 07:22:04 -0700801DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SkImage_NewFromTextureRelease, reporter, ctxInfo) {
802 const int kWidth = 10;
803 const int kHeight = 10;
Ben Wagner7ecc5962016-11-02 17:07:33 -0400804 std::unique_ptr<uint32_t[]> pixels(new uint32_t[kWidth * kHeight]);
Greg Daniel7ef28f32017-04-20 16:41:55 +0000805
806 GrContext* ctx = ctxInfo.grContext();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500807 GrGpu* gpu = ctx->contextPriv().getGpu();
Greg Daniel7ef28f32017-04-20 16:41:55 +0000808
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500809 GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture(
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500810 pixels.get(), kWidth, kHeight, kRGBA_8888_GrPixelConfig, true, GrMipMapped::kNo);
brianosmandb2cb102016-07-22 07:22:04 -0700811
kkinnunen7b94c142015-11-24 07:39:40 -0800812 TextureReleaseChecker releaseChecker;
Greg Daniel7ef28f32017-04-20 16:41:55 +0000813 GrSurfaceOrigin texOrigin = kBottomLeft_GrSurfaceOrigin;
reed9ce9d672016-03-17 10:51:11 -0700814 sk_sp<SkImage> refImg(
Greg Danielf5d87582017-12-18 14:48:15 -0500815 SkImage::MakeFromTexture(ctx, backendTex, texOrigin, kRGBA_8888_SkColorType,
816 kPremul_SkAlphaType, nullptr,
reed9ce9d672016-03-17 10:51:11 -0700817 TextureReleaseChecker::Release, &releaseChecker));
kkinnunen4e184132015-11-17 22:53:28 -0800818
Robert Phillips3390e152017-01-31 17:53:34 -0500819 GrSurfaceOrigin readBackOrigin;
Robert Phillipsc5509952018-04-04 15:54:55 -0400820 GrBackendTexture readBackBackendTex = refImg->getBackendTexture(false, &readBackOrigin);
821 if (!GrBackendTexture::TestingOnly_Equals(readBackBackendTex, backendTex)) {
822 ERRORF(reporter, "backend mismatch\n");
Robert Phillips3390e152017-01-31 17:53:34 -0500823 }
Robert Phillipsc5509952018-04-04 15:54:55 -0400824 REPORTER_ASSERT(reporter, GrBackendTexture::TestingOnly_Equals(readBackBackendTex, backendTex));
Greg Daniel7ef28f32017-04-20 16:41:55 +0000825 if (readBackOrigin != texOrigin) {
826 ERRORF(reporter, "origin mismatch %d %d\n", readBackOrigin, texOrigin);
Robert Phillips3390e152017-01-31 17:53:34 -0500827 }
Greg Daniel7ef28f32017-04-20 16:41:55 +0000828 REPORTER_ASSERT(reporter, readBackOrigin == texOrigin);
Robert Phillips3390e152017-01-31 17:53:34 -0500829
kkinnunen4e184132015-11-17 22:53:28 -0800830 // Now exercise the release proc
kkinnunen7b94c142015-11-24 07:39:40 -0800831 REPORTER_ASSERT(reporter, 0 == releaseChecker.fReleaseCount);
kkinnunen4e184132015-11-17 22:53:28 -0800832 refImg.reset(nullptr); // force a release of the image
kkinnunen7b94c142015-11-24 07:39:40 -0800833 REPORTER_ASSERT(reporter, 1 == releaseChecker.fReleaseCount);
brianosmandb2cb102016-07-22 07:22:04 -0700834
Brian Salomon26102cb2018-03-09 09:33:19 -0500835 gpu->deleteTestingOnlyBackendTexture(backendTex);
kkinnunen4e184132015-11-17 22:53:28 -0800836}
bsalomon0d996862016-03-09 18:44:43 -0800837
Brian Salomondcfca432017-11-15 15:48:03 -0500838static void test_cross_context_image(skiatest::Reporter* reporter, const GrContextOptions& options,
Hal Canaryf7d3f612018-03-22 15:17:42 -0400839 const char* testName,
Brian Osman63bc48d2017-11-07 10:37:00 -0500840 std::function<sk_sp<SkImage>(GrContext*)> imageMaker) {
Brian Osmanceb7a422017-06-21 15:10:33 -0400841 for (int i = 0; i < GrContextFactory::kContextTypeCnt; ++i) {
Brian Salomondcfca432017-11-15 15:48:03 -0500842 GrContextFactory testFactory(options);
Brian Osmanceb7a422017-06-21 15:10:33 -0400843 GrContextFactory::ContextType ctxType = static_cast<GrContextFactory::ContextType>(i);
844 ContextInfo ctxInfo = testFactory.getContextInfo(ctxType);
845 GrContext* ctx = ctxInfo.grContext();
846 if (!ctx) {
847 continue;
848 }
Brian Osman13dddce2017-05-09 13:19:50 -0400849
Brian Osmanceb7a422017-06-21 15:10:33 -0400850 // If we don't have proper support for this feature, the factory will fallback to returning
851 // codec-backed images. Those will "work", but some of our checks will fail because we
852 // expect the cross-context images not to work on multiple contexts at once.
Brian Salomonc7fe0f72018-05-11 10:14:21 -0400853 if (!ctx->contextPriv().caps()->crossContextTextureSupport()) {
Brian Osmanceb7a422017-06-21 15:10:33 -0400854 continue;
855 }
Brian Osman13dddce2017-05-09 13:19:50 -0400856
Brian Osmanceb7a422017-06-21 15:10:33 -0400857 // We test three lifetime patterns for a single context:
858 // 1) Create image, free image
859 // 2) Create image, draw, flush, free image
860 // 3) Create image, draw, free image, flush
861 // ... and then repeat the last two patterns with drawing on a second* context:
862 // 4) Create image, draw*, flush*, free image
863 // 5) Create image, draw*, free iamge, flush*
Brian Osman13dddce2017-05-09 13:19:50 -0400864
Brian Osmanceb7a422017-06-21 15:10:33 -0400865 // Case #1: Create image, free image
866 {
Brian Osman63bc48d2017-11-07 10:37:00 -0500867 sk_sp<SkImage> refImg(imageMaker(ctx));
Brian Osmanceb7a422017-06-21 15:10:33 -0400868 refImg.reset(nullptr); // force a release of the image
869 }
Brian Osman13dddce2017-05-09 13:19:50 -0400870
Brian Osmanceb7a422017-06-21 15:10:33 -0400871 SkImageInfo info = SkImageInfo::MakeN32Premul(128, 128);
872 sk_sp<SkSurface> surface = SkSurface::MakeRenderTarget(ctx, SkBudgeted::kNo, info);
Hal Canaryf7d3f612018-03-22 15:17:42 -0400873 if (!surface) {
874 ERRORF(reporter, "SkSurface::MakeRenderTarget failed for %s.", testName);
875 continue;
876 }
877
Brian Osmanceb7a422017-06-21 15:10:33 -0400878 SkCanvas* canvas = surface->getCanvas();
Brian Osman13dddce2017-05-09 13:19:50 -0400879
Brian Osmanceb7a422017-06-21 15:10:33 -0400880 // Case #2: Create image, draw, flush, free image
881 {
Brian Osman63bc48d2017-11-07 10:37:00 -0500882 sk_sp<SkImage> refImg(imageMaker(ctx));
Brian Osman13dddce2017-05-09 13:19:50 -0400883
Brian Osmanceb7a422017-06-21 15:10:33 -0400884 canvas->drawImage(refImg, 0, 0);
885 canvas->flush();
Brian Osman13dddce2017-05-09 13:19:50 -0400886
Brian Osmanceb7a422017-06-21 15:10:33 -0400887 refImg.reset(nullptr); // force a release of the image
888 }
Brian Osman13dddce2017-05-09 13:19:50 -0400889
Brian Osmanceb7a422017-06-21 15:10:33 -0400890 // Case #3: Create image, draw, free image, flush
891 {
Brian Osman63bc48d2017-11-07 10:37:00 -0500892 sk_sp<SkImage> refImg(imageMaker(ctx));
Brian Osman13dddce2017-05-09 13:19:50 -0400893
Brian Osmanceb7a422017-06-21 15:10:33 -0400894 canvas->drawImage(refImg, 0, 0);
895 refImg.reset(nullptr); // force a release of the image
Brian Osman13dddce2017-05-09 13:19:50 -0400896
Brian Osmanceb7a422017-06-21 15:10:33 -0400897 canvas->flush();
898 }
Brian Osman13dddce2017-05-09 13:19:50 -0400899
Brian Osmanceb7a422017-06-21 15:10:33 -0400900 // Configure second context
901 sk_gpu_test::TestContext* testContext = ctxInfo.testContext();
Brian Osman13dddce2017-05-09 13:19:50 -0400902
Brian Osmanceb7a422017-06-21 15:10:33 -0400903 ContextInfo otherContextInfo = testFactory.getSharedContextInfo(ctx);
904 GrContext* otherCtx = otherContextInfo.grContext();
905 sk_gpu_test::TestContext* otherTestContext = otherContextInfo.testContext();
Brian Osman13dddce2017-05-09 13:19:50 -0400906
Brian Osmanceb7a422017-06-21 15:10:33 -0400907 // Creating a context in a share group may fail
908 if (!otherCtx) {
909 continue;
910 }
Brian Osman13dddce2017-05-09 13:19:50 -0400911
Brian Osmanceb7a422017-06-21 15:10:33 -0400912 surface = SkSurface::MakeRenderTarget(otherCtx, SkBudgeted::kNo, info);
913 canvas = surface->getCanvas();
Brian Osman13dddce2017-05-09 13:19:50 -0400914
Brian Osmanceb7a422017-06-21 15:10:33 -0400915 // Case #4: Create image, draw*, flush*, free image
916 {
917 testContext->makeCurrent();
Brian Osman63bc48d2017-11-07 10:37:00 -0500918 sk_sp<SkImage> refImg(imageMaker(ctx));
Brian Osman13dddce2017-05-09 13:19:50 -0400919
Brian Osmanceb7a422017-06-21 15:10:33 -0400920 otherTestContext->makeCurrent();
921 canvas->drawImage(refImg, 0, 0);
922 canvas->flush();
Brian Osman13dddce2017-05-09 13:19:50 -0400923
Brian Osmanceb7a422017-06-21 15:10:33 -0400924 testContext->makeCurrent();
925 refImg.reset(nullptr); // force a release of the image
926 }
Brian Osman13dddce2017-05-09 13:19:50 -0400927
Brian Osmanceb7a422017-06-21 15:10:33 -0400928 // Case #5: Create image, draw*, free image, flush*
929 {
930 testContext->makeCurrent();
Brian Osman63bc48d2017-11-07 10:37:00 -0500931 sk_sp<SkImage> refImg(imageMaker(ctx));
Brian Osman13dddce2017-05-09 13:19:50 -0400932
Brian Osmanceb7a422017-06-21 15:10:33 -0400933 otherTestContext->makeCurrent();
934 canvas->drawImage(refImg, 0, 0);
Brian Osman13dddce2017-05-09 13:19:50 -0400935
Brian Osmanceb7a422017-06-21 15:10:33 -0400936 testContext->makeCurrent();
937 refImg.reset(nullptr); // force a release of the image
Brian Osman13dddce2017-05-09 13:19:50 -0400938
Brian Osmanceb7a422017-06-21 15:10:33 -0400939 otherTestContext->makeCurrent();
940 canvas->flush();
Greg Daniel3f475d92017-07-25 16:26:35 -0400941
Greg Daniel26b50a42018-03-08 09:49:58 -0500942 // This is specifically here for vulkan to guarantee the command buffer will finish
943 // which is when we call the ReleaseProc.
944 otherCtx->contextPriv().getGpu()->testingOnly_flushGpuAndSync();
Brian Osmanceb7a422017-06-21 15:10:33 -0400945 }
Brian Osman13dddce2017-05-09 13:19:50 -0400946
Brian Osmanceb7a422017-06-21 15:10:33 -0400947 // Case #6: Verify that only one context can be using the image at a time
948 {
949 testContext->makeCurrent();
Brian Osman63bc48d2017-11-07 10:37:00 -0500950 sk_sp<SkImage> refImg(imageMaker(ctx));
Brian Osman13dddce2017-05-09 13:19:50 -0400951
Brian Osmanceb7a422017-06-21 15:10:33 -0400952 // Any context should be able to borrow the texture at this point
953 sk_sp<SkColorSpace> texColorSpace;
954 sk_sp<GrTextureProxy> proxy = as_IB(refImg)->asTextureProxyRef(
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400955 ctx, GrSamplerState::ClampNearest(), nullptr, &texColorSpace, nullptr);
Brian Osmanceb7a422017-06-21 15:10:33 -0400956 REPORTER_ASSERT(reporter, proxy);
Brian Osman13dddce2017-05-09 13:19:50 -0400957
Brian Osmanceb7a422017-06-21 15:10:33 -0400958 // But once it's borrowed, no other context should be able to borrow
959 otherTestContext->makeCurrent();
960 sk_sp<GrTextureProxy> otherProxy = as_IB(refImg)->asTextureProxyRef(
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400961 otherCtx, GrSamplerState::ClampNearest(), nullptr, &texColorSpace, nullptr);
Brian Osmanceb7a422017-06-21 15:10:33 -0400962 REPORTER_ASSERT(reporter, !otherProxy);
963
964 // Original context (that's already borrowing) should be okay
965 testContext->makeCurrent();
966 sk_sp<GrTextureProxy> proxySecondRef = as_IB(refImg)->asTextureProxyRef(
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400967 ctx, GrSamplerState::ClampNearest(), nullptr, &texColorSpace, nullptr);
Brian Osmanceb7a422017-06-21 15:10:33 -0400968 REPORTER_ASSERT(reporter, proxySecondRef);
969
Greg Danielabba9982018-02-01 10:07:57 -0500970 // Release first ref from the original context
Brian Osmanceb7a422017-06-21 15:10:33 -0400971 proxy.reset(nullptr);
Greg Danielabba9982018-02-01 10:07:57 -0500972
973 // We released one proxy but not the other from the current borrowing context. Make sure
974 // a new context is still not able to borrow the texture.
975 otherTestContext->makeCurrent();
976 otherProxy = as_IB(refImg)->asTextureProxyRef(otherCtx, GrSamplerState::ClampNearest(),
977 nullptr, &texColorSpace, nullptr);
978 REPORTER_ASSERT(reporter, !otherProxy);
979
980 // Release second ref from the original context
981 testContext->makeCurrent();
Brian Osmanceb7a422017-06-21 15:10:33 -0400982 proxySecondRef.reset(nullptr);
983
Greg Daniel48661b82018-01-22 16:11:35 -0500984 // Now we should be able to borrow the texture from the other context
Brian Osmanceb7a422017-06-21 15:10:33 -0400985 otherTestContext->makeCurrent();
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400986 otherProxy = as_IB(refImg)->asTextureProxyRef(otherCtx, GrSamplerState::ClampNearest(),
987 nullptr, &texColorSpace, nullptr);
Greg Daniel48661b82018-01-22 16:11:35 -0500988 REPORTER_ASSERT(reporter, otherProxy);
Brian Osmanceb7a422017-06-21 15:10:33 -0400989
990 // Release everything
991 otherProxy.reset(nullptr);
992 refImg.reset(nullptr);
993 }
Brian Osman13dddce2017-05-09 13:19:50 -0400994 }
995}
996
Brian Salomondcfca432017-11-15 15:48:03 -0500997DEF_GPUTEST(SkImage_MakeCrossContextFromEncodedRelease, reporter, options) {
Hal Canaryc465d132017-12-08 10:21:31 -0500998 sk_sp<SkData> data = GetResourceAsData("images/mandrill_128.png");
Brian Osman63bc48d2017-11-07 10:37:00 -0500999 SkASSERT(data.get());
1000
Hal Canaryf7d3f612018-03-22 15:17:42 -04001001 test_cross_context_image(reporter, options, "SkImage_MakeCrossContextFromEncodedRelease",
1002 [&data](GrContext* ctx) {
Brian Osman63bc48d2017-11-07 10:37:00 -05001003 return SkImage::MakeCrossContextFromEncoded(ctx, data, false, nullptr);
1004 });
1005}
1006
Brian Salomondcfca432017-11-15 15:48:03 -05001007DEF_GPUTEST(SkImage_MakeCrossContextFromPixmapRelease, reporter, options) {
Brian Osman63bc48d2017-11-07 10:37:00 -05001008 SkBitmap bitmap;
1009 SkPixmap pixmap;
Hal Canaryc465d132017-12-08 10:21:31 -05001010 SkAssertResult(GetResourceAsBitmap("images/mandrill_128.png", &bitmap) && bitmap.peekPixels(&pixmap));
Brian Osman63bc48d2017-11-07 10:37:00 -05001011
Hal Canaryf7d3f612018-03-22 15:17:42 -04001012 test_cross_context_image(reporter, options, "SkImage_MakeCrossContextFromPixmapRelease",
1013 [&pixmap](GrContext* ctx) {
Brian Osman63bc48d2017-11-07 10:37:00 -05001014 return SkImage::MakeCrossContextFromPixmap(ctx, pixmap, false, nullptr);
1015 });
1016}
1017
Brian Osman052ef692018-03-27 09:56:31 -04001018DEF_GPUTEST(SkImage_CrossContextGrayAlphaConfigs, reporter, options) {
1019
1020 for (SkColorType ct : { kGray_8_SkColorType, kAlpha_8_SkColorType }) {
1021 SkAutoPixmapStorage pixmap;
1022 pixmap.alloc(SkImageInfo::Make(4, 4, ct, kPremul_SkAlphaType));
1023
1024 for (int i = 0; i < GrContextFactory::kContextTypeCnt; ++i) {
1025 GrContextFactory testFactory(options);
1026 GrContextFactory::ContextType ctxType = static_cast<GrContextFactory::ContextType>(i);
1027 ContextInfo ctxInfo = testFactory.getContextInfo(ctxType);
1028 GrContext* ctx = ctxInfo.grContext();
Brian Salomonc7fe0f72018-05-11 10:14:21 -04001029 if (!ctx || !ctx->contextPriv().caps()->crossContextTextureSupport()) {
Brian Osman052ef692018-03-27 09:56:31 -04001030 continue;
1031 }
1032
1033 sk_sp<SkImage> image = SkImage::MakeCrossContextFromPixmap(ctx, pixmap, false, nullptr);
1034 REPORTER_ASSERT(reporter, image);
1035
1036 sk_sp<SkColorSpace> texColorSpace;
1037 sk_sp<GrTextureProxy> proxy = as_IB(image)->asTextureProxyRef(
1038 ctx, GrSamplerState::ClampNearest(), nullptr, &texColorSpace, nullptr);
1039 REPORTER_ASSERT(reporter, proxy);
1040
1041 bool expectAlpha = kAlpha_8_SkColorType == ct;
1042 REPORTER_ASSERT(reporter, expectAlpha == GrPixelConfigIsAlphaOnly(proxy->config()));
1043 }
1044 }
1045}
1046
Eric Karl914a36b2017-10-12 12:44:50 -07001047DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(makeBackendTexture, reporter, ctxInfo) {
1048 GrContext* context = ctxInfo.grContext();
1049 sk_gpu_test::TestContext* testContext = ctxInfo.testContext();
1050 sk_sp<GrContextThreadSafeProxy> proxy = context->threadSafeProxy();
1051
1052 GrContextFactory otherFactory;
1053 ContextInfo otherContextInfo = otherFactory.getContextInfo(ctxInfo.type());
1054
1055 testContext->makeCurrent();
1056 REPORTER_ASSERT(reporter, proxy);
1057 auto createLarge = [context] {
Brian Salomonc7fe0f72018-05-11 10:14:21 -04001058 return create_image_large(context->contextPriv().caps()->maxTextureSize());
Eric Karl914a36b2017-10-12 12:44:50 -07001059 };
1060 struct {
1061 std::function<sk_sp<SkImage> ()> fImageFactory;
1062 bool fExpectation;
1063 bool fCanTakeDirectly;
1064 } testCases[] = {
1065 { create_image, true, false },
1066 { create_codec_image, true, false },
1067 { create_data_image, true, false },
1068 { create_picture_image, true, false },
1069 { [context] { return create_gpu_image(context); }, true, true },
1070 // Create a texture image in a another GrContext.
Brian Salomon55ad7742017-11-17 09:25:23 -05001071 { [otherContextInfo] {
1072 auto restore = otherContextInfo.testContext()->makeCurrentAndAutoRestore();
Eric Karl914a36b2017-10-12 12:44:50 -07001073 sk_sp<SkImage> otherContextImage = create_gpu_image(otherContextInfo.grContext());
Brian Salomon55ad7742017-11-17 09:25:23 -05001074 otherContextInfo.grContext()->flush();
Eric Karl914a36b2017-10-12 12:44:50 -07001075 return otherContextImage;
1076 }, false, false },
1077 // Create an image that is too large to be texture backed.
1078 { createLarge, false, false }
1079 };
1080
1081 for (auto testCase : testCases) {
1082 sk_sp<SkImage> image(testCase.fImageFactory());
1083 if (!image) {
1084 ERRORF(reporter, "Failed to create image!");
1085 continue;
1086 }
1087
Robert Phillipsba375a82018-04-11 10:08:06 -04001088 GrBackendTexture origBackend = image->getBackendTexture(true);
1089 if (testCase.fCanTakeDirectly) {
1090 SkASSERT(origBackend.isValid());
1091 }
1092
1093 GrBackendTexture newBackend;
Eric Karl914a36b2017-10-12 12:44:50 -07001094 SkImage::BackendTextureReleaseProc proc;
Robert Phillipsba375a82018-04-11 10:08:06 -04001095 bool result = SkImage::MakeBackendTextureFromSkImage(context, std::move(image),
1096 &newBackend, &proc);
Eric Karl914a36b2017-10-12 12:44:50 -07001097 if (result != testCase.fExpectation) {
1098 static const char *const kFS[] = { "fail", "succeed" };
1099 ERRORF(reporter, "This image was expected to %s but did not.",
1100 kFS[testCase.fExpectation]);
1101 }
1102
Robert Phillipsba375a82018-04-11 10:08:06 -04001103 if (result) {
1104 SkASSERT(newBackend.isValid());
1105 }
1106
1107 bool tookDirectly = result && GrBackendTexture::TestingOnly_Equals(origBackend, newBackend);
Eric Karl914a36b2017-10-12 12:44:50 -07001108 if (testCase.fCanTakeDirectly != tookDirectly) {
1109 static const char *const kExpectedState[] = { "not expected", "expected" };
1110 ERRORF(reporter, "This backend texture was %s to be taken directly.",
1111 kExpectedState[testCase.fCanTakeDirectly]);
1112 }
1113
Eric Karl914a36b2017-10-12 12:44:50 -07001114 context->flush();
1115 }
1116}
kkinnunen4e184132015-11-17 22:53:28 -08001117#endif
reedeb560282016-07-26 19:42:04 -07001118
1119///////////////////////////////////////////////////////////////////////////////////////////////////
1120
Matt Sarett0bb6f382017-03-06 10:28:24 -05001121static sk_sp<SkImage> create_picture_image(sk_sp<SkColorSpace> space) {
1122 SkPictureRecorder recorder;
1123 SkCanvas* canvas = recorder.beginRecording(10, 10);
1124 canvas->clear(SK_ColorCYAN);
1125 return SkImage::MakeFromPicture(recorder.finishRecordingAsPicture(), SkISize::Make(10, 10),
1126 nullptr, nullptr, SkImage::BitDepth::kU8, std::move(space));
1127};
1128
1129DEF_TEST(Image_ColorSpace, r) {
1130 sk_sp<SkColorSpace> srgb = SkColorSpace::MakeSRGB();
Hal Canaryc465d132017-12-08 10:21:31 -05001131 sk_sp<SkImage> image = GetResourceAsImage("images/mandrill_512_q075.jpg");
Matt Sarett0bb6f382017-03-06 10:28:24 -05001132 REPORTER_ASSERT(r, srgb.get() == image->colorSpace());
1133
Hal Canaryc465d132017-12-08 10:21:31 -05001134 image = GetResourceAsImage("images/webp-color-profile-lossy.webp");
Matt Sarett0bb6f382017-03-06 10:28:24 -05001135 SkColorSpaceTransferFn fn;
1136 bool success = image->colorSpace()->isNumericalTransferFn(&fn);
1137 REPORTER_ASSERT(r, success);
1138 REPORTER_ASSERT(r, color_space_almost_equal(1.8f, fn.fG));
1139
1140 sk_sp<SkColorSpace> rec2020 = SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma,
1141 SkColorSpace::kRec2020_Gamut);
1142 image = create_picture_image(rec2020);
1143 REPORTER_ASSERT(r, SkColorSpace::Equals(rec2020.get(), image->colorSpace()));
1144
1145 SkBitmap bitmap;
1146 SkImageInfo info = SkImageInfo::MakeN32(10, 10, kPremul_SkAlphaType, rec2020);
1147 bitmap.allocPixels(info);
1148 image = SkImage::MakeFromBitmap(bitmap);
1149 REPORTER_ASSERT(r, SkColorSpace::Equals(rec2020.get(), image->colorSpace()));
1150
1151 sk_sp<SkSurface> surface = SkSurface::MakeRaster(
1152 SkImageInfo::MakeN32Premul(SkISize::Make(10, 10)));
1153 image = surface->makeImageSnapshot();
1154 REPORTER_ASSERT(r, nullptr == image->colorSpace());
1155
1156 surface = SkSurface::MakeRaster(info);
1157 image = surface->makeImageSnapshot();
1158 REPORTER_ASSERT(r, SkColorSpace::Equals(rec2020.get(), image->colorSpace()));
1159}
1160
Matt Sarett6de13102017-03-14 14:10:48 -04001161DEF_TEST(Image_makeColorSpace, r) {
1162 sk_sp<SkColorSpace> p3 = SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma,
1163 SkColorSpace::kDCIP3_D65_Gamut);
Matt Sarett5b1dba82017-04-03 11:42:52 -04001164 SkColorSpaceTransferFn fn;
1165 fn.fA = 1.f; fn.fB = 0.f; fn.fC = 0.f; fn.fD = 0.f; fn.fE = 0.f; fn.fF = 0.f; fn.fG = 1.8f;
1166 sk_sp<SkColorSpace> adobeGamut = SkColorSpace::MakeRGB(fn, SkColorSpace::kAdobeRGB_Gamut);
Matt Sarett6de13102017-03-14 14:10:48 -04001167
1168 SkBitmap srgbBitmap;
1169 srgbBitmap.allocPixels(SkImageInfo::MakeS32(1, 1, kOpaque_SkAlphaType));
1170 *srgbBitmap.getAddr32(0, 0) = SkSwizzle_RGBA_to_PMColor(0xFF604020);
1171 srgbBitmap.setImmutable();
1172 sk_sp<SkImage> srgbImage = SkImage::MakeFromBitmap(srgbBitmap);
Matt Sarettcb874232017-04-05 11:41:27 -04001173 sk_sp<SkImage> p3Image = srgbImage->makeColorSpace(p3, SkTransferFunctionBehavior::kIgnore);
Matt Sarett6de13102017-03-14 14:10:48 -04001174 SkBitmap p3Bitmap;
Cary Clark4f5a79c2018-02-07 15:51:00 -05001175 bool success = p3Image->asLegacyBitmap(&p3Bitmap);
Mike Klein55d330c2018-04-23 15:39:21 -04001176
1177 auto almost_equal = [](int a, int b) { return SkTAbs(a - b) <= 2; };
1178
Matt Sarett6de13102017-03-14 14:10:48 -04001179 REPORTER_ASSERT(r, success);
Matt Sarett6de13102017-03-14 14:10:48 -04001180 REPORTER_ASSERT(r, almost_equal(0x28, SkGetPackedR32(*p3Bitmap.getAddr32(0, 0))));
1181 REPORTER_ASSERT(r, almost_equal(0x40, SkGetPackedG32(*p3Bitmap.getAddr32(0, 0))));
1182 REPORTER_ASSERT(r, almost_equal(0x5E, SkGetPackedB32(*p3Bitmap.getAddr32(0, 0))));
1183
Matt Sarettcb874232017-04-05 11:41:27 -04001184 sk_sp<SkImage> adobeImage = srgbImage->makeColorSpace(adobeGamut,
1185 SkTransferFunctionBehavior::kIgnore);
Matt Sarett5b1dba82017-04-03 11:42:52 -04001186 SkBitmap adobeBitmap;
Cary Clark4f5a79c2018-02-07 15:51:00 -05001187 success = adobeImage->asLegacyBitmap(&adobeBitmap);
Matt Sarett5b1dba82017-04-03 11:42:52 -04001188 REPORTER_ASSERT(r, success);
Matt Sarett5b1dba82017-04-03 11:42:52 -04001189 REPORTER_ASSERT(r, almost_equal(0x21, SkGetPackedR32(*adobeBitmap.getAddr32(0, 0))));
1190 REPORTER_ASSERT(r, almost_equal(0x31, SkGetPackedG32(*adobeBitmap.getAddr32(0, 0))));
1191 REPORTER_ASSERT(r, almost_equal(0x4C, SkGetPackedB32(*adobeBitmap.getAddr32(0, 0))));
1192
Hal Canaryc465d132017-12-08 10:21:31 -05001193 srgbImage = GetResourceAsImage("images/1x1.png");
Matt Sarettcb874232017-04-05 11:41:27 -04001194 p3Image = srgbImage->makeColorSpace(p3, SkTransferFunctionBehavior::kIgnore);
Cary Clark4f5a79c2018-02-07 15:51:00 -05001195 success = p3Image->asLegacyBitmap(&p3Bitmap);
Matt Sarett6de13102017-03-14 14:10:48 -04001196 REPORTER_ASSERT(r, success);
Matt Sarett6de13102017-03-14 14:10:48 -04001197 REPORTER_ASSERT(r, almost_equal(0x8B, SkGetPackedR32(*p3Bitmap.getAddr32(0, 0))));
1198 REPORTER_ASSERT(r, almost_equal(0x82, SkGetPackedG32(*p3Bitmap.getAddr32(0, 0))));
1199 REPORTER_ASSERT(r, almost_equal(0x77, SkGetPackedB32(*p3Bitmap.getAddr32(0, 0))));
1200}
1201
Matt Sarett0bb6f382017-03-06 10:28:24 -05001202///////////////////////////////////////////////////////////////////////////////////////////////////
1203
reedeb560282016-07-26 19:42:04 -07001204static void make_all_premul(SkBitmap* bm) {
1205 bm->allocPixels(SkImageInfo::MakeN32(256, 256, kPremul_SkAlphaType));
1206 for (int a = 0; a < 256; ++a) {
1207 for (int r = 0; r < 256; ++r) {
1208 // make all valid premul combinations
1209 int c = SkTMin(a, r);
1210 *bm->getAddr32(a, r) = SkPackARGB32(a, c, c, c);
1211 }
1212 }
1213}
1214
1215static bool equal(const SkBitmap& a, const SkBitmap& b) {
1216 SkASSERT(a.width() == b.width());
1217 SkASSERT(a.height() == b.height());
1218 for (int y = 0; y < a.height(); ++y) {
Mike Reed6f0286f2016-11-28 17:26:27 -05001219 for (int x = 0; x < a.width(); ++x) {
1220 SkPMColor pa = *a.getAddr32(x, y);
1221 SkPMColor pb = *b.getAddr32(x, y);
1222 if (pa != pb) {
1223 return false;
1224 }
reedeb560282016-07-26 19:42:04 -07001225 }
1226 }
1227 return true;
1228}
1229
1230DEF_TEST(image_roundtrip_encode, reporter) {
1231 SkBitmap bm0;
1232 make_all_premul(&bm0);
1233
1234 auto img0 = SkImage::MakeFromBitmap(bm0);
Mike Reed6409f842017-07-11 16:03:13 -04001235 sk_sp<SkData> data = img0->encodeToData(SkEncodedImageFormat::kPNG, 100);
reedeb560282016-07-26 19:42:04 -07001236 auto img1 = SkImage::MakeFromEncoded(data);
mtklein2f3416d2016-08-02 16:02:05 -07001237
reedeb560282016-07-26 19:42:04 -07001238 SkBitmap bm1;
1239 bm1.allocPixels(SkImageInfo::MakeN32(256, 256, kPremul_SkAlphaType));
1240 img1->readPixels(bm1.info(), bm1.getPixels(), bm1.rowBytes(), 0, 0);
mtklein2f3416d2016-08-02 16:02:05 -07001241
reedeb560282016-07-26 19:42:04 -07001242 REPORTER_ASSERT(reporter, equal(bm0, bm1));
1243}
1244
1245DEF_TEST(image_roundtrip_premul, reporter) {
1246 SkBitmap bm0;
1247 make_all_premul(&bm0);
1248
1249 SkBitmap bm1;
1250 bm1.allocPixels(SkImageInfo::MakeN32(256, 256, kUnpremul_SkAlphaType));
1251 bm0.readPixels(bm1.info(), bm1.getPixels(), bm1.rowBytes(), 0, 0);
1252
1253 SkBitmap bm2;
1254 bm2.allocPixels(SkImageInfo::MakeN32(256, 256, kPremul_SkAlphaType));
1255 bm1.readPixels(bm2.info(), bm2.getPixels(), bm2.rowBytes(), 0, 0);
1256
1257 REPORTER_ASSERT(reporter, equal(bm0, bm2));
1258}
Brian Osmanb8a13922017-04-26 15:28:30 -04001259
1260///////////////////////////////////////////////////////////////////////////////////////////////////
1261
1262static void check_scaled_pixels(skiatest::Reporter* reporter, SkPixmap* pmap, uint32_t expected) {
1263 // Verify that all pixels contain the original test color
1264 for (auto y = 0; y < pmap->height(); ++y) {
1265 for (auto x = 0; x < pmap->width(); ++x) {
1266 uint32_t pixel = *pmap->addr32(x, y);
1267 if (pixel != expected) {
1268 ERRORF(reporter, "Expected scaled pixels to be the same. At %d,%d 0x%08x != 0x%08x",
1269 x, y, pixel, expected);
1270 return;
1271 }
1272 }
1273 }
1274}
1275
1276static void test_scale_pixels(skiatest::Reporter* reporter, const SkImage* image,
1277 uint32_t expected) {
1278 SkImageInfo info = SkImageInfo::MakeN32Premul(image->width() * 2, image->height() * 2);
1279
1280 // Make sure to test kDisallow first, so we don't just get a cache hit in that case
1281 for (auto chint : { SkImage::kDisallow_CachingHint, SkImage::kAllow_CachingHint }) {
1282 SkAutoPixmapStorage scaled;
1283 scaled.alloc(info);
1284 if (!image->scalePixels(scaled, kLow_SkFilterQuality, chint)) {
1285 ERRORF(reporter, "Failed to scale image");
1286 continue;
1287 }
1288
1289 check_scaled_pixels(reporter, &scaled, expected);
1290 }
1291}
1292
1293DEF_TEST(ImageScalePixels, reporter) {
1294 const SkPMColor pmRed = SkPackARGB32(0xFF, 0xFF, 0, 0);
1295 const SkColor red = SK_ColorRED;
1296
1297 // Test raster image
1298 SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1);
1299 sk_sp<SkSurface> surface = SkSurface::MakeRaster(info);
1300 surface->getCanvas()->clear(red);
1301 sk_sp<SkImage> rasterImage = surface->makeImageSnapshot();
1302 test_scale_pixels(reporter, rasterImage.get(), pmRed);
1303
1304 // Test encoded image
Mike Reed6409f842017-07-11 16:03:13 -04001305 sk_sp<SkData> data = rasterImage->encodeToData();
Brian Osmanb8a13922017-04-26 15:28:30 -04001306 sk_sp<SkImage> codecImage = SkImage::MakeFromEncoded(data);
1307 test_scale_pixels(reporter, codecImage.get(), pmRed);
1308}
1309
1310#if SK_SUPPORT_GPU
1311DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageScalePixels_Gpu, reporter, ctxInfo) {
1312 const SkPMColor pmRed = SkPackARGB32(0xFF, 0xFF, 0, 0);
1313 const SkColor red = SK_ColorRED;
1314
1315 SkImageInfo info = SkImageInfo::MakeN32Premul(16, 16);
1316 sk_sp<SkSurface> surface = SkSurface::MakeRenderTarget(ctxInfo.grContext(), SkBudgeted::kNo,
1317 info);
1318 surface->getCanvas()->clear(red);
1319 sk_sp<SkImage> gpuImage = surface->makeImageSnapshot();
1320 test_scale_pixels(reporter, gpuImage.get(), pmRed);
1321}
1322#endif
Mike Reedc4e31092018-01-30 11:15:27 -05001323
1324static sk_sp<SkImage> any_image_will_do() {
1325 return GetResourceAsImage("images/mandrill_32.png");
1326}
1327
1328DEF_TEST(Image_nonfinite_dst, reporter) {
1329 auto surf = SkSurface::MakeRasterN32Premul(10, 10);
1330 auto img = any_image_will_do();
1331 SkPaint paint;
1332
1333 for (SkScalar bad : { SK_ScalarInfinity, SK_ScalarNaN}) {
1334 for (int bits = 1; bits <= 15; ++bits) {
1335 SkRect dst = { 0, 0, 10, 10 };
1336 if (bits & 1) dst.fLeft = bad;
1337 if (bits & 2) dst.fTop = bad;
1338 if (bits & 4) dst.fRight = bad;
1339 if (bits & 8) dst.fBottom = bad;
1340
1341 surf->getCanvas()->drawImageRect(img, dst, &paint);
1342
1343 // we should draw nothing
1344 sk_tool_utils::PixelIter iter(surf.get());
1345 while (void* addr = iter.next()) {
1346 REPORTER_ASSERT(reporter, *(SkPMColor*)addr == 0);
1347 }
1348 }
1349 }
1350}
1351