apply imagefilter to all draw calls
Review URL: https://codereview.appspot.com/5856048
git-svn-id: http://skia.googlecode.com/svn/trunk@3476 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 1cd9d71..dde3570 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -277,20 +277,36 @@
class AutoDrawLooper {
public:
- AutoDrawLooper(SkCanvas* canvas, const SkPaint& paint) : fOrigPaint(paint) {
+ AutoDrawLooper(SkCanvas* canvas, const SkPaint& paint,
+ bool skipLayerForImageFilter = false) : fOrigPaint(paint) {
fCanvas = canvas;
fLooper = paint.getLooper();
fFilter = canvas->getDrawFilter();
fPaint = NULL;
fSaveCount = canvas->getSaveCount();
+ fDoClearImageFilter = false;
fDone = false;
+ if (!skipLayerForImageFilter && fOrigPaint.getImageFilter()) {
+ SkPaint tmp;
+ tmp.setImageFilter(fOrigPaint.getImageFilter());
+ // it would be nice if we had a guess at the bounds, instead of null
+ (void)canvas->internalSaveLayer(NULL, &tmp,
+ SkCanvas::kARGB_ClipLayer_SaveFlag, true);
+ // we'll clear the imageFilter for the actual draws in next(), so
+ // it will only be applied during the restore().
+ fDoClearImageFilter = true;
+ }
+
if (fLooper) {
fLooper->init(canvas);
}
}
~AutoDrawLooper() {
+ if (fDoClearImageFilter) {
+ fCanvas->internalRestore();
+ }
SkASSERT(fCanvas->getSaveCount() == fSaveCount);
}
@@ -309,6 +325,7 @@
SkDrawFilter* fFilter;
const SkPaint* fPaint;
int fSaveCount;
+ bool fDoClearImageFilter;
bool fDone;
};
@@ -318,8 +335,13 @@
return false;
}
- if (fLooper || fFilter) {
+ if (fLooper || fFilter || fDoClearImageFilter) {
SkPaint* paint = fLazyPaint.set(fOrigPaint);
+
+ if (fDoClearImageFilter) {
+ paint->setImageFilter(NULL);
+ }
+
if (fLooper && !fLooper->next(fCanvas, paint)) {
fDone = true;
return false;
@@ -332,6 +354,11 @@
}
}
fPaint = paint;
+
+ // if we only came in here for the imagefilter, mark us as done
+ if (!fLooper && !fFilter) {
+ fDone = true;
+ }
} else {
fDone = true;
fPaint = &fOrigPaint;
@@ -386,6 +413,13 @@
////////// macros to place around the internal draw calls //////////////////
+#define LOOPER_BEGIN_DRAWDEVICE(paint, type) \
+/* AutoValidator validator(fMCRec->fTopLayer->fDevice); */ \
+ AutoDrawLooper looper(this, paint, true); \
+ while (looper.next(type)) { \
+ SkAutoBounderCommit ac(fBounder); \
+ SkDrawIter iter(this);
+
#define LOOPER_BEGIN(paint, type) \
/* AutoValidator validator(fMCRec->fTopLayer->fDevice); */ \
AutoDrawLooper looper(this, paint); \
@@ -749,6 +783,11 @@
int SkCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
SaveFlags flags) {
+ return this->internalSaveLayer(bounds, paint, flags, false);
+}
+
+int SkCanvas::internalSaveLayer(const SkRect* bounds, const SkPaint* paint,
+ SaveFlags flags, bool justForImageFilter) {
// do this before we create the layer. We don't call the public save() since
// that would invoke a possibly overridden virtual
int count = this->internalSave(flags);
@@ -764,6 +803,10 @@
SkLazyPaint lazyP;
if (paint && paint->getImageFilter()) {
if (!this->getTopDevice()->allowImageFilter(paint->getImageFilter())) {
+ if (justForImageFilter) {
+ // early exit if the layer was just for the imageFilter
+ return count;
+ }
SkPaint* p = lazyP.set(*paint);
p->setImageFilter(NULL);
paint = p;
@@ -841,9 +884,9 @@
if (NULL != layer) {
if (layer->fNext) {
const SkIPoint& origin = layer->fDevice->getOrigin();
- this->drawDevice(layer->fDevice, origin.x(), origin.y(),
- layer->fPaint);
- // reset this, since drawDevice will have set it to true
+ this->internalDrawDevice(layer->fDevice, origin.x(), origin.y(),
+ layer->fPaint);
+ // reset this, since internalDrawDevice will have set it to true
fDeviceCMDirty = true;
SkASSERT(fLayerCount > 0);
@@ -905,43 +948,38 @@
public:
DeviceImageFilterProxy(SkDevice* device) : fDevice(device) {}
- virtual SkDevice* createDevice(int w, int h) SK_OVERRIDE;
- virtual bool filterImage(SkImageFilter*, const SkBitmap& src,
+ virtual SkDevice* createDevice(int w, int h) SK_OVERRIDE {
+ return fDevice->createCompatibleDevice(SkBitmap::kARGB_8888_Config,
+ w, h, false);
+ }
+ virtual bool canHandleImageFilter(SkImageFilter* filter) SK_OVERRIDE {
+ return fDevice->canHandleImageFilter(filter);
+ }
+ virtual bool filterImage(SkImageFilter* filter, const SkBitmap& src,
const SkMatrix& ctm,
- SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;
-
+ SkBitmap* result, SkIPoint* offset) SK_OVERRIDE {
+ return fDevice->filterImage(filter, src, ctm, result, offset);
+ }
+
private:
SkDevice* fDevice;
};
-SkDevice* DeviceImageFilterProxy::createDevice(int w, int h) {
- return fDevice->createCompatibleDevice(SkBitmap::kARGB_8888_Config,
- w, h, false);
-}
-
-bool DeviceImageFilterProxy::filterImage(SkImageFilter* filter,
- const SkBitmap& src,
- const SkMatrix& ctm,
- SkBitmap* result,
- SkIPoint* offset) {
- return fDevice->filterImage(filter, src, ctm, result, offset);
-}
-
-void SkCanvas::drawDevice(SkDevice* srcDev, int x, int y,
- const SkPaint* paint) {
+void SkCanvas::internalDrawDevice(SkDevice* srcDev, int x, int y,
+ const SkPaint* paint) {
SkPaint tmp;
if (NULL == paint) {
tmp.setDither(true);
paint = &tmp;
}
- LOOPER_BEGIN(*paint, SkDrawFilter::kBitmap_Type)
+ LOOPER_BEGIN_DRAWDEVICE(*paint, SkDrawFilter::kBitmap_Type)
while (iter.next()) {
SkDevice* dstDev = iter.fDevice;
paint = &looper.paint();
SkImageFilter* filter = paint->getImageFilter();
SkIPoint pos = { x - iter.getX(), y - iter.getY() };
- if (filter) {
+ if (filter && !dstDev->canHandleImageFilter(filter)) {
DeviceImageFilterProxy proxy(dstDev);
SkBitmap dst;
const SkBitmap& src = srcDev->accessBitmap(false);
@@ -957,6 +995,40 @@
LOOPER_END
}
+void SkCanvas::drawSprite(const SkBitmap& bitmap, int x, int y,
+ const SkPaint* paint) {
+ SkDEBUGCODE(bitmap.validate();)
+
+ if (reject_bitmap(bitmap)) {
+ return;
+ }
+
+ SkPaint tmp;
+ if (NULL == paint) {
+ paint = &tmp;
+ }
+
+ LOOPER_BEGIN_DRAWDEVICE(*paint, SkDrawFilter::kBitmap_Type)
+
+ while (iter.next()) {
+ paint = &looper.paint();
+ SkImageFilter* filter = paint->getImageFilter();
+ SkIPoint pos = { x - iter.getX(), y - iter.getY() };
+ if (filter && !iter.fDevice->canHandleImageFilter(filter)) {
+ DeviceImageFilterProxy proxy(iter.fDevice);
+ SkBitmap dst;
+ if (filter->filterImage(&proxy, bitmap, *iter.fMatrix, &dst, &pos)) {
+ SkPaint tmp(*paint);
+ tmp.setImageFilter(NULL);
+ iter.fDevice->drawSprite(iter, dst, pos.x(), pos.y(), tmp);
+ }
+ } else {
+ iter.fDevice->drawSprite(iter, bitmap, pos.x(), pos.y(), *paint);
+ }
+ }
+ LOOPER_END
+}
+
/////////////////////////////////////////////////////////////////////////////
bool SkCanvas::translate(SkScalar dx, SkScalar dy) {
@@ -1575,28 +1647,6 @@
this->internalDrawBitmapNine(bitmap, center, dst, paint);
}
-void SkCanvas::drawSprite(const SkBitmap& bitmap, int x, int y,
- const SkPaint* paint) {
- SkDEBUGCODE(bitmap.validate();)
-
- if (reject_bitmap(bitmap)) {
- return;
- }
-
- SkPaint tmp;
- if (NULL == paint) {
- paint = &tmp;
- }
-
- LOOPER_BEGIN(*paint, SkDrawFilter::kBitmap_Type)
-
- while (iter.next()) {
- iter.fDevice->drawSprite(iter, bitmap, x - iter.getX(), y - iter.getY(),
- looper.paint());
- }
- LOOPER_END
-}
-
class SkDeviceFilteredPaint {
public:
SkDeviceFilteredPaint(SkDevice* device, const SkPaint& paint) {
diff --git a/src/core/SkDevice.cpp b/src/core/SkDevice.cpp
index f1da2ef..b92f4e1 100644
--- a/src/core/SkDevice.cpp
+++ b/src/core/SkDevice.cpp
@@ -101,9 +101,13 @@
const SkClipStack& clipStack) {
}
-bool SkDevice::filterImage(SkImageFilter*, const SkBitmap& src,
- const SkMatrix& ctm,
- SkBitmap* result, SkIPoint* offset) {
+bool SkDevice::canHandleImageFilter(SkImageFilter*) {
+ return false;
+}
+
+bool SkDevice::filterImage(SkImageFilter* filter, const SkBitmap& src,
+ const SkMatrix& ctm, SkBitmap* result,
+ SkIPoint* offset) {
return false;
}
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 4917dcb..0ac4ed5 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -1398,11 +1398,50 @@
fContext->drawRectToRect(*grPaint, dstRect, paintRect, &m);
}
+static GrTexture* filter_texture(GrContext* context, GrTexture* texture,
+ SkImageFilter* filter, const GrRect& rect) {
+ GrAssert(filter);
+
+ SkSize blurSize;
+ SkISize radius;
+
+ const GrTextureDesc desc = {
+ kRenderTarget_GrTextureFlagBit,
+ rect.width(),
+ rect.height(),
+ kRGBA_8888_PM_GrPixelConfig,
+ {0} // samples
+ };
+
+ if (filter->asABlur(&blurSize)) {
+ GrAutoScratchTexture temp1, temp2;
+ texture = context->gaussianBlur(texture, &temp1, &temp2, rect,
+ blurSize.width(),
+ blurSize.height());
+ texture->ref();
+ } else if (filter->asADilate(&radius)) {
+ GrAutoScratchTexture temp1(context, desc), temp2(context, desc);
+ texture = context->applyMorphology(texture, rect,
+ temp1.texture(), temp2.texture(),
+ GrSamplerState::kDilate_Filter,
+ radius);
+ texture->ref();
+ } else if (filter->asAnErode(&radius)) {
+ GrAutoScratchTexture temp1(context, desc), temp2(context, desc);
+ texture = context->applyMorphology(texture, rect,
+ temp1.texture(), temp2.texture(),
+ GrSamplerState::kErode_Filter,
+ radius);
+ texture->ref();
+ }
+ return texture;
+}
+
void SkGpuDevice::drawSprite(const SkDraw& draw, const SkBitmap& bitmap,
int left, int top, const SkPaint& paint) {
CHECK_SHOULD_DRAW(draw);
- SkAutoLockPixels alp(bitmap);
+ SkAutoLockPixels alp(bitmap, !bitmap.getTexture());
if (!bitmap.getTexture() && !bitmap.readyToDraw()) {
return;
}
@@ -1422,50 +1461,19 @@
GrTexture* texture;
sampler->reset();
SkAutoCachedTexture act(this, bitmap, sampler, &texture);
+ grPaint.setTexture(kBitmapTextureIdx, texture);
- SkImageFilter* imageFilter = paint.getImageFilter();
- SkSize blurSize;
- SkISize radius;
- if (NULL != imageFilter && imageFilter->asABlur(&blurSize)) {
- GrAutoScratchTexture temp1, temp2;
- GrTexture* blurTexture = fContext->gaussianBlur(texture, &temp1, &temp2,
- GrRect::MakeWH(w, h),
- blurSize.width(),
- blurSize.height());
- texture = blurTexture;
- grPaint.setTexture(kBitmapTextureIdx, texture);
- } else if (NULL != imageFilter && imageFilter->asADilate(&radius)) {
- const GrTextureDesc desc = {
- kRenderTarget_GrTextureFlagBit,
- w,
- h,
- kRGBA_8888_PM_GrPixelConfig,
- {0} // samples
- };
- GrAutoScratchTexture temp1(fContext, desc), temp2(fContext, desc);
- texture = fContext->applyMorphology(texture, GrRect::MakeWH(w, h),
- temp1.texture(), temp2.texture(),
- GrSamplerState::kDilate_Filter,
- radius);
- grPaint.setTexture(kBitmapTextureIdx, texture);
- } else if (NULL != imageFilter && imageFilter->asAnErode(&radius)) {
- const GrTextureDesc desc = {
- kRenderTarget_GrTextureFlagBit,
- w,
- h,
- kRGBA_8888_PM_GrPixelConfig,
- {0} // samples
- };
- GrAutoScratchTexture temp1(fContext, desc), temp2(fContext, desc);
- texture = fContext->applyMorphology(texture, GrRect::MakeWH(w, h),
- temp1.texture(), temp2.texture(),
- GrSamplerState::kErode_Filter,
- radius);
- grPaint.setTexture(kBitmapTextureIdx, texture);
- } else {
- grPaint.setTexture(kBitmapTextureIdx, texture);
+ SkImageFilter* filter = paint.getImageFilter();
+ if (NULL != filter) {
+ GrTexture* filteredTexture = filter_texture(fContext, texture, filter,
+ GrRect::MakeWH(w, h));
+ if (filteredTexture) {
+ grPaint.setTexture(kBitmapTextureIdx, filteredTexture);
+ texture = filteredTexture;
+ filteredTexture->unref();
+ }
}
-
+
fContext->drawRectToRect(grPaint,
GrRect::MakeXYWH(GrIntToScalar(left),
GrIntToScalar(top),
@@ -1488,6 +1496,18 @@
GrTexture* devTex = grPaint.getTexture(0);
SkASSERT(NULL != devTex);
+ SkImageFilter* filter = paint.getImageFilter();
+ if (NULL != filter) {
+ GrRect rect = GrRect::MakeWH(devTex->width(), devTex->height());
+ GrTexture* filteredTexture = filter_texture(fContext, devTex, filter,
+ rect);
+ if (filteredTexture) {
+ grPaint.setTexture(kBitmapTextureIdx, filteredTexture);
+ devTex = filteredTexture;
+ filteredTexture->unref();
+ }
+ }
+
const SkBitmap& bm = dev->accessBitmap(false);
int w = bm.width();
int h = bm.height();
@@ -1509,27 +1529,43 @@
fContext->drawRectToRect(grPaint, dstRect, srcRect);
}
-bool SkGpuDevice::filterImage(SkImageFilter* filter, const SkBitmap& src,
- const SkMatrix& ctm,
- SkBitmap* result, SkIPoint* offset) {
+bool SkGpuDevice::canHandleImageFilter(SkImageFilter* filter) {
SkSize size;
SkISize radius;
if (!filter->asABlur(&size) && !filter->asADilate(&radius) && !filter->asAnErode(&radius)) {
return false;
}
- SkDevice* dev = this->createCompatibleDevice(SkBitmap::kARGB_8888_Config,
- src.width(),
- src.height(),
- false);
- if (NULL == dev) {
+ return true;
+}
+
+bool SkGpuDevice::filterImage(SkImageFilter* filter, const SkBitmap& src,
+ const SkMatrix& ctm,
+ SkBitmap* result, SkIPoint* offset) {
+ // want explicitly our impl, so guard against a subclass of us overriding it
+ if (!this->SkGpuDevice::canHandleImageFilter(filter)) {
return false;
}
- SkAutoUnref aur(dev);
- SkCanvas canvas(dev);
- SkPaint paint;
- paint.setImageFilter(filter);
- canvas.drawSprite(src, 0, 0, &paint);
- *result = dev->accessBitmap(false);
+
+ SkAutoLockPixels alp(src, !src.getTexture());
+ if (!src.getTexture() && !src.readyToDraw()) {
+ return false;
+ }
+
+ GrPaint paint;
+ paint.reset();
+
+ GrSamplerState* sampler = paint.textureSampler(kBitmapTextureIdx);
+
+ GrTexture* texture;
+ SkAutoCachedTexture act(this, src, sampler, &texture);
+
+ result->setConfig(src.config(), src.width(), src.height());
+ GrRect rect = GrRect::MakeWH(src.width(), src.height());
+ GrTexture* resultTexture = filter_texture(fContext, texture, filter, rect);
+ if (resultTexture) {
+ result->setPixelRef(new SkGrTexturePixelRef(resultTexture))->unref();
+ resultTexture->unref();
+ }
return true;
}