blob: caf6f52fe24899bd45c24f2ae966306a13fa8027 [file] [log] [blame]
scroggo478652e2015-03-25 07:11:02 -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
mtklein748ca3b2015-01-15 10:56:12 -08008#include "DMSrcSink.h"
msarett9876ac52016-06-01 14:47:18 -07009#include "Resources.h"
msarett3d9d7a72015-10-21 10:27:10 -070010#include "SkAndroidCodec.h"
scroggof24f2242015-03-03 08:59:20 -080011#include "SkCodec.h"
msarettb714fb02016-01-22 14:46:42 -080012#include "SkCodecImageGenerator.h"
msarett888dc162016-05-23 10:21:17 -070013#include "SkColorSpace.h"
14#include "SkColorSpace_Base.h"
msarett9876ac52016-06-01 14:47:18 -070015#include "SkColorSpaceXform.h"
mtkleina16e69e2015-05-05 11:38:45 -070016#include "SkCommonFlags.h"
mtkleinb3e5e4d2015-03-25 13:13:43 -070017#include "SkData.h"
reedbabc3de2016-07-08 08:43:27 -070018#include "SkDeferredCanvas.h"
mtklein748ca3b2015-01-15 10:56:12 -080019#include "SkDocument.h"
joshualitt5f5a8d72015-02-25 14:09:45 -080020#include "SkError.h"
mtkleinb3e5e4d2015-03-25 13:13:43 -070021#include "SkImageGenerator.h"
msarett18976312016-03-09 14:20:58 -080022#include "SkImageGeneratorCG.h"
msarettfc0b6d12016-03-17 13:50:17 -070023#include "SkImageGeneratorWIC.h"
mtklein8bbbb692016-08-15 12:56:00 -070024#include "SkLiteDL.h"
25#include "SkLiteRecorder.h"
mtkleinc8be09a2016-01-04 18:56:57 -080026#include "SkMallocPixelRef.h"
mtklein748ca3b2015-01-15 10:56:12 -080027#include "SkMultiPictureDraw.h"
mtkleinad66f9b2015-02-13 15:11:10 -080028#include "SkNullCanvas.h"
mtklein748ca3b2015-01-15 10:56:12 -080029#include "SkOSFile.h"
msarett9e9444c2016-02-03 12:39:10 -080030#include "SkOpts.h"
mtkleinffa901a2015-03-16 10:38:07 -070031#include "SkPictureData.h"
mtklein748ca3b2015-01-15 10:56:12 -080032#include "SkPictureRecorder.h"
33#include "SkRandom.h"
mtkleind31c13d2015-05-05 12:59:56 -070034#include "SkRecordDraw.h"
35#include "SkRecorder.h"
fmalita2aafe6f2015-02-06 12:51:10 -080036#include "SkSVGCanvas.h"
scroggoa1193e42015-01-21 12:09:53 -080037#include "SkStream.h"
mtklein449d9b72015-09-28 10:33:02 -070038#include "SkTLogic.h"
msarette6dd0042015-10-09 11:07:34 -070039#include "SkSwizzler.h"
mtklein64593522015-11-12 10:41:05 -080040#include <functional>
mtklein748ca3b2015-01-15 10:56:12 -080041
msarettfc0b6d12016-03-17 13:50:17 -070042#if defined(SK_BUILD_FOR_WIN)
43 #include "SkAutoCoInitialize.h"
44#endif
45
msarett469f1c52016-06-06 08:20:37 -070046#if defined(SK_TEST_QCMS)
msarett9876ac52016-06-01 14:47:18 -070047 #include "qcms.h"
48#endif
49
fmalita718df0a2016-07-15 10:33:29 -070050#if defined(SK_XML)
fmalitaa48f0e32016-08-04 06:26:05 -070051 #include "SkSVGDOM.h"
fmalita718df0a2016-07-15 10:33:29 -070052 #include "SkXMLWriter.h"
53#endif
54
halcanary7e798182015-04-14 14:06:18 -070055DEFINE_bool(multiPage, false, "For document-type backends, render the source"
56 " into multiple pages");
scroggo3ac66e92016-02-08 15:09:48 -080057DEFINE_bool(RAW_threading, true, "Allow RAW decodes to run on multiple threads?");
halcanary7e798182015-04-14 14:06:18 -070058
bsalomon3724e572016-03-30 18:56:19 -070059using sk_gpu_test::GrContextFactory;
60
mtklein748ca3b2015-01-15 10:56:12 -080061namespace DM {
62
mtklein748ca3b2015-01-15 10:56:12 -080063GMSrc::GMSrc(skiagm::GMRegistry::Factory factory) : fFactory(factory) {}
64
65Error GMSrc::draw(SkCanvas* canvas) const {
halcanary96fcdcc2015-08-27 07:41:13 -070066 SkAutoTDelete<skiagm::GM> gm(fFactory(nullptr));
mtklein748ca3b2015-01-15 10:56:12 -080067 canvas->concat(gm->getInitialTransform());
68 gm->draw(canvas);
69 return "";
70}
71
72SkISize GMSrc::size() const {
halcanary96fcdcc2015-08-27 07:41:13 -070073 SkAutoTDelete<skiagm::GM> gm(fFactory(nullptr));
mtklein748ca3b2015-01-15 10:56:12 -080074 return gm->getISize();
75}
76
77Name GMSrc::name() const {
halcanary96fcdcc2015-08-27 07:41:13 -070078 SkAutoTDelete<skiagm::GM> gm(fFactory(nullptr));
mtklein748ca3b2015-01-15 10:56:12 -080079 return gm->getName();
80}
81
bsalomon4ee6bd82015-05-27 13:23:23 -070082void GMSrc::modifyGrContextOptions(GrContextOptions* options) const {
halcanary96fcdcc2015-08-27 07:41:13 -070083 SkAutoTDelete<skiagm::GM> gm(fFactory(nullptr));
bsalomon4ee6bd82015-05-27 13:23:23 -070084 gm->modifyGrContextOptions(options);
85}
86
mtklein748ca3b2015-01-15 10:56:12 -080087/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
88
msarettd1227a72016-05-18 06:23:57 -070089BRDSrc::BRDSrc(Path path, Mode mode, CodecSrc::DstColorType dstColorType, uint32_t sampleSize)
msaretta5783ae2015-09-08 15:35:32 -070090 : fPath(path)
msaretta5783ae2015-09-08 15:35:32 -070091 , fMode(mode)
92 , fDstColorType(dstColorType)
93 , fSampleSize(sampleSize)
94{}
95
96bool BRDSrc::veto(SinkFlags flags) const {
97 // No need to test to non-raster or indirect backends.
98 return flags.type != SinkFlags::kRaster
99 || flags.approach != SinkFlags::kDirect;
100}
101
msarettd1227a72016-05-18 06:23:57 -0700102static SkBitmapRegionDecoder* create_brd(Path path) {
bungeman38d909e2016-08-02 14:40:46 -0700103 sk_sp<SkData> encoded(SkData::MakeFromFileName(path.c_str()));
msaretta5783ae2015-09-08 15:35:32 -0700104 if (!encoded) {
105 return NULL;
106 }
bungeman38d909e2016-08-02 14:40:46 -0700107 return SkBitmapRegionDecoder::Create(encoded.get(),
108 SkBitmapRegionDecoder::kAndroidCodec_Strategy);
msaretta5783ae2015-09-08 15:35:32 -0700109}
110
111Error BRDSrc::draw(SkCanvas* canvas) const {
112 SkColorType colorType = canvas->imageInfo().colorType();
113 if (kRGB_565_SkColorType == colorType &&
114 CodecSrc::kGetFromCanvas_DstColorType != fDstColorType) {
115 return Error::Nonfatal("Testing non-565 to 565 is uninteresting.");
116 }
117 switch (fDstColorType) {
118 case CodecSrc::kGetFromCanvas_DstColorType:
119 break;
120 case CodecSrc::kIndex8_Always_DstColorType:
121 colorType = kIndex_8_SkColorType;
122 break;
123 case CodecSrc::kGrayscale_Always_DstColorType:
124 colorType = kGray_8_SkColorType;
125 break;
msarett34e0ec42016-04-22 16:27:24 -0700126 default:
127 SkASSERT(false);
128 break;
msaretta5783ae2015-09-08 15:35:32 -0700129 }
130
msarettd1227a72016-05-18 06:23:57 -0700131 SkAutoTDelete<SkBitmapRegionDecoder> brd(create_brd(fPath));
msaretta5783ae2015-09-08 15:35:32 -0700132 if (nullptr == brd.get()) {
133 return Error::Nonfatal(SkStringPrintf("Could not create brd for %s.", fPath.c_str()));
134 }
135
msarett04965c62015-10-12 10:24:38 -0700136 if (!brd->conversionSupported(colorType)) {
mtklein9b439152015-12-09 13:02:26 -0800137 return Error::Nonfatal("Cannot convert to color type.");
msarett04965c62015-10-12 10:24:38 -0700138 }
139
msaretta5783ae2015-09-08 15:35:32 -0700140 const uint32_t width = brd->width();
141 const uint32_t height = brd->height();
142 // Visually inspecting very small output images is not necessary.
143 if ((width / fSampleSize <= 10 || height / fSampleSize <= 10) && 1 != fSampleSize) {
144 return Error::Nonfatal("Scaling very small images is uninteresting.");
145 }
146 switch (fMode) {
147 case kFullImage_Mode: {
msarett35e5d1b2015-10-27 12:50:25 -0700148 SkBitmap bitmap;
149 if (!brd->decodeRegion(&bitmap, nullptr, SkIRect::MakeXYWH(0, 0, width, height),
150 fSampleSize, colorType, false)) {
mtklein9b439152015-12-09 13:02:26 -0800151 return "Cannot decode (full) region.";
msarett35e5d1b2015-10-27 12:50:25 -0700152 }
153 if (colorType != bitmap.colorType()) {
mtklein9b439152015-12-09 13:02:26 -0800154 return Error::Nonfatal("Cannot convert to color type.");
msaretta5783ae2015-09-08 15:35:32 -0700155 }
msarett35e5d1b2015-10-27 12:50:25 -0700156 canvas->drawBitmap(bitmap, 0, 0);
msaretta5783ae2015-09-08 15:35:32 -0700157 return "";
158 }
159 case kDivisor_Mode: {
160 const uint32_t divisor = 2;
161 if (width < divisor || height < divisor) {
mtklein9b439152015-12-09 13:02:26 -0800162 return Error::Nonfatal("Divisor is larger than image dimension.");
msaretta5783ae2015-09-08 15:35:32 -0700163 }
164
165 // Use a border to test subsets that extend outside the image.
166 // We will not allow the border to be larger than the image dimensions. Allowing
167 // these large borders causes off by one errors that indicate a problem with the
168 // test suite, not a problem with the implementation.
169 const uint32_t maxBorder = SkTMin(width, height) / (fSampleSize * divisor);
170 const uint32_t scaledBorder = SkTMin(5u, maxBorder);
171 const uint32_t unscaledBorder = scaledBorder * fSampleSize;
172
173 // We may need to clear the canvas to avoid uninitialized memory.
174 // Assume we are scaling a 780x780 image with sampleSize = 8.
175 // The output image should be 97x97.
176 // Each subset will be 390x390.
177 // Each scaled subset be 48x48.
178 // Four scaled subsets will only fill a 96x96 image.
179 // The bottom row and last column will not be touched.
180 // This is an unfortunate result of our rounding rules when scaling.
181 // Maybe we need to consider testing scaled subsets without trying to
182 // combine them to match the full scaled image? Or maybe this is the
183 // best we can do?
184 canvas->clear(0);
185
186 for (uint32_t x = 0; x < divisor; x++) {
187 for (uint32_t y = 0; y < divisor; y++) {
188 // Calculate the subset dimensions
189 uint32_t subsetWidth = width / divisor;
190 uint32_t subsetHeight = height / divisor;
191 const int left = x * subsetWidth;
192 const int top = y * subsetHeight;
193
194 // Increase the size of the last subset in each row or column, when the
195 // divisor does not divide evenly into the image dimensions
196 subsetWidth += (x + 1 == divisor) ? (width % divisor) : 0;
197 subsetHeight += (y + 1 == divisor) ? (height % divisor) : 0;
198
199 // Increase the size of the subset in order to have a border on each side
200 const int decodeLeft = left - unscaledBorder;
201 const int decodeTop = top - unscaledBorder;
202 const uint32_t decodeWidth = subsetWidth + unscaledBorder * 2;
203 const uint32_t decodeHeight = subsetHeight + unscaledBorder * 2;
msarett35e5d1b2015-10-27 12:50:25 -0700204 SkBitmap bitmap;
205 if (!brd->decodeRegion(&bitmap, nullptr, SkIRect::MakeXYWH(decodeLeft,
206 decodeTop, decodeWidth, decodeHeight), fSampleSize, colorType, false)) {
mtklein9b439152015-12-09 13:02:26 -0800207 return "Cannot decode region.";
msarett35e5d1b2015-10-27 12:50:25 -0700208 }
209 if (colorType != bitmap.colorType()) {
mtklein9b439152015-12-09 13:02:26 -0800210 return Error::Nonfatal("Cannot convert to color type.");
msaretta5783ae2015-09-08 15:35:32 -0700211 }
212
msarett35e5d1b2015-10-27 12:50:25 -0700213 canvas->drawBitmapRect(bitmap,
msaretta5783ae2015-09-08 15:35:32 -0700214 SkRect::MakeXYWH((SkScalar) scaledBorder, (SkScalar) scaledBorder,
215 (SkScalar) (subsetWidth / fSampleSize),
216 (SkScalar) (subsetHeight / fSampleSize)),
217 SkRect::MakeXYWH((SkScalar) (left / fSampleSize),
218 (SkScalar) (top / fSampleSize),
219 (SkScalar) (subsetWidth / fSampleSize),
220 (SkScalar) (subsetHeight / fSampleSize)),
221 nullptr);
222 }
223 }
224 return "";
225 }
226 default:
227 SkASSERT(false);
mtklein9b439152015-12-09 13:02:26 -0800228 return "Error: Should not be reached.";
msaretta5783ae2015-09-08 15:35:32 -0700229 }
230}
231
232SkISize BRDSrc::size() const {
msarettd1227a72016-05-18 06:23:57 -0700233 SkAutoTDelete<SkBitmapRegionDecoder> brd(create_brd(fPath));
msaretta5783ae2015-09-08 15:35:32 -0700234 if (brd) {
235 return SkISize::Make(SkTMax(1, brd->width() / (int) fSampleSize),
236 SkTMax(1, brd->height() / (int) fSampleSize));
237 }
238 return SkISize::Make(0, 0);
239}
240
241static SkString get_scaled_name(const Path& path, float scale) {
242 return SkStringPrintf("%s_%.3f", SkOSPath::Basename(path.c_str()).c_str(), scale);
243}
244
245Name BRDSrc::name() const {
246 // We will replicate the names used by CodecSrc so that images can
247 // be compared in Gold.
248 if (1 == fSampleSize) {
249 return SkOSPath::Basename(fPath.c_str());
250 }
msarett4b0778e2015-11-13 09:59:11 -0800251 return get_scaled_name(fPath, 1.0f / (float) fSampleSize);
msaretta5783ae2015-09-08 15:35:32 -0700252}
253
254/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
255
scroggo3ac66e92016-02-08 15:09:48 -0800256static bool serial_from_path_name(const SkString& path) {
257 if (!FLAGS_RAW_threading) {
258 static const char* const exts[] = {
259 "arw", "cr2", "dng", "nef", "nrw", "orf", "raf", "rw2", "pef", "srw",
260 "ARW", "CR2", "DNG", "NEF", "NRW", "ORF", "RAF", "RW2", "PEF", "SRW",
261 };
262 const char* actualExt = strrchr(path.c_str(), '.');
263 if (actualExt) {
264 actualExt++;
265 for (auto* ext : exts) {
266 if (0 == strcmp(ext, actualExt)) {
267 return true;
268 }
269 }
270 }
271 }
272 return false;
273}
274
scroggoc5560be2016-02-03 09:42:42 -0800275CodecSrc::CodecSrc(Path path, Mode mode, DstColorType dstColorType, SkAlphaType dstAlphaType,
276 float scale)
msarett438b2ad2015-04-09 12:43:10 -0700277 : fPath(path)
278 , fMode(mode)
279 , fDstColorType(dstColorType)
scroggoc5560be2016-02-03 09:42:42 -0800280 , fDstAlphaType(dstAlphaType)
msarett0a242972015-06-11 14:27:27 -0700281 , fScale(scale)
scroggo3ac66e92016-02-08 15:09:48 -0800282 , fRunSerially(serial_from_path_name(path))
msarett438b2ad2015-04-09 12:43:10 -0700283{}
mtklein748ca3b2015-01-15 10:56:12 -0800284
mtklein99cab4e2015-07-31 06:43:04 -0700285bool CodecSrc::veto(SinkFlags flags) const {
msarett18976312016-03-09 14:20:58 -0800286 // Test to direct raster backends (8888 and 565).
msarettb714fb02016-01-22 14:46:42 -0800287 return flags.type != SinkFlags::kRaster || flags.approach != SinkFlags::kDirect;
mtkleine0effd62015-07-29 06:37:28 -0700288}
scroggo9b77ddd2015-03-19 06:03:39 -0700289
msarett34e0ec42016-04-22 16:27:24 -0700290// Allows us to test decodes to non-native 8888.
msarettb1be46b2016-05-17 08:52:11 -0700291static void swap_rb_if_necessary(SkBitmap& bitmap, CodecSrc::DstColorType dstColorType) {
msarett34e0ec42016-04-22 16:27:24 -0700292 if (CodecSrc::kNonNative8888_Always_DstColorType != dstColorType) {
293 return;
294 }
295
296 for (int y = 0; y < bitmap.height(); y++) {
297 uint32_t* row = (uint32_t*) bitmap.getAddr(0, y);
298 SkOpts::RGBA_to_BGRA(row, row, bitmap.width());
299 }
300}
301
msarett9e9444c2016-02-03 12:39:10 -0800302// FIXME: Currently we cannot draw unpremultiplied sources. skbug.com/3338 and skbug.com/3339.
303// This allows us to still test unpremultiplied decodes.
msarettb1be46b2016-05-17 08:52:11 -0700304static void premultiply_if_necessary(SkBitmap& bitmap) {
msarett9e9444c2016-02-03 12:39:10 -0800305 if (kUnpremul_SkAlphaType != bitmap.alphaType()) {
306 return;
307 }
308
309 switch (bitmap.colorType()) {
310 case kN32_SkColorType:
311 for (int y = 0; y < bitmap.height(); y++) {
312 uint32_t* row = (uint32_t*) bitmap.getAddr(0, y);
313 SkOpts::RGBA_to_rgbA(row, row, bitmap.width());
314 }
315 break;
316 case kIndex_8_SkColorType: {
317 SkColorTable* colorTable = bitmap.getColorTable();
318 SkPMColor* colorPtr = const_cast<SkPMColor*>(colorTable->readColors());
319 SkOpts::RGBA_to_rgbA(colorPtr, colorPtr, colorTable->count());
320 break;
321 }
322 default:
323 // No need to premultiply kGray or k565 outputs.
324 break;
325 }
msarette1daa482016-02-03 15:31:18 -0800326
327 // In the kIndex_8 case, the canvas won't even try to draw unless we mark the
328 // bitmap as kPremul.
329 bitmap.setAlphaType(kPremul_SkAlphaType);
msarett9e9444c2016-02-03 12:39:10 -0800330}
331
msarettb1be46b2016-05-17 08:52:11 -0700332static bool get_decode_info(SkImageInfo* decodeInfo, SkColorType canvasColorType,
scroggoba584892016-05-20 13:56:13 -0700333 CodecSrc::DstColorType dstColorType, SkAlphaType dstAlphaType) {
msarett3d9d7a72015-10-21 10:27:10 -0700334 switch (dstColorType) {
335 case CodecSrc::kIndex8_Always_DstColorType:
336 if (kRGB_565_SkColorType == canvasColorType) {
337 return false;
338 }
scroggoc5560be2016-02-03 09:42:42 -0800339 *decodeInfo = decodeInfo->makeColorType(kIndex_8_SkColorType);
msarett3d9d7a72015-10-21 10:27:10 -0700340 break;
341 case CodecSrc::kGrayscale_Always_DstColorType:
scroggo1a361922016-05-20 14:27:16 -0700342 if (kRGB_565_SkColorType == canvasColorType) {
msarett3d9d7a72015-10-21 10:27:10 -0700343 return false;
344 }
scroggoc5560be2016-02-03 09:42:42 -0800345 *decodeInfo = decodeInfo->makeColorType(kGray_8_SkColorType);
msarett3d9d7a72015-10-21 10:27:10 -0700346 break;
msarett34e0ec42016-04-22 16:27:24 -0700347 case CodecSrc::kNonNative8888_Always_DstColorType:
348 if (kRGB_565_SkColorType == canvasColorType) {
349 return false;
350 }
351#ifdef SK_PMCOLOR_IS_RGBA
352 *decodeInfo = decodeInfo->makeColorType(kBGRA_8888_SkColorType);
353#else
354 *decodeInfo = decodeInfo->makeColorType(kRGBA_8888_SkColorType);
355#endif
356 break;
msarett3d9d7a72015-10-21 10:27:10 -0700357 default:
msarett55f7bdd2016-02-16 13:24:54 -0800358 if (kRGB_565_SkColorType == canvasColorType &&
359 kOpaque_SkAlphaType != decodeInfo->alphaType()) {
360 return false;
361 }
scroggoc5560be2016-02-03 09:42:42 -0800362 *decodeInfo = decodeInfo->makeColorType(canvasColorType);
msarett3d9d7a72015-10-21 10:27:10 -0700363 break;
364 }
365
scroggoba584892016-05-20 13:56:13 -0700366 *decodeInfo = decodeInfo->makeAlphaType(dstAlphaType);
msarett3d9d7a72015-10-21 10:27:10 -0700367 return true;
368}
369
msarettb1be46b2016-05-17 08:52:11 -0700370static void draw_to_canvas(SkCanvas* canvas, const SkImageInfo& info, void* pixels, size_t rowBytes,
371 SkPMColor* colorPtr, int colorCount, CodecSrc::DstColorType dstColorType,
372 SkScalar left = 0, SkScalar top = 0) {
373 SkAutoTUnref<SkColorTable> colorTable(new SkColorTable(colorPtr, colorCount));
374 SkBitmap bitmap;
375 bitmap.installPixels(info, pixels, rowBytes, colorTable.get(), nullptr, nullptr);
376 premultiply_if_necessary(bitmap);
377 swap_rb_if_necessary(bitmap, dstColorType);
378 canvas->drawBitmap(bitmap, left, top);
379}
380
mtkleine0effd62015-07-29 06:37:28 -0700381Error CodecSrc::draw(SkCanvas* canvas) const {
bungeman38d909e2016-08-02 14:40:46 -0700382 sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
mtklein748ca3b2015-01-15 10:56:12 -0800383 if (!encoded) {
384 return SkStringPrintf("Couldn't read %s.", fPath.c_str());
385 }
msarettb714fb02016-01-22 14:46:42 -0800386
bungeman38d909e2016-08-02 14:40:46 -0700387 SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded.get()));
msarett9e707a02015-09-01 14:57:57 -0700388 if (nullptr == codec.get()) {
389 return SkStringPrintf("Couldn't create codec for %s.", fPath.c_str());
scroggo9b77ddd2015-03-19 06:03:39 -0700390 }
391
scroggoba584892016-05-20 13:56:13 -0700392 SkImageInfo decodeInfo = codec->getInfo();
393 if (!get_decode_info(&decodeInfo, canvas->imageInfo().colorType(), fDstColorType,
394 fDstAlphaType)) {
msarett3d9d7a72015-10-21 10:27:10 -0700395 return Error::Nonfatal("Testing non-565 to 565 is uninteresting.");
msarett438b2ad2015-04-09 12:43:10 -0700396 }
397
msarett0a242972015-06-11 14:27:27 -0700398 // Try to scale the image if it is desired
399 SkISize size = codec->getScaledDimensions(fScale);
400 if (size == decodeInfo.dimensions() && 1.0f != fScale) {
401 return Error::Nonfatal("Test without scaling is uninteresting.");
402 }
msarettb32758a2015-08-18 13:22:46 -0700403
404 // Visually inspecting very small output images is not necessary. We will
405 // cover these cases in unit testing.
406 if ((size.width() <= 10 || size.height() <= 10) && 1.0f != fScale) {
407 return Error::Nonfatal("Scaling very small images is uninteresting.");
408 }
msarett0a242972015-06-11 14:27:27 -0700409 decodeInfo = decodeInfo.makeWH(size.width(), size.height());
410
msarettb1be46b2016-05-17 08:52:11 -0700411 const int bpp = SkColorTypeBytesPerPixel(decodeInfo.colorType());
412 const size_t rowBytes = size.width() * bpp;
413 SkAutoMalloc pixels(decodeInfo.getSafeSize(rowBytes));
414 SkPMColor colorPtr[256];
415 int colorCount = 256;
msarett438b2ad2015-04-09 12:43:10 -0700416
msarettbb25b532016-01-13 09:31:39 -0800417 SkCodec::Options options;
418 if (kCodecZeroInit_Mode == fMode) {
msarettb1be46b2016-05-17 08:52:11 -0700419 memset(pixels.get(), 0, size.height() * rowBytes);
msarettbb25b532016-01-13 09:31:39 -0800420 options.fZeroInitialized = SkCodec::kYes_ZeroInitialized;
421 }
msarett34e0ec42016-04-22 16:27:24 -0700422
423 SkImageInfo bitmapInfo = decodeInfo;
424 if (kRGBA_8888_SkColorType == decodeInfo.colorType() ||
425 kBGRA_8888_SkColorType == decodeInfo.colorType()) {
426 bitmapInfo = bitmapInfo.makeColorType(kN32_SkColorType);
427 }
scroggo9b77ddd2015-03-19 06:03:39 -0700428
scroggo9c59ebc2015-03-25 13:48:49 -0700429 switch (fMode) {
msarettbb25b532016-01-13 09:31:39 -0800430 case kCodecZeroInit_Mode:
msarett9e707a02015-09-01 14:57:57 -0700431 case kCodec_Mode: {
msarettb1be46b2016-05-17 08:52:11 -0700432 switch (codec->getPixels(decodeInfo, pixels.get(), rowBytes, &options,
433 colorPtr, &colorCount)) {
scroggoeb602a52015-07-09 08:16:03 -0700434 case SkCodec::kSuccess:
scroggo9c59ebc2015-03-25 13:48:49 -0700435 // We consider incomplete to be valid, since we should still decode what is
436 // available.
scroggoeb602a52015-07-09 08:16:03 -0700437 case SkCodec::kIncompleteInput:
scroggo9c59ebc2015-03-25 13:48:49 -0700438 break;
scroggo9c59ebc2015-03-25 13:48:49 -0700439 default:
440 // Everything else is considered a failure.
441 return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
442 }
msarettb1be46b2016-05-17 08:52:11 -0700443
444 draw_to_canvas(canvas, bitmapInfo, pixels.get(), rowBytes, colorPtr, colorCount,
445 fDstColorType);
scroggo9c59ebc2015-03-25 13:48:49 -0700446 break;
emmaleer0a4c3cb2015-06-22 10:40:21 -0700447 }
scroggo9c59ebc2015-03-25 13:48:49 -0700448 case kScanline_Mode: {
scroggod8d68552016-06-06 11:26:17 -0700449 if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo, NULL, colorPtr,
450 &colorCount)) {
451 return "Could not start scanline decoder";
scroggo6fb23912016-06-02 14:16:43 -0700452 }
453
scroggod8d68552016-06-06 11:26:17 -0700454 void* dst = pixels.get();
455 uint32_t height = decodeInfo.height();
456 switch (codec->getScanlineOrder()) {
457 case SkCodec::kTopDown_SkScanlineOrder:
458 case SkCodec::kBottomUp_SkScanlineOrder:
459 case SkCodec::kNone_SkScanlineOrder:
460 // We do not need to check the return value. On an incomplete
461 // image, memory will be filled with a default value.
462 codec->getScanlines(dst, height, rowBytes);
463 break;
464 case SkCodec::kOutOfOrder_SkScanlineOrder: {
465 for (int y = 0; y < decodeInfo.height(); y++) {
466 int dstY = codec->outputScanline(y);
467 void* dstPtr = SkTAddOffset<void>(dst, rowBytes * dstY);
468 // We complete the loop, even if this call begins to fail
469 // due to an incomplete image. This ensures any uninitialized
470 // memory will be filled with the proper value.
471 codec->getScanlines(dstPtr, 1, rowBytes);
scroggo6fb23912016-06-02 14:16:43 -0700472 }
scroggod8d68552016-06-06 11:26:17 -0700473 break;
msarett10522ff2015-09-07 08:54:01 -0700474 }
475 }
476
msarettb1be46b2016-05-17 08:52:11 -0700477 draw_to_canvas(canvas, bitmapInfo, dst, rowBytes, colorPtr, colorCount, fDstColorType);
emmaleer97002062015-05-27 12:36:10 -0700478 break;
479 }
msarett0a242972015-06-11 14:27:27 -0700480 case kStripe_Mode: {
481 const int height = decodeInfo.height();
482 // This value is chosen arbitrarily. We exercise more cases by choosing a value that
483 // does not align with image blocks.
484 const int stripeHeight = 37;
485 const int numStripes = (height + stripeHeight - 1) / stripeHeight;
msarettb1be46b2016-05-17 08:52:11 -0700486 void* dst = pixels.get();
msarett0a242972015-06-11 14:27:27 -0700487
488 // Decode odd stripes
msarettb1be46b2016-05-17 08:52:11 -0700489 if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo, nullptr, colorPtr,
490 &colorCount)) {
msarettb65e6042016-02-23 05:37:25 -0800491 return "Could not start scanline decoder";
492 }
493
494 // This mode was designed to test the new skip scanlines API in libjpeg-turbo.
495 // Jpegs have kTopDown_SkScanlineOrder, and at this time, it is not interesting
496 // to run this test for image types that do not have this scanline ordering.
scroggo12e2f502016-05-16 09:04:18 -0700497 // We only run this on Jpeg, which is always kTopDown.
498 SkASSERT(SkCodec::kTopDown_SkScanlineOrder == codec->getScanlineOrder());
msarette6dd0042015-10-09 11:07:34 -0700499
msarett0a242972015-06-11 14:27:27 -0700500 for (int i = 0; i < numStripes; i += 2) {
501 // Skip a stripe
502 const int linesToSkip = SkTMin(stripeHeight, height - i * stripeHeight);
msarette6dd0042015-10-09 11:07:34 -0700503 codec->skipScanlines(linesToSkip);
msarett0a242972015-06-11 14:27:27 -0700504
505 // Read a stripe
506 const int startY = (i + 1) * stripeHeight;
507 const int linesToRead = SkTMin(stripeHeight, height - startY);
508 if (linesToRead > 0) {
msarettb1be46b2016-05-17 08:52:11 -0700509 codec->getScanlines(SkTAddOffset<void>(dst, rowBytes * startY), linesToRead,
510 rowBytes);
msarett0a242972015-06-11 14:27:27 -0700511 }
512 }
513
514 // Decode even stripes
scroggo46c57472015-09-30 08:57:13 -0700515 const SkCodec::Result startResult = codec->startScanlineDecode(decodeInfo, nullptr,
msarettb1be46b2016-05-17 08:52:11 -0700516 colorPtr, &colorCount);
scroggo1c005e42015-08-04 09:24:45 -0700517 if (SkCodec::kSuccess != startResult) {
518 return "Failed to restart scanline decoder with same parameters.";
msarett0a242972015-06-11 14:27:27 -0700519 }
520 for (int i = 0; i < numStripes; i += 2) {
521 // Read a stripe
522 const int startY = i * stripeHeight;
523 const int linesToRead = SkTMin(stripeHeight, height - startY);
msarettb1be46b2016-05-17 08:52:11 -0700524 codec->getScanlines(SkTAddOffset<void>(dst, rowBytes * startY), linesToRead,
525 rowBytes);
msarett0a242972015-06-11 14:27:27 -0700526
527 // Skip a stripe
msarettf6db27e2015-06-12 09:34:04 -0700528 const int linesToSkip = SkTMin(stripeHeight, height - (i + 1) * stripeHeight);
529 if (linesToSkip > 0) {
msarette6dd0042015-10-09 11:07:34 -0700530 codec->skipScanlines(linesToSkip);
msarett0a242972015-06-11 14:27:27 -0700531 }
532 }
msarettb1be46b2016-05-17 08:52:11 -0700533
534 draw_to_canvas(canvas, bitmapInfo, dst, rowBytes, colorPtr, colorCount, fDstColorType);
emmaleer0a4c3cb2015-06-22 10:40:21 -0700535 break;
msarett0a242972015-06-11 14:27:27 -0700536 }
msarett91c22b22016-02-22 12:27:46 -0800537 case kCroppedScanline_Mode: {
538 const int width = decodeInfo.width();
539 const int height = decodeInfo.height();
540 // This value is chosen because, as we move across the image, it will sometimes
541 // align with the jpeg block sizes and it will sometimes not. This allows us
542 // to test interestingly different code paths in the implementation.
543 const int tileSize = 36;
544
545 SkCodec::Options opts;
546 SkIRect subset;
547 for (int x = 0; x < width; x += tileSize) {
548 subset = SkIRect::MakeXYWH(x, 0, SkTMin(tileSize, width - x), height);
549 opts.fSubset = &subset;
550 if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo, &opts,
msarettb1be46b2016-05-17 08:52:11 -0700551 colorPtr, &colorCount)) {
msarett91c22b22016-02-22 12:27:46 -0800552 return "Could not start scanline decoder.";
553 }
554
msarettb1be46b2016-05-17 08:52:11 -0700555 codec->getScanlines(SkTAddOffset<void>(pixels.get(), x * bpp), height, rowBytes);
msarett91c22b22016-02-22 12:27:46 -0800556 }
557
msarettb1be46b2016-05-17 08:52:11 -0700558 draw_to_canvas(canvas, bitmapInfo, pixels.get(), rowBytes, colorPtr, colorCount,
559 fDstColorType);
msarett91c22b22016-02-22 12:27:46 -0800560 break;
561 }
scroggob636b452015-07-22 07:16:20 -0700562 case kSubset_Mode: {
563 // Arbitrarily choose a divisor.
564 int divisor = 2;
565 // Total width/height of the image.
566 const int W = codec->getInfo().width();
567 const int H = codec->getInfo().height();
568 if (divisor > W || divisor > H) {
569 return Error::Nonfatal(SkStringPrintf("Cannot codec subset: divisor %d is too big "
570 "for %s with dimensions (%d x %d)", divisor,
571 fPath.c_str(), W, H));
572 }
573 // subset dimensions
574 // SkWebpCodec, the only one that supports subsets, requires even top/left boundaries.
575 const int w = SkAlign2(W / divisor);
576 const int h = SkAlign2(H / divisor);
577 SkIRect subset;
578 SkCodec::Options opts;
579 opts.fSubset = &subset;
580 SkBitmap subsetBm;
581 // We will reuse pixel memory from bitmap.
msarettb1be46b2016-05-17 08:52:11 -0700582 void* dst = pixels.get();
scroggob636b452015-07-22 07:16:20 -0700583 // Keep track of left and top (for drawing subsetBm into canvas). We could use
584 // fScale * x and fScale * y, but we want integers such that the next subset will start
585 // where the last one ended. So we'll add decodeInfo.width() and height().
586 int left = 0;
587 for (int x = 0; x < W; x += w) {
588 int top = 0;
589 for (int y = 0; y < H; y+= h) {
590 // Do not make the subset go off the edge of the image.
591 const int preScaleW = SkTMin(w, W - x);
592 const int preScaleH = SkTMin(h, H - y);
593 subset.setXYWH(x, y, preScaleW, preScaleH);
594 // And scale
595 // FIXME: Should we have a version of getScaledDimensions that takes a subset
596 // into account?
msarettc7eb4902016-04-25 07:04:58 -0700597 const int scaledW = SkTMax(1, SkScalarRoundToInt(preScaleW * fScale));
598 const int scaledH = SkTMax(1, SkScalarRoundToInt(preScaleH * fScale));
599 decodeInfo = decodeInfo.makeWH(scaledW, scaledH);
600 SkImageInfo subsetBitmapInfo = bitmapInfo.makeWH(scaledW, scaledH);
msarettb1be46b2016-05-17 08:52:11 -0700601 size_t subsetRowBytes = subsetBitmapInfo.minRowBytes();
602 const SkCodec::Result result = codec->getPixels(decodeInfo, dst, subsetRowBytes,
603 &opts, colorPtr, &colorCount);
scroggob636b452015-07-22 07:16:20 -0700604 switch (result) {
605 case SkCodec::kSuccess:
606 case SkCodec::kIncompleteInput:
607 break;
scroggob636b452015-07-22 07:16:20 -0700608 default:
609 return SkStringPrintf("subset codec failed to decode (%d, %d, %d, %d) "
610 "from %s with dimensions (%d x %d)\t error %d",
611 x, y, decodeInfo.width(), decodeInfo.height(),
612 fPath.c_str(), W, H, result);
613 }
msarettb1be46b2016-05-17 08:52:11 -0700614 draw_to_canvas(canvas, subsetBitmapInfo, dst, subsetRowBytes, colorPtr,
615 colorCount, fDstColorType, SkIntToScalar(left),
616 SkIntToScalar(top));
617
scroggob636b452015-07-22 07:16:20 -0700618 // translate by the scaled height.
619 top += decodeInfo.height();
620 }
621 // translate by the scaled width.
622 left += decodeInfo.width();
623 }
624 return "";
625 }
msarettb714fb02016-01-22 14:46:42 -0800626 default:
627 SkASSERT(false);
628 return "Invalid fMode";
scroggo9b77ddd2015-03-19 06:03:39 -0700629 }
scroggo9c59ebc2015-03-25 13:48:49 -0700630 return "";
scroggo9b77ddd2015-03-19 06:03:39 -0700631}
632
633SkISize CodecSrc::size() const {
bungeman38d909e2016-08-02 14:40:46 -0700634 sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
635 SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded.get()));
scroggo7fac5af2015-09-30 11:33:12 -0700636 if (nullptr == codec) {
637 return SkISize::Make(0, 0);
638 }
639 return codec->getScaledDimensions(fScale);
scroggo9b77ddd2015-03-19 06:03:39 -0700640}
641
642Name CodecSrc::name() const {
msarett0a242972015-06-11 14:27:27 -0700643 if (1.0f == fScale) {
644 return SkOSPath::Basename(fPath.c_str());
msarett0a242972015-06-11 14:27:27 -0700645 }
msaretta5783ae2015-09-08 15:35:32 -0700646 return get_scaled_name(fPath, fScale);
scroggo9b77ddd2015-03-19 06:03:39 -0700647}
648
649/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
650
scroggof8dc9df2016-05-16 09:04:13 -0700651AndroidCodecSrc::AndroidCodecSrc(Path path, CodecSrc::DstColorType dstColorType,
scroggoc5560be2016-02-03 09:42:42 -0800652 SkAlphaType dstAlphaType, int sampleSize)
msarett3d9d7a72015-10-21 10:27:10 -0700653 : fPath(path)
msarett3d9d7a72015-10-21 10:27:10 -0700654 , fDstColorType(dstColorType)
scroggoc5560be2016-02-03 09:42:42 -0800655 , fDstAlphaType(dstAlphaType)
msarett3d9d7a72015-10-21 10:27:10 -0700656 , fSampleSize(sampleSize)
scroggo3ac66e92016-02-08 15:09:48 -0800657 , fRunSerially(serial_from_path_name(path))
msarett3d9d7a72015-10-21 10:27:10 -0700658{}
659
660bool AndroidCodecSrc::veto(SinkFlags flags) const {
661 // No need to test decoding to non-raster or indirect backend.
msarett3d9d7a72015-10-21 10:27:10 -0700662 return flags.type != SinkFlags::kRaster
663 || flags.approach != SinkFlags::kDirect;
664}
665
666Error AndroidCodecSrc::draw(SkCanvas* canvas) const {
bungeman38d909e2016-08-02 14:40:46 -0700667 sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
msarett3d9d7a72015-10-21 10:27:10 -0700668 if (!encoded) {
669 return SkStringPrintf("Couldn't read %s.", fPath.c_str());
670 }
bungeman38d909e2016-08-02 14:40:46 -0700671 SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(encoded.get()));
msarett3d9d7a72015-10-21 10:27:10 -0700672 if (nullptr == codec.get()) {
673 return SkStringPrintf("Couldn't create android codec for %s.", fPath.c_str());
674 }
675
scroggoba584892016-05-20 13:56:13 -0700676 SkImageInfo decodeInfo = codec->getInfo();
677 if (!get_decode_info(&decodeInfo, canvas->imageInfo().colorType(), fDstColorType,
678 fDstAlphaType)) {
msarett3d9d7a72015-10-21 10:27:10 -0700679 return Error::Nonfatal("Testing non-565 to 565 is uninteresting.");
680 }
681
682 // Scale the image if it is desired.
683 SkISize size = codec->getSampledDimensions(fSampleSize);
684
685 // Visually inspecting very small output images is not necessary. We will
686 // cover these cases in unit testing.
687 if ((size.width() <= 10 || size.height() <= 10) && 1 != fSampleSize) {
688 return Error::Nonfatal("Scaling very small images is uninteresting.");
689 }
690 decodeInfo = decodeInfo.makeWH(size.width(), size.height());
691
msarettb1be46b2016-05-17 08:52:11 -0700692 int bpp = SkColorTypeBytesPerPixel(decodeInfo.colorType());
693 size_t rowBytes = size.width() * bpp;
694 SkAutoMalloc pixels(size.height() * rowBytes);
695 SkPMColor colorPtr[256];
696 int colorCount = 256;
msarett3d9d7a72015-10-21 10:27:10 -0700697
698 SkBitmap bitmap;
msarett34e0ec42016-04-22 16:27:24 -0700699 SkImageInfo bitmapInfo = decodeInfo;
700 if (kRGBA_8888_SkColorType == decodeInfo.colorType() ||
701 kBGRA_8888_SkColorType == decodeInfo.colorType()) {
702 bitmapInfo = bitmapInfo.makeColorType(kN32_SkColorType);
703 }
msarett3d9d7a72015-10-21 10:27:10 -0700704
705 // Create options for the codec.
706 SkAndroidCodec::AndroidOptions options;
707 options.fColorPtr = colorPtr;
msarettb1be46b2016-05-17 08:52:11 -0700708 options.fColorCount = &colorCount;
msarett3d9d7a72015-10-21 10:27:10 -0700709 options.fSampleSize = fSampleSize;
710
msarettb1be46b2016-05-17 08:52:11 -0700711 switch (codec->getAndroidPixels(decodeInfo, pixels.get(), rowBytes, &options)) {
scroggof8dc9df2016-05-16 09:04:13 -0700712 case SkCodec::kSuccess:
713 case SkCodec::kIncompleteInput:
714 break;
msarett3d9d7a72015-10-21 10:27:10 -0700715 default:
scroggof8dc9df2016-05-16 09:04:13 -0700716 return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
msarett3d9d7a72015-10-21 10:27:10 -0700717 }
msarettb1be46b2016-05-17 08:52:11 -0700718 draw_to_canvas(canvas, bitmapInfo, pixels.get(), rowBytes, colorPtr, colorCount, fDstColorType);
scroggof8dc9df2016-05-16 09:04:13 -0700719 return "";
msarett3d9d7a72015-10-21 10:27:10 -0700720}
721
722SkISize AndroidCodecSrc::size() const {
bungeman38d909e2016-08-02 14:40:46 -0700723 sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
724 SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(encoded.get()));
msarett3d9d7a72015-10-21 10:27:10 -0700725 if (nullptr == codec) {
726 return SkISize::Make(0, 0);
727 }
728 return codec->getSampledDimensions(fSampleSize);
729}
730
731Name AndroidCodecSrc::name() const {
732 // We will replicate the names used by CodecSrc so that images can
733 // be compared in Gold.
734 if (1 == fSampleSize) {
735 return SkOSPath::Basename(fPath.c_str());
736 }
msarett4b0778e2015-11-13 09:59:11 -0800737 return get_scaled_name(fPath, 1.0f / (float) fSampleSize);
msarett3d9d7a72015-10-21 10:27:10 -0700738}
739
740/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
741
msarett18976312016-03-09 14:20:58 -0800742ImageGenSrc::ImageGenSrc(Path path, Mode mode, SkAlphaType alphaType, bool isGpu)
743 : fPath(path)
744 , fMode(mode)
745 , fDstAlphaType(alphaType)
746 , fIsGpu(isGpu)
747 , fRunSerially(serial_from_path_name(path))
748{}
749
750bool ImageGenSrc::veto(SinkFlags flags) const {
751 if (fIsGpu) {
752 return flags.type != SinkFlags::kGPU || flags.approach != SinkFlags::kDirect;
753 }
754
755 return flags.type != SinkFlags::kRaster || flags.approach != SinkFlags::kDirect;
756}
757
758Error ImageGenSrc::draw(SkCanvas* canvas) const {
759 if (kRGB_565_SkColorType == canvas->imageInfo().colorType()) {
760 return Error::Nonfatal("Uninteresting to test image generator to 565.");
761 }
762
bungeman38d909e2016-08-02 14:40:46 -0700763 sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
msarett18976312016-03-09 14:20:58 -0800764 if (!encoded) {
765 return SkStringPrintf("Couldn't read %s.", fPath.c_str());
766 }
767
msarettfc0b6d12016-03-17 13:50:17 -0700768#if defined(SK_BUILD_FOR_WIN)
769 // Initialize COM in order to test with WIC.
770 SkAutoCoInitialize com;
771 if (!com.succeeded()) {
772 return "Could not initialize COM.";
773 }
774#endif
775
msarett18976312016-03-09 14:20:58 -0800776 SkAutoTDelete<SkImageGenerator> gen(nullptr);
777 switch (fMode) {
778 case kCodec_Mode:
bungeman38d909e2016-08-02 14:40:46 -0700779 gen.reset(SkCodecImageGenerator::NewFromEncodedCodec(encoded.get()));
msarett18976312016-03-09 14:20:58 -0800780 if (!gen) {
781 return "Could not create codec image generator.";
782 }
783 break;
msarettfc0b6d12016-03-17 13:50:17 -0700784 case kPlatform_Mode: {
msarett18976312016-03-09 14:20:58 -0800785#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
bungeman38d909e2016-08-02 14:40:46 -0700786 gen.reset(SkImageGeneratorCG::NewFromEncodedCG(encoded.get()));
msarettfc0b6d12016-03-17 13:50:17 -0700787#elif defined(SK_BUILD_FOR_WIN)
bungeman38d909e2016-08-02 14:40:46 -0700788 gen.reset(SkImageGeneratorWIC::NewFromEncodedWIC(encoded.get()));
msarettfc0b6d12016-03-17 13:50:17 -0700789#endif
790
msarett18976312016-03-09 14:20:58 -0800791 if (!gen) {
msarettfc0b6d12016-03-17 13:50:17 -0700792 return "Could not create platform image generator.";
msarett18976312016-03-09 14:20:58 -0800793 }
794 break;
msarettfc0b6d12016-03-17 13:50:17 -0700795 }
msarett18976312016-03-09 14:20:58 -0800796 default:
797 SkASSERT(false);
798 return "Invalid image generator mode";
799 }
800
801 // Test deferred decoding path on GPU
802 if (fIsGpu) {
reed9ce9d672016-03-17 10:51:11 -0700803 sk_sp<SkImage> image(SkImage::MakeFromGenerator(gen.release(), nullptr));
msarett18976312016-03-09 14:20:58 -0800804 if (!image) {
805 return "Could not create image from codec image generator.";
806 }
807 canvas->drawImage(image, 0, 0);
808 return "";
809 }
mtklein343a63d2016-03-22 11:46:53 -0700810
msarett18976312016-03-09 14:20:58 -0800811 // Test various color and alpha types on CPU
812 SkImageInfo decodeInfo = gen->getInfo().makeAlphaType(fDstAlphaType);
mtklein343a63d2016-03-22 11:46:53 -0700813
msarettb1be46b2016-05-17 08:52:11 -0700814 int bpp = SkColorTypeBytesPerPixel(decodeInfo.colorType());
815 size_t rowBytes = decodeInfo.width() * bpp;
816 SkAutoMalloc pixels(decodeInfo.height() * rowBytes);
817 SkPMColor colorPtr[256];
818 int colorCount = 256;
msarett18976312016-03-09 14:20:58 -0800819
msarettb1be46b2016-05-17 08:52:11 -0700820 if (!gen->getPixels(decodeInfo, pixels.get(), rowBytes, colorPtr, &colorCount)) {
msarett18976312016-03-09 14:20:58 -0800821 return SkStringPrintf("Image generator could not getPixels() for %s\n", fPath.c_str());
822 }
823
msarettb1be46b2016-05-17 08:52:11 -0700824 draw_to_canvas(canvas, decodeInfo, pixels.get(), rowBytes, colorPtr, colorCount,
825 CodecSrc::kGetFromCanvas_DstColorType);
msarett18976312016-03-09 14:20:58 -0800826 return "";
827}
828
829SkISize ImageGenSrc::size() const {
bungeman38d909e2016-08-02 14:40:46 -0700830 sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
831 SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded.get()));
msarett18976312016-03-09 14:20:58 -0800832 if (nullptr == codec) {
833 return SkISize::Make(0, 0);
834 }
835 return codec->getInfo().dimensions();
836}
837
838Name ImageGenSrc::name() const {
839 return SkOSPath::Basename(fPath.c_str());
840}
841
842/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
843
msarett9ce3a542016-07-15 13:54:38 -0700844ColorCodecSrc::ColorCodecSrc(Path path, Mode mode, SkColorType colorType)
msarett69deca82016-04-29 09:38:40 -0700845 : fPath(path)
846 , fMode(mode)
msarett9ce3a542016-07-15 13:54:38 -0700847 , fColorType(colorType)
msarett69deca82016-04-29 09:38:40 -0700848{}
849
850bool ColorCodecSrc::veto(SinkFlags flags) const {
851 // Test to direct raster backends (8888 and 565).
852 return flags.type != SinkFlags::kRaster || flags.approach != SinkFlags::kDirect;
853}
854
855Error ColorCodecSrc::draw(SkCanvas* canvas) const {
856 if (kRGB_565_SkColorType == canvas->imageInfo().colorType()) {
857 return Error::Nonfatal("No need to test color correction to 565 backend.");
858 }
859
msarettd1ec89b2016-08-03 12:59:27 -0700860 bool runInLegacyMode = kBaseline_Mode == fMode;
861#if defined(SK_TEST_QCMS)
862 runInLegacyMode = runInLegacyMode || kQCMS_HPZR30w_Mode == fMode;
863#endif
864
865 if (runInLegacyMode && canvas->imageInfo().colorSpace()) {
866 return Error::Nonfatal("Skipping tests that are only interesting in legacy mode.");
867 } else if (!runInLegacyMode && !canvas->imageInfo().colorSpace()) {
868 return Error::Nonfatal("Skipping tests that are only interesting in srgb mode.");
msarett9ce3a542016-07-15 13:54:38 -0700869 }
870
bungeman38d909e2016-08-02 14:40:46 -0700871 sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
msarett69deca82016-04-29 09:38:40 -0700872 if (!encoded) {
873 return SkStringPrintf("Couldn't read %s.", fPath.c_str());
874 }
875
bungeman38d909e2016-08-02 14:40:46 -0700876 SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded.get()));
msarett69deca82016-04-29 09:38:40 -0700877 if (nullptr == codec.get()) {
878 return SkStringPrintf("Couldn't create codec for %s.", fPath.c_str());
879 }
880
msarett9876ac52016-06-01 14:47:18 -0700881 // Load the dst ICC profile. This particular dst is fairly similar to Adobe RGB.
882 sk_sp<SkData> dstData = SkData::MakeFromFileName(
msaretta714bc32016-07-29 08:58:33 -0700883 GetResourcePath("icc_profiles/HP_ZR30w.icc").c_str());
msarett9876ac52016-06-01 14:47:18 -0700884 if (!dstData) {
885 return "Cannot read monitor profile. Is the resource path set correctly?";
886 }
887
msarett50ce1f22016-07-29 06:23:33 -0700888 sk_sp<SkColorSpace> dstSpace = nullptr;
889 if (kDst_sRGB_Mode == fMode) {
890 dstSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named);
891 } else if (kDst_HPZR30w_Mode == fMode) {
892 dstSpace = SkColorSpace::NewICC(dstData->data(), dstData->size());
893 }
894
895 SkImageInfo decodeInfo = codec->getInfo().makeColorType(fColorType).makeColorSpace(dstSpace);
msarettd1ec89b2016-08-03 12:59:27 -0700896 if (kUnpremul_SkAlphaType == decodeInfo.alphaType()) {
897 decodeInfo = decodeInfo.makeAlphaType(kPremul_SkAlphaType);
898 }
899
msarett50ce1f22016-07-29 06:23:33 -0700900 SkImageInfo bitmapInfo = decodeInfo;
901 if (kRGBA_8888_SkColorType == decodeInfo.colorType() ||
902 kBGRA_8888_SkColorType == decodeInfo.colorType())
903 {
904 bitmapInfo = bitmapInfo.makeColorType(kN32_SkColorType);
905 }
906
907 SkBitmap bitmap;
908 if (!bitmap.tryAllocPixels(bitmapInfo)) {
909 return SkStringPrintf("Image(%s) is too large (%d x %d)", fPath.c_str(),
910 bitmapInfo.width(), bitmapInfo.height());
911 }
912
913 size_t rowBytes = bitmap.rowBytes();
914 SkCodec::Result r = codec->getPixels(decodeInfo, bitmap.getPixels(), rowBytes);
915 if (SkCodec::kSuccess != r) {
916 return SkStringPrintf("Couldn't getPixels %s. Error code %d", fPath.c_str(), r);
917 }
918
msarett69deca82016-04-29 09:38:40 -0700919 switch (fMode) {
920 case kBaseline_Mode:
msarett39979d82016-07-28 17:11:18 -0700921 case kDst_sRGB_Mode:
msarett50ce1f22016-07-29 06:23:33 -0700922 case kDst_HPZR30w_Mode:
msarett39979d82016-07-28 17:11:18 -0700923 canvas->drawBitmap(bitmap, 0, 0);
924 break;
msarett469f1c52016-06-06 08:20:37 -0700925#if defined(SK_TEST_QCMS)
msarett9876ac52016-06-01 14:47:18 -0700926 case kQCMS_HPZR30w_Mode: {
927 sk_sp<SkData> srcData = codec->getICCData();
msarettd1ec89b2016-08-03 12:59:27 -0700928 if (!srcData) {
929 return Error::Nonfatal("No ICC profile data. Cannot test with QCMS.\n");
930 }
931
msarett9876ac52016-06-01 14:47:18 -0700932 SkAutoTCallVProc<qcms_profile, qcms_profile_release>
933 srcSpace(qcms_profile_from_memory(srcData->data(), srcData->size()));
934 if (!srcSpace) {
935 return Error::Nonfatal(SkStringPrintf("QCMS cannot create profile for %s.\n",
936 fPath.c_str()));
937 }
938
939 SkAutoTCallVProc<qcms_profile, qcms_profile_release>
940 dstSpace(qcms_profile_from_memory(dstData->data(), dstData->size()));
941 SkASSERT(dstSpace);
msarette8bd9ab2016-06-08 10:02:32 -0700942
943 // Optimizes conversion by precomputing the inverse transformation to dst. Also
944 // causes QCMS to use a completely different codepath. This is how Chrome uses QCMS.
945 qcms_profile_precache_output_transform(dstSpace);
msarett9876ac52016-06-01 14:47:18 -0700946 SkAutoTCallVProc<qcms_transform, qcms_transform_release>
947 transform (qcms_transform_create(srcSpace, QCMS_DATA_RGBA_8, dstSpace,
948 QCMS_DATA_RGBA_8, QCMS_INTENT_PERCEPTUAL));
949 if (!transform) {
950 return SkStringPrintf("QCMS cannot create transform for %s.\n", fPath.c_str());
951 }
952
953#ifdef SK_PMCOLOR_IS_RGBA
954 qcms_output_type outType = QCMS_OUTPUT_RGBX;
955#else
956 qcms_output_type outType = QCMS_OUTPUT_BGRX;
957#endif
958
959 // Perform color correction.
msarett50ce1f22016-07-29 06:23:33 -0700960 uint32_t* row = (uint32_t*) bitmap.getPixels();
961 for (int y = 0; y < decodeInfo.height(); y++) {
962 qcms_transform_data_type(transform, row, row, decodeInfo.width(), outType);
963 row = SkTAddOffset<uint32_t>(row, rowBytes);
msarett9876ac52016-06-01 14:47:18 -0700964 }
965
966 canvas->drawBitmap(bitmap, 0, 0);
967 break;
968 }
969#endif
msarett69deca82016-04-29 09:38:40 -0700970 default:
971 SkASSERT(false);
972 return "Invalid fMode";
973 }
974 return "";
975}
976
977SkISize ColorCodecSrc::size() const {
bungeman38d909e2016-08-02 14:40:46 -0700978 sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
979 SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded.get()));
msarett69deca82016-04-29 09:38:40 -0700980 if (nullptr == codec) {
981 return SkISize::Make(0, 0);
982 }
983 return SkISize::Make(codec->getInfo().width(), codec->getInfo().height());
984}
985
986Name ColorCodecSrc::name() const {
987 return SkOSPath::Basename(fPath.c_str());
988}
989
990/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
991
mtkleinf4ba3212015-01-28 15:32:24 -0800992static const SkRect kSKPViewport = {0,0, 1000,1000};
993
mtklein8d17a132015-01-30 11:42:31 -0800994SKPSrc::SKPSrc(Path path) : fPath(path) {}
mtklein748ca3b2015-01-15 10:56:12 -0800995
996Error SKPSrc::draw(SkCanvas* canvas) const {
scroggoa1193e42015-01-21 12:09:53 -0800997 SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(fPath.c_str()));
mtklein75d98fd2015-01-18 07:05:01 -0800998 if (!stream) {
mtklein748ca3b2015-01-15 10:56:12 -0800999 return SkStringPrintf("Couldn't read %s.", fPath.c_str());
1000 }
reedca2622b2016-03-18 07:25:55 -07001001 sk_sp<SkPicture> pic(SkPicture::MakeFromStream(stream));
mtklein75d98fd2015-01-18 07:05:01 -08001002 if (!pic) {
1003 return SkStringPrintf("Couldn't decode %s as a picture.", fPath.c_str());
1004 }
halcanary96fcdcc2015-08-27 07:41:13 -07001005 stream.reset((SkStream*)nullptr); // Might as well drop this when we're done with it.
joshualitt7c3a2f82015-03-31 13:32:05 -07001006
mtkleinf4ba3212015-01-28 15:32:24 -08001007 canvas->clipRect(kSKPViewport);
mtklein748ca3b2015-01-15 10:56:12 -08001008 canvas->drawPicture(pic);
1009 return "";
1010}
1011
1012SkISize SKPSrc::size() const {
mtkleinffa901a2015-03-16 10:38:07 -07001013 SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(fPath.c_str()));
1014 if (!stream) {
1015 return SkISize::Make(0,0);
1016 }
1017 SkPictInfo info;
1018 if (!SkPicture::InternalOnly_StreamIsSKP(stream, &info)) {
1019 return SkISize::Make(0,0);
1020 }
1021 SkRect viewport = kSKPViewport;
1022 if (!viewport.intersect(info.fCullRect)) {
1023 return SkISize::Make(0,0);
1024 }
1025 return viewport.roundOut().size();
mtklein748ca3b2015-01-15 10:56:12 -08001026}
1027
1028Name SKPSrc::name() const { return SkOSPath::Basename(fPath.c_str()); }
1029
1030/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
fmalitaa2b9fdf2016-08-03 19:53:36 -07001031#if defined(SK_XML)
1032// Should we try to use the SVG intrinsic size instead?
1033static const SkSize kSVGSize = SkSize::Make(1000, 1000);
1034
1035SVGSrc::SVGSrc(Path path) : fPath(path) {}
1036
1037Error SVGSrc::draw(SkCanvas* canvas) const {
1038 SkFILEStream stream(fPath.c_str());
1039 if (!stream.isValid()) {
1040 return SkStringPrintf("Unable to open file: %s", fPath.c_str());
1041 }
1042
1043 sk_sp<SkSVGDOM> dom = SkSVGDOM::MakeFromStream(stream, kSVGSize);
1044 if (!dom) {
1045 return SkStringPrintf("Unable to parse file: %s", fPath.c_str());
1046 }
1047
1048 dom->render(canvas);
1049
1050 return "";
1051}
1052
1053SkISize SVGSrc::size() const {
1054 return kSVGSize.toRound();
1055}
1056
1057Name SVGSrc::name() const { return SkOSPath::Basename(fPath.c_str()); }
1058
fmalita179d8852016-08-16 14:23:29 -07001059bool SVGSrc::veto(SinkFlags flags) const {
1060 // No need to test to non-(raster||gpu) or indirect backends.
1061 bool type_ok = flags.type == SinkFlags::kRaster
1062 || flags.type == SinkFlags::kGPU;
1063
1064 return !type_ok || flags.approach != SinkFlags::kDirect;
1065}
1066
fmalitaa2b9fdf2016-08-03 19:53:36 -07001067#endif // defined(SK_XML)
1068/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
mtklein748ca3b2015-01-15 10:56:12 -08001069
halcanary45420a92016-06-02 12:41:14 -07001070MSKPSrc::MSKPSrc(Path path) : fPath(path) {
1071 std::unique_ptr<SkStreamAsset> stream(SkStream::NewFromFile(fPath.c_str()));
1072 (void)fReader.init(stream.get());
1073}
1074
1075int MSKPSrc::pageCount() const { return fReader.pageCount(); }
1076
1077SkISize MSKPSrc::size() const { return this->size(0); }
1078SkISize MSKPSrc::size(int i) const { return fReader.pageSize(i).toCeil(); }
1079
1080Error MSKPSrc::draw(SkCanvas* c) const { return this->draw(0, c); }
1081Error MSKPSrc::draw(int i, SkCanvas* canvas) const {
1082 std::unique_ptr<SkStreamAsset> stream(SkStream::NewFromFile(fPath.c_str()));
1083 if (!stream) {
1084 return SkStringPrintf("Unable to open file: %s", fPath.c_str());
1085 }
1086 if (fReader.pageCount() == 0) {
1087 return SkStringPrintf("Unable to parse MultiPictureDocument file: %s", fPath.c_str());
1088 }
1089 if (i >= fReader.pageCount()) {
1090 return SkStringPrintf("MultiPictureDocument page number out of range: %d", i);
1091 }
1092 sk_sp<SkPicture> page = fReader.readPage(stream.get(), i);
1093 if (!page) {
1094 return SkStringPrintf("SkMultiPictureDocumentReader failed on page %d: %s",
1095 i, fPath.c_str());
1096 }
1097 canvas->drawPicture(page);
1098 return "";
1099}
1100
1101Name MSKPSrc::name() const { return SkOSPath::Basename(fPath.c_str()); }
1102
1103/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1104
mtkleinad66f9b2015-02-13 15:11:10 -08001105Error NullSink::draw(const Src& src, SkBitmap*, SkWStream*, SkString*) const {
1106 SkAutoTDelete<SkCanvas> canvas(SkCreateNullCanvas());
1107 return src.draw(canvas);
1108}
1109
1110/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1111
mtkleinb9eb4ac2015-02-02 18:26:03 -08001112DEFINE_bool(gpuStats, false, "Append GPU stats to the log for each GPU task?");
1113
bsalomon85b4b532016-04-05 11:06:27 -07001114GPUSink::GPUSink(GrContextFactory::ContextType ct,
1115 GrContextFactory::ContextOptions options,
mtklein82d28432015-01-15 12:46:02 -08001116 int samples,
bsalomonafcd7cd2015-08-31 12:39:41 -07001117 bool diText,
brianosmand93c1202016-03-10 07:49:08 -08001118 SkColorType colorType,
brianosmanb109b8c2016-06-16 13:03:24 -07001119 sk_sp<SkColorSpace> colorSpace,
mtklein82d28432015-01-15 12:46:02 -08001120 bool threaded)
mtklein748ca3b2015-01-15 10:56:12 -08001121 : fContextType(ct)
kkinnunen5219fd92015-12-10 06:28:13 -08001122 , fContextOptions(options)
mtklein748ca3b2015-01-15 10:56:12 -08001123 , fSampleCount(samples)
bsalomonafcd7cd2015-08-31 12:39:41 -07001124 , fUseDIText(diText)
brianosmand93c1202016-03-10 07:49:08 -08001125 , fColorType(colorType)
brianosmanb109b8c2016-06-16 13:03:24 -07001126 , fColorSpace(std::move(colorSpace))
mtklein82d28432015-01-15 12:46:02 -08001127 , fThreaded(threaded) {}
mtklein748ca3b2015-01-15 10:56:12 -08001128
joshualitt5f5a8d72015-02-25 14:09:45 -08001129void PreAbandonGpuContextErrorHandler(SkError, void*) {}
1130
bsalomon648c6962015-10-23 09:06:59 -07001131DEFINE_bool(imm, false, "Run gpu configs in immediate mode.");
bsalomon69cfe952015-11-30 13:27:47 -08001132DEFINE_bool(batchClip, false, "Clip each GrBatch to its device bounds for testing.");
bsalomon6dea83f2015-12-03 12:58:06 -08001133DEFINE_bool(batchBounds, false, "Draw a wireframe bounds of each GrBatch.");
bsalomon489147c2015-12-14 12:13:09 -08001134DEFINE_int32(batchLookback, -1, "Maximum GrBatch lookback for combining, negative means default.");
bsalomonaecc0182016-03-07 11:50:44 -08001135DEFINE_int32(batchLookahead, -1, "Maximum GrBatch lookahead for combining, negative means "
1136 "default.");
bsalomon648c6962015-10-23 09:06:59 -07001137
mtkleinb9eb4ac2015-02-02 18:26:03 -08001138Error GPUSink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString* log) const {
kkinnunen5219fd92015-12-10 06:28:13 -08001139 GrContextOptions grOptions;
bsalomon489147c2015-12-14 12:13:09 -08001140 grOptions.fImmediateMode = FLAGS_imm;
1141 grOptions.fClipBatchToBounds = FLAGS_batchClip;
1142 grOptions.fDrawBatchBounds = FLAGS_batchBounds;
1143 grOptions.fMaxBatchLookback = FLAGS_batchLookback;
bsalomonaecc0182016-03-07 11:50:44 -08001144 grOptions.fMaxBatchLookahead = FLAGS_batchLookahead;
kkinnunen64492c42015-12-08 01:24:40 -08001145
kkinnunen5219fd92015-12-10 06:28:13 -08001146 src.modifyGrContextOptions(&grOptions);
1147
1148 GrContextFactory factory(grOptions);
mtkleinf4ba3212015-01-28 15:32:24 -08001149 const SkISize size = src.size();
mtklein748ca3b2015-01-15 10:56:12 -08001150 const SkImageInfo info =
brianosmand93c1202016-03-10 07:49:08 -08001151 SkImageInfo::Make(size.width(), size.height(), fColorType,
brianosmanb109b8c2016-06-16 13:03:24 -07001152 kPremul_SkAlphaType, fColorSpace);
msarett13a036b2016-02-08 09:10:47 -08001153#if SK_SUPPORT_GPU
bsalomon8b7451a2016-05-11 06:33:06 -07001154 GrContext* context = factory.getContextInfo(fContextType, fContextOptions).grContext();
1155 const int maxDimension = context->caps()->maxTextureSize();
msarett13a036b2016-02-08 09:10:47 -08001156 if (maxDimension < SkTMax(size.width(), size.height())) {
1157 return Error::Nonfatal("Src too large to create a texture.\n");
1158 }
1159#endif
1160
reede8f30622016-03-23 18:59:25 -07001161 auto surface(
kkinnunen3e980c32015-12-23 01:33:00 -08001162 NewGpuSurface(&factory, fContextType, fContextOptions, info, fSampleCount, fUseDIText));
mtklein748ca3b2015-01-15 10:56:12 -08001163 if (!surface) {
1164 return "Could not create a surface.";
1165 }
joshualitt5f5a8d72015-02-25 14:09:45 -08001166 if (FLAGS_preAbandonGpuContext) {
halcanary96fcdcc2015-08-27 07:41:13 -07001167 SkSetErrorCallback(&PreAbandonGpuContextErrorHandler, nullptr);
joshualitt5f5a8d72015-02-25 14:09:45 -08001168 factory.abandonContexts();
1169 }
mtklein748ca3b2015-01-15 10:56:12 -08001170 SkCanvas* canvas = surface->getCanvas();
1171 Error err = src.draw(canvas);
1172 if (!err.isEmpty()) {
1173 return err;
1174 }
1175 canvas->flush();
mtkleinb9eb4ac2015-02-02 18:26:03 -08001176 if (FLAGS_gpuStats) {
1177 canvas->getGrContext()->dumpCacheStats(log);
1178 canvas->getGrContext()->dumpGpuStats(log);
1179 }
mtklein748ca3b2015-01-15 10:56:12 -08001180 dst->allocPixels(info);
joshualitt5f5a8d72015-02-25 14:09:45 -08001181 canvas->readPixels(dst, 0, 0);
mtklein55e88b22015-01-21 15:50:13 -08001182 if (FLAGS_abandonGpuContext) {
1183 factory.abandonContexts();
bsalomon6e2aad42016-04-01 11:54:31 -07001184 } else if (FLAGS_releaseAndAbandonGpuContext) {
1185 factory.releaseResourcesAndAbandonContexts();
mtklein55e88b22015-01-21 15:50:13 -08001186 }
mtklein748ca3b2015-01-15 10:56:12 -08001187 return "";
1188}
1189
1190/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1191
halcanary47ef4d52015-03-03 09:13:09 -08001192static Error draw_skdocument(const Src& src, SkDocument* doc, SkWStream* dst) {
halcanary4ba051c2016-03-10 10:31:53 -08001193 if (src.size().isEmpty()) {
1194 return "Source has empty dimensions";
1195 }
halcanary47ef4d52015-03-03 09:13:09 -08001196 SkASSERT(doc);
halcanary45420a92016-06-02 12:41:14 -07001197 int pageCount = src.pageCount();
1198 for (int i = 0; i < pageCount; ++i) {
1199 int width = src.size(i).width(), height = src.size(i).height();
halcanary7e798182015-04-14 14:06:18 -07001200 SkCanvas* canvas =
1201 doc->beginPage(SkIntToScalar(width), SkIntToScalar(height));
1202 if (!canvas) {
halcanary96fcdcc2015-08-27 07:41:13 -07001203 return "SkDocument::beginPage(w,h) returned nullptr";
halcanary7e798182015-04-14 14:06:18 -07001204 }
halcanary45420a92016-06-02 12:41:14 -07001205 Error err = src.draw(i, canvas);
halcanary7e798182015-04-14 14:06:18 -07001206 if (!err.isEmpty()) {
1207 return err;
1208 }
1209 doc->endPage();
mtklein748ca3b2015-01-15 10:56:12 -08001210 }
halcanary7e798182015-04-14 14:06:18 -07001211 if (!doc->close()) {
1212 return "SkDocument::close() returned false";
1213 }
halcanaryfd4a9932015-01-28 11:45:58 -08001214 dst->flush();
mtklein748ca3b2015-01-15 10:56:12 -08001215 return "";
1216}
1217
halcanary47ef4d52015-03-03 09:13:09 -08001218Error PDFSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
halcanary4b656662016-04-27 07:45:18 -07001219 SkDocument::PDFMetadata metadata;
1220 metadata.fTitle = src.name();
1221 metadata.fSubject = "rendering correctness test";
1222 metadata.fCreator = "Skia/DM";
1223 sk_sp<SkDocument> doc = SkDocument::MakePDF(dst, SK_ScalarDefaultRasterDPI,
1224 metadata, nullptr, fPDFA);
halcanary47ef4d52015-03-03 09:13:09 -08001225 if (!doc) {
halcanary4b656662016-04-27 07:45:18 -07001226 return "SkDocument::MakePDF() returned nullptr";
halcanary47ef4d52015-03-03 09:13:09 -08001227 }
1228 return draw_skdocument(src, doc.get(), dst);
1229}
1230
1231/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1232
1233XPSSink::XPSSink() {}
1234
1235Error XPSSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
halcanary4b656662016-04-27 07:45:18 -07001236 sk_sp<SkDocument> doc(SkDocument::MakeXPS(dst));
halcanary47ef4d52015-03-03 09:13:09 -08001237 if (!doc) {
halcanary4b656662016-04-27 07:45:18 -07001238 return "SkDocument::MakeXPS() returned nullptr";
halcanary47ef4d52015-03-03 09:13:09 -08001239 }
1240 return draw_skdocument(src, doc.get(), dst);
1241}
mtklein748ca3b2015-01-15 10:56:12 -08001242/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1243
mtklein9c3f17d2015-01-28 11:35:18 -08001244SKPSink::SKPSink() {}
1245
mtkleinb9eb4ac2015-02-02 18:26:03 -08001246Error SKPSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
mtklein9c3f17d2015-01-28 11:35:18 -08001247 SkSize size;
1248 size = src.size();
1249 SkPictureRecorder recorder;
1250 Error err = src.draw(recorder.beginRecording(size.width(), size.height()));
1251 if (!err.isEmpty()) {
1252 return err;
1253 }
reedca2622b2016-03-18 07:25:55 -07001254 recorder.finishRecordingAsPicture()->serialize(dst);
mtklein9c3f17d2015-01-28 11:35:18 -08001255 return "";
1256}
1257
1258/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1259
mtklein8a4527e2015-01-31 20:00:58 -08001260SVGSink::SVGSink() {}
1261
mtkleinb9eb4ac2015-02-02 18:26:03 -08001262Error SVGSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
fmalita718df0a2016-07-15 10:33:29 -07001263#if defined(SK_XML)
halcanary385fe4d2015-08-26 13:07:48 -07001264 SkAutoTDelete<SkXMLWriter> xmlWriter(new SkXMLStreamWriter(dst));
fmalita2aafe6f2015-02-06 12:51:10 -08001265 SkAutoTUnref<SkCanvas> canvas(SkSVGCanvas::Create(
1266 SkRect::MakeWH(SkIntToScalar(src.size().width()), SkIntToScalar(src.size().height())),
1267 xmlWriter));
1268 return src.draw(canvas);
fmalita718df0a2016-07-15 10:33:29 -07001269#else
1270 return Error("SVG sink is disabled.");
1271#endif // SK_XML
mtklein8a4527e2015-01-31 20:00:58 -08001272}
1273
1274/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1275
brianosmanb109b8c2016-06-16 13:03:24 -07001276RasterSink::RasterSink(SkColorType colorType, sk_sp<SkColorSpace> colorSpace)
mtklein27c3fdd2016-02-26 14:43:21 -08001277 : fColorType(colorType)
brianosmanb109b8c2016-06-16 13:03:24 -07001278 , fColorSpace(std::move(colorSpace)) {}
mtklein748ca3b2015-01-15 10:56:12 -08001279
mtkleinb9eb4ac2015-02-02 18:26:03 -08001280Error RasterSink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString*) const {
mtkleinf4ba3212015-01-28 15:32:24 -08001281 const SkISize size = src.size();
mtklein748ca3b2015-01-15 10:56:12 -08001282 // If there's an appropriate alpha type for this color type, use it, otherwise use premul.
1283 SkAlphaType alphaType = kPremul_SkAlphaType;
1284 (void)SkColorTypeValidateAlphaType(fColorType, alphaType, &alphaType);
1285
mtkleinc8be09a2016-01-04 18:56:57 -08001286 SkMallocPixelRef::ZeroedPRFactory factory;
mtklein27c3fdd2016-02-26 14:43:21 -08001287 dst->allocPixels(SkImageInfo::Make(size.width(), size.height(),
brianosmanb109b8c2016-06-16 13:03:24 -07001288 fColorType, alphaType, fColorSpace),
mtkleinc8be09a2016-01-04 18:56:57 -08001289 &factory,
1290 nullptr/*colortable*/);
mtklein748ca3b2015-01-15 10:56:12 -08001291 SkCanvas canvas(*dst);
1292 return src.draw(&canvas);
1293}
1294
1295/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1296
mtkleina16e69e2015-05-05 11:38:45 -07001297// Handy for front-patching a Src. Do whatever up-front work you need, then call draw_to_canvas(),
mtkleine44b5082015-05-07 10:53:34 -07001298// passing the Sink draw() arguments, a size, and a function draws into an SkCanvas.
mtkleina16e69e2015-05-05 11:38:45 -07001299// Several examples below.
1300
mtkleincbf89782016-02-19 14:27:14 -08001301template <typename Fn>
msarett62d3b102015-12-10 15:14:27 -08001302static Error draw_to_canvas(Sink* sink, SkBitmap* bitmap, SkWStream* stream, SkString* log,
mtkleincbf89782016-02-19 14:27:14 -08001303 SkISize size, const Fn& draw) {
mtkleina16e69e2015-05-05 11:38:45 -07001304 class ProxySrc : public Src {
1305 public:
mtkleincbf89782016-02-19 14:27:14 -08001306 ProxySrc(SkISize size, const Fn& draw) : fSize(size), fDraw(draw) {}
mtkleina16e69e2015-05-05 11:38:45 -07001307 Error draw(SkCanvas* canvas) const override { return fDraw(canvas); }
halcanaryb4a7f142016-03-30 08:31:27 -07001308 Name name() const override { return "ProxySrc"; }
1309 SkISize size() const override { return fSize; }
mtkleina16e69e2015-05-05 11:38:45 -07001310 private:
mtkleincbf89782016-02-19 14:27:14 -08001311 SkISize fSize;
1312 const Fn& fDraw;
mtkleina16e69e2015-05-05 11:38:45 -07001313 };
msarett62d3b102015-12-10 15:14:27 -08001314 return sink->draw(ProxySrc(size, draw), bitmap, stream, log);
mtkleina16e69e2015-05-05 11:38:45 -07001315}
1316
1317/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1318
mtklein4a34ecb2016-01-08 10:19:35 -08001319DEFINE_bool(check, true, "If true, have most Via- modes fail if they affect the output.");
1320
1321// Is *bitmap identical to what you get drawing src into sink?
1322static Error check_against_reference(const SkBitmap* bitmap, const Src& src, Sink* sink) {
1323 // We can only check raster outputs.
1324 // (Non-raster outputs like .pdf, .skp, .svg may differ but still draw identically.)
1325 if (FLAGS_check && bitmap) {
1326 SkBitmap reference;
1327 SkString log;
halcanaryb4a7f142016-03-30 08:31:27 -07001328 SkDynamicMemoryWStream wStream;
1329 Error err = sink->draw(src, &reference, &wStream, &log);
mtklein4a34ecb2016-01-08 10:19:35 -08001330 // If we can draw into this Sink via some pipeline, we should be able to draw directly.
1331 SkASSERT(err.isEmpty());
1332 if (!err.isEmpty()) {
1333 return err;
1334 }
1335 // The dimensions are a property of the Src only, and so should be identical.
1336 SkASSERT(reference.getSize() == bitmap->getSize());
1337 if (reference.getSize() != bitmap->getSize()) {
1338 return "Dimensions don't match reference";
1339 }
1340 // All SkBitmaps in DM are pre-locked and tight, so this comparison is easy.
1341 if (0 != memcmp(reference.getPixels(), bitmap->getPixels(), reference.getSize())) {
1342 return "Pixels don't match reference";
1343 }
1344 }
1345 return "";
1346}
1347
1348/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1349
mtkleind603b222015-02-17 11:13:33 -08001350static SkISize auto_compute_translate(SkMatrix* matrix, int srcW, int srcH) {
1351 SkRect bounds = SkRect::MakeIWH(srcW, srcH);
1352 matrix->mapRect(&bounds);
1353 matrix->postTranslate(-bounds.x(), -bounds.y());
1354 return SkISize::Make(SkScalarRoundToInt(bounds.width()), SkScalarRoundToInt(bounds.height()));
1355}
1356
msarett62d3b102015-12-10 15:14:27 -08001357ViaMatrix::ViaMatrix(SkMatrix matrix, Sink* sink) : Via(sink), fMatrix(matrix) {}
mtklein748ca3b2015-01-15 10:56:12 -08001358
mtkleinb9eb4ac2015-02-02 18:26:03 -08001359Error ViaMatrix::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
mtkleina16e69e2015-05-05 11:38:45 -07001360 SkMatrix matrix = fMatrix;
1361 SkISize size = auto_compute_translate(&matrix, src.size().width(), src.size().height());
msarett62d3b102015-12-10 15:14:27 -08001362 return draw_to_canvas(fSink, bitmap, stream, log, size, [&](SkCanvas* canvas) {
mtkleina16e69e2015-05-05 11:38:45 -07001363 canvas->concat(matrix);
1364 return src.draw(canvas);
1365 });
mtklein748ca3b2015-01-15 10:56:12 -08001366}
1367
mtkleind603b222015-02-17 11:13:33 -08001368// Undoes any flip or 90 degree rotate without changing the scale of the bitmap.
1369// This should be pixel-preserving.
msarett62d3b102015-12-10 15:14:27 -08001370ViaUpright::ViaUpright(SkMatrix matrix, Sink* sink) : Via(sink), fMatrix(matrix) {}
mtkleind603b222015-02-17 11:13:33 -08001371
1372Error ViaUpright::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
1373 Error err = fSink->draw(src, bitmap, stream, log);
1374 if (!err.isEmpty()) {
1375 return err;
1376 }
1377
1378 SkMatrix inverse;
1379 if (!fMatrix.rectStaysRect() || !fMatrix.invert(&inverse)) {
1380 return "Cannot upright --matrix.";
1381 }
1382 SkMatrix upright = SkMatrix::I();
1383 upright.setScaleX(SkScalarSignAsScalar(inverse.getScaleX()));
1384 upright.setScaleY(SkScalarSignAsScalar(inverse.getScaleY()));
1385 upright.setSkewX(SkScalarSignAsScalar(inverse.getSkewX()));
1386 upright.setSkewY(SkScalarSignAsScalar(inverse.getSkewY()));
1387
1388 SkBitmap uprighted;
1389 SkISize size = auto_compute_translate(&upright, bitmap->width(), bitmap->height());
1390 uprighted.allocPixels(bitmap->info().makeWH(size.width(), size.height()));
1391
1392 SkCanvas canvas(uprighted);
1393 canvas.concat(upright);
1394 SkPaint paint;
1395 paint.setXfermodeMode(SkXfermode::kSrc_Mode);
1396 canvas.drawBitmap(*bitmap, 0, 0, &paint);
1397
1398 *bitmap = uprighted;
1399 bitmap->lockPixels();
1400 return "";
1401}
1402
mtklein748ca3b2015-01-15 10:56:12 -08001403/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1404
mtkleina16e69e2015-05-05 11:38:45 -07001405Error ViaSerialization::draw(
1406 const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
mtklein748ca3b2015-01-15 10:56:12 -08001407 // Record our Src into a picture.
mtkleina16e69e2015-05-05 11:38:45 -07001408 auto size = src.size();
mtklein748ca3b2015-01-15 10:56:12 -08001409 SkPictureRecorder recorder;
mtkleina16e69e2015-05-05 11:38:45 -07001410 Error err = src.draw(recorder.beginRecording(SkIntToScalar(size.width()),
1411 SkIntToScalar(size.height())));
mtklein748ca3b2015-01-15 10:56:12 -08001412 if (!err.isEmpty()) {
1413 return err;
1414 }
reedca2622b2016-03-18 07:25:55 -07001415 sk_sp<SkPicture> pic(recorder.finishRecordingAsPicture());
mtklein748ca3b2015-01-15 10:56:12 -08001416
1417 // Serialize it and then deserialize it.
1418 SkDynamicMemoryWStream wStream;
1419 pic->serialize(&wStream);
scroggoa1193e42015-01-21 12:09:53 -08001420 SkAutoTDelete<SkStream> rStream(wStream.detachAsStream());
reedca2622b2016-03-18 07:25:55 -07001421 sk_sp<SkPicture> deserialized(SkPicture::MakeFromStream(rStream));
mtklein748ca3b2015-01-15 10:56:12 -08001422
msarett62d3b102015-12-10 15:14:27 -08001423 return draw_to_canvas(fSink, bitmap, stream, log, size, [&](SkCanvas* canvas) {
mtkleina16e69e2015-05-05 11:38:45 -07001424 canvas->drawPicture(deserialized);
mtklein4a34ecb2016-01-08 10:19:35 -08001425 return check_against_reference(bitmap, src, fSink);
mtkleina16e69e2015-05-05 11:38:45 -07001426 });
mtklein748ca3b2015-01-15 10:56:12 -08001427}
1428
1429/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1430
msarett62d3b102015-12-10 15:14:27 -08001431ViaTiles::ViaTiles(int w, int h, SkBBHFactory* factory, Sink* sink)
1432 : Via(sink)
mtklein78829242015-05-06 07:54:07 -07001433 , fW(w)
mtklein748ca3b2015-01-15 10:56:12 -08001434 , fH(h)
mtklein78829242015-05-06 07:54:07 -07001435 , fFactory(factory) {}
mtklein748ca3b2015-01-15 10:56:12 -08001436
mtkleinb9eb4ac2015-02-02 18:26:03 -08001437Error ViaTiles::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
mtkleina16e69e2015-05-05 11:38:45 -07001438 auto size = src.size();
mtklein748ca3b2015-01-15 10:56:12 -08001439 SkPictureRecorder recorder;
mtkleina16e69e2015-05-05 11:38:45 -07001440 Error err = src.draw(recorder.beginRecording(SkIntToScalar(size.width()),
1441 SkIntToScalar(size.height()),
1442 fFactory.get()));
mtklein748ca3b2015-01-15 10:56:12 -08001443 if (!err.isEmpty()) {
1444 return err;
1445 }
reedca2622b2016-03-18 07:25:55 -07001446 sk_sp<SkPicture> pic(recorder.finishRecordingAsPicture());
mtklein748ca3b2015-01-15 10:56:12 -08001447
msarett62d3b102015-12-10 15:14:27 -08001448 return draw_to_canvas(fSink, bitmap, stream, log, src.size(), [&](SkCanvas* canvas) {
mtkleina16e69e2015-05-05 11:38:45 -07001449 const int xTiles = (size.width() + fW - 1) / fW,
1450 yTiles = (size.height() + fH - 1) / fH;
1451 SkMultiPictureDraw mpd(xTiles*yTiles);
reede8f30622016-03-23 18:59:25 -07001452 SkTArray<sk_sp<SkSurface>> surfaces;
1453// surfaces.setReserve(xTiles*yTiles);
mtklein748ca3b2015-01-15 10:56:12 -08001454
mtkleina16e69e2015-05-05 11:38:45 -07001455 SkImageInfo info = canvas->imageInfo().makeWH(fW, fH);
1456 for (int j = 0; j < yTiles; j++) {
1457 for (int i = 0; i < xTiles; i++) {
1458 // This lets our ultimate Sink determine the best kind of surface.
1459 // E.g., if it's a GpuSink, the surfaces and images are textures.
reede8f30622016-03-23 18:59:25 -07001460 auto s = canvas->makeSurface(info);
mtkleina16e69e2015-05-05 11:38:45 -07001461 if (!s) {
reede8f30622016-03-23 18:59:25 -07001462 s = SkSurface::MakeRaster(info); // Some canvases can't create surfaces.
mtklein748ca3b2015-01-15 10:56:12 -08001463 }
reede8f30622016-03-23 18:59:25 -07001464 surfaces.push_back(s);
mtkleina16e69e2015-05-05 11:38:45 -07001465 SkCanvas* c = s->getCanvas();
1466 c->translate(SkIntToScalar(-i * fW),
1467 SkIntToScalar(-j * fH)); // Line up the canvas with this tile.
reedca2622b2016-03-18 07:25:55 -07001468 mpd.add(c, pic.get());
mtklein748ca3b2015-01-15 10:56:12 -08001469 }
mtklein748ca3b2015-01-15 10:56:12 -08001470 }
mtkleina16e69e2015-05-05 11:38:45 -07001471 mpd.draw();
1472 for (int j = 0; j < yTiles; j++) {
1473 for (int i = 0; i < xTiles; i++) {
reed9ce9d672016-03-17 10:51:11 -07001474 sk_sp<SkImage> image(surfaces[i+xTiles*j]->makeImageSnapshot());
mtkleina16e69e2015-05-05 11:38:45 -07001475 canvas->drawImage(image, SkIntToScalar(i*fW), SkIntToScalar(j*fH));
1476 }
1477 }
mtkleina16e69e2015-05-05 11:38:45 -07001478 return "";
1479 });
mtklein748ca3b2015-01-15 10:56:12 -08001480}
1481
mtkleinb7e8d692015-04-07 08:30:32 -07001482/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1483
mtklein4a34ecb2016-01-08 10:19:35 -08001484Error ViaPicture::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
1485 auto size = src.size();
1486 return draw_to_canvas(fSink, bitmap, stream, log, size, [&](SkCanvas* canvas) -> Error {
1487 SkPictureRecorder recorder;
reedca2622b2016-03-18 07:25:55 -07001488 sk_sp<SkPicture> pic;
mtklein4a34ecb2016-01-08 10:19:35 -08001489 Error err = src.draw(recorder.beginRecording(SkIntToScalar(size.width()),
1490 SkIntToScalar(size.height())));
1491 if (!err.isEmpty()) {
1492 return err;
1493 }
reedca2622b2016-03-18 07:25:55 -07001494 pic = recorder.finishRecordingAsPicture();
mtklein4a34ecb2016-01-08 10:19:35 -08001495 canvas->drawPicture(pic);
1496 return check_against_reference(bitmap, src, fSink);
1497 });
1498}
1499
1500/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1501
reedbabc3de2016-07-08 08:43:27 -07001502Error ViaDefer::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
1503 auto size = src.size();
1504 return draw_to_canvas(fSink, bitmap, stream, log, size, [&](SkCanvas* canvas) -> Error {
1505 SkDeferredCanvas deferred(canvas);
1506 return src.draw(&deferred);
1507 });
1508}
1509
1510/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1511
mtkleinb7e8d692015-04-07 08:30:32 -07001512// Draw the Src into two pictures, then draw the second picture into the wrapped Sink.
1513// This tests that any shortcuts we may take while recording that second picture are legal.
1514Error ViaSecondPicture::draw(
1515 const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
mtkleina16e69e2015-05-05 11:38:45 -07001516 auto size = src.size();
msarett62d3b102015-12-10 15:14:27 -08001517 return draw_to_canvas(fSink, bitmap, stream, log, size, [&](SkCanvas* canvas) -> Error {
mtkleina16e69e2015-05-05 11:38:45 -07001518 SkPictureRecorder recorder;
reedca2622b2016-03-18 07:25:55 -07001519 sk_sp<SkPicture> pic;
mtkleina16e69e2015-05-05 11:38:45 -07001520 for (int i = 0; i < 2; i++) {
1521 Error err = src.draw(recorder.beginRecording(SkIntToScalar(size.width()),
1522 SkIntToScalar(size.height())));
1523 if (!err.isEmpty()) {
1524 return err;
mtkleinb7e8d692015-04-07 08:30:32 -07001525 }
reedca2622b2016-03-18 07:25:55 -07001526 pic = recorder.finishRecordingAsPicture();
mtkleinb7e8d692015-04-07 08:30:32 -07001527 }
mtkleina16e69e2015-05-05 11:38:45 -07001528 canvas->drawPicture(pic);
mtklein4a34ecb2016-01-08 10:19:35 -08001529 return check_against_reference(bitmap, src, fSink);
mtkleina16e69e2015-05-05 11:38:45 -07001530 });
mtkleinb7e8d692015-04-07 08:30:32 -07001531}
1532
mtkleind31c13d2015-05-05 12:59:56 -07001533/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1534
mtklein6fbf4b32015-05-06 11:35:40 -07001535// Draw the Src twice. This can help exercise caching.
1536Error ViaTwice::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
msarett62d3b102015-12-10 15:14:27 -08001537 return draw_to_canvas(fSink, bitmap, stream, log, src.size(), [&](SkCanvas* canvas) -> Error {
mtklein6fbf4b32015-05-06 11:35:40 -07001538 for (int i = 0; i < 2; i++) {
1539 SkAutoCanvasRestore acr(canvas, true/*save now*/);
1540 canvas->clear(SK_ColorTRANSPARENT);
1541 Error err = src.draw(canvas);
1542 if (err.isEmpty()) {
1543 return err;
1544 }
1545 }
mtklein4a34ecb2016-01-08 10:19:35 -08001546 return check_against_reference(bitmap, src, fSink);
mtklein6fbf4b32015-05-06 11:35:40 -07001547 });
1548}
1549
1550/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1551
mtkleind31c13d2015-05-05 12:59:56 -07001552// This is like SkRecords::Draw, in that it plays back SkRecords ops into a Canvas.
1553// Unlike SkRecords::Draw, it builds a single-op sub-picture out of each Draw-type op.
1554// This is an only-slightly-exaggerated simluation of Blink's Slimming Paint pictures.
1555struct DrawsAsSingletonPictures {
1556 SkCanvas* fCanvas;
mtkleind2baa902015-07-07 09:43:28 -07001557 const SkDrawableList& fDrawables;
mtklein11064df2016-04-06 15:01:57 -07001558 SkRect fBounds;
mtkleind31c13d2015-05-05 12:59:56 -07001559
mtkleind31c13d2015-05-05 12:59:56 -07001560 template <typename T>
1561 void draw(const T& op, SkCanvas* canvas) {
1562 // We must pass SkMatrix::I() as our initial matrix.
1563 // By default SkRecords::Draw() uses the canvas' matrix as its initial matrix,
1564 // which would have the funky effect of applying transforms over and over.
mtkleind2baa902015-07-07 09:43:28 -07001565 SkRecords::Draw d(canvas, nullptr, fDrawables.begin(), fDrawables.count(), &SkMatrix::I());
1566 d(op);
mtkleind31c13d2015-05-05 12:59:56 -07001567 }
1568
mtklein449d9b72015-09-28 10:33:02 -07001569 // Draws get their own picture.
mtkleind31c13d2015-05-05 12:59:56 -07001570 template <typename T>
mtklein449d9b72015-09-28 10:33:02 -07001571 SK_WHEN(T::kTags & SkRecords::kDraw_Tag, void) operator()(const T& op) {
mtkleind31c13d2015-05-05 12:59:56 -07001572 SkPictureRecorder rec;
mtklein11064df2016-04-06 15:01:57 -07001573 this->draw(op, rec.beginRecording(fBounds));
reedca2622b2016-03-18 07:25:55 -07001574 sk_sp<SkPicture> pic(rec.finishRecordingAsPicture());
mtkleind31c13d2015-05-05 12:59:56 -07001575 fCanvas->drawPicture(pic);
1576 }
1577
mtklein449d9b72015-09-28 10:33:02 -07001578 // We'll just issue non-draws directly.
mtkleind31c13d2015-05-05 12:59:56 -07001579 template <typename T>
mtklein449d9b72015-09-28 10:33:02 -07001580 skstd::enable_if_t<!(T::kTags & SkRecords::kDraw_Tag), void> operator()(const T& op) {
1581 this->draw(op, fCanvas);
1582 }
mtkleind31c13d2015-05-05 12:59:56 -07001583};
1584
mtkleind31c13d2015-05-05 12:59:56 -07001585// Record Src into a picture, then record it into a macro picture with a sub-picture for each draw.
1586// Then play back that macro picture into our wrapped sink.
1587Error ViaSingletonPictures::draw(
1588 const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
1589 auto size = src.size();
msarett62d3b102015-12-10 15:14:27 -08001590 return draw_to_canvas(fSink, bitmap, stream, log, size, [&](SkCanvas* canvas) -> Error {
mtkleind31c13d2015-05-05 12:59:56 -07001591 // Use low-level (Skia-private) recording APIs so we can read the SkRecord.
1592 SkRecord skr;
1593 SkRecorder recorder(&skr, size.width(), size.height());
1594 Error err = src.draw(&recorder);
1595 if (!err.isEmpty()) {
1596 return err;
1597 }
1598
1599 // Record our macro-picture, with each draw op as its own sub-picture.
1600 SkPictureRecorder macroRec;
1601 SkCanvas* macroCanvas = macroRec.beginRecording(SkIntToScalar(size.width()),
1602 SkIntToScalar(size.height()));
mtkleind2baa902015-07-07 09:43:28 -07001603
1604 SkAutoTDelete<SkDrawableList> drawables(recorder.detachDrawableList());
1605 const SkDrawableList empty;
1606
1607 DrawsAsSingletonPictures drawsAsSingletonPictures = {
1608 macroCanvas,
1609 drawables ? *drawables : empty,
mtklein11064df2016-04-06 15:01:57 -07001610 SkRect::MakeWH((SkScalar)size.width(), (SkScalar)size.height()),
mtkleind2baa902015-07-07 09:43:28 -07001611 };
mtkleinc6ad06a2015-08-19 09:51:00 -07001612 for (int i = 0; i < skr.count(); i++) {
mtklein343a63d2016-03-22 11:46:53 -07001613 skr.visit(i, drawsAsSingletonPictures);
mtkleind31c13d2015-05-05 12:59:56 -07001614 }
reedca2622b2016-03-18 07:25:55 -07001615 sk_sp<SkPicture> macroPic(macroRec.finishRecordingAsPicture());
mtkleind31c13d2015-05-05 12:59:56 -07001616
1617 canvas->drawPicture(macroPic);
mtklein4a34ecb2016-01-08 10:19:35 -08001618 return check_against_reference(bitmap, src, fSink);
mtkleind31c13d2015-05-05 12:59:56 -07001619 });
1620}
1621
mtklein9c5052f2016-08-06 12:51:51 -07001622/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1623
1624Error ViaLite::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
1625 auto size = src.size();
mtklein8bbbb692016-08-15 12:56:00 -07001626 SkRect bounds = {0,0, (SkScalar)size.width(), (SkScalar)size.height()};
mtklein9c5052f2016-08-06 12:51:51 -07001627 return draw_to_canvas(fSink, bitmap, stream, log, size, [&](SkCanvas* canvas) -> Error {
mtklein8bbbb692016-08-15 12:56:00 -07001628 sk_sp<SkLiteDL> dl = SkLiteDL::New(bounds);
1629
1630 SkLiteRecorder rec;
1631 rec.reset(dl.get());
1632
1633 Error err = src.draw(&rec);
mtklein9c5052f2016-08-06 12:51:51 -07001634 if (!err.isEmpty()) {
1635 return err;
1636 }
mtklein8bbbb692016-08-15 12:56:00 -07001637 dl->draw(canvas);
mtklein03591a72016-08-07 13:35:46 -07001638 return check_against_reference(bitmap, src, fSink);
mtklein9c5052f2016-08-06 12:51:51 -07001639 });
1640}
1641
mtklein748ca3b2015-01-15 10:56:12 -08001642} // namespace DM