1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6 #include "OrientedImage.h"
10 #include "gfx2DGlue.h"
11 #include "gfxContext.h"
12 #include "gfxDrawable.h"
13 #include "gfxPlatform.h"
15 #include "ImageRegion.h"
16 #include "mozilla/SVGImageContext.h"
23 using layers::ImageContainer
;
28 OrientedImage::GetWidth(int32_t* aWidth
) {
29 if (mOrientation
.SwapsWidthAndHeight()) {
30 return InnerImage()->GetHeight(aWidth
);
32 return InnerImage()->GetWidth(aWidth
);
37 OrientedImage::GetHeight(int32_t* aHeight
) {
38 if (mOrientation
.SwapsWidthAndHeight()) {
39 return InnerImage()->GetWidth(aHeight
);
41 return InnerImage()->GetHeight(aHeight
);
45 nsresult
OrientedImage::GetNativeSizes(nsTArray
<IntSize
>& aNativeSizes
) const {
46 nsresult rv
= InnerImage()->GetNativeSizes(aNativeSizes
);
48 if (mOrientation
.SwapsWidthAndHeight()) {
49 auto i
= aNativeSizes
.Length();
52 swap(aNativeSizes
[i
].width
, aNativeSizes
[i
].height
);
60 OrientedImage::GetIntrinsicSize(nsSize
* aSize
) {
61 nsresult rv
= InnerImage()->GetIntrinsicSize(aSize
);
63 if (mOrientation
.SwapsWidthAndHeight()) {
64 swap(aSize
->width
, aSize
->height
);
70 Maybe
<AspectRatio
> OrientedImage::GetIntrinsicRatio() {
71 Maybe
<AspectRatio
> ratio
= InnerImage()->GetIntrinsicRatio();
72 if (ratio
&& mOrientation
.SwapsWidthAndHeight()) {
73 ratio
= Some(ratio
->Inverted());
78 already_AddRefed
<SourceSurface
> OrientedImage::OrientSurface(
79 Orientation aOrientation
, SourceSurface
* aSurface
) {
82 // If the image does not require any re-orientation, return aSurface itself.
83 if (aOrientation
.IsIdentity()) {
84 return do_AddRef(aSurface
);
87 // Determine the size of the new surface.
88 nsIntSize originalSize
= aSurface
->GetSize();
89 nsIntSize targetSize
= originalSize
;
90 if (aOrientation
.SwapsWidthAndHeight()) {
91 swap(targetSize
.width
, targetSize
.height
);
94 // Create our drawable.
95 RefPtr
<gfxDrawable
> drawable
= new gfxSurfaceDrawable(aSurface
, originalSize
);
97 // Determine an appropriate format for the surface.
98 gfx::SurfaceFormat surfaceFormat
= IsOpaque(aSurface
->GetFormat())
99 ? gfx::SurfaceFormat::OS_RGBX
100 : gfx::SurfaceFormat::OS_RGBA
;
102 // Create the new surface to draw into.
103 RefPtr
<DrawTarget
> target
=
104 gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(
105 targetSize
, surfaceFormat
);
106 if (!target
|| !target
->IsValid()) {
107 NS_ERROR("Could not create a DrawTarget");
112 RefPtr
<gfxContext
> ctx
= gfxContext::CreateOrNull(target
);
113 MOZ_ASSERT(ctx
); // already checked the draw target above
114 ctx
->Multiply(OrientationMatrix(aOrientation
, originalSize
));
115 gfxUtils::DrawPixelSnapped(ctx
, drawable
, SizeDouble(originalSize
),
116 ImageRegion::Create(originalSize
), surfaceFormat
,
117 SamplingFilter::LINEAR
);
119 return target
->Snapshot();
122 NS_IMETHODIMP_(already_AddRefed
<SourceSurface
>)
123 OrientedImage::GetFrame(uint32_t aWhichFrame
, uint32_t aFlags
) {
124 // Get a SourceSurface for the inner image then orient it according to
126 RefPtr
<SourceSurface
> innerSurface
=
127 InnerImage()->GetFrame(aWhichFrame
, aFlags
);
128 NS_ENSURE_TRUE(innerSurface
, nullptr);
130 return OrientSurface(mOrientation
, innerSurface
);
133 NS_IMETHODIMP_(already_AddRefed
<SourceSurface
>)
134 OrientedImage::GetFrameAtSize(const IntSize
& aSize
, uint32_t aWhichFrame
,
136 // Get a SourceSurface for the inner image then orient it according to
138 IntSize innerSize
= aSize
;
139 if (mOrientation
.SwapsWidthAndHeight()) {
140 swap(innerSize
.width
, innerSize
.height
);
142 RefPtr
<SourceSurface
> innerSurface
=
143 InnerImage()->GetFrameAtSize(innerSize
, aWhichFrame
, aFlags
);
144 NS_ENSURE_TRUE(innerSurface
, nullptr);
146 return OrientSurface(mOrientation
, innerSurface
);
150 OrientedImage::IsImageContainerAvailable(WindowRenderer
* aRenderer
,
152 if (mOrientation
.IsIdentity()) {
153 return InnerImage()->IsImageContainerAvailable(aRenderer
, aFlags
);
158 NS_IMETHODIMP_(ImgDrawResult
)
159 OrientedImage::GetImageContainerAtSize(
160 WindowRenderer
* aRenderer
, const gfx::IntSize
& aSize
,
161 const Maybe
<SVGImageContext
>& aSVGContext
,
162 const Maybe
<ImageIntRegion
>& aRegion
, uint32_t aFlags
,
163 layers::ImageContainer
** aOutContainer
) {
164 // XXX(seth): We currently don't have a way of orienting the result of
165 // GetImageContainer. We work around this by always returning null, but if it
166 // ever turns out that OrientedImage is widely used on codepaths that can
167 // actually benefit from GetImageContainer, it would be a good idea to fix
168 // that method for performance reasons.
170 if (mOrientation
.IsIdentity()) {
171 return InnerImage()->GetImageContainerAtSize(
172 aRenderer
, aSize
, aSVGContext
, aRegion
, aFlags
, aOutContainer
);
175 return ImgDrawResult::NOT_SUPPORTED
;
178 struct MatrixBuilder
{
179 explicit MatrixBuilder(bool aInvert
) : mInvert(aInvert
) {}
181 gfxMatrix
Build() { return mMatrix
; }
183 void Scale(gfxFloat aX
, gfxFloat aY
) {
185 mMatrix
*= gfxMatrix::Scaling(1.0 / aX
, 1.0 / aY
);
187 mMatrix
.PreScale(aX
, aY
);
191 void Rotate(gfxFloat aPhi
) {
193 mMatrix
*= gfxMatrix::Rotation(-aPhi
);
195 mMatrix
.PreRotate(aPhi
);
199 void Translate(gfxPoint aDelta
) {
201 mMatrix
*= gfxMatrix::Translation(-aDelta
);
203 mMatrix
.PreTranslate(aDelta
);
212 gfxMatrix
OrientedImage::OrientationMatrix(Orientation aOrientation
,
213 const nsIntSize
& aSize
,
214 bool aInvert
/* = false */) {
215 MatrixBuilder
builder(aInvert
);
217 // Apply reflection, if present. (For a regular, non-flipFirst reflection,
218 // this logically happens second, but we apply it first because these
219 // transformations are all premultiplied.) A translation is necessary to place
220 // the image back in the first quadrant.
221 if (aOrientation
.flip
== Flip::Horizontal
&& !aOrientation
.flipFirst
) {
222 if (aOrientation
.SwapsWidthAndHeight()) {
223 builder
.Translate(gfxPoint(aSize
.height
, 0));
225 builder
.Translate(gfxPoint(aSize
.width
, 0));
227 builder
.Scale(-1.0, 1.0);
230 // Apply rotation, if present. Again, a translation is used to place the
231 // image back in the first quadrant.
232 switch (aOrientation
.rotation
) {
236 builder
.Translate(gfxPoint(aSize
.height
, 0));
237 builder
.Rotate(-1.5 * M_PI
);
240 builder
.Translate(gfxPoint(aSize
.width
, aSize
.height
));
241 builder
.Rotate(-1.0 * M_PI
);
244 builder
.Translate(gfxPoint(0, aSize
.width
));
245 builder
.Rotate(-0.5 * M_PI
);
248 MOZ_ASSERT(false, "Invalid rotation value");
251 // Apply a flipFirst reflection.
252 if (aOrientation
.flip
== Flip::Horizontal
&& aOrientation
.flipFirst
) {
253 builder
.Translate(gfxPoint(aSize
.width
, 0.0));
254 builder
.Scale(-1.0, 1.0);
257 return builder
.Build();
260 NS_IMETHODIMP_(ImgDrawResult
)
261 OrientedImage::Draw(gfxContext
* aContext
, const nsIntSize
& aSize
,
262 const ImageRegion
& aRegion
, uint32_t aWhichFrame
,
263 SamplingFilter aSamplingFilter
,
264 const Maybe
<SVGImageContext
>& aSVGContext
, uint32_t aFlags
,
266 if (mOrientation
.IsIdentity()) {
267 return InnerImage()->Draw(aContext
, aSize
, aRegion
, aWhichFrame
,
268 aSamplingFilter
, aSVGContext
, aFlags
, aOpacity
);
271 // Update the image size to match the image's coordinate system. (This could
272 // be done using TransformBounds but since it's only a size a swap is enough.)
273 nsIntSize
size(aSize
);
274 if (mOrientation
.SwapsWidthAndHeight()) {
275 swap(size
.width
, size
.height
);
278 // Update the matrix so that we transform the image into the orientation
279 // expected by the caller before drawing.
280 gfxMatrix
matrix(OrientationMatrix(size
));
281 gfxContextMatrixAutoSaveRestore
saveMatrix(aContext
);
282 aContext
->Multiply(matrix
);
284 // The region is already in the orientation expected by the caller, but we
285 // need it to be in the image's coordinate system, so we transform it using
286 // the inverse of the orientation matrix.
287 gfxMatrix
inverseMatrix(OrientationMatrix(size
, /* aInvert = */ true));
288 ImageRegion
region(aRegion
);
289 region
.TransformBoundsBy(inverseMatrix
);
291 auto orientViewport
= [&](const SVGImageContext
& aOldContext
) {
292 SVGImageContext
context(aOldContext
);
293 auto oldViewport
= aOldContext
.GetViewportSize();
294 if (oldViewport
&& mOrientation
.SwapsWidthAndHeight()) {
295 // Swap width and height:
296 CSSIntSize
newViewport(oldViewport
->height
, oldViewport
->width
);
297 context
.SetViewportSize(Some(newViewport
));
302 return InnerImage()->Draw(aContext
, size
, region
, aWhichFrame
,
303 aSamplingFilter
, aSVGContext
.map(orientViewport
),
307 nsIntSize
OrientedImage::OptimalImageSizeForDest(const gfxSize
& aDest
,
308 uint32_t aWhichFrame
,
309 SamplingFilter aSamplingFilter
,
311 if (!mOrientation
.SwapsWidthAndHeight()) {
312 return InnerImage()->OptimalImageSizeForDest(aDest
, aWhichFrame
,
313 aSamplingFilter
, aFlags
);
316 // Swap the size for the calculation, then swap it back for the caller.
317 gfxSize
destSize(aDest
.height
, aDest
.width
);
318 nsIntSize
innerImageSize(InnerImage()->OptimalImageSizeForDest(
319 destSize
, aWhichFrame
, aSamplingFilter
, aFlags
));
320 return nsIntSize(innerImageSize
.height
, innerImageSize
.width
);
323 NS_IMETHODIMP_(nsIntRect
)
324 OrientedImage::GetImageSpaceInvalidationRect(const nsIntRect
& aRect
) {
325 nsIntRect
rect(InnerImage()->GetImageSpaceInvalidationRect(aRect
));
327 if (mOrientation
.IsIdentity()) {
332 nsresult rv
= InnerImage()->GetWidth(&innerSize
.width
);
333 rv
= NS_FAILED(rv
) ? rv
: InnerImage()->GetHeight(&innerSize
.height
);
335 // Fall back to identity if the width and height aren't available.
339 // Transform the invalidation rect into the correct orientation.
340 gfxMatrix
matrix(OrientationMatrix(innerSize
));
341 gfxRect
invalidRect(matrix
.TransformBounds(
342 gfxRect(rect
.X(), rect
.Y(), rect
.Width(), rect
.Height())));
344 return IntRect::RoundOut(invalidRect
.X(), invalidRect
.Y(),
345 invalidRect
.Width(), invalidRect
.Height());
349 } // namespace mozilla