AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

SkMultiPictureDraw API

Browse Source 
This CL adds a new API to optimize across multiple SkPicture draw calls.

Note that multiple pictures rendered at once (i.e., picture piles) should be flattened into a single new picture that includes the required clipping on the different layers.

R=bsalomon@google.com, reed@google.com

Author: robertphillips@google.com

Review URL: https://codereview.chromium.org/491313003
This commit is contained in:
robertphillips 2014-08-21 13:12:42 -07:00 committed by Commit bot
parent ed20c9b9c9
commit 7eacd77ce6
5 changed files with 502 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

369
gm/multipicturedraw.cpp Normal file
View File

@ -0,0 +1,369 @@
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gm.h"
#include "SkColorFilter.h"
#include "SkMultiPictureDraw.h"
#include "SkPictureRecorder.h"
#include "SkSurface.h"
static const SkScalar kRoot3Over2 = 0.86602545f; // sin(60)
static const int kHexSide = 30;
static const int kNumHexX = 6;
static const int kNumHexY = 6;
static const int kPicWidth = kNumHexX * kHexSide;
static const int kPicHeight = SkScalarCeilToInt((kNumHexY - 0.5f) * 2 * kHexSide * kRoot3Over2);
static const SkScalar kInset = 20.0f;
// Create a hexagon centered at (originX, originY)
static SkPath make_hex_path(SkScalar originX, SkScalar originY) {
SkPath hex;
hex.moveTo(originX-kHexSide, originY);
hex.rLineTo(SkScalarHalf(kHexSide), kRoot3Over2 * kHexSide);
hex.rLineTo(SkIntToScalar(kHexSide), 0);
hex.rLineTo(SkScalarHalf(kHexSide), -kHexSide * kRoot3Over2);
hex.rLineTo(-SkScalarHalf(kHexSide), -kHexSide * kRoot3Over2);
hex.rLineTo(-SkIntToScalar(kHexSide), 0);
hex.close();
return hex;
}
// Make a picture that is a tiling of the plane with stroked hexagons where
// each hexagon is in its own layer. The layers are to exercise Ganesh's
// layer hoisting.
static const SkPicture* make_picture(SkColor fillColor) {
// Create a hexagon with its center at the origin
SkPath hex = make_hex_path(0, 0);
SkPaint fill;
fill.setStyle(SkPaint::kFill_Style);
fill.setColor(fillColor);
SkPaint stroke;
stroke.setStyle(SkPaint::kStroke_Style);
stroke.setStrokeWidth(3);
SkPictureRecorder recorder;
SkCanvas* canvas = recorder.beginRecording(kPicWidth, kPicHeight);
SkScalar xPos, yPos = 0;
for (int y = 0; y < kNumHexY; ++y) {
xPos = 0;
for (int x = 0; x < kNumHexX; ++x) {
canvas->saveLayer(NULL, NULL);
canvas->translate(xPos, yPos + ((x % 2) ? kRoot3Over2 * kHexSide : 0));
canvas->drawPath(hex, fill);
canvas->drawPath(hex, stroke);
canvas->restore();
xPos += 1.5f * kHexSide;
}
yPos += 2 * kHexSide * kRoot3Over2;
}
return recorder.endRecording();
}
static SkSurface* compat_surface(SkCanvas* canvas, int width, int height) {
SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
SkSurface* surface = canvas->newSurface(info);
if (NULL == surface) {
// picture canvas returns NULL so fall back to raster
surface = SkSurface::NewRaster(info);
}
return surface;
}
// This class stores the information required to compose all the result
// fragments potentially generated by the MultiPictureDraw object
class ComposeStep {
public:
ComposeStep() : fSurf(NULL), fX(0.0f), fY(0.0f), fPaint(NULL) { }
~ComposeStep() { SkSafeUnref(fSurf); SkDELETE(fPaint); }
SkSurface* fSurf;
SkScalar fX;
SkScalar fY;
SkPaint* fPaint;
};
typedef void (*PFContentMtd)(SkCanvas* canvas, const SkPicture* pictures[2]);
// Just a single picture with no clip
static void no_clip(SkCanvas* canvas, const SkPicture* pictures[2]) {
canvas->drawPicture(pictures[0]);
}
// Two pictures with a rect clip on the second one
static void rect_clip(SkCanvas* canvas, const SkPicture* pictures[2]) {
canvas->drawPicture(pictures[0]);
SkRect rect = SkRect::MakeWH(SkIntToScalar(kPicWidth), SkIntToScalar(kPicHeight));
rect.inset(kInset, kInset);
canvas->clipRect(rect);
canvas->drawPicture(pictures[1]);
}
// Two pictures with a round rect clip on the second one
static void rrect_clip(SkCanvas* canvas, const SkPicture* pictures[2]) {
canvas->drawPicture(pictures[0]);
SkRect rect = SkRect::MakeWH(SkIntToScalar(kPicWidth), SkIntToScalar(kPicHeight));
rect.inset(kInset, kInset);
SkRRect rrect;
rrect.setRectXY(rect, kInset, kInset);
canvas->clipRRect(rrect);
canvas->drawPicture(pictures[1]);
}
// Two pictures with a clip path on the second one
static void path_clip(SkCanvas* canvas, const SkPicture* pictures[2]) {
canvas->drawPicture(pictures[0]);
// Create a hexagon centered on the middle of the hex grid
SkPath hex = make_hex_path((kNumHexX / 2.0f) * kHexSide, kNumHexY * kHexSide * kRoot3Over2);
canvas->clipPath(hex);
canvas->drawPicture(pictures[1]);
}
// Two pictures with an inverse clip path on the second one
static void invpath_clip(SkCanvas* canvas, const SkPicture* pictures[2]) {
canvas->drawPicture(pictures[0]);
// Create a hexagon centered on the middle of the hex grid
SkPath hex = make_hex_path((kNumHexX / 2.0f) * kHexSide, kNumHexY * kHexSide * kRoot3Over2);
hex.setFillType(SkPath::kInverseEvenOdd_FillType);
canvas->clipPath(hex);
canvas->drawPicture(pictures[1]);
}
static const PFContentMtd gContentMthds[] = {
no_clip,
rect_clip,
rrect_clip,
path_clip,
invpath_clip
};
static void create_content(SkMultiPictureDraw* mpd, PFContentMtd pfGen,
const SkPicture* pictures[2],
SkCanvas* dest, const SkMatrix& xform) {
SkAutoTUnref<SkPicture> composite;
{
SkPictureRecorder recorder;
SkCanvas* pictureCanvas = recorder.beginRecording(kPicWidth, kPicHeight);
(*pfGen)(pictureCanvas, pictures);
composite.reset(recorder.endRecording());
}
mpd->add(dest, composite, &xform);
}
typedef void(*PFLayoutMtd)(SkCanvas* finalCanvas, SkMultiPictureDraw* mpd,
PFContentMtd pfGen, const SkPicture* pictures[2],
SkTArray<ComposeStep>* composeSteps);
// Draw the content into a single canvas
static void simple(SkCanvas* finalCanvas, SkMultiPictureDraw* mpd,
PFContentMtd pfGen,
const SkPicture* pictures[2],
SkTArray<ComposeStep> *composeSteps) {
ComposeStep& step = composeSteps->push_back();
step.fSurf = SkSafeRef(compat_surface(finalCanvas, kPicWidth, kPicHeight));
SkCanvas* subCanvas = step.fSurf->getCanvas();
create_content(mpd, pfGen, pictures, subCanvas, SkMatrix::I());
}
// Draw the content into multiple canvases/tiles
static void tiled(SkCanvas* finalCanvas, SkMultiPictureDraw* mpd,
PFContentMtd pfGen,
const SkPicture* pictures[2],
SkTArray<ComposeStep> *composeSteps) {
static const int kNumTilesX = 2;
static const int kNumTilesY = 2;
static const int kTileWidth = kPicWidth / kNumTilesX;
static const int kTileHeight = kPicHeight / kNumTilesY;
SkASSERT(kPicWidth == kNumTilesX * kTileWidth);
SkASSERT(kPicHeight == kNumTilesY * kTileHeight);
static const SkColor colors[kNumTilesX][kNumTilesY] = {
{ SK_ColorCYAN, SK_ColorMAGENTA },
{ SK_ColorYELLOW, SK_ColorGREEN }
};
for (int y = 0; y < kNumTilesY; ++y) {
for (int x = 0; x < kNumTilesX; ++x) {
ComposeStep& step = composeSteps->push_back();
step.fX = SkIntToScalar(x*kTileWidth);
step.fY = SkIntToScalar(y*kTileHeight);
step.fPaint = SkNEW(SkPaint);
step.fPaint->setColorFilter(
SkColorFilter::CreateModeFilter(colors[x][y], SkXfermode::kModulate_Mode))->unref();
step.fSurf = SkSafeRef(compat_surface(finalCanvas, kTileWidth, kTileHeight));
SkCanvas* subCanvas = step.fSurf->getCanvas();
SkMatrix trans;
trans.setTranslate(-SkIntToScalar(x*kTileWidth), -SkIntToScalar(y*kTileHeight));
create_content(mpd, pfGen, pictures, subCanvas, trans);
}
}
}
static const PFLayoutMtd gLayoutMthds[] = { simple, tiled };
namespace skiagm {
/**
* This GM exercises the SkMultiPictureDraw object. It tests the
* cross product of:
* tiled vs. all-at-once rendering (e.g., into many or just 1 canvas)
* different clips (e.g., none, rect, rrect)
* single vs. multiple pictures (e.g., normal vs. picture-pile-style content)
*/
class MultiPictureDraw : public GM {
public:
enum Content {
kNoClipSingle_Content,
kRectClipMulti_Content,
kRRectClipMulti_Content,
kPathClipMulti_Content,
kInvPathClipMulti_Content,
kLast_Content = kInvPathClipMulti_Content
};
static const int kContentCnt = kLast_Content + 1;
enum Layout {
kSimple_Layout,
kTiled_Layout,
kLast_Layout = kTiled_Layout
};
static const int kLayoutCnt = kLast_Layout + 1;
MultiPictureDraw(Content content, Layout layout) : fContent(content), fLayout(layout) {
SkASSERT(SK_ARRAY_COUNT(gLayoutMthds) == kLayoutCnt);
SkASSERT(SK_ARRAY_COUNT(gContentMthds) == kContentCnt);
fPictures[0] = fPictures[1] = NULL;
}
virtual ~MultiPictureDraw() {
SkSafeUnref(fPictures[0]);
SkSafeUnref(fPictures[1]);
}
protected:
Content fContent;
Layout fLayout;
const SkPicture* fPictures[2];
virtual void onOnceBeforeDraw() SK_OVERRIDE {
fPictures[0] = SkRef(make_picture(SK_ColorWHITE));
fPictures[1] = SkRef(make_picture(SK_ColorGRAY));
}
virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE{
SkMultiPictureDraw mpd;
SkTArray<ComposeStep> composeSteps;
// Fill up the MultiPictureDraw
(*gLayoutMthds[fLayout])(canvas, &mpd,
gContentMthds[fContent],
fPictures, &composeSteps);
mpd.draw();
// Compose all the drawn canvases into the final canvas
for (int i = 0; i < composeSteps.count(); ++i) {
const ComposeStep& step = composeSteps[i];
SkAutoTUnref<SkImage> image(step.fSurf->newImageSnapshot());
image->draw(canvas, step.fX, step.fY, step.fPaint);
}
}
virtual SkISize onISize() SK_OVERRIDE{ return SkISize::Make(kPicWidth, kPicHeight); }
virtual SkString onShortName() SK_OVERRIDE{
static const char* gContentNames[] = {
"noclip", "rectclip", "rrectclip", "pathclip", "invpathclip"
};
static const char* gLayoutNames[] = { "simple", "tiled" };
SkASSERT(SK_ARRAY_COUNT(gLayoutNames) == kLayoutCnt);
SkASSERT(SK_ARRAY_COUNT(gContentNames) == kContentCnt);
SkString name("multipicturedraw_");
name.append(gContentNames[fContent]);
name.append("_");
name.append(gLayoutNames[fLayout]);
return name;
}
virtual uint32_t onGetFlags() const SK_OVERRIDE { return kAsBench_Flag | kSkipTiled_Flag; }
private:
typedef GM INHERITED;
};
DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kNoClipSingle_Content,
MultiPictureDraw::kSimple_Layout));)
DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRectClipMulti_Content,
MultiPictureDraw::kSimple_Layout));)
DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRRectClipMulti_Content,
MultiPictureDraw::kSimple_Layout));)
DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kPathClipMulti_Content,
MultiPictureDraw::kSimple_Layout));)
DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kInvPathClipMulti_Content,
MultiPictureDraw::kSimple_Layout));)
DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kNoClipSingle_Content,
MultiPictureDraw::kTiled_Layout));)
DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRectClipMulti_Content,
MultiPictureDraw::kTiled_Layout));)
DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRRectClipMulti_Content,
MultiPictureDraw::kTiled_Layout));)
DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kPathClipMulti_Content,
MultiPictureDraw::kTiled_Layout));)
DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kInvPathClipMulti_Content,
MultiPictureDraw::kTiled_Layout));)
}

