WebCore/ChangeLog

 12010-10-24 Dirk Schulze <krit@webkit.org>
 2
 3 Reviewed by NOBODY (OOPS!).
 4
 5 Filter example Chiseled from SVG Wow! is slow
 6 https://bugs.webkit.org/show_bug.cgi?id=48174
 7
 8 Use a pointer to the ByteArray instead of the ref counted CanvasPixelArray or ImageData directly
 9 to access the data for pixel manipulation on SVG Filters or SVG Masker. This is a
 10 performance increase since the recurring use of the -> operator can be avoided.
 11 FEConvolveMatrix and FELighting still need to change in a followup patch.
 12
 13 No functionality was changed. So, no new tests.
 14
 15 * platform/graphics/filters/FEBlend.cpp:
 16 (WebCore::FEBlend::apply):
 17 * platform/graphics/filters/FEColorMatrix.cpp:
 18 (WebCore::luminance):
 19 (WebCore::effectType):
 20 (WebCore::FEColorMatrix::apply):
 21 * platform/graphics/filters/FEComponentTransfer.cpp:
 22 (WebCore::FEComponentTransfer::apply):
 23 * platform/graphics/filters/FEComposite.cpp:
 24 (WebCore::arithmetic):
 25 (WebCore::FEComposite::apply):
 26 * platform/graphics/filters/FEDisplacementMap.cpp:
 27 (WebCore::FEDisplacementMap::apply):
 28 * platform/graphics/filters/FEGaussianBlur.cpp:
 29 (WebCore::boxBlur):
 30 (WebCore::FEGaussianBlur::apply):
 31 * platform/graphics/filters/FEMorphology.cpp:
 32 (WebCore::FEMorphology::apply):
 33 * platform/graphics/filters/FETurbulence.cpp:
 34 (WebCore::FETurbulence::apply):
 35 * rendering/RenderSVGResourceMasker.cpp:
 36 (WebCore::RenderSVGResourceMasker::drawContentIntoMaskImage):
 37
1382010-10-23 Daniel Bates <dbates@rim.com>
239
340 Reviewed by Adam Barth.
70409

WebCore/platform/graphics/filters/FEBlend.cpp

