Source/WebCore/rendering/svg/RenderSVGResourceFilter.cpp

   1 /*
   2  * Copyright (C) 2004, 2005, 2006, 2007 Nikolas Zimmermann <zimmermann@kde.org>
   3  * Copyright (C) 2004, 2005 Rob Buis <buis@kde.org>
   4  * Copyright (C) 2005 Eric Seidel <eric@webkit.org>
   5  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
   6  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public License
  19  * along with this library; see the file COPYING.LIB.  If not, write to
  20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21  * Boston, MA 02110-1301, USA.
  22  */
  23
  24 #include "config.h"
  25 #include "RenderSVGResourceFilter.h"
  26
  27 #include "ElementChildIterator.h"
  28 #include "FilterEffect.h"
  29 #include "FloatPoint.h"
  30 #include "Frame.h"
  31 #include "GraphicsContext.h"
  32 #include "Image.h"
  33 #include "ImageData.h"
  34 #include "IntRect.h"
  35 #include "Page.h"
  36 #include "RenderSVGResourceFilterPrimitive.h"
  37 #include "RenderView.h"
  38 #include "SVGFilterPrimitiveStandardAttributes.h"
  39 #include "SVGNames.h"
  40 #include "SVGRenderingContext.h"
  41 #include "Settings.h"
  42 #include "SourceGraphic.h"
  43
  44 namespace WebCore {
  45
  46 RenderSVGResourceFilter::RenderSVGResourceFilter(SVGFilterElement& element, Ref<RenderStyle>&& style)
  47     : RenderSVGResourceContainer(element, WTF::move(style))
  48 {
  49 }
  50
  51 RenderSVGResourceFilter::~RenderSVGResourceFilter()
  52 {
  53 }
  54
  55 void RenderSVGResourceFilter::removeAllClientsFromCache(bool markForInvalidation)
  56 {
  57     m_filter.clear();
  58
  59     markAllClientsForInvalidation(markForInvalidation ? LayoutAndBoundariesInvalidation : ParentOnlyInvalidation);
  60 }
  61
  62 void RenderSVGResourceFilter::removeClientFromCache(RenderElement& client, bool markForInvalidation)
  63 {
  64     if (FilterData* filterData = m_filter.get(&client)) {
  65         if (filterData->savedContext)
  66             filterData->state = FilterData::MarkedForRemoval;
  67         else
  68             m_filter.remove(&client);
  69     }
  70
  71     markClientForInvalidation(client, markForInvalidation ? BoundariesInvalidation : ParentOnlyInvalidation);
  72 }
  73
  74 std::unique_ptr<SVGFilterBuilder> RenderSVGResourceFilter::buildPrimitives(SVGFilter& filter) const
  75 {
  76     static const unsigned maxCountChildNodes = 200;
  77     if (filterElement().countChildNodes() > maxCountChildNodes)
  78         return nullptr;
  79
  80     FloatRect targetBoundingBox = filter.targetBoundingBox();
  81
  82     // Add effects to the builder
  83     auto builder = std::make_unique<SVGFilterBuilder>(SourceGraphic::create(filter));
  84     for (auto& element : childrenOfType<SVGFilterPrimitiveStandardAttributes>(filterElement())) {
  85         RefPtr<FilterEffect> effect = element.build(builder.get(), filter);
  86         if (!effect) {
  87             builder->clearEffects();
  88             return nullptr;
  89         }
  90         builder->appendEffectToEffectReferences(effect, element.renderer());
  91         element.setStandardAttributes(effect.get());
  92         effect->setEffectBoundaries(SVGLengthContext::resolveRectangle<SVGFilterPrimitiveStandardAttributes>(&element, filterElement().primitiveUnits(), targetBoundingBox));
  93         effect->setOperatingColorSpace(element.renderer()->style().svgStyle().colorInterpolationFilters() == CI_LINEARRGB ? ColorSpaceLinearRGB : ColorSpaceDeviceRGB);
  94         builder->add(element.result(), effect.release());
  95     }
  96     return builder;
  97 }
  98
  99 bool RenderSVGResourceFilter::fitsInMaximumImageSize(const FloatSize& size, FloatSize& scale)
 100 {
 101     FloatSize scaledSize(size);
 102     scaledSize.scale(scale.width(), scale.height());
 103     float scaledArea = scaledSize.width() * scaledSize.height();
 104
 105     if (scaledArea <= FilterEffect::maxFilterArea())
 106         return true;
 107
 108     // If area of scaled size is bigger than the upper limit, adjust the scale
 109     // to fit.
 110     scale.scale(sqrt(FilterEffect::maxFilterArea() / scaledArea));
 111     return false;
 112 }
 113
 114 bool RenderSVGResourceFilter::applyResource(RenderElement& renderer, const RenderStyle&, GraphicsContext*& context, unsigned short resourceMode)
 115 {
 116     ASSERT(context);
 117     ASSERT_UNUSED(resourceMode, resourceMode == ApplyToDefaultMode);
 118
 119     if (m_filter.contains(&renderer)) {
 120         FilterData* filterData = m_filter.get(&renderer);
 121         if (filterData->state == FilterData::PaintingSource || filterData->state == FilterData::Applying)
 122             filterData->state = FilterData::CycleDetected;
 123         return false; // Already built, or we're in a cycle, or we're marked for removal. Regardless, just do nothing more now.
 124     }
 125
 126     auto filterData = std::make_unique<FilterData>();
 127     FloatRect targetBoundingBox = renderer.objectBoundingBox();
 128
 129     filterData->boundaries = SVGLengthContext::resolveRectangle<SVGFilterElement>(&filterElement(), filterElement().filterUnits(), targetBoundingBox);
 130     if (filterData->boundaries.isEmpty())
 131         return false;
 132
 133     // Determine absolute transformation matrix for filter.
 134     AffineTransform absoluteTransform;
 135     SVGRenderingContext::calculateTransformationToOutermostCoordinateSystem(renderer, absoluteTransform);
 136     if (!absoluteTransform.isInvertible())
 137         return false;
 138
 139     // Eliminate shear of the absolute transformation matrix, to be able to produce unsheared tile images for feTile.
 140     filterData->shearFreeAbsoluteTransform = AffineTransform(absoluteTransform.xScale(), 0, 0, absoluteTransform.yScale(), 0, 0);
 141
 142     // Determine absolute boundaries of the filter and the drawing region.
 143     FloatRect absoluteFilterBoundaries = filterData->shearFreeAbsoluteTransform.mapRect(filterData->boundaries);
 144     filterData->drawingRegion = renderer.strokeBoundingBox();
 145     filterData->drawingRegion.intersect(filterData->boundaries);
 146     FloatRect absoluteDrawingRegion = filterData->shearFreeAbsoluteTransform.mapRect(filterData->drawingRegion);
 147
 148     // Create the SVGFilter object.
 149     bool primitiveBoundingBoxMode = filterElement().primitiveUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX;
 150     filterData->filter = SVGFilter::create(filterData->shearFreeAbsoluteTransform, absoluteDrawingRegion, targetBoundingBox, filterData->boundaries, primitiveBoundingBoxMode);
 151
 152     // Create all relevant filter primitives.
 153     filterData->builder = buildPrimitives(*filterData->filter);
 154     if (!filterData->builder)
 155         return false;
 156
 157     // Calculate the scale factor for the use of filterRes.
 158     // Also see http://www.w3.org/TR/SVG/filters.html#FilterEffectsRegion
 159     FloatSize scale(1, 1);
 160     if (filterElement().hasAttribute(SVGNames::filterResAttr)) {
 161         scale.setWidth(filterElement().filterResX() / absoluteFilterBoundaries.width());
 162         scale.setHeight(filterElement().filterResY() / absoluteFilterBoundaries.height());
 163     }
 164
 165     if (scale.isEmpty())
 166         return false;
 167
 168     // Determine scale factor for filter. The size of intermediate ImageBuffers shouldn't be bigger than kMaxFilterSize.
 169     FloatRect tempSourceRect = absoluteDrawingRegion;
 170     tempSourceRect.scale(scale.width(), scale.height());
 171     fitsInMaximumImageSize(tempSourceRect.size(), scale);
 172
 173     // Set the scale level in SVGFilter.
 174     filterData->filter->setFilterResolution(scale);
 175
 176     static const unsigned maxTotalOfEffectInputs = 100;
 177     FilterEffect* lastEffect = filterData->builder->lastEffect();
 178     if (!lastEffect || lastEffect->totalNumberOfEffectInputs() > maxTotalOfEffectInputs)
 179         return false;
 180
 181     RenderSVGResourceFilterPrimitive::determineFilterPrimitiveSubregion(*lastEffect);
 182     FloatRect subRegion = lastEffect->maxEffectRect();
 183     // At least one FilterEffect has a too big image size,
 184     // recalculate the effect sizes with new scale factors.
 185     if (!fitsInMaximumImageSize(subRegion.size(), scale)) {
 186         filterData->filter->setFilterResolution(scale);
 187         RenderSVGResourceFilterPrimitive::determineFilterPrimitiveSubregion(*lastEffect);
 188     }
 189
 190     // If the drawingRegion is empty, we have something like <g filter=".."/>.
 191     // Even if the target objectBoundingBox() is empty, we still have to draw the last effect result image in postApplyResource.
 192     if (filterData->drawingRegion.isEmpty()) {
 193         ASSERT(!m_filter.contains(&renderer));
 194         filterData->savedContext = context;
 195         m_filter.set(&renderer, WTF::move(filterData));
 196         return false;
 197     }
 198
 199     // Change the coordinate transformation applied to the filtered element to reflect the resolution of the filter.
 200     AffineTransform effectiveTransform;
 201     effectiveTransform.scale(scale.width(), scale.height());
 202     effectiveTransform.multiply(filterData->shearFreeAbsoluteTransform);
 203
 204     std::unique_ptr<ImageBuffer> sourceGraphic;
 205     RenderingMode renderingMode = renderer.frame().settings().acceleratedFiltersEnabled() ? Accelerated : Unaccelerated;
 206     if (!SVGRenderingContext::createImageBuffer(filterData->drawingRegion, effectiveTransform, sourceGraphic, ColorSpaceLinearRGB, renderingMode)) {
 207         ASSERT(!m_filter.contains(&renderer));
 208         filterData->savedContext = context;
 209         m_filter.set(&renderer, WTF::move(filterData));
 210         return false;
 211     }
 212
 213     // Set the rendering mode from the page's settings.
 214     filterData->filter->setRenderingMode(renderingMode);
 215
 216     GraphicsContext* sourceGraphicContext = sourceGraphic->context();
 217     ASSERT(sourceGraphicContext);
 218
 219     filterData->sourceGraphicBuffer = WTF::move(sourceGraphic);
 220     filterData->savedContext = context;
 221
 222     context = sourceGraphicContext;
 223
 224     ASSERT(!m_filter.contains(&renderer));
 225     m_filter.set(&renderer, WTF::move(filterData));
 226
 227     return true;
 228 }
 229
 230 void RenderSVGResourceFilter::postApplyResource(RenderElement& renderer, GraphicsContext*& context, unsigned short resourceMode, const Path*, const RenderSVGShape*)
 231 {
 232     ASSERT(context);
 233     ASSERT_UNUSED(resourceMode, resourceMode == ApplyToDefaultMode);
 234
 235     FilterData* filterData = m_filter.get(&renderer);
 236     if (!filterData)
 237         return;
 238
 239     switch (filterData->state) {
 240     case FilterData::MarkedForRemoval:
 241         m_filter.remove(&renderer);
 242         return;
 243
 244     case FilterData::CycleDetected:
 245     case FilterData::Applying:
 246         // We have a cycle if we are already applying the data.
 247         // This can occur due to FeImage referencing a source that makes use of the FEImage itself.
 248         // This is the first place we've hit the cycle, so set the state back to PaintingSource so the return stack
 249         // will continue correctly.
 250         filterData->state = FilterData::PaintingSource;
 251         return;
 252
 253     case FilterData::PaintingSource:
 254         if (!filterData->savedContext) {
 255             removeClientFromCache(renderer);
 256             return;
 257         }
 258
 259         context = filterData->savedContext;
 260         filterData->savedContext = 0;
 261         break;
 262
 263     case FilterData::Built: { } // Empty
 264     }
 265
 266     FilterEffect* lastEffect = filterData->builder->lastEffect();
 267
 268     if (lastEffect && !filterData->boundaries.isEmpty() && !lastEffect->filterPrimitiveSubregion().isEmpty()) {
 269         // This is the real filtering of the object. It just needs to be called on the
 270         // initial filtering process. We just take the stored filter result on a
 271         // second drawing.
 272         if (filterData->state != FilterData::Built)
 273             filterData->filter->setSourceImage(WTF::move(filterData->sourceGraphicBuffer));
 274
 275         // Always true if filterData is just built (filterData->state == FilterData::Built).
 276         if (!lastEffect->hasResult()) {
 277             filterData->state = FilterData::Applying;
 278             lastEffect->applyAll();
 279             lastEffect->correctFilterResultIfNeeded();
 280             lastEffect->transformResultColorSpace(ColorSpaceDeviceRGB);
 281         }
 282         filterData->state = FilterData::Built;
 283
 284         ImageBuffer* resultImage = lastEffect->asImageBuffer();
 285         if (resultImage) {
 286             context->concatCTM(filterData->shearFreeAbsoluteTransform.inverse());
 287
 288             context->scale(FloatSize(1 / filterData->filter->filterResolution().width(), 1 / filterData->filter->filterResolution().height()));
 289             context->drawImageBuffer(resultImage, renderer.style().colorSpace(), lastEffect->absolutePaintRect());
 290             context->scale(filterData->filter->filterResolution());
 291
 292             context->concatCTM(filterData->shearFreeAbsoluteTransform);
 293         }
 294     }
 295     filterData->sourceGraphicBuffer.reset();
 296 }
 297
 298 FloatRect RenderSVGResourceFilter::resourceBoundingBox(const RenderObject& object)
 299 {
 300     return SVGLengthContext::resolveRectangle<SVGFilterElement>(&filterElement(), filterElement().filterUnits(), object.objectBoundingBox());
 301 }
 302
 303 void RenderSVGResourceFilter::primitiveAttributeChanged(RenderObject* object, const QualifiedName& attribute)
 304 {
 305     SVGFilterPrimitiveStandardAttributes* primitve = static_cast<SVGFilterPrimitiveStandardAttributes*>(object->node());
 306
 307     for (const auto& objectFilterDataPair : m_filter) {
 308         const auto& filterData = objectFilterDataPair.value;
 309         if (filterData->state != FilterData::Built)
 310             continue;
 311
 312         SVGFilterBuilder* builder = filterData->builder.get();
 313         FilterEffect* effect = builder->effectByRenderer(object);
 314         if (!effect)
 315             continue;
 316         // Since all effects shares the same attribute value, all
 317         // or none of them will be changed.
 318         if (!primitve->setFilterEffectAttribute(effect, attribute))
 319             return;
 320         builder->clearResultsRecursive(effect);
 321
 322         // Repaint the image on the screen.
 323         markClientForInvalidation(*objectFilterDataPair.key, RepaintInvalidation);
 324     }
 325     markAllClientLayersForInvalidation();
 326 }
 327
 328 FloatRect RenderSVGResourceFilter::drawingRegion(RenderObject* object) const
 329 {
 330     FilterData* filterData = m_filter.get(object);
 331     return filterData ? filterData->drawingRegion : FloatRect();
 332 }
 333
 334 }