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/. */
10 #include "PathHelpers.h"
11 #include "SourceSurfaceRawData.h"
14 #include "BufferEdgePad.h"
15 #include "BufferUnrotate.h"
18 # include "mozilla/arm.h"
19 # include "LuminanceNEON.h"
26 * Byte offsets of channels in a native packed gfxColor or cairo image surface.
29 # define GFX_ARGB32_OFFSET_A 0
30 # define GFX_ARGB32_OFFSET_R 1
31 # define GFX_ARGB32_OFFSET_G 2
32 # define GFX_ARGB32_OFFSET_B 3
34 # define GFX_ARGB32_OFFSET_A 3
35 # define GFX_ARGB32_OFFSET_R 2
36 # define GFX_ARGB32_OFFSET_G 1
37 # define GFX_ARGB32_OFFSET_B 0
41 // c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4)) * 255 + 0.5
42 static const uint8_t gsRGBToLinearRGBMap
[256] = {
43 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
44 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3,
45 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6,
46 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11,
47 12, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 17,
48 18, 18, 19, 19, 20, 20, 21, 22, 22, 23, 23, 24, 24, 25, 25,
49 26, 27, 27, 28, 29, 29, 30, 30, 31, 32, 32, 33, 34, 35, 35,
50 36, 37, 37, 38, 39, 40, 41, 41, 42, 43, 44, 45, 45, 46, 47,
51 48, 49, 50, 51, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
52 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 76, 77,
53 78, 79, 80, 81, 82, 84, 85, 86, 87, 88, 90, 91, 92, 93, 95,
54 96, 97, 99, 100, 101, 103, 104, 105, 107, 108, 109, 111, 112, 114, 115,
55 116, 118, 119, 121, 122, 124, 125, 127, 128, 130, 131, 133, 134, 136, 138,
56 139, 141, 142, 144, 146, 147, 149, 151, 152, 154, 156, 157, 159, 161, 163,
57 164, 166, 168, 170, 171, 173, 175, 177, 179, 181, 183, 184, 186, 188, 190,
58 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220,
59 222, 224, 226, 229, 231, 233, 235, 237, 239, 242, 244, 246, 248, 250, 253,
62 static void ComputesRGBLuminanceMask(const uint8_t* aSourceData
,
63 int32_t aSourceStride
, uint8_t* aDestData
,
64 int32_t aDestStride
, const IntSize
& aSize
,
67 if (mozilla::supports_neon()) {
68 ComputesRGBLuminanceMask_NEON(aSourceData
, aSourceStride
, aDestData
,
69 aDestStride
, aSize
, aOpacity
);
74 int32_t redFactor
= 55 * aOpacity
; // 255 * 0.2125 * opacity
75 int32_t greenFactor
= 183 * aOpacity
; // 255 * 0.7154 * opacity
76 int32_t blueFactor
= 18 * aOpacity
; // 255 * 0.0721
77 int32_t sourceOffset
= aSourceStride
- 4 * aSize
.width
;
78 const uint8_t* sourcePixel
= aSourceData
;
79 int32_t destOffset
= aDestStride
- aSize
.width
;
80 uint8_t* destPixel
= aDestData
;
82 for (int32_t y
= 0; y
< aSize
.height
; y
++) {
83 for (int32_t x
= 0; x
< aSize
.width
; x
++) {
84 uint8_t a
= sourcePixel
[GFX_ARGB32_OFFSET_A
];
87 *destPixel
= (redFactor
* sourcePixel
[GFX_ARGB32_OFFSET_R
] +
88 greenFactor
* sourcePixel
[GFX_ARGB32_OFFSET_G
] +
89 blueFactor
* sourcePixel
[GFX_ARGB32_OFFSET_B
]) >>
97 sourcePixel
+= sourceOffset
;
98 destPixel
+= destOffset
;
102 static void ComputeLinearRGBLuminanceMask(
103 const uint8_t* aSourceData
, int32_t aSourceStride
, uint8_t* aDestData
,
104 int32_t aDestStride
, const IntSize
& aSize
, float aOpacity
) {
105 int32_t redFactor
= 55 * aOpacity
; // 255 * 0.2125 * opacity
106 int32_t greenFactor
= 183 * aOpacity
; // 255 * 0.7154 * opacity
107 int32_t blueFactor
= 18 * aOpacity
; // 255 * 0.0721
108 int32_t sourceOffset
= aSourceStride
- 4 * aSize
.width
;
109 const uint8_t* sourcePixel
= aSourceData
;
110 int32_t destOffset
= aDestStride
- aSize
.width
;
111 uint8_t* destPixel
= aDestData
;
113 for (int32_t y
= 0; y
< aSize
.height
; y
++) {
114 for (int32_t x
= 0; x
< aSize
.width
; x
++) {
115 uint8_t a
= sourcePixel
[GFX_ARGB32_OFFSET_A
];
120 /* sRGB -> linearRGB -> intensity */
121 *destPixel
= static_cast<uint8_t>(
122 (gsRGBToLinearRGBMap
[sourcePixel
[GFX_ARGB32_OFFSET_R
]] *
124 gsRGBToLinearRGBMap
[sourcePixel
[GFX_ARGB32_OFFSET_G
]] *
126 gsRGBToLinearRGBMap
[sourcePixel
[GFX_ARGB32_OFFSET_B
]] *
130 uint8_t tempPixel
[4];
131 tempPixel
[GFX_ARGB32_OFFSET_B
] =
132 (255 * sourcePixel
[GFX_ARGB32_OFFSET_B
]) / a
;
133 tempPixel
[GFX_ARGB32_OFFSET_G
] =
134 (255 * sourcePixel
[GFX_ARGB32_OFFSET_G
]) / a
;
135 tempPixel
[GFX_ARGB32_OFFSET_R
] =
136 (255 * sourcePixel
[GFX_ARGB32_OFFSET_R
]) / a
;
138 /* sRGB -> linearRGB -> intensity */
139 *destPixel
= static_cast<uint8_t>(
140 ((gsRGBToLinearRGBMap
[tempPixel
[GFX_ARGB32_OFFSET_R
]] *
142 gsRGBToLinearRGBMap
[tempPixel
[GFX_ARGB32_OFFSET_G
]] *
144 gsRGBToLinearRGBMap
[tempPixel
[GFX_ARGB32_OFFSET_B
]] *
155 sourcePixel
+= sourceOffset
;
156 destPixel
+= destOffset
;
160 void DrawTarget::PushDeviceSpaceClipRects(const IntRect
* aRects
,
162 Matrix oldTransform
= GetTransform();
163 SetTransform(Matrix());
165 RefPtr
<PathBuilder
> pathBuilder
= CreatePathBuilder();
166 for (uint32_t i
= 0; i
< aCount
; i
++) {
167 AppendRectToPath(pathBuilder
, Rect(aRects
[i
]));
169 RefPtr
<Path
> path
= pathBuilder
->Finish();
172 SetTransform(oldTransform
);
175 void DrawTarget::FillRoundedRect(const RoundedRect
& aRect
,
176 const Pattern
& aPattern
,
177 const DrawOptions
& aOptions
) {
178 RefPtr
<Path
> path
= MakePathForRoundedRect(*this, aRect
.rect
, aRect
.corners
);
179 Fill(path
, aPattern
, aOptions
);
182 void DrawTarget::StrokeCircle(const Point
& aOrigin
, float radius
,
183 const Pattern
& aPattern
,
184 const StrokeOptions
& aStrokeOptions
,
185 const DrawOptions
& aOptions
) {
186 RefPtr
<Path
> path
= MakePathForCircle(*this, aOrigin
, radius
);
187 Stroke(path
, aPattern
, aStrokeOptions
, aOptions
);
190 void DrawTarget::FillCircle(const Point
& aOrigin
, float radius
,
191 const Pattern
& aPattern
,
192 const DrawOptions
& aOptions
) {
193 RefPtr
<Path
> path
= MakePathForCircle(*this, aOrigin
, radius
);
194 Fill(path
, aPattern
, aOptions
);
197 void DrawTarget::StrokeGlyphs(ScaledFont
* aFont
, const GlyphBuffer
& aBuffer
,
198 const Pattern
& aPattern
,
199 const StrokeOptions
& aStrokeOptions
,
200 const DrawOptions
& aOptions
) {
201 if (RefPtr
<Path
> path
= aFont
->GetPathForGlyphs(aBuffer
, this)) {
202 Stroke(path
, aPattern
, aStrokeOptions
, aOptions
);
206 already_AddRefed
<SourceSurface
> DrawTarget::IntoLuminanceSource(
207 LuminanceType aMaskType
, float aOpacity
) {
208 // The default IntoLuminanceSource implementation needs a format of B8G8R8A8.
209 if (mFormat
!= SurfaceFormat::B8G8R8A8
) {
213 RefPtr
<SourceSurface
> surface
= Snapshot();
218 IntSize size
= surface
->GetSize();
220 RefPtr
<DataSourceSurface
> maskSurface
= surface
->GetDataSurface();
225 DataSourceSurface::MappedSurface map
;
226 if (!maskSurface
->Map(DataSourceSurface::MapType::READ
, &map
)) {
230 // Create alpha channel mask for output
231 RefPtr
<SourceSurfaceAlignedRawData
> destMaskSurface
=
232 new SourceSurfaceAlignedRawData
;
233 if (!destMaskSurface
->Init(size
, SurfaceFormat::A8
, false, 0)) {
236 DataSourceSurface::MappedSurface destMap
;
237 if (!destMaskSurface
->Map(DataSourceSurface::MapType::WRITE
, &destMap
)) {
242 case LuminanceType::LUMINANCE
: {
243 ComputesRGBLuminanceMask(map
.mData
, map
.mStride
, destMap
.mData
,
244 destMap
.mStride
, size
, aOpacity
);
247 case LuminanceType::LINEARRGB
: {
248 ComputeLinearRGBLuminanceMask(map
.mData
, map
.mStride
, destMap
.mData
,
249 destMap
.mStride
, size
, aOpacity
);
254 maskSurface
->Unmap();
255 destMaskSurface
->Unmap();
257 return destMaskSurface
.forget();
260 void DrawTarget::Blur(const AlphaBoxBlur
& aBlur
) {
264 SurfaceFormat format
;
265 if (!LockBits(&data
, &size
, &stride
, &format
)) {
266 gfxWarning() << "Cannot perform in-place blur on non-data DrawTarget";
270 // Sanity check that the blur size matches the draw target.
271 MOZ_ASSERT(size
== aBlur
.GetSize());
272 MOZ_ASSERT(stride
== aBlur
.GetStride());
278 void DrawTarget::PadEdges(const IntRegion
& aRegion
) {
279 PadDrawTargetOutFromRegion(this, aRegion
);
282 bool DrawTarget::Unrotate(IntPoint aRotation
) {
286 SurfaceFormat format
;
288 if (LockBits(&data
, &size
, &stride
, &format
)) {
289 uint8_t bytesPerPixel
= BytesPerPixel(format
);
290 BufferUnrotate(data
, size
.width
* bytesPerPixel
, size
.height
, stride
,
291 aRotation
.x
* bytesPerPixel
, aRotation
.y
);
298 int32_t ShadowOptions::BlurRadius() const {
299 return AlphaBoxBlur::CalculateBlurRadius(Point(mSigma
, mSigma
)).width
;
302 void DrawTarget::DrawShadow(const Path
* aPath
, const Pattern
& aPattern
,
303 const ShadowOptions
& aShadow
,
304 const DrawOptions
& aOptions
,
305 const StrokeOptions
* aStrokeOptions
) {
306 // Get the approximate bounds of the source path
307 Rect bounds
= aPath
->GetFastBounds(GetTransform(), aStrokeOptions
);
308 if (bounds
.IsEmpty()) {
311 // Inflate the bounds by the blur radius
312 bounds
+= aShadow
.mOffset
;
313 int32_t blurRadius
= aShadow
.BlurRadius();
314 bounds
.Inflate(blurRadius
);
316 // Check if the bounds intersect the viewport
317 Rect
viewport(GetRect());
318 viewport
.Inflate(blurRadius
);
319 bounds
= bounds
.Intersect(viewport
);
321 if (bounds
.IsEmpty() || !bounds
.ToIntRect(&intBounds
) ||
322 !CanCreateSimilarDrawTarget(intBounds
.Size(), SurfaceFormat::A8
)) {
325 // Create a draw target for drawing the shadow mask with enough room for blur
326 RefPtr
<DrawTarget
> shadowTarget
= CreateShadowDrawTarget(
327 intBounds
.Size(), SurfaceFormat::A8
, aShadow
.mSigma
);
330 shadowTarget
->ClearRect(Rect());
332 if (!shadowTarget
|| !shadowTarget
->IsValid()) {
335 // Draw the path into the target for the initial shadow mask
336 Point offset
= Point(intBounds
.TopLeft()) - aShadow
.mOffset
;
337 shadowTarget
->SetTransform(GetTransform().PostTranslate(-offset
));
338 DrawOptions
shadowDrawOptions(
339 aOptions
.mAlpha
, CompositionOp::OP_OVER
,
340 blurRadius
> 1 ? AntialiasMode::NONE
: aOptions
.mAntialiasMode
);
341 if (aStrokeOptions
) {
342 shadowTarget
->Stroke(aPath
, aPattern
, *aStrokeOptions
, shadowDrawOptions
);
344 shadowTarget
->Fill(aPath
, aPattern
, shadowDrawOptions
);
346 RefPtr
<SourceSurface
> snapshot
= shadowTarget
->Snapshot();
347 // Finally, hand a snapshot of the mask to DrawSurfaceWithShadow for the
350 DrawSurfaceWithShadow(snapshot
, offset
, aShadow
, aOptions
.mCompositionOp
);
355 } // namespace mozilla