@@typedef unsigned char (*BlendType)(unsig
3535
3636namespace WebCore {
3737
 38using WTF::ByteArray;
 39
3840FEBlend::FEBlend(BlendModeType mode)
3941 : FilterEffect()
4042 , m_mode(mode)

@@void FEBlend::apply(Filter* filter)
102104 return;
103105
104106 IntRect effectADrawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
105  RefPtr<CanvasPixelArray> srcPixelArrayA(in->resultImage()->getPremultipliedImageData(effectADrawingRect)->data());
 107 RefPtr<CanvasPixelArray> srcCanvasPixelArrayA(in->resultImage()->getPremultipliedImageData(effectADrawingRect)->data());
 108 ByteArray* srcPixelArrayA(srcCanvasPixelArrayA->data());
106109
107110 IntRect effectBDrawingRect = requestedRegionOfInputImageData(in2->absolutePaintRect());
108  RefPtr<CanvasPixelArray> srcPixelArrayB(in2->resultImage()->getPremultipliedImageData(effectBDrawingRect)->data());
 111 RefPtr<CanvasPixelArray> srcCanvasPixelArrayB(in2->resultImage()->getPremultipliedImageData(effectBDrawingRect)->data());
 112 ByteArray* srcPixelArrayB(srcCanvasPixelArrayB->data());
109113
110114 IntRect imageRect(IntPoint(), resultImage()->size());
111115 RefPtr<ImageData> imageData = ImageData::create(imageRect.width(), imageRect.height());
 116 ByteArray* dstPixelArray(imageData->data()->data());
112117
113118 // Keep synchronized with BlendModeType
114119 static const BlendType callEffect[] = {unknown, normal, multiply, screen, darken, lighten};
115120
116  ASSERT(srcPixelArrayA->length() == srcPixelArrayB->length());
117  for (unsigned pixelOffset = 0; pixelOffset < srcPixelArrayA->length(); pixelOffset += 4) {
 121 unsigned pixelArrayLength = srcPixelArrayA->length();
 122 ASSERT(pixelArrayLength == srcPixelArrayB->length());
 123 for (unsigned pixelOffset = 0; pixelOffset < pixelArrayLength; pixelOffset += 4) {
118124 unsigned char alphaA = srcPixelArrayA->get(pixelOffset + 3);
119125 unsigned char alphaB = srcPixelArrayB->get(pixelOffset + 3);
120126 for (unsigned channel = 0; channel < 3; ++channel) {

@@void FEBlend::apply(Filter* filter)
122128 unsigned char colorB = srcPixelArrayB->get(pixelOffset + channel);
123129
124130 unsigned char result = (*callEffect[m_mode])(colorA, colorB, alphaA, alphaB);
125  imageData->data()->set(pixelOffset + channel, result);
 131 dstPixelArray->set(pixelOffset + channel, result);
126132 }
127133 unsigned char alphaR = 255 - ((255 - alphaA) * (255 - alphaB)) / 255;
128  imageData->data()->set(pixelOffset + 3, alphaR);
 134 dstPixelArray->set(pixelOffset + 3, alphaR);
129135 }
130136
131137 resultImage()->putPremultipliedImageData(imageData.get(), imageRect, IntPoint());
70142

WebCore/platform/graphics/filters/FEColorMatrix.cpp

2525#if ENABLE(FILTERS)
2626#include "FEColorMatrix.h"
2727
28 #include "CanvasPixelArray.h"
2928#include "Filter.h"
3029#include "GraphicsContext.h"
3130#include "ImageData.h"
32 #include <math.h>
 31
3332#include <wtf/MathExtras.h>
3433
3534namespace WebCore {
3635
 36using WTF::ByteArray;
 37
3738FEColorMatrix::FEColorMatrix(ColorMatrixType type, const Vector<float>& values)
3839 : FilterEffect()
3940 , m_type(type)

@@inline void huerotate(double& red, doubl
112113inline void luminance(double& red, double& green, double& blue, double& alpha)
113114{
114115 alpha = 0.2125 * red + 0.7154 * green + 0.0721 * blue;
115  red = 0.;
116  green = 0.;
117  blue = 0.;
 116 red = 0;
 117 green = 0;
 118 blue = 0;
118119}
119120
120121template<ColorMatrixType filterType>
121 void effectType(const PassRefPtr<CanvasPixelArray>& srcPixelArray, PassRefPtr<ImageData>& imageData, const Vector<float>& values)
 122void effectType(ByteArray* pixelArray, const Vector<float>& values)
122123{
123  for (unsigned pixelOffset = 0; pixelOffset < srcPixelArray->length(); pixelOffset++) {
124  unsigned pixelByteOffset = pixelOffset * 4;
125 
126  unsigned char r = 0, g = 0, b = 0, a = 0;
127  srcPixelArray->get(pixelByteOffset, r);
128  srcPixelArray->get(pixelByteOffset + 1, g);
129  srcPixelArray->get(pixelByteOffset + 2, b);
130  srcPixelArray->get(pixelByteOffset + 3, a);
 124 unsigned pixelArrayLength = pixelArray->length();
 125 for (unsigned pixelByteOffset = 0; pixelByteOffset < pixelArrayLength; pixelByteOffset += 4) {
 126 double red = pixelArray->get(pixelByteOffset);
 127 double green = pixelArray->get(pixelByteOffset + 1);
 128 double blue = pixelArray->get(pixelByteOffset + 2);
 129 double alpha = pixelArray->get(pixelByteOffset + 3);
131130
132  double red = r, green = g, blue = b, alpha = a;
133 
134131 switch (filterType) {
135132 case FECOLORMATRIX_TYPE_MATRIX:
136133 matrix(red, green, blue, alpha, values);

@@void effectType(const PassRefPtr<CanvasP
146143 break;
147144 }
148145
149  imageData->data()->set(pixelByteOffset, red);
150  imageData->data()->set(pixelByteOffset + 1, green);
151  imageData->data()->set(pixelByteOffset + 2, blue);
152  imageData->data()->set(pixelByteOffset + 3, alpha);
 146 pixelArray->set(pixelByteOffset, red);
 147 pixelArray->set(pixelByteOffset + 1, green);
 148 pixelArray->set(pixelByteOffset + 2, blue);
 149 pixelArray->set(pixelByteOffset + 3, alpha);
153150 }
154151}
155152

@@void FEColorMatrix::apply(Filter* filter
167164 filterContext->drawImageBuffer(in->resultImage(), ColorSpaceDeviceRGB, drawingRegionOfInputImage(in->absolutePaintRect()));
168165
169166 IntRect imageRect(IntPoint(), resultImage()->size());
170  PassRefPtr<ImageData> imageData(resultImage()->getUnmultipliedImageData(imageRect));
171  PassRefPtr<CanvasPixelArray> srcPixelArray(imageData->data());
 167 RefPtr<ImageData> imageData(resultImage()->getUnmultipliedImageData(imageRect));
 168 ByteArray* pixelArray(imageData->data()->data());
172169
173170 switch (m_type) {
174171 case FECOLORMATRIX_TYPE_UNKNOWN:
175172 break;
176173 case FECOLORMATRIX_TYPE_MATRIX:
177  effectType<FECOLORMATRIX_TYPE_MATRIX>(srcPixelArray, imageData, m_values);
 174 effectType<FECOLORMATRIX_TYPE_MATRIX>(pixelArray, m_values);
178175 break;
179176 case FECOLORMATRIX_TYPE_SATURATE:
180  effectType<FECOLORMATRIX_TYPE_SATURATE>(srcPixelArray, imageData, m_values);
 177 effectType<FECOLORMATRIX_TYPE_SATURATE>(pixelArray, m_values);
181178 break;
182179 case FECOLORMATRIX_TYPE_HUEROTATE:
183  effectType<FECOLORMATRIX_TYPE_HUEROTATE>(srcPixelArray, imageData, m_values);
 180 effectType<FECOLORMATRIX_TYPE_HUEROTATE>(pixelArray, m_values);
184181 break;
185182 case FECOLORMATRIX_TYPE_LUMINANCETOALPHA:
186  effectType<FECOLORMATRIX_TYPE_LUMINANCETOALPHA>(srcPixelArray, imageData, m_values);
 183 effectType<FECOLORMATRIX_TYPE_LUMINANCETOALPHA>(pixelArray, m_values);
187184 setIsAlphaImage(true);
188185 break;
189186 }
70143

WebCore/platform/graphics/filters/FEComponentTransfer.cpp

2626#if ENABLE(FILTERS)
2727#include "FEComponentTransfer.h"
2828
29 #include "CanvasPixelArray.h"
3029#include "Filter.h"
3130#include "GraphicsContext.h"
3231#include "ImageData.h"
33 #include <math.h>
 32
 33#include <wtf/MathExtras.h>
3434
3535namespace WebCore {
3636
 37using WTF::ByteArray;
 38
3739typedef void (*TransferType)(unsigned char*, const ComponentTransferFunction&);
3840
3941FEComponentTransfer::FEComponentTransfer(const ComponentTransferFunction& redFunc, const ComponentTransferFunction& greenFunc,

@@void FEComponentTransfer::apply(Filter*
169171
170172 IntRect drawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
171173 RefPtr<ImageData> imageData(in->resultImage()->getUnmultipliedImageData(drawingRect));
172  CanvasPixelArray* srcPixelArray(imageData->data());
 174 ByteArray* pixelArray(imageData->data()->data());
173175
174  for (unsigned pixelOffset = 0; pixelOffset < srcPixelArray->length(); pixelOffset += 4) {
 176 unsigned pixelArrayLength = pixelArray->length();
 177 for (unsigned pixelOffset = 0; pixelOffset < pixelArrayLength; pixelOffset += 4) {
175178 for (unsigned channel = 0; channel < 4; ++channel) {
176  unsigned char c = srcPixelArray->get(pixelOffset + channel);
177  imageData->data()->set(pixelOffset + channel, tables[channel][c]);
 179 unsigned char c = pixelArray->get(pixelOffset + channel);
 180 pixelArray->set(pixelOffset + channel, tables[channel][c]);
178181 }
179182 }
180183
70142

WebCore/platform/graphics/filters/FEComposite.cpp

2626#if ENABLE(FILTERS)
2727#include "FEComposite.h"
2828
29 #include "CanvasPixelArray.h"
3029#include "Filter.h"
3130#include "GraphicsContext.h"
3231#include "ImageData.h"
3332
3433namespace WebCore {
3534
 35using WTF::ByteArray;
 36
3637FEComposite::FEComposite(const CompositeOperationType& type, float k1, float k2, float k3, float k4)
3738 : FilterEffect()
3839 , m_type(type)

@@void FEComposite::setK4(float k4)
9899 m_k4 = k4;
99100}
100101
101 inline void arithmetic(const RefPtr<CanvasPixelArray>& srcPixelArrayA, CanvasPixelArray*& srcPixelArrayB,
 102inline void arithmetic(const ByteArray* srcPixelArrayA, ByteArray* srcPixelArrayB,
102103 float k1, float k2, float k3, float k4)
103104{
104105 float scaledK1 = k1 / 255.f;
105106 float scaledK4 = k4 * 255.f;
106  for (unsigned pixelOffset = 0; pixelOffset < srcPixelArrayA->length(); pixelOffset += 4) {
 107 unsigned pixelArrayLength = srcPixelArrayA->length();
 108 for (unsigned pixelOffset = 0; pixelOffset < pixelArrayLength; pixelOffset += 4) {
107109 for (unsigned channel = 0; channel < 4; ++channel) {
108110 unsigned char i1 = srcPixelArrayA->get(pixelOffset + channel);
109111 unsigned char i2 = srcPixelArrayB->get(pixelOffset + channel);

@@void FEComposite::apply(Filter* filter)
174176 break;
175177 case FECOMPOSITE_OPERATOR_ARITHMETIC: {
176178 IntRect effectADrawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
177  RefPtr<CanvasPixelArray> srcPixelArrayA(in->resultImage()->getPremultipliedImageData(effectADrawingRect)->data());
 179 RefPtr<CanvasPixelArray> srcCanvasPixelArrayA(in->resultImage()->getPremultipliedImageData(effectADrawingRect)->data());
 180 ByteArray* srcPixelArrayA(srcCanvasPixelArrayA->data());
178181
179182 IntRect effectBDrawingRect = requestedRegionOfInputImageData(in2->absolutePaintRect());
180183 RefPtr<ImageData> imageData(in2->resultImage()->getPremultipliedImageData(effectBDrawingRect));
181  CanvasPixelArray* srcPixelArrayB(imageData->data());
 184 ByteArray* srcPixelArrayB(imageData->data()->data());
182185
183186 arithmetic(srcPixelArrayA, srcPixelArrayB, m_k1, m_k2, m_k3, m_k4);
184187 resultImage()->putPremultipliedImageData(imageData.get(), IntRect(IntPoint(), resultImage()->size()), IntPoint());
70143

WebCore/platform/graphics/filters/FEDisplacementMap.cpp

2626#if ENABLE(FILTERS)
2727#include "FEDisplacementMap.h"
2828
29 #include "CanvasPixelArray.h"
3029#include "Filter.h"
3130#include "GraphicsContext.h"
3231#include "ImageData.h"
3332
3433namespace WebCore {
3534
 35using WTF::ByteArray;
 36
3637FEDisplacementMap::FEDisplacementMap(ChannelSelectorType xChannelSelector, ChannelSelectorType yChannelSelector, float scale)
3738 : FilterEffect()
3839 , m_xChannelSelector(xChannelSelector)

@@void FEDisplacementMap::apply(Filter* fi
9394 return;
9495
9596 IntRect effectADrawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
96  RefPtr<CanvasPixelArray> srcPixelArrayA(in->resultImage()->getPremultipliedImageData(effectADrawingRect)->data());
 97 RefPtr<CanvasPixelArray> srcCanvasPixelArrayA(in->resultImage()->getPremultipliedImageData(effectADrawingRect)->data());
 98 ByteArray* srcPixelArrayA(srcCanvasPixelArrayA->data());
9799
98100 IntRect effectBDrawingRect = requestedRegionOfInputImageData(in2->absolutePaintRect());
99  RefPtr<CanvasPixelArray> srcPixelArrayB(in2->resultImage()->getUnmultipliedImageData(effectBDrawingRect)->data());
 101 RefPtr<CanvasPixelArray> srcCanvasPixelArrayB(in2->resultImage()->getUnmultipliedImageData(effectBDrawingRect)->data());
 102 ByteArray* srcPixelArrayB(srcCanvasPixelArrayB->data());
100103
101104 IntRect imageRect(IntPoint(), resultImage()->size());
102105 RefPtr<ImageData> imageData = ImageData::create(imageRect.width(), imageRect.height());
 106 ByteArray* dstPixelArray(imageData->data()->data());
103107
104108 ASSERT(srcPixelArrayA->length() == srcPixelArrayB->length());
105109

@@void FEDisplacementMap::apply(Filter* fi
116120 int srcY = y + static_cast<int>(scaleY * srcPixelArrayB->get(dstIndex + m_yChannelSelector - 1) + scaleAdjustmentY);
117121 for (unsigned channel = 0; channel < 4; ++channel) {
118122 if (srcX < 0 || srcX >= imageRect.width() || srcY < 0 || srcY >= imageRect.height())
119  imageData->data()->set(dstIndex + channel, static_cast<unsigned char>(0));
 123 dstPixelArray->set(dstIndex + channel, static_cast<unsigned char>(0));
120124 else {
121125 unsigned char pixelValue = srcPixelArrayA->get(srcY * stride + srcX * 4 + channel);
122  imageData->data()->set(dstIndex + channel, pixelValue);
 126 dstPixelArray->set(dstIndex + channel, pixelValue);
123127 }
124128 }
125129
70142

WebCore/platform/graphics/filters/FEGaussianBlur.cpp

2727#if ENABLE(FILTERS)
2828#include "FEGaussianBlur.h"
2929
30 #include "CanvasPixelArray.h"
3130#include "Filter.h"
3231#include "GraphicsContext.h"
3332#include "ImageData.h"
 33
3434#include <wtf/MathExtras.h>
3535
3636using std::max;

@@static const unsigned gMaxKernelSize = 1
4040
4141namespace WebCore {
4242
 43using WTF::ByteArray;
 44
4345FEGaussianBlur::FEGaussianBlur(float x, float y)
4446 : FilterEffect()
4547 , m_stdX(x)

@@void FEGaussianBlur::setStdDeviationY(fl
7274 m_stdY = y;
7375}
7476
75 static void boxBlur(CanvasPixelArray*& srcPixelArray, CanvasPixelArray*& dstPixelArray,
 77inline void boxBlur(ByteArray* srcPixelArray, ByteArray* dstPixelArray,
7678 unsigned dx, int dxLeft, int dxRight, int stride, int strideLine, int effectWidth, int effectHeight, bool alphaImage)
7779{
7880 for (int y = 0; y < effectHeight; ++y) {

@@void FEGaussianBlur::apply(Filter* filte
187189 unsigned kernelSizeY = 0;
188190 calculateKernelSize(filter, kernelSizeX, kernelSizeY, m_stdX, m_stdY);
189191
190  CanvasPixelArray* srcPixelArray(srcImageData->data());
 192 ByteArray* srcPixelArray(srcImageData->data()->data());
191193 RefPtr<ImageData> tmpImageData = ImageData::create(imageRect.width(), imageRect.height());
192  CanvasPixelArray* tmpPixelArray(tmpImageData->data());
 194 ByteArray* tmpPixelArray(tmpImageData->data()->data());
193195
194196 int stride = 4 * imageRect.width();
195197 int dxLeft = 0;

@@void FEGaussianBlur::apply(Filter* filte
201203 kernelPosition(i, kernelSizeX, dxLeft, dxRight);
202204 boxBlur(srcPixelArray, tmpPixelArray, kernelSizeX, dxLeft, dxRight, 4, stride, imageRect.width(), imageRect.height(), isAlphaImage());
203205 } else {
204  CanvasPixelArray* auxPixelArray = tmpPixelArray;
 206 ByteArray* auxPixelArray = tmpPixelArray;
205207 tmpPixelArray = srcPixelArray;
206208 srcPixelArray = auxPixelArray;
207209 }

@@void FEGaussianBlur::apply(Filter* filte
210212 kernelPosition(i, kernelSizeY, dyLeft, dyRight);
211213 boxBlur(tmpPixelArray, srcPixelArray, kernelSizeY, dyLeft, dyRight, stride, 4, imageRect.height(), imageRect.width(), isAlphaImage());
212214 } else {
213  CanvasPixelArray* auxPixelArray = tmpPixelArray;
 215 ByteArray* auxPixelArray = tmpPixelArray;
214216 tmpPixelArray = srcPixelArray;
215217 srcPixelArray = auxPixelArray;
216218 }
70142

WebCore/platform/graphics/filters/FEMorphology.cpp

2626#if ENABLE(FILTERS)
2727#include "FEMorphology.h"
2828
29 #include "CanvasPixelArray.h"
3029#include "Filter.h"
3130#include "ImageData.h"
3231

@@using std::max;
3736
3837namespace WebCore {
3938
 39using WTF::ByteArray;
 40
4041FEMorphology::FEMorphology(MorphologyOperatorType type, float radiusX, float radiusY)
4142 : FilterEffect()
4243 , m_type(type)

@@void FEMorphology::apply(Filter* filter)
108109
109110 IntRect imageRect(IntPoint(), resultImage()->size());
110111 IntRect effectDrawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
111  RefPtr<CanvasPixelArray> srcPixelArray(in->resultImage()->getPremultipliedImageData(effectDrawingRect)->data());
 112 RefPtr<CanvasPixelArray> srcCanvasPixelArray(in->resultImage()->getPremultipliedImageData(effectDrawingRect)->data());
 113 ByteArray* srcPixelArray(srcCanvasPixelArray->data());
112114 RefPtr<ImageData> imageData = ImageData::create(imageRect.width(), imageRect.height());
 115 ByteArray* dstPixelArray(imageData->data()->data());
113116
114117 int effectWidth = effectDrawingRect.width() * 4;
115118

@@void FEMorphology::apply(Filter* filter)
155158 (m_type == FEMORPHOLOGY_OPERATOR_DILATE && extrema[kernelIndex] >= entireExtrema))
156159 entireExtrema = extrema[kernelIndex];
157160 }
158  imageData->data()->set(y * effectWidth + 4 * x + channel, entireExtrema);
 161 dstPixelArray->set(y * effectWidth + 4 * x + channel, entireExtrema);
159162 }
160163 }
161164 }
70142

WebCore/platform/graphics/filters/FETurbulence.cpp

2626#if ENABLE(FILTERS)
2727#include "FETurbulence.h"
2828
29 #include "CanvasPixelArray.h"
3029#include "Filter.h"
3130#include "ImageData.h"
3231

3433
3534namespace WebCore {
3635
 36using WTF::ByteArray;
 37
3738/*
3839 Produces results in the range [1, 2**31 - 2]. Algorithm is:
3940 r = (a * r) mod m where a = randAmplitude = 16807 and

@@void FETurbulence::apply(Filter* filter)
329330 return;
330331
331332 RefPtr<ImageData> imageData = ImageData::create(imageRect.width(), imageRect.height());
 333 ByteArray* pixelArray(imageData->data()->data());
332334 PaintingData paintingData(m_seed, roundedIntSize(filterPrimitiveSubregion().size()));
333335 initPaint(paintingData);
334336

@@void FETurbulence::apply(Filter* filter)
342344 for (int x = 0; x < imageRect.width(); ++x) {
343345 point.setX(point.x() + 1);
344346 for (paintingData.channel = 0; paintingData.channel < 4; ++paintingData.channel, ++indexOfPixelChannel)
345  imageData->data()->set(indexOfPixelChannel, calculateTurbulenceValueForPoint(paintingData, filter->mapAbsolutePointToLocalPoint(point)));
 347 pixelArray->set(indexOfPixelChannel, calculateTurbulenceValueForPoint(paintingData, filter->mapAbsolutePointToLocalPoint(point)));
346348 }
347349 }
348350 resultImage()->putUnmultipliedImageData(imageData.get(), imageRect, IntPoint());
70142

WebCore/rendering/RenderSVGResourceMasker.cpp

4444
4545namespace WebCore {
4646
 47using WTF::ByteArray;
 48
 49
4750RenderSVGResourceType RenderSVGResourceMasker::s_resourceType = MaskerResourceType;
4851
4952RenderSVGResourceMasker::RenderSVGResourceMasker(SVGMaskElement* node)

@@void RenderSVGResourceMasker::drawConten
162165 // Create the luminance mask.
163166 IntRect maskImageRect(IntPoint(), maskerData->maskImage->size());
164167 RefPtr<ImageData> imageData(maskerData->maskImage->getUnmultipliedImageData(maskImageRect));
165  CanvasPixelArray* srcPixelArray(imageData->data());
 168 ByteArray* srcPixelArray(imageData->data()->data());
166169
167  for (unsigned pixelOffset = 0; pixelOffset < srcPixelArray->length(); pixelOffset += 4) {
 170 unsigned pixelArrayLength = srcPixelArray->length();
 171 for (unsigned pixelOffset = 0; pixelOffset < pixelArrayLength; pixelOffset += 4) {
168172 unsigned char a = srcPixelArray->get(pixelOffset + 3);
169173 if (!a)
170174 continue;
70143