Changeset 166084 in webkit

Timestamp:

Mar 21, 2014 12:02:35 PM (10 years ago)

Author:

cavalcantii@gmail.com

Message:

Optimize FEGaussian blur
​https://bugs.webkit.org/show_bug.cgi?id=50881

Reviewed by Dirk Schulze.

Currently boxBlur() will calculate the filter for each channel in
a loop and also uses Uint8ClampedArray::set() to write the
resulting pixels into destination array.

Using Uint8ClampedArray::set() requires lots of unnecessary type
conversions, not to mention other function calls. This patch
updates the original written by Simon Fraser to apply cleanly to current
trunk.

It also implements code to handle EdgeModes and finally avoids use
of ::set() in the newly added boxBlurAlphaOnly()
function. Assignment of calculated pixel values rely on pointers.

No new tests, no change on behavior.

• platform/graphics/filters/FEGaussianBlur.cpp:

(WebCore::boxBlurAlphaOnly): Specialized version for alpha only cases.
(WebCore::boxBlur):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• platform/graphics/filters/FEGaussianBlur.cpp (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2014-03-21  Adenilson Cavalcanti  <cavalcantii@gmail.com>
+
+        Optimize FEGaussian blur
+        https://bugs.webkit.org/show_bug.cgi?id=50881
+
+        Reviewed by Dirk Schulze.
+
+        Currently boxBlur() will calculate the filter for each channel in
+        a loop and also uses Uint8ClampedArray::set() to write the
+        resulting pixels into destination array.
+
+        Using Uint8ClampedArray::set() requires lots of unnecessary type
+        conversions, not to mention other function calls. This patch
+        updates the original written by Simon Fraser to apply cleanly to current
+        trunk.
+
+        It also implements code to handle EdgeModes and finally avoids use
+        of ::set() in the newly added boxBlurAlphaOnly()
+        function. Assignment of calculated pixel values rely on pointers.
+
+        No new tests, no change on behavior.
+
+        * platform/graphics/filters/FEGaussianBlur.cpp:
+        (WebCore::boxBlurAlphaOnly): Specialized version for alpha only cases.
+        (WebCore::boxBlur):
+
 2014-03-21  Simon Fraser  <simon.fraser@apple.com>
 

trunk/Source/WebCore/platform/graphics/filters/FEGaussianBlur.cpp

@@ -91 +91 @@
 }
 
