code.vuplus.com Git - vuplus_webkit/blob - 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
  26 #if ENABLE(SVG) && ENABLE(FILTERS)
  27 #include "RenderSVGResourceFilter.h"
  28
  29 #include "AffineTransform.h"
  30 #include "FilterEffect.h"
  31 #include "FloatPoint.h"
  32 #include "FloatRect.h"
  33 #include "GraphicsContext.h"
  34 #include "Image.h"
  35 #include "ImageBuffer.h"
  36 #include "ImageData.h"
  37 #include "IntRect.h"
  38 #include "RenderSVGResource.h"
  39 #include "RenderSVGResourceFilterPrimitive.h"
  40 #include "SVGElement.h"
  41 #include "SVGFilter.h"
  42 #include "SVGFilterElement.h"
  43 #include "SVGFilterPrimitiveStandardAttributes.h"
  44 #include "SVGImageBufferTools.h"
  45 #include "SVGNames.h"
  46 #include "SVGStyledElement.h"
  47 #include "SVGUnitTypes.h"
  48
  49 #include <wtf/UnusedParam.h>
  50 #include <wtf/Vector.h>
  51
  52 using namespace std;
  53
  54 namespace WebCore {
  55
  56 RenderSVGResourceType RenderSVGResourceFilter::s_resourceType = FilterResourceType;
  57
  58 RenderSVGResourceFilter::RenderSVGResourceFilter(SVGFilterElement* node)
  59     : RenderSVGResourceContainer(node)
  60 {
  61 }
  62
  63 RenderSVGResourceFilter::~RenderSVGResourceFilter()
  64 {
  65     if (m_filter.isEmpty())
  66         return;
  67
  68     deleteAllValues(m_filter);
  69     m_filter.clear();
  70 }
  71
  72 void RenderSVGResourceFilter::removeAllClientsFromCache(bool markForInvalidation)
  73 {
  74     if (!m_filter.isEmpty()) {
  75         deleteAllValues(m_filter);
  76         m_filter.clear();
  77     }
  78
  79     markAllClientsForInvalidation(markForInvalidation ? LayoutAndBoundariesInvalidation : ParentOnlyInvalidation);
  80 }
  81
  82 void RenderSVGResourceFilter::removeClientFromCache(RenderObject* client, bool markForInvalidation)
  83 {
  84     ASSERT(client);
  85
  86     if (FilterData* filterData = m_filter.get(client)) {
  87         if (filterData->savedContext)
  88             filterData->markedForRemoval = true;
  89         else
  90             delete m_filter.take(client);
  91     }
  92
  93     markClientForInvalidation(client, markForInvalidation ? BoundariesInvalidation : ParentOnlyInvalidation);
  94 }
  95
  96 PassRefPtr<SVGFilterBuilder> RenderSVGResourceFilter::buildPrimitives(Filter* filter)
  97 {
  98     SVGFilterElement* filterElement = static_cast<SVGFilterElement*>(node());
  99     bool primitiveBoundingBoxMode = filterElement->primitiveUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX;
 100
 101     // Add effects to the builder
 102     RefPtr<SVGFilterBuilder> builder = SVGFilterBuilder::create(filter);
 103     for (Node* node = filterElement->firstChild(); node; node = node->nextSibling()) {
 104         if (!node->isSVGElement())
 105             continue;
 106
 107         SVGElement* element = static_cast<SVGElement*>(node);
 108         if (!element->isFilterEffect())
 109             continue;
 110
 111         SVGFilterPrimitiveStandardAttributes* effectElement = static_cast<SVGFilterPrimitiveStandardAttributes*>(element);
 112         RefPtr<FilterEffect> effect = effectElement->build(builder.get(), filter);
 113         if (!effect) {
 114             builder->clearEffects();
 115             return 0;
 116         }
 117         builder->appendEffectToEffectReferences(effect, effectElement->renderer());
 118         effectElement->setStandardAttributes(primitiveBoundingBoxMode, effect.get());
 119         builder->add(effectElement->result(), effect);
 120     }
 121     return builder.release();
 122 }
 123
 124 bool RenderSVGResourceFilter::fitsInMaximumImageSize(const FloatSize& size, FloatSize& scale)
 125 {
 126     bool matchesFilterSize = true;
 127     if (size.width() > kMaxFilterSize) {
 128         scale.setWidth(scale.width() * kMaxFilterSize / size.width());
 129         matchesFilterSize = false;
 130     }
 131     if (size.height() > kMaxFilterSize) {
 132         scale.setHeight(scale.height() * kMaxFilterSize / size.height());
 133         matchesFilterSize = false;
 134     }
 135
 136     return matchesFilterSize;
 137 }
 138
 139 bool RenderSVGResourceFilter::applyResource(RenderObject* object, RenderStyle*, GraphicsContext*& context, unsigned short resourceMode)
 140 {
 141     ASSERT(object);
 142     ASSERT(context);
 143 #ifndef NDEBUG
 144     ASSERT(resourceMode == ApplyToDefaultMode);
 145 #else
 146     UNUSED_PARAM(resourceMode);
 147 #endif
 148
 149     // Returning false here, to avoid drawings onto the context. We just want to
 150     // draw the stored filter output, not the unfiltered object as well.
 151     if (m_filter.contains(object)) {
 152         FilterData* filterData = m_filter.get(object);
 153         if (filterData->builded)
 154             return false;
 155
 156         delete m_filter.take(object); // Oops, have to rebuild, go through normal code path
 157     }
 158
 159     OwnPtr<FilterData> filterData(adoptPtr(new FilterData));
 160     FloatRect targetBoundingBox = object->objectBoundingBox();
 161
 162     SVGFilterElement* filterElement = static_cast<SVGFilterElement*>(node());
 163     filterData->boundaries = filterElement->filterBoundingBox(targetBoundingBox);
 164     if (filterData->boundaries.isEmpty())
 165         return false;
 166
 167     // Determine absolute transformation matrix for filter.
 168     AffineTransform absoluteTransform;
 169     SVGImageBufferTools::calculateTransformationToOutermostSVGCoordinateSystem(object, absoluteTransform);
 170     if (!absoluteTransform.isInvertible())
 171         return false;
 172
 173     // Eliminate shear of the absolute transformation matrix, to be able to produce unsheared tile images for feTile.
 174     filterData->shearFreeAbsoluteTransform = AffineTransform(absoluteTransform.xScale(), 0, 0, absoluteTransform.yScale(), 0, 0);
 175
 176     // Determine absolute boundaries of the filter and the drawing region.
 177     FloatRect absoluteFilterBoundaries = filterData->shearFreeAbsoluteTransform.mapRect(filterData->boundaries);
 178     FloatRect drawingRegion = object->strokeBoundingBox();
 179     drawingRegion.intersect(filterData->boundaries);
 180     FloatRect absoluteDrawingRegion = filterData->shearFreeAbsoluteTransform.mapRect(drawingRegion);
 181
 182     // Create the SVGFilter object.
 183     bool primitiveBoundingBoxMode = filterElement->primitiveUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX;
 184     filterData->filter = SVGFilter::create(filterData->shearFreeAbsoluteTransform, absoluteDrawingRegion, targetBoundingBox, filterData->boundaries, primitiveBoundingBoxMode);
 185
 186     // Create all relevant filter primitives.
 187     filterData->builder = buildPrimitives(filterData->filter.get());
 188     if (!filterData->builder)
 189         return false;
 190
 191     // Calculate the scale factor for the use of filterRes.
 192     // Also see http://www.w3.org/TR/SVG/filters.html#FilterEffectsRegion
 193     FloatSize scale(1, 1);
 194     if (filterElement->hasAttribute(SVGNames::filterResAttr)) {
 195         scale.setWidth(filterElement->filterResX() / absoluteFilterBoundaries.width());
 196         scale.setHeight(filterElement->filterResY() / absoluteFilterBoundaries.height());
 197     }
 198
 199     if (scale.isEmpty())
 200         return false;
 201
 202     // Determine scale factor for filter. The size of intermediate ImageBuffers shouldn't be bigger than kMaxFilterSize.
 203     FloatRect tempSourceRect = absoluteDrawingRegion;
 204     tempSourceRect.scale(scale.width(), scale.height());
 205     fitsInMaximumImageSize(tempSourceRect.size(), scale);
 206
 207     // Set the scale level in SVGFilter.
 208     filterData->filter->setFilterResolution(scale);
 209
 210     FilterEffect* lastEffect = filterData->builder->lastEffect();
 211     if (!lastEffect)
 212         return false;
 213
 214     RenderSVGResourceFilterPrimitive::determineFilterPrimitiveSubregion(lastEffect);
 215     FloatRect subRegion = lastEffect->maxEffectRect();
 216     // At least one FilterEffect has a too big image size,
 217     // recalculate the effect sizes with new scale factors.
 218     if (!fitsInMaximumImageSize(subRegion.size(), scale)) {
 219         filterData->filter->setFilterResolution(scale);
 220         RenderSVGResourceFilterPrimitive::determineFilterPrimitiveSubregion(lastEffect);
 221     }
 222
 223     // If the drawingRegion is empty, we have something like <g filter=".."/>.
 224     // Even if the target objectBoundingBox() is empty, we still have to draw the last effect result image in postApplyResource.
 225     if (drawingRegion.isEmpty()) {
 226         ASSERT(!m_filter.contains(object));
 227         filterData->savedContext = context;
 228         m_filter.set(object, filterData.leakPtr());
 229         return false;
 230     }
 231
 232     absoluteDrawingRegion.scale(scale.width(), scale.height());
 233
 234     OwnPtr<ImageBuffer> sourceGraphic;
 235     if (!SVGImageBufferTools::createImageBuffer(absoluteDrawingRegion, absoluteDrawingRegion, sourceGraphic, ColorSpaceLinearRGB)) {
 236         ASSERT(!m_filter.contains(object));
 237         filterData->savedContext = context;
 238         m_filter.set(object, filterData.leakPtr());
 239         return false;
 240     }
 241
 242     GraphicsContext* sourceGraphicContext = sourceGraphic->context();
 243     ASSERT(sourceGraphicContext);
 244
 245     sourceGraphicContext->translate(-absoluteDrawingRegion.x(), -absoluteDrawingRegion.y());
 246     if (scale.width() != 1 || scale.height() != 1)
 247         sourceGraphicContext->scale(scale);
 248
 249     sourceGraphicContext->concatCTM(filterData->shearFreeAbsoluteTransform);
 250     sourceGraphicContext->clearRect(FloatRect(FloatPoint(), absoluteDrawingRegion.size()));
 251     filterData->sourceGraphicBuffer = sourceGraphic.release();
 252     filterData->savedContext = context;
 253
 254     context = sourceGraphicContext;
 255
 256     ASSERT(!m_filter.contains(object));
 257     m_filter.set(object, filterData.leakPtr());
 258
 259     return true;
 260 }
 261
 262 void RenderSVGResourceFilter::postApplyResource(RenderObject* object, GraphicsContext*& context, unsigned short resourceMode, const Path*)
 263 {
 264     ASSERT(object);
 265     ASSERT(context);
 266 #ifndef NDEBUG
 267     ASSERT(resourceMode == ApplyToDefaultMode);
 268 #else
 269     UNUSED_PARAM(resourceMode);
 270 #endif
 271
 272     FilterData* filterData = m_filter.get(object);
 273     if (!filterData)
 274         return;
 275
 276     if (filterData->markedForRemoval) {
 277         delete m_filter.take(object);
 278         return;
 279     }
 280
 281     if (!filterData->builded) {
 282         if (!filterData->savedContext) {
 283             removeClientFromCache(object);
 284             return;
 285         }
 286
 287         context = filterData->savedContext;
 288         filterData->savedContext = 0;
 289 #if !USE(CG)
 290         if (filterData->sourceGraphicBuffer)
 291             filterData->sourceGraphicBuffer->transformColorSpace(ColorSpaceDeviceRGB, ColorSpaceLinearRGB);
 292 #endif
 293     }
 294
 295     FilterEffect* lastEffect = filterData->builder->lastEffect();
 296
 297     if (lastEffect && !filterData->boundaries.isEmpty() && !lastEffect->filterPrimitiveSubregion().isEmpty()) {
 298         // This is the real filtering of the object. It just needs to be called on the
 299         // initial filtering process. We just take the stored filter result on a
 300         // second drawing.
 301         if (!filterData->builded)
 302             filterData->filter->setSourceImage(filterData->sourceGraphicBuffer.release());
 303
 304         // Always true if filterData is just built (filterData->builded is false).
 305         if (!lastEffect->hasResult()) {
 306             lastEffect->apply();
 307 #if !USE(CG)
 308             ImageBuffer* resultImage = lastEffect->asImageBuffer();
 309             if (resultImage)
 310                 resultImage->transformColorSpace(ColorSpaceLinearRGB, ColorSpaceDeviceRGB);
 311 #endif
 312         }
 313         filterData->builded = true;
 314
 315         ImageBuffer* resultImage = lastEffect->asImageBuffer();
 316         if (resultImage) {
 317             context->concatCTM(filterData->shearFreeAbsoluteTransform.inverse());
 318
 319             context->scale(FloatSize(1 / filterData->filter->filterResolution().width(), 1 / filterData->filter->filterResolution().height()));
 320             context->clip(lastEffect->maxEffectRect());
 321             context->drawImageBuffer(resultImage, object->style()->colorSpace(), lastEffect->absolutePaintRect());
 322             context->scale(filterData->filter->filterResolution());
 323
 324             context->concatCTM(filterData->shearFreeAbsoluteTransform);
 325         }
 326     }
 327     filterData->sourceGraphicBuffer.clear();
 328 }
 329
 330 FloatRect RenderSVGResourceFilter::resourceBoundingBox(RenderObject* object)
 331 {
 332     if (SVGFilterElement* element = static_cast<SVGFilterElement*>(node()))
 333         return element->filterBoundingBox(object->objectBoundingBox());
 334
 335     return FloatRect();
 336 }
 337
 338 void RenderSVGResourceFilter::primitiveAttributeChanged(RenderObject* object, const QualifiedName& attribute)
 339 {
 340     HashMap<RenderObject*, FilterData*>::iterator it = m_filter.begin();
 341     HashMap<RenderObject*, FilterData*>::iterator end = m_filter.end();
 342     SVGFilterPrimitiveStandardAttributes* primitve = static_cast<SVGFilterPrimitiveStandardAttributes*>(object->node());
 343
 344     for (; it != end; ++it) {
 345         FilterData* filterData = it->second;
 346         if (!filterData->builded)
 347             continue;
 348
 349         SVGFilterBuilder* builder = filterData->builder.get();
 350         FilterEffect* effect = builder->effectByRenderer(object);
 351         if (!effect)
 352             continue;
 353         // Since all effects shares the same attribute value, all
 354         // or none of them will be changed.
 355         if (!primitve->setFilterEffectAttribute(effect, attribute))
 356             return;
 357         builder->clearResultsRecursive(effect);
 358
 359         // Repaint the image on the screen.
 360         markClientForInvalidation(it->first, RepaintInvalidation);
 361     }
 362 }
 363
 364 }
 365 #endif