Source code

Revision control

Other Tools

1
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
3
/* This Source Code Form is subject to the terms of the Mozilla Public
4
* License, v. 2.0. If a copy of the MPL was not distributed with this
5
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7
#ifndef MOZILLA_LAYERS_EFFECTS_H
8
#define MOZILLA_LAYERS_EFFECTS_H
9
10
#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc
11
#include "mozilla/RefPtr.h" // for RefPtr, already_AddRefed, etc
12
#include "mozilla/gfx/Matrix.h" // for Matrix4x4
13
#include "mozilla/gfx/Point.h" // for IntSize
14
#include "mozilla/gfx/Rect.h" // for Rect
15
#include "mozilla/gfx/Types.h" // for SamplingFilter, etc
16
#include "mozilla/layers/CompositorTypes.h" // for EffectTypes, etc
17
#include "mozilla/layers/LayersTypes.h"
18
#include "mozilla/layers/TextureHost.h" // for CompositingRenderTarget, etc
19
#include "mozilla/mozalloc.h" // for operator delete, etc
20
#include "nscore.h" // for nsACString
21
#include "mozilla/EnumeratedArray.h"
22
23
namespace mozilla {
24
namespace layers {
25
26
/**
27
* Effects and effect chains are used by the compositor API (see Compositor.h).
28
* An effect chain represents a rendering method, for example some shader and
29
* the data required for that shader to run. An effect is some component of the
30
* chain and its data.
31
*
32
* An effect chain consists of a primary effect - how the 'texture' memory
33
* should be interpreted (RGBA, BGRX, YCBCR, etc.) - and any number of secondary
34
* effects
35
* - any way in which rendering can be changed, e.g., applying a mask layer.
36
*
37
* During the rendering process, an effect chain is created by the layer being
38
* rendered and the primary effect is added by the compositable host. Secondary
39
* effects may be added by the layer or compositable. The effect chain is passed
40
* to the compositor by the compositable host as a parameter to DrawQuad.
41
*/
42
43
struct TexturedEffect;
44
45
struct Effect {
46
NS_INLINE_DECL_REFCOUNTING(Effect)
47
48
explicit Effect(EffectTypes aType) : mType(aType) {}
49
50
EffectTypes mType;
51
52
virtual TexturedEffect* AsTexturedEffect() { return nullptr; }
53
virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) = 0;
54
55
protected:
56
virtual ~Effect() = default;
57
};
58
59
// Render from a texture
60
struct TexturedEffect : public Effect {
61
TexturedEffect(EffectTypes aType, TextureSource* aTexture,
62
bool aPremultiplied, gfx::SamplingFilter aSamplingFilter)
63
: Effect(aType),
64
mTextureCoords(0, 0, 1.0f, 1.0f),
65
mTexture(aTexture),
66
mPremultiplied(aPremultiplied),
67
mSamplingFilter(aSamplingFilter) {}
68
69
TexturedEffect* AsTexturedEffect() override { return this; }
70
virtual const char* Name() = 0;
71
void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;
72
73
gfx::Rect mTextureCoords;
74
TextureSource* mTexture;
75
bool mPremultiplied;
76
gfx::SamplingFilter mSamplingFilter;
77
};
78
79
// Support an alpha mask.
80
struct EffectMask : public Effect {
81
EffectMask(TextureSource* aMaskTexture, gfx::IntSize aSize,
82
const gfx::Matrix4x4& aMaskTransform)
83
: Effect(EffectTypes::MASK),
84
mMaskTexture(aMaskTexture),
85
mSize(aSize),
86
mMaskTransform(aMaskTransform) {}
87
88
void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;
89
90
TextureSource* mMaskTexture;
91
gfx::IntSize mSize;
92
gfx::Matrix4x4 mMaskTransform;
93
};
94
95
struct EffectBlendMode : public Effect {
96
explicit EffectBlendMode(gfx::CompositionOp aBlendMode)
97
: Effect(EffectTypes::BLEND_MODE), mBlendMode(aBlendMode) {}
98
99
virtual const char* Name() { return "EffectBlendMode"; }
100
void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;
101
102
gfx::CompositionOp mBlendMode;
103
};
104
105
// Render to a render target rather than the screen.
106
struct EffectRenderTarget : public TexturedEffect {
107
explicit EffectRenderTarget(CompositingRenderTarget* aRenderTarget)
108
: TexturedEffect(EffectTypes::RENDER_TARGET, aRenderTarget, true,
109
gfx::SamplingFilter::LINEAR),
110
mRenderTarget(aRenderTarget) {}
111
112
const char* Name() override { return "EffectRenderTarget"; }
113
void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;
114
115
RefPtr<CompositingRenderTarget> mRenderTarget;
116
117
protected:
118
EffectRenderTarget(EffectTypes aType, CompositingRenderTarget* aRenderTarget)
119
: TexturedEffect(aType, aRenderTarget, true, gfx::SamplingFilter::LINEAR),
120
mRenderTarget(aRenderTarget) {}
121
};
122
123
// Render to a render target rather than the screen.
124
struct EffectColorMatrix : public Effect {
125
explicit EffectColorMatrix(gfx::Matrix5x4 aMatrix)
126
: Effect(EffectTypes::COLOR_MATRIX), mColorMatrix(aMatrix) {}
127
128
void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;
129
const gfx::Matrix5x4 mColorMatrix;
130
};
131
132
struct EffectRGB : public TexturedEffect {
133
EffectRGB(TextureSource* aTexture, bool aPremultiplied,
134
gfx::SamplingFilter aSamplingFilter, bool aFlipped = false)
135
: TexturedEffect(EffectTypes::RGB, aTexture, aPremultiplied,
136
aSamplingFilter) {}
137
138
const char* Name() override { return "EffectRGB"; }
139
};
140
141
struct EffectYCbCr : public TexturedEffect {
142
EffectYCbCr(TextureSource* aSource, gfx::YUVColorSpace aYUVColorSpace,
143
gfx::ColorRange aColorRange, gfx::ColorDepth aColorDepth,
144
gfx::SamplingFilter aSamplingFilter)
145
: TexturedEffect(EffectTypes::YCBCR, aSource, false, aSamplingFilter),
146
mYUVColorSpace(aYUVColorSpace),
147
mColorRange(aColorRange),
148
mColorDepth(aColorDepth) {}
149
150
const char* Name() override { return "EffectYCbCr"; }
151
152
gfx::YUVColorSpace mYUVColorSpace;
153
gfx::ColorRange mColorRange;
154
gfx::ColorDepth mColorDepth;
155
};
156
157
struct EffectNV12 : public EffectYCbCr {
158
EffectNV12(TextureSource* aSource, gfx::YUVColorSpace aYUVColorSpace,
159
gfx::ColorRange aColorRange, gfx::ColorDepth aColorDepth,
160
gfx::SamplingFilter aSamplingFilter)
161
: EffectYCbCr(aSource, aYUVColorSpace, aColorRange, aColorDepth,
162
aSamplingFilter) {
163
mType = EffectTypes::NV12;
164
}
165
166
const char* Name() override { return "EffectNV12"; }
167
};
168
169
struct EffectComponentAlpha : public TexturedEffect {
170
EffectComponentAlpha(TextureSource* aOnBlack, TextureSource* aOnWhite,
171
gfx::SamplingFilter aSamplingFilter)
172
: TexturedEffect(EffectTypes::COMPONENT_ALPHA, nullptr, false,
173
aSamplingFilter),
174
mOnBlack(aOnBlack),
175
mOnWhite(aOnWhite) {}
176
177
const char* Name() override { return "EffectComponentAlpha"; }
178
179
TextureSource* mOnBlack;
180
TextureSource* mOnWhite;
181
};
182
183
struct EffectSolidColor : public Effect {
184
explicit EffectSolidColor(const gfx::DeviceColor& aColor)
185
: Effect(EffectTypes::SOLID_COLOR), mColor(aColor) {}
186
187
void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;
188
189
gfx::DeviceColor mColor;
190
};
191
192
struct EffectChain {
193
EffectChain() : mLayerRef(nullptr) {}
194
explicit EffectChain(void* aLayerRef) : mLayerRef(aLayerRef) {}
195
196
RefPtr<Effect> mPrimaryEffect;
197
EnumeratedArray<EffectTypes, EffectTypes::MAX_SECONDARY, RefPtr<Effect>>
198
mSecondaryEffects;
199
void* mLayerRef; //!< For LayerScope logging
200
};
201
202
/**
203
* Create a Textured effect corresponding to aFormat and using
204
* aSource as the (first) texture source.
205
*
206
* Note that aFormat can be different form aSource->GetFormat if, we are
207
* creating an effect that takes several texture sources (like with YCBCR
208
* where aFormat would be FORMAT_YCBCR and each texture source would be
209
* a one-channel A8 texture)
210
*/
211
inline already_AddRefed<TexturedEffect> CreateTexturedEffect(
212
gfx::SurfaceFormat aFormat, TextureSource* aSource,
213
const gfx::SamplingFilter aSamplingFilter, bool isAlphaPremultiplied) {
214
MOZ_ASSERT(aSource);
215
RefPtr<TexturedEffect> result;
216
switch (aFormat) {
217
case gfx::SurfaceFormat::B8G8R8A8:
218
case gfx::SurfaceFormat::B8G8R8X8:
219
case gfx::SurfaceFormat::R8G8B8X8:
220
case gfx::SurfaceFormat::R5G6B5_UINT16:
221
case gfx::SurfaceFormat::R8G8B8A8:
222
result = new EffectRGB(aSource, isAlphaPremultiplied, aSamplingFilter);
223
break;
224
case gfx::SurfaceFormat::YUV:
225
case gfx::SurfaceFormat::NV12:
226
case gfx::SurfaceFormat::P010:
227
case gfx::SurfaceFormat::P016:
228
MOZ_ASSERT_UNREACHABLE(
229
"gfx::SurfaceFormat::YUV/NV12/P010/P016 is invalid");
230
break;
231
default:
232
NS_WARNING("unhandled program type");
233
break;
234
}
235
236
return result.forget();
237
}
238
239
inline already_AddRefed<TexturedEffect> CreateTexturedEffect(
240
TextureHost* aHost, TextureSource* aSource,
241
const gfx::SamplingFilter aSamplingFilter, bool isAlphaPremultiplied) {
242
MOZ_ASSERT(aHost);
243
MOZ_ASSERT(aSource);
244
245
RefPtr<TexturedEffect> result;
246
247
switch (aHost->GetReadFormat()) {
248
case gfx::SurfaceFormat::YUV:
249
MOZ_ASSERT(aHost->GetYUVColorSpace() != gfx::YUVColorSpace::UNKNOWN);
250
result = new EffectYCbCr(aSource, aHost->GetYUVColorSpace(),
251
aHost->GetColorRange(), aHost->GetColorDepth(),
252
aSamplingFilter);
253
break;
254
case gfx::SurfaceFormat::NV12:
255
case gfx::SurfaceFormat::P010:
256
case gfx::SurfaceFormat::P016:
257
result = new EffectNV12(aSource, aHost->GetYUVColorSpace(),
258
aHost->GetColorRange(), aHost->GetColorDepth(),
259
aSamplingFilter);
260
break;
261
default:
262
result = CreateTexturedEffect(aHost->GetReadFormat(), aSource,
263
aSamplingFilter, isAlphaPremultiplied);
264
break;
265
}
266
return result.forget();
267
}
268
269
/**
270
* Create a textured effect based on aSource format and the presence of
271
* aSourceOnWhite.
272
*
273
* aSourceOnWhite can be null.
274
*/
275
inline already_AddRefed<TexturedEffect> CreateTexturedEffect(
276
TextureSource* aSource, TextureSource* aSourceOnWhite,
277
const gfx::SamplingFilter aSamplingFilter, bool isAlphaPremultiplied) {
278
MOZ_ASSERT(aSource);
279
if (aSourceOnWhite) {
280
MOZ_ASSERT(aSource->GetFormat() == gfx::SurfaceFormat::R8G8B8X8 ||
281
aSource->GetFormat() == gfx::SurfaceFormat::B8G8R8X8);
282
MOZ_ASSERT(aSource->GetFormat() == aSourceOnWhite->GetFormat());
283
return MakeAndAddRef<EffectComponentAlpha>(aSource, aSourceOnWhite,
284
aSamplingFilter);
285
}
286
287
return CreateTexturedEffect(aSource->GetFormat(), aSource, aSamplingFilter,
288
isAlphaPremultiplied);
289
}
290
291
/**
292
* Create a textured effect based on aSource format.
293
*
294
* This version excudes the possibility of component alpha.
295
*/
296
inline already_AddRefed<TexturedEffect> CreateTexturedEffect(
297
TextureSource* aTexture, const gfx::SamplingFilter aSamplingFilter) {
298
return CreateTexturedEffect(aTexture, nullptr, aSamplingFilter, true);
299
}
300
301
} // namespace layers
302
} // namespace mozilla
303
304
#endif