-inline void boxBlur(Uint8ClampedArray* srcPixelArray, Uint8ClampedArray* dstPixelArray,
-    unsigned dx, int dxLeft, int dxRight, int stride, int strideLine, int effectWidth, int effectHeight, bool alphaImage, EdgeModeType edgeMode)
-{
+// This function only operates on Alpha channel.
+inline void boxBlurAlphaOnly(const Uint8ClampedArray* srcPixelArray, Uint8ClampedArray* dstPixelArray,
+    unsigned dx, int& dxLeft, int& dxRight, int& stride, int& strideLine, int& effectWidth, int& effectHeight, const int& maxKernelSize)
+{
+    unsigned char* srcData = srcPixelArray->data();
+    unsigned char* dstData = dstPixelArray->data();
+    // Memory alignment is: RGBA, zero-index based.
+    const int channel = 3;
+
     for (int y = 0; y < effectHeight; ++y) {
         int line = y * strideLine;
-        for (int channel = 3; channel >= 0; --channel) {
-            int sum = 0;
-            // The code for edgeMode='none' is the common case and highly optimized.
-            // Furthermore, this code path affects more than just the input area.
-            if (edgeMode == EDGEMODE_NONE) {
-                // Fill the kernel
-                int maxKernelSize = std::min(dxRight, effectWidth);
-                for (int i = 0; i < maxKernelSize; ++i)
-                    sum += srcPixelArray->item(line + i * stride + channel);
-
-                // Blurring
-                for (int x = 0; x < effectWidth; ++x) {
-                    int pixelByteOffset = line + x * stride + channel;
-                    dstPixelArray->set(pixelByteOffset, static_cast<unsigned char>(sum / dx));
-                    // Shift kernel.
-                    if (x >= dxLeft)
-                        sum -= srcPixelArray->item(pixelByteOffset - dxLeft * stride);
-                    if (x + dxRight < effectWidth)
-                        sum += srcPixelArray->item(pixelByteOffset + dxRight * stride);
-                }
-            } else {
-                // FIXME: Add support for 'wrap' here.
-                // Get edge values for edgeMode 'duplicate'.
-                int edgeValueLeft = srcPixelArray->item(line + channel);
-                int edgeValueRight = srcPixelArray->item(line + (effectWidth - 1) * stride + channel);
-                // Fill the kernel
-                for (int i = dxLeft * -1; i < dxRight; ++i) {
-                    if (i < 0)
-                        sum += edgeValueLeft;
-                    else if (i >= effectWidth)
-                        sum += edgeValueRight;
-                    else
-                        sum += srcPixelArray->item(line + i * stride + channel);
-                }
-                // Blurring
-                for (int x = 0; x < effectWidth; ++x) {
-                    int pixelByteOffset = line + x * stride + channel;
-                    dstPixelArray->set(pixelByteOffset, static_cast<unsigned char>(sum / dx));
-                    // Shift kernel.
-                    if (x < dxLeft)
-                        sum -= edgeValueLeft;
-                    else
-                        sum -= srcPixelArray->item(pixelByteOffset - dxLeft * stride);
-                    if (x + dxRight >= effectWidth)
-                        sum += edgeValueRight;
-                    else
-                        sum += srcPixelArray->item(pixelByteOffset + dxRight * stride);
-                }
-            }
-            if (alphaImage) // Source image is black, it just has different alpha values
-                break;
+        int sum = 0;
+
+        // Fill the kernel.
+        for (int i = 0; i < maxKernelSize; ++i) {
+            unsigned offset = line + i * stride;
+            unsigned char* srcPtr = srcData + offset;
+            sum += srcPtr[channel];
+        }
+
+        // Blurring.
+        for (int x = 0; x < effectWidth; ++x) {
+            unsigned pixelByteOffset = line + x * stride + channel;
+            unsigned char* dstPtr = dstData + pixelByteOffset;
+            *dstPtr = static_cast<unsigned char>(sum / dx);
+
+            // Shift kernel.
+            if (x >= dxLeft) {
+                unsigned leftOffset = pixelByteOffset - dxLeft * stride;
+                unsigned char* srcPtr = srcData + leftOffset;
+                sum -= *srcPtr;
+            }
+
+            if (x + dxRight < effectWidth) {
+                unsigned rightOffset = pixelByteOffset + dxRight * stride;
+                unsigned char* srcPtr = srcData + rightOffset;
+                sum += *srcPtr;
+            }
+        }
+    }
+}
+
+inline void boxBlur(const Uint8ClampedArray* srcPixelArray, Uint8ClampedArray* dstPixelArray,
+    unsigned dx, int dxLeft, int dxRight, int stride, int strideLine, int effectWidth, int effectHeight, bool alphaImage, EdgeModeType edgeMode)
+{
+    const int maxKernelSize = std::min(dxRight, effectWidth);
+    if (alphaImage) {
+        return boxBlurAlphaOnly(srcPixelArray, dstPixelArray, dx, dxLeft, dxRight, stride, strideLine,
+            effectWidth, effectHeight, maxKernelSize);
+    }
+
+    unsigned char* srcData = srcPixelArray->data();
+    unsigned char* dstData = dstPixelArray->data();
+
+    // Concerning the array width/length: it is Element size + Margin + Border. The number of pixels will be
+    // P = width * height * channels.
+    for (int y = 0; y < effectHeight; ++y) {
+        int line = y * strideLine;
+        int sumR = 0, sumG = 0, sumB = 0, sumA = 0;
+
+        if (edgeMode == EDGEMODE_NONE) {
+            // Fill the kernel.
+            for (int i = 0; i < maxKernelSize; ++i) {
+                unsigned offset = line + i * stride;
+                unsigned char* srcPtr = srcData + offset;
+                sumR += *srcPtr++;
+                sumG += *srcPtr++;
+                sumB += *srcPtr++;
+                sumA += *srcPtr;
+            }
+
+            // Blurring.
+            for (int x = 0; x < effectWidth; ++x) {
+                unsigned pixelByteOffset = line + x * stride;
+                unsigned char* dstPtr = dstData + pixelByteOffset;
+
+                *dstPtr++ = static_cast<unsigned char>(sumR / dx);
+                *dstPtr++ = static_cast<unsigned char>(sumG / dx);
+                *dstPtr++ = static_cast<unsigned char>(sumB / dx);
+                *dstPtr = static_cast<unsigned char>(sumA / dx);
+
+                // Shift kernel.
+                if (x >= dxLeft) {
+                    unsigned leftOffset = pixelByteOffset - dxLeft * stride;
+                    unsigned char* srcPtr = srcData + leftOffset;
+                    sumR -= srcPtr[0];
+                    sumG -= srcPtr[1];
+                    sumB -= srcPtr[2];
+                    sumA -= srcPtr[3];
+                }
+
+                if (x + dxRight < effectWidth) {
+                    unsigned rightOffset = pixelByteOffset + dxRight * stride;
+                    unsigned char* srcPtr = srcData + rightOffset;
+                    sumR += srcPtr[0];
+                    sumG += srcPtr[1];
+                    sumB += srcPtr[2];
+                    sumA += srcPtr[3];
+                }
+            }
+
+        } else {
+            // FIXME: Add support for 'wrap' here.
+            // Get edge values for edgeMode 'duplicate'.
+            unsigned char* edgeValueLeft = srcData + line;
+            unsigned char* edgeValueRight  = srcData + (line + (effectWidth - 1) * stride);
+
+            // Fill the kernel.
+            for (int i = dxLeft * -1; i < dxRight; ++i) {
+                // Is this right for negative values of 'i'?
+                unsigned offset = line + i * stride;
+                unsigned char* srcPtr = srcData + offset;
+
+                if (i < 0) {
+                    sumR += edgeValueLeft[0];
+                    sumG += edgeValueLeft[1];
+                    sumB += edgeValueLeft[2];
+                    sumA += edgeValueLeft[3];
+                } else if (i >= effectWidth) {
+                    sumR += edgeValueRight[0];
+                    sumG += edgeValueRight[1];
+                    sumB += edgeValueRight[2];
+                    sumA += edgeValueRight[3];
+                } else {
+                    sumR += *srcPtr++;
+                    sumG += *srcPtr++;
+                    sumB += *srcPtr++;
+                    sumA += *srcPtr;
+                }
+            }
+
+            // Blurring.
+            for (int x = 0; x < effectWidth; ++x) {
+                unsigned pixelByteOffset = line + x * stride;
+                unsigned char* dstPtr = dstData + pixelByteOffset;
+
+                *dstPtr++ = static_cast<unsigned char>(sumR / dx);
+                *dstPtr++ = static_cast<unsigned char>(sumG / dx);
+                *dstPtr++ = static_cast<unsigned char>(sumB / dx);
+                *dstPtr = static_cast<unsigned char>(sumA / dx);
+
+                // Shift kernel.
+                if (x < dxLeft) {
+                    sumR -= edgeValueLeft[0];
+                    sumG -= edgeValueLeft[1];
+                    sumB -= edgeValueLeft[2];
+                    sumA -= edgeValueLeft[3];
+                } else {
+                    unsigned leftOffset = pixelByteOffset - dxLeft * stride;
+                    unsigned char* srcPtr = srcData + leftOffset;
+                    sumR -= srcPtr[0];
+                    sumG -= srcPtr[1];
+                    sumB -= srcPtr[2];
+                    sumA -= srcPtr[3];
+                }
+
+                if (x + dxRight >= effectWidth) {
+                    sumR += edgeValueRight[0];
+                    sumG += edgeValueRight[1];
+                    sumB += edgeValueRight[2];
+                    sumA += edgeValueRight[3];
+                } else {
+                    unsigned rightOffset = pixelByteOffset + dxRight * stride;
+                    unsigned char* srcPtr = srcData + rightOffset;
+                    sumR += srcPtr[0];
+                    sumG += srcPtr[1];
+                    sumB += srcPtr[2];
+                    sumA += srcPtr[3];
+                }
+            }
         }
     }