#include "config.h"
#include "ShadowBlur.h"
#include "AffineTransform.h"
#include "FloatQuad.h"
#include "GraphicsContext.h"
#include "ImageBuffer.h"
#include "Timer.h"
#include <wtf/MathExtras.h>
#include <wtf/Noncopyable.h>
namespace WebCore {
enum {
leftLobe = 0,
rightLobe = 1
};
static inline int roundUpToMultipleOf32(int d)
{
return (1 + (d >> 5)) << 5;
}
class ScratchBuffer {
WTF_MAKE_FAST_ALLOCATED;
public:
ScratchBuffer()
: m_purgeTimer(this, &ScratchBuffer::timerFired)
, m_lastWasInset(false)
#if !ASSERT_DISABLED
, m_bufferInUse(false)
#endif
{
}
ImageBuffer* getScratchBuffer(const IntSize& size)
{
ASSERT(!m_bufferInUse);
#if !ASSERT_DISABLED
m_bufferInUse = true;
#endif
if (m_imageBuffer && m_imageBuffer->logicalSize().width() >= size.width() && m_imageBuffer->logicalSize().height() >= size.height())
return m_imageBuffer.get();
IntSize roundedSize(roundUpToMultipleOf32(size.width()), roundUpToMultipleOf32(size.height()));
clearScratchBuffer();
m_imageBuffer = ImageBuffer::create(roundedSize, 1);
return m_imageBuffer.get();
}
bool setCachedShadowValues(const FloatSize& radius, const Color& color, ColorSpace colorSpace, const FloatRect& shadowRect, const FloatRoundedRect::Radii& radii, const FloatSize& layerSize)
{
if (!m_lastWasInset && m_lastRadius == radius && m_lastColor == color && m_lastColorSpace == colorSpace && m_lastShadowRect == shadowRect && m_lastRadii == radii && m_lastLayerSize == layerSize)
return false;
m_lastWasInset = false;
m_lastRadius = radius;
m_lastColor = color;
m_lastColorSpace = colorSpace;
m_lastShadowRect = shadowRect;
m_lastRadii = radii;
m_lastLayerSize = layerSize;
return true;
}
bool setCachedInsetShadowValues(const FloatSize& radius, const Color& color, ColorSpace colorSpace, const FloatRect& bounds, const FloatRect& shadowRect, const FloatRoundedRect::Radii& radii)
{
if (m_lastWasInset && m_lastRadius == radius && m_lastColor == color && m_lastColorSpace == colorSpace && m_lastInsetBounds == bounds && shadowRect == m_lastShadowRect && radii == m_lastRadii)
return false;
m_lastWasInset = true;
m_lastInsetBounds = bounds;
m_lastRadius = radius;
m_lastColor = color;
m_lastColorSpace = colorSpace;
m_lastShadowRect = shadowRect;
m_lastRadii = radii;
return true;
}
void scheduleScratchBufferPurge()
{
#if !ASSERT_DISABLED
m_bufferInUse = false;
#endif
if (m_purgeTimer.isActive())
m_purgeTimer.stop();
const double scratchBufferPurgeInterval = 2;
m_purgeTimer.startOneShot(scratchBufferPurgeInterval);
}
static ScratchBuffer& shared();
private:
void timerFired(Timer*)
{
clearScratchBuffer();
}
void clearScratchBuffer()
{
m_imageBuffer = nullptr;
m_lastRadius = FloatSize();
m_lastLayerSize = FloatSize();
}
std::unique_ptr<ImageBuffer> m_imageBuffer;
Timer m_purgeTimer;
FloatRect m_lastInsetBounds;
FloatRect m_lastShadowRect;
FloatRoundedRect::Radii m_lastRadii;
Color m_lastColor;
ColorSpace m_lastColorSpace;
FloatSize m_lastRadius;
bool m_lastWasInset;
FloatSize m_lastLayerSize;
#if !ASSERT_DISABLED
bool m_bufferInUse;
#endif
};
ScratchBuffer& ScratchBuffer::shared()
{
DEPRECATED_DEFINE_STATIC_LOCAL(ScratchBuffer, scratchBuffer, ());
return scratchBuffer;
}
static const int templateSideLength = 1;
#if USE(CG)
static float radiusToLegacyRadius(float radius)
{
return radius > 8 ? 8 + 4 * sqrt((radius - 8) / 2) : radius;
}
#endif
ShadowBlur::ShadowBlur(const FloatSize& radius, const FloatSize& offset, const Color& color, ColorSpace colorSpace)
: m_color(color)
, m_colorSpace(colorSpace)
, m_blurRadius(radius)
, m_offset(offset)
, m_layerImage(0)
, m_shadowsIgnoreTransforms(false)
{
updateShadowBlurValues();
}
ShadowBlur::ShadowBlur(const GraphicsContextState& state)
: m_color(state.shadowColor)
, m_colorSpace(state.shadowColorSpace)
, m_blurRadius(state.shadowBlur, state.shadowBlur)
, m_offset(state.shadowOffset)
, m_layerImage(0)
, m_shadowsIgnoreTransforms(state.shadowsIgnoreTransforms)
{
#if USE(CG)
if (state.shadowsUseLegacyRadius) {
float shadowBlur = radiusToLegacyRadius(state.shadowBlur);
m_blurRadius = FloatSize(shadowBlur, shadowBlur);
}
#endif
updateShadowBlurValues();
}
ShadowBlur::ShadowBlur()
: m_type(NoShadow)
, m_blurRadius(0, 0)
, m_shadowsIgnoreTransforms(false)
{
}
void ShadowBlur::setShadowValues(const FloatSize& radius, const FloatSize& offset, const Color& color, ColorSpace colorSpace, bool ignoreTransforms)
{
m_blurRadius = radius;
m_offset = offset;
m_color = color;
m_colorSpace = colorSpace;
m_shadowsIgnoreTransforms = ignoreTransforms;
updateShadowBlurValues();
}
void ShadowBlur::updateShadowBlurValues()
{
m_blurRadius = m_blurRadius.shrunkTo(FloatSize(128, 128));
if (!m_color.isValid() || !m_color.alpha()) {
m_type = NoShadow;
} else if (m_blurRadius.width() > 0 || m_blurRadius.height() > 0) {
m_type = BlurShadow;
} else if (!m_offset.width() && !m_offset.height()) {
m_type = NoShadow;
} else
m_type = SolidShadow;
}
static const int blurSumShift = 15;
static void calculateLobes(int lobes[][2], float blurRadius, bool shadowsIgnoreTransforms)
{
int diameter;
if (shadowsIgnoreTransforms)
diameter = std::max(2, static_cast<int>(floorf((2 / 3.f) * blurRadius))); else {
float stdDev = blurRadius / 2;
const float gaussianKernelFactor = 3 / 4.f * sqrtf(2 * piFloat);
const float fudgeFactor = 0.88f;
diameter = std::max(2, static_cast<int>(floorf(stdDev * gaussianKernelFactor * fudgeFactor + 0.5f)));
}
if (diameter & 1) {
int lobeSize = (diameter - 1) / 2;
lobes[0][leftLobe] = lobeSize;
lobes[0][rightLobe] = lobeSize;
lobes[1][leftLobe] = lobeSize;
lobes[1][rightLobe] = lobeSize;
lobes[2][leftLobe] = lobeSize;
lobes[2][rightLobe] = lobeSize;
} else {
int lobeSize = diameter / 2;
lobes[0][leftLobe] = lobeSize;
lobes[0][rightLobe] = lobeSize - 1;
lobes[1][leftLobe] = lobeSize - 1;
lobes[1][rightLobe] = lobeSize;
lobes[2][leftLobe] = lobeSize;
lobes[2][rightLobe] = lobeSize;
}
}
void ShadowBlur::clear()
{
m_type = NoShadow;
m_color = Color();
m_blurRadius = FloatSize();
m_offset = FloatSize();
}
void ShadowBlur::blurLayerImage(unsigned char* imageData, const IntSize& size, int rowStride)
{
const int channels[4] = { 3, 0, 1, 3 };
int lobes[3][2]; calculateLobes(lobes, m_blurRadius.width(), m_shadowsIgnoreTransforms);
int stride = 4;
int delta = rowStride;
int final = size.height();
int dim = size.width();
for (int pass = 0; pass < 2; ++pass) {
unsigned char* pixels = imageData;
if (!pass && !m_blurRadius.width())
final = 0;
for (int j = 0; j < final; ++j, pixels += delta) {
for (int step = 0; step < 3; ++step) {
int side1 = lobes[step][leftLobe];
int side2 = lobes[step][rightLobe];
int pixelCount = side1 + 1 + side2;
int invCount = ((1 << blurSumShift) + pixelCount - 1) / pixelCount;
int ofs = 1 + side2;
int alpha1 = pixels[channels[step]];
int alpha2 = pixels[(dim - 1) * stride + channels[step]];
unsigned char* ptr = pixels + channels[step + 1];
unsigned char* prev = pixels + stride + channels[step];
unsigned char* next = pixels + ofs * stride + channels[step];
int i;
int sum = side1 * alpha1 + alpha1;
int limit = (dim < side2 + 1) ? dim : side2 + 1;
for (i = 1; i < limit; ++i, prev += stride)
sum += *prev;
if (limit <= side2)
sum += (side2 - limit + 1) * alpha2;
limit = (side1 < dim) ? side1 : dim;
for (i = 0; i < limit; ptr += stride, next += stride, ++i, ++ofs) {
*ptr = (sum * invCount) >> blurSumShift;
sum += ((ofs < dim) ? *next : alpha2) - alpha1;
}
prev = pixels + channels[step];
for (; ofs < dim; ptr += stride, prev += stride, next += stride, ++i, ++ofs) {
*ptr = (sum * invCount) >> blurSumShift;
sum += (*next) - (*prev);
}
for (; i < dim; ptr += stride, prev += stride, ++i) {
*ptr = (sum * invCount) >> blurSumShift;
sum += alpha2 - (*prev);
}
}
}
stride = rowStride;
delta = 4;
final = size.width();
dim = size.height();
if (!m_blurRadius.height())
break;
if (m_blurRadius.width() != m_blurRadius.height())
calculateLobes(lobes, m_blurRadius.height(), m_shadowsIgnoreTransforms);
}
}
void ShadowBlur::adjustBlurRadius(GraphicsContext* context)
{
if (!m_shadowsIgnoreTransforms)
return;
AffineTransform transform = context->getCTM();
m_blurRadius.scale(1 / static_cast<float>(transform.xScale()), 1 / static_cast<float>(transform.yScale()));
}
IntSize ShadowBlur::blurredEdgeSize() const
{
IntSize edgeSize = expandedIntSize(m_blurRadius);
if (edgeSize.width() == 1)
edgeSize.setWidth(2);
if (edgeSize.height() == 1)
edgeSize.setHeight(2);
return edgeSize;
}
IntRect ShadowBlur::calculateLayerBoundingRect(GraphicsContext* context, const FloatRect& shadowedRect, const IntRect& clipRect)
{
IntSize edgeSize = blurredEdgeSize();
FloatRect layerRect;
IntSize inflation;
const AffineTransform transform = context->getCTM();
if (m_shadowsIgnoreTransforms && !transform.isIdentity()) {
FloatQuad transformedPolygon = transform.mapQuad(FloatQuad(shadowedRect));
transformedPolygon.move(m_offset);
layerRect = transform.inverse().mapQuad(transformedPolygon).boundingBox();
} else {
layerRect = shadowedRect;
layerRect.move(m_offset);
}
if (m_type == BlurShadow) {
layerRect.inflateX(edgeSize.width());
layerRect.inflateY(edgeSize.height());
inflation = edgeSize;
}
FloatRect unclippedLayerRect = layerRect;
if (!clipRect.contains(enclosingIntRect(layerRect))) {
if (intersection(layerRect, clipRect).isEmpty())
return IntRect();
IntRect inflatedClip = clipRect;
if (m_type == BlurShadow) {
inflatedClip.inflateX(edgeSize.width());
inflatedClip.inflateY(edgeSize.height());
} else {
inflatedClip.inflateX(1);
inflatedClip.inflateY(1);
}
layerRect.intersect(inflatedClip);
}
IntSize frameSize = inflation;
frameSize.scale(2);
m_sourceRect = FloatRect(0, 0, shadowedRect.width() + frameSize.width(), shadowedRect.height() + frameSize.height());
m_layerOrigin = FloatPoint(layerRect.x(), layerRect.y());
m_layerSize = layerRect.size();
const FloatPoint unclippedLayerOrigin = FloatPoint(unclippedLayerRect.x(), unclippedLayerRect.y());
const FloatSize clippedOut = unclippedLayerOrigin - m_layerOrigin;
float translationX = -shadowedRect.x() + inflation.width() - fabsf(clippedOut.width());
float translationY = -shadowedRect.y() + inflation.height() - fabsf(clippedOut.height());
m_layerContextTranslation = FloatSize(translationX, translationY);
return enclosingIntRect(layerRect);
}
void ShadowBlur::drawShadowBuffer(GraphicsContext* graphicsContext)
{
if (!m_layerImage)
return;
GraphicsContextStateSaver stateSaver(*graphicsContext);
IntSize bufferSize = m_layerImage->internalSize();
if (bufferSize != m_layerSize) {
graphicsContext->clip(FloatRect(m_layerOrigin, m_layerSize));
}
graphicsContext->clipToImageBuffer(m_layerImage, FloatRect(m_layerOrigin, bufferSize));
graphicsContext->setFillColor(m_color, m_colorSpace);
graphicsContext->clearShadow();
graphicsContext->fillRect(FloatRect(m_layerOrigin, m_sourceRect.size()));
}
static void computeSliceSizesFromRadii(const IntSize& twiceRadius, const FloatRoundedRect::Radii& radii, int& leftSlice, int& rightSlice, int& topSlice, int& bottomSlice)
{
leftSlice = twiceRadius.width() + std::max(radii.topLeft().width(), radii.bottomLeft().width());
rightSlice = twiceRadius.width() + std::max(radii.topRight().width(), radii.bottomRight().width());
topSlice = twiceRadius.height() + std::max(radii.topLeft().height(), radii.topRight().height());
bottomSlice = twiceRadius.height() + std::max(radii.bottomLeft().height(), radii.bottomRight().height());
}
IntSize ShadowBlur::templateSize(const IntSize& radiusPadding, const FloatRoundedRect::Radii& radii) const
{
const int templateSideLength = 1;
int leftSlice;
int rightSlice;
int topSlice;
int bottomSlice;
IntSize blurExpansion = radiusPadding;
blurExpansion.scale(2);
computeSliceSizesFromRadii(blurExpansion, radii, leftSlice, rightSlice, topSlice, bottomSlice);
return IntSize(templateSideLength + leftSlice + rightSlice,
templateSideLength + topSlice + bottomSlice);
}
void ShadowBlur::drawRectShadow(GraphicsContext* graphicsContext, const FloatRoundedRect& shadowedRect)
{
IntRect layerRect = calculateLayerBoundingRect(graphicsContext, shadowedRect.rect(), graphicsContext->clipBounds());
if (layerRect.isEmpty())
return;
adjustBlurRadius(graphicsContext);
if (!graphicsContext->getCTM().preservesAxisAlignment() || m_type != BlurShadow) {
drawRectShadowWithoutTiling(graphicsContext, shadowedRect, layerRect);
return;
}
IntSize edgeSize = blurredEdgeSize();
IntSize templateSize = this->templateSize(edgeSize, shadowedRect.radii());
const FloatRect& rect = shadowedRect.rect();
if (templateSize.width() > rect.width() || templateSize.height() > rect.height()
|| (templateSize.width() * templateSize.height() > m_sourceRect.width() * m_sourceRect.height())) {
drawRectShadowWithoutTiling(graphicsContext, shadowedRect, layerRect);
return;
}
drawRectShadowWithTiling(graphicsContext, shadowedRect, templateSize, edgeSize);
}
void ShadowBlur::drawInsetShadow(GraphicsContext* graphicsContext, const FloatRect& rect, const FloatRoundedRect& holeRect)
{
IntRect layerRect = calculateLayerBoundingRect(graphicsContext, rect, graphicsContext->clipBounds());
if (layerRect.isEmpty())
return;
adjustBlurRadius(graphicsContext);
if (!graphicsContext->getCTM().preservesAxisAlignment() || m_type != BlurShadow) {
drawInsetShadowWithoutTiling(graphicsContext, rect, holeRect, layerRect);
return;
}
IntSize edgeSize = blurredEdgeSize();
IntSize templateSize = this->templateSize(edgeSize, holeRect.radii());
const FloatRect& hRect = holeRect.rect();
if (templateSize.width() > hRect.width() || templateSize.height() > hRect.height()
|| (templateSize.width() * templateSize.height() > hRect.width() * hRect.height())) {
drawInsetShadowWithoutTiling(graphicsContext, rect, holeRect, layerRect);
return;
}
drawInsetShadowWithTiling(graphicsContext, rect, holeRect, templateSize, edgeSize);
}
void ShadowBlur::drawRectShadowWithoutTiling(GraphicsContext* graphicsContext, const FloatRoundedRect& shadowedRect, const IntRect& layerRect)
{
m_layerImage = ScratchBuffer::shared().getScratchBuffer(layerRect.size());
if (!m_layerImage)
return;
FloatRect bufferRelativeShadowedRect = shadowedRect.rect();
bufferRelativeShadowedRect.move(m_layerContextTranslation);
bool redrawNeeded = ScratchBuffer::shared().setCachedShadowValues(m_blurRadius, Color::black, ColorSpaceDeviceRGB, bufferRelativeShadowedRect, shadowedRect.radii(), m_layerSize);
if (redrawNeeded) {
GraphicsContext* shadowContext = m_layerImage->context();
GraphicsContextStateSaver stateSaver(*shadowContext);
shadowContext->clearRect(FloatRect(0, 0, m_layerSize.width() + 1, m_layerSize.height() + 1));
shadowContext->translate(m_layerContextTranslation);
shadowContext->setFillColor(Color::black, ColorSpaceDeviceRGB);
if (shadowedRect.radii().isZero())
shadowContext->fillRect(shadowedRect.rect());
else {
Path path;
path.addRoundedRect(shadowedRect);
shadowContext->fillPath(path);
}
blurShadowBuffer(expandedIntSize(m_layerSize));
}
drawShadowBuffer(graphicsContext);
m_layerImage = 0;
ScratchBuffer::shared().scheduleScratchBufferPurge();
}
void ShadowBlur::drawInsetShadowWithoutTiling(GraphicsContext* graphicsContext, const FloatRect& rect, const FloatRoundedRect& holeRect, const IntRect& layerRect)
{
m_layerImage = ScratchBuffer::shared().getScratchBuffer(layerRect.size());
if (!m_layerImage)
return;
FloatRect bufferRelativeRect = rect;
bufferRelativeRect.move(m_layerContextTranslation);
FloatRect bufferRelativeHoleRect = holeRect.rect();
bufferRelativeHoleRect.move(m_layerContextTranslation);
bool redrawNeeded = ScratchBuffer::shared().setCachedInsetShadowValues(m_blurRadius, Color::black, ColorSpaceDeviceRGB, bufferRelativeRect, bufferRelativeHoleRect, holeRect.radii());
if (redrawNeeded) {
GraphicsContext* shadowContext = m_layerImage->context();
GraphicsContextStateSaver stateSaver(*shadowContext);
shadowContext->clearRect(FloatRect(0, 0, m_layerSize.width() + 1, m_layerSize.height() + 1));
shadowContext->translate(m_layerContextTranslation);
Path path;
path.addRect(rect);
if (holeRect.radii().isZero())
path.addRect(holeRect.rect());
else
path.addRoundedRect(holeRect);
shadowContext->setFillRule(RULE_EVENODD);
shadowContext->setFillColor(Color::black, ColorSpaceDeviceRGB);
shadowContext->fillPath(path);
blurShadowBuffer(expandedIntSize(m_layerSize));
}
drawShadowBuffer(graphicsContext);
m_layerImage = 0;
ScratchBuffer::shared().scheduleScratchBufferPurge();
}
void ShadowBlur::drawInsetShadowWithTiling(GraphicsContext* graphicsContext, const FloatRect& rect, const FloatRoundedRect& holeRect, const IntSize& templateSize, const IntSize& edgeSize)
{
m_layerImage = ScratchBuffer::shared().getScratchBuffer(templateSize);
if (!m_layerImage)
return;
FloatRect templateBounds(0, 0, templateSize.width(), templateSize.height());
FloatRect templateHole = FloatRect(edgeSize.width(), edgeSize.height(), templateSize.width() - 2 * edgeSize.width(), templateSize.height() - 2 * edgeSize.height());
bool redrawNeeded = ScratchBuffer::shared().setCachedInsetShadowValues(m_blurRadius, m_color, m_colorSpace, templateBounds, templateHole, holeRect.radii());
if (redrawNeeded) {
GraphicsContext* shadowContext = m_layerImage->context();
GraphicsContextStateSaver shadowStateSaver(*shadowContext);
shadowContext->clearRect(templateBounds);
shadowContext->setFillRule(RULE_EVENODD);
shadowContext->setFillColor(Color::black, ColorSpaceDeviceRGB);
Path path;
path.addRect(templateBounds);
if (holeRect.radii().isZero())
path.addRect(templateHole);
else
path.addRoundedRect(FloatRoundedRect(templateHole, holeRect.radii()));
shadowContext->fillPath(path);
blurAndColorShadowBuffer(templateSize);
}
FloatSize offset = m_offset;
if (shadowsIgnoreTransforms()) {
AffineTransform transform = graphicsContext->getCTM();
offset.scale(1 / transform.xScale(), 1 / transform.yScale());
}
FloatRect boundingRect = rect;
boundingRect.move(offset);
FloatRect destHoleRect = holeRect.rect();
destHoleRect.move(offset);
FloatRect destHoleBounds = destHoleRect;
destHoleBounds.inflateX(edgeSize.width());
destHoleBounds.inflateY(edgeSize.height());
Path exteriorPath;
exteriorPath.addRect(boundingRect);
exteriorPath.addRect(destHoleBounds);
{
GraphicsContextStateSaver fillStateSaver(*graphicsContext);
graphicsContext->setFillRule(RULE_EVENODD);
graphicsContext->setFillColor(m_color, m_colorSpace);
graphicsContext->clearShadow();
graphicsContext->fillPath(exteriorPath);
}
drawLayerPieces(graphicsContext, destHoleBounds, holeRect.radii(), edgeSize, templateSize, InnerShadow);
m_layerImage = 0;
ScratchBuffer::shared().scheduleScratchBufferPurge();
}
void ShadowBlur::drawRectShadowWithTiling(GraphicsContext* graphicsContext, const FloatRoundedRect& shadowedRect, const IntSize& templateSize, const IntSize& edgeSize)
{
m_layerImage = ScratchBuffer::shared().getScratchBuffer(templateSize);
if (!m_layerImage)
return;
FloatRect templateShadow = FloatRect(edgeSize.width(), edgeSize.height(), templateSize.width() - 2 * edgeSize.width(), templateSize.height() - 2 * edgeSize.height());
bool redrawNeeded = ScratchBuffer::shared().setCachedShadowValues(m_blurRadius, m_color, m_colorSpace, templateShadow, shadowedRect.radii(), m_layerSize);
if (redrawNeeded) {
GraphicsContext* shadowContext = m_layerImage->context();
GraphicsContextStateSaver shadowStateSaver(*shadowContext);
shadowContext->clearRect(FloatRect(0, 0, templateSize.width(), templateSize.height()));
shadowContext->setFillColor(Color::black, ColorSpaceDeviceRGB);
if (shadowedRect.radii().isZero())
shadowContext->fillRect(templateShadow);
else {
Path path;
path.addRoundedRect(FloatRoundedRect(templateShadow, shadowedRect.radii()));
shadowContext->fillPath(path);
}
blurAndColorShadowBuffer(templateSize);
}
FloatSize offset = m_offset;
if (shadowsIgnoreTransforms()) {
AffineTransform transform = graphicsContext->getCTM();
offset.scale(1 / transform.xScale(), 1 / transform.yScale());
}
FloatRect shadowBounds = shadowedRect.rect();
shadowBounds.move(offset);
shadowBounds.inflateX(edgeSize.width());
shadowBounds.inflateY(edgeSize.height());
drawLayerPieces(graphicsContext, shadowBounds, shadowedRect.radii(), edgeSize, templateSize, OuterShadow);
m_layerImage = 0;
ScratchBuffer::shared().scheduleScratchBufferPurge();
}
void ShadowBlur::drawLayerPieces(GraphicsContext* graphicsContext, const FloatRect& shadowBounds, const FloatRoundedRect::Radii& radii, const IntSize& bufferPadding, const IntSize& templateSize, ShadowDirection direction)
{
const IntSize twiceRadius = IntSize(bufferPadding.width() * 2, bufferPadding.height() * 2);
int leftSlice;
int rightSlice;
int topSlice;
int bottomSlice;
computeSliceSizesFromRadii(twiceRadius, radii, leftSlice, rightSlice, topSlice, bottomSlice);
int centerWidth = shadowBounds.width() - leftSlice - rightSlice;
int centerHeight = shadowBounds.height() - topSlice - bottomSlice;
if (direction == OuterShadow) {
FloatRect shadowInterior(shadowBounds.x() + leftSlice, shadowBounds.y() + topSlice, centerWidth, centerHeight);
if (!shadowInterior.isEmpty()) {
GraphicsContextStateSaver stateSaver(*graphicsContext);
graphicsContext->setFillColor(m_color, m_colorSpace);
graphicsContext->clearShadow();
graphicsContext->fillRect(shadowInterior);
}
}
GraphicsContextStateSaver stateSaver(*graphicsContext);
graphicsContext->setFillColor(m_color, m_colorSpace);
graphicsContext->clearShadow();
FloatRect centerRect(shadowBounds.x() + leftSlice, shadowBounds.y() + topSlice, centerWidth, centerHeight);
centerRect = graphicsContext->roundToDevicePixels(centerRect);
FloatRect tileRect = FloatRect(leftSlice, 0, templateSideLength, topSlice);
FloatRect destRect = FloatRect(centerRect.x(), centerRect.y() - topSlice, centerRect.width(), topSlice);
graphicsContext->drawImageBuffer(m_layerImage, ColorSpaceDeviceRGB, destRect, tileRect);
tileRect.setY(templateSize.height() - bottomSlice);
tileRect.setHeight(bottomSlice);
destRect.setY(centerRect.maxY());
destRect.setHeight(bottomSlice);
graphicsContext->drawImageBuffer(m_layerImage, ColorSpaceDeviceRGB, destRect, tileRect);
tileRect = FloatRect(0, topSlice, leftSlice, templateSideLength);
destRect = FloatRect(centerRect.x() - leftSlice, centerRect.y(), leftSlice, centerRect.height());
graphicsContext->drawImageBuffer(m_layerImage, ColorSpaceDeviceRGB, destRect, tileRect);
tileRect.setX(templateSize.width() - rightSlice);
tileRect.setWidth(rightSlice);
destRect.setX(centerRect.maxX());
destRect.setWidth(rightSlice);
graphicsContext->drawImageBuffer(m_layerImage, ColorSpaceDeviceRGB, destRect, tileRect);
tileRect = FloatRect(0, 0, leftSlice, topSlice);
destRect = FloatRect(centerRect.x() - leftSlice, centerRect.y() - topSlice, leftSlice, topSlice);
graphicsContext->drawImageBuffer(m_layerImage, ColorSpaceDeviceRGB, destRect, tileRect);
tileRect = FloatRect(templateSize.width() - rightSlice, 0, rightSlice, topSlice);
destRect = FloatRect(centerRect.maxX(), centerRect.y() - topSlice, rightSlice, topSlice);
graphicsContext->drawImageBuffer(m_layerImage, ColorSpaceDeviceRGB, destRect, tileRect);
tileRect = FloatRect(templateSize.width() - rightSlice, templateSize.height() - bottomSlice, rightSlice, bottomSlice);
destRect = FloatRect(centerRect.maxX(), centerRect.maxY(), rightSlice, bottomSlice);
graphicsContext->drawImageBuffer(m_layerImage, ColorSpaceDeviceRGB, destRect, tileRect);
tileRect = FloatRect(0, templateSize.height() - bottomSlice, leftSlice, bottomSlice);
destRect = FloatRect(centerRect.x() - leftSlice, centerRect.maxY(), leftSlice, bottomSlice);
graphicsContext->drawImageBuffer(m_layerImage, ColorSpaceDeviceRGB, destRect, tileRect);
}
void ShadowBlur::blurShadowBuffer(const IntSize& templateSize)
{
if (m_type != BlurShadow)
return;
IntRect blurRect(IntPoint(), templateSize);
RefPtr<Uint8ClampedArray> layerData = m_layerImage->getUnmultipliedImageData(blurRect);
blurLayerImage(layerData->data(), blurRect.size(), blurRect.width() * 4);
m_layerImage->putByteArray(Unmultiplied, layerData.get(), blurRect.size(), blurRect, IntPoint());
}
void ShadowBlur::blurAndColorShadowBuffer(const IntSize& templateSize)
{
blurShadowBuffer(templateSize);
GraphicsContext* shadowContext = m_layerImage->context();
GraphicsContextStateSaver stateSaver(*shadowContext);
shadowContext->setCompositeOperation(CompositeSourceIn);
shadowContext->setFillColor(m_color, m_colorSpace);
shadowContext->fillRect(FloatRect(0, 0, templateSize.width(), templateSize.height()));
}
GraphicsContext* ShadowBlur::beginShadowLayer(GraphicsContext *context, const FloatRect& layerArea)
{
adjustBlurRadius(context);
IntRect layerRect = calculateLayerBoundingRect(context, layerArea, context->clipBounds());
if (layerRect.isEmpty())
return 0;
ScratchBuffer::shared().setCachedShadowValues(FloatSize(), Color::black, ColorSpaceDeviceRGB, IntRect(), FloatRoundedRect::Radii(), m_layerSize);
m_layerImage = ScratchBuffer::shared().getScratchBuffer(layerRect.size());
GraphicsContext* shadowContext = m_layerImage->context();
shadowContext->save();
shadowContext->clearRect(FloatRect(0, 0, m_layerSize.width() + 1, m_layerSize.height() + 1));
shadowContext->translate(m_layerContextTranslation);
return shadowContext;
}
void ShadowBlur::endShadowLayer(GraphicsContext* context)
{
m_layerImage->context()->restore();
blurAndColorShadowBuffer(expandedIntSize(m_layerSize));
GraphicsContextStateSaver stateSave(*context);
context->clearShadow();
context->drawImageBuffer(m_layerImage, ColorSpaceDeviceRGB, FloatRect(roundedIntPoint(m_layerOrigin), m_layerSize), FloatRect(FloatPoint(), m_layerSize), context->compositeOperation());
m_layerImage = 0;
ScratchBuffer::shared().scheduleScratchBufferPurge();
}
}