2
gyp/core.gypi
View File

@ -116,6 +116,7 @@
'<(skia_src_path)/core/SkMessageBus.h',
'<(skia_src_path)/core/SkMetaData.cpp',
'<(skia_src_path)/core/SkMipMap.cpp',
'<(skia_src_path)/core/SkMultiPictureDraw.cpp',
'<(skia_src_path)/core/SkPackBits.cpp',
'<(skia_src_path)/core/SkPaint.cpp',
'<(skia_src_path)/core/SkPaintPriv.cpp',
@ -275,6 +276,7 @@
'<(skia_include_path)/core/SkMath.h',
'<(skia_include_path)/core/SkMatrix.h',
'<(skia_include_path)/core/SkMetaData.h',
'<(skia_include_path)/core/SkMultiPictureDraw.h',
'<(skia_include_path)/core/SkOnce.h',
'<(skia_include_path)/core/SkOSFile.h',
'<(skia_include_path)/core/SkPackBits.h',

1
gyp/gmslides.gypi
View File

@ -120,6 +120,7 @@
'../gm/mixedxfermodes.cpp',
'../gm/modecolorfilters.cpp',
'../gm/morphology.cpp',
'../gm/multipicturedraw.cpp',
'../gm/nested.cpp',
'../gm/ninepatchstretch.cpp',
'../gm/nonclosedpaths.cpp',

