src/third_party/WebKit/Source/core/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
  26 #include "core/rendering/svg/RenderSVGResourceFilter.h"
  27
  28 #include "core/frame/Settings.h"
  29 #include "core/rendering/svg/RenderSVGResourceFilterPrimitive.h"
  30 #include "core/rendering/svg/SVGRenderingContext.h"
  31 #include "core/svg/SVGFilterPrimitiveStandardAttributes.h"
  32 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
  33 #include "platform/graphics/filters/SkiaImageFilterBuilder.h"
  34 #include "platform/graphics/filters/SourceAlpha.h"
  35 #include "platform/graphics/filters/SourceGraphic.h"
  36
  37 using namespace std;
  38
  39 namespace WebCore {
  40
  41 const RenderSVGResourceType RenderSVGResourceFilter::s_resourceType = FilterResourceType;
  42
  43 RenderSVGResourceFilter::RenderSVGResourceFilter(SVGFilterElement* node)
  44     : RenderSVGResourceContainer(node)
  45 {
  46 }
  47
  48 RenderSVGResourceFilter::~RenderSVGResourceFilter()
  49 {
  50     m_filter.clear();
  51 }
  52
  53 bool RenderSVGResourceFilter::isChildAllowed(RenderObject* child, RenderStyle*) const
  54 {
  55     return child->isSVGResourceFilterPrimitive();
  56 }
  57
  58 void RenderSVGResourceFilter::removeAllClientsFromCache(bool markForInvalidation)
  59 {
  60     m_filter.clear();
  61     markAllClientsForInvalidation(markForInvalidation ? LayoutAndBoundariesInvalidation : ParentOnlyInvalidation);
  62 }
  63
  64 void RenderSVGResourceFilter::removeClientFromCache(RenderObject* client, bool markForInvalidation)
  65 {
  66     ASSERT(client);
  67
  68     if (FilterData* filterData = m_filter.get(client)) {
  69         if (filterData->savedContext)
  70             filterData->state = FilterData::MarkedForRemoval;
  71         else
  72             m_filter.remove(client);
  73     }
  74
  75     markClientForInvalidation(client, markForInvalidation ? BoundariesInvalidation : ParentOnlyInvalidation);
  76 }
  77
  78 PassRefPtr<SVGFilterBuilder> RenderSVGResourceFilter::buildPrimitives(SVGFilter* filter)
  79 {
  80     SVGFilterElement* filterElement = toSVGFilterElement(element());
  81     FloatRect targetBoundingBox = filter->targetBoundingBox();
  82
  83     // Add effects to the builder
  84     RefPtr<SVGFilterBuilder> builder = SVGFilterBuilder::create(SourceGraphic::create(filter), SourceAlpha::create(filter));
  85     for (SVGElement* element = Traversal<SVGElement>::firstChild(*filterElement); element; element = Traversal<SVGElement>::nextSibling(*element)) {
  86         if (!element->isFilterEffect() || !element->renderer())
  87             continue;
  88
  89         SVGFilterPrimitiveStandardAttributes* effectElement = static_cast<SVGFilterPrimitiveStandardAttributes*>(element);
  90         RefPtr<FilterEffect> effect = effectElement->build(builder.get(), filter);
  91         if (!effect) {
  92             builder->clearEffects();
  93             return nullptr;
  94         }
  95         builder->appendEffectToEffectReferences(effect, effectElement->renderer());
  96         effectElement->setStandardAttributes(effect.get());
  97         effect->setEffectBoundaries(SVGLengthContext::resolveRectangle<SVGFilterPrimitiveStandardAttributes>(effectElement, filterElement->primitiveUnits()->currentValue()->enumValue(), targetBoundingBox));
  98         effect->setOperatingColorSpace(
  99             effectElement->renderer()->style()->svgStyle()->colorInterpolationFilters() == CI_LINEARRGB ? ColorSpaceLinearRGB : ColorSpaceDeviceRGB);
 100         builder->add(AtomicString(effectElement->result()->currentValue()->value()), effect);
 101     }
 102     return builder.release();
 103 }
 104
 105 void RenderSVGResourceFilter::adjustScaleForMaximumImageSize(const FloatSize& size, FloatSize& filterScale)
 106 {
 107     FloatSize scaledSize(size);
 108     scaledSize.scale(filterScale.width(), filterScale.height());
 109     float scaledArea = scaledSize.width() * scaledSize.height();
 110
 111     if (scaledArea <= FilterEffect::maxFilterArea())
 112         return;
 113
 114     // If area of scaled size is bigger than the upper limit, adjust the scale
 115     // to fit.
 116     filterScale.scale(sqrt(FilterEffect::maxFilterArea() / scaledArea));
 117 }
 118
 119 static bool createImageBuffer(const Filter* filter, OwnPtr<ImageBuffer>& imageBuffer)
 120 {
 121     IntRect paintRect = filter->sourceImageRect();
 122     // Don't create empty ImageBuffers.
 123     if (paintRect.isEmpty())
 124         return false;
 125
 126     OwnPtr<ImageBufferSurface> surface = adoptPtr(new UnacceleratedImageBufferSurface(paintRect.size()));
 127     if (!surface->isValid())
 128         return false;
 129     OwnPtr<ImageBuffer> image = ImageBuffer::create(surface.release());
 130
 131     GraphicsContext* imageContext = image->context();
 132     ASSERT(imageContext);
 133
 134     imageContext->translate(-paintRect.x(), -paintRect.y());
 135     imageContext->concatCTM(filter->absoluteTransform());
 136     imageBuffer = image.release();
 137     return true;
 138 }
 139
 140 static void beginDeferredFilter(GraphicsContext* context, FilterData* filterData, SVGFilterElement* filterElement)
 141 {
 142     SkiaImageFilterBuilder builder(context);
 143     RefPtr<ImageFilter> imageFilter = builder.build(filterData->builder->lastEffect(), ColorSpaceDeviceRGB);
 144     filterData->filter->beginApply(context);
 145     FloatRect boundaries = enclosingIntRect(filterData->boundaries);
 146     context->save();
 147     // Clip drawing of filtered image to primitive boundaries.
 148     context->clipRect(boundaries);
 149     if (filterElement->hasAttribute(SVGNames::filterResAttr)) {
 150         // Get boundaries in device coords.
 151         FloatSize size = context->getCTM().mapSize(boundaries.size());
 152         // Compute the scale amount required so that the resulting offscreen is exactly filterResX by filterResY pixels.
 153         FloatSize filterResScale(
 154             filterElement->filterResX()->currentValue()->value() / size.width(),
 155             filterElement->filterResY()->currentValue()->value() / size.height());
 156         // Scale the CTM so the primitive is drawn to filterRes.
 157         context->scale(filterResScale);
 158         // Create a resize filter with the inverse scale.
 159         AffineTransform resizeMatrix;
 160         resizeMatrix.scale(1 / filterResScale.width(), 1 / filterResScale.height());
 161         imageFilter = builder.buildTransform(resizeMatrix, imageFilter.get());
 162     }
 163     // If the CTM contains rotation or shearing, apply the filter to
 164     // the unsheared/unrotated matrix, and do the shearing/rotation
 165     // as a final pass.
 166     AffineTransform ctm = context->getCTM();
 167     if (ctm.b() || ctm.c()) {
 168         AffineTransform scaleAndTranslate;
 169         scaleAndTranslate.translate(ctm.e(), ctm.f());
 170         scaleAndTranslate.scale(ctm.xScale(), ctm.yScale());
 171         ASSERT(scaleAndTranslate.isInvertible());
 172         AffineTransform shearAndRotate = scaleAndTranslate.inverse();
 173         shearAndRotate.multiply(ctm);
 174         context->setCTM(scaleAndTranslate);
 175         imageFilter = builder.buildTransform(shearAndRotate, imageFilter.get());
 176     }
 177     context->beginLayer(1, CompositeSourceOver, &boundaries, ColorFilterNone, imageFilter.get());
 178 }
 179
 180 static void endDeferredFilter(GraphicsContext* context, FilterData* filterData)
 181 {
 182     context->endLayer();
 183     context->restore();
 184     filterData->filter->endApply(context);
 185 }
 186
 187 bool RenderSVGResourceFilter::applyResource(RenderObject* object, RenderStyle*, GraphicsContext*& context, unsigned short resourceMode)
 188 {
 189     ASSERT(object);
 190     ASSERT(context);
 191     ASSERT_UNUSED(resourceMode, resourceMode == ApplyToDefaultMode);
 192
 193     clearInvalidationMask();
 194
 195     bool deferredFiltersEnabled = object->document().settings()->deferredFiltersEnabled();
 196     if (m_filter.contains(object)) {
 197         FilterData* filterData = m_filter.get(object);
 198         if (filterData->state == FilterData::PaintingSource || filterData->state == FilterData::Applying)
 199             filterData->state = FilterData::CycleDetected;
 200         if (deferredFiltersEnabled && filterData->state == FilterData::Built) {
 201             SVGFilterElement* filterElement = toSVGFilterElement(element());
 202             beginDeferredFilter(context, filterData, filterElement);
 203             return true;
 204         }
 205         return false; // Already built, or we're in a cycle, or we're marked for removal. Regardless, just do nothing more now.
 206     }
 207
 208     OwnPtr<FilterData> filterData(adoptPtr(new FilterData));
 209     FloatRect targetBoundingBox = object->objectBoundingBox();
 210
 211     SVGFilterElement* filterElement = toSVGFilterElement(element());
 212     filterData->boundaries = SVGLengthContext::resolveRectangle<SVGFilterElement>(filterElement, filterElement->filterUnits()->currentValue()->enumValue(), targetBoundingBox);
 213     if (filterData->boundaries.isEmpty())
 214         return false;
 215
 216     // Determine absolute transformation matrix for filter.
 217     AffineTransform absoluteTransform;
 218     SVGRenderingContext::calculateDeviceSpaceTransformation(object, absoluteTransform);
 219     if (!absoluteTransform.isInvertible())
 220         return false;
 221
 222     // Filters cannot handle a full transformation, only scales in each direction.
 223     FloatSize filterScale;
 224
 225     // Calculate the scale factor for the filter.
 226     // Also see http://www.w3.org/TR/SVG/filters.html#FilterEffectsRegion
 227     if (filterElement->hasAttribute(SVGNames::filterResAttr)) {
 228         //  If resolution is specified, scale to match it.
 229         filterScale = FloatSize(
 230             filterElement->filterResX()->currentValue()->value() / filterData->boundaries.width(),
 231             filterElement->filterResY()->currentValue()->value() / filterData->boundaries.height());
 232     } else {
 233         // Otherwise, use the scale of the absolute transform.
 234         filterScale = FloatSize(absoluteTransform.xScale(), absoluteTransform.yScale());
 235     }
 236     // The size of the scaled filter boundaries shouldn't be bigger than kMaxFilterSize.
 237     // Intermediate filters are limited by the filter boundaries so they can't be bigger than this.
 238     adjustScaleForMaximumImageSize(filterData->boundaries.size(), filterScale);
 239
 240     filterData->drawingRegion = object->strokeBoundingBox();
 241     filterData->drawingRegion.intersect(filterData->boundaries);
 242     FloatRect absoluteDrawingRegion = filterData->drawingRegion;
 243     if (!deferredFiltersEnabled)
 244         absoluteDrawingRegion.scale(filterScale.width(), filterScale.height());
 245
 246     IntRect intDrawingRegion = enclosingIntRect(absoluteDrawingRegion);
 247
 248     // Create the SVGFilter object.
 249     bool primitiveBoundingBoxMode = filterElement->primitiveUnits()->currentValue()->enumValue() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX;
 250     filterData->shearFreeAbsoluteTransform = AffineTransform();
 251     if (!deferredFiltersEnabled)
 252         filterData->shearFreeAbsoluteTransform.scale(filterScale.width(), filterScale.height());
 253     filterData->filter = SVGFilter::create(filterData->shearFreeAbsoluteTransform, intDrawingRegion, targetBoundingBox, filterData->boundaries, primitiveBoundingBoxMode);
 254
 255     // Create all relevant filter primitives.
 256     filterData->builder = buildPrimitives(filterData->filter.get());
 257     if (!filterData->builder)
 258         return false;
 259
 260     FilterEffect* lastEffect = filterData->builder->lastEffect();
 261     if (!lastEffect)
 262         return false;
 263
 264     lastEffect->determineFilterPrimitiveSubregion(ClipToFilterRegion);
 265
 266     if (deferredFiltersEnabled) {
 267         FilterData* data = filterData.get();
 268         m_filter.set(object, filterData.release());
 269         beginDeferredFilter(context, data, filterElement);
 270         return true;
 271     }
 272
 273     // If the drawingRegion is empty, we have something like <g filter=".."/>.
 274     // Even if the target objectBoundingBox() is empty, we still have to draw the last effect result image in postApplyResource.
 275     if (filterData->drawingRegion.isEmpty()) {
 276         ASSERT(!m_filter.contains(object));
 277         filterData->savedContext = context;
 278         m_filter.set(object, filterData.release());
 279         return false;
 280     }
 281
 282     OwnPtr<ImageBuffer> sourceGraphic;
 283     if (!createImageBuffer(filterData->filter.get(), sourceGraphic)) {
 284         ASSERT(!m_filter.contains(object));
 285         filterData->savedContext = context;
 286         m_filter.set(object, filterData.release());
 287         return false;
 288     }
 289
 290     GraphicsContext* sourceGraphicContext = sourceGraphic->context();
 291     ASSERT(sourceGraphicContext);
 292
 293     filterData->sourceGraphicBuffer = sourceGraphic.release();
 294     filterData->savedContext = context;
 295
 296     context = sourceGraphicContext;
 297
 298     ASSERT(!m_filter.contains(object));
 299     m_filter.set(object, filterData.release());
 300
 301     return true;
 302 }
 303
 304 void RenderSVGResourceFilter::postApplyResource(RenderObject* object, GraphicsContext*& context, unsigned short resourceMode, const Path*, const RenderSVGShape*)
 305 {
 306     ASSERT(object);
 307     ASSERT(context);
 308     ASSERT_UNUSED(resourceMode, resourceMode == ApplyToDefaultMode);
 309
 310     FilterData* filterData = m_filter.get(object);
 311     if (!filterData)
 312         return;
 313
 314     if (object->document().settings()->deferredFiltersEnabled() && (filterData->state == FilterData::PaintingSource || filterData->state == FilterData::Built)) {
 315         endDeferredFilter(context, filterData);
 316         filterData->state = FilterData::Built;
 317         return;
 318     }
 319
 320     switch (filterData->state) {
 321     case FilterData::MarkedForRemoval:
 322         m_filter.remove(object);
 323         return;
 324
 325     case FilterData::CycleDetected:
 326     case FilterData::Applying:
 327         // We have a cycle if we are already applying the data.
 328         // This can occur due to FeImage referencing a source that makes use of the FEImage itself.
 329         // This is the first place we've hit the cycle, so set the state back to PaintingSource so the return stack
 330         // will continue correctly.
 331         filterData->state = FilterData::PaintingSource;
 332         return;
 333
 334     case FilterData::PaintingSource:
 335         if (!filterData->savedContext) {
 336             removeClientFromCache(object);
 337             return;
 338         }
 339
 340         context = filterData->savedContext;
 341         filterData->savedContext = 0;
 342         break;
 343
 344     case FilterData::Built: { } // Empty
 345     }
 346
 347     FilterEffect* lastEffect = filterData->builder->lastEffect();
 348
 349     if (lastEffect && !filterData->boundaries.isEmpty() && !lastEffect->filterPrimitiveSubregion().isEmpty()) {
 350         // This is the real filtering of the object. It just needs to be called on the
 351         // initial filtering process. We just take the stored filter result on a
 352         // second drawing.
 353         if (filterData->state != FilterData::Built)
 354             filterData->filter->setSourceImage(filterData->sourceGraphicBuffer.release());
 355
 356         // Always true if filterData is just built (filterData->state == FilterData::Built).
 357         if (!lastEffect->hasResult()) {
 358             filterData->state = FilterData::Applying;
 359             lastEffect->apply();
 360             lastEffect->correctFilterResultIfNeeded();
 361             lastEffect->transformResultColorSpace(ColorSpaceDeviceRGB);
 362         }
 363         filterData->state = FilterData::Built;
 364
 365         ImageBuffer* resultImage = lastEffect->asImageBuffer();
 366         if (resultImage) {
 367             context->drawImageBuffer(resultImage, filterData->filter->mapAbsoluteRectToLocalRect(lastEffect->absolutePaintRect()));
 368         }
 369     }
 370     filterData->sourceGraphicBuffer.clear();
 371 }
 372
 373 FloatRect RenderSVGResourceFilter::resourceBoundingBox(const RenderObject* object)
 374 {
 375     if (SVGFilterElement* element = toSVGFilterElement(this->element()))
 376         return SVGLengthContext::resolveRectangle<SVGFilterElement>(element, element->filterUnits()->currentValue()->enumValue(), object->objectBoundingBox());
 377
 378     return FloatRect();
 379 }
 380
 381 void RenderSVGResourceFilter::primitiveAttributeChanged(RenderObject* object, const QualifiedName& attribute)
 382 {
 383     FilterMap::iterator it = m_filter.begin();
 384     FilterMap::iterator end = m_filter.end();
 385     SVGFilterPrimitiveStandardAttributes* primitve = static_cast<SVGFilterPrimitiveStandardAttributes*>(object->node());
 386
 387     for (; it != end; ++it) {
 388         FilterData* filterData = it->value.get();
 389         if (filterData->state != FilterData::Built)
 390             continue;
 391
 392         SVGFilterBuilder* builder = filterData->builder.get();
 393         FilterEffect* effect = builder->effectByRenderer(object);
 394         if (!effect)
 395             continue;
 396         // Since all effects shares the same attribute value, all
 397         // or none of them will be changed.
 398         if (!primitve->setFilterEffectAttribute(effect, attribute))
 399             return;
 400         builder->clearResultsRecursive(effect);
 401
 402         // Repaint the image on the screen.
 403         markClientForInvalidation(it->key, RepaintInvalidation);
 404     }
 405     markAllClientLayersForInvalidation();
 406 }
 407
 408 FloatRect RenderSVGResourceFilter::drawingRegion(RenderObject* object) const
 409 {
 410     FilterData* filterData = m_filter.get(object);
 411     return filterData ? filterData->drawingRegion : FloatRect();
 412 }
 413
 414 }