void FEMorphology::platformApply(PaintingData* paintingData)
{
int optimalThreadNumber = (paintingData->width * paintingData->height) / s_minimalArea;
if (optimalThreadNumber > 1) {
ParallelJobs<PlatformApplyParameters> parallelJobs(&WebCore::FEMorphology::platformApplyWorker, optimalThreadNumber);
int numOfThreads = parallelJobs.numberOfJobs();
if (numOfThreads > 1) {
// Split the job into "jobSize"-sized jobs but there a few jobs that need to be slightly larger since
// jobSize * jobs < total size. These extras are handled by the remainder "jobsWithExtra".
const int jobSize = paintingData->height / numOfThreads;
const int jobsWithExtra = paintingData->height % numOfThreads;
int currentY = 0;
for (int job = numOfThreads - 1; job >= 0; --job) {
PlatformApplyParameters& param = parallelJobs.parameter(job);
param.filter = this;
param.startY = currentY;
currentY += job < jobsWithExtra ? jobSize + 1 : jobSize;
param.endY = currentY;
param.paintingData = paintingData;
}
parallelJobs.execute();
return;
}
// Fallback to single thread model
}
platformApplyGeneric(paintingData, 0, paintingData->height);
}
void FEMorphology::platformApply(PaintingData* paintingData)
{
#if ENABLE(PARALLEL_JOBS)
int optimalThreadNumber = (paintingData->width * paintingData->height) / s_minimalArea;
if (optimalThreadNumber > 1) {
ParallelJobs<PlatformApplyParameters> parallelJobs(&WebCore::FEMorphology::platformApplyWorker, optimalThreadNumber);
int numOfThreads = parallelJobs.numberOfJobs();
if (numOfThreads > 1) {
const int deltaY = 1 + paintingData->height / numOfThreads;
int currentY = 0;
for (int job = numOfThreads - 1; job >= 0; --job) {
PlatformApplyParameters& param = parallelJobs.parameter(job);
param.filter = this;
param.startY = currentY;
currentY += deltaY;
param.endY = job ? currentY : paintingData->height;
param.paintingData = paintingData;
}
parallelJobs.execute();
return;
}
// Fallback to single thread model
}
#endif
platformApplyGeneric(paintingData, 0, paintingData->height);
}
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 FEBlend::platformApplySoftware()
{
FilterEffect* in = inputEffect(0);
FilterEffect* in2 = inputEffect(1);
ASSERT(m_mode > FEBLEND_MODE_UNKNOWN);
ASSERT(m_mode <= FEBLEND_MODE_LIGHTEN);
Uint8ClampedArray* dstPixelArray = createPremultipliedImageResult();
if (!dstPixelArray)
return;
IntRect effectADrawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
RefPtr<Uint8ClampedArray> srcPixelArrayA = in->asPremultipliedImage(effectADrawingRect);
IntRect effectBDrawingRect = requestedRegionOfInputImageData(in2->absolutePaintRect());
RefPtr<Uint8ClampedArray> srcPixelArrayB = in2->asPremultipliedImage(effectBDrawingRect);
unsigned pixelArrayLength = srcPixelArrayA->length();
ASSERT(pixelArrayLength == srcPixelArrayB->length());
#if HAVE(ARM_NEON_INTRINSICS)
if (pixelArrayLength >= 8)
platformApplyNEON(srcPixelArrayA->data(), srcPixelArrayB->data(), dstPixelArray->data(), pixelArrayLength);
else { // If there is just one pixel we expand it to two.
ASSERT(pixelArrayLength > 0);
uint32_t sourceA[2] = {0, 0};
uint32_t sourceBAndDest[2] = {0, 0};
sourceA[0] = reinterpret_cast<uint32_t*>(srcPixelArrayA->data())[0];
sourceBAndDest[0] = reinterpret_cast<uint32_t*>(srcPixelArrayB->data())[0];
platformApplyNEON(reinterpret_cast<uint8_t*>(sourceA), reinterpret_cast<uint8_t*>(sourceBAndDest), reinterpret_cast<uint8_t*>(sourceBAndDest), 8);
reinterpret_cast<uint32_t*>(dstPixelArray->data())[0] = sourceBAndDest[0];
}
#else
platformApplyGeneric(srcPixelArrayA->data(), srcPixelArrayB->data(), dstPixelArray->data(), pixelArrayLength);
#endif
}
inline void FEGaussianBlur::platformApply(Uint8ClampedArray* srcPixelArray, Uint8ClampedArray* tmpPixelArray, unsigned kernelSizeX, unsigned kernelSizeY, IntSize& paintSize)
{
int scanline = 4 * paintSize.width();
int extraHeight = 3 * kernelSizeY * 0.5f;
int optimalThreadNumber = (paintSize.width() * paintSize.height()) / (s_minimalRectDimension + extraHeight * paintSize.width());
if (optimalThreadNumber > 1) {
WTF::ParallelJobs<PlatformApplyParameters> parallelJobs(&platformApplyWorker, optimalThreadNumber);
int jobs = parallelJobs.numberOfJobs();
if (jobs > 1) {
int blockHeight = paintSize.height() / jobs;
--jobs;
for (int job = jobs; job >= 0; --job) {
PlatformApplyParameters& params = parallelJobs.parameter(job);
params.filter = this;
int startY;
int endY;
if (!job) {
startY = 0;
endY = blockHeight + extraHeight;
params.srcPixelArray = srcPixelArray;
params.dstPixelArray = tmpPixelArray;
} else {
if (job == jobs) {
startY = job * blockHeight - extraHeight;
endY = paintSize.height();
} else {
startY = job * blockHeight - extraHeight;
endY = (job + 1) * blockHeight + extraHeight;
}
int blockSize = (endY - startY) * scanline;
params.srcPixelArray = Uint8ClampedArray::createUninitialized(blockSize);
params.dstPixelArray = Uint8ClampedArray::createUninitialized(blockSize);
memcpy(params.srcPixelArray->data(), srcPixelArray->data() + startY * scanline, blockSize);
}
params.width = paintSize.width();
params.height = endY - startY;
params.kernelSizeX = kernelSizeX;
params.kernelSizeY = kernelSizeY;
}
parallelJobs.execute();
// Copy together the parts of the image.
for (int job = jobs; job >= 1; --job) {
PlatformApplyParameters& params = parallelJobs.parameter(job);
int sourceOffset;
int destinationOffset;
int size;
if (job == jobs) {
sourceOffset = extraHeight * scanline;
destinationOffset = job * blockHeight * scanline;
size = (paintSize.height() - job * blockHeight) * scanline;
} else {
sourceOffset = extraHeight * scanline;
destinationOffset = job * blockHeight * scanline;
size = blockHeight * scanline;
}
memcpy(srcPixelArray->data() + destinationOffset, params.srcPixelArray->data() + sourceOffset, size);
}
return;
}
// Fallback to single threaded mode.
}
// The selection here eventually should happen dynamically on some platforms.
#if CPU(ARM_NEON) && COMPILER(GCC)
platformApplyNeon(srcPixelArray, tmpPixelArray, kernelSizeX, kernelSizeY, paintSize);
#else
platformApplyGeneric(srcPixelArray, tmpPixelArray, kernelSizeX, kernelSizeY, paintSize);
#endif
}
inline void FEGaussianBlur::platformApply(Uint8ClampedArray* srcPixelArray, Uint8ClampedArray* tmpPixelArray, unsigned kernelSizeX, unsigned kernelSizeY, IntSize& paintSize)
{
int scanline = 4 * paintSize.width();
int extraHeight = 3 * kernelSizeY * 0.5f;
int optimalThreadNumber = (paintSize.width() * paintSize.height()) / (s_minimalRectDimension + extraHeight * paintSize.width());
if (optimalThreadNumber > 1) {
WTF::ParallelJobs<PlatformApplyParameters> parallelJobs(&platformApplyWorker, optimalThreadNumber);
int jobs = parallelJobs.numberOfJobs();
if (jobs > 1) {
// Split the job into "blockHeight"-sized jobs but there a few jobs that need to be slightly larger since
// blockHeight * jobs < total size. These extras are handled by the remainder "jobsWithExtra".
const int blockHeight = paintSize.height() / jobs;
const int jobsWithExtra = paintSize.height() % jobs;
int currentY = 0;
for (int job = 0; job < jobs; job++) {
PlatformApplyParameters& params = parallelJobs.parameter(job);
params.filter = this;
int startY = !job ? 0 : currentY - extraHeight;
currentY += job < jobsWithExtra ? blockHeight + 1 : blockHeight;
int endY = job == jobs - 1 ? currentY : currentY + extraHeight;
int blockSize = (endY - startY) * scanline;
if (!job) {
params.srcPixelArray = srcPixelArray;
params.dstPixelArray = tmpPixelArray;
} else {
params.srcPixelArray = Uint8ClampedArray::createUninitialized(blockSize);
params.dstPixelArray = Uint8ClampedArray::createUninitialized(blockSize);
memcpy(params.srcPixelArray->data(), srcPixelArray->data() + startY * scanline, blockSize);
}
params.width = paintSize.width();
params.height = endY - startY;
params.kernelSizeX = kernelSizeX;
params.kernelSizeY = kernelSizeY;
}
parallelJobs.execute();
// Copy together the parts of the image.
currentY = 0;
for (int job = 1; job < jobs; job++) {
PlatformApplyParameters& params = parallelJobs.parameter(job);
int sourceOffset;
int destinationOffset;
int size;
int adjustedBlockHeight = job < jobsWithExtra ? blockHeight + 1 : blockHeight;
currentY += adjustedBlockHeight;
sourceOffset = extraHeight * scanline;
destinationOffset = currentY * scanline;
size = adjustedBlockHeight * scanline;
memcpy(srcPixelArray->data() + destinationOffset, params.srcPixelArray->data() + sourceOffset, size);
}
return;
}
// Fallback to single threaded mode.
}
// The selection here eventually should happen dynamically on some platforms.
platformApplyGeneric(srcPixelArray, tmpPixelArray, kernelSizeX, kernelSizeY, paintSize);
}
