1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef mozilla_image_SurfacePipeFactory_h
#define mozilla_image_SurfacePipeFactory_h
#include "SurfacePipe.h"
#include "SurfaceFilters.h"
namespace mozilla {
namespace image {
namespace detail {
/**
* FilterPipeline is a helper template for SurfacePipeFactory that determines
* the full type of the sequence of SurfaceFilters that a sequence of
* configuration structs corresponds to. To make this work, all configuration
* structs must include a typedef 'Filter' that identifies the SurfaceFilter
* they configure.
*/
template <typename... Configs>
struct FilterPipeline;
template <typename Config, typename... Configs>
struct FilterPipeline<Config, Configs...>
{
typedef typename Config::template Filter<typename FilterPipeline<Configs...>::Type> Type;
};
template <typename Config>
struct FilterPipeline<Config>
{
typedef typename Config::Filter Type;
};
} // namespace detail
/**
* Flags for SurfacePipeFactory, used in conjuction with the factory functions
* in SurfacePipeFactory to enable or disable various SurfacePipe
* functionality.
*/
enum class SurfacePipeFlags
{
DEINTERLACE = 1 << 0, // If set, deinterlace the image.
ADAM7_INTERPOLATE = 1 << 1, // If set, the caller is deinterlacing the
// image using ADAM7, and we may want to
// interpolate it for better intermediate results.
FLIP_VERTICALLY = 1 << 2, // If set, flip the image vertically.
PROGRESSIVE_DISPLAY = 1 << 3 // If set, we expect the image to be displayed
// progressively. This enables features that
// result in a better user experience for
// progressive display but which may be more
// computationally expensive.
};
MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(SurfacePipeFlags)
class SurfacePipeFactory
{
public:
/**
* Creates and initializes a normal (i.e., non-paletted) SurfacePipe.
*
* @param aDecoder The decoder whose current frame the SurfacePipe will write
* to.
* @param aInputSize The original size of the image.
* @param aOutputSize The size the SurfacePipe should output. Must be the same
* as @aInputSize or smaller. If smaller, the image will be
* downscaled during decoding.
* @param aFrameRect The portion of the image that actually contains data.
* @param aFormat The surface format of the image; generally B8G8R8A8 or
* B8G8R8X8.
* @param aAnimParams Extra parameters used by animated images.
* @param aFlags Flags enabling or disabling various functionality for the
* SurfacePipe; see the SurfacePipeFlags documentation for more
* information.
*
* @return A SurfacePipe if the parameters allowed one to be created
* successfully, or Nothing() if the SurfacePipe could not be
* initialized.
*/
static Maybe<SurfacePipe>
CreateSurfacePipe(Decoder* aDecoder,
const nsIntSize& aInputSize,
const nsIntSize& aOutputSize,
const nsIntRect& aFrameRect,
gfx::SurfaceFormat aFormat,
const Maybe<AnimationParams>& aAnimParams,
SurfacePipeFlags aFlags)
{
const bool deinterlace = bool(aFlags & SurfacePipeFlags::DEINTERLACE);
const bool flipVertically = bool(aFlags & SurfacePipeFlags::FLIP_VERTICALLY);
const bool progressiveDisplay = bool(aFlags & SurfacePipeFlags::PROGRESSIVE_DISPLAY);
const bool downscale = aInputSize != aOutputSize;
const bool removeFrameRect =
!aFrameRect.IsEqualEdges(nsIntRect(0, 0, aInputSize.width, aInputSize.height));
// Don't interpolate if we're sure we won't show this surface to the user
// until it's completely decoded. The final pass of an ADAM7 image doesn't
// need interpolation, so we only need to interpolate if we'll be displaying
// the image while it's still being decoded.
const bool adam7Interpolate = bool(aFlags & SurfacePipeFlags::ADAM7_INTERPOLATE) &&
progressiveDisplay;
if (deinterlace && adam7Interpolate) {
MOZ_ASSERT_UNREACHABLE("ADAM7 deinterlacing is handled by libpng");
return Nothing();
}
// Construct configurations for the SurfaceFilters. Note that the order of
// these filters is significant. We want to deinterlace or interpolate raw
// input rows, before any other transformations, and we want to remove the
// frame rect (which may involve adding blank rows or columns to the image)
// before any downscaling, so that the new rows and columns are taken into
// account.
DeinterlacingConfig<uint32_t> deinterlacingConfig { progressiveDisplay };
ADAM7InterpolatingConfig interpolatingConfig;
RemoveFrameRectConfig removeFrameRectConfig { aFrameRect };
DownscalingConfig downscalingConfig { aInputSize, aFormat };
SurfaceConfig surfaceConfig { aDecoder, aOutputSize, aFormat,
flipVertically, aAnimParams };
Maybe<SurfacePipe> pipe;
if (downscale) {
if (removeFrameRect) {
if (deinterlace) {
pipe = MakePipe(deinterlacingConfig, removeFrameRectConfig,
downscalingConfig, surfaceConfig);
} else if (adam7Interpolate) {
pipe = MakePipe(interpolatingConfig, removeFrameRectConfig,
downscalingConfig, surfaceConfig);
} else { // (deinterlace and adam7Interpolate are false)
pipe = MakePipe(removeFrameRectConfig, downscalingConfig, surfaceConfig);
}
} else { // (removeFrameRect is false)
if (deinterlace) {
pipe = MakePipe(deinterlacingConfig, downscalingConfig, surfaceConfig);
} else if (adam7Interpolate) {
pipe = MakePipe(interpolatingConfig, downscalingConfig, surfaceConfig);
} else { // (deinterlace and adam7Interpolate are false)
pipe = MakePipe(downscalingConfig, surfaceConfig);
}
}
} else { // (downscale is false)
if (removeFrameRect) {
if (deinterlace) {
pipe = MakePipe(deinterlacingConfig, removeFrameRectConfig, surfaceConfig);
} else if (adam7Interpolate) {
pipe = MakePipe(interpolatingConfig, removeFrameRectConfig, surfaceConfig);
} else { // (deinterlace and adam7Interpolate are false)
pipe = MakePipe(removeFrameRectConfig, surfaceConfig);
}
} else { // (removeFrameRect is false)
if (deinterlace) {
pipe = MakePipe(deinterlacingConfig, surfaceConfig);
} else if (adam7Interpolate) {
pipe = MakePipe(interpolatingConfig, surfaceConfig);
} else { // (deinterlace and adam7Interpolate are false)
pipe = MakePipe(surfaceConfig);
}
}
}
return pipe;
}
/**
* Creates and initializes a paletted SurfacePipe.
*
* XXX(seth): We'll remove all support for paletted surfaces in bug 1247520,
* which means we can remove CreatePalettedSurfacePipe() entirely.
*
* @param aDecoder The decoder whose current frame the SurfacePipe will write
* to.
* @param aInputSize The original size of the image.
* @param aFrameRect The portion of the image that actually contains data.
* @param aFormat The surface format of the image; generally B8G8R8A8 or
* B8G8R8X8.
* @param aPaletteDepth The palette depth of the image.
* @param aAnimParams Extra parameters used by animated images.
* @param aFlags Flags enabling or disabling various functionality for the
* SurfacePipe; see the SurfacePipeFlags documentation for more
* information.
*
* @return A SurfacePipe if the parameters allowed one to be created
* successfully, or Nothing() if the SurfacePipe could not be
* initialized.
*/
static Maybe<SurfacePipe>
CreatePalettedSurfacePipe(Decoder* aDecoder,
const nsIntSize& aInputSize,
const nsIntRect& aFrameRect,
gfx::SurfaceFormat aFormat,
uint8_t aPaletteDepth,
const Maybe<AnimationParams>& aAnimParams,
SurfacePipeFlags aFlags)
{
const bool deinterlace = bool(aFlags & SurfacePipeFlags::DEINTERLACE);
const bool flipVertically = bool(aFlags & SurfacePipeFlags::FLIP_VERTICALLY);
const bool progressiveDisplay = bool(aFlags & SurfacePipeFlags::PROGRESSIVE_DISPLAY);
// Construct configurations for the SurfaceFilters.
DeinterlacingConfig<uint8_t> deinterlacingConfig { progressiveDisplay };
PalettedSurfaceConfig palettedSurfaceConfig { aDecoder, aInputSize, aFrameRect,
aFormat, aPaletteDepth,
flipVertically, aAnimParams };
Maybe<SurfacePipe> pipe;
if (deinterlace) {
pipe = MakePipe(deinterlacingConfig, palettedSurfaceConfig);
} else {
pipe = MakePipe(palettedSurfaceConfig);
}
return pipe;
}
private:
template <typename... Configs>
static Maybe<SurfacePipe>
MakePipe(const Configs&... aConfigs)
{
auto pipe = MakeUnique<typename detail::FilterPipeline<Configs...>::Type>();
nsresult rv = pipe->Configure(aConfigs...);
if (NS_FAILED(rv)) {
return Nothing();
}
return Some(SurfacePipe { Move(pipe) } );
}
virtual ~SurfacePipeFactory() = 0;
};
} // namespace image
} // namespace mozilla
#endif // mozilla_image_SurfacePipeFactory_h
|
