1/*
2 * Copyright (C) 2011 Apple Inc. All rights reserved.
3 * Copyright (C) 2013 Google Inc. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
15 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
18 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27#include "config.h"
28
29#include "core/rendering/FilterEffectRenderer.h"
30
31#include "core/fetch/DocumentResource.h"
32#include "core/fetch/DocumentResourceReference.h"
33#include "core/frame/Settings.h"
34#include "core/page/Page.h"
35#include "core/rendering/RenderLayer.h"
36#include "core/rendering/RenderView.h"
37#include "core/rendering/svg/ReferenceFilterBuilder.h"
38#include "core/svg/SVGElement.h"
39#include "core/svg/SVGFilterPrimitiveStandardAttributes.h"
40#include "platform/FloatConversion.h"
41#include "platform/LengthFunctions.h"
42#include "platform/graphics/ColorSpace.h"
43#include "platform/graphics/UnacceleratedImageBufferSurface.h"
44#include "platform/graphics/filters/FEColorMatrix.h"
45#include "platform/graphics/filters/FEComponentTransfer.h"
46#include "platform/graphics/filters/FEDropShadow.h"
47#include "platform/graphics/filters/FEGaussianBlur.h"
48#include "platform/graphics/filters/SkiaImageFilterBuilder.h"
49#include "wtf/MathExtras.h"
50#include <algorithm>
51
52namespace blink {
53
54static inline void endMatrixRow(Vector<float>& parameters)
55{
56    parameters.append(0);
57    parameters.append(0);
58}
59
60static inline void lastMatrixRow(Vector<float>& parameters)
61{
62    parameters.append(0);
63    parameters.append(0);
64    parameters.append(0);
65    parameters.append(1);
66    parameters.append(0);
67}
68
69FilterEffectRenderer::FilterEffectRenderer()
70    : Filter(AffineTransform())
71    , m_graphicsBufferAttached(false)
72    , m_hasFilterThatMovesPixels(false)
73{
74    m_sourceGraphic = SourceGraphic::create(this);
75}
76
77FilterEffectRenderer::~FilterEffectRenderer()
78{
79}
80
81GraphicsContext* FilterEffectRenderer::inputContext()
82{
83    return sourceImage() ? sourceImage()->context() : 0;
84}
85
86bool FilterEffectRenderer::build(RenderObject* renderer, const FilterOperations& operations)
87{
88    m_hasFilterThatMovesPixels = operations.hasFilterThatMovesPixels();
89
90    // Inverse zoom the pre-zoomed CSS shorthand filters, so that they are in the same zoom as the unzoomed reference filters.
91    const RenderStyle* style = renderer->style();
92    float invZoom = style ? 1.0f / style->effectiveZoom() : 1.0f;
93
94    RefPtr<FilterEffect> previousEffect = m_sourceGraphic;
95    for (size_t i = 0; i < operations.operations().size(); ++i) {
96        RefPtr<FilterEffect> effect;
97        FilterOperation* filterOperation = operations.operations().at(i).get();
98        switch (filterOperation->type()) {
99        case FilterOperation::REFERENCE: {
100            effect = ReferenceFilterBuilder::build(this, renderer, previousEffect.get(), toReferenceFilterOperation(filterOperation));
101            break;
102        }
103        case FilterOperation::GRAYSCALE: {
104            Vector<float> inputParameters;
105            double oneMinusAmount = clampTo(1 - toBasicColorMatrixFilterOperation(filterOperation)->amount(), 0.0, 1.0);
106
107            // See https://dvcs.w3.org/hg/FXTF/raw-file/tip/filters/index.html#grayscaleEquivalent
108            // for information on parameters.
109
110            inputParameters.append(narrowPrecisionToFloat(0.2126 + 0.7874 * oneMinusAmount));
111            inputParameters.append(narrowPrecisionToFloat(0.7152 - 0.7152 * oneMinusAmount));
112            inputParameters.append(narrowPrecisionToFloat(0.0722 - 0.0722 * oneMinusAmount));
113            endMatrixRow(inputParameters);
114
115            inputParameters.append(narrowPrecisionToFloat(0.2126 - 0.2126 * oneMinusAmount));
116            inputParameters.append(narrowPrecisionToFloat(0.7152 + 0.2848 * oneMinusAmount));
117            inputParameters.append(narrowPrecisionToFloat(0.0722 - 0.0722 * oneMinusAmount));
118            endMatrixRow(inputParameters);
119
120            inputParameters.append(narrowPrecisionToFloat(0.2126 - 0.2126 * oneMinusAmount));
121            inputParameters.append(narrowPrecisionToFloat(0.7152 - 0.7152 * oneMinusAmount));
122            inputParameters.append(narrowPrecisionToFloat(0.0722 + 0.9278 * oneMinusAmount));
123            endMatrixRow(inputParameters);
124
125            lastMatrixRow(inputParameters);
126
127            effect = FEColorMatrix::create(this, FECOLORMATRIX_TYPE_MATRIX, inputParameters);
128            break;
129        }
130        case FilterOperation::SEPIA: {
131            Vector<float> inputParameters;
132            double oneMinusAmount = clampTo(1 - toBasicColorMatrixFilterOperation(filterOperation)->amount(), 0.0, 1.0);
133
134            // See https://dvcs.w3.org/hg/FXTF/raw-file/tip/filters/index.html#sepiaEquivalent
135            // for information on parameters.
136
137            inputParameters.append(narrowPrecisionToFloat(0.393 + 0.607 * oneMinusAmount));
138            inputParameters.append(narrowPrecisionToFloat(0.769 - 0.769 * oneMinusAmount));
139            inputParameters.append(narrowPrecisionToFloat(0.189 - 0.189 * oneMinusAmount));
140            endMatrixRow(inputParameters);
141
142            inputParameters.append(narrowPrecisionToFloat(0.349 - 0.349 * oneMinusAmount));
143            inputParameters.append(narrowPrecisionToFloat(0.686 + 0.314 * oneMinusAmount));
144            inputParameters.append(narrowPrecisionToFloat(0.168 - 0.168 * oneMinusAmount));
145            endMatrixRow(inputParameters);
146
147            inputParameters.append(narrowPrecisionToFloat(0.272 - 0.272 * oneMinusAmount));
148            inputParameters.append(narrowPrecisionToFloat(0.534 - 0.534 * oneMinusAmount));
149            inputParameters.append(narrowPrecisionToFloat(0.131 + 0.869 * oneMinusAmount));
150            endMatrixRow(inputParameters);
151
152            lastMatrixRow(inputParameters);
153
154            effect = FEColorMatrix::create(this, FECOLORMATRIX_TYPE_MATRIX, inputParameters);
155            break;
156        }
157        case FilterOperation::SATURATE: {
158            Vector<float> inputParameters;
159            inputParameters.append(narrowPrecisionToFloat(toBasicColorMatrixFilterOperation(filterOperation)->amount()));
160            effect = FEColorMatrix::create(this, FECOLORMATRIX_TYPE_SATURATE, inputParameters);
161            break;
162        }
163        case FilterOperation::HUE_ROTATE: {
164            Vector<float> inputParameters;
165            inputParameters.append(narrowPrecisionToFloat(toBasicColorMatrixFilterOperation(filterOperation)->amount()));
166            effect = FEColorMatrix::create(this, FECOLORMATRIX_TYPE_HUEROTATE, inputParameters);
167            break;
168        }
169        case FilterOperation::INVERT: {
170            BasicComponentTransferFilterOperation* componentTransferOperation = toBasicComponentTransferFilterOperation(filterOperation);
171            ComponentTransferFunction transferFunction;
172            transferFunction.type = FECOMPONENTTRANSFER_TYPE_TABLE;
173            Vector<float> transferParameters;
174            transferParameters.append(narrowPrecisionToFloat(componentTransferOperation->amount()));
175            transferParameters.append(narrowPrecisionToFloat(1 - componentTransferOperation->amount()));
176            transferFunction.tableValues = transferParameters;
177
178            ComponentTransferFunction nullFunction;
179            effect = FEComponentTransfer::create(this, transferFunction, transferFunction, transferFunction, nullFunction);
180            break;
181        }
182        case FilterOperation::OPACITY: {
183            ComponentTransferFunction transferFunction;
184            transferFunction.type = FECOMPONENTTRANSFER_TYPE_TABLE;
185            Vector<float> transferParameters;
186            transferParameters.append(0);
187            transferParameters.append(narrowPrecisionToFloat(toBasicComponentTransferFilterOperation(filterOperation)->amount()));
188            transferFunction.tableValues = transferParameters;
189
190            ComponentTransferFunction nullFunction;
191            effect = FEComponentTransfer::create(this, nullFunction, nullFunction, nullFunction, transferFunction);
192            break;
193        }
194        case FilterOperation::BRIGHTNESS: {
195            ComponentTransferFunction transferFunction;
196            transferFunction.type = FECOMPONENTTRANSFER_TYPE_LINEAR;
197            transferFunction.slope = narrowPrecisionToFloat(toBasicComponentTransferFilterOperation(filterOperation)->amount());
198            transferFunction.intercept = 0;
199
200            ComponentTransferFunction nullFunction;
201            effect = FEComponentTransfer::create(this, transferFunction, transferFunction, transferFunction, nullFunction);
202            break;
203        }
204        case FilterOperation::CONTRAST: {
205            ComponentTransferFunction transferFunction;
206            transferFunction.type = FECOMPONENTTRANSFER_TYPE_LINEAR;
207            float amount = narrowPrecisionToFloat(toBasicComponentTransferFilterOperation(filterOperation)->amount());
208            transferFunction.slope = amount;
209            transferFunction.intercept = -0.5 * amount + 0.5;
210
211            ComponentTransferFunction nullFunction;
212            effect = FEComponentTransfer::create(this, transferFunction, transferFunction, transferFunction, nullFunction);
213            break;
214        }
215        case FilterOperation::BLUR: {
216            float stdDeviation = floatValueForLength(toBlurFilterOperation(filterOperation)->stdDeviation(), 0) * invZoom;
217            effect = FEGaussianBlur::create(this, stdDeviation, stdDeviation);
218            break;
219        }
220        case FilterOperation::DROP_SHADOW: {
221            DropShadowFilterOperation* dropShadowOperation = toDropShadowFilterOperation(filterOperation);
222            float stdDeviation = dropShadowOperation->stdDeviation() * invZoom;
223            float x = dropShadowOperation->x() * invZoom;
224            float y = dropShadowOperation->y() * invZoom;
225            effect = FEDropShadow::create(this, stdDeviation, stdDeviation, x, y, dropShadowOperation->color(), 1);
226            break;
227        }
228        default:
229            break;
230        }
231
232        if (effect) {
233            if (filterOperation->type() != FilterOperation::REFERENCE) {
234                // Unlike SVG, filters applied here should not clip to their primitive subregions.
235                effect->setClipsToBounds(false);
236                effect->setOperatingColorSpace(ColorSpaceDeviceRGB);
237                effect->inputEffects().append(previousEffect);
238            }
239            previousEffect = effect.release();
240        }
241    }
242
243    // We need to keep the old effects alive until this point, so that SVG reference filters
244    // can share cached resources across frames.
245    m_lastEffect = previousEffect;
246
247    // If we didn't make any effects, tell our caller we are not valid
248    if (!m_lastEffect.get())
249        return false;
250
251    return true;
252}
253
254bool FilterEffectRenderer::updateBackingStoreRect(const FloatRect& floatFilterRect)
255{
256    IntRect filterRect = enclosingIntRect(floatFilterRect);
257    if (!filterRect.isEmpty() && FilterEffect::isFilterSizeValid(filterRect)) {
258        FloatRect currentSourceRect = sourceImageRect();
259        if (filterRect != currentSourceRect) {
260            setSourceImageRect(filterRect);
261            return true;
262        }
263    }
264    return false;
265}
266
267void FilterEffectRenderer::allocateBackingStoreIfNeeded()
268{
269    // At this point the effect chain has been built, and the
270    // source image sizes set. We just need to attach the graphic
271    // buffer if we have not yet done so.
272    if (!m_graphicsBufferAttached) {
273        IntSize logicalSize(m_sourceDrawingRegion.width(), m_sourceDrawingRegion.height());
274        if (!sourceImage() || sourceImage()->size() != logicalSize) {
275            OwnPtr<ImageBufferSurface> surface = adoptPtr(new UnacceleratedImageBufferSurface(logicalSize));
276            setSourceImage(ImageBuffer::create(surface.release()));
277        }
278        m_graphicsBufferAttached = true;
279    }
280}
281
282void FilterEffectRenderer::clearIntermediateResults()
283{
284    if (m_lastEffect.get())
285        m_lastEffect->clearResultsRecursive();
286}
287
288void FilterEffectRenderer::apply()
289{
290    RefPtr<FilterEffect> effect = lastEffect();
291    effect->apply();
292    effect->transformResultColorSpace(ColorSpaceDeviceRGB);
293}
294
295LayoutRect FilterEffectRenderer::computeSourceImageRectForDirtyRect(const LayoutRect& filterBoxRect, const LayoutRect& dirtyRect)
296{
297    // The result of this function is the area in the "filterBoxRect" that needs paint invalidation, so that we fully cover the "dirtyRect".
298    FloatRect rectForPaintInvalidation = dirtyRect;
299    float inf = std::numeric_limits<float>::infinity();
300    FloatRect clipRect = FloatRect(FloatPoint(-inf, -inf), FloatSize(inf, inf));
301    rectForPaintInvalidation = lastEffect()->getSourceRect(rectForPaintInvalidation, clipRect);
302    rectForPaintInvalidation.intersect(filterBoxRect);
303    return LayoutRect(rectForPaintInvalidation);
304}
305
306bool FilterEffectRendererHelper::prepareFilterEffect(RenderLayer* renderLayer, const LayoutRect& filterBoxRect, const LayoutRect& dirtyRect)
307{
308    ASSERT(m_haveFilterEffect && renderLayer->filterRenderer());
309    m_renderLayer = renderLayer;
310    m_paintInvalidationRect = dirtyRect;
311
312    // Get the zoom factor to scale the filterSourceRect input
313    const RenderLayerModelObject* renderer = renderLayer->renderer();
314    const RenderStyle* style = renderer ? renderer->style() : 0;
315    float zoom = style ? style->effectiveZoom() : 1.0f;
316
317    // Prepare a transformation that brings the coordinates into the space
318    // filter coordinates are defined in.
319    AffineTransform absoluteTransform;
320    // FIXME: Should these really be upconverted to doubles and not rounded? crbug.com/350474
321    absoluteTransform.translate(filterBoxRect.x().toDouble(), filterBoxRect.y().toDouble());
322    absoluteTransform.scale(zoom, zoom);
323
324    FilterEffectRenderer* filter = renderLayer->filterRenderer();
325    filter->setAbsoluteTransform(absoluteTransform);
326
327    IntRect filterSourceRect = pixelSnappedIntRect(filter->computeSourceImageRectForDirtyRect(filterBoxRect, dirtyRect));
328
329    if (filterSourceRect.isEmpty()) {
330        // The dirty rect is not in view, just bail out.
331        m_haveFilterEffect = false;
332        return false;
333    }
334
335    m_filterBoxRect = filterBoxRect;
336    filter->setFilterRegion(filter->mapAbsoluteRectToLocalRect(filterSourceRect));
337    filter->lastEffect()->determineFilterPrimitiveSubregion(MapRectForward);
338
339    bool hasUpdatedBackingStore = filter->updateBackingStoreRect(filterSourceRect);
340    if (filter->hasFilterThatMovesPixels()) {
341        if (hasUpdatedBackingStore)
342            m_paintInvalidationRect = filterSourceRect;
343        else
344            m_paintInvalidationRect.intersect(filterSourceRect);
345    }
346    return true;
347}
348
349GraphicsContext* FilterEffectRendererHelper::beginFilterEffect(GraphicsContext* context)
350{
351    ASSERT(m_renderLayer);
352
353    FilterEffectRenderer* filter = m_renderLayer->filterRenderer();
354    if (m_renderLayer->renderer()->document().settings()->deferredFiltersEnabled()) {
355        SkiaImageFilterBuilder builder(context);
356        RefPtr<ImageFilter> imageFilter = builder.build(filter->lastEffect().get(), ColorSpaceDeviceRGB);
357        if (!imageFilter) {
358            m_haveFilterEffect = false;
359            return context;
360        }
361        m_savedGraphicsContext = context;
362        context->save();
363        FloatRect boundaries = mapImageFilterRect(imageFilter.get(), m_filterBoxRect);
364        context->translate(m_filterBoxRect.x(), m_filterBoxRect.y());
365        boundaries.move(-m_filterBoxRect.x(), -m_filterBoxRect.y());
366        context->beginLayer(1, CompositeSourceOver, &boundaries, ColorFilterNone, imageFilter.get());
367        context->translate(-m_filterBoxRect.x(), -m_filterBoxRect.y());
368        return context;
369    }
370    filter->allocateBackingStoreIfNeeded();
371    // Paint into the context that represents the SourceGraphic of the filter.
372    GraphicsContext* sourceGraphicsContext = filter->inputContext();
373    if (!sourceGraphicsContext || !FilterEffect::isFilterSizeValid(filter->absoluteFilterRegion())) {
374        // Disable the filters and continue.
375        m_haveFilterEffect = false;
376        return context;
377    }
378
379    m_savedGraphicsContext = context;
380
381    // Translate the context so that the contents of the layer is captuterd in the offscreen memory buffer.
382    sourceGraphicsContext->save();
383    // FIXME: can we just use sourceImageRect for everything, and get rid of
384    // m_paintInvalidationRect?
385    FloatPoint offset = filter->sourceImageRect().location();
386    sourceGraphicsContext->translate(-offset.x(), -offset.y());
387    sourceGraphicsContext->clearRect(m_paintInvalidationRect);
388    sourceGraphicsContext->clip(m_paintInvalidationRect);
389
390    return sourceGraphicsContext;
391}
392
393GraphicsContext* FilterEffectRendererHelper::applyFilterEffect()
394{
395    ASSERT(m_haveFilterEffect && m_renderLayer->filterRenderer());
396    FilterEffectRenderer* filter = m_renderLayer->filterRenderer();
397
398    if (m_renderLayer->renderer()->document().settings()->deferredFiltersEnabled()) {
399        GraphicsContext* context = m_savedGraphicsContext;
400        context->endLayer();
401        context->restore();
402        return context;
403    }
404
405    filter->inputContext()->restore();
406
407    filter->apply();
408
409    // Get the filtered output and draw it in place.
410    m_savedGraphicsContext->drawImageBuffer(filter->output(), filter->outputRect());
411
412    filter->clearIntermediateResults();
413
414    return m_savedGraphicsContext;
415}
416
417} // namespace blink
418
419