blob: f437906068b75e4f2ecc8f171d856d7d2033c3ad [file] [log] [blame]
epoger@google.comec3ed6a2011-07-28 14:26:00 +00001/*
2 * Copyright 2011 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 */
bsalomon@google.com971d0c82011-08-19 17:22:05 +00007
bungeman@google.comb29c8832011-10-10 13:19:10 +00008#include "gm.h"
bsalomon@google.com971d0c82011-08-19 17:22:05 +00009#include "GrContext.h"
10#include "GrRenderTarget.h"
11
reed@android.comb9b9a182009-07-08 02:54:47 +000012#include "SkColorPriv.h"
reed@google.com8a85d0c2011-06-24 19:12:12 +000013#include "SkData.h"
bsalomon@google.com971d0c82011-08-19 17:22:05 +000014#include "SkDevice.h"
bsalomon@google.com971d0c82011-08-19 17:22:05 +000015#include "SkGpuCanvas.h"
16#include "SkGpuDevice.h"
reed@android.com8015dd82009-06-21 00:49:18 +000017#include "SkGraphics.h"
18#include "SkImageDecoder.h"
19#include "SkImageEncoder.h"
bsalomon@google.com373a6632011-10-19 20:43:20 +000020#include "SkNativeGLContext.h"
21#include "SkMesaGLContext.h"
tomhudson@google.com9875dd12011-04-25 15:49:53 +000022#include "SkPicture.h"
reed@google.com07700442010-12-20 19:46:07 +000023#include "SkStream.h"
24#include "SkRefCnt.h"
25
26#ifdef SK_SUPPORT_PDF
tomhudson@google.com9875dd12011-04-25 15:49:53 +000027 #include "SkPDFDevice.h"
28 #include "SkPDFDocument.h"
reed@google.com07700442010-12-20 19:46:07 +000029#endif
reed@android.com00dae862009-06-10 15:38:48 +000030
bungeman@google.comb29c8832011-10-10 13:19:10 +000031#ifdef SK_SUPPORT_XPS
32 #include "SkXPSDevice.h"
33#endif
34
reed@google.com46cce912011-06-29 12:54:46 +000035#ifdef SK_BUILD_FOR_MAC
36 #include "SkCGUtils.h"
bsalomon@google.com0a09eef2011-06-29 19:42:58 +000037 #define CAN_IMAGE_PDF 1
reed@google.com46cce912011-06-29 12:54:46 +000038#else
bsalomon@google.com0a09eef2011-06-29 19:42:58 +000039 #define CAN_IMAGE_PDF 0
reed@google.com46cce912011-06-29 12:54:46 +000040#endif
41
reed@android.com00dae862009-06-10 15:38:48 +000042using namespace skiagm;
43
reed@android.com00dae862009-06-10 15:38:48 +000044class Iter {
45public:
46 Iter() {
bsalomon@google.com39149582011-06-13 21:55:32 +000047 this->reset();
48 }
49
50 void reset() {
reed@android.comdd0ac282009-06-20 02:38:16 +000051 fReg = GMRegistry::Head();
reed@android.com00dae862009-06-10 15:38:48 +000052 }
reed@google.comd4dfd102011-01-18 21:05:42 +000053
reed@android.comdd0ac282009-06-20 02:38:16 +000054 GM* next() {
reed@android.com00dae862009-06-10 15:38:48 +000055 if (fReg) {
reed@android.comdd0ac282009-06-20 02:38:16 +000056 GMRegistry::Factory fact = fReg->factory();
reed@android.com00dae862009-06-10 15:38:48 +000057 fReg = fReg->next();
reed@android.comdd0ac282009-06-20 02:38:16 +000058 return fact(0);
reed@android.com00dae862009-06-10 15:38:48 +000059 }
60 return NULL;
61 }
reed@google.comd4dfd102011-01-18 21:05:42 +000062
reed@android.com00dae862009-06-10 15:38:48 +000063 static int Count() {
reed@android.comdd0ac282009-06-20 02:38:16 +000064 const GMRegistry* reg = GMRegistry::Head();
reed@android.com00dae862009-06-10 15:38:48 +000065 int count = 0;
66 while (reg) {
67 count += 1;
68 reg = reg->next();
69 }
70 return count;
71 }
reed@google.comd4dfd102011-01-18 21:05:42 +000072
reed@android.com00dae862009-06-10 15:38:48 +000073private:
74 const GMRegistry* fReg;
75};
76
reed@android.com8015dd82009-06-21 00:49:18 +000077static SkString make_name(const char shortName[], const char configName[]) {
78 SkString name(shortName);
79 name.appendf("_%s", configName);
80 return name;
81}
82
tomhudson@google.com9875dd12011-04-25 15:49:53 +000083static SkString make_filename(const char path[],
84 const char pathSuffix[],
85 const SkString& name,
86 const char suffix[]) {
reed@android.com8015dd82009-06-21 00:49:18 +000087 SkString filename(path);
tomhudson@google.com9875dd12011-04-25 15:49:53 +000088 if (filename.endsWith("/")) {
89 filename.remove(filename.size() - 1, 1);
reed@android.com00dae862009-06-10 15:38:48 +000090 }
tomhudson@google.com9875dd12011-04-25 15:49:53 +000091 filename.append(pathSuffix);
92 filename.append("/");
reed@google.com07700442010-12-20 19:46:07 +000093 filename.appendf("%s.%s", name.c_str(), suffix);
reed@android.com8015dd82009-06-21 00:49:18 +000094 return filename;
95}
96
reed@android.comb9b9a182009-07-08 02:54:47 +000097/* since PNG insists on unpremultiplying our alpha, we take no precision chances
98 and force all pixels to be 100% opaque, otherwise on compare we may not get
99 a perfect match.
100 */
101static void force_all_opaque(const SkBitmap& bitmap) {
102 SkAutoLockPixels lock(bitmap);
103 for (int y = 0; y < bitmap.height(); y++) {
104 for (int x = 0; x < bitmap.width(); x++) {
105 *bitmap.getAddr32(x, y) |= (SK_A32_MASK << SK_A32_SHIFT);
106 }
107 }
108}
109
110static bool write_bitmap(const SkString& path, const SkBitmap& bitmap) {
111 SkBitmap copy;
112 bitmap.copyTo(&copy, SkBitmap::kARGB_8888_Config);
113 force_all_opaque(copy);
114 return SkImageEncoder::EncodeFile(path.c_str(), copy,
115 SkImageEncoder::kPNG_Type, 100);
116}
117
reed@google.com3d3f0922010-12-20 21:10:29 +0000118static inline SkPMColor compute_diff_pmcolor(SkPMColor c0, SkPMColor c1) {
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000119 int dr = SkGetPackedR32(c0) - SkGetPackedR32(c1);
120 int dg = SkGetPackedG32(c0) - SkGetPackedG32(c1);
121 int db = SkGetPackedB32(c0) - SkGetPackedB32(c1);
122 return SkPackARGB32(0xFF, SkAbs32(dr), SkAbs32(dg), SkAbs32(db));
reed@google.com3d3f0922010-12-20 21:10:29 +0000123}
124
125static void compute_diff(const SkBitmap& target, const SkBitmap& base,
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000126 SkBitmap* diff) {
127 SkAutoLockPixels alp(*diff);
reed@google.com3d3f0922010-12-20 21:10:29 +0000128
129 const int w = target.width();
130 const int h = target.height();
131 for (int y = 0; y < h; y++) {
132 for (int x = 0; x < w; x++) {
133 SkPMColor c0 = *base.getAddr32(x, y);
134 SkPMColor c1 = *target.getAddr32(x, y);
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000135 SkPMColor d = 0;
136 if (c0 != c1) {
137 d = compute_diff_pmcolor(c0, c1);
138 }
139 *diff->getAddr32(x, y) = d;
140 }
141 }
reed@google.com3d3f0922010-12-20 21:10:29 +0000142}
143
144static bool compare(const SkBitmap& target, const SkBitmap& base,
tomhudson@google.comea325432011-06-09 20:30:03 +0000145 const SkString& name, const char* renderModeDescriptor,
tomhudson@google.com6abfa492011-04-26 14:59:32 +0000146 SkBitmap* diff) {
reed@android.comb9b9a182009-07-08 02:54:47 +0000147 SkBitmap copy;
148 const SkBitmap* bm = &target;
149 if (target.config() != SkBitmap::kARGB_8888_Config) {
150 target.copyTo(&copy, SkBitmap::kARGB_8888_Config);
151 bm = &copy;
152 }
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000153 SkBitmap baseCopy;
154 const SkBitmap* bp = &base;
155 if (base.config() != SkBitmap::kARGB_8888_Config) {
156 base.copyTo(&baseCopy, SkBitmap::kARGB_8888_Config);
157 bp = &baseCopy;
158 }
reed@android.comb9b9a182009-07-08 02:54:47 +0000159
160 force_all_opaque(*bm);
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000161 force_all_opaque(*bp);
reed@android.comb9b9a182009-07-08 02:54:47 +0000162
163 const int w = bm->width();
164 const int h = bm->height();
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000165 if (w != bp->width() || h != bp->height()) {
tomhudson@google.comea325432011-06-09 20:30:03 +0000166 SkDebugf(
167"---- %s dimensions mismatch for %s base [%d %d] current [%d %d]\n",
168 renderModeDescriptor, name.c_str(),
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000169 bp->width(), bp->height(), w, h);
reed@google.com3d3f0922010-12-20 21:10:29 +0000170 return false;
reed@android.comb9b9a182009-07-08 02:54:47 +0000171 }
172
173 SkAutoLockPixels bmLock(*bm);
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000174 SkAutoLockPixels baseLock(*bp);
reed@android.comb9b9a182009-07-08 02:54:47 +0000175
176 for (int y = 0; y < h; y++) {
177 for (int x = 0; x < w; x++) {
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000178 SkPMColor c0 = *bp->getAddr32(x, y);
reed@android.comb9b9a182009-07-08 02:54:47 +0000179 SkPMColor c1 = *bm->getAddr32(x, y);
180 if (c0 != c1) {
tomhudson@google.comea325432011-06-09 20:30:03 +0000181 SkDebugf(
182"----- %s pixel mismatch for %s at [%d %d] base 0x%08X current 0x%08X\n",
183 renderModeDescriptor, name.c_str(), x, y, c0, c1);
reed@google.com3d3f0922010-12-20 21:10:29 +0000184
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000185 if (diff) {
186 diff->setConfig(SkBitmap::kARGB_8888_Config, w, h);
187 diff->allocPixels();
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000188 compute_diff(*bm, *bp, diff);
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000189 }
reed@google.com3d3f0922010-12-20 21:10:29 +0000190 return false;
reed@android.comb9b9a182009-07-08 02:54:47 +0000191 }
192 }
193 }
reed@google.com3d3f0922010-12-20 21:10:29 +0000194
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000195 // they're equal
196 return true;
reed@android.com8015dd82009-06-21 00:49:18 +0000197}
reed@android.com00dae862009-06-10 15:38:48 +0000198
bungeman@google.comb29c8832011-10-10 13:19:10 +0000199static bool write_document(const SkString& path,
200 const SkDynamicMemoryWStream& document) {
vandebo@chromium.org686abdf2011-02-03 23:00:40 +0000201 SkFILEWStream stream(path.c_str());
bungeman@google.comb29c8832011-10-10 13:19:10 +0000202 SkAutoDataUnref data(document.copyToData());
reed@google.com8a85d0c2011-06-24 19:12:12 +0000203 return stream.writeData(data.get());
reed@google.com07700442010-12-20 19:46:07 +0000204}
205
vandebo@chromium.org686abdf2011-02-03 23:00:40 +0000206enum Backend {
207 kRaster_Backend,
208 kGPU_Backend,
209 kPDF_Backend,
bungeman@google.comb29c8832011-10-10 13:19:10 +0000210 kXPS_Backend,
vandebo@chromium.org686abdf2011-02-03 23:00:40 +0000211};
212
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000213struct ConfigData {
214 SkBitmap::Config fConfig;
vandebo@chromium.org686abdf2011-02-03 23:00:40 +0000215 Backend fBackend;
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000216 const char* fName;
217};
218
219/// Returns true if processing should continue, false to skip the
220/// remainder of this config for this GM.
221//@todo thudson 22 April 2011 - could refactor this to take in
222// a factory to generate the context, always call readPixels()
223// (logically a noop for rasters, if wasted time), and thus collapse the
224// GPU special case and also let this be used for SkPicture testing.
225static void setup_bitmap(const ConfigData& gRec, SkISize& size,
226 SkBitmap* bitmap) {
227 bitmap->setConfig(gRec.fConfig, size.width(), size.height());
228 bitmap->allocPixels();
229 bitmap->eraseColor(0);
230}
231
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000232// Returns true if the test should continue, false if the test should
233// halt.
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000234static bool generate_image(GM* gm, const ConfigData& gRec,
235 GrContext* context,
bsalomon@google.com971d0c82011-08-19 17:22:05 +0000236 GrRenderTarget* rt,
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000237 SkBitmap* bitmap) {
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000238 SkISize size (gm->getISize());
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000239 setup_bitmap(gRec, size, bitmap);
240 SkCanvas canvas(*bitmap);
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000241
242 if (gRec.fBackend == kRaster_Backend) {
243 gm->draw(&canvas);
244 } else { // GPU
245 if (NULL == context) {
246 return false;
247 }
reed@google.comaf951c92011-06-16 19:10:39 +0000248 SkGpuCanvas gc(context, rt);
249 gc.setDevice(new SkGpuDevice(context, rt))->unref();
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000250 gm->draw(&gc);
reed@google.comaf951c92011-06-16 19:10:39 +0000251 // the device is as large as the current rendertarget, so we explicitly
252 // only readback the amount we expect (in size)
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000253 // overwrite our previous allocation
bsalomon@google.comc6980972011-11-02 19:57:21 +0000254 bitmap->setConfig(SkBitmap::kARGB_8888_Config, size.fWidth,
255 size.fHeight);
256 gc.readPixels(bitmap, 0, 0);
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000257 }
258 return true;
259}
260
261static void generate_image_from_picture(GM* gm, const ConfigData& gRec,
262 SkPicture* pict, SkBitmap* bitmap) {
263 SkISize size = gm->getISize();
264 setup_bitmap(gRec, size, bitmap);
265 SkCanvas canvas(*bitmap);
266 canvas.drawPicture(*pict);
267}
268
269static void generate_pdf(GM* gm, SkDynamicMemoryWStream& pdf) {
270#ifdef SK_SUPPORT_PDF
271 SkISize size = gm->getISize();
272 SkMatrix identity;
273 identity.reset();
ctguil@chromium.org15261292011-04-29 17:54:16 +0000274 SkPDFDevice* dev = new SkPDFDevice(size, size, identity);
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000275 SkAutoUnref aur(dev);
276
277 SkCanvas c(dev);
278 gm->draw(&c);
279
280 SkPDFDocument doc;
281 doc.appendPage(dev);
282 doc.emitPDF(&pdf);
283#endif
284}
285
bungeman@google.comb29c8832011-10-10 13:19:10 +0000286static void generate_xps(GM* gm, SkDynamicMemoryWStream& xps) {
287#ifdef SK_SUPPORT_XPS
288 SkISize size = gm->getISize();
289
290 SkSize trimSize = SkSize::Make(SkIntToScalar(size.width()),
291 SkIntToScalar(size.height()));
292 static const double inchesPerMeter = 10000.0 / 254.0;
293 static const double upm = 72 * inchesPerMeter;
294 SkVector unitsPerMeter = SkPoint::Make(SkDoubleToScalar(upm),
295 SkDoubleToScalar(upm));
296 static const double ppm = 200 * inchesPerMeter;
297 SkVector pixelsPerMeter = SkPoint::Make(SkDoubleToScalar(ppm),
298 SkDoubleToScalar(ppm));
299
300 SkXPSDevice* dev = new SkXPSDevice();
301 SkAutoUnref aur(dev);
302
303 SkCanvas c(dev);
304 dev->beginPortfolio(&xps);
305 dev->beginSheet(unitsPerMeter, pixelsPerMeter, trimSize);
306 gm->draw(&c);
307 dev->endSheet();
308 dev->endPortfolio();
309
310#endif
311}
312
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000313static bool write_reference_image(const ConfigData& gRec,
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000314 const char writePath [],
tomhudson@google.comea325432011-06-09 20:30:03 +0000315 const char renderModeDescriptor [],
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000316 const SkString& name,
317 SkBitmap& bitmap,
bungeman@google.comb29c8832011-10-10 13:19:10 +0000318 SkDynamicMemoryWStream* document) {
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000319 SkString path;
320 bool success = false;
bungeman@google.comb29c8832011-10-10 13:19:10 +0000321 if (gRec.fBackend == kRaster_Backend ||
322 gRec.fBackend == kGPU_Backend ||
323 (gRec.fBackend == kPDF_Backend && CAN_IMAGE_PDF)) {
324
tomhudson@google.comea325432011-06-09 20:30:03 +0000325 path = make_filename(writePath, renderModeDescriptor, name, "png");
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000326 success = write_bitmap(path, bitmap);
reed@google.com46cce912011-06-29 12:54:46 +0000327 }
328 if (kPDF_Backend == gRec.fBackend) {
tomhudson@google.comea325432011-06-09 20:30:03 +0000329 path = make_filename(writePath, renderModeDescriptor, name, "pdf");
bungeman@google.comb29c8832011-10-10 13:19:10 +0000330 success = write_document(path, *document);
331 }
332 if (kXPS_Backend == gRec.fBackend) {
333 path = make_filename(writePath, renderModeDescriptor, name, "xps");
334 success = write_document(path, *document);
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000335 }
336 if (!success) {
337 fprintf(stderr, "FAILED to write %s\n", path.c_str());
338 }
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000339 return success;
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000340}
341
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000342static bool compare_to_reference_image(const SkString& name,
343 SkBitmap &bitmap,
344 const SkBitmap& comparisonBitmap,
345 const char diffPath [],
346 const char renderModeDescriptor []) {
347 bool success;
348 SkBitmap diffBitmap;
349 success = compare(bitmap, comparisonBitmap, name, renderModeDescriptor,
350 diffPath ? &diffBitmap : NULL);
351 if (!success && diffPath) {
352 SkString diffName = make_filename(diffPath, "", name, ".diff.png");
353 write_bitmap(diffName, diffBitmap);
354 }
355 return success;
356}
357
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000358static bool compare_to_reference_image(const char readPath [],
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000359 const SkString& name,
360 SkBitmap &bitmap,
tomhudson@google.com6abfa492011-04-26 14:59:32 +0000361 const char diffPath [],
tomhudson@google.comea325432011-06-09 20:30:03 +0000362 const char renderModeDescriptor []) {
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000363 SkString path = make_filename(readPath, "", name, "png");
364 SkBitmap orig;
365 bool success = SkImageDecoder::DecodeFile(path.c_str(), &orig,
366 SkBitmap::kARGB_8888_Config,
367 SkImageDecoder::kDecodePixels_Mode, NULL);
368 if (success) {
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000369 success = compare_to_reference_image(name, bitmap,
370 orig, diffPath,
371 renderModeDescriptor);
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000372 } else {
373 fprintf(stderr, "FAILED to read %s\n", path.c_str());
reed@google.comac864a92011-06-27 18:11:17 +0000374 // we lie here, and report succes, since we're just missing a master
375 // image. This way we can check in new tests, and not report failure.
376 // A real failure is to draw *differently* from the master image, but
377 // that's not the case here.
378 success = true;
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000379 }
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000380 return success;
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000381}
382
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000383static bool handle_test_results(GM* gm,
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000384 const ConfigData& gRec,
385 const char writePath [],
386 const char readPath [],
387 const char diffPath [],
tomhudson@google.comea325432011-06-09 20:30:03 +0000388 const char renderModeDescriptor [],
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000389 SkBitmap& bitmap,
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000390 SkDynamicMemoryWStream* pdf,
391 const SkBitmap* comparisonBitmap) {
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000392 SkString name = make_name(gm->shortName(), gRec.fName);
393
394 if (writePath) {
tomhudson@google.comea325432011-06-09 20:30:03 +0000395 write_reference_image(gRec, writePath, renderModeDescriptor,
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000396 name, bitmap, pdf);
bungeman@google.comb29c8832011-10-10 13:19:10 +0000397 } else if (readPath && (
398 gRec.fBackend == kRaster_Backend ||
399 gRec.fBackend == kGPU_Backend ||
400 (gRec.fBackend == kPDF_Backend && CAN_IMAGE_PDF))) {
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000401 return compare_to_reference_image(readPath, name, bitmap,
tomhudson@google.comea325432011-06-09 20:30:03 +0000402 diffPath, renderModeDescriptor);
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000403 } else if (comparisonBitmap) {
404 return compare_to_reference_image(name, bitmap,
405 *comparisonBitmap, diffPath,
406 renderModeDescriptor);
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000407 }
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000408 return true;
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000409}
410
411static SkPicture* generate_new_picture(GM* gm) {
412 // Pictures are refcounted so must be on heap
413 SkPicture* pict = new SkPicture;
414 SkCanvas* cv = pict->beginRecording(1000, 1000);
415 gm->draw(cv);
416 pict->endRecording();
417
418 return pict;
419}
420
421static SkPicture* stream_to_new_picture(const SkPicture& src) {
422
423 // To do in-memory commiunications with a stream, we need to:
424 // * create a dynamic memory stream
425 // * copy it into a buffer
426 // * create a read stream from it
427 // ?!?!
428
429 SkDynamicMemoryWStream storage;
430 src.serialize(&storage);
431
432 int streamSize = storage.getOffset();
433 SkAutoMalloc dstStorage(streamSize);
434 void* dst = dstStorage.get();
435 //char* dst = new char [streamSize];
436 //@todo thudson 22 April 2011 when can we safely delete [] dst?
437 storage.copyTo(dst);
438 SkMemoryStream pictReadback(dst, streamSize);
439 SkPicture* retval = new SkPicture (&pictReadback);
440 return retval;
441}
442
443// Test: draw into a bitmap or pdf.
444// Depending on flags, possibly compare to an expected image
445// and possibly output a diff image if it fails to match.
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000446static bool test_drawing(GM* gm,
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000447 const ConfigData& gRec,
448 const char writePath [],
449 const char readPath [],
450 const char diffPath [],
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000451 GrContext* context,
bsalomon@google.com971d0c82011-08-19 17:22:05 +0000452 GrRenderTarget* rt,
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000453 SkBitmap* bitmap) {
bungeman@google.comb29c8832011-10-10 13:19:10 +0000454 SkDynamicMemoryWStream document;
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000455
456 if (gRec.fBackend == kRaster_Backend ||
bsalomon@google.com971d0c82011-08-19 17:22:05 +0000457 gRec.fBackend == kGPU_Backend) {
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000458 // Early exit if we can't generate the image, but this is
459 // expected in some cases, so don't report a test failure.
bsalomon@google.com971d0c82011-08-19 17:22:05 +0000460 if (!generate_image(gm, gRec, context, rt, bitmap)) {
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000461 return true;
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000462 }
reed@google.com46cce912011-06-29 12:54:46 +0000463 } else if (gRec.fBackend == kPDF_Backend) {
bungeman@google.comb29c8832011-10-10 13:19:10 +0000464 generate_pdf(gm, document);
reed@google.com46cce912011-06-29 12:54:46 +0000465#if CAN_IMAGE_PDF
bungeman@google.com0f1541f2011-10-10 13:47:06 +0000466 SkAutoDataUnref data(document.copyToData());
reed@google.com46cce912011-06-29 12:54:46 +0000467 SkMemoryStream stream(data.data(), data.size());
468 SkPDFDocumentToBitmap(&stream, bitmap);
469#endif
bungeman@google.comb29c8832011-10-10 13:19:10 +0000470 } else if (gRec.fBackend == kXPS_Backend) {
471 generate_xps(gm, document);
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000472 }
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000473 return handle_test_results(gm, gRec, writePath, readPath, diffPath,
bungeman@google.comb29c8832011-10-10 13:19:10 +0000474 "", *bitmap, &document, NULL);
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000475}
476
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000477static bool test_picture_playback(GM* gm,
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000478 const ConfigData& gRec,
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000479 const SkBitmap& comparisonBitmap,
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000480 const char readPath [],
481 const char diffPath []) {
482 SkPicture* pict = generate_new_picture(gm);
483 SkAutoUnref aur(pict);
484
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000485 if (kRaster_Backend == gRec.fBackend) {
486 SkBitmap bitmap;
487 generate_image_from_picture(gm, gRec, pict, &bitmap);
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000488 return handle_test_results(gm, gRec, NULL, NULL, diffPath,
489 "-replay", bitmap, NULL, &comparisonBitmap);
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000490 }
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000491 return true;
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000492}
493
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000494static bool test_picture_serialization(GM* gm,
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000495 const ConfigData& gRec,
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000496 const SkBitmap& comparisonBitmap,
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000497 const char readPath [],
498 const char diffPath []) {
499 SkPicture* pict = generate_new_picture(gm);
500 SkAutoUnref aurp(pict);
501 SkPicture* repict = stream_to_new_picture(*pict);
502 SkAutoUnref aurr(repict);
503
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000504 if (kRaster_Backend == gRec.fBackend) {
505 SkBitmap bitmap;
506 generate_image_from_picture(gm, gRec, repict, &bitmap);
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000507 return handle_test_results(gm, gRec, NULL, NULL, diffPath,
508 "-serialize", bitmap, NULL, &comparisonBitmap);
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000509 }
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000510 return true;
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000511}
512
513static void usage(const char * argv0) {
514 SkDebugf("%s [-w writePath] [-r readPath] [-d diffPath]\n", argv0);
tomhudson@google.com73fb0422011-04-25 19:20:54 +0000515 SkDebugf(" [--replay] [--serialize]\n");
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000516 SkDebugf(" writePath: directory to write rendered images in.\n");
tomhudson@google.com73fb0422011-04-25 19:20:54 +0000517 SkDebugf(
518" readPath: directory to read reference images from;\n"
519" reports if any pixels mismatch between reference and new images\n");
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000520 SkDebugf(" diffPath: directory to write difference images in.\n");
tomhudson@google.com73fb0422011-04-25 19:20:54 +0000521 SkDebugf(" --replay: exercise SkPicture replay.\n");
522 SkDebugf(
523" --serialize: exercise SkPicture serialization & deserialization.\n");
reed@google.come6a5c4d2011-07-25 14:30:54 +0000524 SkDebugf(" --match foo will only run tests that substring match foo.\n");
bsalomon@google.com373a6632011-10-19 20:43:20 +0000525#if SK_MESA
526 SkDebugf(" --mesagl will run using the osmesa sw gl rasterizer.\n");
527#endif
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000528}
529
530static const ConfigData gRec[] = {
vandebo@chromium.org686abdf2011-02-03 23:00:40 +0000531 { SkBitmap::kARGB_8888_Config, kRaster_Backend, "8888" },
532 { SkBitmap::kARGB_4444_Config, kRaster_Backend, "4444" },
533 { SkBitmap::kRGB_565_Config, kRaster_Backend, "565" },
reed@google.com1a7e9462011-06-20 13:21:24 +0000534#ifdef SK_SCALAR_IS_FLOAT
vandebo@chromium.org686abdf2011-02-03 23:00:40 +0000535 { SkBitmap::kARGB_8888_Config, kGPU_Backend, "gpu" },
reed@google.com1a7e9462011-06-20 13:21:24 +0000536#endif
vandebo@chromium.org686abdf2011-02-03 23:00:40 +0000537#ifdef SK_SUPPORT_PDF
538 { SkBitmap::kARGB_8888_Config, kPDF_Backend, "pdf" },
539#endif
bungeman@google.comb29c8832011-10-10 13:19:10 +0000540#ifdef SK_SUPPORT_XPS
541 { SkBitmap::kARGB_8888_Config, kXPS_Backend, "xps" },
542#endif
reed@android.com00dae862009-06-10 15:38:48 +0000543};
544
reed@google.comb2a51622011-10-31 16:30:04 +0000545static bool skip_name(const SkTDArray<const char*> array, const char name[]) {
546 if (0 == array.count()) {
547 // no names, so don't skip anything
548 return false;
549 }
550 for (int i = 0; i < array.count(); ++i) {
551 if (strstr(name, array[i])) {
552 // found the name, so don't skip
553 return false;
554 }
555 }
556 return true;
557}
558
bsalomon@google.comd9f826c2011-07-18 15:25:04 +0000559namespace skiagm {
560static GrContext* gGrContext;
561GrContext* GetGr() {
562 return gGrContext;
563}
564}
565
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000566int main(int argc, char * const argv[]) {
reed@android.com00dae862009-06-10 15:38:48 +0000567 SkAutoGraphics ag;
reed@google.comd4dfd102011-01-18 21:05:42 +0000568
reed@android.com8015dd82009-06-21 00:49:18 +0000569 const char* writePath = NULL; // if non-null, where we write the originals
570 const char* readPath = NULL; // if non-null, were we read from to compare
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000571 const char* diffPath = NULL; // if non-null, where we write our diffs (from compare)
reed@android.com8015dd82009-06-21 00:49:18 +0000572
reed@google.comb2a51622011-10-31 16:30:04 +0000573 SkTDArray<const char*> fMatches;
574
reed@google.comab973972011-09-19 19:01:38 +0000575 bool doPDF = true;
reed@google.comb8b09832011-05-26 15:57:56 +0000576 bool doReplay = true;
tomhudson@google.com6abfa492011-04-26 14:59:32 +0000577 bool doSerialize = false;
bsalomon@google.com373a6632011-10-19 20:43:20 +0000578 bool useMesa = false;
579
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000580 const char* const commandName = argv[0];
reed@android.com8015dd82009-06-21 00:49:18 +0000581 char* const* stop = argv + argc;
582 for (++argv; argv < stop; ++argv) {
583 if (strcmp(*argv, "-w") == 0) {
584 argv++;
585 if (argv < stop && **argv) {
586 writePath = *argv;
587 }
588 } else if (strcmp(*argv, "-r") == 0) {
589 argv++;
590 if (argv < stop && **argv) {
591 readPath = *argv;
592 }
reed@google.com3d3f0922010-12-20 21:10:29 +0000593 } else if (strcmp(*argv, "-d") == 0) {
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000594 argv++;
reed@google.com3d3f0922010-12-20 21:10:29 +0000595 if (argv < stop && **argv) {
596 diffPath = *argv;
597 }
reed@google.comb8b09832011-05-26 15:57:56 +0000598 } else if (strcmp(*argv, "--noreplay") == 0) {
599 doReplay = false;
reed@google.comab973972011-09-19 19:01:38 +0000600 } else if (strcmp(*argv, "--nopdf") == 0) {
601 doPDF = false;
tomhudson@google.com73fb0422011-04-25 19:20:54 +0000602 } else if (strcmp(*argv, "--serialize") == 0) {
603 doSerialize = true;
reed@google.comece2b022011-07-25 14:28:57 +0000604 } else if (strcmp(*argv, "--match") == 0) {
605 ++argv;
606 if (argv < stop && **argv) {
reed@google.comb2a51622011-10-31 16:30:04 +0000607 // just record the ptr, no need for a deep copy
608 *fMatches.append() = *argv;
reed@google.comece2b022011-07-25 14:28:57 +0000609 }
bsalomon@google.com373a6632011-10-19 20:43:20 +0000610#if SK_MESA
611 } else if (strcmp(*argv, "--mesagl") == 0) {
612 useMesa = true;
613#endif
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000614 } else {
615 usage(commandName);
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000616 return -1;
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000617 }
618 }
619 if (argv != stop) {
620 usage(commandName);
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000621 return -1;
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000622 }
reed@google.com873cb1e2010-12-23 15:00:45 +0000623
bsalomon@google.com39149582011-06-13 21:55:32 +0000624 int maxW = -1;
625 int maxH = -1;
626 Iter iter;
627 GM* gm;
628 while ((gm = iter.next()) != NULL) {
629 SkISize size = gm->getISize();
630 maxW = SkMax32(size.width(), maxW);
631 maxH = SkMax32(size.height(), maxH);
632 }
reed@google.com873cb1e2010-12-23 15:00:45 +0000633 // setup a GL context for drawing offscreen
bsalomon@google.com373a6632011-10-19 20:43:20 +0000634 SkAutoTUnref<SkGLContext> glContext;
635#if SK_MESA
636 if (useMesa) {
637 glContext.reset(new SkMesaGLContext());
638 } else
639#endif
640 {
641 glContext.reset(new SkNativeGLContext());
642 }
643
bsalomon@google.com971d0c82011-08-19 17:22:05 +0000644 GrRenderTarget* rt = NULL;
bsalomon@google.com373a6632011-10-19 20:43:20 +0000645 if (glContext.get()->init(maxW, maxH)) {
646 GrPlatform3DContext ctx =
647 reinterpret_cast<GrPlatform3DContext>(glContext.get()->gl());
648 gGrContext = GrContext::Create(kOpenGL_Shaders_GrEngine, ctx);
bsalomon@google.com971d0c82011-08-19 17:22:05 +0000649 if (NULL != gGrContext) {
bsalomon@google.come269f212011-11-07 13:29:52 +0000650 GrPlatformRenderTargetDesc desc;
bsalomon@google.com971d0c82011-08-19 17:22:05 +0000651 desc.fConfig = kRGBA_8888_GrPixelConfig;
652 desc.fWidth = maxW;
653 desc.fHeight = maxH;
654 desc.fStencilBits = 8;
bsalomon@google.come269f212011-11-07 13:29:52 +0000655 desc.fRenderTargetHandle = glContext.get()->getFBOID();
656 rt = gGrContext->createPlatformRenderTarget(desc);
bsalomon@google.com971d0c82011-08-19 17:22:05 +0000657 if (NULL == rt) {
658 gGrContext->unref();
659 gGrContext = NULL;
660 }
661 }
bsalomon@google.com373a6632011-10-19 20:43:20 +0000662 } else {
663 fprintf(stderr, "could not create GL context.\n");
reed@google.com37df17d2010-12-23 20:20:51 +0000664 }
reed@google.com873cb1e2010-12-23 15:00:45 +0000665
reed@android.com00f883e2010-12-14 17:46:14 +0000666 if (readPath) {
667 fprintf(stderr, "reading from %s\n", readPath);
668 } else if (writePath) {
669 fprintf(stderr, "writing to %s\n", writePath);
670 }
671
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000672 // Accumulate success of all tests so we can flag error in any
673 // one with the return value.
bsalomon@google.com39149582011-06-13 21:55:32 +0000674 iter.reset();
tomhudson@google.comea325432011-06-09 20:30:03 +0000675 bool overallSuccess = true;
reed@android.com00dae862009-06-10 15:38:48 +0000676 while ((gm = iter.next()) != NULL) {
reed@google.comece2b022011-07-25 14:28:57 +0000677 const char* shortName = gm->shortName();
reed@google.comb2a51622011-10-31 16:30:04 +0000678 if (skip_name(fMatches, shortName)) {
reed@google.comece2b022011-07-25 14:28:57 +0000679 SkDELETE(gm);
680 continue;
681 }
682
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000683 SkISize size = gm->getISize();
reed@google.comece2b022011-07-25 14:28:57 +0000684 SkDebugf("drawing... %s [%d %d]\n", shortName,
reed@android.com8015dd82009-06-21 00:49:18 +0000685 size.width(), size.height());
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000686 SkBitmap forwardRenderedBitmap;
reed@android.com8015dd82009-06-21 00:49:18 +0000687
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000688 for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); i++) {
reed@google.comfbc21172011-09-19 19:08:33 +0000689 uint32_t gmFlags = gm->getFlags();
690
bungeman@google.com64e011a2011-09-19 19:31:04 +0000691 if ((kPDF_Backend == gRec[i].fBackend) &&
692 (!doPDF || (gmFlags & GM::kSkipPDF_Flag)))
693 {
reed@google.comab973972011-09-19 19:01:38 +0000694 continue;
695 }
696
tomhudson@google.comea325432011-06-09 20:30:03 +0000697 bool testSuccess = test_drawing(gm, gRec[i],
bsalomon@google.comd9f826c2011-07-18 15:25:04 +0000698 writePath, readPath, diffPath, gGrContext,
bsalomon@google.com971d0c82011-08-19 17:22:05 +0000699 rt, &forwardRenderedBitmap);
tomhudson@google.comea325432011-06-09 20:30:03 +0000700 overallSuccess &= testSuccess;
reed@android.com00dae862009-06-10 15:38:48 +0000701
reed@google.comfbc21172011-09-19 19:08:33 +0000702 if (doReplay && testSuccess && !(gmFlags & GM::kSkipPicture_Flag)) {
tomhudson@google.comea325432011-06-09 20:30:03 +0000703 testSuccess = test_picture_playback(gm, gRec[i],
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000704 forwardRenderedBitmap,
tomhudson@google.comea325432011-06-09 20:30:03 +0000705 readPath, diffPath);
706 overallSuccess &= testSuccess;
tomhudson@google.com73fb0422011-04-25 19:20:54 +0000707 }
vandebo@chromium.org686abdf2011-02-03 23:00:40 +0000708
tomhudson@google.comea325432011-06-09 20:30:03 +0000709 if (doSerialize && testSuccess) {
tomhudson@google.comcae6b3f2011-06-17 13:11:45 +0000710 testSuccess &= test_picture_serialization(gm, gRec[i],
711 forwardRenderedBitmap,
712 readPath, diffPath);
713 overallSuccess &= testSuccess;
tomhudson@google.com73fb0422011-04-25 19:20:54 +0000714 }
tomhudson@google.com9875dd12011-04-25 15:49:53 +0000715 }
reed@android.com00dae862009-06-10 15:38:48 +0000716 SkDELETE(gm);
717 }
tomhudson@google.comea325432011-06-09 20:30:03 +0000718 if (false == overallSuccess) {
tomhudson@google.com8e728d72011-04-26 20:22:57 +0000719 return -1;
720 }
reed@android.com00dae862009-06-10 15:38:48 +0000721 return 0;
722}