src/third_party/skia/src/effects/SkXfermodeImageFilter.cpp

   1 /*
   2  * Copyright 2013 The Android Open Source Project
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "SkXfermodeImageFilter.h"
   9 #include "SkCanvas.h"
  10 #include "SkDevice.h"
  11 #include "SkColorPriv.h"
  12 #include "SkReadBuffer.h"
  13 #include "SkWriteBuffer.h"
  14 #include "SkXfermode.h"
  15 #if SK_SUPPORT_GPU
  16 #include "GrContext.h"
  17 #include "effects/GrSimpleTextureEffect.h"
  18 #include "SkGr.h"
  19 #endif
  20
  21 ///////////////////////////////////////////////////////////////////////////////
  22
  23 SkXfermodeImageFilter::SkXfermodeImageFilter(SkXfermode* mode,
  24                                              SkImageFilter* inputs[2],
  25                                              const CropRect* cropRect,
  26                                              uint32_t uniqueID)
  27   : INHERITED(2, inputs, cropRect, uniqueID), fMode(mode) {
  28     SkSafeRef(fMode);
  29 }
  30
  31 SkXfermodeImageFilter::~SkXfermodeImageFilter() {
  32     SkSafeUnref(fMode);
  33 }
  34
  35 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
  36 SkXfermodeImageFilter::SkXfermodeImageFilter(SkReadBuffer& buffer)
  37   : INHERITED(2, buffer) {
  38     fMode = buffer.readXfermode();
  39 }
  40 #endif
  41
  42 SkFlattenable* SkXfermodeImageFilter::CreateProc(SkReadBuffer& buffer) {
  43     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
  44     SkAutoTUnref<SkXfermode> mode(buffer.readXfermode());
  45     return Create(mode, common.getInput(0), common.getInput(1), &common.cropRect(), common.uniqueID());
  46 }
  47
  48 void SkXfermodeImageFilter::flatten(SkWriteBuffer& buffer) const {
  49     this->INHERITED::flatten(buffer);
  50     buffer.writeFlattenable(fMode);
  51 }
  52
  53 bool SkXfermodeImageFilter::onFilterImage(Proxy* proxy,
  54                                             const SkBitmap& src,
  55                                             const Context& ctx,
  56                                             SkBitmap* dst,
  57                                             SkIPoint* offset) const {
  58     SkBitmap background = src, foreground = src;
  59     SkImageFilter* backgroundInput = getInput(0);
  60     SkImageFilter* foregroundInput = getInput(1);
  61     SkIPoint backgroundOffset = SkIPoint::Make(0, 0);
  62     if (backgroundInput &&
  63         !backgroundInput->filterImage(proxy, src, ctx, &background, &backgroundOffset)) {
  64         background.reset();
  65     }
  66     SkIPoint foregroundOffset = SkIPoint::Make(0, 0);
  67     if (foregroundInput &&
  68         !foregroundInput->filterImage(proxy, src, ctx, &foreground, &foregroundOffset)) {
  69         foreground.reset();
  70     }
  71
  72     SkIRect bounds, foregroundBounds;
  73     if (!applyCropRect(ctx, foreground, foregroundOffset, &foregroundBounds)) {
  74         foregroundBounds.setEmpty();
  75         foreground.reset();
  76     }
  77     if (!applyCropRect(ctx, background, backgroundOffset, &bounds)) {
  78         bounds.setEmpty();
  79         background.reset();
  80     }
  81     bounds.join(foregroundBounds);
  82     if (bounds.isEmpty()) {
  83         return false;
  84     }
  85
  86     SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(bounds.width(), bounds.height()));
  87     if (NULL == device.get()) {
  88         return false;
  89     }
  90     SkCanvas canvas(device);
  91     canvas.translate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
  92     SkPaint paint;
  93     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
  94     canvas.drawBitmap(background, SkIntToScalar(backgroundOffset.fX),
  95                       SkIntToScalar(backgroundOffset.fY), &paint);
  96     paint.setXfermode(fMode);
  97     canvas.drawBitmap(foreground, SkIntToScalar(foregroundOffset.fX),
  98                       SkIntToScalar(foregroundOffset.fY), &paint);
  99     canvas.clipRect(SkRect::Make(foregroundBounds), SkRegion::kDifference_Op);
 100     paint.setColor(SK_ColorTRANSPARENT);
 101     canvas.drawPaint(paint);
 102     *dst = device->accessBitmap(false);
 103     offset->fX = bounds.left();
 104     offset->fY = bounds.top();
 105     return true;
 106 }
 107
 108 #if SK_SUPPORT_GPU
 109
 110 bool SkXfermodeImageFilter::canFilterImageGPU() const {
 111     return fMode && fMode->asFragmentProcessor(NULL, NULL) && !cropRectIsSet();
 112 }
 113
 114 bool SkXfermodeImageFilter::filterImageGPU(Proxy* proxy,
 115                                            const SkBitmap& src,
 116                                            const Context& ctx,
 117                                            SkBitmap* result,
 118                                            SkIPoint* offset) const {
 119     SkBitmap background = src;
 120     SkIPoint backgroundOffset = SkIPoint::Make(0, 0);
 121     if (getInput(0) && !getInput(0)->getInputResultGPU(proxy, src, ctx, &background,
 122                                                        &backgroundOffset)) {
 123         return onFilterImage(proxy, src, ctx, result, offset);
 124     }
 125     GrTexture* backgroundTex = background.getTexture();
 126     SkBitmap foreground = src;
 127     SkIPoint foregroundOffset = SkIPoint::Make(0, 0);
 128     if (getInput(1) && !getInput(1)->getInputResultGPU(proxy, src, ctx, &foreground,
 129                                                        &foregroundOffset)) {
 130         return onFilterImage(proxy, src, ctx, result, offset);
 131     }
 132     GrTexture* foregroundTex = foreground.getTexture();
 133     GrContext* context = foregroundTex->getContext();
 134
 135     GrFragmentProcessor* xferProcessor = NULL;
 136
 137     GrSurfaceDesc desc;
 138     desc.fFlags = kRenderTarget_GrSurfaceFlag | kNoStencil_GrSurfaceFlag;
 139     desc.fWidth = src.width();
 140     desc.fHeight = src.height();
 141     desc.fConfig = kSkia8888_GrPixelConfig;
 142     SkAutoTUnref<GrTexture> dst(
 143         context->refScratchTexture(desc, GrContext::kApprox_ScratchTexMatch));
 144     if (!dst) {
 145         return false;
 146     }
 147     GrContext::AutoRenderTarget art(context, dst->asRenderTarget());
 148
 149     if (!fMode || !fMode->asFragmentProcessor(&xferProcessor, backgroundTex)) {
 150         // canFilterImageGPU() should've taken care of this
 151         SkASSERT(false);
 152         return false;
 153     }
 154
 155     SkMatrix foregroundMatrix = GrCoordTransform::MakeDivByTextureWHMatrix(foregroundTex);
 156     foregroundMatrix.preTranslate(SkIntToScalar(backgroundOffset.fX-foregroundOffset.fX),
 157                                   SkIntToScalar(backgroundOffset.fY-foregroundOffset.fY));
 158
 159
 160     SkRect srcRect;
 161     src.getBounds(&srcRect);
 162
 163     GrPaint paint;
 164     paint.addColorTextureProcessor(foregroundTex, foregroundMatrix);
 165     paint.addColorProcessor(xferProcessor)->unref();
 166     context->drawRect(paint, srcRect);
 167
 168     offset->fX = backgroundOffset.fX;
 169     offset->fY = backgroundOffset.fY;
 170     WrapTexture(dst, src.width(), src.height(), result);
 171     return true;
 172 }
 173
 174 #endif