blob: e8c33a4c4b0f461fb9cd6e45955289a0d2fa1599 [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"
Hal Canary95e3c052017-01-11 12:44:43 -050011#include "SkAutoMalloc.h"
scroggof24f2242015-03-03 08:59:20 -080012#include "SkCodec.h"
msarettb714fb02016-01-22 14:46:42 -080013#include "SkCodecImageGenerator.h"
msarett888dc162016-05-23 10:21:17 -070014#include "SkColorSpace.h"
Kevin Lubickc456b732017-01-11 17:21:57 +000015#include "SkColorSpaceXform.h"
Mike Klein841101d2017-03-10 09:55:51 -050016#include "SkColorSpaceXformCanvas.h"
Hal Canary95e3c052017-01-11 12:44:43 -050017#include "SkColorSpace_XYZ.h"
mtkleina16e69e2015-05-05 11:38:45 -070018#include "SkCommonFlags.h"
mtkleinb3e5e4d2015-03-25 13:13:43 -070019#include "SkData.h"
Hal Canary85c7fe82016-10-25 10:33:27 -040020#include "SkDebugCanvas.h"
reedbabc3de2016-07-08 08:43:27 -070021#include "SkDeferredCanvas.h"
mtklein748ca3b2015-01-15 10:56:12 -080022#include "SkDocument.h"
mtkleinb3e5e4d2015-03-25 13:13:43 -070023#include "SkImageGenerator.h"
msarett18976312016-03-09 14:20:58 -080024#include "SkImageGeneratorCG.h"
msarettfc0b6d12016-03-17 13:50:17 -070025#include "SkImageGeneratorWIC.h"
mtklein8bbbb692016-08-15 12:56:00 -070026#include "SkLiteDL.h"
27#include "SkLiteRecorder.h"
mtkleinc8be09a2016-01-04 18:56:57 -080028#include "SkMallocPixelRef.h"
Hal Canary45cde312017-04-03 16:06:42 -040029#include "SkMultiPictureDocumentPriv.h"
mtklein748ca3b2015-01-15 10:56:12 -080030#include "SkMultiPictureDraw.h"
mtkleinad66f9b2015-02-13 15:11:10 -080031#include "SkNullCanvas.h"
mtklein748ca3b2015-01-15 10:56:12 -080032#include "SkOSFile.h"
Ben Wagnerbf111d72016-11-07 18:05:29 -050033#include "SkOSPath.h"
msarett9e9444c2016-02-03 12:39:10 -080034#include "SkOpts.h"
mtkleinffa901a2015-03-16 10:38:07 -070035#include "SkPictureData.h"
mtklein748ca3b2015-01-15 10:56:12 -080036#include "SkPictureRecorder.h"
reed54dc4872016-09-13 08:09:45 -070037#include "SkPipe.h"
mtklein748ca3b2015-01-15 10:56:12 -080038#include "SkRandom.h"
mtkleind31c13d2015-05-05 12:59:56 -070039#include "SkRecordDraw.h"
40#include "SkRecorder.h"
fmalita2aafe6f2015-02-06 12:51:10 -080041#include "SkSVGCanvas.h"
scroggoa1193e42015-01-21 12:09:53 -080042#include "SkStream.h"
Kevin Lubickc456b732017-01-11 17:21:57 +000043#include "SkSwizzler.h"
Hal Canary95e3c052017-01-11 12:44:43 -050044#include "SkTLogic.h"
Kevin Lubickc456b732017-01-11 17:21:57 +000045#include <cmath>
Hal Canary95e3c052017-01-11 12:44:43 -050046#include <functional>
mtklein748ca3b2015-01-15 10:56:12 -080047
msarettfc0b6d12016-03-17 13:50:17 -070048#if defined(SK_BUILD_FOR_WIN)
49 #include "SkAutoCoInitialize.h"
Hal Canary5e221e72017-02-06 09:51:42 -050050 #include "SkHRESULT.h"
51 #include "SkTScopedComPtr.h"
52 #include <XpsObjectModel.h>
msarettfc0b6d12016-03-17 13:50:17 -070053#endif
54
fmalita718df0a2016-07-15 10:33:29 -070055#if defined(SK_XML)
fmalitaa48f0e32016-08-04 06:26:05 -070056 #include "SkSVGDOM.h"
fmalita718df0a2016-07-15 10:33:29 -070057 #include "SkXMLWriter.h"
58#endif
59
halcanary7e798182015-04-14 14:06:18 -070060DEFINE_bool(multiPage, false, "For document-type backends, render the source"
61 " into multiple pages");
scroggo3ac66e92016-02-08 15:09:48 -080062DEFINE_bool(RAW_threading, true, "Allow RAW decodes to run on multiple threads?");
halcanary7e798182015-04-14 14:06:18 -070063
bsalomon3724e572016-03-30 18:56:19 -070064using sk_gpu_test::GrContextFactory;
65
mtklein748ca3b2015-01-15 10:56:12 -080066namespace DM {
67
mtklein748ca3b2015-01-15 10:56:12 -080068GMSrc::GMSrc(skiagm::GMRegistry::Factory factory) : fFactory(factory) {}
69
70Error GMSrc::draw(SkCanvas* canvas) const {
Ben Wagner145dbcd2016-11-03 14:40:50 -040071 std::unique_ptr<skiagm::GM> gm(fFactory(nullptr));
mtklein748ca3b2015-01-15 10:56:12 -080072 canvas->concat(gm->getInitialTransform());
73 gm->draw(canvas);
74 return "";
75}
76
77SkISize GMSrc::size() const {
Ben Wagner145dbcd2016-11-03 14:40:50 -040078 std::unique_ptr<skiagm::GM> gm(fFactory(nullptr));
mtklein748ca3b2015-01-15 10:56:12 -080079 return gm->getISize();
80}
81
82Name GMSrc::name() const {
Ben Wagner145dbcd2016-11-03 14:40:50 -040083 std::unique_ptr<skiagm::GM> gm(fFactory(nullptr));
mtklein748ca3b2015-01-15 10:56:12 -080084 return gm->getName();
85}
86
bsalomon4ee6bd82015-05-27 13:23:23 -070087void GMSrc::modifyGrContextOptions(GrContextOptions* options) const {
Ben Wagner145dbcd2016-11-03 14:40:50 -040088 std::unique_ptr<skiagm::GM> gm(fFactory(nullptr));
bsalomon4ee6bd82015-05-27 13:23:23 -070089 gm->modifyGrContextOptions(options);
90}
91
mtklein748ca3b2015-01-15 10:56:12 -080092/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
93
msarettd1227a72016-05-18 06:23:57 -070094BRDSrc::BRDSrc(Path path, Mode mode, CodecSrc::DstColorType dstColorType, uint32_t sampleSize)
msaretta5783ae2015-09-08 15:35:32 -070095 : fPath(path)
msaretta5783ae2015-09-08 15:35:32 -070096 , fMode(mode)
97 , fDstColorType(dstColorType)
98 , fSampleSize(sampleSize)
99{}
100
101bool BRDSrc::veto(SinkFlags flags) const {
102 // No need to test to non-raster or indirect backends.
103 return flags.type != SinkFlags::kRaster
104 || flags.approach != SinkFlags::kDirect;
105}
106
msarettd1227a72016-05-18 06:23:57 -0700107static SkBitmapRegionDecoder* create_brd(Path path) {
bungeman38d909e2016-08-02 14:40:46 -0700108 sk_sp<SkData> encoded(SkData::MakeFromFileName(path.c_str()));
msaretta5783ae2015-09-08 15:35:32 -0700109 if (!encoded) {
110 return NULL;
111 }
reed42943c82016-09-12 12:01:44 -0700112 return SkBitmapRegionDecoder::Create(encoded, SkBitmapRegionDecoder::kAndroidCodec_Strategy);
msaretta5783ae2015-09-08 15:35:32 -0700113}
114
Matt Sarett334df3a2016-12-15 18:17:33 -0500115static inline void alpha8_to_gray8(SkBitmap* bitmap) {
116 // Android requires kGray8 bitmaps to be tagged as kAlpha8. Here we convert
117 // them back to kGray8 so our test framework can draw them correctly.
118 if (kAlpha_8_SkColorType == bitmap->info().colorType()) {
119 SkImageInfo newInfo = bitmap->info().makeColorType(kGray_8_SkColorType)
120 .makeAlphaType(kOpaque_SkAlphaType);
121 *const_cast<SkImageInfo*>(&bitmap->info()) = newInfo;
122 }
123}
124
msaretta5783ae2015-09-08 15:35:32 -0700125Error BRDSrc::draw(SkCanvas* canvas) const {
126 SkColorType colorType = canvas->imageInfo().colorType();
127 if (kRGB_565_SkColorType == colorType &&
128 CodecSrc::kGetFromCanvas_DstColorType != fDstColorType) {
129 return Error::Nonfatal("Testing non-565 to 565 is uninteresting.");
130 }
131 switch (fDstColorType) {
132 case CodecSrc::kGetFromCanvas_DstColorType:
133 break;
134 case CodecSrc::kIndex8_Always_DstColorType:
135 colorType = kIndex_8_SkColorType;
136 break;
137 case CodecSrc::kGrayscale_Always_DstColorType:
138 colorType = kGray_8_SkColorType;
139 break;
msarett34e0ec42016-04-22 16:27:24 -0700140 default:
141 SkASSERT(false);
142 break;
msaretta5783ae2015-09-08 15:35:32 -0700143 }
144
Ben Wagner145dbcd2016-11-03 14:40:50 -0400145 std::unique_ptr<SkBitmapRegionDecoder> brd(create_brd(fPath));
msaretta5783ae2015-09-08 15:35:32 -0700146 if (nullptr == brd.get()) {
147 return Error::Nonfatal(SkStringPrintf("Could not create brd for %s.", fPath.c_str()));
148 }
149
msarett04965c62015-10-12 10:24:38 -0700150 if (!brd->conversionSupported(colorType)) {
mtklein9b439152015-12-09 13:02:26 -0800151 return Error::Nonfatal("Cannot convert to color type.");
msarett04965c62015-10-12 10:24:38 -0700152 }
153
msaretta5783ae2015-09-08 15:35:32 -0700154 const uint32_t width = brd->width();
155 const uint32_t height = brd->height();
156 // Visually inspecting very small output images is not necessary.
157 if ((width / fSampleSize <= 10 || height / fSampleSize <= 10) && 1 != fSampleSize) {
158 return Error::Nonfatal("Scaling very small images is uninteresting.");
159 }
160 switch (fMode) {
161 case kFullImage_Mode: {
msarett35e5d1b2015-10-27 12:50:25 -0700162 SkBitmap bitmap;
163 if (!brd->decodeRegion(&bitmap, nullptr, SkIRect::MakeXYWH(0, 0, width, height),
Matt Sarett68feef42017-04-11 09:51:32 -0400164 fSampleSize, colorType, false, SkColorSpace::MakeSRGB())) {
mtklein9b439152015-12-09 13:02:26 -0800165 return "Cannot decode (full) region.";
msarett35e5d1b2015-10-27 12:50:25 -0700166 }
Matt Sarett334df3a2016-12-15 18:17:33 -0500167 alpha8_to_gray8(&bitmap);
msarett35e5d1b2015-10-27 12:50:25 -0700168 canvas->drawBitmap(bitmap, 0, 0);
msaretta5783ae2015-09-08 15:35:32 -0700169 return "";
170 }
171 case kDivisor_Mode: {
172 const uint32_t divisor = 2;
173 if (width < divisor || height < divisor) {
mtklein9b439152015-12-09 13:02:26 -0800174 return Error::Nonfatal("Divisor is larger than image dimension.");
msaretta5783ae2015-09-08 15:35:32 -0700175 }
176
177 // Use a border to test subsets that extend outside the image.
178 // We will not allow the border to be larger than the image dimensions. Allowing
179 // these large borders causes off by one errors that indicate a problem with the
180 // test suite, not a problem with the implementation.
181 const uint32_t maxBorder = SkTMin(width, height) / (fSampleSize * divisor);
182 const uint32_t scaledBorder = SkTMin(5u, maxBorder);
183 const uint32_t unscaledBorder = scaledBorder * fSampleSize;
184
185 // We may need to clear the canvas to avoid uninitialized memory.
186 // Assume we are scaling a 780x780 image with sampleSize = 8.
187 // The output image should be 97x97.
188 // Each subset will be 390x390.
189 // Each scaled subset be 48x48.
190 // Four scaled subsets will only fill a 96x96 image.
191 // The bottom row and last column will not be touched.
192 // This is an unfortunate result of our rounding rules when scaling.
193 // Maybe we need to consider testing scaled subsets without trying to
194 // combine them to match the full scaled image? Or maybe this is the
195 // best we can do?
196 canvas->clear(0);
197
198 for (uint32_t x = 0; x < divisor; x++) {
199 for (uint32_t y = 0; y < divisor; y++) {
200 // Calculate the subset dimensions
201 uint32_t subsetWidth = width / divisor;
202 uint32_t subsetHeight = height / divisor;
203 const int left = x * subsetWidth;
204 const int top = y * subsetHeight;
205
206 // Increase the size of the last subset in each row or column, when the
207 // divisor does not divide evenly into the image dimensions
208 subsetWidth += (x + 1 == divisor) ? (width % divisor) : 0;
209 subsetHeight += (y + 1 == divisor) ? (height % divisor) : 0;
210
211 // Increase the size of the subset in order to have a border on each side
212 const int decodeLeft = left - unscaledBorder;
213 const int decodeTop = top - unscaledBorder;
214 const uint32_t decodeWidth = subsetWidth + unscaledBorder * 2;
215 const uint32_t decodeHeight = subsetHeight + unscaledBorder * 2;
msarett35e5d1b2015-10-27 12:50:25 -0700216 SkBitmap bitmap;
217 if (!brd->decodeRegion(&bitmap, nullptr, SkIRect::MakeXYWH(decodeLeft,
Matt Sarett68feef42017-04-11 09:51:32 -0400218 decodeTop, decodeWidth, decodeHeight), fSampleSize, colorType, false,
219 SkColorSpace::MakeSRGB())) {
mtklein9b439152015-12-09 13:02:26 -0800220 return "Cannot decode region.";
msarett35e5d1b2015-10-27 12:50:25 -0700221 }
msaretta5783ae2015-09-08 15:35:32 -0700222
Matt Sarett334df3a2016-12-15 18:17:33 -0500223 alpha8_to_gray8(&bitmap);
msarett35e5d1b2015-10-27 12:50:25 -0700224 canvas->drawBitmapRect(bitmap,
msaretta5783ae2015-09-08 15:35:32 -0700225 SkRect::MakeXYWH((SkScalar) scaledBorder, (SkScalar) scaledBorder,
226 (SkScalar) (subsetWidth / fSampleSize),
227 (SkScalar) (subsetHeight / fSampleSize)),
228 SkRect::MakeXYWH((SkScalar) (left / fSampleSize),
229 (SkScalar) (top / fSampleSize),
230 (SkScalar) (subsetWidth / fSampleSize),
231 (SkScalar) (subsetHeight / fSampleSize)),
232 nullptr);
233 }
234 }
235 return "";
236 }
237 default:
238 SkASSERT(false);
mtklein9b439152015-12-09 13:02:26 -0800239 return "Error: Should not be reached.";
msaretta5783ae2015-09-08 15:35:32 -0700240 }
241}
242
243SkISize BRDSrc::size() const {
Ben Wagner145dbcd2016-11-03 14:40:50 -0400244 std::unique_ptr<SkBitmapRegionDecoder> brd(create_brd(fPath));
msaretta5783ae2015-09-08 15:35:32 -0700245 if (brd) {
Hal Canaryfafe1352017-04-11 12:12:02 -0400246 return {SkTMax(1, brd->width() / (int)fSampleSize),
247 SkTMax(1, brd->height() / (int)fSampleSize)};
msaretta5783ae2015-09-08 15:35:32 -0700248 }
Hal Canaryfafe1352017-04-11 12:12:02 -0400249 return {0, 0};
msaretta5783ae2015-09-08 15:35:32 -0700250}
251
252static SkString get_scaled_name(const Path& path, float scale) {
253 return SkStringPrintf("%s_%.3f", SkOSPath::Basename(path.c_str()).c_str(), scale);
254}
255
256Name BRDSrc::name() const {
257 // We will replicate the names used by CodecSrc so that images can
258 // be compared in Gold.
259 if (1 == fSampleSize) {
260 return SkOSPath::Basename(fPath.c_str());
261 }
msarett4b0778e2015-11-13 09:59:11 -0800262 return get_scaled_name(fPath, 1.0f / (float) fSampleSize);
msaretta5783ae2015-09-08 15:35:32 -0700263}
264
265/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
266
scroggo3ac66e92016-02-08 15:09:48 -0800267static bool serial_from_path_name(const SkString& path) {
268 if (!FLAGS_RAW_threading) {
269 static const char* const exts[] = {
270 "arw", "cr2", "dng", "nef", "nrw", "orf", "raf", "rw2", "pef", "srw",
271 "ARW", "CR2", "DNG", "NEF", "NRW", "ORF", "RAF", "RW2", "PEF", "SRW",
272 };
273 const char* actualExt = strrchr(path.c_str(), '.');
274 if (actualExt) {
275 actualExt++;
276 for (auto* ext : exts) {
277 if (0 == strcmp(ext, actualExt)) {
278 return true;
279 }
280 }
281 }
282 }
283 return false;
284}
285
scroggoc5560be2016-02-03 09:42:42 -0800286CodecSrc::CodecSrc(Path path, Mode mode, DstColorType dstColorType, SkAlphaType dstAlphaType,
287 float scale)
msarett438b2ad2015-04-09 12:43:10 -0700288 : fPath(path)
289 , fMode(mode)
290 , fDstColorType(dstColorType)
scroggoc5560be2016-02-03 09:42:42 -0800291 , fDstAlphaType(dstAlphaType)
msarett0a242972015-06-11 14:27:27 -0700292 , fScale(scale)
scroggo3ac66e92016-02-08 15:09:48 -0800293 , fRunSerially(serial_from_path_name(path))
msarett438b2ad2015-04-09 12:43:10 -0700294{}
mtklein748ca3b2015-01-15 10:56:12 -0800295
mtklein99cab4e2015-07-31 06:43:04 -0700296bool CodecSrc::veto(SinkFlags flags) const {
msarett18976312016-03-09 14:20:58 -0800297 // Test to direct raster backends (8888 and 565).
msarettb714fb02016-01-22 14:46:42 -0800298 return flags.type != SinkFlags::kRaster || flags.approach != SinkFlags::kDirect;
mtkleine0effd62015-07-29 06:37:28 -0700299}
scroggo9b77ddd2015-03-19 06:03:39 -0700300
msarett34e0ec42016-04-22 16:27:24 -0700301// Allows us to test decodes to non-native 8888.
msarettb1be46b2016-05-17 08:52:11 -0700302static void swap_rb_if_necessary(SkBitmap& bitmap, CodecSrc::DstColorType dstColorType) {
msarett34e0ec42016-04-22 16:27:24 -0700303 if (CodecSrc::kNonNative8888_Always_DstColorType != dstColorType) {
304 return;
305 }
306
307 for (int y = 0; y < bitmap.height(); y++) {
308 uint32_t* row = (uint32_t*) bitmap.getAddr(0, y);
309 SkOpts::RGBA_to_BGRA(row, row, bitmap.width());
310 }
311}
312
msarett9e9444c2016-02-03 12:39:10 -0800313// FIXME: Currently we cannot draw unpremultiplied sources. skbug.com/3338 and skbug.com/3339.
314// This allows us to still test unpremultiplied decodes.
msarettb1be46b2016-05-17 08:52:11 -0700315static void premultiply_if_necessary(SkBitmap& bitmap) {
msarett9e9444c2016-02-03 12:39:10 -0800316 if (kUnpremul_SkAlphaType != bitmap.alphaType()) {
317 return;
318 }
319
320 switch (bitmap.colorType()) {
321 case kN32_SkColorType:
322 for (int y = 0; y < bitmap.height(); y++) {
323 uint32_t* row = (uint32_t*) bitmap.getAddr(0, y);
324 SkOpts::RGBA_to_rgbA(row, row, bitmap.width());
325 }
326 break;
327 case kIndex_8_SkColorType: {
328 SkColorTable* colorTable = bitmap.getColorTable();
329 SkPMColor* colorPtr = const_cast<SkPMColor*>(colorTable->readColors());
330 SkOpts::RGBA_to_rgbA(colorPtr, colorPtr, colorTable->count());
331 break;
332 }
333 default:
334 // No need to premultiply kGray or k565 outputs.
335 break;
336 }
msarette1daa482016-02-03 15:31:18 -0800337
338 // In the kIndex_8 case, the canvas won't even try to draw unless we mark the
339 // bitmap as kPremul.
340 bitmap.setAlphaType(kPremul_SkAlphaType);
msarett9e9444c2016-02-03 12:39:10 -0800341}
342
msarettb1be46b2016-05-17 08:52:11 -0700343static bool get_decode_info(SkImageInfo* decodeInfo, SkColorType canvasColorType,
scroggoba584892016-05-20 13:56:13 -0700344 CodecSrc::DstColorType dstColorType, SkAlphaType dstAlphaType) {
msarett3d9d7a72015-10-21 10:27:10 -0700345 switch (dstColorType) {
346 case CodecSrc::kIndex8_Always_DstColorType:
347 if (kRGB_565_SkColorType == canvasColorType) {
348 return false;
349 }
scroggoc5560be2016-02-03 09:42:42 -0800350 *decodeInfo = decodeInfo->makeColorType(kIndex_8_SkColorType);
msarett3d9d7a72015-10-21 10:27:10 -0700351 break;
352 case CodecSrc::kGrayscale_Always_DstColorType:
scroggo1a361922016-05-20 14:27:16 -0700353 if (kRGB_565_SkColorType == canvasColorType) {
msarett3d9d7a72015-10-21 10:27:10 -0700354 return false;
355 }
scroggoc5560be2016-02-03 09:42:42 -0800356 *decodeInfo = decodeInfo->makeColorType(kGray_8_SkColorType);
msarett3d9d7a72015-10-21 10:27:10 -0700357 break;
msarett34e0ec42016-04-22 16:27:24 -0700358 case CodecSrc::kNonNative8888_Always_DstColorType:
359 if (kRGB_565_SkColorType == canvasColorType) {
360 return false;
361 }
362#ifdef SK_PMCOLOR_IS_RGBA
363 *decodeInfo = decodeInfo->makeColorType(kBGRA_8888_SkColorType);
364#else
365 *decodeInfo = decodeInfo->makeColorType(kRGBA_8888_SkColorType);
366#endif
367 break;
msarett3d9d7a72015-10-21 10:27:10 -0700368 default:
msarett55f7bdd2016-02-16 13:24:54 -0800369 if (kRGB_565_SkColorType == canvasColorType &&
370 kOpaque_SkAlphaType != decodeInfo->alphaType()) {
371 return false;
372 }
Matt Sarett09a1c082017-02-01 15:34:22 -0800373
374 if (kRGBA_F16_SkColorType == canvasColorType) {
Matt Sarettea518f02017-02-03 11:58:59 -0800375 if (kUnpremul_SkAlphaType == dstAlphaType) {
376 // Testing kPremul is enough for adequate coverage of F16 decoding.
377 return false;
378 }
379
Matt Sarett09a1c082017-02-01 15:34:22 -0800380 sk_sp<SkColorSpace> linearSpace =
381 as_CSB(decodeInfo->colorSpace())->makeLinearGamma();
382 *decodeInfo = decodeInfo->makeColorSpace(std::move(linearSpace));
383 }
384
scroggoc5560be2016-02-03 09:42:42 -0800385 *decodeInfo = decodeInfo->makeColorType(canvasColorType);
msarett3d9d7a72015-10-21 10:27:10 -0700386 break;
387 }
388
scroggoba584892016-05-20 13:56:13 -0700389 *decodeInfo = decodeInfo->makeAlphaType(dstAlphaType);
msarett3d9d7a72015-10-21 10:27:10 -0700390 return true;
391}
392
msarettb1be46b2016-05-17 08:52:11 -0700393static void draw_to_canvas(SkCanvas* canvas, const SkImageInfo& info, void* pixels, size_t rowBytes,
394 SkPMColor* colorPtr, int colorCount, CodecSrc::DstColorType dstColorType,
395 SkScalar left = 0, SkScalar top = 0) {
Hal Canary2db83612016-11-04 13:02:54 -0400396 sk_sp<SkColorTable> colorTable(new SkColorTable(colorPtr, colorCount));
msarettb1be46b2016-05-17 08:52:11 -0700397 SkBitmap bitmap;
398 bitmap.installPixels(info, pixels, rowBytes, colorTable.get(), nullptr, nullptr);
399 premultiply_if_necessary(bitmap);
400 swap_rb_if_necessary(bitmap, dstColorType);
401 canvas->drawBitmap(bitmap, left, top);
402}
403
mtkleine0effd62015-07-29 06:37:28 -0700404Error CodecSrc::draw(SkCanvas* canvas) const {
bungeman38d909e2016-08-02 14:40:46 -0700405 sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
mtklein748ca3b2015-01-15 10:56:12 -0800406 if (!encoded) {
407 return SkStringPrintf("Couldn't read %s.", fPath.c_str());
408 }
msarettb714fb02016-01-22 14:46:42 -0800409
Ben Wagner145dbcd2016-11-03 14:40:50 -0400410 std::unique_ptr<SkCodec> codec(SkCodec::NewFromData(encoded));
msarett9e707a02015-09-01 14:57:57 -0700411 if (nullptr == codec.get()) {
412 return SkStringPrintf("Couldn't create codec for %s.", fPath.c_str());
scroggo9b77ddd2015-03-19 06:03:39 -0700413 }
414
scroggoba584892016-05-20 13:56:13 -0700415 SkImageInfo decodeInfo = codec->getInfo();
416 if (!get_decode_info(&decodeInfo, canvas->imageInfo().colorType(), fDstColorType,
417 fDstAlphaType)) {
Matt Sarettea518f02017-02-03 11:58:59 -0800418 return Error::Nonfatal("Skipping uninteresting test.");
msarett438b2ad2015-04-09 12:43:10 -0700419 }
420
msarett0a242972015-06-11 14:27:27 -0700421 // Try to scale the image if it is desired
422 SkISize size = codec->getScaledDimensions(fScale);
423 if (size == decodeInfo.dimensions() && 1.0f != fScale) {
424 return Error::Nonfatal("Test without scaling is uninteresting.");
425 }
msarettb32758a2015-08-18 13:22:46 -0700426
427 // Visually inspecting very small output images is not necessary. We will
428 // cover these cases in unit testing.
429 if ((size.width() <= 10 || size.height() <= 10) && 1.0f != fScale) {
430 return Error::Nonfatal("Scaling very small images is uninteresting.");
431 }
msarett0a242972015-06-11 14:27:27 -0700432 decodeInfo = decodeInfo.makeWH(size.width(), size.height());
433
msarettb1be46b2016-05-17 08:52:11 -0700434 const int bpp = SkColorTypeBytesPerPixel(decodeInfo.colorType());
435 const size_t rowBytes = size.width() * bpp;
scroggo19b91532016-10-24 09:03:26 -0700436 const size_t safeSize = decodeInfo.getSafeSize(rowBytes);
437 SkAutoMalloc pixels(safeSize);
msarettb1be46b2016-05-17 08:52:11 -0700438 SkPMColor colorPtr[256];
439 int colorCount = 256;
msarett438b2ad2015-04-09 12:43:10 -0700440
msarettbb25b532016-01-13 09:31:39 -0800441 SkCodec::Options options;
442 if (kCodecZeroInit_Mode == fMode) {
msarettb1be46b2016-05-17 08:52:11 -0700443 memset(pixels.get(), 0, size.height() * rowBytes);
msarettbb25b532016-01-13 09:31:39 -0800444 options.fZeroInitialized = SkCodec::kYes_ZeroInitialized;
445 }
msarett34e0ec42016-04-22 16:27:24 -0700446
447 SkImageInfo bitmapInfo = decodeInfo;
448 if (kRGBA_8888_SkColorType == decodeInfo.colorType() ||
449 kBGRA_8888_SkColorType == decodeInfo.colorType()) {
450 bitmapInfo = bitmapInfo.makeColorType(kN32_SkColorType);
451 }
scroggo9b77ddd2015-03-19 06:03:39 -0700452
scroggo9c59ebc2015-03-25 13:48:49 -0700453 switch (fMode) {
scroggo19b91532016-10-24 09:03:26 -0700454 case kAnimated_Mode: {
455 std::vector<SkCodec::FrameInfo> frameInfos = codec->getFrameInfo();
456 if (frameInfos.size() <= 1) {
457 return SkStringPrintf("%s is not an animated image.", fPath.c_str());
458 }
459
scroggo90e971a2016-10-25 06:11:01 -0700460 // As in CodecSrc::size(), compute a roughly square grid to draw the frames
461 // into. "factor" is the number of frames to draw on one row. There will be
462 // up to "factor" rows as well.
463 const float root = sqrt((float) frameInfos.size());
464 const int factor = sk_float_ceil2int(root);
465
scroggo19b91532016-10-24 09:03:26 -0700466 // Used to cache a frame that future frames will depend on.
467 SkAutoMalloc priorFramePixels;
468 size_t cachedFrame = SkCodec::kNone;
469 for (size_t i = 0; i < frameInfos.size(); i++) {
470 options.fFrameIndex = i;
471 // Check for a prior frame
472 const size_t reqFrame = frameInfos[i].fRequiredFrame;
473 if (reqFrame != SkCodec::kNone && reqFrame == cachedFrame
474 && priorFramePixels.get()) {
475 // Copy into pixels
476 memcpy(pixels.get(), priorFramePixels.get(), safeSize);
477 options.fHasPriorFrame = true;
478 } else {
479 options.fHasPriorFrame = false;
480 }
Leon Scroggins III3fc97d72016-12-09 16:39:33 -0500481 SkCodec::Result result = codec->getPixels(decodeInfo, pixels.get(),
482 rowBytes, &options,
483 colorPtr, &colorCount);
484 if (SkCodec::kInvalidInput == result && i > 0) {
485 // Some of our test images have truncated later frames. Treat that
486 // the same as incomplete.
487 result = SkCodec::kIncompleteInput;
488 }
scroggo19b91532016-10-24 09:03:26 -0700489 switch (result) {
490 case SkCodec::kSuccess:
scroggo90e971a2016-10-25 06:11:01 -0700491 case SkCodec::kIncompleteInput: {
492 SkAutoCanvasRestore acr(canvas, true);
493 const int xTranslate = (i % factor) * decodeInfo.width();
494 const int yTranslate = (i / factor) * decodeInfo.height();
495 canvas->translate(SkIntToScalar(xTranslate), SkIntToScalar(yTranslate));
scroggo19b91532016-10-24 09:03:26 -0700496 draw_to_canvas(canvas, bitmapInfo, pixels.get(), rowBytes,
497 colorPtr, colorCount, fDstColorType);
498 if (result == SkCodec::kIncompleteInput) {
499 return "";
500 }
501 break;
scroggo90e971a2016-10-25 06:11:01 -0700502 }
scroggo53f63b62016-10-27 08:29:13 -0700503 case SkCodec::kInvalidConversion:
504 if (i > 0 && (decodeInfo.colorType() == kRGB_565_SkColorType
505 || decodeInfo.colorType() == kIndex_8_SkColorType)) {
506 return Error::Nonfatal(SkStringPrintf(
507 "Cannot decode frame %i to 565/Index8 (%s).", i, fPath.c_str()));
508 }
509 // Fall through.
scroggo19b91532016-10-24 09:03:26 -0700510 default:
511 return SkStringPrintf("Couldn't getPixels for frame %i in %s.",
512 i, fPath.c_str());
513 }
514
515 // If a future frame depends on this one, store it in priorFrame.
516 // (Note that if i+1 does *not* depend on i, then no future frame can.)
517 if (i+1 < frameInfos.size() && frameInfos[i+1].fRequiredFrame == i) {
518 memcpy(priorFramePixels.reset(safeSize), pixels.get(), safeSize);
519 cachedFrame = i;
520 }
scroggo19b91532016-10-24 09:03:26 -0700521 }
522 break;
523 }
msarettbb25b532016-01-13 09:31:39 -0800524 case kCodecZeroInit_Mode:
msarett9e707a02015-09-01 14:57:57 -0700525 case kCodec_Mode: {
msarettb1be46b2016-05-17 08:52:11 -0700526 switch (codec->getPixels(decodeInfo, pixels.get(), rowBytes, &options,
527 colorPtr, &colorCount)) {
scroggoeb602a52015-07-09 08:16:03 -0700528 case SkCodec::kSuccess:
scroggo9c59ebc2015-03-25 13:48:49 -0700529 // We consider incomplete to be valid, since we should still decode what is
530 // available.
scroggoeb602a52015-07-09 08:16:03 -0700531 case SkCodec::kIncompleteInput:
scroggo9c59ebc2015-03-25 13:48:49 -0700532 break;
scroggo9c59ebc2015-03-25 13:48:49 -0700533 default:
534 // Everything else is considered a failure.
535 return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
536 }
msarettb1be46b2016-05-17 08:52:11 -0700537
538 draw_to_canvas(canvas, bitmapInfo, pixels.get(), rowBytes, colorPtr, colorCount,
539 fDstColorType);
scroggo9c59ebc2015-03-25 13:48:49 -0700540 break;
emmaleer0a4c3cb2015-06-22 10:40:21 -0700541 }
scroggo9c59ebc2015-03-25 13:48:49 -0700542 case kScanline_Mode: {
scroggod8d68552016-06-06 11:26:17 -0700543 void* dst = pixels.get();
544 uint32_t height = decodeInfo.height();
scroggo19b91532016-10-24 09:03:26 -0700545 const bool useIncremental = [this]() {
546 auto exts = { "png", "PNG", "gif", "GIF" };
547 for (auto ext : exts) {
548 if (fPath.endsWith(ext)) {
549 return true;
550 }
551 }
552 return false;
553 }();
554 // ico may use the old scanline method or the new one, depending on whether it
555 // internally holds a bmp or a png.
scroggo8e6c7ad2016-09-16 08:20:38 -0700556 const bool ico = fPath.endsWith("ico");
scroggo19b91532016-10-24 09:03:26 -0700557 bool useOldScanlineMethod = !useIncremental && !ico;
558 if (useIncremental || ico) {
scroggo8e6c7ad2016-09-16 08:20:38 -0700559 if (SkCodec::kSuccess == codec->startIncrementalDecode(decodeInfo, dst,
560 rowBytes, nullptr, colorPtr, &colorCount)) {
561 int rowsDecoded;
562 if (SkCodec::kIncompleteInput == codec->incrementalDecode(&rowsDecoded)) {
563 codec->fillIncompleteImage(decodeInfo, dst, rowBytes,
564 SkCodec::kNo_ZeroInitialized, height,
565 rowsDecoded);
scroggo6fb23912016-06-02 14:16:43 -0700566 }
scroggo8e6c7ad2016-09-16 08:20:38 -0700567 } else {
scroggo19b91532016-10-24 09:03:26 -0700568 if (useIncremental) {
569 // Error: These should support incremental decode.
scroggo8e6c7ad2016-09-16 08:20:38 -0700570 return "Could not start incremental decode";
571 }
572 // Otherwise, this is an ICO. Since incremental failed, it must contain a BMP,
573 // which should work via startScanlineDecode
574 useOldScanlineMethod = true;
575 }
576 }
577
578 if (useOldScanlineMethod) {
579 if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo, NULL, colorPtr,
580 &colorCount)) {
581 return "Could not start scanline decoder";
582 }
583
584 switch (codec->getScanlineOrder()) {
585 case SkCodec::kTopDown_SkScanlineOrder:
586 case SkCodec::kBottomUp_SkScanlineOrder:
587 // We do not need to check the return value. On an incomplete
588 // image, memory will be filled with a default value.
589 codec->getScanlines(dst, height, rowBytes);
590 break;
msarett10522ff2015-09-07 08:54:01 -0700591 }
592 }
593
msarettb1be46b2016-05-17 08:52:11 -0700594 draw_to_canvas(canvas, bitmapInfo, dst, rowBytes, colorPtr, colorCount, fDstColorType);
emmaleer97002062015-05-27 12:36:10 -0700595 break;
596 }
msarett0a242972015-06-11 14:27:27 -0700597 case kStripe_Mode: {
598 const int height = decodeInfo.height();
599 // This value is chosen arbitrarily. We exercise more cases by choosing a value that
600 // does not align with image blocks.
601 const int stripeHeight = 37;
602 const int numStripes = (height + stripeHeight - 1) / stripeHeight;
msarettb1be46b2016-05-17 08:52:11 -0700603 void* dst = pixels.get();
msarett0a242972015-06-11 14:27:27 -0700604
605 // Decode odd stripes
msarettb1be46b2016-05-17 08:52:11 -0700606 if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo, nullptr, colorPtr,
607 &colorCount)) {
msarettb65e6042016-02-23 05:37:25 -0800608 return "Could not start scanline decoder";
609 }
610
611 // This mode was designed to test the new skip scanlines API in libjpeg-turbo.
612 // Jpegs have kTopDown_SkScanlineOrder, and at this time, it is not interesting
613 // to run this test for image types that do not have this scanline ordering.
scroggo12e2f502016-05-16 09:04:18 -0700614 // We only run this on Jpeg, which is always kTopDown.
615 SkASSERT(SkCodec::kTopDown_SkScanlineOrder == codec->getScanlineOrder());
msarette6dd0042015-10-09 11:07:34 -0700616
msarett0a242972015-06-11 14:27:27 -0700617 for (int i = 0; i < numStripes; i += 2) {
618 // Skip a stripe
619 const int linesToSkip = SkTMin(stripeHeight, height - i * stripeHeight);
msarette6dd0042015-10-09 11:07:34 -0700620 codec->skipScanlines(linesToSkip);
msarett0a242972015-06-11 14:27:27 -0700621
622 // Read a stripe
623 const int startY = (i + 1) * stripeHeight;
624 const int linesToRead = SkTMin(stripeHeight, height - startY);
625 if (linesToRead > 0) {
msarettb1be46b2016-05-17 08:52:11 -0700626 codec->getScanlines(SkTAddOffset<void>(dst, rowBytes * startY), linesToRead,
627 rowBytes);
msarett0a242972015-06-11 14:27:27 -0700628 }
629 }
630
631 // Decode even stripes
scroggo46c57472015-09-30 08:57:13 -0700632 const SkCodec::Result startResult = codec->startScanlineDecode(decodeInfo, nullptr,
msarettb1be46b2016-05-17 08:52:11 -0700633 colorPtr, &colorCount);
scroggo1c005e42015-08-04 09:24:45 -0700634 if (SkCodec::kSuccess != startResult) {
635 return "Failed to restart scanline decoder with same parameters.";
msarett0a242972015-06-11 14:27:27 -0700636 }
637 for (int i = 0; i < numStripes; i += 2) {
638 // Read a stripe
639 const int startY = i * stripeHeight;
640 const int linesToRead = SkTMin(stripeHeight, height - startY);
msarettb1be46b2016-05-17 08:52:11 -0700641 codec->getScanlines(SkTAddOffset<void>(dst, rowBytes * startY), linesToRead,
642 rowBytes);
msarett0a242972015-06-11 14:27:27 -0700643
644 // Skip a stripe
msarettf6db27e2015-06-12 09:34:04 -0700645 const int linesToSkip = SkTMin(stripeHeight, height - (i + 1) * stripeHeight);
646 if (linesToSkip > 0) {
msarette6dd0042015-10-09 11:07:34 -0700647 codec->skipScanlines(linesToSkip);
msarett0a242972015-06-11 14:27:27 -0700648 }
649 }
msarettb1be46b2016-05-17 08:52:11 -0700650
651 draw_to_canvas(canvas, bitmapInfo, dst, rowBytes, colorPtr, colorCount, fDstColorType);
emmaleer0a4c3cb2015-06-22 10:40:21 -0700652 break;
msarett0a242972015-06-11 14:27:27 -0700653 }
msarett91c22b22016-02-22 12:27:46 -0800654 case kCroppedScanline_Mode: {
655 const int width = decodeInfo.width();
656 const int height = decodeInfo.height();
657 // This value is chosen because, as we move across the image, it will sometimes
658 // align with the jpeg block sizes and it will sometimes not. This allows us
659 // to test interestingly different code paths in the implementation.
660 const int tileSize = 36;
661
662 SkCodec::Options opts;
663 SkIRect subset;
664 for (int x = 0; x < width; x += tileSize) {
665 subset = SkIRect::MakeXYWH(x, 0, SkTMin(tileSize, width - x), height);
666 opts.fSubset = &subset;
667 if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo, &opts,
msarettb1be46b2016-05-17 08:52:11 -0700668 colorPtr, &colorCount)) {
msarett91c22b22016-02-22 12:27:46 -0800669 return "Could not start scanline decoder.";
670 }
671
msarettb1be46b2016-05-17 08:52:11 -0700672 codec->getScanlines(SkTAddOffset<void>(pixels.get(), x * bpp), height, rowBytes);
msarett91c22b22016-02-22 12:27:46 -0800673 }
674
msarettb1be46b2016-05-17 08:52:11 -0700675 draw_to_canvas(canvas, bitmapInfo, pixels.get(), rowBytes, colorPtr, colorCount,
676 fDstColorType);
msarett91c22b22016-02-22 12:27:46 -0800677 break;
678 }
scroggob636b452015-07-22 07:16:20 -0700679 case kSubset_Mode: {
680 // Arbitrarily choose a divisor.
681 int divisor = 2;
682 // Total width/height of the image.
683 const int W = codec->getInfo().width();
684 const int H = codec->getInfo().height();
685 if (divisor > W || divisor > H) {
686 return Error::Nonfatal(SkStringPrintf("Cannot codec subset: divisor %d is too big "
687 "for %s with dimensions (%d x %d)", divisor,
688 fPath.c_str(), W, H));
689 }
690 // subset dimensions
691 // SkWebpCodec, the only one that supports subsets, requires even top/left boundaries.
692 const int w = SkAlign2(W / divisor);
693 const int h = SkAlign2(H / divisor);
694 SkIRect subset;
695 SkCodec::Options opts;
696 opts.fSubset = &subset;
697 SkBitmap subsetBm;
698 // We will reuse pixel memory from bitmap.
msarettb1be46b2016-05-17 08:52:11 -0700699 void* dst = pixels.get();
scroggob636b452015-07-22 07:16:20 -0700700 // Keep track of left and top (for drawing subsetBm into canvas). We could use
701 // fScale * x and fScale * y, but we want integers such that the next subset will start
702 // where the last one ended. So we'll add decodeInfo.width() and height().
703 int left = 0;
704 for (int x = 0; x < W; x += w) {
705 int top = 0;
706 for (int y = 0; y < H; y+= h) {
707 // Do not make the subset go off the edge of the image.
708 const int preScaleW = SkTMin(w, W - x);
709 const int preScaleH = SkTMin(h, H - y);
710 subset.setXYWH(x, y, preScaleW, preScaleH);
711 // And scale
712 // FIXME: Should we have a version of getScaledDimensions that takes a subset
713 // into account?
msarettc7eb4902016-04-25 07:04:58 -0700714 const int scaledW = SkTMax(1, SkScalarRoundToInt(preScaleW * fScale));
715 const int scaledH = SkTMax(1, SkScalarRoundToInt(preScaleH * fScale));
716 decodeInfo = decodeInfo.makeWH(scaledW, scaledH);
717 SkImageInfo subsetBitmapInfo = bitmapInfo.makeWH(scaledW, scaledH);
msarettb1be46b2016-05-17 08:52:11 -0700718 size_t subsetRowBytes = subsetBitmapInfo.minRowBytes();
719 const SkCodec::Result result = codec->getPixels(decodeInfo, dst, subsetRowBytes,
720 &opts, colorPtr, &colorCount);
scroggob636b452015-07-22 07:16:20 -0700721 switch (result) {
722 case SkCodec::kSuccess:
723 case SkCodec::kIncompleteInput:
724 break;
scroggob636b452015-07-22 07:16:20 -0700725 default:
726 return SkStringPrintf("subset codec failed to decode (%d, %d, %d, %d) "
727 "from %s with dimensions (%d x %d)\t error %d",
728 x, y, decodeInfo.width(), decodeInfo.height(),
729 fPath.c_str(), W, H, result);
730 }
msarettb1be46b2016-05-17 08:52:11 -0700731 draw_to_canvas(canvas, subsetBitmapInfo, dst, subsetRowBytes, colorPtr,
732 colorCount, fDstColorType, SkIntToScalar(left),
733 SkIntToScalar(top));
734
scroggob636b452015-07-22 07:16:20 -0700735 // translate by the scaled height.
736 top += decodeInfo.height();
737 }
738 // translate by the scaled width.
739 left += decodeInfo.width();
740 }
741 return "";
742 }
msarettb714fb02016-01-22 14:46:42 -0800743 default:
744 SkASSERT(false);
745 return "Invalid fMode";
scroggo9b77ddd2015-03-19 06:03:39 -0700746 }
scroggo9c59ebc2015-03-25 13:48:49 -0700747 return "";
scroggo9b77ddd2015-03-19 06:03:39 -0700748}
749
750SkISize CodecSrc::size() const {
bungeman38d909e2016-08-02 14:40:46 -0700751 sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
Ben Wagner145dbcd2016-11-03 14:40:50 -0400752 std::unique_ptr<SkCodec> codec(SkCodec::NewFromData(encoded));
scroggo7fac5af2015-09-30 11:33:12 -0700753 if (nullptr == codec) {
Hal Canaryfafe1352017-04-11 12:12:02 -0400754 return {0, 0};
scroggo7fac5af2015-09-30 11:33:12 -0700755 }
scroggo19b91532016-10-24 09:03:26 -0700756
757 auto imageSize = codec->getScaledDimensions(fScale);
758 if (fMode == kAnimated_Mode) {
scroggo90e971a2016-10-25 06:11:01 -0700759 // We'll draw one of each frame, so make it big enough to hold them all
760 // in a grid. The grid will be roughly square, with "factor" frames per
761 // row and up to "factor" rows.
scroggo19b91532016-10-24 09:03:26 -0700762 const size_t count = codec->getFrameInfo().size();
scroggo90e971a2016-10-25 06:11:01 -0700763 const float root = sqrt((float) count);
764 const int factor = sk_float_ceil2int(root);
765 imageSize.fWidth = imageSize.fWidth * factor;
766 imageSize.fHeight = imageSize.fHeight * sk_float_ceil2int((float) count / (float) factor);
scroggo19b91532016-10-24 09:03:26 -0700767 }
768 return imageSize;
scroggo9b77ddd2015-03-19 06:03:39 -0700769}
770
771Name CodecSrc::name() const {
msarett0a242972015-06-11 14:27:27 -0700772 if (1.0f == fScale) {
scroggo6e8c68e2016-10-24 13:48:49 -0700773 Name name = SkOSPath::Basename(fPath.c_str());
774 if (fMode == kAnimated_Mode) {
775 name.append("_animated");
776 }
777 return name;
msarett0a242972015-06-11 14:27:27 -0700778 }
scroggo6e8c68e2016-10-24 13:48:49 -0700779 SkASSERT(fMode != kAnimated_Mode);
msaretta5783ae2015-09-08 15:35:32 -0700780 return get_scaled_name(fPath, fScale);
scroggo9b77ddd2015-03-19 06:03:39 -0700781}
782
783/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
784
scroggof8dc9df2016-05-16 09:04:13 -0700785AndroidCodecSrc::AndroidCodecSrc(Path path, CodecSrc::DstColorType dstColorType,
scroggoc5560be2016-02-03 09:42:42 -0800786 SkAlphaType dstAlphaType, int sampleSize)
msarett3d9d7a72015-10-21 10:27:10 -0700787 : fPath(path)
msarett3d9d7a72015-10-21 10:27:10 -0700788 , fDstColorType(dstColorType)
scroggoc5560be2016-02-03 09:42:42 -0800789 , fDstAlphaType(dstAlphaType)
msarett3d9d7a72015-10-21 10:27:10 -0700790 , fSampleSize(sampleSize)
scroggo3ac66e92016-02-08 15:09:48 -0800791 , fRunSerially(serial_from_path_name(path))
msarett3d9d7a72015-10-21 10:27:10 -0700792{}
793
794bool AndroidCodecSrc::veto(SinkFlags flags) const {
795 // No need to test decoding to non-raster or indirect backend.
msarett3d9d7a72015-10-21 10:27:10 -0700796 return flags.type != SinkFlags::kRaster
797 || flags.approach != SinkFlags::kDirect;
798}
799
800Error AndroidCodecSrc::draw(SkCanvas* canvas) const {
bungeman38d909e2016-08-02 14:40:46 -0700801 sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
msarett3d9d7a72015-10-21 10:27:10 -0700802 if (!encoded) {
803 return SkStringPrintf("Couldn't read %s.", fPath.c_str());
804 }
Ben Wagner145dbcd2016-11-03 14:40:50 -0400805 std::unique_ptr<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(encoded));
msarett3d9d7a72015-10-21 10:27:10 -0700806 if (nullptr == codec.get()) {
807 return SkStringPrintf("Couldn't create android codec for %s.", fPath.c_str());
808 }
809
scroggoba584892016-05-20 13:56:13 -0700810 SkImageInfo decodeInfo = codec->getInfo();
811 if (!get_decode_info(&decodeInfo, canvas->imageInfo().colorType(), fDstColorType,
812 fDstAlphaType)) {
Matt Sarettea518f02017-02-03 11:58:59 -0800813 return Error::Nonfatal("Skipping uninteresting test.");
msarett3d9d7a72015-10-21 10:27:10 -0700814 }
815
816 // Scale the image if it is desired.
817 SkISize size = codec->getSampledDimensions(fSampleSize);
818
819 // Visually inspecting very small output images is not necessary. We will
820 // cover these cases in unit testing.
821 if ((size.width() <= 10 || size.height() <= 10) && 1 != fSampleSize) {
822 return Error::Nonfatal("Scaling very small images is uninteresting.");
823 }
824 decodeInfo = decodeInfo.makeWH(size.width(), size.height());
825
msarettb1be46b2016-05-17 08:52:11 -0700826 int bpp = SkColorTypeBytesPerPixel(decodeInfo.colorType());
827 size_t rowBytes = size.width() * bpp;
828 SkAutoMalloc pixels(size.height() * rowBytes);
829 SkPMColor colorPtr[256];
830 int colorCount = 256;
msarett3d9d7a72015-10-21 10:27:10 -0700831
832 SkBitmap bitmap;
msarett34e0ec42016-04-22 16:27:24 -0700833 SkImageInfo bitmapInfo = decodeInfo;
834 if (kRGBA_8888_SkColorType == decodeInfo.colorType() ||
835 kBGRA_8888_SkColorType == decodeInfo.colorType()) {
836 bitmapInfo = bitmapInfo.makeColorType(kN32_SkColorType);
837 }
msarett3d9d7a72015-10-21 10:27:10 -0700838
839 // Create options for the codec.
840 SkAndroidCodec::AndroidOptions options;
841 options.fColorPtr = colorPtr;
msarettb1be46b2016-05-17 08:52:11 -0700842 options.fColorCount = &colorCount;
msarett3d9d7a72015-10-21 10:27:10 -0700843 options.fSampleSize = fSampleSize;
844
msarettb1be46b2016-05-17 08:52:11 -0700845 switch (codec->getAndroidPixels(decodeInfo, pixels.get(), rowBytes, &options)) {
scroggof8dc9df2016-05-16 09:04:13 -0700846 case SkCodec::kSuccess:
847 case SkCodec::kIncompleteInput:
848 break;
msarett3d9d7a72015-10-21 10:27:10 -0700849 default:
scroggof8dc9df2016-05-16 09:04:13 -0700850 return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
msarett3d9d7a72015-10-21 10:27:10 -0700851 }
msarettb1be46b2016-05-17 08:52:11 -0700852 draw_to_canvas(canvas, bitmapInfo, pixels.get(), rowBytes, colorPtr, colorCount, fDstColorType);
scroggof8dc9df2016-05-16 09:04:13 -0700853 return "";
msarett3d9d7a72015-10-21 10:27:10 -0700854}
855
856SkISize AndroidCodecSrc::size() const {
bungeman38d909e2016-08-02 14:40:46 -0700857 sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
Ben Wagner145dbcd2016-11-03 14:40:50 -0400858 std::unique_ptr<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(encoded));
msarett3d9d7a72015-10-21 10:27:10 -0700859 if (nullptr == codec) {
Hal Canaryfafe1352017-04-11 12:12:02 -0400860 return {0, 0};
msarett3d9d7a72015-10-21 10:27:10 -0700861 }
862 return codec->getSampledDimensions(fSampleSize);
863}
864
865Name AndroidCodecSrc::name() const {
866 // We will replicate the names used by CodecSrc so that images can
867 // be compared in Gold.
868 if (1 == fSampleSize) {
869 return SkOSPath::Basename(fPath.c_str());
870 }
msarett4b0778e2015-11-13 09:59:11 -0800871 return get_scaled_name(fPath, 1.0f / (float) fSampleSize);
msarett3d9d7a72015-10-21 10:27:10 -0700872}
873
874/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
875
msarett18976312016-03-09 14:20:58 -0800876ImageGenSrc::ImageGenSrc(Path path, Mode mode, SkAlphaType alphaType, bool isGpu)
877 : fPath(path)
878 , fMode(mode)
879 , fDstAlphaType(alphaType)
880 , fIsGpu(isGpu)
881 , fRunSerially(serial_from_path_name(path))
882{}
883
884bool ImageGenSrc::veto(SinkFlags flags) const {
885 if (fIsGpu) {
Brian Salomonbd7c5512017-03-07 09:08:36 -0500886 // MSAA runs tend to run out of memory and tests the same code paths as regular gpu configs.
887 return flags.type != SinkFlags::kGPU || flags.approach != SinkFlags::kDirect ||
888 flags.multisampled == SinkFlags::kMultisampled;
msarett18976312016-03-09 14:20:58 -0800889 }
890
891 return flags.type != SinkFlags::kRaster || flags.approach != SinkFlags::kDirect;
892}
893
894Error ImageGenSrc::draw(SkCanvas* canvas) const {
895 if (kRGB_565_SkColorType == canvas->imageInfo().colorType()) {
896 return Error::Nonfatal("Uninteresting to test image generator to 565.");
897 }
898
bungeman38d909e2016-08-02 14:40:46 -0700899 sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
msarett18976312016-03-09 14:20:58 -0800900 if (!encoded) {
901 return SkStringPrintf("Couldn't read %s.", fPath.c_str());
902 }
903
msarettfc0b6d12016-03-17 13:50:17 -0700904#if defined(SK_BUILD_FOR_WIN)
905 // Initialize COM in order to test with WIC.
906 SkAutoCoInitialize com;
907 if (!com.succeeded()) {
908 return "Could not initialize COM.";
909 }
910#endif
911
Ben Wagner145dbcd2016-11-03 14:40:50 -0400912 std::unique_ptr<SkImageGenerator> gen(nullptr);
msarett18976312016-03-09 14:20:58 -0800913 switch (fMode) {
914 case kCodec_Mode:
Mike Reed185130c2017-02-15 15:14:16 -0500915 gen = SkCodecImageGenerator::MakeFromEncodedCodec(encoded);
msarett18976312016-03-09 14:20:58 -0800916 if (!gen) {
917 return "Could not create codec image generator.";
918 }
919 break;
msarettfc0b6d12016-03-17 13:50:17 -0700920 case kPlatform_Mode: {
msarett18976312016-03-09 14:20:58 -0800921#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
bungeman38d909e2016-08-02 14:40:46 -0700922 gen.reset(SkImageGeneratorCG::NewFromEncodedCG(encoded.get()));
msarettfc0b6d12016-03-17 13:50:17 -0700923#elif defined(SK_BUILD_FOR_WIN)
bungeman38d909e2016-08-02 14:40:46 -0700924 gen.reset(SkImageGeneratorWIC::NewFromEncodedWIC(encoded.get()));
msarettfc0b6d12016-03-17 13:50:17 -0700925#endif
926
msarett18976312016-03-09 14:20:58 -0800927 if (!gen) {
msarettfc0b6d12016-03-17 13:50:17 -0700928 return "Could not create platform image generator.";
msarett18976312016-03-09 14:20:58 -0800929 }
930 break;
msarettfc0b6d12016-03-17 13:50:17 -0700931 }
msarett18976312016-03-09 14:20:58 -0800932 default:
933 SkASSERT(false);
934 return "Invalid image generator mode";
935 }
936
937 // Test deferred decoding path on GPU
938 if (fIsGpu) {
Mike Reed185130c2017-02-15 15:14:16 -0500939 sk_sp<SkImage> image(SkImage::MakeFromGenerator(std::move(gen), nullptr));
msarett18976312016-03-09 14:20:58 -0800940 if (!image) {
941 return "Could not create image from codec image generator.";
942 }
943 canvas->drawImage(image, 0, 0);
944 return "";
945 }
mtklein343a63d2016-03-22 11:46:53 -0700946
msarett18976312016-03-09 14:20:58 -0800947 // Test various color and alpha types on CPU
948 SkImageInfo decodeInfo = gen->getInfo().makeAlphaType(fDstAlphaType);
mtklein343a63d2016-03-22 11:46:53 -0700949
msarettb1be46b2016-05-17 08:52:11 -0700950 int bpp = SkColorTypeBytesPerPixel(decodeInfo.colorType());
951 size_t rowBytes = decodeInfo.width() * bpp;
952 SkAutoMalloc pixels(decodeInfo.height() * rowBytes);
953 SkPMColor colorPtr[256];
954 int colorCount = 256;
msarett18976312016-03-09 14:20:58 -0800955
msarettb1be46b2016-05-17 08:52:11 -0700956 if (!gen->getPixels(decodeInfo, pixels.get(), rowBytes, colorPtr, &colorCount)) {
Matt Sarett05cb4c32017-03-02 12:07:46 -0500957 SkString err =
958 SkStringPrintf("Image generator could not getPixels() for %s\n", fPath.c_str());
959
960#if defined(SK_BUILD_FOR_WIN)
961 if (kPlatform_Mode == fMode) {
962 // Do not issue a fatal error for WIC flakiness.
963 return Error::Nonfatal(err);
964 }
965#endif
966
967 return err;
msarett18976312016-03-09 14:20:58 -0800968 }
969
msarettb1be46b2016-05-17 08:52:11 -0700970 draw_to_canvas(canvas, decodeInfo, pixels.get(), rowBytes, colorPtr, colorCount,
971 CodecSrc::kGetFromCanvas_DstColorType);
msarett18976312016-03-09 14:20:58 -0800972 return "";
973}
974
975SkISize ImageGenSrc::size() const {
bungeman38d909e2016-08-02 14:40:46 -0700976 sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
Ben Wagner145dbcd2016-11-03 14:40:50 -0400977 std::unique_ptr<SkCodec> codec(SkCodec::NewFromData(encoded));
msarett18976312016-03-09 14:20:58 -0800978 if (nullptr == codec) {
Hal Canaryfafe1352017-04-11 12:12:02 -0400979 return {0, 0};
msarett18976312016-03-09 14:20:58 -0800980 }
981 return codec->getInfo().dimensions();
982}
983
984Name ImageGenSrc::name() const {
985 return SkOSPath::Basename(fPath.c_str());
986}
987
988/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
989
msarett9ce3a542016-07-15 13:54:38 -0700990ColorCodecSrc::ColorCodecSrc(Path path, Mode mode, SkColorType colorType)
msarett69deca82016-04-29 09:38:40 -0700991 : fPath(path)
992 , fMode(mode)
msarett9ce3a542016-07-15 13:54:38 -0700993 , fColorType(colorType)
msarett69deca82016-04-29 09:38:40 -0700994{}
995
996bool ColorCodecSrc::veto(SinkFlags flags) const {
997 // Test to direct raster backends (8888 and 565).
998 return flags.type != SinkFlags::kRaster || flags.approach != SinkFlags::kDirect;
999}
1000
1001Error ColorCodecSrc::draw(SkCanvas* canvas) const {
1002 if (kRGB_565_SkColorType == canvas->imageInfo().colorType()) {
1003 return Error::Nonfatal("No need to test color correction to 565 backend.");
1004 }
1005
msarettd1ec89b2016-08-03 12:59:27 -07001006 bool runInLegacyMode = kBaseline_Mode == fMode;
msarettd1ec89b2016-08-03 12:59:27 -07001007 if (runInLegacyMode && canvas->imageInfo().colorSpace()) {
1008 return Error::Nonfatal("Skipping tests that are only interesting in legacy mode.");
1009 } else if (!runInLegacyMode && !canvas->imageInfo().colorSpace()) {
1010 return Error::Nonfatal("Skipping tests that are only interesting in srgb mode.");
msarett9ce3a542016-07-15 13:54:38 -07001011 }
1012
bungeman38d909e2016-08-02 14:40:46 -07001013 sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
msarett69deca82016-04-29 09:38:40 -07001014 if (!encoded) {
1015 return SkStringPrintf("Couldn't read %s.", fPath.c_str());
1016 }
1017
Ben Wagner145dbcd2016-11-03 14:40:50 -04001018 std::unique_ptr<SkCodec> codec(SkCodec::NewFromData(encoded));
msarett69deca82016-04-29 09:38:40 -07001019 if (nullptr == codec.get()) {
1020 return SkStringPrintf("Couldn't create codec for %s.", fPath.c_str());
1021 }
1022
msarett9876ac52016-06-01 14:47:18 -07001023 // Load the dst ICC profile. This particular dst is fairly similar to Adobe RGB.
1024 sk_sp<SkData> dstData = SkData::MakeFromFileName(
msaretta714bc32016-07-29 08:58:33 -07001025 GetResourcePath("icc_profiles/HP_ZR30w.icc").c_str());
msarett9876ac52016-06-01 14:47:18 -07001026 if (!dstData) {
1027 return "Cannot read monitor profile. Is the resource path set correctly?";
1028 }
1029
msarett50ce1f22016-07-29 06:23:33 -07001030 sk_sp<SkColorSpace> dstSpace = nullptr;
1031 if (kDst_sRGB_Mode == fMode) {
Matt Sarett77a7a1b2017-02-07 13:56:11 -05001032 dstSpace = SkColorSpace::MakeSRGB();
msarett50ce1f22016-07-29 06:23:33 -07001033 } else if (kDst_HPZR30w_Mode == fMode) {
Brian Osman526972e2016-10-24 09:24:02 -04001034 dstSpace = SkColorSpace::MakeICC(dstData->data(), dstData->size());
msarett50ce1f22016-07-29 06:23:33 -07001035 }
1036
1037 SkImageInfo decodeInfo = codec->getInfo().makeColorType(fColorType).makeColorSpace(dstSpace);
msarettd1ec89b2016-08-03 12:59:27 -07001038 if (kUnpremul_SkAlphaType == decodeInfo.alphaType()) {
1039 decodeInfo = decodeInfo.makeAlphaType(kPremul_SkAlphaType);
1040 }
msarett2ecc35f2016-09-08 11:55:16 -07001041 if (kRGBA_F16_SkColorType == fColorType) {
raftias94888332016-10-18 10:02:51 -07001042 SkASSERT(SkColorSpace_Base::Type::kXYZ == as_CSB(decodeInfo.colorSpace())->type());
1043 SkColorSpace_XYZ* csXYZ = static_cast<SkColorSpace_XYZ*>(decodeInfo.colorSpace());
1044 decodeInfo = decodeInfo.makeColorSpace(csXYZ->makeLinearGamma());
msarett2ecc35f2016-09-08 11:55:16 -07001045 }
msarettd1ec89b2016-08-03 12:59:27 -07001046
msarett50ce1f22016-07-29 06:23:33 -07001047 SkImageInfo bitmapInfo = decodeInfo;
1048 if (kRGBA_8888_SkColorType == decodeInfo.colorType() ||
1049 kBGRA_8888_SkColorType == decodeInfo.colorType())
1050 {
1051 bitmapInfo = bitmapInfo.makeColorType(kN32_SkColorType);
1052 }
1053
1054 SkBitmap bitmap;
1055 if (!bitmap.tryAllocPixels(bitmapInfo)) {
1056 return SkStringPrintf("Image(%s) is too large (%d x %d)", fPath.c_str(),
1057 bitmapInfo.width(), bitmapInfo.height());
1058 }
1059
1060 size_t rowBytes = bitmap.rowBytes();
1061 SkCodec::Result r = codec->getPixels(decodeInfo, bitmap.getPixels(), rowBytes);
msarettf7eb6fc2016-09-13 09:04:11 -07001062 if (SkCodec::kSuccess != r && SkCodec::kIncompleteInput != r) {
raftias54761282016-12-01 13:44:07 -05001063 return SkStringPrintf("Couldn't getPixels %s. Error code %d", fPath.c_str(), r);
msarett50ce1f22016-07-29 06:23:33 -07001064 }
1065
msarett69deca82016-04-29 09:38:40 -07001066 switch (fMode) {
1067 case kBaseline_Mode:
msarett39979d82016-07-28 17:11:18 -07001068 case kDst_sRGB_Mode:
msarett50ce1f22016-07-29 06:23:33 -07001069 case kDst_HPZR30w_Mode:
msarett39979d82016-07-28 17:11:18 -07001070 canvas->drawBitmap(bitmap, 0, 0);
1071 break;
msarett69deca82016-04-29 09:38:40 -07001072 default:
1073 SkASSERT(false);
1074 return "Invalid fMode";
1075 }
1076 return "";
1077}
1078
1079SkISize ColorCodecSrc::size() const {
bungeman38d909e2016-08-02 14:40:46 -07001080 sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
Ben Wagner145dbcd2016-11-03 14:40:50 -04001081 std::unique_ptr<SkCodec> codec(SkCodec::NewFromData(encoded));
msarett69deca82016-04-29 09:38:40 -07001082 if (nullptr == codec) {
Hal Canaryfafe1352017-04-11 12:12:02 -04001083 return {0, 0};
msarett69deca82016-04-29 09:38:40 -07001084 }
Hal Canaryfafe1352017-04-11 12:12:02 -04001085 return {codec->getInfo().width(), codec->getInfo().height()};
msarett69deca82016-04-29 09:38:40 -07001086}
1087
1088Name ColorCodecSrc::name() const {
1089 return SkOSPath::Basename(fPath.c_str());
1090}
1091
1092/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1093
mtkleinf4ba3212015-01-28 15:32:24 -08001094static const SkRect kSKPViewport = {0,0, 1000,1000};
1095
mtklein8d17a132015-01-30 11:42:31 -08001096SKPSrc::SKPSrc(Path path) : fPath(path) {}
mtklein748ca3b2015-01-15 10:56:12 -08001097
1098Error SKPSrc::draw(SkCanvas* canvas) const {
bungemanf93d7112016-09-16 06:24:20 -07001099 std::unique_ptr<SkStream> stream = SkStream::MakeFromFile(fPath.c_str());
mtklein75d98fd2015-01-18 07:05:01 -08001100 if (!stream) {
mtklein748ca3b2015-01-15 10:56:12 -08001101 return SkStringPrintf("Couldn't read %s.", fPath.c_str());
1102 }
bungemanf93d7112016-09-16 06:24:20 -07001103 sk_sp<SkPicture> pic(SkPicture::MakeFromStream(stream.get()));
mtklein75d98fd2015-01-18 07:05:01 -08001104 if (!pic) {
1105 return SkStringPrintf("Couldn't decode %s as a picture.", fPath.c_str());
1106 }
bungemanf93d7112016-09-16 06:24:20 -07001107 stream = nullptr; // Might as well drop this when we're done with it.
joshualitt7c3a2f82015-03-31 13:32:05 -07001108
mtkleinf4ba3212015-01-28 15:32:24 -08001109 canvas->clipRect(kSKPViewport);
mtklein748ca3b2015-01-15 10:56:12 -08001110 canvas->drawPicture(pic);
1111 return "";
1112}
1113
1114SkISize SKPSrc::size() const {
bungemanf93d7112016-09-16 06:24:20 -07001115 std::unique_ptr<SkStream> stream = SkStream::MakeFromFile(fPath.c_str());
mtkleinffa901a2015-03-16 10:38:07 -07001116 if (!stream) {
Hal Canaryfafe1352017-04-11 12:12:02 -04001117 return {0, 0};
mtkleinffa901a2015-03-16 10:38:07 -07001118 }
1119 SkPictInfo info;
bungemanf93d7112016-09-16 06:24:20 -07001120 if (!SkPicture::InternalOnly_StreamIsSKP(stream.get(), &info)) {
Hal Canaryfafe1352017-04-11 12:12:02 -04001121 return {0, 0};
mtkleinffa901a2015-03-16 10:38:07 -07001122 }
1123 SkRect viewport = kSKPViewport;
1124 if (!viewport.intersect(info.fCullRect)) {
Hal Canaryfafe1352017-04-11 12:12:02 -04001125 return {0, 0};
mtkleinffa901a2015-03-16 10:38:07 -07001126 }
1127 return viewport.roundOut().size();
mtklein748ca3b2015-01-15 10:56:12 -08001128}
1129
1130Name SKPSrc::name() const { return SkOSPath::Basename(fPath.c_str()); }
1131
1132/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
fmalitaa2b9fdf2016-08-03 19:53:36 -07001133#if defined(SK_XML)
fmalitabdf3e5c2016-09-17 07:26:26 -07001134// Used when the image doesn't have an intrinsic size.
Hal Canaryfafe1352017-04-11 12:12:02 -04001135static const SkSize kDefaultSVGSize = {1000, 1000};
fmalitaa2b9fdf2016-08-03 19:53:36 -07001136
fmalitabdf3e5c2016-09-17 07:26:26 -07001137// Used to force-scale tiny fixed-size images.
Hal Canaryfafe1352017-04-11 12:12:02 -04001138static const SkSize kMinimumSVGSize = {128, 128};
fmalitaa2b9fdf2016-08-03 19:53:36 -07001139
fmalitaacd2f5c2016-11-08 07:13:45 -08001140SVGSrc::SVGSrc(Path path)
1141 : fName(SkOSPath::Basename(path.c_str()))
1142 , fScale(1) {
fmalitabdf3e5c2016-09-17 07:26:26 -07001143
fmalitaacd2f5c2016-11-08 07:13:45 -08001144 SkFILEStream stream(path.c_str());
1145 if (!stream.isValid()) {
1146 return;
1147 }
1148 fDom = SkSVGDOM::MakeFromStream(stream);
1149 if (!fDom) {
1150 return;
1151 }
1152
1153 const SkSize& sz = fDom->containerSize();
1154 if (sz.isEmpty()) {
1155 // no intrinsic size
1156 fDom->setContainerSize(kDefaultSVGSize);
1157 } else {
1158 fScale = SkTMax(1.f, SkTMax(kMinimumSVGSize.width() / sz.width(),
1159 kMinimumSVGSize.height() / sz.height()));
1160 }
1161}
1162
1163Error SVGSrc::draw(SkCanvas* canvas) const {
fmalitabdf3e5c2016-09-17 07:26:26 -07001164 if (!fDom) {
fmalitaacd2f5c2016-11-08 07:13:45 -08001165 return SkStringPrintf("Unable to parse file: %s", fName.c_str());
fmalitaa2b9fdf2016-08-03 19:53:36 -07001166 }
1167
fmalitaacd2f5c2016-11-08 07:13:45 -08001168 SkAutoCanvasRestore acr(canvas, true);
1169 canvas->scale(fScale, fScale);
1170 fDom->render(canvas);
1171
fmalitaa2b9fdf2016-08-03 19:53:36 -07001172 return "";
1173}
1174
1175SkISize SVGSrc::size() const {
fmalitaacd2f5c2016-11-08 07:13:45 -08001176 if (!fDom) {
Hal Canaryfafe1352017-04-11 12:12:02 -04001177 return {0, 0};
fmalitabdf3e5c2016-09-17 07:26:26 -07001178 }
1179
Hal Canaryfafe1352017-04-11 12:12:02 -04001180 return SkSize{fDom->containerSize().width() * fScale, fDom->containerSize().height() * fScale}
1181 .toRound();
fmalitaa2b9fdf2016-08-03 19:53:36 -07001182}
1183
fmalitaacd2f5c2016-11-08 07:13:45 -08001184Name SVGSrc::name() const { return fName; }
fmalitaa2b9fdf2016-08-03 19:53:36 -07001185
fmalita179d8852016-08-16 14:23:29 -07001186bool SVGSrc::veto(SinkFlags flags) const {
1187 // No need to test to non-(raster||gpu) or indirect backends.
1188 bool type_ok = flags.type == SinkFlags::kRaster
1189 || flags.type == SinkFlags::kGPU;
1190
1191 return !type_ok || flags.approach != SinkFlags::kDirect;
1192}
1193
fmalitaa2b9fdf2016-08-03 19:53:36 -07001194#endif // defined(SK_XML)
1195/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
mtklein748ca3b2015-01-15 10:56:12 -08001196
halcanary45420a92016-06-02 12:41:14 -07001197MSKPSrc::MSKPSrc(Path path) : fPath(path) {
bungemanf93d7112016-09-16 06:24:20 -07001198 std::unique_ptr<SkStreamAsset> stream = SkStream::MakeFromFile(fPath.c_str());
Hal Canary45cde312017-04-03 16:06:42 -04001199 int count = SkMultiPictureDocumentReadPageCount(stream.get());
1200 if (count > 0) {
1201 fPages.reset(count);
1202 (void)SkMultiPictureDocumentReadPageSizes(stream.get(), &fPages[0], fPages.count());
1203 }
halcanary45420a92016-06-02 12:41:14 -07001204}
1205
Hal Canary45cde312017-04-03 16:06:42 -04001206int MSKPSrc::pageCount() const { return fPages.count(); }
halcanary45420a92016-06-02 12:41:14 -07001207
1208SkISize MSKPSrc::size() const { return this->size(0); }
Hal Canary45cde312017-04-03 16:06:42 -04001209SkISize MSKPSrc::size(int i) const {
Hal Canaryfafe1352017-04-11 12:12:02 -04001210 return i >= 0 && i < fPages.count() ? fPages[i].fSize.toCeil() : SkISize{0, 0};
Hal Canary45cde312017-04-03 16:06:42 -04001211}
halcanary45420a92016-06-02 12:41:14 -07001212
1213Error MSKPSrc::draw(SkCanvas* c) const { return this->draw(0, c); }
1214Error MSKPSrc::draw(int i, SkCanvas* canvas) const {
Hal Canary45cde312017-04-03 16:06:42 -04001215 if (this->pageCount() == 0) {
halcanary45420a92016-06-02 12:41:14 -07001216 return SkStringPrintf("Unable to parse MultiPictureDocument file: %s", fPath.c_str());
1217 }
Hal Canary45cde312017-04-03 16:06:42 -04001218 if (i >= fPages.count() || i < 0) {
halcanary45420a92016-06-02 12:41:14 -07001219 return SkStringPrintf("MultiPictureDocument page number out of range: %d", i);
1220 }
Hal Canary45cde312017-04-03 16:06:42 -04001221 SkPicture* page = fPages[i].fPicture.get();
halcanary45420a92016-06-02 12:41:14 -07001222 if (!page) {
Hal Canary45cde312017-04-03 16:06:42 -04001223 std::unique_ptr<SkStreamAsset> stream = SkStream::MakeFromFile(fPath.c_str());
1224 if (!stream) {
1225 return SkStringPrintf("Unable to open file: %s", fPath.c_str());
1226 }
1227 if (!SkMultiPictureDocumentRead(stream.get(), &fPages[0], fPages.count())) {
1228 return SkStringPrintf("SkMultiPictureDocument reader failed on page %d: %s", i,
1229 fPath.c_str());
1230 }
1231 page = fPages[i].fPicture.get();
halcanary45420a92016-06-02 12:41:14 -07001232 }
1233 canvas->drawPicture(page);
1234 return "";
1235}
1236
1237Name MSKPSrc::name() const { return SkOSPath::Basename(fPath.c_str()); }
1238
1239/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1240
mtkleinad66f9b2015-02-13 15:11:10 -08001241Error NullSink::draw(const Src& src, SkBitmap*, SkWStream*, SkString*) const {
Mike Reed5df49342016-11-12 08:06:55 -06001242 return src.draw(SkMakeNullCanvas().get());
mtkleinad66f9b2015-02-13 15:11:10 -08001243}
1244
1245/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1246
mtkleinb9eb4ac2015-02-02 18:26:03 -08001247DEFINE_bool(gpuStats, false, "Append GPU stats to the log for each GPU task?");
1248
bsalomon85b4b532016-04-05 11:06:27 -07001249GPUSink::GPUSink(GrContextFactory::ContextType ct,
csmartdaltone812d492017-02-21 12:36:05 -07001250 GrContextFactory::ContextOverrides overrides,
mtklein82d28432015-01-15 12:46:02 -08001251 int samples,
bsalomonafcd7cd2015-08-31 12:39:41 -07001252 bool diText,
brianosmand93c1202016-03-10 07:49:08 -08001253 SkColorType colorType,
brianosmanb109b8c2016-06-16 13:03:24 -07001254 sk_sp<SkColorSpace> colorSpace,
mtklein82d28432015-01-15 12:46:02 -08001255 bool threaded)
mtklein748ca3b2015-01-15 10:56:12 -08001256 : fContextType(ct)
csmartdaltone812d492017-02-21 12:36:05 -07001257 , fContextOverrides(overrides)
mtklein748ca3b2015-01-15 10:56:12 -08001258 , fSampleCount(samples)
bsalomonafcd7cd2015-08-31 12:39:41 -07001259 , fUseDIText(diText)
brianosmand93c1202016-03-10 07:49:08 -08001260 , fColorType(colorType)
brianosmanb109b8c2016-06-16 13:03:24 -07001261 , fColorSpace(std::move(colorSpace))
mtklein82d28432015-01-15 12:46:02 -08001262 , fThreaded(threaded) {}
mtklein748ca3b2015-01-15 10:56:12 -08001263
bsalomon648c6962015-10-23 09:06:59 -07001264DEFINE_bool(imm, false, "Run gpu configs in immediate mode.");
Brian Salomon09d994e2016-12-21 11:14:46 -05001265DEFINE_bool(drawOpClip, false, "Clip each GrDrawOp to its device bounds for testing.");
1266DEFINE_int32(opLookback, -1, "Maximum GrOp lookback for combining, negative means default.");
1267DEFINE_int32(opLookahead, -1, "Maximum GrOp lookahead for combining, negative means default.");
bsalomon648c6962015-10-23 09:06:59 -07001268
mtkleinb9eb4ac2015-02-02 18:26:03 -08001269Error GPUSink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString* log) const {
kkinnunen5219fd92015-12-10 06:28:13 -08001270 GrContextOptions grOptions;
bsalomon489147c2015-12-14 12:13:09 -08001271 grOptions.fImmediateMode = FLAGS_imm;
Brian Salomon09d994e2016-12-21 11:14:46 -05001272 grOptions.fMaxOpCombineLookback = FLAGS_opLookback;
1273 grOptions.fMaxOpCombineLookahead = FLAGS_opLookahead;
kkinnunen64492c42015-12-08 01:24:40 -08001274
kkinnunen5219fd92015-12-10 06:28:13 -08001275 src.modifyGrContextOptions(&grOptions);
1276
1277 GrContextFactory factory(grOptions);
mtkleinf4ba3212015-01-28 15:32:24 -08001278 const SkISize size = src.size();
mtklein748ca3b2015-01-15 10:56:12 -08001279 const SkImageInfo info =
brianosmand93c1202016-03-10 07:49:08 -08001280 SkImageInfo::Make(size.width(), size.height(), fColorType,
brianosmanb109b8c2016-06-16 13:03:24 -07001281 kPremul_SkAlphaType, fColorSpace);
msarett13a036b2016-02-08 09:10:47 -08001282#if SK_SUPPORT_GPU
csmartdaltone812d492017-02-21 12:36:05 -07001283 GrContext* context = factory.getContextInfo(fContextType, fContextOverrides).grContext();
bsalomon8b7451a2016-05-11 06:33:06 -07001284 const int maxDimension = context->caps()->maxTextureSize();
msarett13a036b2016-02-08 09:10:47 -08001285 if (maxDimension < SkTMax(size.width(), size.height())) {
1286 return Error::Nonfatal("Src too large to create a texture.\n");
1287 }
1288#endif
1289
reede8f30622016-03-23 18:59:25 -07001290 auto surface(
csmartdaltone812d492017-02-21 12:36:05 -07001291 NewGpuSurface(&factory, fContextType, fContextOverrides, info, fSampleCount, fUseDIText));
mtklein748ca3b2015-01-15 10:56:12 -08001292 if (!surface) {
1293 return "Could not create a surface.";
1294 }
joshualitt5f5a8d72015-02-25 14:09:45 -08001295 if (FLAGS_preAbandonGpuContext) {
joshualitt5f5a8d72015-02-25 14:09:45 -08001296 factory.abandonContexts();
1297 }
mtklein748ca3b2015-01-15 10:56:12 -08001298 SkCanvas* canvas = surface->getCanvas();
1299 Error err = src.draw(canvas);
1300 if (!err.isEmpty()) {
1301 return err;
1302 }
1303 canvas->flush();
mtkleinb9eb4ac2015-02-02 18:26:03 -08001304 if (FLAGS_gpuStats) {
1305 canvas->getGrContext()->dumpCacheStats(log);
1306 canvas->getGrContext()->dumpGpuStats(log);
1307 }
mtklein748ca3b2015-01-15 10:56:12 -08001308 dst->allocPixels(info);
joshualitt5f5a8d72015-02-25 14:09:45 -08001309 canvas->readPixels(dst, 0, 0);
mtklein55e88b22015-01-21 15:50:13 -08001310 if (FLAGS_abandonGpuContext) {
1311 factory.abandonContexts();
bsalomon6e2aad42016-04-01 11:54:31 -07001312 } else if (FLAGS_releaseAndAbandonGpuContext) {
1313 factory.releaseResourcesAndAbandonContexts();
mtklein55e88b22015-01-21 15:50:13 -08001314 }
mtklein748ca3b2015-01-15 10:56:12 -08001315 return "";
1316}
1317
1318/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1319
halcanary47ef4d52015-03-03 09:13:09 -08001320static Error draw_skdocument(const Src& src, SkDocument* doc, SkWStream* dst) {
halcanary4ba051c2016-03-10 10:31:53 -08001321 if (src.size().isEmpty()) {
1322 return "Source has empty dimensions";
1323 }
halcanary47ef4d52015-03-03 09:13:09 -08001324 SkASSERT(doc);
halcanary45420a92016-06-02 12:41:14 -07001325 int pageCount = src.pageCount();
1326 for (int i = 0; i < pageCount; ++i) {
1327 int width = src.size(i).width(), height = src.size(i).height();
halcanary7e798182015-04-14 14:06:18 -07001328 SkCanvas* canvas =
1329 doc->beginPage(SkIntToScalar(width), SkIntToScalar(height));
1330 if (!canvas) {
halcanary96fcdcc2015-08-27 07:41:13 -07001331 return "SkDocument::beginPage(w,h) returned nullptr";
halcanary7e798182015-04-14 14:06:18 -07001332 }
halcanary45420a92016-06-02 12:41:14 -07001333 Error err = src.draw(i, canvas);
halcanary7e798182015-04-14 14:06:18 -07001334 if (!err.isEmpty()) {
1335 return err;
1336 }
1337 doc->endPage();
mtklein748ca3b2015-01-15 10:56:12 -08001338 }
reedd14df7c2016-09-22 14:12:46 -07001339 doc->close();
halcanaryfd4a9932015-01-28 11:45:58 -08001340 dst->flush();
mtklein748ca3b2015-01-15 10:56:12 -08001341 return "";
1342}
1343
halcanary47ef4d52015-03-03 09:13:09 -08001344Error PDFSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
halcanary4b656662016-04-27 07:45:18 -07001345 SkDocument::PDFMetadata metadata;
1346 metadata.fTitle = src.name();
1347 metadata.fSubject = "rendering correctness test";
1348 metadata.fCreator = "Skia/DM";
1349 sk_sp<SkDocument> doc = SkDocument::MakePDF(dst, SK_ScalarDefaultRasterDPI,
1350 metadata, nullptr, fPDFA);
halcanary47ef4d52015-03-03 09:13:09 -08001351 if (!doc) {
halcanary4b656662016-04-27 07:45:18 -07001352 return "SkDocument::MakePDF() returned nullptr";
halcanary47ef4d52015-03-03 09:13:09 -08001353 }
1354 return draw_skdocument(src, doc.get(), dst);
1355}
1356
1357/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1358
1359XPSSink::XPSSink() {}
1360
Hal Canaryabc88d22017-02-06 09:26:49 -05001361#ifdef SK_BUILD_FOR_WIN
Hal Canary5e221e72017-02-06 09:51:42 -05001362static SkTScopedComPtr<IXpsOMObjectFactory> make_xps_factory() {
1363 IXpsOMObjectFactory* factory;
1364 HRN(CoCreateInstance(CLSID_XpsOMObjectFactory,
1365 nullptr,
1366 CLSCTX_INPROC_SERVER,
1367 IID_PPV_ARGS(&factory)));
1368 return SkTScopedComPtr<IXpsOMObjectFactory>(factory);
1369}
1370
1371Error XPSSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
Hal Canaryabc88d22017-02-06 09:26:49 -05001372 SkAutoCoInitialize com;
1373 if (!com.succeeded()) {
1374 return "Could not initialize COM.";
1375 }
Hal Canary5e221e72017-02-06 09:51:42 -05001376 SkTScopedComPtr<IXpsOMObjectFactory> factory = make_xps_factory();
1377 if (!factory) {
1378 return "Failed to create XPS Factory.";
1379 }
1380 sk_sp<SkDocument> doc(SkDocument::MakeXPS(dst, factory.get()));
halcanary47ef4d52015-03-03 09:13:09 -08001381 if (!doc) {
halcanary4b656662016-04-27 07:45:18 -07001382 return "SkDocument::MakeXPS() returned nullptr";
halcanary47ef4d52015-03-03 09:13:09 -08001383 }
1384 return draw_skdocument(src, doc.get(), dst);
1385}
Hal Canary5e221e72017-02-06 09:51:42 -05001386#else
1387Error XPSSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
1388 return "XPS not supported on this platform.";
1389}
1390#endif
reed54dc4872016-09-13 08:09:45 -07001391
1392/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1393
1394PipeSink::PipeSink() {}
1395
1396Error PipeSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
1397 return src.draw(SkPipeSerializer().beginWrite(SkRect::Make(src.size()), dst));
1398}
1399
mtklein748ca3b2015-01-15 10:56:12 -08001400/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1401
mtklein9c3f17d2015-01-28 11:35:18 -08001402SKPSink::SKPSink() {}
1403
mtkleinb9eb4ac2015-02-02 18:26:03 -08001404Error SKPSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
mtklein9c3f17d2015-01-28 11:35:18 -08001405 SkSize size;
1406 size = src.size();
1407 SkPictureRecorder recorder;
1408 Error err = src.draw(recorder.beginRecording(size.width(), size.height()));
1409 if (!err.isEmpty()) {
1410 return err;
1411 }
reedca2622b2016-03-18 07:25:55 -07001412 recorder.finishRecordingAsPicture()->serialize(dst);
mtklein9c3f17d2015-01-28 11:35:18 -08001413 return "";
1414}
1415
1416/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1417
Hal Canary85c7fe82016-10-25 10:33:27 -04001418Error DebugSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
1419 SkDebugCanvas debugCanvas(src.size().width(), src.size().height());
1420 Error err = src.draw(&debugCanvas);
1421 if (!err.isEmpty()) {
1422 return err;
1423 }
Mike Reed5df49342016-11-12 08:06:55 -06001424 std::unique_ptr<SkCanvas> nullCanvas = SkMakeNullCanvas();
Hal Canary85c7fe82016-10-25 10:33:27 -04001425 UrlDataManager dataManager(SkString("data"));
1426 Json::Value json = debugCanvas.toJSON(
1427 dataManager, debugCanvas.getSize(), nullCanvas.get());
1428 std::string value = Json::StyledWriter().write(json);
1429 return dst->write(value.c_str(), value.size()) ? "" : "SkWStream Error";
1430}
1431
1432/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1433
mtklein8a4527e2015-01-31 20:00:58 -08001434SVGSink::SVGSink() {}
1435
mtkleinb9eb4ac2015-02-02 18:26:03 -08001436Error SVGSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
fmalita718df0a2016-07-15 10:33:29 -07001437#if defined(SK_XML)
Ben Wagner145dbcd2016-11-03 14:40:50 -04001438 std::unique_ptr<SkXMLWriter> xmlWriter(new SkXMLStreamWriter(dst));
Mike Reed5df49342016-11-12 08:06:55 -06001439 return src.draw(SkSVGCanvas::Make(SkRect::MakeWH(SkIntToScalar(src.size().width()),
1440 SkIntToScalar(src.size().height())),
1441 xmlWriter.get()).get());
fmalita718df0a2016-07-15 10:33:29 -07001442#else
1443 return Error("SVG sink is disabled.");
1444#endif // SK_XML
mtklein8a4527e2015-01-31 20:00:58 -08001445}
1446
1447/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1448
brianosmanb109b8c2016-06-16 13:03:24 -07001449RasterSink::RasterSink(SkColorType colorType, sk_sp<SkColorSpace> colorSpace)
mtklein27c3fdd2016-02-26 14:43:21 -08001450 : fColorType(colorType)
brianosmanb109b8c2016-06-16 13:03:24 -07001451 , fColorSpace(std::move(colorSpace)) {}
mtklein748ca3b2015-01-15 10:56:12 -08001452
mtkleinb9eb4ac2015-02-02 18:26:03 -08001453Error RasterSink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString*) const {
mtkleinf4ba3212015-01-28 15:32:24 -08001454 const SkISize size = src.size();
mtklein748ca3b2015-01-15 10:56:12 -08001455 // If there's an appropriate alpha type for this color type, use it, otherwise use premul.
1456 SkAlphaType alphaType = kPremul_SkAlphaType;
1457 (void)SkColorTypeValidateAlphaType(fColorType, alphaType, &alphaType);
1458
mtklein27c3fdd2016-02-26 14:43:21 -08001459 dst->allocPixels(SkImageInfo::Make(size.width(), size.height(),
brianosmanb109b8c2016-06-16 13:03:24 -07001460 fColorType, alphaType, fColorSpace),
Mike Reed6b3155c2017-04-03 14:41:44 -04001461 nullptr/*colortable*/, SkBitmap::kZeroPixels_AllocFlag);
mtklein748ca3b2015-01-15 10:56:12 -08001462 SkCanvas canvas(*dst);
1463 return src.draw(&canvas);
1464}
1465
1466/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1467
mtkleina16e69e2015-05-05 11:38:45 -07001468// Handy for front-patching a Src. Do whatever up-front work you need, then call draw_to_canvas(),
mtkleine44b5082015-05-07 10:53:34 -07001469// passing the Sink draw() arguments, a size, and a function draws into an SkCanvas.
mtkleina16e69e2015-05-05 11:38:45 -07001470// Several examples below.
1471
mtkleincbf89782016-02-19 14:27:14 -08001472template <typename Fn>
msarett62d3b102015-12-10 15:14:27 -08001473static Error draw_to_canvas(Sink* sink, SkBitmap* bitmap, SkWStream* stream, SkString* log,
mtkleincbf89782016-02-19 14:27:14 -08001474 SkISize size, const Fn& draw) {
mtkleina16e69e2015-05-05 11:38:45 -07001475 class ProxySrc : public Src {
1476 public:
mtkleincbf89782016-02-19 14:27:14 -08001477 ProxySrc(SkISize size, const Fn& draw) : fSize(size), fDraw(draw) {}
mtkleina16e69e2015-05-05 11:38:45 -07001478 Error draw(SkCanvas* canvas) const override { return fDraw(canvas); }
halcanaryb4a7f142016-03-30 08:31:27 -07001479 Name name() const override { return "ProxySrc"; }
1480 SkISize size() const override { return fSize; }
mtkleina16e69e2015-05-05 11:38:45 -07001481 private:
mtkleincbf89782016-02-19 14:27:14 -08001482 SkISize fSize;
1483 const Fn& fDraw;
mtkleina16e69e2015-05-05 11:38:45 -07001484 };
msarett62d3b102015-12-10 15:14:27 -08001485 return sink->draw(ProxySrc(size, draw), bitmap, stream, log);
mtkleina16e69e2015-05-05 11:38:45 -07001486}
1487
1488/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1489
mtklein4a34ecb2016-01-08 10:19:35 -08001490DEFINE_bool(check, true, "If true, have most Via- modes fail if they affect the output.");
1491
1492// Is *bitmap identical to what you get drawing src into sink?
1493static Error check_against_reference(const SkBitmap* bitmap, const Src& src, Sink* sink) {
1494 // We can only check raster outputs.
1495 // (Non-raster outputs like .pdf, .skp, .svg may differ but still draw identically.)
1496 if (FLAGS_check && bitmap) {
1497 SkBitmap reference;
1498 SkString log;
halcanaryb4a7f142016-03-30 08:31:27 -07001499 SkDynamicMemoryWStream wStream;
1500 Error err = sink->draw(src, &reference, &wStream, &log);
mtklein4a34ecb2016-01-08 10:19:35 -08001501 // If we can draw into this Sink via some pipeline, we should be able to draw directly.
1502 SkASSERT(err.isEmpty());
1503 if (!err.isEmpty()) {
1504 return err;
1505 }
1506 // The dimensions are a property of the Src only, and so should be identical.
1507 SkASSERT(reference.getSize() == bitmap->getSize());
1508 if (reference.getSize() != bitmap->getSize()) {
1509 return "Dimensions don't match reference";
1510 }
1511 // All SkBitmaps in DM are pre-locked and tight, so this comparison is easy.
1512 if (0 != memcmp(reference.getPixels(), bitmap->getPixels(), reference.getSize())) {
1513 return "Pixels don't match reference";
1514 }
1515 }
1516 return "";
1517}
1518
1519/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1520
mtkleind603b222015-02-17 11:13:33 -08001521static SkISize auto_compute_translate(SkMatrix* matrix, int srcW, int srcH) {
1522 SkRect bounds = SkRect::MakeIWH(srcW, srcH);
1523 matrix->mapRect(&bounds);
1524 matrix->postTranslate(-bounds.x(), -bounds.y());
Hal Canaryfafe1352017-04-11 12:12:02 -04001525 return {SkScalarRoundToInt(bounds.width()), SkScalarRoundToInt(bounds.height())};
mtkleind603b222015-02-17 11:13:33 -08001526}
1527
msarett62d3b102015-12-10 15:14:27 -08001528ViaMatrix::ViaMatrix(SkMatrix matrix, Sink* sink) : Via(sink), fMatrix(matrix) {}
mtklein748ca3b2015-01-15 10:56:12 -08001529
mtkleinb9eb4ac2015-02-02 18:26:03 -08001530Error ViaMatrix::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
mtkleina16e69e2015-05-05 11:38:45 -07001531 SkMatrix matrix = fMatrix;
1532 SkISize size = auto_compute_translate(&matrix, src.size().width(), src.size().height());
Ben Wagner145dbcd2016-11-03 14:40:50 -04001533 return draw_to_canvas(fSink.get(), bitmap, stream, log, size, [&](SkCanvas* canvas) {
mtkleina16e69e2015-05-05 11:38:45 -07001534 canvas->concat(matrix);
1535 return src.draw(canvas);
1536 });
mtklein748ca3b2015-01-15 10:56:12 -08001537}
1538
mtkleind603b222015-02-17 11:13:33 -08001539// Undoes any flip or 90 degree rotate without changing the scale of the bitmap.
1540// This should be pixel-preserving.
msarett62d3b102015-12-10 15:14:27 -08001541ViaUpright::ViaUpright(SkMatrix matrix, Sink* sink) : Via(sink), fMatrix(matrix) {}
mtkleind603b222015-02-17 11:13:33 -08001542
1543Error ViaUpright::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
1544 Error err = fSink->draw(src, bitmap, stream, log);
1545 if (!err.isEmpty()) {
1546 return err;
1547 }
1548
1549 SkMatrix inverse;
1550 if (!fMatrix.rectStaysRect() || !fMatrix.invert(&inverse)) {
1551 return "Cannot upright --matrix.";
1552 }
1553 SkMatrix upright = SkMatrix::I();
1554 upright.setScaleX(SkScalarSignAsScalar(inverse.getScaleX()));
1555 upright.setScaleY(SkScalarSignAsScalar(inverse.getScaleY()));
1556 upright.setSkewX(SkScalarSignAsScalar(inverse.getSkewX()));
1557 upright.setSkewY(SkScalarSignAsScalar(inverse.getSkewY()));
1558
1559 SkBitmap uprighted;
1560 SkISize size = auto_compute_translate(&upright, bitmap->width(), bitmap->height());
1561 uprighted.allocPixels(bitmap->info().makeWH(size.width(), size.height()));
1562
1563 SkCanvas canvas(uprighted);
1564 canvas.concat(upright);
1565 SkPaint paint;
reed374772b2016-10-05 17:33:02 -07001566 paint.setBlendMode(SkBlendMode::kSrc);
mtkleind603b222015-02-17 11:13:33 -08001567 canvas.drawBitmap(*bitmap, 0, 0, &paint);
1568
1569 *bitmap = uprighted;
1570 bitmap->lockPixels();
1571 return "";
1572}
1573
mtklein748ca3b2015-01-15 10:56:12 -08001574/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1575
mtkleina16e69e2015-05-05 11:38:45 -07001576Error ViaSerialization::draw(
1577 const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
mtklein748ca3b2015-01-15 10:56:12 -08001578 // Record our Src into a picture.
mtkleina16e69e2015-05-05 11:38:45 -07001579 auto size = src.size();
mtklein748ca3b2015-01-15 10:56:12 -08001580 SkPictureRecorder recorder;
mtkleina16e69e2015-05-05 11:38:45 -07001581 Error err = src.draw(recorder.beginRecording(SkIntToScalar(size.width()),
1582 SkIntToScalar(size.height())));
mtklein748ca3b2015-01-15 10:56:12 -08001583 if (!err.isEmpty()) {
1584 return err;
1585 }
reedca2622b2016-03-18 07:25:55 -07001586 sk_sp<SkPicture> pic(recorder.finishRecordingAsPicture());
mtklein748ca3b2015-01-15 10:56:12 -08001587
1588 // Serialize it and then deserialize it.
reed39eaf5f2016-09-15 07:19:35 -07001589 sk_sp<SkPicture> deserialized(SkPicture::MakeFromData(pic->serialize().get()));
mtklein748ca3b2015-01-15 10:56:12 -08001590
Ben Wagner145dbcd2016-11-03 14:40:50 -04001591 return draw_to_canvas(fSink.get(), bitmap, stream, log, size, [&](SkCanvas* canvas) {
mtkleina16e69e2015-05-05 11:38:45 -07001592 canvas->drawPicture(deserialized);
Ben Wagner145dbcd2016-11-03 14:40:50 -04001593 return check_against_reference(bitmap, src, fSink.get());
mtkleina16e69e2015-05-05 11:38:45 -07001594 });
mtklein748ca3b2015-01-15 10:56:12 -08001595}
1596
1597/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1598
msarett62d3b102015-12-10 15:14:27 -08001599ViaTiles::ViaTiles(int w, int h, SkBBHFactory* factory, Sink* sink)
1600 : Via(sink)
mtklein78829242015-05-06 07:54:07 -07001601 , fW(w)
mtklein748ca3b2015-01-15 10:56:12 -08001602 , fH(h)
mtklein78829242015-05-06 07:54:07 -07001603 , fFactory(factory) {}
mtklein748ca3b2015-01-15 10:56:12 -08001604
mtkleinb9eb4ac2015-02-02 18:26:03 -08001605Error ViaTiles::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
mtkleina16e69e2015-05-05 11:38:45 -07001606 auto size = src.size();
mtklein748ca3b2015-01-15 10:56:12 -08001607 SkPictureRecorder recorder;
mtkleina16e69e2015-05-05 11:38:45 -07001608 Error err = src.draw(recorder.beginRecording(SkIntToScalar(size.width()),
1609 SkIntToScalar(size.height()),
1610 fFactory.get()));
mtklein748ca3b2015-01-15 10:56:12 -08001611 if (!err.isEmpty()) {
1612 return err;
1613 }
reedca2622b2016-03-18 07:25:55 -07001614 sk_sp<SkPicture> pic(recorder.finishRecordingAsPicture());
mtklein748ca3b2015-01-15 10:56:12 -08001615
Ben Wagner145dbcd2016-11-03 14:40:50 -04001616 return draw_to_canvas(fSink.get(), bitmap, stream, log, src.size(), [&](SkCanvas* canvas) {
mtkleina16e69e2015-05-05 11:38:45 -07001617 const int xTiles = (size.width() + fW - 1) / fW,
1618 yTiles = (size.height() + fH - 1) / fH;
1619 SkMultiPictureDraw mpd(xTiles*yTiles);
reede8f30622016-03-23 18:59:25 -07001620 SkTArray<sk_sp<SkSurface>> surfaces;
1621// surfaces.setReserve(xTiles*yTiles);
mtklein748ca3b2015-01-15 10:56:12 -08001622
mtkleina16e69e2015-05-05 11:38:45 -07001623 SkImageInfo info = canvas->imageInfo().makeWH(fW, fH);
1624 for (int j = 0; j < yTiles; j++) {
1625 for (int i = 0; i < xTiles; i++) {
1626 // This lets our ultimate Sink determine the best kind of surface.
1627 // E.g., if it's a GpuSink, the surfaces and images are textures.
reede8f30622016-03-23 18:59:25 -07001628 auto s = canvas->makeSurface(info);
mtkleina16e69e2015-05-05 11:38:45 -07001629 if (!s) {
reede8f30622016-03-23 18:59:25 -07001630 s = SkSurface::MakeRaster(info); // Some canvases can't create surfaces.
mtklein748ca3b2015-01-15 10:56:12 -08001631 }
reede8f30622016-03-23 18:59:25 -07001632 surfaces.push_back(s);
mtkleina16e69e2015-05-05 11:38:45 -07001633 SkCanvas* c = s->getCanvas();
1634 c->translate(SkIntToScalar(-i * fW),
1635 SkIntToScalar(-j * fH)); // Line up the canvas with this tile.
reedca2622b2016-03-18 07:25:55 -07001636 mpd.add(c, pic.get());
mtklein748ca3b2015-01-15 10:56:12 -08001637 }
mtklein748ca3b2015-01-15 10:56:12 -08001638 }
mtkleina16e69e2015-05-05 11:38:45 -07001639 mpd.draw();
1640 for (int j = 0; j < yTiles; j++) {
1641 for (int i = 0; i < xTiles; i++) {
reed9ce9d672016-03-17 10:51:11 -07001642 sk_sp<SkImage> image(surfaces[i+xTiles*j]->makeImageSnapshot());
mtkleina16e69e2015-05-05 11:38:45 -07001643 canvas->drawImage(image, SkIntToScalar(i*fW), SkIntToScalar(j*fH));
1644 }
1645 }
mtkleina16e69e2015-05-05 11:38:45 -07001646 return "";
1647 });
mtklein748ca3b2015-01-15 10:56:12 -08001648}
1649
mtkleinb7e8d692015-04-07 08:30:32 -07001650/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1651
mtklein4a34ecb2016-01-08 10:19:35 -08001652Error ViaPicture::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
1653 auto size = src.size();
Ben Wagner145dbcd2016-11-03 14:40:50 -04001654 return draw_to_canvas(fSink.get(), bitmap, stream, log, size, [&](SkCanvas* canvas) -> Error {
mtklein4a34ecb2016-01-08 10:19:35 -08001655 SkPictureRecorder recorder;
reedca2622b2016-03-18 07:25:55 -07001656 sk_sp<SkPicture> pic;
mtklein4a34ecb2016-01-08 10:19:35 -08001657 Error err = src.draw(recorder.beginRecording(SkIntToScalar(size.width()),
1658 SkIntToScalar(size.height())));
1659 if (!err.isEmpty()) {
1660 return err;
1661 }
reedca2622b2016-03-18 07:25:55 -07001662 pic = recorder.finishRecordingAsPicture();
mtklein4a34ecb2016-01-08 10:19:35 -08001663 canvas->drawPicture(pic);
Ben Wagner145dbcd2016-11-03 14:40:50 -04001664 return check_against_reference(bitmap, src, fSink.get());
mtklein4a34ecb2016-01-08 10:19:35 -08001665 });
1666}
1667
1668/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1669
reedbabc3de2016-07-08 08:43:27 -07001670Error ViaDefer::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
1671 auto size = src.size();
Ben Wagner145dbcd2016-11-03 14:40:50 -04001672 return draw_to_canvas(fSink.get(), bitmap, stream, log, size, [&](SkCanvas* canvas) -> Error {
Herb Derby1a3c4b82017-03-17 15:51:53 -04001673 SkDeferredCanvas deferred(canvas, SkDeferredCanvas::kEager);
reedbabc3de2016-07-08 08:43:27 -07001674 return src.draw(&deferred);
1675 });
1676}
1677
1678/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1679
reed54dc4872016-09-13 08:09:45 -07001680Error ViaPipe::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
1681 auto size = src.size();
Ben Wagner145dbcd2016-11-03 14:40:50 -04001682 return draw_to_canvas(fSink.get(), bitmap, stream, log, size, [&](SkCanvas* canvas) -> Error {
reed54dc4872016-09-13 08:09:45 -07001683 SkDynamicMemoryWStream tmpStream;
1684 Error err = src.draw(SkPipeSerializer().beginWrite(SkRect::Make(size), &tmpStream));
1685 if (!err.isEmpty()) {
1686 return err;
1687 }
1688 sk_sp<SkData> data = tmpStream.detachAsData();
1689 SkPipeDeserializer().playback(data->data(), data->size(), canvas);
Ben Wagner145dbcd2016-11-03 14:40:50 -04001690 return check_against_reference(bitmap, src, fSink.get());
reed54dc4872016-09-13 08:09:45 -07001691 });
1692}
1693
1694/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1695
mtkleinb7e8d692015-04-07 08:30:32 -07001696// Draw the Src into two pictures, then draw the second picture into the wrapped Sink.
1697// This tests that any shortcuts we may take while recording that second picture are legal.
1698Error ViaSecondPicture::draw(
1699 const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
mtkleina16e69e2015-05-05 11:38:45 -07001700 auto size = src.size();
Ben Wagner145dbcd2016-11-03 14:40:50 -04001701 return draw_to_canvas(fSink.get(), bitmap, stream, log, size, [&](SkCanvas* canvas) -> Error {
mtkleina16e69e2015-05-05 11:38:45 -07001702 SkPictureRecorder recorder;
reedca2622b2016-03-18 07:25:55 -07001703 sk_sp<SkPicture> pic;
mtkleina16e69e2015-05-05 11:38:45 -07001704 for (int i = 0; i < 2; i++) {
1705 Error err = src.draw(recorder.beginRecording(SkIntToScalar(size.width()),
1706 SkIntToScalar(size.height())));
1707 if (!err.isEmpty()) {
1708 return err;
mtkleinb7e8d692015-04-07 08:30:32 -07001709 }
reedca2622b2016-03-18 07:25:55 -07001710 pic = recorder.finishRecordingAsPicture();
mtkleinb7e8d692015-04-07 08:30:32 -07001711 }
mtkleina16e69e2015-05-05 11:38:45 -07001712 canvas->drawPicture(pic);
Ben Wagner145dbcd2016-11-03 14:40:50 -04001713 return check_against_reference(bitmap, src, fSink.get());
mtkleina16e69e2015-05-05 11:38:45 -07001714 });
mtkleinb7e8d692015-04-07 08:30:32 -07001715}
1716
mtkleind31c13d2015-05-05 12:59:56 -07001717/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1718
mtklein6fbf4b32015-05-06 11:35:40 -07001719// Draw the Src twice. This can help exercise caching.
1720Error ViaTwice::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
Ben Wagner145dbcd2016-11-03 14:40:50 -04001721 return draw_to_canvas(fSink.get(), bitmap, stream, log, src.size(), [&](SkCanvas* canvas) -> Error {
mtklein6fbf4b32015-05-06 11:35:40 -07001722 for (int i = 0; i < 2; i++) {
1723 SkAutoCanvasRestore acr(canvas, true/*save now*/);
1724 canvas->clear(SK_ColorTRANSPARENT);
1725 Error err = src.draw(canvas);
1726 if (err.isEmpty()) {
1727 return err;
1728 }
1729 }
Ben Wagner145dbcd2016-11-03 14:40:50 -04001730 return check_against_reference(bitmap, src, fSink.get());
mtklein6fbf4b32015-05-06 11:35:40 -07001731 });
1732}
1733
1734/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1735
Mike Reedbae888e2017-02-18 16:50:45 -05001736#ifdef TEST_VIA_SVG
Mike Reedf67c4592017-02-17 17:06:11 -05001737#include "SkXMLWriter.h"
1738#include "SkSVGCanvas.h"
1739#include "SkSVGDOM.h"
1740
1741Error ViaSVG::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
1742 auto size = src.size();
1743 return draw_to_canvas(fSink.get(), bitmap, stream, log, size, [&](SkCanvas* canvas) -> Error {
1744 SkDynamicMemoryWStream wstream;
1745 SkXMLStreamWriter writer(&wstream);
1746 Error err = src.draw(SkSVGCanvas::Make(SkRect::Make(size), &writer).get());
1747 if (!err.isEmpty()) {
1748 return err;
1749 }
1750 std::unique_ptr<SkStream> rstream(wstream.detachAsStream());
1751 auto dom = SkSVGDOM::MakeFromStream(*rstream);
1752 if (dom) {
1753 dom->setContainerSize(SkSize::Make(size));
1754 dom->render(canvas);
1755 }
1756 return "";
1757 });
1758}
Mike Reedbae888e2017-02-18 16:50:45 -05001759#endif
Mike Reedf67c4592017-02-17 17:06:11 -05001760
1761/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1762
mtkleind31c13d2015-05-05 12:59:56 -07001763// This is like SkRecords::Draw, in that it plays back SkRecords ops into a Canvas.
1764// Unlike SkRecords::Draw, it builds a single-op sub-picture out of each Draw-type op.
1765// This is an only-slightly-exaggerated simluation of Blink's Slimming Paint pictures.
1766struct DrawsAsSingletonPictures {
1767 SkCanvas* fCanvas;
mtkleind2baa902015-07-07 09:43:28 -07001768 const SkDrawableList& fDrawables;
mtklein11064df2016-04-06 15:01:57 -07001769 SkRect fBounds;
mtkleind31c13d2015-05-05 12:59:56 -07001770
mtkleind31c13d2015-05-05 12:59:56 -07001771 template <typename T>
1772 void draw(const T& op, SkCanvas* canvas) {
1773 // We must pass SkMatrix::I() as our initial matrix.
1774 // By default SkRecords::Draw() uses the canvas' matrix as its initial matrix,
1775 // which would have the funky effect of applying transforms over and over.
mtkleind2baa902015-07-07 09:43:28 -07001776 SkRecords::Draw d(canvas, nullptr, fDrawables.begin(), fDrawables.count(), &SkMatrix::I());
1777 d(op);
mtkleind31c13d2015-05-05 12:59:56 -07001778 }
1779
mtklein449d9b72015-09-28 10:33:02 -07001780 // Draws get their own picture.
mtkleind31c13d2015-05-05 12:59:56 -07001781 template <typename T>
mtklein449d9b72015-09-28 10:33:02 -07001782 SK_WHEN(T::kTags & SkRecords::kDraw_Tag, void) operator()(const T& op) {
mtkleind31c13d2015-05-05 12:59:56 -07001783 SkPictureRecorder rec;
mtklein11064df2016-04-06 15:01:57 -07001784 this->draw(op, rec.beginRecording(fBounds));
reedca2622b2016-03-18 07:25:55 -07001785 sk_sp<SkPicture> pic(rec.finishRecordingAsPicture());
mtkleind31c13d2015-05-05 12:59:56 -07001786 fCanvas->drawPicture(pic);
1787 }
1788
mtklein449d9b72015-09-28 10:33:02 -07001789 // We'll just issue non-draws directly.
mtkleind31c13d2015-05-05 12:59:56 -07001790 template <typename T>
mtklein449d9b72015-09-28 10:33:02 -07001791 skstd::enable_if_t<!(T::kTags & SkRecords::kDraw_Tag), void> operator()(const T& op) {
1792 this->draw(op, fCanvas);
1793 }
mtkleind31c13d2015-05-05 12:59:56 -07001794};
1795
mtkleind31c13d2015-05-05 12:59:56 -07001796// Record Src into a picture, then record it into a macro picture with a sub-picture for each draw.
1797// Then play back that macro picture into our wrapped sink.
1798Error ViaSingletonPictures::draw(
1799 const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
1800 auto size = src.size();
Ben Wagner145dbcd2016-11-03 14:40:50 -04001801 return draw_to_canvas(fSink.get(), bitmap, stream, log, size, [&](SkCanvas* canvas) -> Error {
mtkleind31c13d2015-05-05 12:59:56 -07001802 // Use low-level (Skia-private) recording APIs so we can read the SkRecord.
1803 SkRecord skr;
1804 SkRecorder recorder(&skr, size.width(), size.height());
1805 Error err = src.draw(&recorder);
1806 if (!err.isEmpty()) {
1807 return err;
1808 }
1809
1810 // Record our macro-picture, with each draw op as its own sub-picture.
1811 SkPictureRecorder macroRec;
1812 SkCanvas* macroCanvas = macroRec.beginRecording(SkIntToScalar(size.width()),
1813 SkIntToScalar(size.height()));
mtkleind2baa902015-07-07 09:43:28 -07001814
bungeman6bd52842016-10-27 09:30:08 -07001815 std::unique_ptr<SkDrawableList> drawables(recorder.detachDrawableList());
mtkleind2baa902015-07-07 09:43:28 -07001816 const SkDrawableList empty;
1817
1818 DrawsAsSingletonPictures drawsAsSingletonPictures = {
1819 macroCanvas,
1820 drawables ? *drawables : empty,
mtklein11064df2016-04-06 15:01:57 -07001821 SkRect::MakeWH((SkScalar)size.width(), (SkScalar)size.height()),
mtkleind2baa902015-07-07 09:43:28 -07001822 };
mtkleinc6ad06a2015-08-19 09:51:00 -07001823 for (int i = 0; i < skr.count(); i++) {
mtklein343a63d2016-03-22 11:46:53 -07001824 skr.visit(i, drawsAsSingletonPictures);
mtkleind31c13d2015-05-05 12:59:56 -07001825 }
reedca2622b2016-03-18 07:25:55 -07001826 sk_sp<SkPicture> macroPic(macroRec.finishRecordingAsPicture());
mtkleind31c13d2015-05-05 12:59:56 -07001827
1828 canvas->drawPicture(macroPic);
Ben Wagner145dbcd2016-11-03 14:40:50 -04001829 return check_against_reference(bitmap, src, fSink.get());
mtkleind31c13d2015-05-05 12:59:56 -07001830 });
1831}
1832
mtklein9c5052f2016-08-06 12:51:51 -07001833/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1834
1835Error ViaLite::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
1836 auto size = src.size();
Derek Sollenbergerd7875f52017-03-01 15:33:23 -05001837 SkIRect bounds = {0,0, size.width(), size.height()};
Ben Wagner145dbcd2016-11-03 14:40:50 -04001838 return draw_to_canvas(fSink.get(), bitmap, stream, log, size, [&](SkCanvas* canvas) -> Error {
Derek Sollenbergerd7875f52017-03-01 15:33:23 -05001839 SkLiteDL dl;
mtklein8bbbb692016-08-15 12:56:00 -07001840 SkLiteRecorder rec;
Derek Sollenbergerd7875f52017-03-01 15:33:23 -05001841 rec.reset(&dl, bounds);
mtklein8bbbb692016-08-15 12:56:00 -07001842
1843 Error err = src.draw(&rec);
mtklein9c5052f2016-08-06 12:51:51 -07001844 if (!err.isEmpty()) {
1845 return err;
1846 }
Derek Sollenbergerd7875f52017-03-01 15:33:23 -05001847 dl.draw(canvas);
Ben Wagner145dbcd2016-11-03 14:40:50 -04001848 return check_against_reference(bitmap, src, fSink.get());
mtklein9c5052f2016-08-06 12:51:51 -07001849 });
1850}
1851
Mike Klein841101d2017-03-10 09:55:51 -05001852/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1853
Mike Klein919cc452017-03-18 15:36:52 +00001854ViaCSXform::ViaCSXform(Sink* sink, sk_sp<SkColorSpace> cs, bool colorSpin)
1855 : Via(sink)
1856 , fCS(std::move(cs))
1857 , fColorSpin(colorSpin) {}
Mike Klein841101d2017-03-10 09:55:51 -05001858
1859Error ViaCSXform::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
1860 return draw_to_canvas(fSink.get(), bitmap, stream, log, src.size(),
1861 [&](SkCanvas* canvas) -> Error {
1862 auto proxy = SkCreateColorSpaceXformCanvas(canvas, fCS);
Mike Klein919cc452017-03-18 15:36:52 +00001863 Error err = src.draw(proxy.get());
1864 if (!err.isEmpty()) {
1865 return err;
1866 }
1867
1868 // Undo the color spin, so we can look at the pixels in Gold.
1869 if (fColorSpin) {
1870 SkBitmap pixels;
1871 pixels.allocPixels(canvas->imageInfo());
1872 canvas->readPixels(&pixels, 0, 0);
1873 for (int y = 0; y < pixels.height(); y++) {
1874 for (int x = 0; x < pixels.width(); x++) {
1875 uint32_t pixel = *pixels.getAddr32(x, y);
1876 uint8_t r = SkGetPackedR32(pixel);
1877 uint8_t g = SkGetPackedG32(pixel);
1878 uint8_t b = SkGetPackedB32(pixel);
1879 uint8_t a = SkGetPackedA32(pixel);
1880 *pixels.getAddr32(x, y) =
1881 SkSwizzle_RGBA_to_PMColor(b << 0 | r << 8 | g << 16 | a << 24);
1882 }
1883 }
1884
1885 canvas->writePixels(pixels, 0, 0);
1886 }
1887
1888 return "";
Mike Klein841101d2017-03-10 09:55:51 -05001889 });
1890}
1891
mtklein748ca3b2015-01-15 10:56:12 -08001892} // namespace DM