/*

  This file is part of the Ofi Labs X2 project.

  Copyright (C) 2010 Ariya Hidayat <ariya.hidayat@gmail.com>

  Redistribution and use in source and binary forms, with or without

  modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright

      notice, this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright

      notice, this list of conditions and the following disclaimer in the

      documentation and/or other materials provided with the distribution.

    * Neither the name of the <organization> nor the

      names of its contributors may be used to endorse or promote products

      derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY

  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#include "shadowblur.h"

#include <QImage>

#include <QPainter>

static const int BlurSumShift = 15;

// Check http://www.w3.org/TR/SVG/filters.html#feGaussianBlur.

// As noted in the SVG filter specification, running box blur 3x

// approximates a real gaussian blur nicely.

void shadowBlur(QImage& image, int radius, const QColor& shadowColor)

{

    // See comments in http://webkit.org/b/40793, it seems sensible

    // to follow Skia's limit of 128 pixels for the blur radius.

    if (radius > 128)

        radius = 128;

    int channels[4] = { 3, 0, 1, 3 };

    int dmax = radius >> 1;

    int dmin = dmax - 1 + (radius & 1);

    if (dmin < 0)

        dmin = 0;

    // Two stages: horizontal and vertical

    for (int k = 0; k < 2; ++k) {

        unsigned char* pixels = image.bits();

        int stride = (k == 0) ? 4 : image.bytesPerLine();

        int delta = (k == 0) ? image.bytesPerLine() : 4;

        int jfinal = (k == 0) ? image.height() : image.width();

        int dim = (k == 0) ? image.width() : image.height();

        for (int j = 0; j < jfinal; ++j, pixels += delta) {

            // For each step, we blur the alpha in a channel and store the result

            // in another channel for the subsequent step.

            // We use sliding window algorithm to accumulate the alpha values.

            // This is much more efficient than computing the sum of each pixels

            // covered by the box kernel size for each x.

            for (int step = 0; step < 3; ++step) {

                int side1 = (step == 0) ? dmin : dmax;

                int side2 = (step == 1) ? dmin : dmax;

                int pixelCount = side1 + 1 + side2;

                int invCount = ((1 << BlurSumShift) + pixelCount - 1) / pixelCount;

                int ofs = 1 + side2;

                int alpha1 = pixels[channels[step]];

                int alpha2 = pixels[(dim - 1) * stride + channels[step]];

                unsigned char* ptr = pixels + channels[step + 1];

                unsigned char* prev = pixels + stride + channels[step];

                unsigned char* next = pixels + ofs * stride + channels[step];

                int i;

                int sum = side1 * alpha1 + alpha1;

                int limit = (dim < side2 + 1) ? dim : side2 + 1;

                for (i = 1; i < limit; ++i, prev += stride)

                    sum += *prev;

                if (limit <= side2)

                    sum += (side2 - limit + 1) * alpha2;

                limit = (side1 < dim) ? side1 : dim;

                for (i = 0; i < limit; ptr += stride, next += stride, ++i, ++ofs) {

                    *ptr = (sum * invCount) >> BlurSumShift;

                    sum += ((ofs < dim) ? *next : alpha2) - alpha1;

                }

                prev = pixels + channels[step];

                for (; ofs < dim; ptr += stride, prev += stride, next += stride, ++i, ++ofs) {

                    *ptr = (sum * invCount) >> BlurSumShift;

                    sum += (*next) - (*prev);

                }

                for (; i < dim; ptr += stride, prev += stride, ++i) {

                    *ptr = (sum * invCount) >> BlurSumShift;

                    sum += alpha2 - (*prev);

                }

            }

        }

    }

    // "Colorize" with the right shadow color.

    QPainter p(&image);

    p.setCompositionMode(QPainter::CompositionMode_SourceIn);

    p.fillRect(image.rect(), shadowColor);

    p.end();

}