void FilterEffect::apply()
{
if (hasResult())
return;
unsigned size = m_inputEffects.size();
for (unsigned i = 0; i < size; ++i) {
FilterEffect* in = m_inputEffects.at(i).get();
in->apply();
if (!in->hasResult())
return;
// Convert input results to the current effect's color space.
transformResultColorSpace(in, i);
}
determineAbsolutePaintRect();
setResultColorSpace(m_operatingColorSpace);
if (m_absolutePaintRect.isEmpty() || ImageBuffer::sizeNeedsClamping(m_absolutePaintRect.size()))
return;
if (requiresValidPreMultipliedPixels()) {
for (unsigned i = 0; i < size; ++i)
inputEffect(i)->correctFilterResultIfNeeded();
}
// Add platform specific apply functions here and return earlier.
platformApplySoftware();
}
void FilterEffect::apply()
{
if (hasResult())
return;
unsigned size = m_inputEffects.size();
for (unsigned i = 0; i < size; ++i) {
FilterEffect* in = m_inputEffects.at(i).get();
in->apply();
if (!in->hasResult())
return;
// Convert input results to the current effect's color space.
transformResultColorSpace(in, i);
}
determineAbsolutePaintRect();
setResultColorSpace(m_operatingColorSpace);
if (!isFilterSizeValid(m_absolutePaintRect))
return;
if (requiresValidPreMultipliedPixels()) {
for (unsigned i = 0; i < size; ++i)
inputEffect(i)->correctFilterResultIfNeeded();
}
// Add platform specific apply functions here and return earlier.
#if ENABLE(OPENCL)
if (platformApplyOpenCL())
return;
#endif
platformApplySoftware();
}
void FilterEffect::applyRecursive()
{
if (hasResult())
return;
unsigned size = m_inputEffects.size();
for (unsigned i = 0; i < size; ++i) {
FilterEffect* in = m_inputEffects.at(i).get();
in->applyRecursive();
if (!in->hasResult())
return;
// Convert input results to the current effect's color space.
transformResultColorSpace(in, i);
}
setResultColorSpace(m_operatingColorSpace);
if (!isFilterSizeValid(m_absolutePaintRect))
return;
if (!mayProduceInvalidPreMultipliedPixels()) {
for (unsigned i = 0; i < size; ++i)
inputEffect(i)->correctFilterResultIfNeeded();
}
applySoftware();
}
void FEMorphology::apply()
{
if (hasResult())
return;
FilterEffect* in = inputEffect(0);
in->apply();
if (!in->hasResult())
return;
ByteArray* dstPixelArray = createPremultipliedImageResult();
if (!dstPixelArray)
return;
setIsAlphaImage(in->isAlphaImage());
if (m_radiusX <= 0 || m_radiusY <= 0)
return;
Filter* filter = this->filter();
int radiusX = static_cast<int>(floorf(filter->applyHorizontalScale(m_radiusX)));
int radiusY = static_cast<int>(floorf(filter->applyVerticalScale(m_radiusY)));
IntRect effectDrawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
RefPtr<ByteArray> srcPixelArray = in->asPremultipliedImage(effectDrawingRect);
PaintingData paintingData;
paintingData.srcPixelArray = srcPixelArray.get();
paintingData.dstPixelArray = dstPixelArray;
paintingData.width = effectDrawingRect.width();
paintingData.height = effectDrawingRect.height();
paintingData.radiusX = min(effectDrawingRect.width() - 1, radiusX);
paintingData.radiusY = min(effectDrawingRect.height() - 1, radiusY);
platformApply(&paintingData);
}
void FEGaussianBlur::apply()
{
if (hasResult())
return;
FilterEffect* in = inputEffect(0);
in->apply();
if (!in->hasResult())
return;
ByteArray* srcPixelArray = createPremultipliedImageResult();
if (!srcPixelArray)
return;
setIsAlphaImage(in->isAlphaImage());
IntRect effectDrawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
in->copyPremultipliedImage(srcPixelArray, effectDrawingRect);
if (!m_stdX && !m_stdY)
return;
unsigned kernelSizeX = 0;
unsigned kernelSizeY = 0;
calculateKernelSize(filter(), kernelSizeX, kernelSizeY, m_stdX, m_stdY);
IntSize paintSize = absolutePaintRect().size();
RefPtr<ByteArray> tmpImageData = ByteArray::create(paintSize.width() * paintSize.height() * 4);
ByteArray* tmpPixelArray = tmpImageData.get();
platformApply(srcPixelArray, tmpPixelArray, kernelSizeX, kernelSizeY, paintSize);
}
void FEDisplacementMap::apply()
{
if (hasResult())
return;
FilterEffect* in = inputEffect(0);
FilterEffect* in2 = inputEffect(1);
in->apply();
in2->apply();
if (!in->hasResult() || !in2->hasResult())
return;
if (m_xChannelSelector == CHANNEL_UNKNOWN || m_yChannelSelector == CHANNEL_UNKNOWN)
return;
ByteArray* dstPixelArray = createPremultipliedImageResult();
if (!dstPixelArray)
return;
IntRect effectADrawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
RefPtr<ByteArray> srcPixelArrayA = in->asPremultipliedImage(effectADrawingRect);
IntRect effectBDrawingRect = requestedRegionOfInputImageData(in2->absolutePaintRect());
RefPtr<ByteArray> srcPixelArrayB = in2->asUnmultipliedImage(effectBDrawingRect);
ASSERT(srcPixelArrayA->length() == srcPixelArrayB->length());
Filter* filter = this->filter();
IntSize paintSize = absolutePaintRect().size();
float scaleX = filter->applyHorizontalScale(m_scale / 255);
float scaleY = filter->applyVerticalScale(m_scale / 255);
float scaleAdjustmentX = filter->applyHorizontalScale(0.5f - 0.5f * m_scale);
float scaleAdjustmentY = filter->applyVerticalScale(0.5f - 0.5f * m_scale);
int stride = paintSize.width() * 4;
for (int y = 0; y < paintSize.height(); ++y) {
int line = y * stride;
for (int x = 0; x < paintSize.width(); ++x) {
int dstIndex = line + x * 4;
int srcX = x + static_cast<int>(scaleX * srcPixelArrayB->get(dstIndex + m_xChannelSelector - 1) + scaleAdjustmentX);
int srcY = y + static_cast<int>(scaleY * srcPixelArrayB->get(dstIndex + m_yChannelSelector - 1) + scaleAdjustmentY);
for (unsigned channel = 0; channel < 4; ++channel) {
if (srcX < 0 || srcX >= paintSize.width() || srcY < 0 || srcY >= paintSize.height())
dstPixelArray->set(dstIndex + channel, static_cast<unsigned char>(0));
else {
unsigned char pixelValue = srcPixelArrayA->get(srcY * stride + srcX * 4 + channel);
dstPixelArray->set(dstIndex + channel, pixelValue);
}
}
}
}
}
void FilterEffect::apply()
{
if (hasResult())
return;
unsigned size = m_inputEffects.size();
for (unsigned i = 0; i < size; ++i) {
FilterEffect* in = m_inputEffects.at(i).get();
in->apply();
if (!in->hasResult())
return;
}
determineAbsolutePaintRect();
// Add platform specific apply functions here and return earlier.
platformApplySoftware();
}
void FEBlend::apply()
{
if (hasResult())
return;
FilterEffect* in = inputEffect(0);
FilterEffect* in2 = inputEffect(1);
in->apply();
in2->apply();
if (!in->hasResult() || !in2->hasResult())
return;
ASSERT(m_mode > FEBLEND_MODE_UNKNOWN);
ASSERT(m_mode <= FEBLEND_MODE_LIGHTEN);
ByteArray* dstPixelArray = createPremultipliedImageResult();
if (!dstPixelArray)
return;
IntRect effectADrawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
RefPtr<ByteArray> srcPixelArrayA = in->asPremultipliedImage(effectADrawingRect);
IntRect effectBDrawingRect = requestedRegionOfInputImageData(in2->absolutePaintRect());
RefPtr<ByteArray> srcPixelArrayB = in2->asPremultipliedImage(effectBDrawingRect);
// Keep synchronized with BlendModeType
static const BlendType callEffect[] = {unknown, normal, multiply, screen, darken, lighten};
unsigned pixelArrayLength = srcPixelArrayA->length();
ASSERT(pixelArrayLength == srcPixelArrayB->length());
for (unsigned pixelOffset = 0; pixelOffset < pixelArrayLength; pixelOffset += 4) {
unsigned char alphaA = srcPixelArrayA->get(pixelOffset + 3);
unsigned char alphaB = srcPixelArrayB->get(pixelOffset + 3);
for (unsigned channel = 0; channel < 3; ++channel) {
unsigned char colorA = srcPixelArrayA->get(pixelOffset + channel);
unsigned char colorB = srcPixelArrayB->get(pixelOffset + channel);
unsigned char result = (*callEffect[m_mode])(colorA, colorB, alphaA, alphaB);
dstPixelArray->set(pixelOffset + channel, result);
}
unsigned char alphaR = 255 - ((255 - alphaA) * (255 - alphaB)) / 255;
dstPixelArray->set(pixelOffset + 3, alphaR);
}
}
void FEOffset::apply()
{
if (hasResult())
return;
FilterEffect* in = inputEffect(0);
in->apply();
if (!in->hasResult())
return;
ImageBuffer* resultImage = createImageBufferResult();
if (!resultImage)
return;
setIsAlphaImage(in->isAlphaImage());
FloatRect drawingRegion = drawingRegionOfInputImage(in->absolutePaintRect());
Filter* filter = this->filter();
drawingRegion.move(filter->applyHorizontalScale(m_dx), filter->applyVerticalScale(m_dy));
resultImage->context()->drawImageBuffer(in->asImageBuffer(), ColorSpaceDeviceRGB, drawingRegion);
}
void FEColorMatrix::apply()
{
if (hasResult())
return;
FilterEffect* in = inputEffect(0);
in->apply();
if (!in->hasResult())
return;
ImageBuffer* resultImage = createImageBufferResult();
if (!resultImage)
return;
resultImage->context()->drawImageBuffer(in->asImageBuffer(), ColorSpaceDeviceRGB, drawingRegionOfInputImage(in->absolutePaintRect()));
IntRect imageRect(IntPoint(), absolutePaintRect().size());
RefPtr<ImageData> imageData = resultImage->getUnmultipliedImageData(imageRect);
ByteArray* pixelArray = imageData->data()->data();
switch (m_type) {
case FECOLORMATRIX_TYPE_UNKNOWN:
break;
case FECOLORMATRIX_TYPE_MATRIX:
effectType<FECOLORMATRIX_TYPE_MATRIX>(pixelArray, m_values);
break;
case FECOLORMATRIX_TYPE_SATURATE:
effectType<FECOLORMATRIX_TYPE_SATURATE>(pixelArray, m_values);
break;
case FECOLORMATRIX_TYPE_HUEROTATE:
effectType<FECOLORMATRIX_TYPE_HUEROTATE>(pixelArray, m_values);
break;
case FECOLORMATRIX_TYPE_LUMINANCETOALPHA:
effectType<FECOLORMATRIX_TYPE_LUMINANCETOALPHA>(pixelArray, m_values);
setIsAlphaImage(true);
break;
}
resultImage->putUnmultipliedImageData(imageData.get(), imageRect, IntPoint());
}
void FEMerge::apply()
{
if (hasResult())
return;
unsigned size = numberOfEffectInputs();
ASSERT(size > 0);
for (unsigned i = 0; i < size; ++i) {
FilterEffect* in = inputEffect(i);
in->apply();
if (!in->hasResult())
return;
}
ImageBuffer* resultImage = createImageBufferResult();
if (!resultImage)
return;
GraphicsContext* filterContext = resultImage->context();
for (unsigned i = 0; i < size; ++i) {
FilterEffect* in = inputEffect(i);
filterContext->drawImageBuffer(in->asImageBuffer(), ColorSpaceDeviceRGB, drawingRegionOfInputImage(in->absolutePaintRect()));
}
}
void FEConvolveMatrix::apply()
{
if (hasResult())
return;
FilterEffect* in = inputEffect(0);
in->apply();
if (!in->hasResult())
return;
ByteArray* resultImage;
if (m_preserveAlpha)
resultImage = createUnmultipliedImageResult();
else
resultImage = createPremultipliedImageResult();
if (!resultImage)
return;
IntRect effectDrawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
RefPtr<ByteArray> srcPixelArray;
if (m_preserveAlpha)
srcPixelArray = in->asUnmultipliedImage(effectDrawingRect);
else
srcPixelArray = in->asPremultipliedImage(effectDrawingRect);
IntSize paintSize = absolutePaintRect().size();
PaintingData paintingData;
paintingData.srcPixelArray = srcPixelArray.get();
paintingData.dstPixelArray = resultImage;
paintingData.width = paintSize.width();
paintingData.height = paintSize.height();
paintingData.bias = m_bias * 255;
// Drawing fully covered pixels
int clipRight = paintSize.width() - m_kernelSize.width();
int clipBottom = paintSize.height() - m_kernelSize.height();
if (clipRight >= 0 && clipBottom >= 0) {
#if ENABLE(PARALLEL_JOBS)
int optimalThreadNumber = (absolutePaintRect().width() * absolutePaintRect().height()) / s_minimalRectDimension;
if (optimalThreadNumber > 1) {
ParallelJobs<InteriorPixelParameters> parallelJobs(&WebCore::FEConvolveMatrix::setInteriorPixelsWorker, optimalThreadNumber);
const int numOfThreads = parallelJobs.numberOfJobs();
const int heightPerThread = clipBottom / numOfThreads;
int startY = 0;
for (int job = 0; job < numOfThreads; ++job) {
InteriorPixelParameters& param = parallelJobs.parameter(job);
param.filter = this;
param.paintingData = &paintingData;
param.clipRight = clipRight;
param.clipBottom = clipBottom;
param.yStart = startY;
if (job < numOfThreads - 1) {
startY += heightPerThread;
param.yEnd = startY - 1;
} else
param.yEnd = clipBottom;
}
parallelJobs.execute();
} else
// Fallback to the default setInteriorPixels call.
#endif
setInteriorPixels(paintingData, clipRight, clipBottom, 0, clipBottom);
clipRight += m_targetOffset.x() + 1;
clipBottom += m_targetOffset.y() + 1;
if (m_targetOffset.y() > 0)
setOuterPixels(paintingData, 0, 0, paintSize.width(), m_targetOffset.y());
if (clipBottom < paintSize.height())
setOuterPixels(paintingData, 0, clipBottom, paintSize.width(), paintSize.height());
if (m_targetOffset.x() > 0)
setOuterPixels(paintingData, 0, m_targetOffset.y(), m_targetOffset.x(), clipBottom);
if (clipRight < paintSize.width())
setOuterPixels(paintingData, clipRight, m_targetOffset.y(), paintSize.width(), clipBottom);
} else {
// Rare situation, not optimizied for speed
setOuterPixels(paintingData, 0, 0, paintSize.width(), paintSize.height());
}
}
void RenderSVGResourceFilter::postApplyResource(RenderElement& renderer, GraphicsContext*& context, unsigned short resourceMode, const Path*, const RenderSVGShape*)
{
ASSERT(context);
ASSERT_UNUSED(resourceMode, resourceMode == ApplyToDefaultMode);
FilterData* filterData = m_filter.get(&renderer);
if (!filterData)
return;
switch (filterData->state) {
case FilterData::MarkedForRemoval:
m_filter.remove(&renderer);
return;
case FilterData::CycleDetected:
case FilterData::Applying:
// We have a cycle if we are already applying the data.
// This can occur due to FeImage referencing a source that makes use of the FEImage itself.
// This is the first place we've hit the cycle, so set the state back to PaintingSource so the return stack
// will continue correctly.
filterData->state = FilterData::PaintingSource;
return;
case FilterData::PaintingSource:
if (!filterData->savedContext) {
removeClientFromCache(renderer);
return;
}
context = filterData->savedContext;
filterData->savedContext = 0;
break;
case FilterData::Built:
{ } // Empty
}
FilterEffect* lastEffect = filterData->builder->lastEffect();
if (lastEffect && !filterData->boundaries.isEmpty() && !lastEffect->filterPrimitiveSubregion().isEmpty()) {
// This is the real filtering of the object. It just needs to be called on the
// initial filtering process. We just take the stored filter result on a
// second drawing.
if (filterData->state != FilterData::Built)
filterData->filter->setSourceImage(WTF::move(filterData->sourceGraphicBuffer));
// Always true if filterData is just built (filterData->state == FilterData::Built).
if (!lastEffect->hasResult()) {
filterData->state = FilterData::Applying;
lastEffect->applyAll();
lastEffect->correctFilterResultIfNeeded();
lastEffect->transformResultColorSpace(ColorSpaceDeviceRGB);
}
filterData->state = FilterData::Built;
ImageBuffer* resultImage = lastEffect->asImageBuffer();
if (resultImage) {
context->concatCTM(filterData->shearFreeAbsoluteTransform.inverse());
context->scale(FloatSize(1 / filterData->filter->filterResolution().width(), 1 / filterData->filter->filterResolution().height()));
context->drawImageBuffer(resultImage, renderer.style().colorSpace(), lastEffect->absolutePaintRect());
context->scale(filterData->filter->filterResolution());
context->concatCTM(filterData->shearFreeAbsoluteTransform);
}
}
filterData->sourceGraphicBuffer.reset();
}
void RenderSVGResourceFilter::postApplyResource(RenderObject* object, GraphicsContext*& context, unsigned short resourceMode, const Path*, const RenderSVGShape*)
{
ASSERT(object);
ASSERT(context);
ASSERT_UNUSED(resourceMode, resourceMode == ApplyToDefaultMode);
FilterData* filterData = m_filter.get(object);
if (!filterData)
return;
if (filterData->markedForRemoval) {
delete m_filter.take(object);
return;
}
if (!filterData->builded) {
if (!filterData->savedContext) {
removeClientFromCache(object);
return;
}
context = filterData->savedContext;
filterData->savedContext = 0;
#if !USE(CG)
if (filterData->sourceGraphicBuffer)
filterData->sourceGraphicBuffer->transformColorSpace(ColorSpaceDeviceRGB, ColorSpaceLinearRGB);
#endif
}
FilterEffect* lastEffect = filterData->builder->lastEffect();
if (lastEffect && !filterData->boundaries.isEmpty() && !lastEffect->filterPrimitiveSubregion().isEmpty()) {
// This is the real filtering of the object. It just needs to be called on the
// initial filtering process. We just take the stored filter result on a
// second drawing.
if (!filterData->builded)
filterData->filter->setSourceImage(filterData->sourceGraphicBuffer.release());
// Always true if filterData is just built (filterData->builded is false).
if (!lastEffect->hasResult()) {
lastEffect->apply();
#if !USE(CG)
ImageBuffer* resultImage = lastEffect->asImageBuffer();
if (resultImage)
resultImage->transformColorSpace(ColorSpaceLinearRGB, ColorSpaceDeviceRGB);
#endif
}
filterData->builded = true;
ImageBuffer* resultImage = lastEffect->asImageBuffer();
if (resultImage) {
context->concatCTM(filterData->shearFreeAbsoluteTransform.inverse());
context->scale(FloatSize(1 / filterData->filter->filterResolution().width(), 1 / filterData->filter->filterResolution().height()));
context->clip(lastEffect->maxEffectRect());
context->drawImageBuffer(resultImage, object->style()->colorSpace(), lastEffect->absolutePaintRect());
context->scale(filterData->filter->filterResolution());
context->concatCTM(filterData->shearFreeAbsoluteTransform);
}
}
filterData->sourceGraphicBuffer.clear();
}
