diff options
author | mtklein <mtklein@chromium.org> | 2015-05-18 13:47:17 -0700 |
---|---|---|
committer | Commit bot <commit-bot@chromium.org> | 2015-05-18 13:47:17 -0700 |
commit | 15877b6eae33a9282458bdb904a6d00440eca0ec (patch) | |
tree | 9aee7fa5144cc7039eff79fef5a1c82a59b740f3 /src/core/SkPictureCommon.h | |
parent | cfa90a1aaff2ffbb71a8597905607287856601e5 (diff) |
Sketch splitting SkPicture into an interface and SkBigPicture.
Adds small pictures for drawRect(), drawTextBlob(), and drawPath().
These cover about 89% of draw calls from Blink SKPs,
and about 25% of draw calls from our GMs.
SkPicture handles:
- serialization and deserialization
- unique IDs
Everything else is left to the subclasses:
- playback(), cullRect()
- hasBitmap(), hasText(), suitableForGPU(), etc.
- LayerInfo / AccelData if applicable.
The time to record a 1-op picture improves a good chunk
(2 mallocs to 1), and the time to record a 0-op picture
greatly improves (2 mallocs to none):
picture_overhead_draw: 450ns -> 350ns
picture_overhead_nodraw: 300ns -> 90ns
BUG=skia:
Committed: https://skia.googlesource.com/skia/+/c92c129ff85b05a714bd1bf921c02d5e14651f8b
Latest blink_linux_rel:
http://build.chromium.org/p/tryserver.blink/builders/linux_blink_rel/builds/61248
Review URL: https://codereview.chromium.org/1112523006
Diffstat (limited to 'src/core/SkPictureCommon.h')
-rw-r--r-- | src/core/SkPictureCommon.h | 136 |
1 files changed, 136 insertions, 0 deletions
diff --git a/src/core/SkPictureCommon.h b/src/core/SkPictureCommon.h new file mode 100644 index 0000000000..827bf117de --- /dev/null +++ b/src/core/SkPictureCommon.h @@ -0,0 +1,136 @@ +/* + * Copyright 2015 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +// Some shared code used by both SkBigPicture and SkMiniPicture. +// SkTextHunter -- SkRecord visitor that returns true when the op draws text. +// SkBitmapHunter -- SkRecord visitor that returns true when the op draws a bitmap. +// SkPathCounter -- SkRecord visitor that counts paths that draw slowly on the GPU. + +#include "SkPathEffect.h" +#include "SkRecords.h" +#include "SkTLogic.h" + +struct SkTextHunter { + // Most ops never have text. Some always do. Subpictures know themeselves. + template <typename T> bool operator()(const T&) { return false; } + bool operator()(const SkRecords::DrawPosText&) { return true; } + bool operator()(const SkRecords::DrawPosTextH&) { return true; } + bool operator()(const SkRecords::DrawText&) { return true; } + bool operator()(const SkRecords::DrawTextBlob&) { return true; } + bool operator()(const SkRecords::DrawTextOnPath&) { return true; } + bool operator()(const SkRecords::DrawPicture& op) { return op.picture->hasText(); } +}; + + +struct SkBitmapHunter { + // Helpers. These create HasMember_bitmap and HasMember_paint. + SK_CREATE_MEMBER_DETECTOR(bitmap); + SK_CREATE_MEMBER_DETECTOR(paint); + + // Some ops have a paint, some have an optional paint. Either way, get back a pointer. + static const SkPaint* AsPtr(const SkPaint& p) { return &p; } + static const SkPaint* AsPtr(const SkRecords::Optional<SkPaint>& p) { return p; } + + // Main entry for visitor: + // If the op is a DrawPicture, recurse. + // If the op has a bitmap directly, return true. + // If the op has a paint and the paint has a bitmap, return true. + // Otherwise, return false. + bool operator()(const SkRecords::DrawPicture& op) { return op.picture->willPlayBackBitmaps(); } + + template <typename T> + bool operator()(const T& r) { return CheckBitmap(r); } + + // If the op has a bitmap, of course we're going to play back bitmaps. + template <typename T> + static SK_WHEN(HasMember_bitmap<T>, bool) CheckBitmap(const T&) { return true; } + + // If not, look for one in its paint (if it has a paint). + template <typename T> + static SK_WHEN(!HasMember_bitmap<T>, bool) CheckBitmap(const T& r) { return CheckPaint(r); } + + // If we have a paint, dig down into the effects looking for a bitmap. + template <typename T> + static SK_WHEN(HasMember_paint<T>, bool) CheckPaint(const T& r) { + const SkPaint* paint = AsPtr(r.paint); + if (paint) { + const SkShader* shader = paint->getShader(); + if (shader && + shader->asABitmap(nullptr, nullptr, nullptr) == SkShader::kDefault_BitmapType) { + return true; + } + } + return false; + } + + // If we don't have a paint, that non-paint has no bitmap. + template <typename T> + static SK_WHEN(!HasMember_paint<T>, bool) CheckPaint(const T&) { return false; } +}; + +// TODO: might be nicer to have operator() return an int (the number of slow paths) ? +struct SkPathCounter { + SK_CREATE_MEMBER_DETECTOR(paint); + + // Some ops have a paint, some have an optional paint. Either way, get back a pointer. + static const SkPaint* AsPtr(const SkPaint& p) { return &p; } + static const SkPaint* AsPtr(const SkRecords::Optional<SkPaint>& p) { return p; } + + SkPathCounter() : fNumSlowPathsAndDashEffects(0) {} + + // Recurse into nested pictures. + void operator()(const SkRecords::DrawPicture& op) { + fNumSlowPathsAndDashEffects += op.picture->numSlowPaths(); + } + + void checkPaint(const SkPaint* paint) { + if (paint && paint->getPathEffect()) { + // Initially assume it's slow. + fNumSlowPathsAndDashEffects++; + } + } + + void operator()(const SkRecords::DrawPoints& op) { + this->checkPaint(&op.paint); + const SkPathEffect* effect = op.paint.getPathEffect(); + if (effect) { + SkPathEffect::DashInfo info; + SkPathEffect::DashType dashType = effect->asADash(&info); + if (2 == op.count && SkPaint::kRound_Cap != op.paint.getStrokeCap() && + SkPathEffect::kDash_DashType == dashType && 2 == info.fCount) { + fNumSlowPathsAndDashEffects--; + } + } + } + + void operator()(const SkRecords::DrawPath& op) { + this->checkPaint(&op.paint); + if (op.paint.isAntiAlias() && !op.path.isConvex()) { + SkPaint::Style paintStyle = op.paint.getStyle(); + const SkRect& pathBounds = op.path.getBounds(); + if (SkPaint::kStroke_Style == paintStyle && + 0 == op.paint.getStrokeWidth()) { + // AA hairline concave path is not slow. + } else if (SkPaint::kFill_Style == paintStyle && pathBounds.width() < 64.f && + pathBounds.height() < 64.f && !op.path.isVolatile()) { + // AADF eligible concave path is not slow. + } else { + fNumSlowPathsAndDashEffects++; + } + } + } + + template <typename T> + SK_WHEN(HasMember_paint<T>, void) operator()(const T& op) { + this->checkPaint(AsPtr(op.paint)); + } + + template <typename T> + SK_WHEN(!HasMember_paint<T>, void) operator()(const T& op) { /* do nothing */ } + + int fNumSlowPathsAndDashEffects; +}; |