| /* |
| * Copyright (C) 2011 Apple Inc. All rights reserved. |
| * Copyright (C) 2013 Google Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "third_party/blink/renderer/core/paint/filter_effect_builder.h" |
| |
| #include <algorithm> |
| #include "third_party/blink/public/platform/web_point.h" |
| #include "third_party/blink/renderer/core/style/filter_operations.h" |
| #include "third_party/blink/renderer/core/svg/graphics/filters/svg_filter_builder.h" |
| #include "third_party/blink/renderer/core/svg/svg_filter_element.h" |
| #include "third_party/blink/renderer/core/svg/svg_length_context.h" |
| #include "third_party/blink/renderer/core/svg/svg_resource.h" |
| #include "third_party/blink/renderer/platform/geometry/length_functions.h" |
| #include "third_party/blink/renderer/platform/graphics/compositor_filter_operations.h" |
| #include "third_party/blink/renderer/platform/graphics/filters/fe_box_reflect.h" |
| #include "third_party/blink/renderer/platform/graphics/filters/fe_color_matrix.h" |
| #include "third_party/blink/renderer/platform/graphics/filters/fe_component_transfer.h" |
| #include "third_party/blink/renderer/platform/graphics/filters/fe_drop_shadow.h" |
| #include "third_party/blink/renderer/platform/graphics/filters/fe_gaussian_blur.h" |
| #include "third_party/blink/renderer/platform/graphics/filters/filter.h" |
| #include "third_party/blink/renderer/platform/graphics/filters/filter_effect.h" |
| #include "third_party/blink/renderer/platform/graphics/filters/paint_filter_builder.h" |
| #include "third_party/blink/renderer/platform/graphics/filters/source_graphic.h" |
| #include "third_party/blink/renderer/platform/graphics/interpolation_space.h" |
| #include "third_party/blink/renderer/platform/wtf/math_extras.h" |
| |
| namespace blink { |
| |
| namespace { |
| |
| inline void EndMatrixRow(Vector<float>& matrix) { |
| matrix.UncheckedAppend(0); |
| matrix.UncheckedAppend(0); |
| } |
| |
| inline void LastMatrixRow(Vector<float>& matrix) { |
| matrix.UncheckedAppend(0); |
| matrix.UncheckedAppend(0); |
| matrix.UncheckedAppend(0); |
| matrix.UncheckedAppend(1); |
| matrix.UncheckedAppend(0); |
| } |
| |
| Vector<float> GrayscaleMatrix(double amount) { |
| double one_minus_amount = clampTo(1 - amount, 0.0, 1.0); |
| |
| // See https://drafts.fxtf.org/filter-effects/#grayscaleEquivalent for |
| // information on parameters. |
| Vector<float> matrix; |
| matrix.ReserveInitialCapacity(20); |
| |
| matrix.UncheckedAppend(clampTo<float>(0.2126 + 0.7874 * one_minus_amount)); |
| matrix.UncheckedAppend(clampTo<float>(0.7152 - 0.7152 * one_minus_amount)); |
| matrix.UncheckedAppend(clampTo<float>(0.0722 - 0.0722 * one_minus_amount)); |
| EndMatrixRow(matrix); |
| |
| matrix.UncheckedAppend(clampTo<float>(0.2126 - 0.2126 * one_minus_amount)); |
| matrix.UncheckedAppend(clampTo<float>(0.7152 + 0.2848 * one_minus_amount)); |
| matrix.UncheckedAppend(clampTo<float>(0.0722 - 0.0722 * one_minus_amount)); |
| EndMatrixRow(matrix); |
| |
| matrix.UncheckedAppend(clampTo<float>(0.2126 - 0.2126 * one_minus_amount)); |
| matrix.UncheckedAppend(clampTo<float>(0.7152 - 0.7152 * one_minus_amount)); |
| matrix.UncheckedAppend(clampTo<float>(0.0722 + 0.9278 * one_minus_amount)); |
| EndMatrixRow(matrix); |
| |
| LastMatrixRow(matrix); |
| return matrix; |
| } |
| |
| Vector<float> SepiaMatrix(double amount) { |
| double one_minus_amount = clampTo(1 - amount, 0.0, 1.0); |
| |
| // See https://drafts.fxtf.org/filter-effects/#sepiaEquivalent for information |
| // on parameters. |
| Vector<float> matrix; |
| matrix.ReserveInitialCapacity(20); |
| |
| matrix.UncheckedAppend(clampTo<float>(0.393 + 0.607 * one_minus_amount)); |
| matrix.UncheckedAppend(clampTo<float>(0.769 - 0.769 * one_minus_amount)); |
| matrix.UncheckedAppend(clampTo<float>(0.189 - 0.189 * one_minus_amount)); |
| EndMatrixRow(matrix); |
| |
| matrix.UncheckedAppend(clampTo<float>(0.349 - 0.349 * one_minus_amount)); |
| matrix.UncheckedAppend(clampTo<float>(0.686 + 0.314 * one_minus_amount)); |
| matrix.UncheckedAppend(clampTo<float>(0.168 - 0.168 * one_minus_amount)); |
| EndMatrixRow(matrix); |
| |
| matrix.UncheckedAppend(clampTo<float>(0.272 - 0.272 * one_minus_amount)); |
| matrix.UncheckedAppend(clampTo<float>(0.534 - 0.534 * one_minus_amount)); |
| matrix.UncheckedAppend(clampTo<float>(0.131 + 0.869 * one_minus_amount)); |
| EndMatrixRow(matrix); |
| |
| LastMatrixRow(matrix); |
| return matrix; |
| } |
| |
| } // namespace |
| |
| FilterEffectBuilder::FilterEffectBuilder(const FloatRect& reference_box, |
| float zoom, |
| const PaintFlags* fill_flags, |
| const PaintFlags* stroke_flags) |
| : reference_box_(reference_box), |
| zoom_(zoom), |
| fill_flags_(fill_flags), |
| stroke_flags_(stroke_flags) {} |
| |
| FilterEffect* FilterEffectBuilder::BuildFilterEffect( |
| const FilterOperations& operations, |
| bool input_tainted) const { |
| // Create a parent filter for shorthand filters. These have already been |
| // scaled by the CSS code for page zoom, so scale is 1.0 here. |
| Filter* parent_filter = Filter::Create(1.0f); |
| FilterEffect* previous_effect = parent_filter->GetSourceGraphic(); |
| if (input_tainted) |
| previous_effect->SetOriginTainted(); |
| for (FilterOperation* filter_operation : operations.Operations()) { |
| FilterEffect* effect = nullptr; |
| switch (filter_operation->GetType()) { |
| case FilterOperation::REFERENCE: { |
| ReferenceFilterOperation& reference_operation = |
| ToReferenceFilterOperation(*filter_operation); |
| Filter* reference_filter = |
| BuildReferenceFilter(reference_operation, previous_effect); |
| if (reference_filter) { |
| effect = reference_filter->LastEffect(); |
| // TODO(fs): This is essentially only needed for the |
| // side-effects (mapRect). The filter differs from the one |
| // computed just above in what the SourceGraphic is, and how |
| // it's connected to the filter-chain. |
| reference_filter = BuildReferenceFilter(reference_operation, nullptr); |
| } |
| reference_operation.SetFilter(reference_filter); |
| break; |
| } |
| case FilterOperation::GRAYSCALE: { |
| Vector<float> input_parameters = GrayscaleMatrix( |
| ToBasicColorMatrixFilterOperation(filter_operation)->Amount()); |
| effect = FEColorMatrix::Create(parent_filter, FECOLORMATRIX_TYPE_MATRIX, |
| input_parameters); |
| break; |
| } |
| case FilterOperation::SEPIA: { |
| Vector<float> input_parameters = SepiaMatrix( |
| ToBasicColorMatrixFilterOperation(filter_operation)->Amount()); |
| effect = FEColorMatrix::Create(parent_filter, FECOLORMATRIX_TYPE_MATRIX, |
| input_parameters); |
| break; |
| } |
| case FilterOperation::SATURATE: { |
| Vector<float> input_parameters; |
| input_parameters.push_back(clampTo<float>( |
| ToBasicColorMatrixFilterOperation(filter_operation)->Amount())); |
| effect = FEColorMatrix::Create( |
| parent_filter, FECOLORMATRIX_TYPE_SATURATE, input_parameters); |
| break; |
| } |
| case FilterOperation::HUE_ROTATE: { |
| Vector<float> input_parameters; |
| input_parameters.push_back(clampTo<float>( |
| ToBasicColorMatrixFilterOperation(filter_operation)->Amount())); |
| effect = FEColorMatrix::Create( |
| parent_filter, FECOLORMATRIX_TYPE_HUEROTATE, input_parameters); |
| break; |
| } |
| case FilterOperation::INVERT: { |
| BasicComponentTransferFilterOperation* component_transfer_operation = |
| ToBasicComponentTransferFilterOperation(filter_operation); |
| ComponentTransferFunction transfer_function; |
| transfer_function.type = FECOMPONENTTRANSFER_TYPE_TABLE; |
| Vector<float> transfer_parameters; |
| transfer_parameters.push_back( |
| clampTo<float>(component_transfer_operation->Amount())); |
| transfer_parameters.push_back( |
| clampTo<float>(1 - component_transfer_operation->Amount())); |
| transfer_function.table_values = transfer_parameters; |
| |
| ComponentTransferFunction null_function; |
| effect = FEComponentTransfer::Create(parent_filter, transfer_function, |
| transfer_function, |
| transfer_function, null_function); |
| break; |
| } |
| case FilterOperation::OPACITY: { |
| ComponentTransferFunction transfer_function; |
| transfer_function.type = FECOMPONENTTRANSFER_TYPE_TABLE; |
| Vector<float> transfer_parameters; |
| transfer_parameters.push_back(0); |
| transfer_parameters.push_back(clampTo<float>( |
| ToBasicComponentTransferFilterOperation(filter_operation) |
| ->Amount())); |
| transfer_function.table_values = transfer_parameters; |
| |
| ComponentTransferFunction null_function; |
| effect = FEComponentTransfer::Create(parent_filter, null_function, |
| null_function, null_function, |
| transfer_function); |
| break; |
| } |
| case FilterOperation::BRIGHTNESS: { |
| ComponentTransferFunction transfer_function; |
| transfer_function.type = FECOMPONENTTRANSFER_TYPE_LINEAR; |
| transfer_function.slope = clampTo<float>( |
| ToBasicComponentTransferFilterOperation(filter_operation) |
| ->Amount()); |
| transfer_function.intercept = 0; |
| |
| ComponentTransferFunction null_function; |
| effect = FEComponentTransfer::Create(parent_filter, transfer_function, |
| transfer_function, |
| transfer_function, null_function); |
| break; |
| } |
| case FilterOperation::CONTRAST: { |
| ComponentTransferFunction transfer_function; |
| transfer_function.type = FECOMPONENTTRANSFER_TYPE_LINEAR; |
| float amount = clampTo<float>( |
| ToBasicComponentTransferFilterOperation(filter_operation) |
| ->Amount()); |
| transfer_function.slope = amount; |
| transfer_function.intercept = -0.5 * amount + 0.5; |
| |
| ComponentTransferFunction null_function; |
| effect = FEComponentTransfer::Create(parent_filter, transfer_function, |
| transfer_function, |
| transfer_function, null_function); |
| break; |
| } |
| case FilterOperation::BLUR: { |
| float std_deviation = FloatValueForLength( |
| ToBlurFilterOperation(filter_operation)->StdDeviation(), 0); |
| effect = |
| FEGaussianBlur::Create(parent_filter, std_deviation, std_deviation); |
| break; |
| } |
| case FilterOperation::DROP_SHADOW: { |
| const ShadowData& shadow = |
| ToDropShadowFilterOperation(*filter_operation).Shadow(); |
| effect = FEDropShadow::Create(parent_filter, shadow.Blur(), |
| shadow.Blur(), shadow.X(), shadow.Y(), |
| shadow.GetColor().GetColor(), 1); |
| break; |
| } |
| case FilterOperation::BOX_REFLECT: { |
| BoxReflectFilterOperation* box_reflect_operation = |
| ToBoxReflectFilterOperation(filter_operation); |
| effect = FEBoxReflect::Create(parent_filter, |
| box_reflect_operation->Reflection()); |
| break; |
| } |
| default: |
| break; |
| } |
| |
| if (effect) { |
| if (filter_operation->GetType() != FilterOperation::REFERENCE) { |
| // Unlike SVG, filters applied here should not clip to their primitive |
| // subregions. |
| effect->SetClipsToBounds(false); |
| effect->SetOperatingInterpolationSpace(kInterpolationSpaceSRGB); |
| effect->InputEffects().push_back(previous_effect); |
| } |
| if (previous_effect->OriginTainted()) |
| effect->SetOriginTainted(); |
| previous_effect = effect; |
| } |
| } |
| return previous_effect; |
| } |
| |
| CompositorFilterOperations FilterEffectBuilder::BuildFilterOperations( |
| const FilterOperations& operations) const { |
| InterpolationSpace current_interpolation_space = kInterpolationSpaceSRGB; |
| |
| CompositorFilterOperations filters; |
| for (FilterOperation* op : operations.Operations()) { |
| switch (op->GetType()) { |
| case FilterOperation::REFERENCE: { |
| ReferenceFilterOperation& reference_operation = |
| ToReferenceFilterOperation(*op); |
| Filter* reference_filter = |
| BuildReferenceFilter(reference_operation, nullptr); |
| if (reference_filter && reference_filter->LastEffect()) { |
| paint_filter_builder::PopulateSourceGraphicImageFilters( |
| reference_filter->GetSourceGraphic(), nullptr, |
| current_interpolation_space); |
| |
| FilterEffect* filter_effect = reference_filter->LastEffect(); |
| current_interpolation_space = |
| filter_effect->OperatingInterpolationSpace(); |
| auto paint_filter = paint_filter_builder::Build( |
| filter_effect, current_interpolation_space); |
| if (!paint_filter) |
| continue; |
| filters.AppendReferenceFilter(std::move(paint_filter)); |
| } |
| reference_operation.SetFilter(reference_filter); |
| break; |
| } |
| case FilterOperation::GRAYSCALE: |
| case FilterOperation::SEPIA: |
| case FilterOperation::SATURATE: |
| case FilterOperation::HUE_ROTATE: { |
| float amount = ToBasicColorMatrixFilterOperation(*op).Amount(); |
| switch (op->GetType()) { |
| case FilterOperation::GRAYSCALE: |
| filters.AppendGrayscaleFilter(amount); |
| break; |
| case FilterOperation::SEPIA: |
| filters.AppendSepiaFilter(amount); |
| break; |
| case FilterOperation::SATURATE: |
| filters.AppendSaturateFilter(amount); |
| break; |
| case FilterOperation::HUE_ROTATE: |
| filters.AppendHueRotateFilter(amount); |
| break; |
| default: |
| NOTREACHED(); |
| } |
| break; |
| } |
| case FilterOperation::INVERT: |
| case FilterOperation::OPACITY: |
| case FilterOperation::BRIGHTNESS: |
| case FilterOperation::CONTRAST: { |
| float amount = ToBasicComponentTransferFilterOperation(*op).Amount(); |
| switch (op->GetType()) { |
| case FilterOperation::INVERT: |
| filters.AppendInvertFilter(amount); |
| break; |
| case FilterOperation::OPACITY: |
| filters.AppendOpacityFilter(amount); |
| break; |
| case FilterOperation::BRIGHTNESS: |
| filters.AppendBrightnessFilter(amount); |
| break; |
| case FilterOperation::CONTRAST: |
| filters.AppendContrastFilter(amount); |
| break; |
| default: |
| NOTREACHED(); |
| } |
| break; |
| } |
| case FilterOperation::BLUR: { |
| float pixel_radius = |
| ToBlurFilterOperation(*op).StdDeviation().GetFloatValue(); |
| filters.AppendBlurFilter(pixel_radius); |
| break; |
| } |
| case FilterOperation::DROP_SHADOW: { |
| const ShadowData& shadow = ToDropShadowFilterOperation(*op).Shadow(); |
| filters.AppendDropShadowFilter(FlooredIntPoint(shadow.Location()), |
| shadow.Blur(), |
| shadow.GetColor().GetColor()); |
| break; |
| } |
| case FilterOperation::BOX_REFLECT: { |
| // TODO(jbroman): Consider explaining box reflect to the compositor, |
| // instead of calling this a "reference filter". |
| const auto& reflection = ToBoxReflectFilterOperation(*op).Reflection(); |
| filters.AppendReferenceFilter( |
| paint_filter_builder::BuildBoxReflectFilter(reflection, nullptr)); |
| break; |
| } |
| case FilterOperation::NONE: |
| break; |
| } |
| } |
| if (current_interpolation_space != kInterpolationSpaceSRGB) { |
| // Transform to device color space at the end of processing, if required. |
| sk_sp<PaintFilter> filter = |
| paint_filter_builder::TransformInterpolationSpace( |
| nullptr, current_interpolation_space, kInterpolationSpaceSRGB); |
| filters.AppendReferenceFilter(std::move(filter)); |
| } |
| |
| if (!filters.IsEmpty()) |
| filters.SetReferenceBox(reference_box_); |
| |
| return filters; |
| } |
| |
| Filter* FilterEffectBuilder::BuildReferenceFilter( |
| const ReferenceFilterOperation& reference_operation, |
| FilterEffect* previous_effect) const { |
| SVGResource* resource = reference_operation.Resource(); |
| if (auto* filter = |
| ToSVGFilterElementOrNull(resource ? resource->Target() : nullptr)) |
| return BuildReferenceFilter(*filter, previous_effect); |
| return nullptr; |
| } |
| |
| Filter* FilterEffectBuilder::BuildReferenceFilter( |
| SVGFilterElement& filter_element, |
| FilterEffect* previous_effect, |
| SVGFilterGraphNodeMap* node_map) const { |
| FloatRect filter_region = |
| SVGLengthContext::ResolveRectangle<SVGFilterElement>( |
| &filter_element, |
| filter_element.filterUnits()->CurrentValue()->EnumValue(), |
| reference_box_); |
| // TODO(fs): We rely on the presence of a node map here to opt-in to the |
| // check for an empty filter region. The reason for this is that we lack a |
| // viewport to resolve against for HTML content. This is crbug.com/512453. |
| if (node_map && filter_region.IsEmpty()) |
| return nullptr; |
| |
| bool primitive_bounding_box_mode = |
| filter_element.primitiveUnits()->CurrentValue()->EnumValue() == |
| SVGUnitTypes::kSvgUnitTypeObjectboundingbox; |
| Filter::UnitScaling unit_scaling = |
| primitive_bounding_box_mode ? Filter::kBoundingBox : Filter::kUserSpace; |
| Filter* result = |
| Filter::Create(reference_box_, filter_region, zoom_, unit_scaling); |
| if (!previous_effect) |
| previous_effect = result->GetSourceGraphic(); |
| SVGFilterBuilder builder(previous_effect, node_map, fill_flags_, |
| stroke_flags_); |
| builder.BuildGraph(result, filter_element, reference_box_); |
| result->SetLastEffect(builder.LastEffect()); |
| return result; |
| } |
| |
| } // namespace blink |
