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

Move SkRecordComputeLayers and CollectLayers into SkRecordDraw.cpp

Browse Source 
Rather then exposing parts of FillBounds (as in Expose FillBounds to allow GrPictureUtils::CollectLayers to be layered on top of it - https://codereview.chromium.org/698643002/), this CL moves CollectLayers into SkRecordDraw.cpp to accomplish the layering.

Review URL: https://codereview.chromium.org/716913003
This commit is contained in:
robertphillips 2014-11-12 06:46:08 -08:00 committed by Commit bot
parent b103d0c64a
commit 4e8e3421aa
6 changed files with 246 additions and 627 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/core/SkPicture.h
View File

@ -20,8 +20,6 @@
class GrContext;
#endif
class GrAccelData;
class GrReplacements;
class SkBBoxHierarchy;
class SkCanvas;
class SkData;
@ -283,7 +281,6 @@ private:
friend class GrLayerHoister; // access to fRecord
friend class SkPicturePlayback; // to get fData
friend class ReplaceDraw;
friend const GrAccelData* GPUOptimize(const SkPicture* pict);
typedef SkRefCnt INHERITED;

268
src/core/SkRecordDraw.cpp
View File

@ -8,6 +8,10 @@
#include "SkRecordDraw.h"
#include "SkPatchUtils.h"
#if SK_SUPPORT_GPU
#include "GrPictureUtils.h"
#endif
void SkRecordDraw(const SkRecord& record,
SkCanvas* canvas,
const SkBBoxHierarchy* bbh,
@ -142,17 +146,19 @@ DRAW(DrawData, drawData(r.data, r.length));
// in for all the control ops we stashed away.
class FillBounds : SkNoncopyable {
public:
FillBounds(const SkRect& cullRect, const SkRecord& record, SkBBoxHierarchy* bbh)
: fCullRect(cullRect)
FillBounds(const SkRect& cullRect, const SkRecord& record)
: fNumRecords(record.count())
, fCullRect(cullRect)
, fBounds(record.count()) {
// Calculate bounds for all ops. This won't go quite in order, so we'll need
// to store the bounds separately then feed them in to the BBH later in order.
fCTM = &SkMatrix::I();
fCurrentClipBounds = fCullRect;
for (fCurrentOp = 0; fCurrentOp < record.count(); fCurrentOp++) {
record.visit<void>(fCurrentOp, *this);
}
}
void setCurrentOp(unsigned currentOp) { fCurrentOp = currentOp; }
void cleanUp(SkBBoxHierarchy* bbh) {
// If we have any lingering unpaired Saves, simulate restores to make
// sure all ops in those Save blocks have their bounds calculated.
while (!fSaveStack.isEmpty()) {
@ -166,7 +172,7 @@ public:
// Finally feed all stored bounds into the BBH. They'll be returned in this order.
SkASSERT(bbh);
bbh->insert(&fBounds, record.count());
bbh->insert(&fBounds, fNumRecords);
}
template <typename T> void operator()(const T& op) {
@ -175,10 +181,41 @@ public:
this->trackBounds(op);
}
private:
// In this file, SkRect are in local coordinates, Bounds are translated back to identity space.
typedef SkRect Bounds;
unsigned currentOp() const { return fCurrentOp; }
const SkMatrix& ctm() const { return *fCTM; }
const Bounds& currentClipBounds() const { return fCurrentClipBounds; }
const Bounds& getBounds(unsigned index) const { return fBounds[index]; }
// Adjust rect for all paints that may affect its geometry, then map it to identity space.
Bounds adjustAndMap(SkRect rect, const SkPaint* paint) const {
// Inverted rectangles really confuse our BBHs.
rect.sort();
// Adjust the rect for its own paint.
if (!AdjustForPaint(paint, &rect)) {
// The paint could do anything to our bounds. The only safe answer is the current clip.
return fCurrentClipBounds;
}
// Adjust rect for all the paints from the SaveLayers we're inside.
if (!this->adjustForSaveLayerPaints(&rect)) {
// Same deal as above.
return fCurrentClipBounds;
}
// Map the rect back to identity space.
fCTM->mapRect(&rect);
// Nothing can draw outside the current clip.
// (Only bounded ops call into this method, so oddballs like Clear don't matter here.)
rect.intersect(fCurrentClipBounds);
return rect;
}
private:
struct SaveBounds {
int controlOps; // Number of control ops in this Save block, including the Save.
Bounds bounds; // Bounds of everything in the block.
@ -514,31 +551,7 @@ private:
return true;
}
// Adjust rect for all paints that may affect its geometry, then map it to identity space.
Bounds adjustAndMap(SkRect rect, const SkPaint* paint) const {
// Inverted rectangles really confuse our BBHs.
rect.sort();
// Adjust the rect for its own paint.
if (!AdjustForPaint(paint, &rect)) {
// The paint could do anything to our bounds. The only safe answer is the current clip.
return fCurrentClipBounds;
}
// Adjust rect for all the paints from the SaveLayers we're inside.
if (!this->adjustForSaveLayerPaints(&rect)) {
// Same deal as above.
return fCurrentClipBounds;
}
// Map the rect back to identity space.
fCTM->mapRect(&rect);
// Nothing can draw outside the current clip.
// (Only bounded ops call into this method, so oddballs like Clear don't matter here.)
rect.intersect(fCurrentClipBounds);
return rect;
}
const unsigned fNumRecords;
// We do not guarantee anything for operations outside of the cull rect
const SkRect fCullRect;
@ -558,8 +571,197 @@ private:
SkTDArray<unsigned> fControlIndices;
};
#if SK_SUPPORT_GPU
// SkRecord visitor to gather saveLayer/restore information.
class CollectLayers : SkNoncopyable {
public:
CollectLayers(const SkRect& cullRect, const SkRecord& record, GrAccelData* accelData)
: fSaveLayersInStack(0)
, fAccelData(accelData)
, fFillBounds(cullRect, record) {
}
void setCurrentOp(unsigned currentOp) { fFillBounds.setCurrentOp(currentOp); }
void cleanUp(SkBBoxHierarchy* bbh) {
// fFillBounds must perform its cleanUp first so that all the bounding
// boxes associated with unbalanced restores are updated (prior to
// fetching their bound in popSaveLayerInfo).
fFillBounds.cleanUp(bbh);
while (!fSaveLayerStack.isEmpty()) {
this->popSaveLayerInfo();
}
}
template <typename T> void operator()(const T& op) {
fFillBounds(op);
this->trackSaveLayers(op);
}
private:
struct SaveLayerInfo {
SaveLayerInfo() { }
SaveLayerInfo(int opIndex, bool isSaveLayer, const SkPaint* paint,
const FillBounds::Bounds& clipBound)
: fStartIndex(opIndex)
, fIsSaveLayer(isSaveLayer)
, fHasNestedSaveLayer(false)
, fPaint(paint)
, fClipBound(clipBound) {
}
int fStartIndex;
bool fIsSaveLayer;
bool fHasNestedSaveLayer;
const SkPaint* fPaint;
FillBounds::Bounds fClipBound;
};
template <typename T> void trackSaveLayers(const T& op) {
/* most ops aren't involved in saveLayers */
}
void trackSaveLayers(const Save& s) { this->pushSaveLayerInfo(false, NULL); }
void trackSaveLayers(const SaveLayer& sl) { this->pushSaveLayerInfo(true, sl.paint); }
void trackSaveLayers(const Restore& r) { this->popSaveLayerInfo(); }
void trackSaveLayers(const DrawPicture& dp) {
// For sub-pictures, we wrap their layer information within the parent
// picture's rendering hierarchy
SkPicture::AccelData::Key key = GrAccelData::ComputeAccelDataKey();
const GrAccelData* childData =
static_cast<const GrAccelData*>(dp.picture->EXPERIMENTAL_getAccelData(key));
if (!childData) {
// If the child layer hasn't been generated with saveLayer data we
// assume the worst (i.e., that it does contain layers which nest
// inside existing layers). Layers within sub-pictures that don't
// have saveLayer data cannot be hoisted.
// TODO: could the analysis data be use to fine tune this?
this->updateStackForSaveLayer();
return;
}
for (int i = 0; i < childData->numSaveLayers(); ++i) {
const GrAccelData::SaveLayerInfo& src = childData->saveLayerInfo(i);
FillBounds::Bounds newClip(fFillBounds.currentClipBounds());
if (!newClip.intersect(fFillBounds.adjustAndMap(src.fBounds, dp.paint))) {
continue;
}
this->updateStackForSaveLayer();
GrAccelData::SaveLayerInfo& dst = fAccelData->addSaveLayerInfo();
// If src.fPicture is NULL the layer is in dp.picture; otherwise
// it belongs to a sub-picture.
dst.fPicture = src.fPicture ? src.fPicture : static_cast<const SkPicture*>(dp.picture);
dst.fPicture->ref();
dst.fBounds = newClip;
dst.fLocalMat = src.fLocalMat;
dst.fPreMat = src.fPreMat;
dst.fPreMat.postConcat(fFillBounds.ctm());
if (src.fPaint) {
dst.fPaint = SkNEW_ARGS(SkPaint, (*src.fPaint));
}
dst.fSaveLayerOpID = src.fSaveLayerOpID;
dst.fRestoreOpID = src.fRestoreOpID;
dst.fHasNestedLayers = src.fHasNestedLayers;
dst.fIsNested = fSaveLayersInStack > 0 || src.fIsNested;
}
}
// Inform all the saveLayers already on the stack that they now have a
// nested saveLayer inside them
void updateStackForSaveLayer() {
for (int index = fSaveLayerStack.count() - 1; index >= 0; --index) {
if (fSaveLayerStack[index].fHasNestedSaveLayer) {
break;
}
fSaveLayerStack[index].fHasNestedSaveLayer = true;
if (fSaveLayerStack[index].fIsSaveLayer) {
break;
}
}
}
void pushSaveLayerInfo(bool isSaveLayer, const SkPaint* paint) {
if (isSaveLayer) {
this->updateStackForSaveLayer();
++fSaveLayersInStack;
}
fSaveLayerStack.push(SaveLayerInfo(fFillBounds.currentOp(), isSaveLayer, paint,
fFillBounds.currentClipBounds()));
}
void popSaveLayerInfo() {
if (fSaveLayerStack.count() <= 0) {
SkASSERT(false);
return;
}
SaveLayerInfo sli;
fSaveLayerStack.pop(&sli);
if (!sli.fIsSaveLayer) {
return;
}
--fSaveLayersInStack;
GrAccelData::SaveLayerInfo& slInfo = fAccelData->addSaveLayerInfo();
SkASSERT(NULL == slInfo.fPicture); // This layer is in the top-most picture
slInfo.fBounds = fFillBounds.getBounds(sli.fStartIndex);
slInfo.fBounds.intersect(sli.fClipBound);
slInfo.fLocalMat = fFillBounds.ctm();
slInfo.fPreMat = SkMatrix::I();
if (sli.fPaint) {
slInfo.fPaint = SkNEW_ARGS(SkPaint, (*sli.fPaint));
}
slInfo.fSaveLayerOpID = sli.fStartIndex;
slInfo.fRestoreOpID = fFillBounds.currentOp();
slInfo.fHasNestedLayers = sli.fHasNestedSaveLayer;
slInfo.fIsNested = fSaveLayersInStack > 0;
}
// Used to collect saveLayer information for layer hoisting
int fSaveLayersInStack;
SkTDArray<SaveLayerInfo> fSaveLayerStack;
GrAccelData* fAccelData;
SkRecords::FillBounds fFillBounds;
};
#endif
} // namespace SkRecords
void SkRecordFillBounds(const SkRect& cullRect, const SkRecord& record, SkBBoxHierarchy* bbh) {
SkRecords::FillBounds(cullRect, record, bbh);
SkRecords::FillBounds visitor(cullRect, record);
for (unsigned curOp = 0; curOp < record.count(); curOp++) {
visitor.setCurrentOp(curOp);
record.visit<void>(curOp, visitor);
}
visitor.cleanUp(bbh);
}
#if SK_SUPPORT_GPU
void SkRecordComputeLayers(const SkRect& cullRect, const SkRecord& record,
SkBBoxHierarchy* bbh, GrAccelData* data) {
SkRecords::CollectLayers visitor(cullRect, record, data);
for (unsigned curOp = 0; curOp < record.count(); curOp++) {
visitor.setCurrentOp(curOp);
record.visit<void>(curOp, visitor);
}
visitor.cleanUp(bbh);
}
#endif

7
src/core/SkRecordDraw.h
View File

@ -17,6 +17,13 @@
// Fill a BBH to be used by SkRecordDraw to accelerate playback.
void SkRecordFillBounds(const SkRect& cullRect, const SkRecord&, SkBBoxHierarchy*);
#if SK_SUPPORT_GPU
class GrAccelData;
void SkRecordComputeLayers(const SkRect& cullRect, const SkRecord& record,
SkBBoxHierarchy* bbh, GrAccelData* data);
#endif
// Draw an SkRecord into an SkCanvas. A convenience wrapper around SkRecords::Draw.
void SkRecordDraw(const SkRecord&, SkCanvas*, const SkBBoxHierarchy*, SkDrawPictureCallback*);

585
src/gpu/GrPictureUtils.cpp
View File

@ -19,588 +19,3 @@ SkPicture::AccelData::Key GrAccelData::ComputeAccelDataKey() {
return gGPUID;
}
// This looks silly, I know. Why not just use SkRect::MakeLargest()?
// In practice, this is well large enough, and it has a few extra advantages:
// it fits in an SkIRect, and we can munge it a little in both SkRect and
// SKIRect space without worrying about overflow.
static const SkRect kUnbounded = { -2e9f, -2e9f, 2e9f, 2e9f };
namespace SkRecords {
// SkRecord visitor to gather saveLayer/restore information.
class CollectLayers : SkNoncopyable {
public:
CollectLayers(const SkRect& cullRect, const SkRecord& record,
SkBBoxHierarchy* bbh, GrAccelData* accelData)
: fSaveLayersInStack(0)
, fAccelData(accelData) {
// Calculate bounds for all ops. This won't go quite in order, so we'll need
// to store the bounds separately then feed them in to the BBH later in order.
fCTM = &SkMatrix::I();
fCurrentClipBounds = kUnbounded;
fBounds.reset(record.count());
for (fCurrentOp = 0; fCurrentOp < record.count(); ++fCurrentOp) {
record.visit<void>(fCurrentOp, *this);
}
// If we have any lingering unpaired Saves, simulate restores to make
// sure all ops in those Save blocks have their bounds calculated.
while (!fSaveStack.isEmpty()) {
this->popSaveBlock();
}
// Any control ops not part of any Save/Restore block draw everywhere.
while (!fControlIndices.isEmpty()) {
this->popControl(kUnbounded);
}
//--------- LAYER HOISTING
while (!fSaveLayerStack.isEmpty()) {
this->popSaveLayerInfo();
}
//--------- LAYER HOISTING
// Finally feed all stored bounds into the BBH. They'll be returned in this order.
SkASSERT(bbh);
bbh->insert(&fBounds, record.count());
}
template <typename T> void operator()(const T& op) {
this->updateCTM(op);
this->updateClipBounds(op);
this->trackBounds(op);
//--------- LAYER HOISTING
this->trackSaveLayers(op);
//--------- LAYER HOISTING
}
private:
// In this file, SkRect are in local coordinates, Bounds are translated back to identity space.
typedef SkRect Bounds;
struct SaveBounds {
int controlOps; // Number of control ops in this Save block, including the Save.
Bounds bounds; // Bounds of everything in the block.
const SkPaint* paint; // Unowned. If set, adjusts the bounds of all ops in this block.
};
//--------- LAYER HOISTING
class SaveLayerInfo {
public:
SaveLayerInfo() { }
SaveLayerInfo(int opIndex, bool isSaveLayer, const SkPaint* paint, const Bounds& clipBound)
: fStartIndex(opIndex)
, fIsSaveLayer(isSaveLayer)
, fHasNestedSaveLayer(false)
, fPaint(paint)
, fClipBound(clipBound) {
}
int fStartIndex;
bool fIsSaveLayer;
bool fHasNestedSaveLayer;
const SkPaint* fPaint;
Bounds fClipBound;
};
//--------- LAYER HOISTING
// Only Restore and SetMatrix change the CTM.
template <typename T> void updateCTM(const T&) {}
void updateCTM(const Restore& op) { fCTM = &op.matrix; }
void updateCTM(const SetMatrix& op) { fCTM = &op.matrix; }
// Most ops don't change the clip.
template <typename T> void updateClipBounds(const T&) {}
// Clip{Path,RRect,Rect,Region} obviously change the clip. They all know their bounds already.
void updateClipBounds(const ClipPath& op) { this->updateClipBoundsForClipOp(op.devBounds); }
void updateClipBounds(const ClipRRect& op) { this->updateClipBoundsForClipOp(op.devBounds); }
void updateClipBounds(const ClipRect& op) { this->updateClipBoundsForClipOp(op.devBounds); }
void updateClipBounds(const ClipRegion& op) { this->updateClipBoundsForClipOp(op.devBounds); }
// The bounds of clip ops need to be adjusted for the paints of saveLayers they're inside.
void updateClipBoundsForClipOp(const SkIRect& devBounds) {
Bounds clip = SkRect::Make(devBounds);
// We don't call adjustAndMap() because as its last step it would intersect the adjusted
// clip bounds with the previous clip, exactly what we can't do when the clip grows.
fCurrentClipBounds = this->adjustForSaveLayerPaints(&clip) ? clip : kUnbounded;
}
// Restore holds the devBounds for the clip after the {save,saveLayer}/restore block completes.
void updateClipBounds(const Restore& op) {
// This is just like the clip ops above, but we need to skip the effects (if any) of our
// paired saveLayer (if it is one); it has not yet been popped off the save stack. Our
// devBounds reflect the state of the world after the saveLayer/restore block is done,
// so they are not affected by the saveLayer's paint.
const int kSavesToIgnore = 1;
Bounds clip = SkRect::Make(op.devBounds);
fCurrentClipBounds =
this->adjustForSaveLayerPaints(&clip, kSavesToIgnore) ? clip : kUnbounded;
}
// We also take advantage of SaveLayer bounds when present to further cut the clip down.
void updateClipBounds(const SaveLayer& op) {
if (op.bounds) {
// adjustAndMap() intersects these layer bounds with the previous clip for us.
fCurrentClipBounds = this->adjustAndMap(*op.bounds, op.paint);
}
}
// The bounds of these ops must be calculated when we hit the Restore
// from the bounds of the ops in the same Save block.
void trackBounds(const Save&) { this->pushSaveBlock(NULL); }
void trackBounds(const SaveLayer& op) { this->pushSaveBlock(op.paint); }
void trackBounds(const Restore&) { fBounds[fCurrentOp] = this->popSaveBlock(); }
void trackBounds(const SetMatrix&) { this->pushControl(); }
void trackBounds(const ClipRect&) { this->pushControl(); }
void trackBounds(const ClipRRect&) { this->pushControl(); }
void trackBounds(const ClipPath&) { this->pushControl(); }
void trackBounds(const ClipRegion&) { this->pushControl(); }
void trackBounds(const PushCull&) { this->pushControl(); }
void trackBounds(const PopCull&) { this->pushControl(); }
void trackBounds(const BeginCommentGroup&) { this->pushControl(); }
void trackBounds(const AddComment&) { this->pushControl(); }
void trackBounds(const EndCommentGroup&) { this->pushControl(); }
void trackBounds(const DrawData&) { this->pushControl(); }
// For all other ops, we can calculate and store the bounds directly now.
template <typename T> void trackBounds(const T& op) {
fBounds[fCurrentOp] = this->bounds(op);
this->updateSaveBounds(fBounds[fCurrentOp]);
}
void pushSaveBlock(const SkPaint* paint) {
// Starting a new Save block. Push a new entry to represent that.
SaveBounds sb = { 0, Bounds::MakeEmpty(), paint };
fSaveStack.push(sb);
this->pushControl();
}
static bool PaintMayAffectTransparentBlack(const SkPaint* paint) {
if (paint) {
// FIXME: this is very conservative
if (paint->getImageFilter() || paint->getColorFilter()) {
return true;
}
// Unusual Xfermodes require us to process a saved layer
// even with operations outisde the clip.
// For example, DstIn is used by masking layers.
// https://code.google.com/p/skia/issues/detail?id=1291
// https://crbug.com/401593
SkXfermode* xfermode = paint->getXfermode();
SkXfermode::Mode mode;
// SrcOver is ok, and is also the common case with a NULL xfermode.
// So we should make that the fast path and bypass the mode extraction
// and test.
if (xfermode && xfermode->asMode(&mode)) {
switch (mode) {
// For each of the following transfer modes, if the source
// alpha is zero (our transparent black), the resulting
// blended alpha is not necessarily equal to the original
// destination alpha.
case SkXfermode::kClear_Mode:
case SkXfermode::kSrc_Mode:
case SkXfermode::kSrcIn_Mode:
case SkXfermode::kDstIn_Mode:
case SkXfermode::kSrcOut_Mode:
case SkXfermode::kDstATop_Mode:
case SkXfermode::kModulate_Mode:
return true;
break;
default:
break;
}
}
}
return false;
}
Bounds popSaveBlock() {
// We're done the Save block. Apply the block's bounds to all control ops inside it.
SaveBounds sb;
fSaveStack.pop(&sb);
// If the paint affects transparent black, we can't trust any of our calculated bounds.
const Bounds& bounds =
PaintMayAffectTransparentBlack(sb.paint) ? fCurrentClipBounds : sb.bounds;
while (sb.controlOps-- > 0) {
this->popControl(bounds);
}
// This whole Save block may be part another Save block.
this->updateSaveBounds(bounds);
// If called from a real Restore (not a phony one for balance), it'll need the bounds.
return bounds;
}
void pushControl() {
fControlIndices.push(fCurrentOp);
if (!fSaveStack.isEmpty()) {
fSaveStack.top().controlOps++;
}
}
void popControl(const Bounds& bounds) {
fBounds[fControlIndices.top()] = bounds;
fControlIndices.pop();
}
void updateSaveBounds(const Bounds& bounds) {
// If we're in a Save block, expand its bounds to cover these bounds too.
if (!fSaveStack.isEmpty()) {
fSaveStack.top().bounds.join(bounds);
}
}
// FIXME: this method could use better bounds
Bounds bounds(const DrawText&) const { return fCurrentClipBounds; }
Bounds bounds(const Clear&) const { return kUnbounded; } // Ignores the clip.
Bounds bounds(const DrawPaint&) const { return fCurrentClipBounds; }
Bounds bounds(const NoOp&) const { return Bounds::MakeEmpty(); } // NoOps don't draw.
Bounds bounds(const DrawSprite& op) const {
const SkBitmap& bm = op.bitmap;
return Bounds::Make(SkIRect::MakeXYWH(op.left, op.top, bm.width(), bm.height())); // Ignores the matrix.
}
Bounds bounds(const DrawRect& op) const { return this->adjustAndMap(op.rect, &op.paint); }
Bounds bounds(const DrawOval& op) const { return this->adjustAndMap(op.oval, &op.paint); }
Bounds bounds(const DrawRRect& op) const {
return this->adjustAndMap(op.rrect.rect(), &op.paint);
}
Bounds bounds(const DrawDRRect& op) const {
return this->adjustAndMap(op.outer.rect(), &op.paint);
}
Bounds bounds(const DrawImage& op) const {
const SkImage* image = op.image;
SkRect rect = SkRect::MakeXYWH(op.left, op.top,
SkIntToScalar(image->width()), SkIntToScalar(image->height()));
return this->adjustAndMap(rect, op.paint);
}
Bounds bounds(const DrawImageRect& op) const {
return this->adjustAndMap(op.dst, op.paint);
}
Bounds bounds(const DrawBitmapRectToRect& op) const {
return this->adjustAndMap(op.dst, op.paint);
}
Bounds bounds(const DrawBitmapNine& op) const {
return this->adjustAndMap(op.dst, op.paint);
}
Bounds bounds(const DrawBitmap& op) const {
const SkBitmap& bm = op.bitmap;
return this->adjustAndMap(SkRect::MakeXYWH(op.left, op.top, SkIntToScalar(bm.width()), SkIntToScalar(bm.height())),
op.paint);
}
Bounds bounds(const DrawBitmapMatrix& op) const {
const SkBitmap& bm = op.bitmap;
SkRect dst = SkRect::Make(SkIRect::MakeWH(bm.width(), bm.height()));
op.matrix.mapRect(&dst);
return this->adjustAndMap(dst, op.paint);
}
Bounds bounds(const DrawPath& op) const {
return op.path.isInverseFillType() ? fCurrentClipBounds
: this->adjustAndMap(op.path.getBounds(), &op.paint);
}
Bounds bounds(const DrawPoints& op) const {
SkRect dst;
dst.set(op.pts, op.count);
// Pad the bounding box a little to make sure hairline points' bounds aren't empty.
SkScalar stroke = SkMaxScalar(op.paint.getStrokeWidth(), 0.01f);
dst.outset(stroke / 2, stroke / 2);
return this->adjustAndMap(dst, &op.paint);
}
Bounds bounds(const DrawPatch& op) const {
SkRect dst;
dst.set(op.cubics, SkPatchUtils::kNumCtrlPts);
return this->adjustAndMap(dst, &op.paint);
}
Bounds bounds(const DrawVertices& op) const {
SkRect dst;
dst.set(op.vertices, op.vertexCount);
return this->adjustAndMap(dst, &op.paint);
}
Bounds bounds(const DrawPicture& op) const {
SkRect dst = op.picture->cullRect();
if (op.matrix) {
op.matrix->mapRect(&dst);
}
return this->adjustAndMap(dst, op.paint);
}
Bounds bounds(const DrawPosText& op) const {
const int N = op.paint.countText(op.text, op.byteLength);
if (N == 0) {
return Bounds::MakeEmpty();
}
SkRect dst;
dst.set(op.pos, N);
AdjustTextForFontMetrics(&dst, op.paint);
return this->adjustAndMap(dst, &op.paint);
}
Bounds bounds(const DrawPosTextH& op) const {
const int N = op.paint.countText(op.text, op.byteLength);
if (N == 0) {
return Bounds::MakeEmpty();
}
SkScalar left = op.xpos[0], right = op.xpos[0];
for (int i = 1; i < N; i++) {
left = SkMinScalar(left, op.xpos[i]);
right = SkMaxScalar(right, op.xpos[i]);
}
SkRect dst = { left, op.y, right, op.y };
AdjustTextForFontMetrics(&dst, op.paint);
return this->adjustAndMap(dst, &op.paint);
}
Bounds bounds(const DrawTextOnPath& op) const {
SkRect dst = op.path.getBounds();
// Pad all sides by the maximum padding in any direction we'd normally apply.
SkRect pad = { 0, 0, 0, 0 };
AdjustTextForFontMetrics(&pad, op.paint);
// That maximum padding happens to always be the right pad today.
SkASSERT(pad.fLeft == -pad.fRight);
SkASSERT(pad.fTop == -pad.fBottom);
SkASSERT(pad.fRight > pad.fBottom);
dst.outset(pad.fRight, pad.fRight);
return this->adjustAndMap(dst, &op.paint);
}
Bounds bounds(const DrawTextBlob& op) const {
SkRect dst = op.blob->bounds();
dst.offset(op.x, op.y);
return this->adjustAndMap(dst, &op.paint);
}
static void AdjustTextForFontMetrics(SkRect* rect, const SkPaint& paint) {
#ifdef SK_DEBUG
SkRect correct = *rect;
#endif
// crbug.com/373785 ~~> xPad = 4x yPad
// crbug.com/424824 ~~> bump yPad from 2x text size to 2.5x
const SkScalar yPad = 2.5f * paint.getTextSize(),
xPad = 4.0f * yPad;
rect->outset(xPad, yPad);
#ifdef SK_DEBUG
SkPaint::FontMetrics metrics;
paint.getFontMetrics(&metrics);
correct.fLeft += metrics.fXMin;
correct.fTop += metrics.fTop;
correct.fRight += metrics.fXMax;
correct.fBottom += metrics.fBottom;
// See skia:2862 for why we ignore small text sizes.
SkASSERTF(paint.getTextSize() < 0.001f || rect->contains(correct),
"%f %f %f %f vs. %f %f %f %f\n",
-xPad, -yPad, +xPad, +yPad,
metrics.fXMin, metrics.fTop, metrics.fXMax, metrics.fBottom);
#endif
}
//--------- LAYER HOISTING
template <typename T> void trackSaveLayers(const T& op) {
/* most ops aren't involved in saveLayers */
}
void trackSaveLayers(const Save& s) { this->pushSaveLayerInfo(false, NULL); }
void trackSaveLayers(const SaveLayer& sl) {
this->pushSaveLayerInfo(true, sl.paint);
}
void trackSaveLayers(const Restore& r) { this->popSaveLayerInfo(); }
void trackSaveLayers(const DrawPicture& dp) {
// For sub-pictures, we wrap their layer information within the parent
// picture's rendering hierarchy
SkPicture::AccelData::Key key = GrAccelData::ComputeAccelDataKey();
const GrAccelData* childData =
static_cast<const GrAccelData*>(dp.picture->EXPERIMENTAL_getAccelData(key));
if (!childData) {
// If the child layer hasn't been generated with saveLayer data we
// assume the worst (i.e., that it does contain layers which nest
// inside existing layers). Layers within sub-pictures that don't
// have saveLayer data cannot be hoisted.
// TODO: could the analysis data be use to fine tune this?
this->updateStackForSaveLayer();
return;
}
for (int i = 0; i < childData->numSaveLayers(); ++i) {
const GrAccelData::SaveLayerInfo& src = childData->saveLayerInfo(i);
Bounds newClip(fCurrentClipBounds);
if (!newClip.intersect(this->adjustAndMap(src.fBounds, dp.paint))) {
continue;
}
this->updateStackForSaveLayer();
GrAccelData::SaveLayerInfo& dst = fAccelData->addSaveLayerInfo();
// If src.fPicture is NULL the layer is in dp.picture; otherwise
// it belongs to a sub-picture.
dst.fPicture = src.fPicture ? src.fPicture : static_cast<const SkPicture*>(dp.picture);
dst.fPicture->ref();
dst.fBounds = newClip;
dst.fLocalMat = src.fLocalMat;
dst.fPreMat = src.fPreMat;
dst.fPreMat.postConcat(*fCTM);
if (src.fPaint) {
dst.fPaint = SkNEW_ARGS(SkPaint, (*src.fPaint));
}
dst.fSaveLayerOpID = src.fSaveLayerOpID;
dst.fRestoreOpID = src.fRestoreOpID;
dst.fHasNestedLayers = src.fHasNestedLayers;
dst.fIsNested = fSaveLayersInStack > 0 || src.fIsNested;
}
}
// Inform all the saveLayers already on the stack that they now have a
// nested saveLayer inside them
void updateStackForSaveLayer() {
for (int index = fSaveLayerStack.count() - 1; index >= 0; --index) {
if (fSaveLayerStack[index].fHasNestedSaveLayer) {
break;
}
fSaveLayerStack[index].fHasNestedSaveLayer = true;
if (fSaveLayerStack[index].fIsSaveLayer) {
break;
}
}
}
void pushSaveLayerInfo(bool isSaveLayer, const SkPaint* paint) {
if (isSaveLayer) {
this->updateStackForSaveLayer();
++fSaveLayersInStack;
}
fSaveLayerStack.push(SaveLayerInfo(fCurrentOp, isSaveLayer, paint, fCurrentClipBounds));
}
void popSaveLayerInfo() {
if (fSaveLayerStack.count() <= 0) {
SkASSERT(false);
return;
}
SaveLayerInfo sli;
fSaveLayerStack.pop(&sli);
if (!sli.fIsSaveLayer) {
return;
}
--fSaveLayersInStack;
GrAccelData::SaveLayerInfo& slInfo = fAccelData->addSaveLayerInfo();
SkASSERT(NULL == slInfo.fPicture); // This layer is in the top-most picture
slInfo.fBounds = fBounds[sli.fStartIndex];
slInfo.fBounds.intersect(sli.fClipBound);
slInfo.fLocalMat = *fCTM;
slInfo.fPreMat = SkMatrix::I();
if (sli.fPaint) {
slInfo.fPaint = SkNEW_ARGS(SkPaint, (*sli.fPaint));
}
slInfo.fSaveLayerOpID = sli.fStartIndex;
slInfo.fRestoreOpID = fCurrentOp;
slInfo.fHasNestedLayers = sli.fHasNestedSaveLayer;
slInfo.fIsNested = fSaveLayersInStack > 0;
}
//--------- LAYER HOISTING
// Returns true if rect was meaningfully adjusted for the effects of paint,
// false if the paint could affect the rect in unknown ways.
static bool AdjustForPaint(const SkPaint* paint, SkRect* rect) {
if (paint) {
if (paint->canComputeFastBounds()) {
*rect = paint->computeFastBounds(*rect, rect);
return true;
}
return false;
}
return true;
}
bool adjustForSaveLayerPaints(SkRect* rect, int savesToIgnore = 0) const {
for (int i = fSaveStack.count() - 1 - savesToIgnore; i >= 0; i--) {
if (!AdjustForPaint(fSaveStack[i].paint, rect)) {
return false;
}
}
return true;
}
// Adjust rect for all paints that may affect its geometry, then map it to identity space.
Bounds adjustAndMap(SkRect rect, const SkPaint* paint) const {
// Inverted rectangles really confuse our BBHs.
rect.sort();
// Adjust the rect for its own paint.
if (!AdjustForPaint(paint, &rect)) {
// The paint could do anything to our bounds. The only safe answer is the current clip.
return fCurrentClipBounds;
}
// Adjust rect for all the paints from the SaveLayers we're inside.
if (!this->adjustForSaveLayerPaints(&rect)) {
// Same deal as above.
return fCurrentClipBounds;
}
// Map the rect back to identity space.
fCTM->mapRect(&rect);
// Nothing can draw outside the current clip.
// (Only bounded ops call into this method, so oddballs like Clear don't matter here.)
rect.intersect(fCurrentClipBounds);
return rect;
}
// Conservative identity-space bounds for each op in the SkRecord.
SkAutoTMalloc<Bounds> fBounds;
// We walk fCurrentOp through the SkRecord, as we go using updateCTM()
// and updateClipBounds() to maintain the exact CTM (fCTM) and conservative
// identity-space bounds of the current clip (fCurrentClipBounds).
unsigned fCurrentOp;
const SkMatrix* fCTM;
Bounds fCurrentClipBounds;
// Used to track the bounds of Save/Restore blocks and the control ops inside them.
SkTDArray<SaveBounds> fSaveStack;
SkTDArray<unsigned> fControlIndices;
//--------- LAYER HOISTING
// Used to collect saveLayer information for layer hoisting
int fSaveLayersInStack;
SkTDArray<SaveLayerInfo> fSaveLayerStack;
GrAccelData* fAccelData;
//--------- LAYER HOISTING
};
} // namespace SkRecords
void SkRecordComputeLayers(const SkRect& cullRect, const SkRecord& record,
SkBBoxHierarchy* bbh, GrAccelData* data) {
SkRecords::CollectLayers collector(cullRect, record, bbh, data);
}

3
src/gpu/GrPictureUtils.h
View File

@ -76,7 +76,4 @@ private:
typedef SkPicture::AccelData INHERITED;
};
void SkRecordComputeLayers(const SkRect& cullRect, const SkRecord& record,
SkBBoxHierarchy* bbh, GrAccelData* data);
#endif // GrPictureUtils_DEFINED

7
tests/PictureTest.cpp
View File

@ -1018,11 +1018,12 @@ static void test_gpu_picture_optimization(skiatest::Reporter* reporter,
REPORTER_ASSERT(reporter, !info0.fIsNested && !info0.fHasNestedLayers);
REPORTER_ASSERT(reporter, NULL == info1.fPicture);
REPORTER_ASSERT(reporter, kWidth == info1.fBounds.width() &&
kHeight == info1.fBounds.height());
REPORTER_ASSERT(reporter, kWidth/2.0 == info1.fBounds.width() &&
kHeight/2.0 == info1.fBounds.height());
REPORTER_ASSERT(reporter, info1.fLocalMat.isIdentity());
REPORTER_ASSERT(reporter, info1.fPreMat.isIdentity());
REPORTER_ASSERT(reporter, 0 == info1.fBounds.fLeft && 0 == info1.fBounds.fTop);
REPORTER_ASSERT(reporter, kWidth/2.0 == info1.fBounds.fLeft &&
kHeight/2.0 == info1.fBounds.fTop);
REPORTER_ASSERT(reporter, NULL == info1.fPaint);
REPORTER_ASSERT(reporter, !info1.fIsNested &&
info1.fHasNestedLayers); // has a nested SL