SkXfermode_opts.h 4.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138
  1. /*
  2. * Copyright 2015 Google Inc.
  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. #ifndef Sk4pxXfermode_DEFINED
  8. #define Sk4pxXfermode_DEFINED
  9. #include "include/private/SkNx.h"
  10. #include "src/core/Sk4px.h"
  11. #include "src/core/SkMSAN.h"
  12. #include "src/core/SkXfermodePriv.h"
  13. #ifdef SK_FORCE_RASTER_PIPELINE_BLITTER
  14. namespace SK_OPTS_NS {
  15. /*not static*/ inline SkXfermode* create_xfermode(SkBlendMode) { return nullptr; }
  16. }
  17. #else
  18. namespace { // NOLINT(google-build-namespaces)
  19. // Most xfermodes can be done most efficiently 4 pixels at a time in 8 or 16-bit fixed point.
  20. #define XFERMODE(Xfermode) \
  21. struct Xfermode { Sk4px operator()(const Sk4px&, const Sk4px&) const; }; \
  22. inline Sk4px Xfermode::operator()(const Sk4px& d, const Sk4px& s) const
  23. XFERMODE(Clear) { return Sk4px::DupPMColor(0); }
  24. XFERMODE(Src) { return s; }
  25. XFERMODE(Dst) { return d; }
  26. XFERMODE(SrcIn) { return s.approxMulDiv255(d.alphas() ); }
  27. XFERMODE(SrcOut) { return s.approxMulDiv255(d.alphas().inv()); }
  28. XFERMODE(SrcOver) { return s + d.approxMulDiv255(s.alphas().inv()); }
  29. XFERMODE(DstIn) { return SrcIn ()(s,d); }
  30. XFERMODE(DstOut) { return SrcOut ()(s,d); }
  31. XFERMODE(DstOver) { return SrcOver()(s,d); }
  32. // [ S * Da + (1 - Sa) * D]
  33. XFERMODE(SrcATop) { return (s * d.alphas() + d * s.alphas().inv()).div255(); }
  34. XFERMODE(DstATop) { return SrcATop()(s,d); }
  35. //[ S * (1 - Da) + (1 - Sa) * D ]
  36. XFERMODE(Xor) { return (s * d.alphas().inv() + d * s.alphas().inv()).div255(); }
  37. // [S + D ]
  38. XFERMODE(Plus) { return s.saturatedAdd(d); }
  39. // [S * D ]
  40. XFERMODE(Modulate) { return s.approxMulDiv255(d); }
  41. // [S + D - S * D]
  42. XFERMODE(Screen) {
  43. // Doing the math as S + (1-S)*D or S + (D - S*D) means the add and subtract can be done
  44. // in 8-bit space without overflow. S + (1-S)*D is a touch faster because inv() is cheap.
  45. return s + d.approxMulDiv255(s.inv());
  46. }
  47. #undef XFERMODE
  48. // A reasonable fallback mode for doing AA is to simply apply the transfermode first,
  49. // then linearly interpolate the AA.
  50. template <typename Xfermode>
  51. static Sk4px xfer_aa(const Sk4px& d, const Sk4px& s, const Sk4px& aa) {
  52. Sk4px bw = Xfermode()(d, s);
  53. return (bw * aa + d * aa.inv()).div255();
  54. }
  55. // For some transfermodes we specialize AA, either for correctness or performance.
  56. #define XFERMODE_AA(Xfermode) \
  57. template <> Sk4px xfer_aa<Xfermode>(const Sk4px& d, const Sk4px& s, const Sk4px& aa)
  58. // Plus' clamp needs to happen after AA. skia:3852
  59. XFERMODE_AA(Plus) { // [ clamp( (1-AA)D + (AA)(S+D) ) == clamp(D + AA*S) ]
  60. return d.saturatedAdd(s.approxMulDiv255(aa));
  61. }
  62. #undef XFERMODE_AA
  63. // Src and Clear modes are safe to use with unitialized dst buffers,
  64. // even if the implementation branches based on bytes from dst (e.g. asserts in Debug mode).
  65. // For those modes, just lie to MSAN that dst is always intialized.
  66. template <typename Xfermode> static void mark_dst_initialized_if_safe(void*, void*) {}
  67. template <> void mark_dst_initialized_if_safe<Src>(void* dst, void* end) {
  68. sk_msan_mark_initialized(dst, end, "Src doesn't read dst.");
  69. }
  70. template <> void mark_dst_initialized_if_safe<Clear>(void* dst, void* end) {
  71. sk_msan_mark_initialized(dst, end, "Clear doesn't read dst.");
  72. }
  73. template <typename Xfermode>
  74. class Sk4pxXfermode : public SkXfermode {
  75. public:
  76. Sk4pxXfermode() {}
  77. void xfer32(SkPMColor dst[], const SkPMColor src[], int n, const SkAlpha aa[]) const override {
  78. mark_dst_initialized_if_safe<Xfermode>(dst, dst+n);
  79. if (nullptr == aa) {
  80. Sk4px::MapDstSrc(n, dst, src, Xfermode());
  81. } else {
  82. Sk4px::MapDstSrcAlpha(n, dst, src, aa, xfer_aa<Xfermode>);
  83. }
  84. }
  85. };
  86. } // namespace
  87. namespace SK_OPTS_NS {
  88. /*not static*/ inline SkXfermode* create_xfermode(SkBlendMode mode) {
  89. switch (mode) {
  90. #define CASE(Xfermode) \
  91. case SkBlendMode::k##Xfermode: return new Sk4pxXfermode<Xfermode>()
  92. CASE(Clear);
  93. CASE(Src);
  94. CASE(Dst);
  95. CASE(SrcOver);
  96. CASE(DstOver);
  97. CASE(SrcIn);
  98. CASE(DstIn);
  99. CASE(SrcOut);
  100. CASE(DstOut);
  101. CASE(SrcATop);
  102. CASE(DstATop);
  103. CASE(Xor);
  104. CASE(Plus);
  105. CASE(Modulate);
  106. CASE(Screen);
  107. #undef CASE
  108. default: break;
  109. }
  110. return nullptr;
  111. }
  112. } // namespace SK_OPTS_NS
  113. #endif // #ifdef SK_FORCE_RASTER_PIPELINE_BLITTER
  114. #endif//Sk4pxXfermode_DEFINED