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