2012-08-20 21:02:49 +00:00
|
|
|
/*
|
|
|
|
* Copyright 2012 Google Inc.
|
|
|
|
*
|
|
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
|
|
* found in the LICENSE file.
|
|
|
|
*/
|
|
|
|
|
2012-07-26 17:27:57 +00:00
|
|
|
#include "PictureRenderer.h"
|
2012-08-31 16:15:22 +00:00
|
|
|
#include "picture_utils.h"
|
2012-07-26 17:27:57 +00:00
|
|
|
#include "SamplePipeControllers.h"
|
2013-12-13 20:52:36 +00:00
|
|
|
#include "SkBitmapHasher.h"
|
2012-07-26 17:27:57 +00:00
|
|
|
#include "SkCanvas.h"
|
2013-05-21 20:31:23 +00:00
|
|
|
#include "SkData.h"
|
2012-07-26 17:27:57 +00:00
|
|
|
#include "SkDevice.h"
|
2013-12-18 17:25:33 +00:00
|
|
|
#include "SkDiscardableMemoryPool.h"
|
2012-07-26 17:27:57 +00:00
|
|
|
#include "SkGPipe.h"
|
2012-08-31 16:15:22 +00:00
|
|
|
#if SK_SUPPORT_GPU
|
2013-02-07 19:45:46 +00:00
|
|
|
#include "gl/GrGLDefines.h"
|
2012-08-31 16:15:22 +00:00
|
|
|
#include "SkGpuDevice.h"
|
|
|
|
#endif
|
|
|
|
#include "SkGraphics.h"
|
|
|
|
#include "SkImageEncoder.h"
|
2012-11-06 21:26:13 +00:00
|
|
|
#include "SkMaskFilter.h"
|
2012-08-23 15:24:13 +00:00
|
|
|
#include "SkMatrix.h"
|
2012-07-26 17:27:57 +00:00
|
|
|
#include "SkPicture.h"
|
2013-05-21 20:31:23 +00:00
|
|
|
#include "SkPictureUtils.h"
|
|
|
|
#include "SkPixelRef.h"
|
Initial QuadTree implementation
In an effort to find a faster bounding box hierarchy than the R-Tree, a QuadTree has been implemented here.
For now, the QuadTree construction is generally faster than the R-Tree and the queries are a bit slower, so overall, SKP local tests showed QuadTree performance similar to the R-Tree performance.
Tests and bench are included in this cl.
At this point, I'd like to be able to commit this in order to more easily use the bots to test multiple configurations and a larger number of SKPs. The R-Tree BBH is still used by default so this change shouldn't affect chromium.
BUG=skia:
R=junov@chromium.org, junov@google.com, senorblanco@google.com, senorblanco@chromium.org, reed@google.com, sugoi@google.com, fmalita@google.com
Author: sugoi@chromium.org
Review URL: https://codereview.chromium.org/131343011
git-svn-id: http://skia.googlecode.com/svn/trunk@13282 2bbb7eff-a529-9590-31e7-b0007b416f81
2014-02-03 18:08:33 +00:00
|
|
|
#include "SkQuadTree.h"
|
|
|
|
#include "SkQuadTreePicture.h"
|
2012-11-02 18:11:49 +00:00
|
|
|
#include "SkRTree.h"
|
2012-08-23 15:24:13 +00:00
|
|
|
#include "SkScalar.h"
|
2012-11-07 17:52:48 +00:00
|
|
|
#include "SkStream.h"
|
2012-08-21 19:05:08 +00:00
|
|
|
#include "SkString.h"
|
2012-08-31 16:15:22 +00:00
|
|
|
#include "SkTemplates.h"
|
2012-12-13 16:39:53 +00:00
|
|
|
#include "SkTileGridPicture.h"
|
2012-07-26 17:27:57 +00:00
|
|
|
#include "SkTDArray.h"
|
2012-08-31 16:15:22 +00:00
|
|
|
#include "SkThreadUtils.h"
|
2012-07-26 17:27:57 +00:00
|
|
|
#include "SkTypes.h"
|
2012-08-20 15:03:29 +00:00
|
|
|
|
2013-12-18 04:59:26 +00:00
|
|
|
static inline SkScalar scalar_log2(SkScalar x) {
|
|
|
|
static const SkScalar log2_conversion_factor = SkScalarDiv(1, SkScalarLog(2));
|
2013-12-18 07:01:56 +00:00
|
|
|
|
2013-12-18 04:59:26 +00:00
|
|
|
return SkScalarLog(x) * log2_conversion_factor;
|
|
|
|
}
|
|
|
|
|
2012-07-26 17:27:57 +00:00
|
|
|
namespace sk_tools {
|
|
|
|
|
|
|
|
enum {
|
|
|
|
kDefaultTileWidth = 256,
|
|
|
|
kDefaultTileHeight = 256
|
|
|
|
};
|
|
|
|
|
2013-12-13 20:52:36 +00:00
|
|
|
/* TODO(epoger): These constants are already maintained in 2 other places:
|
|
|
|
* gm/gm_json.py and gm/gm_expectations.cpp. We shouldn't add yet a third place.
|
|
|
|
* Figure out a way to share the definitions instead.
|
|
|
|
*/
|
|
|
|
const static char kJsonKey_ActualResults[] = "actual-results";
|
|
|
|
const static char kJsonKey_ActualResults_NoComparison[] = "no-comparison";
|
|
|
|
const static char kJsonKey_Hashtype_Bitmap_64bitMD5[] = "bitmap-64bitMD5";
|
|
|
|
|
|
|
|
void ImageResultsSummary::add(const char *testName, const SkBitmap& bitmap) {
|
|
|
|
uint64_t hash;
|
|
|
|
SkAssertResult(SkBitmapHasher::ComputeDigest(bitmap, &hash));
|
|
|
|
Json::Value jsonTypeValuePair;
|
|
|
|
jsonTypeValuePair.append(Json::Value(kJsonKey_Hashtype_Bitmap_64bitMD5));
|
|
|
|
jsonTypeValuePair.append(Json::UInt64(hash));
|
|
|
|
fActualResultsNoComparison[testName] = jsonTypeValuePair;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ImageResultsSummary::writeToFile(const char *filename) {
|
|
|
|
Json::Value actualResults;
|
|
|
|
actualResults[kJsonKey_ActualResults_NoComparison] = fActualResultsNoComparison;
|
|
|
|
Json::Value root;
|
|
|
|
root[kJsonKey_ActualResults] = actualResults;
|
|
|
|
std::string jsonStdString = root.toStyledString();
|
|
|
|
SkFILEWStream stream(filename);
|
|
|
|
stream.write(jsonStdString.c_str(), jsonStdString.length());
|
|
|
|
}
|
|
|
|
|
2012-08-07 17:11:33 +00:00
|
|
|
void PictureRenderer::init(SkPicture* pict) {
|
2012-08-20 15:03:44 +00:00
|
|
|
SkASSERT(NULL == fPicture);
|
|
|
|
SkASSERT(NULL == fCanvas.get());
|
|
|
|
if (fPicture != NULL || NULL != fCanvas.get()) {
|
2012-08-07 17:11:33 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
SkASSERT(pict != NULL);
|
2012-08-20 15:03:44 +00:00
|
|
|
if (NULL == pict) {
|
2012-08-07 17:11:33 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
fPicture = pict;
|
2012-11-02 18:11:49 +00:00
|
|
|
fPicture->ref();
|
2012-08-20 15:03:57 +00:00
|
|
|
fCanvas.reset(this->setupCanvas());
|
|
|
|
}
|
|
|
|
|
2012-11-06 21:26:13 +00:00
|
|
|
class FlagsDrawFilter : public SkDrawFilter {
|
|
|
|
public:
|
|
|
|
FlagsDrawFilter(PictureRenderer::DrawFilterFlags* flags) :
|
|
|
|
fFlags(flags) {}
|
|
|
|
|
2012-11-26 20:26:54 +00:00
|
|
|
virtual bool filter(SkPaint* paint, Type t) {
|
2012-11-06 21:26:13 +00:00
|
|
|
paint->setFlags(paint->getFlags() & ~fFlags[t] & SkPaint::kAllFlags);
|
2013-07-03 15:34:35 +00:00
|
|
|
if (PictureRenderer::kMaskFilter_DrawFilterFlag & fFlags[t]) {
|
2012-11-06 21:26:13 +00:00
|
|
|
SkMaskFilter* maskFilter = paint->getMaskFilter();
|
2013-07-03 15:34:35 +00:00
|
|
|
if (NULL != maskFilter) {
|
2012-12-18 18:20:44 +00:00
|
|
|
paint->setMaskFilter(NULL);
|
2012-11-06 21:26:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (PictureRenderer::kHinting_DrawFilterFlag & fFlags[t]) {
|
|
|
|
paint->setHinting(SkPaint::kNo_Hinting);
|
|
|
|
} else if (PictureRenderer::kSlightHinting_DrawFilterFlag & fFlags[t]) {
|
|
|
|
paint->setHinting(SkPaint::kSlight_Hinting);
|
|
|
|
}
|
2012-11-26 20:26:54 +00:00
|
|
|
return true;
|
2012-11-06 21:26:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
PictureRenderer::DrawFilterFlags* fFlags;
|
|
|
|
};
|
|
|
|
|
2012-12-17 19:25:54 +00:00
|
|
|
static void setUpFilter(SkCanvas* canvas, PictureRenderer::DrawFilterFlags* drawFilters) {
|
2012-11-06 21:26:13 +00:00
|
|
|
if (drawFilters && !canvas->getDrawFilter()) {
|
|
|
|
canvas->setDrawFilter(SkNEW_ARGS(FlagsDrawFilter, (drawFilters)))->unref();
|
2012-11-07 16:42:17 +00:00
|
|
|
if (drawFilters[0] & PictureRenderer::kAAClip_DrawFilterFlag) {
|
|
|
|
canvas->setAllowSoftClip(false);
|
|
|
|
}
|
2012-11-06 21:26:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-20 15:03:57 +00:00
|
|
|
SkCanvas* PictureRenderer::setupCanvas() {
|
2012-12-13 21:40:48 +00:00
|
|
|
const int width = this->getViewWidth();
|
|
|
|
const int height = this->getViewHeight();
|
|
|
|
return this->setupCanvas(width, height);
|
2012-08-20 15:03:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SkCanvas* PictureRenderer::setupCanvas(int width, int height) {
|
2012-11-06 21:26:13 +00:00
|
|
|
SkCanvas* canvas;
|
2012-08-20 15:03:29 +00:00
|
|
|
switch(fDeviceType) {
|
|
|
|
case kBitmap_DeviceType: {
|
|
|
|
SkBitmap bitmap;
|
2012-08-20 15:03:57 +00:00
|
|
|
sk_tools::setup_bitmap(&bitmap, width, height);
|
2012-11-06 21:26:13 +00:00
|
|
|
canvas = SkNEW_ARGS(SkCanvas, (bitmap));
|
2012-08-20 15:03:29 +00:00
|
|
|
}
|
2012-12-17 19:25:54 +00:00
|
|
|
break;
|
2012-08-20 15:03:29 +00:00
|
|
|
#if SK_SUPPORT_GPU
|
2013-02-08 19:38:21 +00:00
|
|
|
#if SK_ANGLE
|
|
|
|
case kAngle_DeviceType:
|
|
|
|
// fall through
|
2014-01-06 18:37:24 +00:00
|
|
|
#endif
|
|
|
|
#if SK_MESA
|
|
|
|
case kMesa_DeviceType:
|
|
|
|
// fall through
|
2013-02-08 19:38:21 +00:00
|
|
|
#endif
|
2012-08-20 15:03:29 +00:00
|
|
|
case kGPU_DeviceType: {
|
2013-04-10 17:27:30 +00:00
|
|
|
SkAutoTUnref<GrSurface> target;
|
2013-02-08 19:38:21 +00:00
|
|
|
if (fGrContext) {
|
|
|
|
// create a render target to back the device
|
|
|
|
GrTextureDesc desc;
|
|
|
|
desc.fConfig = kSkia8888_GrPixelConfig;
|
|
|
|
desc.fFlags = kRenderTarget_GrTextureFlagBit;
|
|
|
|
desc.fWidth = width;
|
|
|
|
desc.fHeight = height;
|
2013-05-02 12:39:37 +00:00
|
|
|
desc.fSampleCnt = fSampleCount;
|
2013-04-10 17:27:30 +00:00
|
|
|
target.reset(fGrContext->createUncachedTexture(desc, NULL, 0));
|
2013-02-08 19:38:21 +00:00
|
|
|
}
|
2013-04-10 17:27:30 +00:00
|
|
|
if (NULL == target.get()) {
|
2013-02-08 19:38:21 +00:00
|
|
|
SkASSERT(0);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-04-10 17:27:30 +00:00
|
|
|
SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(target));
|
2012-11-06 21:26:13 +00:00
|
|
|
canvas = SkNEW_ARGS(SkCanvas, (device.get()));
|
2013-02-08 19:38:21 +00:00
|
|
|
break;
|
2012-08-20 15:03:29 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
SkASSERT(0);
|
2012-12-17 19:25:54 +00:00
|
|
|
return NULL;
|
2012-08-20 15:03:29 +00:00
|
|
|
}
|
2012-12-17 19:25:54 +00:00
|
|
|
setUpFilter(canvas, fDrawFilters);
|
|
|
|
this->scaleToScaleFactor(canvas);
|
2014-01-15 14:51:25 +00:00
|
|
|
|
|
|
|
// Pictures often lie about their extent (i.e., claim to be 100x100 but
|
|
|
|
// only ever draw to 90x100). Clear here so the undrawn portion will have
|
|
|
|
// a consistent color
|
|
|
|
canvas->clear(SK_ColorTRANSPARENT);
|
2012-12-17 19:25:54 +00:00
|
|
|
return canvas;
|
|
|
|
}
|
2012-08-20 15:03:57 +00:00
|
|
|
|
2012-12-17 19:25:54 +00:00
|
|
|
void PictureRenderer::scaleToScaleFactor(SkCanvas* canvas) {
|
|
|
|
SkASSERT(canvas != NULL);
|
|
|
|
if (fScaleFactor != SK_Scalar1) {
|
|
|
|
canvas->scale(fScaleFactor, fScaleFactor);
|
|
|
|
}
|
2012-08-07 17:11:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void PictureRenderer::end() {
|
Change the method for timing individual tiles in bench_pictures.
When timing individual tiles in bench_pictures, keep a timer running
across all repeats, and then take the average. The former method of
timing each iteration separately runs into precision errors on some
platforms.
Running on my Mac Pro with OSX 10.8, the cmsecs for the new method
and the old method are roughly the same when checking the CPU time.
When checking the wall time, the old method often gives me 0ms,
while the new method gives me a larger value. I don't think this
can be entirely attributed to rounding though, since on occasion I
see the old method showing a short time period (.05 - .15ms) while
the new method shows .15ms higher (which is in range for the
difference I'm seeing for other tiles where the old method reports
0ms).
Some other changes:
PictureRenderer::resetState now takes a boolean parameter. If called
with false, it will only do a flush, while if called with true, it
will also call finish.
resetState is now called with true everywhere except in between
iterations of drawing the same tile (when timing individual tiles).
render_pictures_main no longer calls resetState directly, since it
already calls end, which calls resetState.
BUG=http://code.google.com/p/skia/issues/detail?id=1066
Review URL: https://codereview.appspot.com/7101060
git-svn-id: http://skia.googlecode.com/svn/trunk@7424 2bbb7eff-a529-9590-31e7-b0007b416f81
2013-01-28 20:40:24 +00:00
|
|
|
this->resetState(true);
|
2012-11-02 18:11:49 +00:00
|
|
|
SkSafeUnref(fPicture);
|
2012-08-07 17:11:33 +00:00
|
|
|
fPicture = NULL;
|
|
|
|
fCanvas.reset(NULL);
|
|
|
|
}
|
|
|
|
|
2012-12-13 21:40:48 +00:00
|
|
|
int PictureRenderer::getViewWidth() {
|
|
|
|
SkASSERT(fPicture != NULL);
|
2013-02-07 00:13:34 +00:00
|
|
|
int width = SkScalarCeilToInt(fPicture->width() * fScaleFactor);
|
2012-12-13 21:40:48 +00:00
|
|
|
if (fViewport.width() > 0) {
|
|
|
|
width = SkMin32(width, fViewport.width());
|
|
|
|
}
|
|
|
|
return width;
|
|
|
|
}
|
|
|
|
|
|
|
|
int PictureRenderer::getViewHeight() {
|
|
|
|
SkASSERT(fPicture != NULL);
|
2013-02-07 00:13:34 +00:00
|
|
|
int height = SkScalarCeilToInt(fPicture->height() * fScaleFactor);
|
2012-12-13 21:40:48 +00:00
|
|
|
if (fViewport.height() > 0) {
|
|
|
|
height = SkMin32(height, fViewport.height());
|
|
|
|
}
|
|
|
|
return height;
|
|
|
|
}
|
|
|
|
|
2012-11-02 18:11:49 +00:00
|
|
|
/** Converts fPicture to a picture that uses a BBoxHierarchy.
|
|
|
|
* PictureRenderer subclasses that are used to test picture playback
|
|
|
|
* should call this method during init.
|
|
|
|
*/
|
|
|
|
void PictureRenderer::buildBBoxHierarchy() {
|
|
|
|
SkASSERT(NULL != fPicture);
|
|
|
|
if (kNone_BBoxHierarchyType != fBBoxHierarchyType && NULL != fPicture) {
|
|
|
|
SkPicture* newPicture = this->createPicture();
|
|
|
|
SkCanvas* recorder = newPicture->beginRecording(fPicture->width(), fPicture->height(),
|
|
|
|
this->recordFlags());
|
|
|
|
fPicture->draw(recorder);
|
|
|
|
newPicture->endRecording();
|
|
|
|
fPicture->unref();
|
|
|
|
fPicture = newPicture;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Change the method for timing individual tiles in bench_pictures.
When timing individual tiles in bench_pictures, keep a timer running
across all repeats, and then take the average. The former method of
timing each iteration separately runs into precision errors on some
platforms.
Running on my Mac Pro with OSX 10.8, the cmsecs for the new method
and the old method are roughly the same when checking the CPU time.
When checking the wall time, the old method often gives me 0ms,
while the new method gives me a larger value. I don't think this
can be entirely attributed to rounding though, since on occasion I
see the old method showing a short time period (.05 - .15ms) while
the new method shows .15ms higher (which is in range for the
difference I'm seeing for other tiles where the old method reports
0ms).
Some other changes:
PictureRenderer::resetState now takes a boolean parameter. If called
with false, it will only do a flush, while if called with true, it
will also call finish.
resetState is now called with true everywhere except in between
iterations of drawing the same tile (when timing individual tiles).
render_pictures_main no longer calls resetState directly, since it
already calls end, which calls resetState.
BUG=http://code.google.com/p/skia/issues/detail?id=1066
Review URL: https://codereview.appspot.com/7101060
git-svn-id: http://skia.googlecode.com/svn/trunk@7424 2bbb7eff-a529-9590-31e7-b0007b416f81
2013-01-28 20:40:24 +00:00
|
|
|
void PictureRenderer::resetState(bool callFinish) {
|
2012-08-20 15:04:12 +00:00
|
|
|
#if SK_SUPPORT_GPU
|
2013-02-28 20:16:25 +00:00
|
|
|
SkGLContextHelper* glContext = this->getGLContext();
|
2013-02-08 19:38:21 +00:00
|
|
|
if (NULL == glContext) {
|
|
|
|
SkASSERT(kBitmap_DeviceType == fDeviceType);
|
|
|
|
return;
|
|
|
|
}
|
2012-08-20 15:04:15 +00:00
|
|
|
|
2013-02-08 19:38:21 +00:00
|
|
|
fGrContext->flush();
|
|
|
|
if (callFinish) {
|
|
|
|
SK_GL(*glContext, Finish());
|
2012-08-20 15:03:47 +00:00
|
|
|
}
|
2012-08-20 15:04:12 +00:00
|
|
|
#endif
|
2012-08-20 15:03:47 +00:00
|
|
|
}
|
|
|
|
|
2013-12-18 17:25:33 +00:00
|
|
|
void PictureRenderer::purgeTextures() {
|
|
|
|
SkDiscardableMemoryPool* pool = SkGetGlobalDiscardableMemoryPool();
|
|
|
|
|
|
|
|
pool->dumpPool();
|
|
|
|
|
|
|
|
#if SK_SUPPORT_GPU
|
|
|
|
SkGLContextHelper* glContext = this->getGLContext();
|
|
|
|
if (NULL == glContext) {
|
|
|
|
SkASSERT(kBitmap_DeviceType == fDeviceType);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// resetState should've already done this
|
|
|
|
fGrContext->flush();
|
|
|
|
|
|
|
|
fGrContext->purgeAllUnlockedResources();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-11-02 18:11:49 +00:00
|
|
|
uint32_t PictureRenderer::recordFlags() {
|
2013-01-16 20:12:22 +00:00
|
|
|
return ((kNone_BBoxHierarchyType == fBBoxHierarchyType) ? 0 :
|
|
|
|
SkPicture::kOptimizeForClippedPlayback_RecordingFlag) |
|
|
|
|
SkPicture::kUsePathBoundsForClip_RecordingFlag;
|
2012-11-02 18:11:49 +00:00
|
|
|
}
|
|
|
|
|
2012-10-03 17:32:33 +00:00
|
|
|
/**
|
|
|
|
* Write the canvas to the specified path.
|
|
|
|
* @param canvas Must be non-null. Canvas to be written to a file.
|
|
|
|
* @param path Path for the file to be written. Should have no extension; write() will append
|
|
|
|
* an appropriate one. Passed in by value so it can be modified.
|
2013-12-13 20:52:36 +00:00
|
|
|
* @param jsonSummaryPtr If not null, add image results to this summary.
|
2012-10-03 17:32:33 +00:00
|
|
|
* @return bool True if the Canvas is written to a file.
|
2013-12-13 20:52:36 +00:00
|
|
|
*
|
|
|
|
* TODO(epoger): Right now, all canvases must pass through this function in order to be appended
|
|
|
|
* to the ImageResultsSummary. We need some way to add bitmaps to the ImageResultsSummary
|
|
|
|
* even if --writePath has not been specified (and thus this function is not called).
|
|
|
|
*
|
|
|
|
* One fix would be to pass in these path elements separately, and allow this function to be
|
|
|
|
* called even if --writePath was not specified...
|
|
|
|
* const char *outputDir // NULL if we don't want to write image files to disk
|
|
|
|
* const char *filename // name we use within JSON summary, and as the filename within outputDir
|
2012-10-03 17:32:33 +00:00
|
|
|
*/
|
2013-12-13 20:52:36 +00:00
|
|
|
static bool write(SkCanvas* canvas, const SkString* path, ImageResultsSummary *jsonSummaryPtr) {
|
2012-09-20 14:54:21 +00:00
|
|
|
SkASSERT(canvas != NULL);
|
2012-10-03 17:32:33 +00:00
|
|
|
if (NULL == canvas) {
|
2012-08-21 19:05:08 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-12-13 20:52:36 +00:00
|
|
|
SkASSERT(path != NULL); // TODO(epoger): we want to remove this constraint, as noted above
|
|
|
|
SkString fullPathname(*path);
|
|
|
|
fullPathname.append(".png");
|
|
|
|
|
2012-08-21 19:05:08 +00:00
|
|
|
SkBitmap bitmap;
|
2012-09-20 14:54:21 +00:00
|
|
|
SkISize size = canvas->getDeviceSize();
|
|
|
|
sk_tools::setup_bitmap(&bitmap, size.width(), size.height());
|
2012-08-21 19:05:08 +00:00
|
|
|
|
2012-09-20 14:54:21 +00:00
|
|
|
canvas->readPixels(&bitmap, 0, 0);
|
2012-08-21 19:05:08 +00:00
|
|
|
sk_tools::force_all_opaque(bitmap);
|
|
|
|
|
2013-12-13 20:52:36 +00:00
|
|
|
if (NULL != jsonSummaryPtr) {
|
|
|
|
// EPOGER: This is a hacky way of constructing the filename associated with the
|
|
|
|
// image checksum; we assume that outputDir is not NULL, and we remove outputDir
|
|
|
|
// from fullPathname.
|
|
|
|
//
|
|
|
|
// EPOGER: what about including the config type within hashFilename? That way,
|
|
|
|
// we could combine results of different config types without conflicting filenames.
|
|
|
|
SkString hashFilename;
|
|
|
|
sk_tools::get_basename(&hashFilename, fullPathname);
|
|
|
|
jsonSummaryPtr->add(hashFilename.c_str(), bitmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
return SkImageEncoder::EncodeFile(fullPathname.c_str(), bitmap, SkImageEncoder::kPNG_Type, 100);
|
2012-08-21 19:05:08 +00:00
|
|
|
}
|
|
|
|
|
2012-10-03 17:32:33 +00:00
|
|
|
/**
|
2013-12-13 20:52:36 +00:00
|
|
|
* If path is non NULL, append number to it, and call write() to write the
|
2012-10-03 17:32:33 +00:00
|
|
|
* provided canvas to a file. Returns true if path is NULL or if write() succeeds.
|
|
|
|
*/
|
2013-12-13 20:52:36 +00:00
|
|
|
static bool writeAppendNumber(SkCanvas* canvas, const SkString* path, int number,
|
|
|
|
ImageResultsSummary *jsonSummaryPtr) {
|
2012-10-03 17:32:33 +00:00
|
|
|
if (NULL == path) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
SkString pathWithNumber(*path);
|
|
|
|
pathWithNumber.appendf("%i", number);
|
2013-12-13 20:52:36 +00:00
|
|
|
return write(canvas, &pathWithNumber, jsonSummaryPtr);
|
2012-10-03 17:32:33 +00:00
|
|
|
}
|
|
|
|
|
2012-09-18 14:32:35 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2012-11-06 16:54:40 +00:00
|
|
|
SkCanvas* RecordPictureRenderer::setupCanvas(int width, int height) {
|
|
|
|
// defer the canvas setup until the render step
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-01-08 15:42:01 +00:00
|
|
|
// the size_t* parameter is deprecated, so we ignore it
|
|
|
|
static SkData* encode_bitmap_to_data(size_t*, const SkBitmap& bm) {
|
2013-05-21 20:31:23 +00:00
|
|
|
return SkImageEncoder::EncodeData(bm, SkImageEncoder::kPNG_Type, 100);
|
2012-11-07 17:52:48 +00:00
|
|
|
}
|
|
|
|
|
2012-12-18 22:24:03 +00:00
|
|
|
bool RecordPictureRenderer::render(const SkString* path, SkBitmap** out) {
|
2012-11-02 18:11:49 +00:00
|
|
|
SkAutoTUnref<SkPicture> replayer(this->createPicture());
|
2012-12-17 19:25:54 +00:00
|
|
|
SkCanvas* recorder = replayer->beginRecording(this->getViewWidth(), this->getViewHeight(),
|
2012-11-02 18:11:49 +00:00
|
|
|
this->recordFlags());
|
2012-12-17 19:25:54 +00:00
|
|
|
this->scaleToScaleFactor(recorder);
|
2012-09-07 15:21:18 +00:00
|
|
|
fPicture->draw(recorder);
|
2012-11-02 18:11:49 +00:00
|
|
|
replayer->endRecording();
|
2012-11-07 17:52:48 +00:00
|
|
|
if (path != NULL) {
|
|
|
|
// Record the new picture as a new SKP with PNG encoded bitmaps.
|
|
|
|
SkString skpPath(*path);
|
|
|
|
// ".skp" was removed from 'path' before being passed in here.
|
|
|
|
skpPath.append(".skp");
|
|
|
|
SkFILEWStream stream(skpPath.c_str());
|
2013-05-21 20:31:23 +00:00
|
|
|
replayer->serialize(&stream, &encode_bitmap_to_data);
|
2012-11-07 17:52:48 +00:00
|
|
|
return true;
|
|
|
|
}
|
2012-09-20 14:54:21 +00:00
|
|
|
return false;
|
2012-09-07 15:21:18 +00:00
|
|
|
}
|
|
|
|
|
2012-11-02 22:01:26 +00:00
|
|
|
SkString RecordPictureRenderer::getConfigNameInternal() {
|
|
|
|
return SkString("record");
|
|
|
|
}
|
|
|
|
|
2012-09-18 14:32:35 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2012-12-18 22:24:03 +00:00
|
|
|
bool PipePictureRenderer::render(const SkString* path, SkBitmap** out) {
|
2012-08-07 17:11:33 +00:00
|
|
|
SkASSERT(fCanvas.get() != NULL);
|
|
|
|
SkASSERT(fPicture != NULL);
|
2012-08-20 15:03:44 +00:00
|
|
|
if (NULL == fCanvas.get() || NULL == fPicture) {
|
2012-09-20 14:54:21 +00:00
|
|
|
return false;
|
2012-08-07 17:11:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
PipeController pipeController(fCanvas.get());
|
2012-07-26 17:27:57 +00:00
|
|
|
SkGPipeWriter writer;
|
|
|
|
SkCanvas* pipeCanvas = writer.startRecording(&pipeController);
|
2012-08-07 17:11:33 +00:00
|
|
|
pipeCanvas->drawPicture(*fPicture);
|
2012-07-26 17:27:57 +00:00
|
|
|
writer.endRecording();
|
2012-09-07 15:21:18 +00:00
|
|
|
fCanvas->flush();
|
2012-10-26 13:26:55 +00:00
|
|
|
if (NULL != path) {
|
2013-12-13 20:52:36 +00:00
|
|
|
return write(fCanvas, path, fJsonSummaryPtr);
|
2012-10-26 13:26:55 +00:00
|
|
|
}
|
2012-12-18 22:24:03 +00:00
|
|
|
if (NULL != out) {
|
|
|
|
*out = SkNEW(SkBitmap);
|
|
|
|
setup_bitmap(*out, fPicture->width(), fPicture->height());
|
|
|
|
fCanvas->readPixels(*out, 0, 0);
|
2012-12-19 02:01:38 +00:00
|
|
|
}
|
2012-10-26 13:26:55 +00:00
|
|
|
return true;
|
2012-07-26 17:27:57 +00:00
|
|
|
}
|
|
|
|
|
2012-11-02 22:01:26 +00:00
|
|
|
SkString PipePictureRenderer::getConfigNameInternal() {
|
|
|
|
return SkString("pipe");
|
|
|
|
}
|
|
|
|
|
2012-09-18 14:32:35 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2012-11-02 18:11:49 +00:00
|
|
|
void SimplePictureRenderer::init(SkPicture* picture) {
|
|
|
|
INHERITED::init(picture);
|
|
|
|
this->buildBBoxHierarchy();
|
|
|
|
}
|
|
|
|
|
2012-12-18 22:24:03 +00:00
|
|
|
bool SimplePictureRenderer::render(const SkString* path, SkBitmap** out) {
|
2012-08-07 17:11:33 +00:00
|
|
|
SkASSERT(fCanvas.get() != NULL);
|
|
|
|
SkASSERT(fPicture != NULL);
|
2012-08-20 15:03:44 +00:00
|
|
|
if (NULL == fCanvas.get() || NULL == fPicture) {
|
2012-09-20 14:54:21 +00:00
|
|
|
return false;
|
2012-08-07 17:11:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fCanvas->drawPicture(*fPicture);
|
2012-09-07 15:21:18 +00:00
|
|
|
fCanvas->flush();
|
2012-10-26 13:26:55 +00:00
|
|
|
if (NULL != path) {
|
2013-12-13 20:52:36 +00:00
|
|
|
return write(fCanvas, path, fJsonSummaryPtr);
|
2012-10-26 13:26:55 +00:00
|
|
|
}
|
2012-12-19 02:01:38 +00:00
|
|
|
|
2012-12-18 22:24:03 +00:00
|
|
|
if (NULL != out) {
|
|
|
|
*out = SkNEW(SkBitmap);
|
|
|
|
setup_bitmap(*out, fPicture->width(), fPicture->height());
|
|
|
|
fCanvas->readPixels(*out, 0, 0);
|
|
|
|
}
|
|
|
|
|
2012-10-26 13:26:55 +00:00
|
|
|
return true;
|
2012-07-26 17:27:57 +00:00
|
|
|
}
|
|
|
|
|
2012-11-02 22:01:26 +00:00
|
|
|
SkString SimplePictureRenderer::getConfigNameInternal() {
|
|
|
|
return SkString("simple");
|
|
|
|
}
|
|
|
|
|
2012-09-18 14:32:35 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2012-07-26 17:27:57 +00:00
|
|
|
TiledPictureRenderer::TiledPictureRenderer()
|
2012-11-02 21:28:12 +00:00
|
|
|
: fTileWidth(kDefaultTileWidth)
|
2012-08-29 17:35:07 +00:00
|
|
|
, fTileHeight(kDefaultTileHeight)
|
2012-09-10 19:01:38 +00:00
|
|
|
, fTileWidthPercentage(0.0)
|
2012-08-29 17:35:07 +00:00
|
|
|
, fTileHeightPercentage(0.0)
|
Provide an option to bench drawing individual tiles in bench_pictures.
Provides output like the following:
running bench [1236 12045] androidpolice.skp
tile_256x256: tile [0,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [1,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [2,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [3,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [4,0] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,1] out of [5,48]: msecs = 2.00
tile_256x256: tile [1,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [2,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [3,1] out of [5,48]: msecs = 6.00
tile_256x256: tile [4,1] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,2] out of [5,48]: msecs = 2.00
BUG=https://code.google.com/p/skia/issues/detail?id=1016
Review URL: https://codereview.appspot.com/6937047
git-svn-id: http://skia.googlecode.com/svn/trunk@6805 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-12-13 22:09:28 +00:00
|
|
|
, fTileMinPowerOf2Width(0)
|
|
|
|
, fCurrentTileOffset(-1)
|
|
|
|
, fTilesX(0)
|
|
|
|
, fTilesY(0) { }
|
2012-07-26 17:27:57 +00:00
|
|
|
|
2012-08-07 17:11:33 +00:00
|
|
|
void TiledPictureRenderer::init(SkPicture* pict) {
|
|
|
|
SkASSERT(pict != NULL);
|
2012-09-18 14:32:35 +00:00
|
|
|
SkASSERT(0 == fTileRects.count());
|
|
|
|
if (NULL == pict || fTileRects.count() != 0) {
|
2012-08-07 17:11:33 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-09-18 14:32:35 +00:00
|
|
|
// Do not call INHERITED::init(), which would create a (potentially large) canvas which is not
|
|
|
|
// used by bench_pictures.
|
|
|
|
fPicture = pict;
|
2012-11-02 18:11:49 +00:00
|
|
|
fPicture->ref();
|
2012-11-02 21:28:12 +00:00
|
|
|
this->buildBBoxHierarchy();
|
2012-07-27 20:09:26 +00:00
|
|
|
|
|
|
|
if (fTileWidthPercentage > 0) {
|
2012-08-15 14:36:41 +00:00
|
|
|
fTileWidth = sk_float_ceil2int(float(fTileWidthPercentage * fPicture->width() / 100));
|
2012-07-27 20:09:26 +00:00
|
|
|
}
|
|
|
|
if (fTileHeightPercentage > 0) {
|
2012-08-15 14:36:41 +00:00
|
|
|
fTileHeight = sk_float_ceil2int(float(fTileHeightPercentage * fPicture->height() / 100));
|
2012-07-27 20:09:26 +00:00
|
|
|
}
|
|
|
|
|
2012-08-23 20:53:25 +00:00
|
|
|
if (fTileMinPowerOf2Width > 0) {
|
|
|
|
this->setupPowerOf2Tiles();
|
|
|
|
} else {
|
|
|
|
this->setupTiles();
|
|
|
|
}
|
Provide an option to bench drawing individual tiles in bench_pictures.
Provides output like the following:
running bench [1236 12045] androidpolice.skp
tile_256x256: tile [0,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [1,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [2,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [3,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [4,0] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,1] out of [5,48]: msecs = 2.00
tile_256x256: tile [1,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [2,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [3,1] out of [5,48]: msecs = 6.00
tile_256x256: tile [4,1] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,2] out of [5,48]: msecs = 2.00
BUG=https://code.google.com/p/skia/issues/detail?id=1016
Review URL: https://codereview.appspot.com/6937047
git-svn-id: http://skia.googlecode.com/svn/trunk@6805 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-12-13 22:09:28 +00:00
|
|
|
fCanvas.reset(this->setupCanvas(fTileWidth, fTileHeight));
|
|
|
|
// Initialize to -1 so that the first call to nextTile will set this up to draw tile 0 on the
|
|
|
|
// first call to drawCurrentTile.
|
|
|
|
fCurrentTileOffset = -1;
|
2012-07-26 17:27:57 +00:00
|
|
|
}
|
|
|
|
|
2012-08-07 17:11:33 +00:00
|
|
|
void TiledPictureRenderer::end() {
|
2012-09-20 14:42:33 +00:00
|
|
|
fTileRects.reset();
|
2012-08-07 17:11:33 +00:00
|
|
|
this->INHERITED::end();
|
2012-07-26 17:27:57 +00:00
|
|
|
}
|
|
|
|
|
2012-08-07 17:11:33 +00:00
|
|
|
void TiledPictureRenderer::setupTiles() {
|
2012-12-13 21:40:48 +00:00
|
|
|
// Only use enough tiles to cover the viewport
|
|
|
|
const int width = this->getViewWidth();
|
|
|
|
const int height = this->getViewHeight();
|
|
|
|
|
Provide an option to bench drawing individual tiles in bench_pictures.
Provides output like the following:
running bench [1236 12045] androidpolice.skp
tile_256x256: tile [0,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [1,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [2,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [3,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [4,0] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,1] out of [5,48]: msecs = 2.00
tile_256x256: tile [1,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [2,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [3,1] out of [5,48]: msecs = 6.00
tile_256x256: tile [4,1] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,2] out of [5,48]: msecs = 2.00
BUG=https://code.google.com/p/skia/issues/detail?id=1016
Review URL: https://codereview.appspot.com/6937047
git-svn-id: http://skia.googlecode.com/svn/trunk@6805 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-12-13 22:09:28 +00:00
|
|
|
fTilesX = fTilesY = 0;
|
2012-12-13 21:40:48 +00:00
|
|
|
for (int tile_y_start = 0; tile_y_start < height; tile_y_start += fTileHeight) {
|
Provide an option to bench drawing individual tiles in bench_pictures.
Provides output like the following:
running bench [1236 12045] androidpolice.skp
tile_256x256: tile [0,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [1,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [2,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [3,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [4,0] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,1] out of [5,48]: msecs = 2.00
tile_256x256: tile [1,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [2,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [3,1] out of [5,48]: msecs = 6.00
tile_256x256: tile [4,1] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,2] out of [5,48]: msecs = 2.00
BUG=https://code.google.com/p/skia/issues/detail?id=1016
Review URL: https://codereview.appspot.com/6937047
git-svn-id: http://skia.googlecode.com/svn/trunk@6805 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-12-13 22:09:28 +00:00
|
|
|
fTilesY++;
|
2012-12-13 21:40:48 +00:00
|
|
|
for (int tile_x_start = 0; tile_x_start < width; tile_x_start += fTileWidth) {
|
Provide an option to bench drawing individual tiles in bench_pictures.
Provides output like the following:
running bench [1236 12045] androidpolice.skp
tile_256x256: tile [0,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [1,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [2,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [3,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [4,0] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,1] out of [5,48]: msecs = 2.00
tile_256x256: tile [1,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [2,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [3,1] out of [5,48]: msecs = 6.00
tile_256x256: tile [4,1] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,2] out of [5,48]: msecs = 2.00
BUG=https://code.google.com/p/skia/issues/detail?id=1016
Review URL: https://codereview.appspot.com/6937047
git-svn-id: http://skia.googlecode.com/svn/trunk@6805 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-12-13 22:09:28 +00:00
|
|
|
if (0 == tile_y_start) {
|
|
|
|
// Only count tiles in the X direction on the first pass.
|
|
|
|
fTilesX++;
|
|
|
|
}
|
2012-09-18 14:32:35 +00:00
|
|
|
*fTileRects.append() = SkRect::MakeXYWH(SkIntToScalar(tile_x_start),
|
|
|
|
SkIntToScalar(tile_y_start),
|
|
|
|
SkIntToScalar(fTileWidth),
|
|
|
|
SkIntToScalar(fTileHeight));
|
2012-08-23 20:53:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Provide an option to bench drawing individual tiles in bench_pictures.
Provides output like the following:
running bench [1236 12045] androidpolice.skp
tile_256x256: tile [0,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [1,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [2,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [3,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [4,0] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,1] out of [5,48]: msecs = 2.00
tile_256x256: tile [1,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [2,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [3,1] out of [5,48]: msecs = 6.00
tile_256x256: tile [4,1] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,2] out of [5,48]: msecs = 2.00
BUG=https://code.google.com/p/skia/issues/detail?id=1016
Review URL: https://codereview.appspot.com/6937047
git-svn-id: http://skia.googlecode.com/svn/trunk@6805 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-12-13 22:09:28 +00:00
|
|
|
bool TiledPictureRenderer::tileDimensions(int &x, int &y) {
|
|
|
|
if (fTileRects.count() == 0 || NULL == fPicture) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
x = fTilesX;
|
|
|
|
y = fTilesY;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-08-23 20:53:25 +00:00
|
|
|
// The goal of the powers of two tiles is to minimize the amount of wasted tile
|
|
|
|
// space in the width-wise direction and then minimize the number of tiles. The
|
|
|
|
// constraints are that every tile must have a pixel width that is a power of
|
|
|
|
// two and also be of some minimal width (that is also a power of two).
|
|
|
|
//
|
2012-08-31 16:15:22 +00:00
|
|
|
// This is solved by first taking our picture size and rounding it up to the
|
2012-08-23 20:53:25 +00:00
|
|
|
// multiple of the minimal width. The binary representation of this rounded
|
|
|
|
// value gives us the tiles we need: a bit of value one means we need a tile of
|
|
|
|
// that size.
|
|
|
|
void TiledPictureRenderer::setupPowerOf2Tiles() {
|
2012-12-13 21:40:48 +00:00
|
|
|
// Only use enough tiles to cover the viewport
|
|
|
|
const int width = this->getViewWidth();
|
|
|
|
const int height = this->getViewHeight();
|
|
|
|
|
|
|
|
int rounded_value = width;
|
|
|
|
if (width % fTileMinPowerOf2Width != 0) {
|
|
|
|
rounded_value = width - (width % fTileMinPowerOf2Width) + fTileMinPowerOf2Width;
|
2012-08-23 20:53:25 +00:00
|
|
|
}
|
|
|
|
|
2013-12-18 04:59:26 +00:00
|
|
|
int num_bits = SkScalarCeilToInt(scalar_log2(SkIntToScalar(width)));
|
2012-08-23 20:53:25 +00:00
|
|
|
int largest_possible_tile_size = 1 << num_bits;
|
|
|
|
|
Provide an option to bench drawing individual tiles in bench_pictures.
Provides output like the following:
running bench [1236 12045] androidpolice.skp
tile_256x256: tile [0,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [1,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [2,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [3,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [4,0] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,1] out of [5,48]: msecs = 2.00
tile_256x256: tile [1,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [2,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [3,1] out of [5,48]: msecs = 6.00
tile_256x256: tile [4,1] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,2] out of [5,48]: msecs = 2.00
BUG=https://code.google.com/p/skia/issues/detail?id=1016
Review URL: https://codereview.appspot.com/6937047
git-svn-id: http://skia.googlecode.com/svn/trunk@6805 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-12-13 22:09:28 +00:00
|
|
|
fTilesX = fTilesY = 0;
|
2012-08-23 20:53:25 +00:00
|
|
|
// The tile height is constant for a particular picture.
|
2012-12-13 21:40:48 +00:00
|
|
|
for (int tile_y_start = 0; tile_y_start < height; tile_y_start += fTileHeight) {
|
Provide an option to bench drawing individual tiles in bench_pictures.
Provides output like the following:
running bench [1236 12045] androidpolice.skp
tile_256x256: tile [0,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [1,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [2,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [3,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [4,0] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,1] out of [5,48]: msecs = 2.00
tile_256x256: tile [1,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [2,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [3,1] out of [5,48]: msecs = 6.00
tile_256x256: tile [4,1] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,2] out of [5,48]: msecs = 2.00
BUG=https://code.google.com/p/skia/issues/detail?id=1016
Review URL: https://codereview.appspot.com/6937047
git-svn-id: http://skia.googlecode.com/svn/trunk@6805 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-12-13 22:09:28 +00:00
|
|
|
fTilesY++;
|
2012-08-23 20:53:25 +00:00
|
|
|
int tile_x_start = 0;
|
|
|
|
int current_width = largest_possible_tile_size;
|
2012-09-18 14:32:35 +00:00
|
|
|
// Set fTileWidth to be the width of the widest tile, so that each canvas is large enough
|
|
|
|
// to draw each tile.
|
|
|
|
fTileWidth = current_width;
|
2012-08-23 20:53:25 +00:00
|
|
|
|
|
|
|
while (current_width >= fTileMinPowerOf2Width) {
|
|
|
|
// It is very important this is a bitwise AND.
|
|
|
|
if (current_width & rounded_value) {
|
Provide an option to bench drawing individual tiles in bench_pictures.
Provides output like the following:
running bench [1236 12045] androidpolice.skp
tile_256x256: tile [0,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [1,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [2,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [3,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [4,0] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,1] out of [5,48]: msecs = 2.00
tile_256x256: tile [1,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [2,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [3,1] out of [5,48]: msecs = 6.00
tile_256x256: tile [4,1] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,2] out of [5,48]: msecs = 2.00
BUG=https://code.google.com/p/skia/issues/detail?id=1016
Review URL: https://codereview.appspot.com/6937047
git-svn-id: http://skia.googlecode.com/svn/trunk@6805 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-12-13 22:09:28 +00:00
|
|
|
if (0 == tile_y_start) {
|
|
|
|
// Only count tiles in the X direction on the first pass.
|
|
|
|
fTilesX++;
|
|
|
|
}
|
2012-09-18 14:32:35 +00:00
|
|
|
*fTileRects.append() = SkRect::MakeXYWH(SkIntToScalar(tile_x_start),
|
|
|
|
SkIntToScalar(tile_y_start),
|
|
|
|
SkIntToScalar(current_width),
|
|
|
|
SkIntToScalar(fTileHeight));
|
2012-08-23 20:53:25 +00:00
|
|
|
tile_x_start += current_width;
|
|
|
|
}
|
|
|
|
|
|
|
|
current_width >>= 1;
|
2012-07-26 17:27:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-20 14:42:33 +00:00
|
|
|
/**
|
|
|
|
* Draw the specified playback to the canvas translated to rectangle provided, so that this mini
|
|
|
|
* canvas represents the rectangle's portion of the overall picture.
|
|
|
|
* Saves and restores so that the initial clip and matrix return to their state before this function
|
|
|
|
* is called.
|
|
|
|
*/
|
|
|
|
template<class T>
|
|
|
|
static void DrawTileToCanvas(SkCanvas* canvas, const SkRect& tileRect, T* playback) {
|
|
|
|
int saveCount = canvas->save();
|
2012-12-17 19:25:54 +00:00
|
|
|
// Translate so that we draw the correct portion of the picture.
|
|
|
|
// Perform a postTranslate so that the scaleFactor does not interfere with the positioning.
|
|
|
|
SkMatrix mat(canvas->getTotalMatrix());
|
|
|
|
mat.postTranslate(-tileRect.fLeft, -tileRect.fTop);
|
|
|
|
canvas->setMatrix(mat);
|
2012-09-20 14:42:33 +00:00
|
|
|
playback->draw(canvas);
|
|
|
|
canvas->restoreToCount(saveCount);
|
|
|
|
canvas->flush();
|
2012-07-26 17:27:57 +00:00
|
|
|
}
|
|
|
|
|
2012-09-20 14:42:33 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2013-12-13 20:52:36 +00:00
|
|
|
/**
|
|
|
|
* Copies the entirety of the src bitmap (typically a tile) into a portion of the dst bitmap.
|
|
|
|
* If the src bitmap is too large to fit within the dst bitmap after the x and y
|
|
|
|
* offsets have been applied, any excess will be ignored (so only the top-left portion of the
|
|
|
|
* src bitmap will be copied).
|
|
|
|
*
|
|
|
|
* @param src source bitmap
|
|
|
|
* @param dst destination bitmap
|
|
|
|
* @param xOffset x-offset within destination bitmap
|
|
|
|
* @param yOffset y-offset within destination bitmap
|
|
|
|
*/
|
|
|
|
static void bitmapCopyAtOffset(const SkBitmap& src, SkBitmap* dst,
|
|
|
|
int xOffset, int yOffset) {
|
|
|
|
for (int y = 0; y <src.height() && y + yOffset < dst->height() ; y++) {
|
|
|
|
for (int x = 0; x < src.width() && x + xOffset < dst->width() ; x++) {
|
|
|
|
*dst->getAddr32(xOffset + x, yOffset + y) = *src.getAddr32(x, y);
|
2012-12-18 22:24:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Provide an option to bench drawing individual tiles in bench_pictures.
Provides output like the following:
running bench [1236 12045] androidpolice.skp
tile_256x256: tile [0,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [1,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [2,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [3,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [4,0] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,1] out of [5,48]: msecs = 2.00
tile_256x256: tile [1,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [2,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [3,1] out of [5,48]: msecs = 6.00
tile_256x256: tile [4,1] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,2] out of [5,48]: msecs = 2.00
BUG=https://code.google.com/p/skia/issues/detail?id=1016
Review URL: https://codereview.appspot.com/6937047
git-svn-id: http://skia.googlecode.com/svn/trunk@6805 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-12-13 22:09:28 +00:00
|
|
|
bool TiledPictureRenderer::nextTile(int &i, int &j) {
|
|
|
|
if (++fCurrentTileOffset < fTileRects.count()) {
|
|
|
|
i = fCurrentTileOffset % fTilesX;
|
|
|
|
j = fCurrentTileOffset / fTilesX;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TiledPictureRenderer::drawCurrentTile() {
|
|
|
|
SkASSERT(fCurrentTileOffset >= 0 && fCurrentTileOffset < fTileRects.count());
|
|
|
|
DrawTileToCanvas(fCanvas, fTileRects[fCurrentTileOffset], fPicture);
|
|
|
|
}
|
|
|
|
|
2012-12-18 22:24:03 +00:00
|
|
|
bool TiledPictureRenderer::render(const SkString* path, SkBitmap** out) {
|
2012-11-02 21:28:12 +00:00
|
|
|
SkASSERT(fPicture != NULL);
|
|
|
|
if (NULL == fPicture) {
|
|
|
|
return false;
|
2012-09-20 14:42:33 +00:00
|
|
|
}
|
|
|
|
|
2012-12-18 22:24:03 +00:00
|
|
|
SkBitmap bitmap;
|
|
|
|
if (out){
|
|
|
|
*out = SkNEW(SkBitmap);
|
|
|
|
setup_bitmap(*out, fPicture->width(), fPicture->height());
|
|
|
|
setup_bitmap(&bitmap, fTileWidth, fTileHeight);
|
|
|
|
}
|
2012-11-02 21:28:12 +00:00
|
|
|
bool success = true;
|
|
|
|
for (int i = 0; i < fTileRects.count(); ++i) {
|
Provide an option to bench drawing individual tiles in bench_pictures.
Provides output like the following:
running bench [1236 12045] androidpolice.skp
tile_256x256: tile [0,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [1,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [2,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [3,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [4,0] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,1] out of [5,48]: msecs = 2.00
tile_256x256: tile [1,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [2,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [3,1] out of [5,48]: msecs = 6.00
tile_256x256: tile [4,1] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,2] out of [5,48]: msecs = 2.00
BUG=https://code.google.com/p/skia/issues/detail?id=1016
Review URL: https://codereview.appspot.com/6937047
git-svn-id: http://skia.googlecode.com/svn/trunk@6805 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-12-13 22:09:28 +00:00
|
|
|
DrawTileToCanvas(fCanvas, fTileRects[i], fPicture);
|
2012-11-02 21:28:12 +00:00
|
|
|
if (NULL != path) {
|
2013-12-13 20:52:36 +00:00
|
|
|
success &= writeAppendNumber(fCanvas, path, i, fJsonSummaryPtr);
|
2012-10-03 17:32:33 +00:00
|
|
|
}
|
2012-12-18 22:24:03 +00:00
|
|
|
if (NULL != out) {
|
|
|
|
if (fCanvas->readPixels(&bitmap, 0, 0)) {
|
2013-12-13 20:52:36 +00:00
|
|
|
// Add this tile to the entire bitmap.
|
|
|
|
bitmapCopyAtOffset(bitmap, *out, SkScalarFloorToInt(fTileRects[i].left()),
|
|
|
|
SkScalarFloorToInt(fTileRects[i].top()));
|
2012-12-18 22:24:03 +00:00
|
|
|
} else {
|
|
|
|
success = false;
|
|
|
|
}
|
|
|
|
}
|
2012-09-20 14:42:33 +00:00
|
|
|
}
|
2012-11-02 21:28:12 +00:00
|
|
|
return success;
|
2012-09-20 14:42:33 +00:00
|
|
|
}
|
2012-08-31 16:15:22 +00:00
|
|
|
|
2012-11-02 21:28:12 +00:00
|
|
|
SkCanvas* TiledPictureRenderer::setupCanvas(int width, int height) {
|
|
|
|
SkCanvas* canvas = this->INHERITED::setupCanvas(width, height);
|
|
|
|
SkASSERT(fPicture != NULL);
|
2012-12-17 19:25:54 +00:00
|
|
|
// Clip the tile to an area that is completely inside both the SkPicture and the viewport. This
|
|
|
|
// is mostly important for tiles on the right and bottom edges as they may go over this area and
|
|
|
|
// the picture may have some commands that draw outside of this area and so should not actually
|
|
|
|
// be written.
|
|
|
|
// Uses a clipRegion so that it will be unaffected by the scale factor, which may have been set
|
|
|
|
// by INHERITED::setupCanvas.
|
|
|
|
SkRegion clipRegion;
|
|
|
|
clipRegion.setRect(0, 0, this->getViewWidth(), this->getViewHeight());
|
|
|
|
canvas->clipRegion(clipRegion);
|
2012-11-02 21:28:12 +00:00
|
|
|
return canvas;
|
|
|
|
}
|
2012-11-02 22:01:26 +00:00
|
|
|
|
|
|
|
SkString TiledPictureRenderer::getConfigNameInternal() {
|
|
|
|
SkString name;
|
|
|
|
if (fTileMinPowerOf2Width > 0) {
|
|
|
|
name.append("pow2tile_");
|
|
|
|
name.appendf("%i", fTileMinPowerOf2Width);
|
|
|
|
} else {
|
|
|
|
name.append("tile_");
|
|
|
|
if (fTileWidthPercentage > 0) {
|
|
|
|
name.appendf("%.f%%", fTileWidthPercentage);
|
|
|
|
} else {
|
|
|
|
name.appendf("%i", fTileWidth);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
name.append("x");
|
|
|
|
if (fTileHeightPercentage > 0) {
|
|
|
|
name.appendf("%.f%%", fTileHeightPercentage);
|
|
|
|
} else {
|
|
|
|
name.appendf("%i", fTileHeight);
|
|
|
|
}
|
|
|
|
return name;
|
|
|
|
}
|
|
|
|
|
2012-08-31 16:15:22 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2012-11-02 21:28:12 +00:00
|
|
|
// Holds all of the information needed to draw a set of tiles.
|
|
|
|
class CloneData : public SkRunnable {
|
|
|
|
|
|
|
|
public:
|
|
|
|
CloneData(SkPicture* clone, SkCanvas* canvas, SkTDArray<SkRect>& rects, int start, int end,
|
2013-12-13 20:52:36 +00:00
|
|
|
SkRunnable* done, ImageResultsSummary* jsonSummaryPtr)
|
2012-11-02 21:28:12 +00:00
|
|
|
: fClone(clone)
|
|
|
|
, fCanvas(canvas)
|
|
|
|
, fPath(NULL)
|
|
|
|
, fRects(rects)
|
|
|
|
, fStart(start)
|
|
|
|
, fEnd(end)
|
|
|
|
, fSuccess(NULL)
|
2013-12-13 20:52:36 +00:00
|
|
|
, fDone(done)
|
|
|
|
, fJsonSummaryPtr(jsonSummaryPtr) {
|
2012-11-02 21:28:12 +00:00
|
|
|
SkASSERT(fDone != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual void run() SK_OVERRIDE {
|
|
|
|
SkGraphics::SetTLSFontCacheLimit(1024 * 1024);
|
2012-12-18 22:24:03 +00:00
|
|
|
|
|
|
|
SkBitmap bitmap;
|
|
|
|
if (fBitmap != NULL) {
|
|
|
|
// All tiles are the same size.
|
2013-01-07 18:41:28 +00:00
|
|
|
setup_bitmap(&bitmap, SkScalarFloorToInt(fRects[0].width()), SkScalarFloorToInt(fRects[0].height()));
|
2012-12-18 22:24:03 +00:00
|
|
|
}
|
2012-12-19 02:01:38 +00:00
|
|
|
|
2012-11-02 21:28:12 +00:00
|
|
|
for (int i = fStart; i < fEnd; i++) {
|
|
|
|
DrawTileToCanvas(fCanvas, fRects[i], fClone);
|
2013-12-13 20:52:36 +00:00
|
|
|
if ((fPath != NULL) && !writeAppendNumber(fCanvas, fPath, i, fJsonSummaryPtr)
|
2012-11-02 21:28:12 +00:00
|
|
|
&& fSuccess != NULL) {
|
|
|
|
*fSuccess = false;
|
|
|
|
// If one tile fails to write to a file, do not continue drawing the rest.
|
|
|
|
break;
|
|
|
|
}
|
2012-12-18 22:24:03 +00:00
|
|
|
if (fBitmap != NULL) {
|
|
|
|
if (fCanvas->readPixels(&bitmap, 0, 0)) {
|
|
|
|
SkAutoLockPixels alp(*fBitmap);
|
2013-12-13 20:52:36 +00:00
|
|
|
bitmapCopyAtOffset(bitmap, fBitmap, SkScalarFloorToInt(fRects[i].left()),
|
|
|
|
SkScalarFloorToInt(fRects[i].top()));
|
2012-12-18 22:24:03 +00:00
|
|
|
} else {
|
|
|
|
*fSuccess = false;
|
|
|
|
// If one tile fails to read pixels, do not continue drawing the rest.
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2012-11-02 21:28:12 +00:00
|
|
|
}
|
|
|
|
fDone->run();
|
|
|
|
}
|
2012-09-20 14:42:33 +00:00
|
|
|
|
2012-11-02 21:28:12 +00:00
|
|
|
void setPathAndSuccess(const SkString* path, bool* success) {
|
|
|
|
fPath = path;
|
|
|
|
fSuccess = success;
|
|
|
|
}
|
2012-09-20 14:42:33 +00:00
|
|
|
|
2012-12-18 22:24:03 +00:00
|
|
|
void setBitmap(SkBitmap* bitmap) {
|
|
|
|
fBitmap = bitmap;
|
|
|
|
}
|
|
|
|
|
2012-11-02 21:28:12 +00:00
|
|
|
private:
|
|
|
|
// All pointers unowned.
|
|
|
|
SkPicture* fClone; // Picture to draw from. Each CloneData has a unique one which
|
|
|
|
// is threadsafe.
|
|
|
|
SkCanvas* fCanvas; // Canvas to draw to. Reused for each tile.
|
|
|
|
const SkString* fPath; // If non-null, path to write the result to as a PNG.
|
|
|
|
SkTDArray<SkRect>& fRects; // All tiles of the picture.
|
|
|
|
const int fStart; // Range of tiles drawn by this thread.
|
|
|
|
const int fEnd;
|
|
|
|
bool* fSuccess; // Only meaningful if path is non-null. Shared by all threads,
|
|
|
|
// and only set to false upon failure to write to a PNG.
|
|
|
|
SkRunnable* fDone;
|
2012-12-18 22:24:03 +00:00
|
|
|
SkBitmap* fBitmap;
|
2013-12-13 20:52:36 +00:00
|
|
|
ImageResultsSummary* fJsonSummaryPtr;
|
2012-08-31 16:15:22 +00:00
|
|
|
};
|
|
|
|
|
2012-11-02 21:28:12 +00:00
|
|
|
MultiCorePictureRenderer::MultiCorePictureRenderer(int threadCount)
|
|
|
|
: fNumThreads(threadCount)
|
|
|
|
, fThreadPool(threadCount)
|
|
|
|
, fCountdown(threadCount) {
|
|
|
|
// Only need to create fNumThreads - 1 clones, since one thread will use the base
|
|
|
|
// picture.
|
|
|
|
fPictureClones = SkNEW_ARRAY(SkPicture, fNumThreads - 1);
|
|
|
|
fCloneData = SkNEW_ARRAY(CloneData*, fNumThreads);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MultiCorePictureRenderer::init(SkPicture *pict) {
|
|
|
|
// Set fPicture and the tiles.
|
|
|
|
this->INHERITED::init(pict);
|
|
|
|
for (int i = 0; i < fNumThreads; ++i) {
|
|
|
|
*fCanvasPool.append() = this->setupCanvas(this->getTileWidth(), this->getTileHeight());
|
|
|
|
}
|
|
|
|
// Only need to create fNumThreads - 1 clones, since one thread will use the base picture.
|
|
|
|
fPicture->clone(fPictureClones, fNumThreads - 1);
|
|
|
|
// Populate each thread with the appropriate data.
|
|
|
|
// Group the tiles into nearly equal size chunks, rounding up so we're sure to cover them all.
|
|
|
|
const int chunkSize = (fTileRects.count() + fNumThreads - 1) / fNumThreads;
|
|
|
|
|
|
|
|
for (int i = 0; i < fNumThreads; i++) {
|
|
|
|
SkPicture* pic;
|
|
|
|
if (i == fNumThreads-1) {
|
|
|
|
// The last set will use the original SkPicture.
|
|
|
|
pic = fPicture;
|
|
|
|
} else {
|
|
|
|
pic = &fPictureClones[i];
|
2012-10-03 17:32:33 +00:00
|
|
|
}
|
2012-11-02 21:28:12 +00:00
|
|
|
const int start = i * chunkSize;
|
|
|
|
const int end = SkMin32(start + chunkSize, fTileRects.count());
|
|
|
|
fCloneData[i] = SkNEW_ARGS(CloneData,
|
2013-12-13 20:52:36 +00:00
|
|
|
(pic, fCanvasPool[i], fTileRects, start, end, &fCountdown,
|
|
|
|
fJsonSummaryPtr));
|
2012-09-20 14:42:33 +00:00
|
|
|
}
|
|
|
|
}
|
2012-08-31 16:15:22 +00:00
|
|
|
|
2012-12-18 22:24:03 +00:00
|
|
|
bool MultiCorePictureRenderer::render(const SkString *path, SkBitmap** out) {
|
2012-11-02 21:28:12 +00:00
|
|
|
bool success = true;
|
|
|
|
if (path != NULL) {
|
|
|
|
for (int i = 0; i < fNumThreads-1; i++) {
|
|
|
|
fCloneData[i]->setPathAndSuccess(path, &success);
|
2012-09-20 14:42:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-18 22:24:03 +00:00
|
|
|
if (NULL != out) {
|
|
|
|
*out = SkNEW(SkBitmap);
|
|
|
|
setup_bitmap(*out, fPicture->width(), fPicture->height());
|
|
|
|
for (int i = 0; i < fNumThreads; i++) {
|
|
|
|
fCloneData[i]->setBitmap(*out);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (int i = 0; i < fNumThreads; i++) {
|
|
|
|
fCloneData[i]->setBitmap(NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-02 21:28:12 +00:00
|
|
|
fCountdown.reset(fNumThreads);
|
|
|
|
for (int i = 0; i < fNumThreads; i++) {
|
|
|
|
fThreadPool.add(fCloneData[i]);
|
2012-09-18 14:32:35 +00:00
|
|
|
}
|
2012-11-02 21:28:12 +00:00
|
|
|
fCountdown.wait();
|
2012-09-18 14:32:35 +00:00
|
|
|
|
2012-11-02 21:28:12 +00:00
|
|
|
return success;
|
|
|
|
}
|
|
|
|
|
|
|
|
void MultiCorePictureRenderer::end() {
|
|
|
|
for (int i = 0; i < fNumThreads - 1; i++) {
|
|
|
|
SkDELETE(fCloneData[i]);
|
|
|
|
fCloneData[i] = NULL;
|
2012-08-01 17:53:29 +00:00
|
|
|
}
|
2012-11-02 21:28:12 +00:00
|
|
|
|
|
|
|
fCanvasPool.unrefAll();
|
|
|
|
|
|
|
|
this->INHERITED::end();
|
2012-08-01 17:53:29 +00:00
|
|
|
}
|
|
|
|
|
2012-11-02 21:28:12 +00:00
|
|
|
MultiCorePictureRenderer::~MultiCorePictureRenderer() {
|
|
|
|
// Each individual CloneData was deleted in end.
|
|
|
|
SkDELETE_ARRAY(fCloneData);
|
|
|
|
SkDELETE_ARRAY(fPictureClones);
|
2012-09-20 14:42:33 +00:00
|
|
|
}
|
|
|
|
|
2012-11-02 22:01:26 +00:00
|
|
|
SkString MultiCorePictureRenderer::getConfigNameInternal() {
|
|
|
|
SkString name = this->INHERITED::getConfigNameInternal();
|
|
|
|
name.appendf("_multi_%i_threads", fNumThreads);
|
|
|
|
return name;
|
|
|
|
}
|
|
|
|
|
2012-09-18 14:32:35 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
2012-09-07 15:21:18 +00:00
|
|
|
|
|
|
|
void PlaybackCreationRenderer::setup() {
|
2012-11-02 18:11:49 +00:00
|
|
|
fReplayer.reset(this->createPicture());
|
2012-12-17 19:25:54 +00:00
|
|
|
SkCanvas* recorder = fReplayer->beginRecording(this->getViewWidth(), this->getViewHeight(),
|
2012-11-02 18:11:49 +00:00
|
|
|
this->recordFlags());
|
2012-12-17 19:25:54 +00:00
|
|
|
this->scaleToScaleFactor(recorder);
|
2012-09-07 15:21:18 +00:00
|
|
|
fPicture->draw(recorder);
|
|
|
|
}
|
|
|
|
|
2012-12-18 22:24:03 +00:00
|
|
|
bool PlaybackCreationRenderer::render(const SkString*, SkBitmap** out) {
|
2012-11-02 18:11:49 +00:00
|
|
|
fReplayer->endRecording();
|
2012-09-20 14:54:21 +00:00
|
|
|
// Since this class does not actually render, return false.
|
|
|
|
return false;
|
2012-07-26 17:27:57 +00:00
|
|
|
}
|
|
|
|
|
2012-11-02 22:01:26 +00:00
|
|
|
SkString PlaybackCreationRenderer::getConfigNameInternal() {
|
|
|
|
return SkString("playback_creation");
|
|
|
|
}
|
|
|
|
|
2012-11-02 18:11:49 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// SkPicture variants for each BBoxHierarchy type
|
|
|
|
|
|
|
|
class RTreePicture : public SkPicture {
|
|
|
|
public:
|
|
|
|
virtual SkBBoxHierarchy* createBBoxHierarchy() const SK_OVERRIDE{
|
|
|
|
static const int kRTreeMinChildren = 6;
|
|
|
|
static const int kRTreeMaxChildren = 11;
|
|
|
|
SkScalar aspectRatio = SkScalarDiv(SkIntToScalar(fWidth),
|
|
|
|
SkIntToScalar(fHeight));
|
2013-08-30 17:27:47 +00:00
|
|
|
bool sortDraws = false;
|
2012-11-02 18:11:49 +00:00
|
|
|
return SkRTree::Create(kRTreeMinChildren, kRTreeMaxChildren,
|
2013-08-30 17:27:47 +00:00
|
|
|
aspectRatio, sortDraws);
|
2012-11-02 18:11:49 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
SkPicture* PictureRenderer::createPicture() {
|
|
|
|
switch (fBBoxHierarchyType) {
|
|
|
|
case kNone_BBoxHierarchyType:
|
|
|
|
return SkNEW(SkPicture);
|
Initial QuadTree implementation
In an effort to find a faster bounding box hierarchy than the R-Tree, a QuadTree has been implemented here.
For now, the QuadTree construction is generally faster than the R-Tree and the queries are a bit slower, so overall, SKP local tests showed QuadTree performance similar to the R-Tree performance.
Tests and bench are included in this cl.
At this point, I'd like to be able to commit this in order to more easily use the bots to test multiple configurations and a larger number of SKPs. The R-Tree BBH is still used by default so this change shouldn't affect chromium.
BUG=skia:
R=junov@chromium.org, junov@google.com, senorblanco@google.com, senorblanco@chromium.org, reed@google.com, sugoi@google.com, fmalita@google.com
Author: sugoi@chromium.org
Review URL: https://codereview.chromium.org/131343011
git-svn-id: http://skia.googlecode.com/svn/trunk@13282 2bbb7eff-a529-9590-31e7-b0007b416f81
2014-02-03 18:08:33 +00:00
|
|
|
case kQuadTree_BBoxHierarchyType:
|
|
|
|
return SkNEW_ARGS(SkQuadTreePicture, (SkIRect::MakeWH(fPicture->width(),
|
|
|
|
fPicture->height())));
|
2012-11-02 18:11:49 +00:00
|
|
|
case kRTree_BBoxHierarchyType:
|
|
|
|
return SkNEW(RTreePicture);
|
2012-11-06 18:58:43 +00:00
|
|
|
case kTileGrid_BBoxHierarchyType:
|
2013-02-27 18:35:16 +00:00
|
|
|
return SkNEW_ARGS(SkTileGridPicture, (fPicture->width(),
|
|
|
|
fPicture->height(), fGridInfo));
|
2012-11-02 18:11:49 +00:00
|
|
|
}
|
|
|
|
SkASSERT(0); // invalid bbhType
|
|
|
|
return NULL;
|
2012-07-26 17:27:57 +00:00
|
|
|
}
|
2012-11-02 18:11:49 +00:00
|
|
|
|
2012-11-29 21:00:39 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
class GatherRenderer : public PictureRenderer {
|
|
|
|
public:
|
2012-12-18 22:24:03 +00:00
|
|
|
virtual bool render(const SkString* path, SkBitmap** out = NULL)
|
|
|
|
SK_OVERRIDE {
|
2012-11-29 21:00:39 +00:00
|
|
|
SkRect bounds = SkRect::MakeWH(SkIntToScalar(fPicture->width()),
|
|
|
|
SkIntToScalar(fPicture->height()));
|
|
|
|
SkData* data = SkPictureUtils::GatherPixelRefs(fPicture, bounds);
|
|
|
|
SkSafeUnref(data);
|
2012-12-11 02:01:20 +00:00
|
|
|
|
2012-11-29 21:00:39 +00:00
|
|
|
return NULL == path; // we don't have anything to write
|
|
|
|
}
|
2012-12-11 02:01:20 +00:00
|
|
|
|
2012-11-29 21:00:39 +00:00
|
|
|
private:
|
|
|
|
virtual SkString getConfigNameInternal() SK_OVERRIDE {
|
|
|
|
return SkString("gather_pixelrefs");
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
PictureRenderer* CreateGatherPixelRefsRenderer() {
|
|
|
|
return SkNEW(GatherRenderer);
|
|
|
|
}
|
2012-11-30 02:01:24 +00:00
|
|
|
|
2012-12-10 16:05:09 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
class PictureCloneRenderer : public PictureRenderer {
|
|
|
|
public:
|
2012-12-18 22:24:03 +00:00
|
|
|
virtual bool render(const SkString* path, SkBitmap** out = NULL)
|
|
|
|
SK_OVERRIDE {
|
2012-12-10 16:05:09 +00:00
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
|
|
SkPicture* clone = fPicture->clone();
|
|
|
|
SkSafeUnref(clone);
|
|
|
|
}
|
2012-12-11 02:01:20 +00:00
|
|
|
|
2012-12-10 16:05:09 +00:00
|
|
|
return NULL == path; // we don't have anything to write
|
|
|
|
}
|
2012-12-11 02:01:20 +00:00
|
|
|
|
2012-12-10 16:05:09 +00:00
|
|
|
private:
|
|
|
|
virtual SkString getConfigNameInternal() SK_OVERRIDE {
|
|
|
|
return SkString("picture_clone");
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
PictureRenderer* CreatePictureCloneRenderer() {
|
|
|
|
return SkNEW(PictureCloneRenderer);
|
|
|
|
}
|
|
|
|
|
2012-11-02 18:11:49 +00:00
|
|
|
} // namespace sk_tools
|