2 * Copyright 2013 Google Inc.
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
9 #include "SkCachingPixelRef.h"
12 #include "SkDecodingImageGenerator.h"
13 #include "SkDiscardableMemoryPool.h"
14 #include "SkImageDecoder.h"
15 #include "SkScaledImageCache.h"
22 * Fill this bitmap with some color.
24 static void make_test_image(SkBitmap* bm) {
25 static const int W = 50, H = 50;
26 static const SkBitmap::Config config = SkBitmap::kARGB_8888_Config;
27 bm->setConfig(config, W, H);
29 bm->eraseColor(SK_ColorBLACK);
32 paint.setColor(SK_ColorBLUE);
33 canvas.drawRectCoords(0, 0, SkIntToScalar(W/2),
34 SkIntToScalar(H/2), paint);
35 paint.setColor(SK_ColorWHITE);
36 canvas.drawRectCoords(SkIntToScalar(W/2), SkIntToScalar(H/2),
37 SkIntToScalar(W), SkIntToScalar(H), paint);
41 * encode this bitmap into some data via SkImageEncoder
43 static SkData* create_data_from_bitmap(const SkBitmap& bm,
44 SkImageEncoder::Type type) {
45 SkDynamicMemoryWStream stream;
46 if (SkImageEncoder::EncodeStream(&stream, bm, type, 100)) {
47 return stream.copyToData();
52 ////////////////////////////////////////////////////////////////////////////////
54 static void compare_bitmaps(skiatest::Reporter* reporter,
55 const SkBitmap& b1, const SkBitmap& b2,
56 bool pixelPerfect = true) {
57 REPORTER_ASSERT(reporter, b1.empty() == b2.empty());
58 REPORTER_ASSERT(reporter, b1.width() == b2.width());
59 REPORTER_ASSERT(reporter, b1.height() == b2.height());
60 REPORTER_ASSERT(reporter, b1.isNull() == b2.isNull());
61 SkAutoLockPixels autoLockPixels1(b1);
62 SkAutoLockPixels autoLockPixels2(b2);
63 REPORTER_ASSERT(reporter, b1.isNull() == b2.isNull());
64 if (b1.isNull() || b1.empty()) {
67 REPORTER_ASSERT(reporter, NULL != b1.getPixels());
68 REPORTER_ASSERT(reporter, NULL != b2.getPixels());
69 if ((!(b1.getPixels())) || (!(b2.getPixels()))) {
72 if ((b1.width() != b2.width()) ||
73 (b1.height() != b2.height())) {
81 for (int y = 0; y < b2.height(); ++y) {
82 for (int x = 0; x < b2.width(); ++x) {
83 if (b1.getColor(x, y) != b2.getColor(x, y)) {
88 REPORTER_ASSERT(reporter, 0 == pixelErrors);
91 typedef bool (*InstallEncoded)(SkData* encoded, SkBitmap* dst);
94 This function tests three differently encoded images against the
96 static void test_three_encodings(skiatest::Reporter* reporter,
97 InstallEncoded install) {
99 make_test_image(&original);
100 REPORTER_ASSERT(reporter, !original.empty());
101 REPORTER_ASSERT(reporter, !original.isNull());
102 if (original.empty() || original.isNull()) {
105 static const SkImageEncoder::Type types[] = {
106 SkImageEncoder::kPNG_Type,
107 SkImageEncoder::kJPEG_Type,
108 SkImageEncoder::kWEBP_Type
110 for (size_t i = 0; i < SK_ARRAY_COUNT(types); i++) {
111 SkImageEncoder::Type type = types[i];
112 SkAutoDataUnref encoded(create_data_from_bitmap(original, type));
113 REPORTER_ASSERT(reporter, encoded.get() != NULL);
114 if (NULL == encoded.get()) {
118 bool installSuccess = install(encoded.get(), &lazy);
119 REPORTER_ASSERT(reporter, installSuccess);
120 if (!installSuccess) {
123 REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
125 SkAutoLockPixels autoLockPixels(lazy); // now pixels are good.
126 REPORTER_ASSERT(reporter, NULL != lazy.getPixels());
127 if (NULL == lazy.getPixels()) {
131 // pixels should be gone!
132 REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
134 SkAutoLockPixels autoLockPixels(lazy); // now pixels are good.
135 REPORTER_ASSERT(reporter, NULL != lazy.getPixels());
136 if (NULL == lazy.getPixels()) {
140 bool comparePixels = (SkImageEncoder::kPNG_Type == type);
141 compare_bitmaps(reporter, original, lazy, comparePixels);
145 ////////////////////////////////////////////////////////////////////////////////
146 static bool install_skCachingPixelRef(SkData* encoded, SkBitmap* dst) {
147 return SkCachingPixelRef::Install(
148 SkDecodingImageGenerator::Create(
149 encoded, SkDecodingImageGenerator::Options()), dst);
151 static bool install_skDiscardablePixelRef(SkData* encoded, SkBitmap* dst) {
152 // Use system-default discardable memory.
153 return SkInstallDiscardablePixelRef(
154 SkDecodingImageGenerator::Create(
155 encoded, SkDecodingImageGenerator::Options()), dst, NULL);
158 ////////////////////////////////////////////////////////////////////////////////
160 * This checks to see that a SkCachingPixelRef and a
161 * SkDiscardablePixelRef works as advertised with a
162 * SkDecodingImageGenerator.
164 DEF_TEST(DecodingImageGenerator, reporter) {
165 test_three_encodings(reporter, install_skCachingPixelRef);
166 test_three_encodings(reporter, install_skDiscardablePixelRef);
169 class TestImageGenerator : public SkImageGenerator {
172 kFailGetInfo_TestType,
173 kFailGetPixels_TestType,
174 kSucceedGetPixels_TestType,
175 kLast_TestType = kSucceedGetPixels_TestType
177 static int Width() { return 10; }
178 static int Height() { return 10; }
179 static SkColor Color() { return SK_ColorCYAN; }
180 TestImageGenerator(TestType type, skiatest::Reporter* reporter)
181 : fType(type), fReporter(reporter) {
182 SkASSERT((fType <= kLast_TestType) && (fType >= 0));
184 virtual ~TestImageGenerator() { }
185 virtual bool getInfo(SkImageInfo* info) SK_OVERRIDE {
186 REPORTER_ASSERT(fReporter, NULL != info);
187 if ((NULL == info) || (kFailGetInfo_TestType == fType)) {
190 info->fWidth = TestImageGenerator::Width();
191 info->fHeight = TestImageGenerator::Height();
192 info->fColorType = kPMColor_SkColorType;
193 info->fAlphaType = kOpaque_SkAlphaType;
196 virtual bool getPixels(const SkImageInfo& info,
198 size_t rowBytes) SK_OVERRIDE {
199 REPORTER_ASSERT(fReporter, pixels != NULL);
201 = static_cast<size_t>(info.fWidth * info.bytesPerPixel());
202 REPORTER_ASSERT(fReporter, rowBytes >= minRowBytes);
204 || (fType != kSucceedGetPixels_TestType)
205 || (info.fColorType != kPMColor_SkColorType)) {
208 char* bytePtr = static_cast<char*>(pixels);
209 for (int y = 0; y < info.fHeight; ++y) {
210 sk_memset32(reinterpret_cast<SkColor*>(bytePtr),
211 TestImageGenerator::Color(), info.fWidth);
218 const TestType fType;
219 skiatest::Reporter* const fReporter;
222 static void check_test_image_generator_bitmap(skiatest::Reporter* reporter,
223 const SkBitmap& bm) {
224 REPORTER_ASSERT(reporter, TestImageGenerator::Width() == bm.width());
225 REPORTER_ASSERT(reporter, TestImageGenerator::Height() == bm.height());
226 SkAutoLockPixels autoLockPixels(bm);
227 REPORTER_ASSERT(reporter, NULL != bm.getPixels());
228 if (NULL == bm.getPixels()) {
232 for (int y = 0; y < bm.height(); ++y) {
233 for (int x = 0; x < bm.width(); ++x) {
234 if (TestImageGenerator::Color() != *bm.getAddr32(x, y)) {
239 REPORTER_ASSERT(reporter, 0 == errors);
243 kSkCaching_PixelRefType,
244 kSkDiscardable_PixelRefType,
245 kLast_PixelRefType = kSkDiscardable_PixelRefType
248 static void check_pixelref(TestImageGenerator::TestType type,
249 skiatest::Reporter* reporter,
250 PixelRefType pixelRefType,
251 SkDiscardableMemory::Factory* factory) {
252 SkASSERT((pixelRefType >= 0) && (pixelRefType <= kLast_PixelRefType));
253 SkAutoTDelete<SkImageGenerator> gen(SkNEW_ARGS(TestImageGenerator,
255 REPORTER_ASSERT(reporter, gen.get() != NULL);
258 if (kSkCaching_PixelRefType == pixelRefType) {
259 // Ignore factory; use global SkScaledImageCache.
260 success = SkCachingPixelRef::Install(gen.detach(), &lazy);
262 success = SkInstallDiscardablePixelRef(gen.detach(), &lazy, factory);
264 REPORTER_ASSERT(reporter, success
265 == (TestImageGenerator::kFailGetInfo_TestType != type));
266 if (TestImageGenerator::kSucceedGetPixels_TestType == type) {
267 check_test_image_generator_bitmap(reporter, lazy);
268 } else if (TestImageGenerator::kFailGetPixels_TestType == type) {
269 SkAutoLockPixels autoLockPixels(lazy);
270 REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
274 // new/lock/delete is an odd pattern for a pixelref, but it needs to not assert
275 static void test_newlockdelete(skiatest::Reporter* reporter) {
277 SkImageGenerator* ig = new TestImageGenerator(
278 TestImageGenerator::kSucceedGetPixels_TestType, reporter);
279 SkInstallDiscardablePixelRef(ig, &bm, NULL);
280 bm.pixelRef()->lockPixels();
284 * This tests the basic functionality of SkDiscardablePixelRef with a
285 * basic SkImageGenerator implementation and several
286 * SkDiscardableMemory::Factory choices.
288 DEF_TEST(DiscardableAndCachingPixelRef, reporter) {
289 test_newlockdelete(reporter);
291 check_pixelref(TestImageGenerator::kFailGetInfo_TestType,
292 reporter, kSkCaching_PixelRefType, NULL);
293 check_pixelref(TestImageGenerator::kFailGetPixels_TestType,
294 reporter, kSkCaching_PixelRefType, NULL);
295 check_pixelref(TestImageGenerator::kSucceedGetPixels_TestType,
296 reporter, kSkCaching_PixelRefType, NULL);
298 check_pixelref(TestImageGenerator::kFailGetInfo_TestType,
299 reporter, kSkDiscardable_PixelRefType, NULL);
300 check_pixelref(TestImageGenerator::kFailGetPixels_TestType,
301 reporter, kSkDiscardable_PixelRefType, NULL);
302 check_pixelref(TestImageGenerator::kSucceedGetPixels_TestType,
303 reporter, kSkDiscardable_PixelRefType, NULL);
305 SkAutoTUnref<SkDiscardableMemoryPool> pool(
306 SkDiscardableMemoryPool::Create(1, NULL));
307 REPORTER_ASSERT(reporter, 0 == pool->getRAMUsed());
308 check_pixelref(TestImageGenerator::kFailGetPixels_TestType,
309 reporter, kSkDiscardable_PixelRefType, pool);
310 REPORTER_ASSERT(reporter, 0 == pool->getRAMUsed());
311 check_pixelref(TestImageGenerator::kSucceedGetPixels_TestType,
312 reporter, kSkDiscardable_PixelRefType, pool);
313 REPORTER_ASSERT(reporter, 0 == pool->getRAMUsed());
315 SkDiscardableMemoryPool* globalPool = SkGetGlobalDiscardableMemoryPool();
316 // Only acts differently from NULL on a platform that has a
317 // default discardable memory implementation that differs from the
319 check_pixelref(TestImageGenerator::kFailGetPixels_TestType,
320 reporter, kSkDiscardable_PixelRefType, globalPool);
321 check_pixelref(TestImageGenerator::kSucceedGetPixels_TestType,
322 reporter, kSkDiscardable_PixelRefType, globalPool);