blob: 53654b923f379476f66ba1608813f1c3c2f79545 [file] [log] [blame]
keyar@chromium.orgb3fb7c12012-08-20 21:02:49 +00001/*
2 * Copyright 2012 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
keyar@chromium.org451bb9f2012-07-26 17:27:57 +00008#include "PictureRenderer.h"
scroggo@google.com58b4ead2012-08-31 16:15:22 +00009#include "picture_utils.h"
keyar@chromium.org451bb9f2012-07-26 17:27:57 +000010#include "SamplePipeControllers.h"
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +000011#include "SkBitmapHasher.h"
keyar@chromium.org451bb9f2012-07-26 17:27:57 +000012#include "SkCanvas.h"
scroggo@google.com1b1bcc32013-05-21 20:31:23 +000013#include "SkData.h"
keyar@chromium.org451bb9f2012-07-26 17:27:57 +000014#include "SkDevice.h"
robertphillips@google.com94d8f1e2013-12-18 17:25:33 +000015#include "SkDiscardableMemoryPool.h"
keyar@chromium.org451bb9f2012-07-26 17:27:57 +000016#include "SkGPipe.h"
scroggo@google.com58b4ead2012-08-31 16:15:22 +000017#if SK_SUPPORT_GPU
robertphillips@google.comfe1b5362013-02-07 19:45:46 +000018#include "gl/GrGLDefines.h"
scroggo@google.com58b4ead2012-08-31 16:15:22 +000019#include "SkGpuDevice.h"
20#endif
21#include "SkGraphics.h"
22#include "SkImageEncoder.h"
caryclark@google.coma3622372012-11-06 21:26:13 +000023#include "SkMaskFilter.h"
keyar@chromium.orgea826952012-08-23 15:24:13 +000024#include "SkMatrix.h"
keyar@chromium.org451bb9f2012-07-26 17:27:57 +000025#include "SkPicture.h"
scroggo@google.com1b1bcc32013-05-21 20:31:23 +000026#include "SkPictureUtils.h"
27#include "SkPixelRef.h"
junov@chromium.org9313ca42012-11-02 18:11:49 +000028#include "SkRTree.h"
keyar@chromium.orgea826952012-08-23 15:24:13 +000029#include "SkScalar.h"
scroggo@google.coma9e3a362012-11-07 17:52:48 +000030#include "SkStream.h"
keyar@chromium.org9299ede2012-08-21 19:05:08 +000031#include "SkString.h"
scroggo@google.com58b4ead2012-08-31 16:15:22 +000032#include "SkTemplates.h"
junov@chromium.org3cb834b2012-12-13 16:39:53 +000033#include "SkTileGridPicture.h"
keyar@chromium.org451bb9f2012-07-26 17:27:57 +000034#include "SkTDArray.h"
scroggo@google.com58b4ead2012-08-31 16:15:22 +000035#include "SkThreadUtils.h"
keyar@chromium.org451bb9f2012-07-26 17:27:57 +000036#include "SkTypes.h"
keyar@chromium.org4ea96c52012-08-20 15:03:29 +000037
reed@google.come15b2f52013-12-18 04:59:26 +000038static inline SkScalar scalar_log2(SkScalar x) {
39 static const SkScalar log2_conversion_factor = SkScalarDiv(1, SkScalarLog(2));
skia.committer@gmail.com3b85deb2013-12-18 07:01:56 +000040
reed@google.come15b2f52013-12-18 04:59:26 +000041 return SkScalarLog(x) * log2_conversion_factor;
42}
43
keyar@chromium.org451bb9f2012-07-26 17:27:57 +000044namespace sk_tools {
45
46enum {
47 kDefaultTileWidth = 256,
48 kDefaultTileHeight = 256
49};
50
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +000051/* TODO(epoger): These constants are already maintained in 2 other places:
52 * gm/gm_json.py and gm/gm_expectations.cpp. We shouldn't add yet a third place.
53 * Figure out a way to share the definitions instead.
54 */
55const static char kJsonKey_ActualResults[] = "actual-results";
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +000056const static char kJsonKey_ActualResults_NoComparison[] = "no-comparison";
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +000057const static char kJsonKey_Hashtype_Bitmap_64bitMD5[] = "bitmap-64bitMD5";
58
59void ImageResultsSummary::add(const char *testName, const SkBitmap& bitmap) {
60 uint64_t hash;
61 SkAssertResult(SkBitmapHasher::ComputeDigest(bitmap, &hash));
62 Json::Value jsonTypeValuePair;
63 jsonTypeValuePair.append(Json::Value(kJsonKey_Hashtype_Bitmap_64bitMD5));
64 jsonTypeValuePair.append(Json::UInt64(hash));
65 fActualResultsNoComparison[testName] = jsonTypeValuePair;
66}
67
68void ImageResultsSummary::writeToFile(const char *filename) {
69 Json::Value actualResults;
70 actualResults[kJsonKey_ActualResults_NoComparison] = fActualResultsNoComparison;
71 Json::Value root;
72 root[kJsonKey_ActualResults] = actualResults;
73 std::string jsonStdString = root.toStyledString();
74 SkFILEWStream stream(filename);
75 stream.write(jsonStdString.c_str(), jsonStdString.length());
76}
77
keyar@chromium.org9d696c02012-08-07 17:11:33 +000078void PictureRenderer::init(SkPicture* pict) {
keyar@chromium.org78a35c52012-08-20 15:03:44 +000079 SkASSERT(NULL == fPicture);
80 SkASSERT(NULL == fCanvas.get());
81 if (fPicture != NULL || NULL != fCanvas.get()) {
keyar@chromium.org9d696c02012-08-07 17:11:33 +000082 return;
83 }
84
85 SkASSERT(pict != NULL);
keyar@chromium.org78a35c52012-08-20 15:03:44 +000086 if (NULL == pict) {
keyar@chromium.org9d696c02012-08-07 17:11:33 +000087 return;
88 }
89
90 fPicture = pict;
junov@chromium.org9313ca42012-11-02 18:11:49 +000091 fPicture->ref();
keyar@chromium.orga474ce32012-08-20 15:03:57 +000092 fCanvas.reset(this->setupCanvas());
93}
94
caryclark@google.coma3622372012-11-06 21:26:13 +000095class FlagsDrawFilter : public SkDrawFilter {
96public:
97 FlagsDrawFilter(PictureRenderer::DrawFilterFlags* flags) :
98 fFlags(flags) {}
99
reed@google.com971aca72012-11-26 20:26:54 +0000100 virtual bool filter(SkPaint* paint, Type t) {
caryclark@google.coma3622372012-11-06 21:26:13 +0000101 paint->setFlags(paint->getFlags() & ~fFlags[t] & SkPaint::kAllFlags);
robertphillips@google.com49149312013-07-03 15:34:35 +0000102 if (PictureRenderer::kMaskFilter_DrawFilterFlag & fFlags[t]) {
caryclark@google.coma3622372012-11-06 21:26:13 +0000103 SkMaskFilter* maskFilter = paint->getMaskFilter();
robertphillips@google.com49149312013-07-03 15:34:35 +0000104 if (NULL != maskFilter) {
reed@google.com457d8a72012-12-18 18:20:44 +0000105 paint->setMaskFilter(NULL);
caryclark@google.coma3622372012-11-06 21:26:13 +0000106 }
107 }
108 if (PictureRenderer::kHinting_DrawFilterFlag & fFlags[t]) {
109 paint->setHinting(SkPaint::kNo_Hinting);
110 } else if (PictureRenderer::kSlightHinting_DrawFilterFlag & fFlags[t]) {
111 paint->setHinting(SkPaint::kSlight_Hinting);
112 }
reed@google.com971aca72012-11-26 20:26:54 +0000113 return true;
caryclark@google.coma3622372012-11-06 21:26:13 +0000114 }
115
116private:
117 PictureRenderer::DrawFilterFlags* fFlags;
118};
119
scroggo@google.com82ec0b02012-12-17 19:25:54 +0000120static void setUpFilter(SkCanvas* canvas, PictureRenderer::DrawFilterFlags* drawFilters) {
caryclark@google.coma3622372012-11-06 21:26:13 +0000121 if (drawFilters && !canvas->getDrawFilter()) {
122 canvas->setDrawFilter(SkNEW_ARGS(FlagsDrawFilter, (drawFilters)))->unref();
caryclark@google.come3e940c2012-11-07 16:42:17 +0000123 if (drawFilters[0] & PictureRenderer::kAAClip_DrawFilterFlag) {
124 canvas->setAllowSoftClip(false);
125 }
caryclark@google.coma3622372012-11-06 21:26:13 +0000126 }
caryclark@google.coma3622372012-11-06 21:26:13 +0000127}
128
keyar@chromium.orga474ce32012-08-20 15:03:57 +0000129SkCanvas* PictureRenderer::setupCanvas() {
scroggo@google.comc0d5e542012-12-13 21:40:48 +0000130 const int width = this->getViewWidth();
131 const int height = this->getViewHeight();
132 return this->setupCanvas(width, height);
keyar@chromium.orga474ce32012-08-20 15:03:57 +0000133}
134
135SkCanvas* PictureRenderer::setupCanvas(int width, int height) {
caryclark@google.coma3622372012-11-06 21:26:13 +0000136 SkCanvas* canvas;
keyar@chromium.org4ea96c52012-08-20 15:03:29 +0000137 switch(fDeviceType) {
138 case kBitmap_DeviceType: {
139 SkBitmap bitmap;
keyar@chromium.orga474ce32012-08-20 15:03:57 +0000140 sk_tools::setup_bitmap(&bitmap, width, height);
caryclark@google.coma3622372012-11-06 21:26:13 +0000141 canvas = SkNEW_ARGS(SkCanvas, (bitmap));
keyar@chromium.org4ea96c52012-08-20 15:03:29 +0000142 }
scroggo@google.com82ec0b02012-12-17 19:25:54 +0000143 break;
keyar@chromium.org4ea96c52012-08-20 15:03:29 +0000144#if SK_SUPPORT_GPU
scroggo@google.com0556ea02013-02-08 19:38:21 +0000145#if SK_ANGLE
146 case kAngle_DeviceType:
147 // fall through
148#endif
rmistry@google.com6ab96732014-01-06 18:37:24 +0000149#if SK_MESA
150 case kMesa_DeviceType:
151 // fall through
152#endif
keyar@chromium.org4ea96c52012-08-20 15:03:29 +0000153 case kGPU_DeviceType: {
commit-bot@chromium.orgae403b92013-04-10 17:27:30 +0000154 SkAutoTUnref<GrSurface> target;
scroggo@google.com0556ea02013-02-08 19:38:21 +0000155 if (fGrContext) {
156 // create a render target to back the device
157 GrTextureDesc desc;
158 desc.fConfig = kSkia8888_GrPixelConfig;
159 desc.fFlags = kRenderTarget_GrTextureFlagBit;
160 desc.fWidth = width;
161 desc.fHeight = height;
jvanverth@google.comf6a90332013-05-02 12:39:37 +0000162 desc.fSampleCnt = fSampleCount;
commit-bot@chromium.orgae403b92013-04-10 17:27:30 +0000163 target.reset(fGrContext->createUncachedTexture(desc, NULL, 0));
scroggo@google.com0556ea02013-02-08 19:38:21 +0000164 }
commit-bot@chromium.orgae403b92013-04-10 17:27:30 +0000165 if (NULL == target.get()) {
scroggo@google.com0556ea02013-02-08 19:38:21 +0000166 SkASSERT(0);
167 return NULL;
168 }
169
commit-bot@chromium.orgae403b92013-04-10 17:27:30 +0000170 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(target));
caryclark@google.coma3622372012-11-06 21:26:13 +0000171 canvas = SkNEW_ARGS(SkCanvas, (device.get()));
scroggo@google.com0556ea02013-02-08 19:38:21 +0000172 break;
keyar@chromium.org4ea96c52012-08-20 15:03:29 +0000173 }
174#endif
175 default:
176 SkASSERT(0);
scroggo@google.com82ec0b02012-12-17 19:25:54 +0000177 return NULL;
keyar@chromium.org4ea96c52012-08-20 15:03:29 +0000178 }
scroggo@google.com82ec0b02012-12-17 19:25:54 +0000179 setUpFilter(canvas, fDrawFilters);
180 this->scaleToScaleFactor(canvas);
181 return canvas;
182}
keyar@chromium.orga474ce32012-08-20 15:03:57 +0000183
scroggo@google.com82ec0b02012-12-17 19:25:54 +0000184void PictureRenderer::scaleToScaleFactor(SkCanvas* canvas) {
185 SkASSERT(canvas != NULL);
186 if (fScaleFactor != SK_Scalar1) {
187 canvas->scale(fScaleFactor, fScaleFactor);
188 }
keyar@chromium.org9d696c02012-08-07 17:11:33 +0000189}
190
191void PictureRenderer::end() {
scroggo@google.com08085f82013-01-28 20:40:24 +0000192 this->resetState(true);
junov@chromium.org9313ca42012-11-02 18:11:49 +0000193 SkSafeUnref(fPicture);
keyar@chromium.org9d696c02012-08-07 17:11:33 +0000194 fPicture = NULL;
195 fCanvas.reset(NULL);
196}
197
scroggo@google.comc0d5e542012-12-13 21:40:48 +0000198int PictureRenderer::getViewWidth() {
199 SkASSERT(fPicture != NULL);
robertphillips@google.com8ac811e2013-02-07 00:13:34 +0000200 int width = SkScalarCeilToInt(fPicture->width() * fScaleFactor);
scroggo@google.comc0d5e542012-12-13 21:40:48 +0000201 if (fViewport.width() > 0) {
202 width = SkMin32(width, fViewport.width());
203 }
204 return width;
205}
206
207int PictureRenderer::getViewHeight() {
208 SkASSERT(fPicture != NULL);
robertphillips@google.com8ac811e2013-02-07 00:13:34 +0000209 int height = SkScalarCeilToInt(fPicture->height() * fScaleFactor);
scroggo@google.comc0d5e542012-12-13 21:40:48 +0000210 if (fViewport.height() > 0) {
211 height = SkMin32(height, fViewport.height());
212 }
213 return height;
214}
215
junov@chromium.org9313ca42012-11-02 18:11:49 +0000216/** Converts fPicture to a picture that uses a BBoxHierarchy.
217 * PictureRenderer subclasses that are used to test picture playback
218 * should call this method during init.
219 */
220void PictureRenderer::buildBBoxHierarchy() {
221 SkASSERT(NULL != fPicture);
222 if (kNone_BBoxHierarchyType != fBBoxHierarchyType && NULL != fPicture) {
223 SkPicture* newPicture = this->createPicture();
224 SkCanvas* recorder = newPicture->beginRecording(fPicture->width(), fPicture->height(),
225 this->recordFlags());
226 fPicture->draw(recorder);
227 newPicture->endRecording();
228 fPicture->unref();
229 fPicture = newPicture;
230 }
231}
232
scroggo@google.com08085f82013-01-28 20:40:24 +0000233void PictureRenderer::resetState(bool callFinish) {
keyar@chromium.org28136b32012-08-20 15:04:15 +0000234#if SK_SUPPORT_GPU
robertphillips@google.com6177e692013-02-28 20:16:25 +0000235 SkGLContextHelper* glContext = this->getGLContext();
scroggo@google.com0556ea02013-02-08 19:38:21 +0000236 if (NULL == glContext) {
237 SkASSERT(kBitmap_DeviceType == fDeviceType);
238 return;
239 }
keyar@chromium.org28136b32012-08-20 15:04:15 +0000240
scroggo@google.com0556ea02013-02-08 19:38:21 +0000241 fGrContext->flush();
242 if (callFinish) {
243 SK_GL(*glContext, Finish());
keyar@chromium.org77a55222012-08-20 15:03:47 +0000244 }
keyar@chromium.orga40c20d2012-08-20 15:04:12 +0000245#endif
keyar@chromium.org77a55222012-08-20 15:03:47 +0000246}
247
robertphillips@google.com94d8f1e2013-12-18 17:25:33 +0000248void PictureRenderer::purgeTextures() {
249 SkDiscardableMemoryPool* pool = SkGetGlobalDiscardableMemoryPool();
250
251 pool->dumpPool();
252
253#if SK_SUPPORT_GPU
254 SkGLContextHelper* glContext = this->getGLContext();
255 if (NULL == glContext) {
256 SkASSERT(kBitmap_DeviceType == fDeviceType);
257 return;
258 }
259
260 // resetState should've already done this
261 fGrContext->flush();
262
263 fGrContext->purgeAllUnlockedResources();
264#endif
265}
266
junov@chromium.org9313ca42012-11-02 18:11:49 +0000267uint32_t PictureRenderer::recordFlags() {
junov@chromium.org100b1c52013-01-16 20:12:22 +0000268 return ((kNone_BBoxHierarchyType == fBBoxHierarchyType) ? 0 :
269 SkPicture::kOptimizeForClippedPlayback_RecordingFlag) |
270 SkPicture::kUsePathBoundsForClip_RecordingFlag;
junov@chromium.org9313ca42012-11-02 18:11:49 +0000271}
272
scroggo@google.comb6e806b2012-10-03 17:32:33 +0000273/**
274 * Write the canvas to the specified path.
275 * @param canvas Must be non-null. Canvas to be written to a file.
276 * @param path Path for the file to be written. Should have no extension; write() will append
277 * an appropriate one. Passed in by value so it can be modified.
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000278 * @param jsonSummaryPtr If not null, add image results to this summary.
scroggo@google.comb6e806b2012-10-03 17:32:33 +0000279 * @return bool True if the Canvas is written to a file.
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000280 *
281 * TODO(epoger): Right now, all canvases must pass through this function in order to be appended
282 * to the ImageResultsSummary. We need some way to add bitmaps to the ImageResultsSummary
283 * even if --writePath has not been specified (and thus this function is not called).
284 *
285 * One fix would be to pass in these path elements separately, and allow this function to be
286 * called even if --writePath was not specified...
287 * const char *outputDir // NULL if we don't want to write image files to disk
288 * const char *filename // name we use within JSON summary, and as the filename within outputDir
scroggo@google.comb6e806b2012-10-03 17:32:33 +0000289 */
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000290static bool write(SkCanvas* canvas, const SkString* path, ImageResultsSummary *jsonSummaryPtr) {
scroggo@google.com81f9d2e2012-09-20 14:54:21 +0000291 SkASSERT(canvas != NULL);
scroggo@google.comb6e806b2012-10-03 17:32:33 +0000292 if (NULL == canvas) {
keyar@chromium.org9299ede2012-08-21 19:05:08 +0000293 return false;
294 }
295
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000296 SkASSERT(path != NULL); // TODO(epoger): we want to remove this constraint, as noted above
297 SkString fullPathname(*path);
298 fullPathname.append(".png");
299
keyar@chromium.org9299ede2012-08-21 19:05:08 +0000300 SkBitmap bitmap;
scroggo@google.com81f9d2e2012-09-20 14:54:21 +0000301 SkISize size = canvas->getDeviceSize();
302 sk_tools::setup_bitmap(&bitmap, size.width(), size.height());
keyar@chromium.org9299ede2012-08-21 19:05:08 +0000303
scroggo@google.com81f9d2e2012-09-20 14:54:21 +0000304 canvas->readPixels(&bitmap, 0, 0);
keyar@chromium.org9299ede2012-08-21 19:05:08 +0000305 sk_tools::force_all_opaque(bitmap);
306
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000307 if (NULL != jsonSummaryPtr) {
308 // EPOGER: This is a hacky way of constructing the filename associated with the
309 // image checksum; we assume that outputDir is not NULL, and we remove outputDir
310 // from fullPathname.
311 //
312 // EPOGER: what about including the config type within hashFilename? That way,
313 // we could combine results of different config types without conflicting filenames.
314 SkString hashFilename;
315 sk_tools::get_basename(&hashFilename, fullPathname);
316 jsonSummaryPtr->add(hashFilename.c_str(), bitmap);
317 }
318
319 return SkImageEncoder::EncodeFile(fullPathname.c_str(), bitmap, SkImageEncoder::kPNG_Type, 100);
keyar@chromium.org9299ede2012-08-21 19:05:08 +0000320}
321
scroggo@google.comb6e806b2012-10-03 17:32:33 +0000322/**
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000323 * If path is non NULL, append number to it, and call write() to write the
scroggo@google.comb6e806b2012-10-03 17:32:33 +0000324 * provided canvas to a file. Returns true if path is NULL or if write() succeeds.
325 */
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000326static bool writeAppendNumber(SkCanvas* canvas, const SkString* path, int number,
327 ImageResultsSummary *jsonSummaryPtr) {
scroggo@google.comb6e806b2012-10-03 17:32:33 +0000328 if (NULL == path) {
329 return true;
330 }
331 SkString pathWithNumber(*path);
332 pathWithNumber.appendf("%i", number);
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000333 return write(canvas, &pathWithNumber, jsonSummaryPtr);
scroggo@google.comb6e806b2012-10-03 17:32:33 +0000334}
335
scroggo@google.comacfb30e2012-09-18 14:32:35 +0000336///////////////////////////////////////////////////////////////////////////////////////////////
337
djsollen@google.comfd9720c2012-11-06 16:54:40 +0000338SkCanvas* RecordPictureRenderer::setupCanvas(int width, int height) {
339 // defer the canvas setup until the render step
340 return NULL;
341}
342
reed@google.com672588b2014-01-08 15:42:01 +0000343// the size_t* parameter is deprecated, so we ignore it
344static SkData* encode_bitmap_to_data(size_t*, const SkBitmap& bm) {
scroggo@google.com1b1bcc32013-05-21 20:31:23 +0000345 return SkImageEncoder::EncodeData(bm, SkImageEncoder::kPNG_Type, 100);
scroggo@google.coma9e3a362012-11-07 17:52:48 +0000346}
347
edisonn@google.com84f548c2012-12-18 22:24:03 +0000348bool RecordPictureRenderer::render(const SkString* path, SkBitmap** out) {
junov@chromium.org9313ca42012-11-02 18:11:49 +0000349 SkAutoTUnref<SkPicture> replayer(this->createPicture());
scroggo@google.com82ec0b02012-12-17 19:25:54 +0000350 SkCanvas* recorder = replayer->beginRecording(this->getViewWidth(), this->getViewHeight(),
junov@chromium.org9313ca42012-11-02 18:11:49 +0000351 this->recordFlags());
scroggo@google.com82ec0b02012-12-17 19:25:54 +0000352 this->scaleToScaleFactor(recorder);
scroggo@google.com9a412522012-09-07 15:21:18 +0000353 fPicture->draw(recorder);
junov@chromium.org9313ca42012-11-02 18:11:49 +0000354 replayer->endRecording();
scroggo@google.coma9e3a362012-11-07 17:52:48 +0000355 if (path != NULL) {
356 // Record the new picture as a new SKP with PNG encoded bitmaps.
357 SkString skpPath(*path);
358 // ".skp" was removed from 'path' before being passed in here.
359 skpPath.append(".skp");
360 SkFILEWStream stream(skpPath.c_str());
scroggo@google.com1b1bcc32013-05-21 20:31:23 +0000361 replayer->serialize(&stream, &encode_bitmap_to_data);
scroggo@google.coma9e3a362012-11-07 17:52:48 +0000362 return true;
363 }
scroggo@google.com81f9d2e2012-09-20 14:54:21 +0000364 return false;
scroggo@google.com9a412522012-09-07 15:21:18 +0000365}
366
scroggo@google.com0a049b82012-11-02 22:01:26 +0000367SkString RecordPictureRenderer::getConfigNameInternal() {
368 return SkString("record");
369}
370
scroggo@google.comacfb30e2012-09-18 14:32:35 +0000371///////////////////////////////////////////////////////////////////////////////////////////////
372
edisonn@google.com84f548c2012-12-18 22:24:03 +0000373bool PipePictureRenderer::render(const SkString* path, SkBitmap** out) {
keyar@chromium.org9d696c02012-08-07 17:11:33 +0000374 SkASSERT(fCanvas.get() != NULL);
375 SkASSERT(fPicture != NULL);
keyar@chromium.org78a35c52012-08-20 15:03:44 +0000376 if (NULL == fCanvas.get() || NULL == fPicture) {
scroggo@google.com81f9d2e2012-09-20 14:54:21 +0000377 return false;
keyar@chromium.org9d696c02012-08-07 17:11:33 +0000378 }
379
380 PipeController pipeController(fCanvas.get());
keyar@chromium.org451bb9f2012-07-26 17:27:57 +0000381 SkGPipeWriter writer;
382 SkCanvas* pipeCanvas = writer.startRecording(&pipeController);
keyar@chromium.org9d696c02012-08-07 17:11:33 +0000383 pipeCanvas->drawPicture(*fPicture);
keyar@chromium.org451bb9f2012-07-26 17:27:57 +0000384 writer.endRecording();
scroggo@google.com9a412522012-09-07 15:21:18 +0000385 fCanvas->flush();
borenet@google.com070d3542012-10-26 13:26:55 +0000386 if (NULL != path) {
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000387 return write(fCanvas, path, fJsonSummaryPtr);
borenet@google.com070d3542012-10-26 13:26:55 +0000388 }
edisonn@google.com84f548c2012-12-18 22:24:03 +0000389 if (NULL != out) {
390 *out = SkNEW(SkBitmap);
391 setup_bitmap(*out, fPicture->width(), fPicture->height());
392 fCanvas->readPixels(*out, 0, 0);
skia.committer@gmail.coma7d8e3e2012-12-19 02:01:38 +0000393 }
borenet@google.com070d3542012-10-26 13:26:55 +0000394 return true;
keyar@chromium.org451bb9f2012-07-26 17:27:57 +0000395}
396
scroggo@google.com0a049b82012-11-02 22:01:26 +0000397SkString PipePictureRenderer::getConfigNameInternal() {
398 return SkString("pipe");
399}
400
scroggo@google.comacfb30e2012-09-18 14:32:35 +0000401///////////////////////////////////////////////////////////////////////////////////////////////
402
junov@chromium.org9313ca42012-11-02 18:11:49 +0000403void SimplePictureRenderer::init(SkPicture* picture) {
404 INHERITED::init(picture);
405 this->buildBBoxHierarchy();
406}
407
edisonn@google.com84f548c2012-12-18 22:24:03 +0000408bool SimplePictureRenderer::render(const SkString* path, SkBitmap** out) {
keyar@chromium.org9d696c02012-08-07 17:11:33 +0000409 SkASSERT(fCanvas.get() != NULL);
410 SkASSERT(fPicture != NULL);
keyar@chromium.org78a35c52012-08-20 15:03:44 +0000411 if (NULL == fCanvas.get() || NULL == fPicture) {
scroggo@google.com81f9d2e2012-09-20 14:54:21 +0000412 return false;
keyar@chromium.org9d696c02012-08-07 17:11:33 +0000413 }
414
415 fCanvas->drawPicture(*fPicture);
scroggo@google.com9a412522012-09-07 15:21:18 +0000416 fCanvas->flush();
borenet@google.com070d3542012-10-26 13:26:55 +0000417 if (NULL != path) {
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000418 return write(fCanvas, path, fJsonSummaryPtr);
borenet@google.com070d3542012-10-26 13:26:55 +0000419 }
skia.committer@gmail.coma7d8e3e2012-12-19 02:01:38 +0000420
edisonn@google.com84f548c2012-12-18 22:24:03 +0000421 if (NULL != out) {
422 *out = SkNEW(SkBitmap);
423 setup_bitmap(*out, fPicture->width(), fPicture->height());
424 fCanvas->readPixels(*out, 0, 0);
425 }
426
borenet@google.com070d3542012-10-26 13:26:55 +0000427 return true;
keyar@chromium.org451bb9f2012-07-26 17:27:57 +0000428}
429
scroggo@google.com0a049b82012-11-02 22:01:26 +0000430SkString SimplePictureRenderer::getConfigNameInternal() {
431 return SkString("simple");
432}
433
scroggo@google.comacfb30e2012-09-18 14:32:35 +0000434///////////////////////////////////////////////////////////////////////////////////////////////
435
keyar@chromium.org451bb9f2012-07-26 17:27:57 +0000436TiledPictureRenderer::TiledPictureRenderer()
scroggo@google.coma62da2f2012-11-02 21:28:12 +0000437 : fTileWidth(kDefaultTileWidth)
rileya@google.comb947b912012-08-29 17:35:07 +0000438 , fTileHeight(kDefaultTileHeight)
rileya@google.coma04dc022012-09-10 19:01:38 +0000439 , fTileWidthPercentage(0.0)
rileya@google.comb947b912012-08-29 17:35:07 +0000440 , fTileHeightPercentage(0.0)
scroggo@google.comcbcef702012-12-13 22:09:28 +0000441 , fTileMinPowerOf2Width(0)
442 , fCurrentTileOffset(-1)
443 , fTilesX(0)
444 , fTilesY(0) { }
keyar@chromium.org451bb9f2012-07-26 17:27:57 +0000445
keyar@chromium.org9d696c02012-08-07 17:11:33 +0000446void TiledPictureRenderer::init(SkPicture* pict) {
447 SkASSERT(pict != NULL);
scroggo@google.comacfb30e2012-09-18 14:32:35 +0000448 SkASSERT(0 == fTileRects.count());
449 if (NULL == pict || fTileRects.count() != 0) {
keyar@chromium.org9d696c02012-08-07 17:11:33 +0000450 return;
451 }
452
scroggo@google.comacfb30e2012-09-18 14:32:35 +0000453 // Do not call INHERITED::init(), which would create a (potentially large) canvas which is not
454 // used by bench_pictures.
455 fPicture = pict;
junov@chromium.org9313ca42012-11-02 18:11:49 +0000456 fPicture->ref();
scroggo@google.coma62da2f2012-11-02 21:28:12 +0000457 this->buildBBoxHierarchy();
keyar@chromium.orgcc6e5ef2012-07-27 20:09:26 +0000458
459 if (fTileWidthPercentage > 0) {
robertphillips@google.com5d8d1862012-08-15 14:36:41 +0000460 fTileWidth = sk_float_ceil2int(float(fTileWidthPercentage * fPicture->width() / 100));
keyar@chromium.orgcc6e5ef2012-07-27 20:09:26 +0000461 }
462 if (fTileHeightPercentage > 0) {
robertphillips@google.com5d8d1862012-08-15 14:36:41 +0000463 fTileHeight = sk_float_ceil2int(float(fTileHeightPercentage * fPicture->height() / 100));
keyar@chromium.orgcc6e5ef2012-07-27 20:09:26 +0000464 }
465
keyar@chromium.orgf4959ab2012-08-23 20:53:25 +0000466 if (fTileMinPowerOf2Width > 0) {
467 this->setupPowerOf2Tiles();
468 } else {
469 this->setupTiles();
470 }
scroggo@google.comcbcef702012-12-13 22:09:28 +0000471 fCanvas.reset(this->setupCanvas(fTileWidth, fTileHeight));
472 // Initialize to -1 so that the first call to nextTile will set this up to draw tile 0 on the
473 // first call to drawCurrentTile.
474 fCurrentTileOffset = -1;
keyar@chromium.org451bb9f2012-07-26 17:27:57 +0000475}
476
keyar@chromium.org9d696c02012-08-07 17:11:33 +0000477void TiledPictureRenderer::end() {
scroggo@google.combcdf2ec2012-09-20 14:42:33 +0000478 fTileRects.reset();
keyar@chromium.org9d696c02012-08-07 17:11:33 +0000479 this->INHERITED::end();
keyar@chromium.org451bb9f2012-07-26 17:27:57 +0000480}
481
keyar@chromium.org9d696c02012-08-07 17:11:33 +0000482void TiledPictureRenderer::setupTiles() {
scroggo@google.comc0d5e542012-12-13 21:40:48 +0000483 // Only use enough tiles to cover the viewport
484 const int width = this->getViewWidth();
485 const int height = this->getViewHeight();
486
scroggo@google.comcbcef702012-12-13 22:09:28 +0000487 fTilesX = fTilesY = 0;
scroggo@google.comc0d5e542012-12-13 21:40:48 +0000488 for (int tile_y_start = 0; tile_y_start < height; tile_y_start += fTileHeight) {
scroggo@google.comcbcef702012-12-13 22:09:28 +0000489 fTilesY++;
scroggo@google.comc0d5e542012-12-13 21:40:48 +0000490 for (int tile_x_start = 0; tile_x_start < width; tile_x_start += fTileWidth) {
scroggo@google.comcbcef702012-12-13 22:09:28 +0000491 if (0 == tile_y_start) {
492 // Only count tiles in the X direction on the first pass.
493 fTilesX++;
494 }
scroggo@google.comacfb30e2012-09-18 14:32:35 +0000495 *fTileRects.append() = SkRect::MakeXYWH(SkIntToScalar(tile_x_start),
496 SkIntToScalar(tile_y_start),
497 SkIntToScalar(fTileWidth),
498 SkIntToScalar(fTileHeight));
keyar@chromium.orgf4959ab2012-08-23 20:53:25 +0000499 }
500 }
501}
502
scroggo@google.comcbcef702012-12-13 22:09:28 +0000503bool TiledPictureRenderer::tileDimensions(int &x, int &y) {
504 if (fTileRects.count() == 0 || NULL == fPicture) {
505 return false;
506 }
507 x = fTilesX;
508 y = fTilesY;
509 return true;
510}
511
keyar@chromium.orgf4959ab2012-08-23 20:53:25 +0000512// The goal of the powers of two tiles is to minimize the amount of wasted tile
513// space in the width-wise direction and then minimize the number of tiles. The
514// constraints are that every tile must have a pixel width that is a power of
515// two and also be of some minimal width (that is also a power of two).
516//
scroggo@google.com58b4ead2012-08-31 16:15:22 +0000517// This is solved by first taking our picture size and rounding it up to the
keyar@chromium.orgf4959ab2012-08-23 20:53:25 +0000518// multiple of the minimal width. The binary representation of this rounded
519// value gives us the tiles we need: a bit of value one means we need a tile of
520// that size.
521void TiledPictureRenderer::setupPowerOf2Tiles() {
scroggo@google.comc0d5e542012-12-13 21:40:48 +0000522 // Only use enough tiles to cover the viewport
523 const int width = this->getViewWidth();
524 const int height = this->getViewHeight();
525
526 int rounded_value = width;
527 if (width % fTileMinPowerOf2Width != 0) {
528 rounded_value = width - (width % fTileMinPowerOf2Width) + fTileMinPowerOf2Width;
keyar@chromium.orgf4959ab2012-08-23 20:53:25 +0000529 }
530
reed@google.come15b2f52013-12-18 04:59:26 +0000531 int num_bits = SkScalarCeilToInt(scalar_log2(SkIntToScalar(width)));
keyar@chromium.orgf4959ab2012-08-23 20:53:25 +0000532 int largest_possible_tile_size = 1 << num_bits;
533
scroggo@google.comcbcef702012-12-13 22:09:28 +0000534 fTilesX = fTilesY = 0;
keyar@chromium.orgf4959ab2012-08-23 20:53:25 +0000535 // The tile height is constant for a particular picture.
scroggo@google.comc0d5e542012-12-13 21:40:48 +0000536 for (int tile_y_start = 0; tile_y_start < height; tile_y_start += fTileHeight) {
scroggo@google.comcbcef702012-12-13 22:09:28 +0000537 fTilesY++;
keyar@chromium.orgf4959ab2012-08-23 20:53:25 +0000538 int tile_x_start = 0;
539 int current_width = largest_possible_tile_size;
scroggo@google.comacfb30e2012-09-18 14:32:35 +0000540 // Set fTileWidth to be the width of the widest tile, so that each canvas is large enough
541 // to draw each tile.
542 fTileWidth = current_width;
keyar@chromium.orgf4959ab2012-08-23 20:53:25 +0000543
544 while (current_width >= fTileMinPowerOf2Width) {
545 // It is very important this is a bitwise AND.
546 if (current_width & rounded_value) {
scroggo@google.comcbcef702012-12-13 22:09:28 +0000547 if (0 == tile_y_start) {
548 // Only count tiles in the X direction on the first pass.
549 fTilesX++;
550 }
scroggo@google.comacfb30e2012-09-18 14:32:35 +0000551 *fTileRects.append() = SkRect::MakeXYWH(SkIntToScalar(tile_x_start),
552 SkIntToScalar(tile_y_start),
553 SkIntToScalar(current_width),
554 SkIntToScalar(fTileHeight));
keyar@chromium.orgf4959ab2012-08-23 20:53:25 +0000555 tile_x_start += current_width;
556 }
557
558 current_width >>= 1;
keyar@chromium.org451bb9f2012-07-26 17:27:57 +0000559 }
560 }
561}
562
scroggo@google.combcdf2ec2012-09-20 14:42:33 +0000563/**
564 * Draw the specified playback to the canvas translated to rectangle provided, so that this mini
565 * canvas represents the rectangle's portion of the overall picture.
566 * Saves and restores so that the initial clip and matrix return to their state before this function
567 * is called.
568 */
569template<class T>
570static void DrawTileToCanvas(SkCanvas* canvas, const SkRect& tileRect, T* playback) {
571 int saveCount = canvas->save();
scroggo@google.com82ec0b02012-12-17 19:25:54 +0000572 // Translate so that we draw the correct portion of the picture.
573 // Perform a postTranslate so that the scaleFactor does not interfere with the positioning.
574 SkMatrix mat(canvas->getTotalMatrix());
575 mat.postTranslate(-tileRect.fLeft, -tileRect.fTop);
576 canvas->setMatrix(mat);
scroggo@google.combcdf2ec2012-09-20 14:42:33 +0000577 playback->draw(canvas);
578 canvas->restoreToCount(saveCount);
579 canvas->flush();
keyar@chromium.org451bb9f2012-07-26 17:27:57 +0000580}
581
scroggo@google.com58b4ead2012-08-31 16:15:22 +0000582///////////////////////////////////////////////////////////////////////////////////////////////
scroggo@google.combcdf2ec2012-09-20 14:42:33 +0000583
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000584/**
585 * Copies the entirety of the src bitmap (typically a tile) into a portion of the dst bitmap.
586 * If the src bitmap is too large to fit within the dst bitmap after the x and y
587 * offsets have been applied, any excess will be ignored (so only the top-left portion of the
588 * src bitmap will be copied).
589 *
590 * @param src source bitmap
591 * @param dst destination bitmap
592 * @param xOffset x-offset within destination bitmap
593 * @param yOffset y-offset within destination bitmap
594 */
595static void bitmapCopyAtOffset(const SkBitmap& src, SkBitmap* dst,
596 int xOffset, int yOffset) {
597 for (int y = 0; y <src.height() && y + yOffset < dst->height() ; y++) {
598 for (int x = 0; x < src.width() && x + xOffset < dst->width() ; x++) {
599 *dst->getAddr32(xOffset + x, yOffset + y) = *src.getAddr32(x, y);
edisonn@google.com84f548c2012-12-18 22:24:03 +0000600 }
601 }
602}
603
scroggo@google.comcbcef702012-12-13 22:09:28 +0000604bool TiledPictureRenderer::nextTile(int &i, int &j) {
605 if (++fCurrentTileOffset < fTileRects.count()) {
606 i = fCurrentTileOffset % fTilesX;
607 j = fCurrentTileOffset / fTilesX;
608 return true;
609 }
610 return false;
611}
612
613void TiledPictureRenderer::drawCurrentTile() {
614 SkASSERT(fCurrentTileOffset >= 0 && fCurrentTileOffset < fTileRects.count());
615 DrawTileToCanvas(fCanvas, fTileRects[fCurrentTileOffset], fPicture);
616}
617
edisonn@google.com84f548c2012-12-18 22:24:03 +0000618bool TiledPictureRenderer::render(const SkString* path, SkBitmap** out) {
scroggo@google.comacfb30e2012-09-18 14:32:35 +0000619 SkASSERT(fPicture != NULL);
620 if (NULL == fPicture) {
scroggo@google.com81f9d2e2012-09-20 14:54:21 +0000621 return false;
scroggo@google.comacfb30e2012-09-18 14:32:35 +0000622 }
623
edisonn@google.com84f548c2012-12-18 22:24:03 +0000624 SkBitmap bitmap;
625 if (out){
626 *out = SkNEW(SkBitmap);
627 setup_bitmap(*out, fPicture->width(), fPicture->height());
628 setup_bitmap(&bitmap, fTileWidth, fTileHeight);
629 }
scroggo@google.coma62da2f2012-11-02 21:28:12 +0000630 bool success = true;
631 for (int i = 0; i < fTileRects.count(); ++i) {
scroggo@google.comcbcef702012-12-13 22:09:28 +0000632 DrawTileToCanvas(fCanvas, fTileRects[i], fPicture);
scroggo@google.coma62da2f2012-11-02 21:28:12 +0000633 if (NULL != path) {
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000634 success &= writeAppendNumber(fCanvas, path, i, fJsonSummaryPtr);
scroggo@google.com58b4ead2012-08-31 16:15:22 +0000635 }
edisonn@google.com84f548c2012-12-18 22:24:03 +0000636 if (NULL != out) {
637 if (fCanvas->readPixels(&bitmap, 0, 0)) {
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000638 // Add this tile to the entire bitmap.
639 bitmapCopyAtOffset(bitmap, *out, SkScalarFloorToInt(fTileRects[i].left()),
640 SkScalarFloorToInt(fTileRects[i].top()));
edisonn@google.com84f548c2012-12-18 22:24:03 +0000641 } else {
642 success = false;
643 }
644 }
keyar@chromium.org163b5672012-08-01 17:53:29 +0000645 }
scroggo@google.coma62da2f2012-11-02 21:28:12 +0000646 return success;
keyar@chromium.org163b5672012-08-01 17:53:29 +0000647}
648
scroggo@google.combcdf2ec2012-09-20 14:42:33 +0000649SkCanvas* TiledPictureRenderer::setupCanvas(int width, int height) {
650 SkCanvas* canvas = this->INHERITED::setupCanvas(width, height);
651 SkASSERT(fPicture != NULL);
scroggo@google.com82ec0b02012-12-17 19:25:54 +0000652 // Clip the tile to an area that is completely inside both the SkPicture and the viewport. This
653 // is mostly important for tiles on the right and bottom edges as they may go over this area and
654 // the picture may have some commands that draw outside of this area and so should not actually
655 // be written.
656 // Uses a clipRegion so that it will be unaffected by the scale factor, which may have been set
657 // by INHERITED::setupCanvas.
658 SkRegion clipRegion;
659 clipRegion.setRect(0, 0, this->getViewWidth(), this->getViewHeight());
660 canvas->clipRegion(clipRegion);
scroggo@google.combcdf2ec2012-09-20 14:42:33 +0000661 return canvas;
662}
scroggo@google.com0a049b82012-11-02 22:01:26 +0000663
664SkString TiledPictureRenderer::getConfigNameInternal() {
665 SkString name;
666 if (fTileMinPowerOf2Width > 0) {
667 name.append("pow2tile_");
668 name.appendf("%i", fTileMinPowerOf2Width);
669 } else {
670 name.append("tile_");
671 if (fTileWidthPercentage > 0) {
672 name.appendf("%.f%%", fTileWidthPercentage);
673 } else {
674 name.appendf("%i", fTileWidth);
675 }
676 }
677 name.append("x");
678 if (fTileHeightPercentage > 0) {
679 name.appendf("%.f%%", fTileHeightPercentage);
680 } else {
681 name.appendf("%i", fTileHeight);
682 }
683 return name;
684}
685
scroggo@google.coma62da2f2012-11-02 21:28:12 +0000686///////////////////////////////////////////////////////////////////////////////////////////////
687
688// Holds all of the information needed to draw a set of tiles.
689class CloneData : public SkRunnable {
690
691public:
692 CloneData(SkPicture* clone, SkCanvas* canvas, SkTDArray<SkRect>& rects, int start, int end,
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000693 SkRunnable* done, ImageResultsSummary* jsonSummaryPtr)
scroggo@google.coma62da2f2012-11-02 21:28:12 +0000694 : fClone(clone)
695 , fCanvas(canvas)
696 , fPath(NULL)
697 , fRects(rects)
698 , fStart(start)
699 , fEnd(end)
700 , fSuccess(NULL)
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000701 , fDone(done)
702 , fJsonSummaryPtr(jsonSummaryPtr) {
scroggo@google.coma62da2f2012-11-02 21:28:12 +0000703 SkASSERT(fDone != NULL);
704 }
705
706 virtual void run() SK_OVERRIDE {
707 SkGraphics::SetTLSFontCacheLimit(1024 * 1024);
edisonn@google.com84f548c2012-12-18 22:24:03 +0000708
709 SkBitmap bitmap;
710 if (fBitmap != NULL) {
711 // All tiles are the same size.
jvanverth@google.com9c4e5ac2013-01-07 18:41:28 +0000712 setup_bitmap(&bitmap, SkScalarFloorToInt(fRects[0].width()), SkScalarFloorToInt(fRects[0].height()));
edisonn@google.com84f548c2012-12-18 22:24:03 +0000713 }
skia.committer@gmail.coma7d8e3e2012-12-19 02:01:38 +0000714
scroggo@google.coma62da2f2012-11-02 21:28:12 +0000715 for (int i = fStart; i < fEnd; i++) {
716 DrawTileToCanvas(fCanvas, fRects[i], fClone);
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000717 if ((fPath != NULL) && !writeAppendNumber(fCanvas, fPath, i, fJsonSummaryPtr)
scroggo@google.coma62da2f2012-11-02 21:28:12 +0000718 && fSuccess != NULL) {
719 *fSuccess = false;
720 // If one tile fails to write to a file, do not continue drawing the rest.
721 break;
722 }
edisonn@google.com84f548c2012-12-18 22:24:03 +0000723 if (fBitmap != NULL) {
724 if (fCanvas->readPixels(&bitmap, 0, 0)) {
725 SkAutoLockPixels alp(*fBitmap);
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000726 bitmapCopyAtOffset(bitmap, fBitmap, SkScalarFloorToInt(fRects[i].left()),
727 SkScalarFloorToInt(fRects[i].top()));
edisonn@google.com84f548c2012-12-18 22:24:03 +0000728 } else {
729 *fSuccess = false;
730 // If one tile fails to read pixels, do not continue drawing the rest.
731 break;
732 }
733 }
scroggo@google.coma62da2f2012-11-02 21:28:12 +0000734 }
735 fDone->run();
736 }
737
738 void setPathAndSuccess(const SkString* path, bool* success) {
739 fPath = path;
740 fSuccess = success;
741 }
742
edisonn@google.com84f548c2012-12-18 22:24:03 +0000743 void setBitmap(SkBitmap* bitmap) {
744 fBitmap = bitmap;
745 }
746
scroggo@google.coma62da2f2012-11-02 21:28:12 +0000747private:
748 // All pointers unowned.
749 SkPicture* fClone; // Picture to draw from. Each CloneData has a unique one which
750 // is threadsafe.
751 SkCanvas* fCanvas; // Canvas to draw to. Reused for each tile.
752 const SkString* fPath; // If non-null, path to write the result to as a PNG.
753 SkTDArray<SkRect>& fRects; // All tiles of the picture.
754 const int fStart; // Range of tiles drawn by this thread.
755 const int fEnd;
756 bool* fSuccess; // Only meaningful if path is non-null. Shared by all threads,
757 // and only set to false upon failure to write to a PNG.
758 SkRunnable* fDone;
edisonn@google.com84f548c2012-12-18 22:24:03 +0000759 SkBitmap* fBitmap;
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000760 ImageResultsSummary* fJsonSummaryPtr;
scroggo@google.coma62da2f2012-11-02 21:28:12 +0000761};
762
763MultiCorePictureRenderer::MultiCorePictureRenderer(int threadCount)
764: fNumThreads(threadCount)
765, fThreadPool(threadCount)
766, fCountdown(threadCount) {
767 // Only need to create fNumThreads - 1 clones, since one thread will use the base
768 // picture.
769 fPictureClones = SkNEW_ARRAY(SkPicture, fNumThreads - 1);
770 fCloneData = SkNEW_ARRAY(CloneData*, fNumThreads);
771}
772
773void MultiCorePictureRenderer::init(SkPicture *pict) {
774 // Set fPicture and the tiles.
775 this->INHERITED::init(pict);
776 for (int i = 0; i < fNumThreads; ++i) {
777 *fCanvasPool.append() = this->setupCanvas(this->getTileWidth(), this->getTileHeight());
778 }
779 // Only need to create fNumThreads - 1 clones, since one thread will use the base picture.
780 fPicture->clone(fPictureClones, fNumThreads - 1);
781 // Populate each thread with the appropriate data.
782 // Group the tiles into nearly equal size chunks, rounding up so we're sure to cover them all.
783 const int chunkSize = (fTileRects.count() + fNumThreads - 1) / fNumThreads;
784
785 for (int i = 0; i < fNumThreads; i++) {
786 SkPicture* pic;
787 if (i == fNumThreads-1) {
788 // The last set will use the original SkPicture.
789 pic = fPicture;
790 } else {
791 pic = &fPictureClones[i];
792 }
793 const int start = i * chunkSize;
794 const int end = SkMin32(start + chunkSize, fTileRects.count());
795 fCloneData[i] = SkNEW_ARGS(CloneData,
commit-bot@chromium.orga3f882c2013-12-13 20:52:36 +0000796 (pic, fCanvasPool[i], fTileRects, start, end, &fCountdown,
797 fJsonSummaryPtr));
scroggo@google.coma62da2f2012-11-02 21:28:12 +0000798 }
799}
800
edisonn@google.com84f548c2012-12-18 22:24:03 +0000801bool MultiCorePictureRenderer::render(const SkString *path, SkBitmap** out) {
scroggo@google.coma62da2f2012-11-02 21:28:12 +0000802 bool success = true;
803 if (path != NULL) {
804 for (int i = 0; i < fNumThreads-1; i++) {
805 fCloneData[i]->setPathAndSuccess(path, &success);
806 }
807 }
808
edisonn@google.com84f548c2012-12-18 22:24:03 +0000809 if (NULL != out) {
810 *out = SkNEW(SkBitmap);
811 setup_bitmap(*out, fPicture->width(), fPicture->height());
812 for (int i = 0; i < fNumThreads; i++) {
813 fCloneData[i]->setBitmap(*out);
814 }
815 } else {
816 for (int i = 0; i < fNumThreads; i++) {
817 fCloneData[i]->setBitmap(NULL);
818 }
819 }
820
scroggo@google.coma62da2f2012-11-02 21:28:12 +0000821 fCountdown.reset(fNumThreads);
822 for (int i = 0; i < fNumThreads; i++) {
823 fThreadPool.add(fCloneData[i]);
824 }
825 fCountdown.wait();
826
827 return success;
828}
829
830void MultiCorePictureRenderer::end() {
831 for (int i = 0; i < fNumThreads - 1; i++) {
832 SkDELETE(fCloneData[i]);
833 fCloneData[i] = NULL;
834 }
835
836 fCanvasPool.unrefAll();
837
838 this->INHERITED::end();
839}
840
841MultiCorePictureRenderer::~MultiCorePictureRenderer() {
842 // Each individual CloneData was deleted in end.
843 SkDELETE_ARRAY(fCloneData);
844 SkDELETE_ARRAY(fPictureClones);
845}
scroggo@google.combcdf2ec2012-09-20 14:42:33 +0000846
scroggo@google.com0a049b82012-11-02 22:01:26 +0000847SkString MultiCorePictureRenderer::getConfigNameInternal() {
848 SkString name = this->INHERITED::getConfigNameInternal();
849 name.appendf("_multi_%i_threads", fNumThreads);
850 return name;
851}
852
scroggo@google.comacfb30e2012-09-18 14:32:35 +0000853///////////////////////////////////////////////////////////////////////////////////////////////
scroggo@google.com9a412522012-09-07 15:21:18 +0000854
855void PlaybackCreationRenderer::setup() {
junov@chromium.org9313ca42012-11-02 18:11:49 +0000856 fReplayer.reset(this->createPicture());
scroggo@google.com82ec0b02012-12-17 19:25:54 +0000857 SkCanvas* recorder = fReplayer->beginRecording(this->getViewWidth(), this->getViewHeight(),
junov@chromium.org9313ca42012-11-02 18:11:49 +0000858 this->recordFlags());
scroggo@google.com82ec0b02012-12-17 19:25:54 +0000859 this->scaleToScaleFactor(recorder);
scroggo@google.com9a412522012-09-07 15:21:18 +0000860 fPicture->draw(recorder);
861}
862
edisonn@google.com84f548c2012-12-18 22:24:03 +0000863bool PlaybackCreationRenderer::render(const SkString*, SkBitmap** out) {
junov@chromium.org9313ca42012-11-02 18:11:49 +0000864 fReplayer->endRecording();
scroggo@google.com81f9d2e2012-09-20 14:54:21 +0000865 // Since this class does not actually render, return false.
866 return false;
keyar@chromium.org451bb9f2012-07-26 17:27:57 +0000867}
868
scroggo@google.com0a049b82012-11-02 22:01:26 +0000869SkString PlaybackCreationRenderer::getConfigNameInternal() {
870 return SkString("playback_creation");
871}
872
junov@chromium.org9313ca42012-11-02 18:11:49 +0000873///////////////////////////////////////////////////////////////////////////////////////////////
874// SkPicture variants for each BBoxHierarchy type
875
876class RTreePicture : public SkPicture {
877public:
878 virtual SkBBoxHierarchy* createBBoxHierarchy() const SK_OVERRIDE{
879 static const int kRTreeMinChildren = 6;
880 static const int kRTreeMaxChildren = 11;
881 SkScalar aspectRatio = SkScalarDiv(SkIntToScalar(fWidth),
882 SkIntToScalar(fHeight));
sglez@google.com8c902122013-08-30 17:27:47 +0000883 bool sortDraws = false;
junov@chromium.org9313ca42012-11-02 18:11:49 +0000884 return SkRTree::Create(kRTreeMinChildren, kRTreeMaxChildren,
sglez@google.com8c902122013-08-30 17:27:47 +0000885 aspectRatio, sortDraws);
junov@chromium.org9313ca42012-11-02 18:11:49 +0000886 }
887};
888
889SkPicture* PictureRenderer::createPicture() {
890 switch (fBBoxHierarchyType) {
891 case kNone_BBoxHierarchyType:
892 return SkNEW(SkPicture);
893 case kRTree_BBoxHierarchyType:
894 return SkNEW(RTreePicture);
junov@chromium.org7b537062012-11-06 18:58:43 +0000895 case kTileGrid_BBoxHierarchyType:
junov@chromium.org29b19e52013-02-27 18:35:16 +0000896 return SkNEW_ARGS(SkTileGridPicture, (fPicture->width(),
897 fPicture->height(), fGridInfo));
junov@chromium.org9313ca42012-11-02 18:11:49 +0000898 }
899 SkASSERT(0); // invalid bbhType
900 return NULL;
keyar@chromium.org451bb9f2012-07-26 17:27:57 +0000901}
junov@chromium.org9313ca42012-11-02 18:11:49 +0000902
reed@google.comfe7b1ed2012-11-29 21:00:39 +0000903///////////////////////////////////////////////////////////////////////////////
904
905class GatherRenderer : public PictureRenderer {
906public:
edisonn@google.com84f548c2012-12-18 22:24:03 +0000907 virtual bool render(const SkString* path, SkBitmap** out = NULL)
908 SK_OVERRIDE {
reed@google.comfe7b1ed2012-11-29 21:00:39 +0000909 SkRect bounds = SkRect::MakeWH(SkIntToScalar(fPicture->width()),
910 SkIntToScalar(fPicture->height()));
911 SkData* data = SkPictureUtils::GatherPixelRefs(fPicture, bounds);
912 SkSafeUnref(data);
skia.committer@gmail.comc7b4be72012-12-11 02:01:20 +0000913
reed@google.comfe7b1ed2012-11-29 21:00:39 +0000914 return NULL == path; // we don't have anything to write
915 }
skia.committer@gmail.comc7b4be72012-12-11 02:01:20 +0000916
reed@google.comfe7b1ed2012-11-29 21:00:39 +0000917private:
918 virtual SkString getConfigNameInternal() SK_OVERRIDE {
919 return SkString("gather_pixelrefs");
920 }
921};
922
923PictureRenderer* CreateGatherPixelRefsRenderer() {
924 return SkNEW(GatherRenderer);
925}
skia.committer@gmail.comc3d7d902012-11-30 02:01:24 +0000926
reed@google.com5a34fd32012-12-10 16:05:09 +0000927///////////////////////////////////////////////////////////////////////////////
928
929class PictureCloneRenderer : public PictureRenderer {
930public:
edisonn@google.com84f548c2012-12-18 22:24:03 +0000931 virtual bool render(const SkString* path, SkBitmap** out = NULL)
932 SK_OVERRIDE {
reed@google.com5a34fd32012-12-10 16:05:09 +0000933 for (int i = 0; i < 100; ++i) {
934 SkPicture* clone = fPicture->clone();
935 SkSafeUnref(clone);
936 }
skia.committer@gmail.comc7b4be72012-12-11 02:01:20 +0000937
reed@google.com5a34fd32012-12-10 16:05:09 +0000938 return NULL == path; // we don't have anything to write
939 }
skia.committer@gmail.comc7b4be72012-12-11 02:01:20 +0000940
reed@google.com5a34fd32012-12-10 16:05:09 +0000941private:
942 virtual SkString getConfigNameInternal() SK_OVERRIDE {
943 return SkString("picture_clone");
944 }
945};
946
947PictureRenderer* CreatePictureCloneRenderer() {
948 return SkNEW(PictureCloneRenderer);
949}
950
junov@chromium.org9313ca42012-11-02 18:11:49 +0000951} // namespace sk_tools