68
include/core/SkMultiPictureDraw.h Normal file
View File

@ -0,0 +1,68 @@
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkMultiPictureDraw_DEFINED
#define SkMultiPictureDraw_DEFINED
#include "SkMatrix.h"
#include "SkTDArray.h"
class SkCanvas;
class SkPaint;
class SkPicture;
/** \class SkMultiPictureDraw
The MultiPictureDraw object accepts several picture/canvas pairs and
then attempts to optimally draw the pictures into the canvases, sharing
as many resources as possible.
*/
class SK_API SkMultiPictureDraw {
public:
/**
* Create an object to optimize the drawing of multiple pictures.
* @param reserve Hint for the number of add calls expected to be issued
*/
SkMultiPictureDraw(int reserve = 0);
~SkMultiPictureDraw() { this->reset(); }
/**
* Add a canvas/picture pair for later rendering.
* @param canvas the canvas in which to draw picture
* @param picture the picture to draw into canvas
* @param matrix if non-NULL, applied to the CTM when drawing
* @param paint if non-NULL, draw picture to a temporary buffer
* and then apply the paint when the result is drawn
*/
void add(SkCanvas* canvas,
const SkPicture* picture,
const SkMatrix* matrix = NULL,
const SkPaint* paint = NULL);
/**
* Perform all the previously added draws. This will reset the state
* of this object.
*/
void draw();
/**
* Abandon all buffered draws and reset to the initial state.
*/
void reset();
private:
struct DrawData {
SkCanvas* canvas; // reffed
const SkPicture* picture; // reffed
SkMatrix matrix;
SkPaint* paint; // owned
};
SkTDArray<DrawData> fDrawData;
};
#endif

