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
|
/* -*- 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 GFX_TILEDLAYERBUFFER_H
#define GFX_TILEDLAYERBUFFER_H
// Debug defines
//#define GFX_TILEDLAYER_DEBUG_OVERLAY
//#define GFX_TILEDLAYER_PREF_WARNINGS
//#define GFX_TILEDLAYER_RETAINING_LOG
#include <stdint.h> // for uint16_t, uint32_t
#include <sys/types.h> // for int32_t
#include <type_traits>
#include "mozilla/gfx/gfxVars.h"
#include "mozilla/gfx/Logging.h" // for gfxCriticalError
#include "mozilla/layers/LayersTypes.h" // for TextureDumpMode
#include "nsDebug.h" // for NS_ASSERTION
#include "nsPoint.h" // for nsIntPoint
#include "nsRect.h" // for mozilla::gfx::IntRect
#include "nsRegion.h" // for nsIntRegion
#include "nsTArray.h" // for nsTArray
namespace mozilla {
struct TileCoordUnit {};
template <>
struct IsPixel<TileCoordUnit> : std::true_type {};
namespace layers {
// You can enable all the TILING_LOG print statements by
// changing the 0 to a 1 in the following #define.
#define ENABLE_TILING_LOG 0
#if ENABLE_TILING_LOG
# define TILING_LOG(...) printf_stderr(__VA_ARGS__);
#else
# define TILING_LOG(...)
#endif
// Normal integer division truncates towards zero,
// we instead want to floor to hangle negative numbers.
static inline int floor_div(int a, int b) {
int rem = a % b;
int div = a / b;
if (rem == 0) {
return div;
} else {
// If the signs are different substract 1.
int sub;
sub = a ^ b;
// The results of this shift is either 0 or -1.
sub >>= 8 * sizeof(int) - 1;
return div + sub;
}
}
// Tiles are aligned to a grid with one of the grid points at (0,0) and other
// grid points spaced evenly in the x- and y-directions by GetTileSize()
// multiplied by mResolution. GetScaledTileSize() provides convenience for
// accessing these values.
//
// This tile buffer stores a valid region, which defines the areas that have
// up-to-date content. The contents of tiles within this region will be reused
// from paint to paint. It also stores the region that was modified in the last
// paint operation; this is useful when one tiled layer buffer shadows another
// (as in an off-main-thread-compositing scenario), so that the shadow tiled
// layer buffer can correctly reflect the updates of the master layer buffer.
//
// The associated Tile may be of any type as long as the derived class can
// validate and return tiles of that type. Tiles will be frequently copied, so
// the tile type should be a reference or some other type with an efficient
// copy constructor.
//
// The contents of the tile buffer will be rendered at the resolution specified
// in mResolution, which can be altered with SetResolution. The resolution
// should always be a factor of the tile length, to avoid tiles covering
// non-integer amounts of pixels.
// Size and Point in number of tiles rather than in pixels
typedef gfx::IntSizeTyped<TileCoordUnit> TileCoordIntSize;
typedef gfx::IntPointTyped<TileCoordUnit> TileCoordIntPoint;
/**
* Stores the origin and size of a tile buffer and handles switching between
* tile indices and tile coordinates.
*
* Tile coordinates in TileCoordIntPoint take the first tile offset into account
* which means that two TilesPlacement of the same layer and resolution give
* tile coordinates in the same coordinate space (useful when changing the
* offset and/or size of a tile buffer).
*/
struct TilesPlacement {
TileCoordIntPoint mFirst;
TileCoordIntSize mSize;
TilesPlacement(int aFirstX, int aFirstY, int aRetainedWidth,
int aRetainedHeight)
: mFirst(aFirstX, aFirstY), mSize(aRetainedWidth, aRetainedHeight) {}
int TileIndex(TileCoordIntPoint aCoord) const {
return (aCoord.x - mFirst.x) * mSize.height + aCoord.y - mFirst.y;
}
TileCoordIntPoint TileCoord(size_t aIndex) const {
return TileCoordIntPoint(mFirst.x + aIndex / mSize.height,
mFirst.y + aIndex % mSize.height);
}
bool HasTile(TileCoordIntPoint aCoord) const {
return aCoord.x >= mFirst.x && aCoord.x < mFirst.x + mSize.width &&
aCoord.y >= mFirst.y && aCoord.y < mFirst.y + mSize.height;
}
};
// Given a position i, this function returns the position inside the current
// tile.
inline int GetTileStart(int i, int aTileLength) {
return (i >= 0) ? (i % aTileLength)
: ((aTileLength - (-i % aTileLength)) % aTileLength);
}
// Rounds the given coordinate down to the nearest tile boundary.
inline int RoundDownToTileEdge(int aX, int aTileLength) {
return aX - GetTileStart(aX, aTileLength);
}
template <typename Derived, typename Tile>
class TiledLayerBuffer {
public:
TiledLayerBuffer()
: mTiles(0, 0, 0, 0),
mResolution(1),
mTileSize(mozilla::gfx::gfxVars::TileSize()) {}
~TiledLayerBuffer() = default;
gfx::IntPoint GetTileOffset(TileCoordIntPoint aPosition) const {
gfx::IntSize scaledTileSize = GetScaledTileSize();
return gfx::IntPoint(aPosition.x * scaledTileSize.width,
aPosition.y * scaledTileSize.height) +
mTileOrigin;
}
const TilesPlacement& GetPlacement() const { return mTiles; }
const gfx::IntSize& GetTileSize() const { return mTileSize; }
gfx::IntSize GetScaledTileSize() const {
return gfx::IntSize::Round(gfx::Size(mTileSize) / mResolution);
}
unsigned int GetTileCount() const { return mRetainedTiles.Length(); }
Tile& GetTile(size_t i) { return mRetainedTiles[i]; }
const nsIntRegion& GetValidRegion() const { return mValidRegion; }
// Get and set draw scaling. mResolution affects the resolution at which the
// contents of the buffer are drawn. mResolution has no effect on the
// coordinate space of the valid region, but does affect the size of an
// individual tile's rect in relation to the valid region.
// Setting the resolution will invalidate the buffer.
float GetResolution() const { return mResolution; }
bool IsLowPrecision() const { return mResolution < 1; }
void Dump(std::stringstream& aStream, const char* aPrefix, bool aDumpHtml,
TextureDumpMode aCompress);
protected:
nsIntRegion mValidRegion;
/**
* mRetainedTiles is a rectangular buffer of mTiles.mSize.width x
* mTiles.mSize.height stored as column major with the same origin as
* mValidRegion.GetBounds(). Any tile that does not intersect mValidRegion is
* a PlaceholderTile. Only the region intersecting with mValidRegion should be
* read from a tile, another other region is assumed to be uninitialized. The
* contents of the tiles is scaled by mResolution.
*/
nsTArray<Tile> mRetainedTiles;
TilesPlacement mTiles;
float mResolution;
gfx::IntSize mTileSize;
gfx::IntPoint mTileOrigin;
};
template <typename Derived, typename Tile>
void TiledLayerBuffer<Derived, Tile>::Dump(std::stringstream& aStream,
const char* aPrefix, bool aDumpHtml,
TextureDumpMode aCompress) {
for (size_t i = 0; i < mRetainedTiles.Length(); ++i) {
const TileCoordIntPoint tileCoord = mTiles.TileCoord(i);
gfx::IntPoint tileOffset = GetTileOffset(tileCoord);
aStream << "\n"
<< aPrefix << "Tile (x=" << tileOffset.x << ", y=" << tileOffset.y
<< "): ";
if (!mRetainedTiles[i].IsPlaceholderTile()) {
mRetainedTiles[i].DumpTexture(aStream, aCompress);
} else {
aStream << "empty tile";
}
}
}
} // namespace layers
} // namespace mozilla
#endif // GFX_TILEDLAYERBUFFER_H
|
