/* * 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 "src/core/SkRecordOpts.h" #include "include/private/SkTDArray.h" #include "src/core/SkCanvasPriv.h" #include "src/core/SkRecordPattern.h" #include "src/core/SkRecords.h" using namespace SkRecords; // Most of the optimizations in this file are pattern-based. These are all defined as structs with: // - a Match typedef // - a bool onMatch(SkRceord*, Match*, int begin, int 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::Match, and when found calls onMatch() with that pattern, // record, and [begin,end) span of the commands that matched. template static bool apply(Pass* pass, SkRecord* record) { typename Pass::Match match; bool changed = false; int begin, end = 0; while (match.search(record, &begin, &end)) { changed |= pass->onMatch(record, &match, begin, end); } return changed; } /////////////////////////////////////////////////////////////////////////////////////////////////// static void multiple_set_matrices(SkRecord* record) { struct { typedef Pattern, Greedy>, Is > Match; bool onMatch(SkRecord* record, Match* pattern, int begin, int end) { record->replace(begin); // first SetMatrix return true; } } pass; while (apply(&pass, record)); } /////////////////////////////////////////////////////////////////////////////////////////////////// #if 0 // experimental, but needs knowledge of previous matrix to operate correctly static void apply_matrix_to_draw_params(SkRecord* record) { struct { typedef Pattern, Greedy>, Is > Pattern; bool onMatch(SkRecord* record, Pattern* pattern, int begin, int end) { record->replace(begin); // first SetMatrix return true; } } pass; // No need to loop, as we never "open up" opportunities for more of this type of optimization. apply(&pass, record); } #endif /////////////////////////////////////////////////////////////////////////////////////////////////// // Turns the logical NoOp Save and Restore in Save-Draw*-Restore patterns into actual NoOps. struct SaveOnlyDrawsRestoreNooper { typedef Pattern, Greedy, IsDraw>>, Is> Match; bool onMatch(SkRecord* record, Match*, int begin, int end) { record->replace(begin); // Save record->replace(end-1); // Restore return true; } }; static bool fold_opacity_layer_color_to_paint(const SkPaint* layerPaint, bool isSaveLayer, SkPaint* paint) { // We assume layerPaint is always from a saveLayer. If isSaveLayer is // true, we assume paint is too. // The alpha folding can proceed if the filter layer paint does not have properties which cause // the resulting filter layer to be "blended" in complex ways to the parent layer. For example, // looper drawing unmodulated filter layer twice and then modulating the result produces // different image to drawing modulated filter layer twice. // TODO: most likely the looper and only some xfer modes are the hard constraints if (!paint->isSrcOver() #ifdef SK_SUPPORT_LEGACY_DRAWLOOPER || paint->getLooper() #endif ) { return false; } if (!isSaveLayer && paint->getImageFilter()) { // For normal draws, the paint color is used as one input for the color for the draw. Image // filter will operate on the result, and thus we can not change the input. // For layer saves, the image filter is applied to the layer contents. The layer is then // modulated with the paint color, so it's fine to proceed with the fold for saveLayer // paints with image filters. return false; } if (paint->getColorFilter()) { // Filter input depends on the paint color. // Here we could filter the color if we knew the draw is going to be uniform color. This // should be detectable as drawPath/drawRect/.. without a shader being uniform, while // drawBitmap/drawSprite or a shader being non-uniform. However, current matchers don't // give the type out easily, so just do not optimize that at the moment. return false; } if (layerPaint) { const uint32_t layerColor = layerPaint->getColor(); // The layer paint color must have only alpha component. if (SK_ColorTRANSPARENT != SkColorSetA(layerColor, SK_AlphaTRANSPARENT)) { return false; } // The layer paint can not have any effects. if (layerPaint->getPathEffect() || layerPaint->getShader() || !layerPaint->isSrcOver() || layerPaint->getMaskFilter() || layerPaint->getColorFilter() || #ifdef SK_SUPPORT_LEGACY_DRAWLOOPER layerPaint->getLooper() || #endif layerPaint->getImageFilter()) { return false; } paint->setAlpha(SkMulDiv255Round(paint->getAlpha(), SkColorGetA(layerColor))); } return true; } // Turns logical no-op Save-[non-drawing command]*-Restore patterns into actual no-ops. struct SaveNoDrawsRestoreNooper { // Greedy matches greedily, so we also have to exclude Save and Restore. // Nested SaveLayers need to be excluded, or we'll match their Restore! typedef Pattern, Greedy, Is, Is, IsDraw>>>, Is> Match; bool onMatch(SkRecord* record, Match*, int begin, int end) { // The entire span between Save and Restore (inclusively) does nothing. for (int i = begin; i < end; i++) { record->replace(i); } return true; } }; void SkRecordNoopSaveRestores(SkRecord* record) { SaveOnlyDrawsRestoreNooper onlyDraws; SaveNoDrawsRestoreNooper noDraws; // Run until they stop changing things. while (apply(&onlyDraws, record) || apply(&noDraws, record)); } #ifndef SK_BUILD_FOR_ANDROID_FRAMEWORK static bool effectively_srcover(const SkPaint* paint) { if (!paint || paint->isSrcOver()) { return true; } // src-mode with opaque and no effects (which might change opaqueness) is ok too. return !paint->getShader() && !paint->getColorFilter() && !paint->getImageFilter() && 0xFF == paint->getAlpha() && paint->getBlendMode() == SkBlendMode::kSrc; } // 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 Pattern, IsDraw, Is> Match; bool onMatch(SkRecord* record, Match* match, int begin, int end) { if (match->first()->backdrop || match->first()->clipMask) { // can't throw away the layer if we have a backdrop or clip mask return false; } if (match->first()->saveLayerFlags & SkCanvasPriv::kDontClipToLayer_SaveLayerFlag) { // can't throw away the layer if set return false; } // A SaveLayer's bounds field is just a hint, so we should be free to ignore it. SkPaint* layerPaint = match->first()->paint; SkPaint* drawPaint = match->second(); if (nullptr == layerPaint && effectively_srcover(drawPaint)) { // There wasn't really any point to this SaveLayer at all. return KillSaveLayerAndRestore(record, begin); } if (drawPaint == nullptr) { // We can just give the draw the SaveLayer's paint. // TODO(mtklein): figure out how to do this clearly return false; } if (!fold_opacity_layer_color_to_paint(layerPaint, false /*isSaveLayer*/, drawPaint)) { return false; } return KillSaveLayerAndRestore(record, begin); } static bool KillSaveLayerAndRestore(SkRecord* record, int saveLayerIndex) { record->replace(saveLayerIndex); // SaveLayer record->replace(saveLayerIndex+2); // Restore return true; } }; void SkRecordNoopSaveLayerDrawRestores(SkRecord* record) { SaveLayerDrawRestoreNooper pass; apply(&pass, record); } #endif /* For SVG generated: SaveLayer (non-opaque, typically for CSS opacity) Save ClipRect SaveLayer (typically for SVG filter) Restore Restore Restore */ struct SvgOpacityAndFilterLayerMergePass { typedef Pattern, Is, Is, Is, Is, Is, Is> Match; bool onMatch(SkRecord* record, Match* match, int begin, int end) { if (match->first()->backdrop) { // can't throw away the layer if we have a backdrop return false; } SkPaint* opacityPaint = match->first()->paint; if (nullptr == opacityPaint) { // There wasn't really any point to this SaveLayer at all. return KillSaveLayerAndRestore(record, begin); } // This layer typically contains a filter, but this should work for layers with for other // purposes too. SkPaint* filterLayerPaint = match->fourth()->paint; if (filterLayerPaint == nullptr) { // We can just give the inner SaveLayer the paint of the outer SaveLayer. // TODO(mtklein): figure out how to do this clearly return false; } if (!fold_opacity_layer_color_to_paint(opacityPaint, true /*isSaveLayer*/, filterLayerPaint)) { return false; } return KillSaveLayerAndRestore(record, begin); } static bool KillSaveLayerAndRestore(SkRecord* record, int saveLayerIndex) { record->replace(saveLayerIndex); // SaveLayer record->replace(saveLayerIndex + 6); // Restore return true; } }; void SkRecordMergeSvgOpacityAndFilterLayers(SkRecord* record) { SvgOpacityAndFilterLayerMergePass pass; apply(&pass, record); } /////////////////////////////////////////////////////////////////////////////////////////////////// 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. // As there is a known problem with this peephole and drawAnnotation, disable this. // If we want to enable this we must first fix this bug: // https://bugs.chromium.org/p/skia/issues/detail?id=5548 // SkRecordNoopSaveRestores(record); // Turn off this optimization completely for Android framework // because it makes the following Android CTS test fail: // android.uirendering.cts.testclasses.LayerTests#testSaveLayerClippedWithAlpha #ifndef SK_BUILD_FOR_ANDROID_FRAMEWORK SkRecordNoopSaveLayerDrawRestores(record); #endif SkRecordMergeSvgOpacityAndFilterLayers(record); record->defrag(); } void SkRecordOptimize2(SkRecord* record) { multiple_set_matrices(record); SkRecordNoopSaveRestores(record); // See why we turn this off in SkRecordOptimize above. #ifndef SK_BUILD_FOR_ANDROID_FRAMEWORK SkRecordNoopSaveLayerDrawRestores(record); #endif SkRecordMergeSvgOpacityAndFilterLayers(record); record->defrag(); }