SkXfermodeImageFilter.cpp 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343
  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. #include "include/core/SkCanvas.h"
  8. #include "include/effects/SkArithmeticImageFilter.h"
  9. #include "include/effects/SkXfermodeImageFilter.h"
  10. #include "include/private/SkColorData.h"
  11. #include "src/core/SkImageFilterPriv.h"
  12. #include "src/core/SkReadBuffer.h"
  13. #include "src/core/SkSpecialImage.h"
  14. #include "src/core/SkSpecialSurface.h"
  15. #include "src/core/SkWriteBuffer.h"
  16. #if SK_SUPPORT_GPU
  17. #include "include/private/GrRecordingContext.h"
  18. #include "src/gpu/GrCaps.h"
  19. #include "src/gpu/GrClip.h"
  20. #include "src/gpu/GrColorSpaceXform.h"
  21. #include "src/gpu/GrRecordingContextPriv.h"
  22. #include "src/gpu/GrRenderTargetContext.h"
  23. #include "src/gpu/GrTextureProxy.h"
  24. #include "src/gpu/SkGr.h"
  25. #include "src/gpu/effects/GrTextureDomain.h"
  26. #include "src/gpu/effects/generated/GrConstColorProcessor.h"
  27. #include "src/gpu/effects/generated/GrSimpleTextureEffect.h"
  28. #endif
  29. #include "src/core/SkClipOpPriv.h"
  30. class SkXfermodeImageFilter_Base : public SkImageFilter {
  31. public:
  32. SkXfermodeImageFilter_Base(SkBlendMode mode, sk_sp<SkImageFilter> inputs[2],
  33. const CropRect* cropRect);
  34. protected:
  35. sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* source, const Context&,
  36. SkIPoint* offset) const override;
  37. SkIRect onFilterBounds(const SkIRect&, const SkMatrix& ctm,
  38. MapDirection, const SkIRect* inputRect) const override;
  39. #if SK_SUPPORT_GPU
  40. sk_sp<SkSpecialImage> filterImageGPU(SkSpecialImage* source,
  41. sk_sp<SkSpecialImage> background,
  42. const SkIPoint& backgroundOffset,
  43. sk_sp<SkSpecialImage> foreground,
  44. const SkIPoint& foregroundOffset,
  45. const SkIRect& bounds,
  46. const OutputProperties& outputProperties) const;
  47. #endif
  48. void flatten(SkWriteBuffer&) const override;
  49. void drawForeground(SkCanvas* canvas, SkSpecialImage*, const SkIRect&) const;
  50. #if SK_SUPPORT_GPU
  51. std::unique_ptr<GrFragmentProcessor> makeFGFrag(
  52. std::unique_ptr<GrFragmentProcessor> bgFP) const;
  53. #endif
  54. private:
  55. SK_FLATTENABLE_HOOKS(SkXfermodeImageFilter_Base)
  56. SkBlendMode fMode;
  57. friend class SkXfermodeImageFilter;
  58. typedef SkImageFilter INHERITED;
  59. };
  60. ///////////////////////////////////////////////////////////////////////////////
  61. sk_sp<SkImageFilter> SkXfermodeImageFilter::Make(SkBlendMode mode,
  62. sk_sp<SkImageFilter> background,
  63. sk_sp<SkImageFilter> foreground,
  64. const SkImageFilter::CropRect* cropRect) {
  65. sk_sp<SkImageFilter> inputs[2] = { std::move(background), std::move(foreground) };
  66. return sk_sp<SkImageFilter>(new SkXfermodeImageFilter_Base(mode, inputs, cropRect));
  67. }
  68. SkXfermodeImageFilter_Base::SkXfermodeImageFilter_Base(SkBlendMode mode,
  69. sk_sp<SkImageFilter> inputs[2],
  70. const CropRect* cropRect)
  71. : INHERITED(inputs, 2, cropRect)
  72. , fMode(mode)
  73. {}
  74. static unsigned unflatten_blendmode(SkReadBuffer& buffer) {
  75. unsigned mode = buffer.read32();
  76. (void)buffer.validate(mode <= (unsigned)SkBlendMode::kLastMode);
  77. return mode;
  78. }
  79. sk_sp<SkFlattenable> SkXfermodeImageFilter_Base::CreateProc(SkReadBuffer& buffer) {
  80. SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
  81. unsigned mode = unflatten_blendmode(buffer);
  82. if (!buffer.isValid()) {
  83. return nullptr;
  84. }
  85. return SkXfermodeImageFilter::Make((SkBlendMode)mode, common.getInput(0),
  86. common.getInput(1), &common.cropRect());
  87. }
  88. void SkXfermodeImageFilter_Base::flatten(SkWriteBuffer& buffer) const {
  89. this->INHERITED::flatten(buffer);
  90. buffer.write32((unsigned)fMode);
  91. }
  92. sk_sp<SkSpecialImage> SkXfermodeImageFilter_Base::onFilterImage(SkSpecialImage* source,
  93. const Context& ctx,
  94. SkIPoint* offset) const {
  95. SkIPoint backgroundOffset = SkIPoint::Make(0, 0);
  96. sk_sp<SkSpecialImage> background(this->filterInput(0, source, ctx, &backgroundOffset));
  97. SkIPoint foregroundOffset = SkIPoint::Make(0, 0);
  98. sk_sp<SkSpecialImage> foreground(this->filterInput(1, source, ctx, &foregroundOffset));
  99. SkIRect foregroundBounds = SkIRect::EmptyIRect();
  100. if (foreground) {
  101. foregroundBounds = SkIRect::MakeXYWH(foregroundOffset.x(), foregroundOffset.y(),
  102. foreground->width(), foreground->height());
  103. }
  104. SkIRect srcBounds = SkIRect::EmptyIRect();
  105. if (background) {
  106. srcBounds = SkIRect::MakeXYWH(backgroundOffset.x(), backgroundOffset.y(),
  107. background->width(), background->height());
  108. }
  109. srcBounds.join(foregroundBounds);
  110. if (srcBounds.isEmpty()) {
  111. return nullptr;
  112. }
  113. SkIRect bounds;
  114. if (!this->applyCropRect(ctx, srcBounds, &bounds)) {
  115. return nullptr;
  116. }
  117. offset->fX = bounds.left();
  118. offset->fY = bounds.top();
  119. #if SK_SUPPORT_GPU
  120. if (source->isTextureBacked()) {
  121. return this->filterImageGPU(source,
  122. background, backgroundOffset,
  123. foreground, foregroundOffset,
  124. bounds, ctx.outputProperties());
  125. }
  126. #endif
  127. sk_sp<SkSpecialSurface> surf(source->makeSurface(ctx.outputProperties(), bounds.size()));
  128. if (!surf) {
  129. return nullptr;
  130. }
  131. SkCanvas* canvas = surf->getCanvas();
  132. SkASSERT(canvas);
  133. canvas->clear(0x0); // can't count on background to fully clear the background
  134. canvas->translate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
  135. if (background) {
  136. SkPaint paint;
  137. paint.setBlendMode(SkBlendMode::kSrc);
  138. background->draw(canvas,
  139. SkIntToScalar(backgroundOffset.fX), SkIntToScalar(backgroundOffset.fY),
  140. &paint);
  141. }
  142. this->drawForeground(canvas, foreground.get(), foregroundBounds);
  143. return surf->makeImageSnapshot();
  144. }
  145. SkIRect SkXfermodeImageFilter_Base::onFilterBounds(const SkIRect& src,
  146. const SkMatrix& ctm,
  147. MapDirection dir,
  148. const SkIRect* inputRect) const {
  149. if (kReverse_MapDirection == dir) {
  150. return SkImageFilter::onFilterBounds(src, ctm, dir, inputRect);
  151. }
  152. SkASSERT(!inputRect);
  153. SkASSERT(2 == this->countInputs());
  154. auto getBackground = [&]() {
  155. return this->getInput(0) ? this->getInput(0)->filterBounds(src, ctm, dir, inputRect) : src;
  156. };
  157. auto getForeground = [&]() {
  158. return this->getInput(1) ? this->getInput(1)->filterBounds(src, ctm, dir, inputRect) : src;
  159. };
  160. switch (fMode) {
  161. case SkBlendMode::kClear:
  162. return SkIRect::MakeEmpty();
  163. case SkBlendMode::kSrc:
  164. case SkBlendMode::kDstATop:
  165. return getForeground();
  166. case SkBlendMode::kDst:
  167. case SkBlendMode::kSrcATop:
  168. return getBackground();
  169. case SkBlendMode::kSrcIn:
  170. case SkBlendMode::kDstIn: {
  171. auto result = getBackground();
  172. if (!result.intersect(getForeground())) {
  173. return SkIRect::MakeEmpty();
  174. }
  175. return result;
  176. }
  177. default: {
  178. auto result = getBackground();
  179. result.join(getForeground());
  180. return result;
  181. }
  182. }
  183. }
  184. void SkXfermodeImageFilter_Base::drawForeground(SkCanvas* canvas, SkSpecialImage* img,
  185. const SkIRect& fgBounds) const {
  186. SkPaint paint;
  187. paint.setBlendMode(fMode);
  188. if (img) {
  189. img->draw(canvas, SkIntToScalar(fgBounds.fLeft), SkIntToScalar(fgBounds.fTop), &paint);
  190. }
  191. SkAutoCanvasRestore acr(canvas, true);
  192. canvas->clipRect(SkRect::Make(fgBounds), kDifference_SkClipOp);
  193. paint.setColor(0);
  194. canvas->drawPaint(paint);
  195. }
  196. #if SK_SUPPORT_GPU
  197. #include "src/gpu/effects/GrXfermodeFragmentProcessor.h"
  198. sk_sp<SkSpecialImage> SkXfermodeImageFilter_Base::filterImageGPU(
  199. SkSpecialImage* source,
  200. sk_sp<SkSpecialImage> background,
  201. const SkIPoint& backgroundOffset,
  202. sk_sp<SkSpecialImage> foreground,
  203. const SkIPoint& foregroundOffset,
  204. const SkIRect& bounds,
  205. const OutputProperties& outputProperties) const {
  206. SkASSERT(source->isTextureBacked());
  207. auto context = source->getContext();
  208. sk_sp<GrTextureProxy> backgroundProxy, foregroundProxy;
  209. if (background) {
  210. backgroundProxy = background->asTextureProxyRef(context);
  211. }
  212. if (foreground) {
  213. foregroundProxy = foreground->asTextureProxyRef(context);
  214. }
  215. GrPaint paint;
  216. std::unique_ptr<GrFragmentProcessor> bgFP;
  217. if (backgroundProxy) {
  218. SkIRect bgSubset = background->subset();
  219. SkMatrix bgMatrix = SkMatrix::MakeTrans(
  220. SkIntToScalar(bgSubset.left() - backgroundOffset.fX),
  221. SkIntToScalar(bgSubset.top() - backgroundOffset.fY));
  222. bgFP = GrTextureDomainEffect::Make(
  223. std::move(backgroundProxy), bgMatrix,
  224. GrTextureDomain::MakeTexelDomain(bgSubset, GrTextureDomain::kDecal_Mode),
  225. GrTextureDomain::kDecal_Mode, GrSamplerState::Filter::kNearest);
  226. bgFP = GrColorSpaceXformEffect::Make(std::move(bgFP), background->getColorSpace(),
  227. background->alphaType(),
  228. outputProperties.colorSpace());
  229. } else {
  230. bgFP = GrConstColorProcessor::Make(SK_PMColor4fTRANSPARENT,
  231. GrConstColorProcessor::InputMode::kIgnore);
  232. }
  233. if (foregroundProxy) {
  234. SkIRect fgSubset = foreground->subset();
  235. SkMatrix fgMatrix = SkMatrix::MakeTrans(
  236. SkIntToScalar(fgSubset.left() - foregroundOffset.fX),
  237. SkIntToScalar(fgSubset.top() - foregroundOffset.fY));
  238. auto foregroundFP = GrTextureDomainEffect::Make(
  239. std::move(foregroundProxy), fgMatrix,
  240. GrTextureDomain::MakeTexelDomain(fgSubset, GrTextureDomain::kDecal_Mode),
  241. GrTextureDomain::kDecal_Mode, GrSamplerState::Filter::kNearest);
  242. foregroundFP = GrColorSpaceXformEffect::Make(std::move(foregroundFP),
  243. foreground->getColorSpace(),
  244. foreground->alphaType(),
  245. outputProperties.colorSpace());
  246. paint.addColorFragmentProcessor(std::move(foregroundFP));
  247. std::unique_ptr<GrFragmentProcessor> xferFP = this->makeFGFrag(std::move(bgFP));
  248. // A null 'xferFP' here means kSrc_Mode was used in which case we can just proceed
  249. if (xferFP) {
  250. paint.addColorFragmentProcessor(std::move(xferFP));
  251. }
  252. } else {
  253. paint.addColorFragmentProcessor(std::move(bgFP));
  254. }
  255. paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
  256. GrColorType colorType = SkColorTypeToGrColorType(outputProperties.colorType());
  257. sk_sp<GrRenderTargetContext> renderTargetContext(
  258. context->priv().makeDeferredRenderTargetContext(
  259. SkBackingFit::kApprox, bounds.width(), bounds.height(), colorType,
  260. sk_ref_sp(outputProperties.colorSpace())));
  261. if (!renderTargetContext) {
  262. return nullptr;
  263. }
  264. SkMatrix matrix;
  265. matrix.setTranslate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
  266. renderTargetContext->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, matrix,
  267. SkRect::Make(bounds));
  268. return SkSpecialImage::MakeDeferredFromGpu(
  269. context,
  270. SkIRect::MakeWH(bounds.width(), bounds.height()),
  271. kNeedNewImageUniqueID_SpecialImage,
  272. renderTargetContext->asTextureProxyRef(),
  273. renderTargetContext->colorSpaceInfo().refColorSpace());
  274. }
  275. std::unique_ptr<GrFragmentProcessor> SkXfermodeImageFilter_Base::makeFGFrag(
  276. std::unique_ptr<GrFragmentProcessor> bgFP) const {
  277. return GrXfermodeFragmentProcessor::MakeFromDstProcessor(std::move(bgFP), fMode);
  278. }
  279. #endif
  280. ///////////////////////////////////////////////////////////////////////////////////////////////////
  281. void SkXfermodeImageFilter::RegisterFlattenables() {
  282. SK_REGISTER_FLATTENABLE(SkXfermodeImageFilter_Base);
  283. }