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
|
/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkScaledImageCache_DEFINED
#define SkScaledImageCache_DEFINED
#include "SkBitmap.h"
class SkDiscardableMemory;
class SkMipMap;
/**
* Cache object for bitmaps (with possible scale in X Y as part of the key).
*
* Multiple caches can be instantiated, but each instance is not implicitly
* thread-safe, so if a given instance is to be shared across threads, the
* caller must manage the access itself (e.g. via a mutex).
*
* As a convenience, a global instance is also defined, which can be safely
* access across threads via the static methods (e.g. FindAndLock, etc.).
*/
class SkScaledImageCache {
public:
struct ID;
/**
* Returns a locked/pinned SkDiscardableMemory instance for the specified
* number of bytes, or NULL on failure.
*/
typedef SkDiscardableMemory* (*DiscardableFactory)(size_t bytes);
/*
* The following static methods are thread-safe wrappers around a global
* instance of this cache.
*/
static ID* FindAndLock(uint32_t pixelGenerationID,
int32_t width,
int32_t height,
SkBitmap* returnedBitmap);
static ID* FindAndLock(const SkBitmap& original, SkScalar scaleX,
SkScalar scaleY, SkBitmap* returnedBitmap);
static ID* FindAndLockMip(const SkBitmap& original,
SkMipMap const** returnedMipMap);
static ID* AddAndLock(uint32_t pixelGenerationID,
int32_t width,
int32_t height,
const SkBitmap& bitmap);
static ID* AddAndLock(const SkBitmap& original, SkScalar scaleX,
SkScalar scaleY, const SkBitmap& bitmap);
static ID* AddAndLockMip(const SkBitmap& original, const SkMipMap* mipMap);
static void Unlock(ID*);
static size_t GetBytesUsed();
static size_t GetByteLimit();
static size_t SetByteLimit(size_t newLimit);
static SkBitmap::Allocator* GetAllocator();
/**
* Call SkDebugf() with diagnostic information about the state of the cache
*/
static void Dump();
///////////////////////////////////////////////////////////////////////////
/**
* Construct the cache to call DiscardableFactory when it
* allocates memory for the pixels. In this mode, the cache has
* not explicit budget, and so methods like getBytesUsed() and
* getByteLimit() will return 0, and setByteLimit will ignore its argument
* and return 0.
*/
SkScaledImageCache(DiscardableFactory);
/**
* Construct the cache, allocating memory with malloc, and respect the
* byteLimit, purging automatically when a new image is added to the cache
* that pushes the total bytesUsed over the limit. Note: The limit can be
* changed at runtime with setByteLimit.
*/
SkScaledImageCache(size_t byteLimit);
~SkScaledImageCache();
/**
* Search the cache for a matching bitmap (using generationID,
* width, and height as a search key). If found, return it in
* returnedBitmap, and return its ID pointer. Use the returned
* ptr to unlock the cache when you are done using
* returnedBitmap.
*
* If a match is not found, returnedBitmap will be unmodifed, and
* NULL will be returned.
*
* This is used if there is no scaling or subsetting, for example
* by SkLazyPixelRef.
*/
ID* findAndLock(uint32_t pixelGenerationID, int32_t width, int32_t height,
SkBitmap* returnedBitmap);
/**
* Search the cache for a scaled version of original. If found,
* return it in returnedBitmap, and return its ID pointer. Use
* the returned ptr to unlock the cache when you are done using
* returnedBitmap.
*
* If a match is not found, returnedBitmap will be unmodifed, and
* NULL will be returned.
*/
ID* findAndLock(const SkBitmap& original, SkScalar scaleX,
SkScalar scaleY, SkBitmap* returnedBitmap);
ID* findAndLockMip(const SkBitmap& original,
SkMipMap const** returnedMipMap);
/**
* To add a new bitmap (or mipMap) to the cache, call
* AddAndLock. Use the returned ptr to unlock the cache when you
* are done using scaled.
*
* Use (generationID, width, and height) or (original, scaleX,
* scaleY) or (original) as a search key
*/
ID* addAndLock(uint32_t pixelGenerationID, int32_t width, int32_t height,
const SkBitmap& bitmap);
ID* addAndLock(const SkBitmap& original, SkScalar scaleX,
SkScalar scaleY, const SkBitmap& bitmap);
ID* addAndLockMip(const SkBitmap& original, const SkMipMap* mipMap);
/**
* Given a non-null ID ptr returned by either findAndLock or addAndLock,
* this releases the associated resources to be available to be purged
* if needed. After this, the cached bitmap should no longer be
* referenced by the caller.
*/
void unlock(ID*);
size_t getBytesUsed() const { return fBytesUsed; }
size_t getByteLimit() const { return fByteLimit; }
/**
* Set the maximum number of bytes available to this cache. If the current
* cache exceeds this new value, it will be purged to try to fit within
* this new limit.
*/
size_t setByteLimit(size_t newLimit);
SkBitmap::Allocator* allocator() const { return fAllocator; };
/**
* Call SkDebugf() with diagnostic information about the state of the cache
*/
void dump() const;
public:
struct Rec;
struct Key;
private:
Rec* fHead;
Rec* fTail;
class Hash;
Hash* fHash;
DiscardableFactory fDiscardableFactory;
// the allocator is NULL or one that matches discardables
SkBitmap::Allocator* fAllocator;
size_t fBytesUsed;
size_t fByteLimit;
int fCount;
Rec* findAndLock(uint32_t generationID, SkScalar sx, SkScalar sy,
const SkIRect& bounds);
Rec* findAndLock(const Key& key);
ID* addAndLock(Rec* rec);
void purgeRec(Rec*);
void purgeAsNeeded();
// linklist management
void moveToHead(Rec*);
void addToHead(Rec*);
void detach(Rec*);
void init(); // called by constructors
#ifdef SK_DEBUG
void validate() const;
#else
void validate() const {}
#endif
};
#endif
|
