Scaling and offset fix for FELighting (software and skia paths)

Source/platform/graphics/filters/FELighting.cpp

 /*
  * Copyright (C) 2010 University of Szeged
  * Copyright (C) 2010 Zoltan Herczeg
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 169 matching lines @@
     offset -= widthMultipliedByPixelSize;
     int topLeft = static_cast<int>(pixels->item(offset - cPixelSize + cAlphaChannelOffset));
     int top = static_cast<int>(pixels->item(offset + cAlphaChannelOffset));
     normalVector.setX(-topLeft + top - (left << 1) + (center << 1));
     normalVector.setY(-topLeft - (top << 1) + left + (center << 1));
 }
 
 inline void FELighting::inlineSetPixel(int offset, LightingData& data, LightSource::PaintingData& paintingData,
                                        int lightX, int lightY, float factorX, float factorY, IntPoint& normal2DVector)
 {
-    m_lightSource->updatePaintingData(paintingData, lightX, lightY, static_cast<float>(data.pixels->item(offset + cAlphaChannelOffset)) * data.surfaceScale);
+    float transformedLightX = (static_cast<float>(lightX) + data.originOffset.width()) / data.worldScale.x();

[Stephen White, 2014/03/03 21:00:57]

Nit: I don't think you need static_cast<float> here; the compiler must promote
it to float based on the other (float) argument to +.

Bigger problem: divides are not cheap. Doing this per-pixel is going to be
expensive. I suggest we transform the light once, outside the loop, and pass the
transformed light in to this function.

[sugoi1, 2014/03/04 14:45:56]

Done.

+    float transformedLightY = (static_cast<float>(lightY) + data.originOffset.height()) / data.worldScale.y();
+    m_lightSource->updatePaintingData(paintingData, transformedLightX, transformedLightY, static_cast<float>(data.pixels->item(offset + cAlphaChannelOffset)) * data.surfaceScale * data.worldScale.z());
 
     float lightStrength;
     if (!normal2DVector.x() && !normal2DVector.y()) {
         // Normal vector is (0, 0, 1). This is a quite frequent case.
         if (m_lightingType == FELighting::DiffuseLighting) {
             lightStrength = m_diffuseConstant * paintingData.lightVector.z() / paintingData.lightVectorLength;
         } else {
             FloatPoint3D halfwayVector = paintingData.lightVector;
             halfwayVector.setZ(halfwayVector.z() + paintingData.lightVectorLength);
             float halfwayVectorLength = halfwayVector.length();
@@ skipping 94 matching lines @@
 inline void FELighting::platformApply(LightingData& data, LightSource::PaintingData& paintingData)
 {
     // The selection here eventually should happen dynamically on some platforms.
 #if CPU(ARM_NEON) && CPU(ARM_TRADITIONAL) && COMPILER(GCC)
     platformApplyNeon(data, paintingData);
 #else
     platformApplyGeneric(data, paintingData);
 #endif
 }
 
+void FELighting::getTransform(FloatSize* offset, FloatPoint3D* scale) const
+{
+    FloatRect initialEffectRect = effectBoundaries();
+    FloatRect absoluteEffectRect = filter()->mapLocalRectToAbsoluteRect(initialEffectRect);
+    FloatPoint absoluteLocation(absolutePaintRect().location());
+    FloatSize positionOffset(absoluteLocation - absoluteEffectRect.location());
+    offset->setWidth(positionOffset.width());
+    offset->setHeight(positionOffset.height());
+    scale->setX(initialEffectRect.width() > 0.0f && initialEffectRect.width() > 0.0f ? absoluteEffectRect.width() / initialEffectRect.width() : 1.0f);
+    scale->setY(initialEffectRect.height() > 0.0f && initialEffectRect.height() > 0.0f ? absoluteEffectRect.height() / initialEffectRect.height() : 1.0f);
+    // X and Y scale should be the same, but, if not, do a best effort by averaging the 2 for Z scale
+    scale->setZ(0.5f * (scale->x() + scale->y()));
+}
+
 bool FELighting::drawLighting(Uint8ClampedArray* pixels, int width, int height)
 {
     LightSource::PaintingData paintingData;
     LightingData data;
 
     if (!m_lightSource)
         return false;
 
     // FIXME: do something if width or height (or both) is 1 pixel.
     // The W3 spec does not define this case. Now the filter just returns.
     if (width <= 2 || height <= 2)
         return false;
 
     data.pixels = pixels;
     data.surfaceScale = m_surfaceScale / 255.0f;
     data.widthMultipliedByPixelSize = width * cPixelSize;
     data.widthDecreasedByOne = width - 1;
     data.heightDecreasedByOne = height - 1;
+    getTransform(&data.originOffset, &data.worldScale);
     Color lightColor = adaptColorToOperatingColorSpace(m_lightingColor);
     paintingData.colorVector = FloatPoint3D(lightColor.red(), lightColor.green(), lightColor.blue());
     m_lightSource->initPaintingData(paintingData);
 
     // Top/Left corner.
     IntPoint normalVector;
     int offset = 0;
     data.topLeft(offset, normalVector);
     setPixel(offset, data, paintingData, 0, 0, cFactor2div3, cFactor2div3, normalVector);
 
@@ skipping 153 matching lines @@
     GraphicsContext* dstContext = resultImage->context();
 
     SkPaint paint;
     RefPtr<SkImageFilter> filter = createImageFilter(0);
     paint.setImageFilter(filter.get());
     dstContext->drawBitmap(nativeImage->bitmap(), drawingRegion.location().x(), drawingRegion.location().y(), &paint);
     return true;
 }
 
 } // namespace WebCore