62
src/core/SkMultiPictureDraw.cpp Normal file
View File

@ -0,0 +1,62 @@
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkCanvas.h"
#include "SkMultiPictureDraw.h"
#include "SkPicture.h"
SkMultiPictureDraw::SkMultiPictureDraw(int reserve) {
if (reserve > 0) {
fDrawData.setReserve(reserve);
}
}
void SkMultiPictureDraw::reset() {
for (int i = 0; i < fDrawData.count(); ++i) {
fDrawData[i].picture->unref();
fDrawData[i].canvas->unref();
SkDELETE(fDrawData[i].paint);
}
fDrawData.rewind();
}
void SkMultiPictureDraw::add(SkCanvas* canvas,
const SkPicture* picture,
const SkMatrix* matrix,
const SkPaint* paint) {
if (NULL == canvas || NULL == picture) {
SkDEBUGFAIL("parameters to SkMultiPictureDraw::add should be non-NULL");
return;
}
DrawData* data = fDrawData.append();
data->picture = SkRef(picture);
data->canvas = SkRef(canvas);
if (NULL != matrix) {
data->matrix = *matrix;
} else {
data->matrix.setIdentity();
}
if (NULL != paint) {
data->paint = SkNEW_ARGS(SkPaint, (*paint));
} else {
data->paint = NULL;
}
}
void SkMultiPictureDraw::draw() {
for (int i = 0; i < fDrawData.count(); ++i) {
fDrawData[i].canvas->drawPicture(fDrawData[i].picture,
&fDrawData[i].matrix,
fDrawData[i].paint);
}
this->reset();
}