1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "VectorDrawable.h"
18
19 #include <math.h>
20 #include <string.h>
21 #include <utils/Log.h>
22
23 #include "PathParser.h"
24 #include "SkColorFilter.h"
25 #include "SkImageInfo.h"
26 #include "SkShader.h"
27 #include "hwui/Paint.h"
28
29 #ifdef __ANDROID__
30 #include "renderthread/RenderThread.h"
31 #endif
32
33 #include <gui/TraceUtils.h>
34 #include "utils/Macros.h"
35 #include "utils/VectorDrawableUtils.h"
36
37 namespace android {
38 namespace uirenderer {
39 namespace VectorDrawable {
40
41 const int Tree::MAX_CACHED_BITMAP_SIZE = 2048;
42
dump()43 void Path::dump() {
44 ALOGD("Path: %s has %zu points", mName.c_str(), mProperties.getData().points.size());
45 }
46
47 // Called from UI thread during the initial setup/theme change.
Path(const char * pathStr,size_t strLength)48 Path::Path(const char* pathStr, size_t strLength) {
49 PathParser::ParseResult result;
50 Data data;
51 PathParser::getPathDataFromAsciiString(&data, &result, pathStr, strLength);
52 mStagingProperties.setData(data);
53 }
54
Path(const Path & path)55 Path::Path(const Path& path) : Node(path) {
56 mStagingProperties.syncProperties(path.mStagingProperties);
57 }
58
getUpdatedPath(bool useStagingData,SkPath * tempStagingPath)59 const SkPath& Path::getUpdatedPath(bool useStagingData, SkPath* tempStagingPath) {
60 if (useStagingData) {
61 tempStagingPath->reset();
62 VectorDrawableUtils::verbsToPath(tempStagingPath, mStagingProperties.getData());
63 return *tempStagingPath;
64 } else {
65 if (mSkPathDirty) {
66 mSkPath.reset();
67 VectorDrawableUtils::verbsToPath(&mSkPath, mProperties.getData());
68 mSkPathDirty = false;
69 }
70 return mSkPath;
71 }
72 }
73
syncProperties()74 void Path::syncProperties() {
75 if (mStagingPropertiesDirty) {
76 mProperties.syncProperties(mStagingProperties);
77 } else {
78 mStagingProperties.syncProperties(mProperties);
79 }
80 mStagingPropertiesDirty = false;
81 }
82
FullPath(const FullPath & path)83 FullPath::FullPath(const FullPath& path) : Path(path) {
84 mStagingProperties.syncProperties(path.mStagingProperties);
85 }
86
applyTrim(SkPath * outPath,const SkPath & inPath,float trimPathStart,float trimPathEnd,float trimPathOffset)87 static void applyTrim(SkPath* outPath, const SkPath& inPath, float trimPathStart, float trimPathEnd,
88 float trimPathOffset) {
89 if (trimPathStart == 0.0f && trimPathEnd == 1.0f) {
90 *outPath = inPath;
91 return;
92 }
93 outPath->reset();
94 if (trimPathStart == trimPathEnd) {
95 // Trimmed path should be empty.
96 return;
97 }
98 SkPathMeasure measure(inPath, false);
99 float len = SkScalarToFloat(measure.getLength());
100 float start = len * fmod((trimPathStart + trimPathOffset), 1.0f);
101 float end = len * fmod((trimPathEnd + trimPathOffset), 1.0f);
102
103 if (start > end) {
104 measure.getSegment(start, len, outPath, true);
105 if (end > 0) {
106 measure.getSegment(0, end, outPath, true);
107 }
108 } else {
109 measure.getSegment(start, end, outPath, true);
110 }
111 }
112
getUpdatedPath(bool useStagingData,SkPath * tempStagingPath)113 const SkPath& FullPath::getUpdatedPath(bool useStagingData, SkPath* tempStagingPath) {
114 if (!useStagingData && !mSkPathDirty && !mProperties.mTrimDirty) {
115 return mTrimmedSkPath;
116 }
117 Path::getUpdatedPath(useStagingData, tempStagingPath);
118 SkPath* outPath;
119 if (useStagingData) {
120 SkPath inPath = *tempStagingPath;
121 applyTrim(tempStagingPath, inPath, mStagingProperties.getTrimPathStart(),
122 mStagingProperties.getTrimPathEnd(), mStagingProperties.getTrimPathOffset());
123 outPath = tempStagingPath;
124 } else {
125 if (mProperties.getTrimPathStart() != 0.0f || mProperties.getTrimPathEnd() != 1.0f) {
126 mProperties.mTrimDirty = false;
127 applyTrim(&mTrimmedSkPath, mSkPath, mProperties.getTrimPathStart(),
128 mProperties.getTrimPathEnd(), mProperties.getTrimPathOffset());
129 outPath = &mTrimmedSkPath;
130 } else {
131 outPath = &mSkPath;
132 }
133 }
134 const FullPathProperties& properties = useStagingData ? mStagingProperties : mProperties;
135 bool setFillPath = properties.getFillGradient() != nullptr ||
136 properties.getFillColor() != SK_ColorTRANSPARENT;
137 if (setFillPath) {
138 outPath->setFillType(static_cast<SkPathFillType>(properties.getFillType()));
139 }
140 return *outPath;
141 }
142
dump()143 void FullPath::dump() {
144 Path::dump();
145 ALOGD("stroke width, color, alpha: %f, %d, %f, fill color, alpha: %d, %f",
146 mProperties.getStrokeWidth(), mProperties.getStrokeColor(), mProperties.getStrokeAlpha(),
147 mProperties.getFillColor(), mProperties.getFillAlpha());
148 }
149
applyAlpha(SkColor color,float alpha)150 inline SkColor applyAlpha(SkColor color, float alpha) {
151 int alphaBytes = SkColorGetA(color);
152 return SkColorSetA(color, alphaBytes * alpha);
153 }
154
draw(SkCanvas * outCanvas,bool useStagingData)155 void FullPath::draw(SkCanvas* outCanvas, bool useStagingData) {
156 const FullPathProperties& properties = useStagingData ? mStagingProperties : mProperties;
157 SkPath tempStagingPath;
158 const SkPath& renderPath = getUpdatedPath(useStagingData, &tempStagingPath);
159
160 // Draw path's fill, if fill color or gradient is valid
161 bool needsFill = false;
162 SkPaint paint;
163 if (properties.getFillGradient() != nullptr) {
164 paint.setColor(applyAlpha(SK_ColorBLACK, properties.getFillAlpha()));
165 paint.setShader(sk_sp<SkShader>(SkSafeRef(properties.getFillGradient())));
166 needsFill = true;
167 } else if (properties.getFillColor() != SK_ColorTRANSPARENT) {
168 paint.setColor(applyAlpha(properties.getFillColor(), properties.getFillAlpha()));
169 needsFill = true;
170 }
171
172 if (needsFill) {
173 paint.setStyle(SkPaint::Style::kFill_Style);
174 paint.setAntiAlias(mAntiAlias);
175 outCanvas->drawPath(renderPath, paint);
176 }
177
178 // Draw path's stroke, if stroke color or Gradient is valid
179 bool needsStroke = false;
180 if (properties.getStrokeGradient() != nullptr) {
181 paint.setColor(applyAlpha(SK_ColorBLACK, properties.getStrokeAlpha()));
182 paint.setShader(sk_sp<SkShader>(SkSafeRef(properties.getStrokeGradient())));
183 needsStroke = true;
184 } else if (properties.getStrokeColor() != SK_ColorTRANSPARENT) {
185 paint.setColor(applyAlpha(properties.getStrokeColor(), properties.getStrokeAlpha()));
186 needsStroke = true;
187 }
188 if (needsStroke) {
189 paint.setStyle(SkPaint::Style::kStroke_Style);
190 paint.setAntiAlias(mAntiAlias);
191 paint.setStrokeJoin(SkPaint::Join(properties.getStrokeLineJoin()));
192 paint.setStrokeCap(SkPaint::Cap(properties.getStrokeLineCap()));
193 paint.setStrokeMiter(properties.getStrokeMiterLimit());
194 paint.setStrokeWidth(properties.getStrokeWidth());
195 outCanvas->drawPath(renderPath, paint);
196 }
197 }
198
syncProperties()199 void FullPath::syncProperties() {
200 Path::syncProperties();
201
202 if (mStagingPropertiesDirty) {
203 mProperties.syncProperties(mStagingProperties);
204 } else {
205 // Update staging property with property values from animation.
206 mStagingProperties.syncProperties(mProperties);
207 }
208 mStagingPropertiesDirty = false;
209 }
210
211 REQUIRE_COMPATIBLE_LAYOUT(FullPath::FullPathProperties::PrimitiveFields);
212
213 static_assert(sizeof(float) == sizeof(int32_t), "float is not the same size as int32_t");
214 static_assert(sizeof(SkColor) == sizeof(int32_t), "SkColor is not the same size as int32_t");
215
copyProperties(int8_t * outProperties,int length) const216 bool FullPath::FullPathProperties::copyProperties(int8_t* outProperties, int length) const {
217 int propertyDataSize = sizeof(FullPathProperties::PrimitiveFields);
218 if (length != propertyDataSize) {
219 LOG_ALWAYS_FATAL("Properties needs exactly %d bytes, a byte array of size %d is provided",
220 propertyDataSize, length);
221 return false;
222 }
223
224 PrimitiveFields* out = reinterpret_cast<PrimitiveFields*>(outProperties);
225 *out = mPrimitiveFields;
226 return true;
227 }
228
setColorPropertyValue(int propertyId,int32_t value)229 void FullPath::FullPathProperties::setColorPropertyValue(int propertyId, int32_t value) {
230 Property currentProperty = static_cast<Property>(propertyId);
231 if (currentProperty == Property::strokeColor) {
232 setStrokeColor(value);
233 } else if (currentProperty == Property::fillColor) {
234 setFillColor(value);
235 } else {
236 LOG_ALWAYS_FATAL(
237 "Error setting color property on FullPath: No valid property"
238 " with id: %d",
239 propertyId);
240 }
241 }
242
setPropertyValue(int propertyId,float value)243 void FullPath::FullPathProperties::setPropertyValue(int propertyId, float value) {
244 Property property = static_cast<Property>(propertyId);
245 switch (property) {
246 case Property::strokeWidth:
247 setStrokeWidth(value);
248 break;
249 case Property::strokeAlpha:
250 setStrokeAlpha(value);
251 break;
252 case Property::fillAlpha:
253 setFillAlpha(value);
254 break;
255 case Property::trimPathStart:
256 setTrimPathStart(value);
257 break;
258 case Property::trimPathEnd:
259 setTrimPathEnd(value);
260 break;
261 case Property::trimPathOffset:
262 setTrimPathOffset(value);
263 break;
264 default:
265 LOG_ALWAYS_FATAL("Invalid property id: %d for animation", propertyId);
266 break;
267 }
268 }
269
draw(SkCanvas * outCanvas,bool useStagingData)270 void ClipPath::draw(SkCanvas* outCanvas, bool useStagingData) {
271 SkPath tempStagingPath;
272 outCanvas->clipPath(getUpdatedPath(useStagingData, &tempStagingPath), true);
273 }
274
Group(const Group & group)275 Group::Group(const Group& group) : Node(group) {
276 mStagingProperties.syncProperties(group.mStagingProperties);
277 }
278
draw(SkCanvas * outCanvas,bool useStagingData)279 void Group::draw(SkCanvas* outCanvas, bool useStagingData) {
280 // Save the current clip and matrix information, which is local to this group.
281 SkAutoCanvasRestore saver(outCanvas, true);
282 // apply the current group's matrix to the canvas
283 SkMatrix stackedMatrix;
284 const GroupProperties& prop = useStagingData ? mStagingProperties : mProperties;
285 getLocalMatrix(&stackedMatrix, prop);
286 outCanvas->concat(stackedMatrix);
287 // Draw the group tree in the same order as the XML file.
288 for (auto& child : mChildren) {
289 child->draw(outCanvas, useStagingData);
290 }
291 // Restore the previous clip and matrix information.
292 }
293
dump()294 void Group::dump() {
295 ALOGD("Group %s has %zu children: ", mName.c_str(), mChildren.size());
296 ALOGD("Group translateX, Y : %f, %f, scaleX, Y: %f, %f", mProperties.getTranslateX(),
297 mProperties.getTranslateY(), mProperties.getScaleX(), mProperties.getScaleY());
298 for (size_t i = 0; i < mChildren.size(); i++) {
299 mChildren[i]->dump();
300 }
301 }
302
syncProperties()303 void Group::syncProperties() {
304 // Copy over the dirty staging properties
305 if (mStagingPropertiesDirty) {
306 mProperties.syncProperties(mStagingProperties);
307 } else {
308 mStagingProperties.syncProperties(mProperties);
309 }
310 mStagingPropertiesDirty = false;
311 for (auto& child : mChildren) {
312 child->syncProperties();
313 }
314 }
315
getLocalMatrix(SkMatrix * outMatrix,const GroupProperties & properties)316 void Group::getLocalMatrix(SkMatrix* outMatrix, const GroupProperties& properties) {
317 outMatrix->reset();
318 // TODO: use rotate(mRotate, mPivotX, mPivotY) and scale with pivot point, instead of
319 // translating to pivot for rotating and scaling, then translating back.
320 outMatrix->postTranslate(-properties.getPivotX(), -properties.getPivotY());
321 outMatrix->postScale(properties.getScaleX(), properties.getScaleY());
322 outMatrix->postRotate(properties.getRotation(), 0, 0);
323 outMatrix->postTranslate(properties.getTranslateX() + properties.getPivotX(),
324 properties.getTranslateY() + properties.getPivotY());
325 }
326
addChild(Node * child)327 void Group::addChild(Node* child) {
328 mChildren.emplace_back(child);
329 if (mPropertyChangedListener != nullptr) {
330 child->setPropertyChangedListener(mPropertyChangedListener);
331 }
332 }
333
copyProperties(float * outProperties,int length) const334 bool Group::GroupProperties::copyProperties(float* outProperties, int length) const {
335 int propertyCount = static_cast<int>(Property::count);
336 if (length != propertyCount) {
337 LOG_ALWAYS_FATAL("Properties needs exactly %d bytes, a byte array of size %d is provided",
338 propertyCount, length);
339 return false;
340 }
341
342 PrimitiveFields* out = reinterpret_cast<PrimitiveFields*>(outProperties);
343 *out = mPrimitiveFields;
344 return true;
345 }
346
347 // TODO: Consider animating the properties as float pointers
348 // Called on render thread
getPropertyValue(int propertyId) const349 float Group::GroupProperties::getPropertyValue(int propertyId) const {
350 Property currentProperty = static_cast<Property>(propertyId);
351 switch (currentProperty) {
352 case Property::rotate:
353 return getRotation();
354 case Property::pivotX:
355 return getPivotX();
356 case Property::pivotY:
357 return getPivotY();
358 case Property::scaleX:
359 return getScaleX();
360 case Property::scaleY:
361 return getScaleY();
362 case Property::translateX:
363 return getTranslateX();
364 case Property::translateY:
365 return getTranslateY();
366 default:
367 LOG_ALWAYS_FATAL("Invalid property index: %d", propertyId);
368 return 0;
369 }
370 }
371
372 // Called on render thread
setPropertyValue(int propertyId,float value)373 void Group::GroupProperties::setPropertyValue(int propertyId, float value) {
374 Property currentProperty = static_cast<Property>(propertyId);
375 switch (currentProperty) {
376 case Property::rotate:
377 setRotation(value);
378 break;
379 case Property::pivotX:
380 setPivotX(value);
381 break;
382 case Property::pivotY:
383 setPivotY(value);
384 break;
385 case Property::scaleX:
386 setScaleX(value);
387 break;
388 case Property::scaleY:
389 setScaleY(value);
390 break;
391 case Property::translateX:
392 setTranslateX(value);
393 break;
394 case Property::translateY:
395 setTranslateY(value);
396 break;
397 default:
398 LOG_ALWAYS_FATAL("Invalid property index: %d", propertyId);
399 }
400 }
401
isValidProperty(int propertyId)402 bool Group::isValidProperty(int propertyId) {
403 return GroupProperties::isValidProperty(propertyId);
404 }
405
isValidProperty(int propertyId)406 bool Group::GroupProperties::isValidProperty(int propertyId) {
407 return propertyId >= 0 && propertyId < static_cast<int>(Property::count);
408 }
409
draw(Canvas * outCanvas,SkColorFilter * colorFilter,const SkRect & bounds,bool needsMirroring,bool canReuseCache)410 int Tree::draw(Canvas* outCanvas, SkColorFilter* colorFilter, const SkRect& bounds,
411 bool needsMirroring, bool canReuseCache) {
412 // The imageView can scale the canvas in different ways, in order to
413 // avoid blurry scaling, we have to draw into a bitmap with exact pixel
414 // size first. This bitmap size is determined by the bounds and the
415 // canvas scale.
416 SkMatrix canvasMatrix;
417 outCanvas->getMatrix(&canvasMatrix);
418 float canvasScaleX = 1.0f;
419 float canvasScaleY = 1.0f;
420 if (canvasMatrix.getSkewX() == 0 && canvasMatrix.getSkewY() == 0) {
421 // Only use the scale value when there's no skew or rotation in the canvas matrix.
422 // TODO: Add a cts test for drawing VD on a canvas with negative scaling factors.
423 canvasScaleX = fabs(canvasMatrix.getScaleX());
424 canvasScaleY = fabs(canvasMatrix.getScaleY());
425 }
426 int scaledWidth = (int)(bounds.width() * canvasScaleX);
427 int scaledHeight = (int)(bounds.height() * canvasScaleY);
428 scaledWidth = std::min(Tree::MAX_CACHED_BITMAP_SIZE, scaledWidth);
429 scaledHeight = std::min(Tree::MAX_CACHED_BITMAP_SIZE, scaledHeight);
430
431 if (scaledWidth <= 0 || scaledHeight <= 0) {
432 return 0;
433 }
434
435 mStagingProperties.setScaledSize(scaledWidth, scaledHeight);
436 int saveCount = outCanvas->save(SaveFlags::MatrixClip);
437 outCanvas->translate(bounds.fLeft, bounds.fTop);
438
439 // Handle RTL mirroring.
440 if (needsMirroring) {
441 outCanvas->translate(bounds.width(), 0);
442 outCanvas->scale(-1.0f, 1.0f);
443 }
444 mStagingProperties.setColorFilter(colorFilter);
445
446 // At this point, canvas has been translated to the right position.
447 // And we use this bound for the destination rect for the drawBitmap, so
448 // we offset to (0, 0);
449 SkRect tmpBounds = bounds;
450 tmpBounds.offsetTo(0, 0);
451 mStagingProperties.setBounds(tmpBounds);
452 outCanvas->drawVectorDrawable(this);
453 outCanvas->restoreToCount(saveCount);
454 return scaledWidth * scaledHeight;
455 }
456
drawStaging(Canvas * outCanvas)457 void Tree::drawStaging(Canvas* outCanvas) {
458 bool redrawNeeded = allocateBitmapIfNeeded(mStagingCache, mStagingProperties.getScaledWidth(),
459 mStagingProperties.getScaledHeight());
460 // draw bitmap cache
461 if (redrawNeeded || mStagingCache.dirty) {
462 updateBitmapCache(*mStagingCache.bitmap, true);
463 mStagingCache.dirty = false;
464 }
465
466 Paint skp;
467 getPaintFor(&skp, mStagingProperties);
468 Paint paint;
469 paint.setFilterBitmap(skp.isFilterBitmap());
470 paint.setColorFilter(skp.refColorFilter());
471 paint.setAlpha(skp.getAlpha());
472 outCanvas->drawBitmap(*mStagingCache.bitmap, 0, 0, mStagingCache.bitmap->width(),
473 mStagingCache.bitmap->height(), mStagingProperties.getBounds().left(),
474 mStagingProperties.getBounds().top(),
475 mStagingProperties.getBounds().right(),
476 mStagingProperties.getBounds().bottom(), &paint);
477 }
478
getPaintFor(Paint * outPaint,const TreeProperties & prop) const479 void Tree::getPaintFor(Paint* outPaint, const TreeProperties& prop) const {
480 // HWUI always draws VD with bilinear filtering.
481 outPaint->setFilterBitmap(true);
482 if (prop.getColorFilter() != nullptr) {
483 outPaint->setColorFilter(sk_ref_sp(prop.getColorFilter()));
484 }
485 outPaint->setAlpha(prop.getRootAlpha() * 255);
486 }
487
getBitmapUpdateIfDirty()488 Bitmap& Tree::getBitmapUpdateIfDirty() {
489 bool redrawNeeded = allocateBitmapIfNeeded(mCache, mProperties.getScaledWidth(),
490 mProperties.getScaledHeight());
491 if (redrawNeeded || mCache.dirty) {
492 updateBitmapCache(*mCache.bitmap, false);
493 mCache.dirty = false;
494 }
495 return *mCache.bitmap;
496 }
497
draw(SkCanvas * canvas,const SkRect & bounds,const SkPaint & inPaint)498 void Tree::draw(SkCanvas* canvas, const SkRect& bounds, const SkPaint& inPaint) {
499 if (canvas->quickReject(bounds)) {
500 // The RenderNode is on screen, but the AVD is not.
501 return;
502 }
503
504 // Update the paint for any animatable properties
505 SkPaint paint = inPaint;
506 paint.setAlpha(mProperties.getRootAlpha() * 255);
507
508 sk_sp<SkImage> cachedBitmap = getBitmapUpdateIfDirty().makeImage();
509
510 // HWUI always draws VD with bilinear filtering.
511 auto sampling = SkSamplingOptions(SkFilterMode::kLinear);
512 int scaledWidth = SkScalarCeilToInt(mProperties.getScaledWidth());
513 int scaledHeight = SkScalarCeilToInt(mProperties.getScaledHeight());
514 canvas->drawImageRect(cachedBitmap, SkRect::MakeWH(scaledWidth, scaledHeight), bounds,
515 sampling, &paint, SkCanvas::kFast_SrcRectConstraint);
516 }
517
updateBitmapCache(Bitmap & bitmap,bool useStagingData)518 void Tree::updateBitmapCache(Bitmap& bitmap, bool useStagingData) {
519 SkBitmap outCache;
520 bitmap.getSkBitmap(&outCache);
521 int cacheWidth = outCache.width();
522 int cacheHeight = outCache.height();
523 ATRACE_FORMAT("VectorDrawable repaint %dx%d", cacheWidth, cacheHeight);
524 outCache.eraseColor(SK_ColorTRANSPARENT);
525 SkCanvas outCanvas(outCache);
526 float viewportWidth =
527 useStagingData ? mStagingProperties.getViewportWidth() : mProperties.getViewportWidth();
528 float viewportHeight = useStagingData ? mStagingProperties.getViewportHeight()
529 : mProperties.getViewportHeight();
530 float scaleX = cacheWidth / viewportWidth;
531 float scaleY = cacheHeight / viewportHeight;
532 outCanvas.scale(scaleX, scaleY);
533 mRootNode->draw(&outCanvas, useStagingData);
534 }
535
allocateBitmapIfNeeded(Cache & cache,int width,int height)536 bool Tree::allocateBitmapIfNeeded(Cache& cache, int width, int height) {
537 if (!canReuseBitmap(cache.bitmap.get(), width, height)) {
538 SkImageInfo info = SkImageInfo::MakeN32(width, height, kPremul_SkAlphaType);
539 cache.bitmap = Bitmap::allocateHeapBitmap(info);
540 return true;
541 }
542 return false;
543 }
544
canReuseBitmap(Bitmap * bitmap,int width,int height)545 bool Tree::canReuseBitmap(Bitmap* bitmap, int width, int height) {
546 return bitmap && width <= bitmap->width() && height <= bitmap->height();
547 }
548
onPropertyChanged(TreeProperties * prop)549 void Tree::onPropertyChanged(TreeProperties* prop) {
550 if (prop == &mStagingProperties) {
551 mStagingCache.dirty = true;
552 } else {
553 mCache.dirty = true;
554 }
555 }
556
557 class MinMaxAverage {
558 public:
add(float sample)559 void add(float sample) {
560 if (mCount == 0) {
561 mMin = sample;
562 mMax = sample;
563 } else {
564 mMin = std::min(mMin, sample);
565 mMax = std::max(mMax, sample);
566 }
567 mTotal += sample;
568 mCount++;
569 }
570
average()571 float average() { return mTotal / mCount; }
572
min()573 float min() { return mMin; }
574
max()575 float max() { return mMax; }
576
delta()577 float delta() { return mMax - mMin; }
578
579 private:
580 float mMin = 0.0f;
581 float mMax = 0.0f;
582 float mTotal = 0.0f;
583 int mCount = 0;
584 };
585
computePalette()586 BitmapPalette Tree::computePalette() {
587 // TODO Cache this and share the code with Bitmap.cpp
588
589 ATRACE_CALL();
590
591 // TODO: This calculation of converting to HSV & tracking min/max is probably overkill
592 // Experiment with something simpler since we just want to figure out if it's "color-ful"
593 // and then the average perceptual lightness.
594
595 MinMaxAverage hue, saturation, value;
596 int sampledCount = 0;
597
598 // Sample a grid of 100 pixels to get an overall estimation of the colors in play
599 mRootNode->forEachFillColor([&](SkColor color) {
600 if (SkColorGetA(color) < 75) {
601 return;
602 }
603 sampledCount++;
604 float hsv[3];
605 SkColorToHSV(color, hsv);
606 hue.add(hsv[0]);
607 saturation.add(hsv[1]);
608 value.add(hsv[2]);
609 });
610
611 if (sampledCount == 0) {
612 ALOGV("VectorDrawable is mostly translucent");
613 return BitmapPalette::Unknown;
614 }
615
616 ALOGV("samples = %d, hue [min = %f, max = %f, avg = %f]; saturation [min = %f, max = %f, avg = "
617 "%f]; value [min = %f, max = %f, avg = %f]",
618 sampledCount, hue.min(), hue.max(), hue.average(), saturation.min(), saturation.max(),
619 saturation.average(), value.min(), value.max(), value.average());
620
621 if (hue.delta() <= 20 && saturation.delta() <= .1f) {
622 if (value.average() >= .5f) {
623 return BitmapPalette::Light;
624 } else {
625 return BitmapPalette::Dark;
626 }
627 }
628 return BitmapPalette::Unknown;
629 }
630
631 } // namespace VectorDrawable
632
633 } // namespace uirenderer
634 } // namespace android
635