1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
/*
* 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 "SkRecordOpts.h"
#include "SkRecordPattern.h"
#include "SkRecords.h"
#include "SkTDArray.h"
using namespace SkRecords;
void SkRecordOptimize(SkRecord* record) {
// This might be useful as a first pass in the future if we want to weed
// out junk for other optimization passes. Right now, nothing needs it,
// and the bounding box hierarchy will do the work of skipping no-op
// Save-NoDraw-Restore sequences better than we can here.
//SkRecordNoopSaveRestores(record);
SkRecordNoopSaveLayerDrawRestores(record);
}
// Most of the optimizations in this file are pattern-based. These are all defined as structs with:
// - a Pattern typedef
// - a bool onMatch(SkRceord*, Pattern*, unsigned begin, unsigned end) method,
// which returns true if it made changes and false if not.
// Run a pattern-based optimization once across the SkRecord, returning true if it made any changes.
// It looks for spans which match Pass::Pattern, and when found calls onMatch() with the pattern,
// record, and [begin,end) span of the commands that matched.
template <typename Pass>
static bool apply(Pass* pass, SkRecord* record) {
typename Pass::Pattern pattern;
bool changed = false;
unsigned begin, end = 0;
while (pattern.search(record, &begin, &end)) {
changed |= pass->onMatch(record, &pattern, begin, end);
}
return changed;
}
// Turns the logical NoOp Save and Restore in Save-Draw*-Restore patterns into actual NoOps.
struct SaveOnlyDrawsRestoreNooper {
typedef Pattern3<Is<Save>,
Star<Or<Is<NoOp>, IsDraw> >,
Is<Restore> >
Pattern;
bool onMatch(SkRecord* record, Pattern* pattern, unsigned begin, unsigned end) {
record->replace<NoOp>(begin); // Save
record->replace<NoOp>(end-1); // Restore
return true;
}
};
// Turns logical no-op Save-[non-drawing command]*-Restore patterns into actual no-ops.
struct SaveNoDrawsRestoreNooper {
// Star matches greedily, so we also have to exclude Save and Restore.
// Nested SaveLayers need to be excluded, or we'll match their Restore!
typedef Pattern3<Is<Save>,
Star<Not<Or4<Is<Save>,
Is<SaveLayer>,
Is<Restore>,
IsDraw> > >,
Is<Restore> >
Pattern;
bool onMatch(SkRecord* record, Pattern* pattern, unsigned begin, unsigned end) {
// The entire span between Save and Restore (inclusively) does nothing.
for (unsigned i = begin; i < end; i++) {
record->replace<NoOp>(i);
}
return true;
}
};
void SkRecordNoopSaveRestores(SkRecord* record) {
SaveOnlyDrawsRestoreNooper onlyDraws;
SaveNoDrawsRestoreNooper noDraws;
// Run until they stop changing things.
while (apply(&onlyDraws, record) || apply(&noDraws, record));
}
// For some SaveLayer-[drawing command]-Restore patterns, merge the SaveLayer's alpha into the
// draw, and no-op the SaveLayer and Restore.
struct SaveLayerDrawRestoreNooper {
typedef Pattern3<Is<SaveLayer>, IsDraw, Is<Restore> > Pattern;
bool onMatch(SkRecord* record, Pattern* pattern, unsigned begin, unsigned end) {
SaveLayer* saveLayer = pattern->first<SaveLayer>();
if (saveLayer->bounds != NULL) {
// SaveLayer with bounds is too tricky for us.
return false;
}
SkPaint* layerPaint = saveLayer->paint;
if (NULL == layerPaint) {
// There wasn't really any point to this SaveLayer at all.
return KillSaveLayerAndRestore(record, begin);
}
SkPaint* drawPaint = pattern->second<SkPaint>();
if (drawPaint == NULL) {
// We can just give the draw the SaveLayer's paint.
// TODO(mtklein): figure out how to do this clearly
return false;
}
const uint32_t layerColor = layerPaint->getColor();
const uint32_t drawColor = drawPaint->getColor();
if (!IsOnlyAlpha(layerColor) || !IsOpaque(drawColor) ||
HasAnyEffect(*layerPaint) || HasAnyEffect(*drawPaint)) {
// Too fancy for us. Actually, as long as layerColor is just an alpha
// we can blend it into drawColor's alpha; drawColor doesn't strictly have to be opaque.
return false;
}
drawPaint->setColor(SkColorSetA(drawColor, SkColorGetA(layerColor)));
return KillSaveLayerAndRestore(record, begin);
}
static bool KillSaveLayerAndRestore(SkRecord* record, unsigned saveLayerIndex) {
record->replace<NoOp>(saveLayerIndex); // SaveLayer
record->replace<NoOp>(saveLayerIndex+2); // Restore
return true;
}
static bool HasAnyEffect(const SkPaint& paint) {
return paint.getPathEffect() ||
paint.getShader() ||
paint.getXfermode() ||
paint.getMaskFilter() ||
paint.getColorFilter() ||
paint.getRasterizer() ||
paint.getLooper() ||
paint.getImageFilter();
}
static bool IsOpaque(SkColor color) {
return SkColorGetA(color) == SK_AlphaOPAQUE;
}
static bool IsOnlyAlpha(SkColor color) {
return SK_ColorTRANSPARENT == SkColorSetA(color, SK_AlphaTRANSPARENT);
}
};
void SkRecordNoopSaveLayerDrawRestores(SkRecord* record) {
SaveLayerDrawRestoreNooper pass;
apply(&pass, record);
}
|
