1 /*
2 * Copyright 2006 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 "src/shaders/SkBlendShader.h"
9
10 #include "include/core/SkBlendMode.h"
11 #include "include/core/SkBlender.h"
12 #include "include/core/SkData.h"
13 #include "include/core/SkFlattenable.h"
14 #include "include/effects/SkRuntimeEffect.h"
15 #include "src/base/SkArenaAlloc.h"
16 #include "src/core/SkBlendModePriv.h"
17 #include "src/core/SkBlenderBase.h"
18 #include "src/core/SkEffectPriv.h"
19 #include "src/core/SkKnownRuntimeEffects.h"
20 #include "src/core/SkRasterPipeline.h"
21 #include "src/core/SkRasterPipelineOpContexts.h"
22 #include "src/core/SkRasterPipelineOpList.h"
23 #include "src/core/SkReadBuffer.h"
24 #include "src/core/SkWriteBuffer.h"
25 #include "src/shaders/SkShaderBase.h"
26
27 #include <optional>
28
CreateProc(SkReadBuffer & buffer)29 sk_sp<SkFlattenable> SkBlendShader::CreateProc(SkReadBuffer& buffer) {
30 sk_sp<SkShader> dst(buffer.readShader());
31 sk_sp<SkShader> src(buffer.readShader());
32 if (!buffer.validate(dst && src)) {
33 return nullptr;
34 }
35
36 unsigned mode = buffer.read32();
37
38 if (mode == kCustom_SkBlendMode) {
39 sk_sp<SkBlender> blender = buffer.readBlender();
40 if (buffer.validate(blender != nullptr)) {
41 return SkShaders::Blend(std::move(blender), std::move(dst), std::move(src));
42 }
43 } else {
44 if (buffer.validate(mode <= (unsigned)SkBlendMode::kLastMode)) {
45 return SkShaders::Blend(static_cast<SkBlendMode>(mode), std::move(dst), std::move(src));
46 }
47 }
48 return nullptr;
49 }
50
flatten(SkWriteBuffer & buffer) const51 void SkBlendShader::flatten(SkWriteBuffer& buffer) const {
52 buffer.writeFlattenable(fDst.get());
53 buffer.writeFlattenable(fSrc.get());
54 buffer.write32((int)fMode);
55 }
56
57 // Returns the output of e0, and leaves the output of e1 in r,g,b,a
append_two_shaders(const SkStageRec & rec,const SkShaders::MatrixRec & mRec,SkShader * s0,SkShader * s1)58 static float* append_two_shaders(const SkStageRec& rec,
59 const SkShaders::MatrixRec& mRec,
60 SkShader* s0,
61 SkShader* s1) {
62 struct Storage {
63 float fCoords[2 * SkRasterPipeline_kMaxStride];
64 float fRes0[4 * SkRasterPipeline_kMaxStride];
65 };
66 auto storage = rec.fAlloc->make<Storage>();
67
68 // Note we cannot simply apply mRec here and then unconditionally store the coordinates. When
69 // building for Android Framework it would interrupt the backwards local matrix concatenation if
70 // mRec had a pending local matrix and either of the children also had a local matrix.
71 // b/256873449
72 if (mRec.rasterPipelineCoordsAreSeeded()) {
73 rec.fPipeline->append(SkRasterPipelineOp::store_src_rg, storage->fCoords);
74 }
75 if (!as_SB(s0)->appendStages(rec, mRec)) {
76 return nullptr;
77 }
78 rec.fPipeline->append(SkRasterPipelineOp::store_src, storage->fRes0);
79
80 if (mRec.rasterPipelineCoordsAreSeeded()) {
81 rec.fPipeline->append(SkRasterPipelineOp::load_src_rg, storage->fCoords);
82 }
83 if (!as_SB(s1)->appendStages(rec, mRec)) {
84 return nullptr;
85 }
86 return storage->fRes0;
87 }
88
appendStages(const SkStageRec & rec,const SkShaders::MatrixRec & mRec) const89 bool SkBlendShader::appendStages(const SkStageRec& rec, const SkShaders::MatrixRec& mRec) const {
90 float* res0 = append_two_shaders(rec, mRec, fDst.get(), fSrc.get());
91 if (!res0) {
92 return false;
93 }
94
95 rec.fPipeline->append(SkRasterPipelineOp::load_dst, res0);
96 SkBlendMode_AppendStages(fMode, rec.fPipeline);
97 return true;
98 }
99
Blend(SkBlendMode mode,sk_sp<SkShader> dst,sk_sp<SkShader> src)100 sk_sp<SkShader> SkShaders::Blend(SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src) {
101 if (!src || !dst) {
102 return nullptr;
103 }
104 switch (mode) {
105 case SkBlendMode::kClear:
106 return Color(0);
107 case SkBlendMode::kDst:
108 return dst;
109 case SkBlendMode::kSrc:
110 return src;
111 default:
112 break;
113 }
114 return sk_sp<SkShader>(new SkBlendShader(mode, std::move(dst), std::move(src)));
115 }
116
Blend(sk_sp<SkBlender> blender,sk_sp<SkShader> dst,sk_sp<SkShader> src)117 sk_sp<SkShader> SkShaders::Blend(sk_sp<SkBlender> blender,
118 sk_sp<SkShader> dst,
119 sk_sp<SkShader> src) {
120 using namespace SkKnownRuntimeEffects;
121
122 if (!src || !dst) {
123 return nullptr;
124 }
125 if (!blender) {
126 return SkShaders::Blend(SkBlendMode::kSrcOver, std::move(dst), std::move(src));
127 }
128 if (std::optional<SkBlendMode> mode = as_BB(blender)->asBlendMode()) {
129 return sk_make_sp<SkBlendShader>(mode.value(), std::move(dst), std::move(src));
130 }
131
132 // This isn't a built-in blend mode; we might as well use a runtime effect to evaluate it.
133 const SkRuntimeEffect* blendEffect = GetKnownRuntimeEffect(StableKey::kBlend);
134
135 SkRuntimeEffect::ChildPtr children[] = {std::move(src), std::move(dst), std::move(blender)};
136 return blendEffect->makeShader(/*uniforms=*/{}, children);
137 }
138
SkRegisterBlendShaderFlattenable()139 void SkRegisterBlendShaderFlattenable() {
140 SK_REGISTER_FLATTENABLE(SkBlendShader);
141 // Previous name
142 SkFlattenable::Register("SkShader_Blend", SkBlendShader::CreateProc);
143 }
144