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
|
/*
* Copyright 2006 The Android Open Source Project
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkGraphics_DEFINED
#define SkGraphics_DEFINED
#include "SkTypes.h"
class SK_API SkGraphics {
public:
/**
* Call this at process initialization time if your environment does not
* permit static global initializers that execute code. Note that
* Init() is not thread-safe.
*/
static void Init();
/**
* Call this to release any memory held privately, such as the font cache.
*/
static void Term();
/**
* Return the version numbers for the library. If the parameter is not
* null, it is set to the version number.
*/
static void GetVersion(int32_t* major, int32_t* minor, int32_t* patch);
/**
* Return the max number of bytes that should be used by the font cache.
* If the cache needs to allocate more, it will purge previous entries.
* This max can be changed by calling SetFontCacheLimit().
*/
static size_t GetFontCacheLimit();
/**
* Specify the max number of bytes that should be used by the font cache.
* If the cache needs to allocate more, it will purge previous entries.
*
* This function returns the previous setting, as if GetFontCacheLimit()
* had be called before the new limit was set.
*/
static size_t SetFontCacheLimit(size_t bytes);
/**
* Return the number of bytes currently used by the font cache.
*/
static size_t GetFontCacheUsed();
/**
* Return the number of entries in the font cache.
* A cache "entry" is associated with each typeface + pointSize + matrix.
*/
static int GetFontCacheCountUsed();
/**
* Return the current limit to the number of entries in the font cache.
* A cache "entry" is associated with each typeface + pointSize + matrix.
*/
static int GetFontCacheCountLimit();
/**
* Set the limit to the number of entries in the font cache, and return
* the previous value. If this new value is lower than the previous,
* it will automatically try to purge entries to meet the new limit.
*/
static int SetFontCacheCountLimit(int count);
/**
* For debugging purposes, this will attempt to purge the font cache. It
* does not change the limit, but will cause subsequent font measures and
* draws to be recreated, since they will no longer be in the cache.
*/
static void PurgeFontCache();
/**
* Scaling bitmaps with the SkPaint::kHigh_FilterLevel setting is
* expensive, so the result is saved in the global Scaled Image
* Cache.
*
* This function returns the memory usage of the Scaled Image Cache.
*/
static size_t GetResourceCacheTotalBytesUsed();
/**
* These functions get/set the memory usage limit for the resource cache, used for temporary
* bitmaps and other resources. Entries are purged from the cache when the memory useage
* exceeds this limit.
*/
static size_t GetResourceCacheTotalByteLimit();
static size_t SetResourceCacheTotalByteLimit(size_t newLimit);
/**
* When the cachable entry is very lage (e.g. a large scaled bitmap), adding it to the cache
* can cause most/all of the existing entries to be purged. To avoid the, the client can set
* a limit for a single allocation. If a cacheable entry would have been cached, but its size
* exceeds this limit, then we do not attempt to cache it at all.
*
* Zero is the default value, meaning we always attempt to cache entries.
*/
static size_t GetResourceCacheSingleAllocationByteLimit();
static size_t SetResourceCacheSingleAllocationByteLimit(size_t newLimit);
#ifdef SK_SUPPORT_LEGACY_IMAGECACHE_NAME
static size_t GetImageCacheBytesUsed() {
return GetImageCacheTotalBytesUsed();
}
static size_t GetImageCacheByteLimit() {
return GetImageCacheTotalByteLimit();
}
static size_t SetImageCacheByteLimit(size_t newLimit) {
return SetImageCacheTotalByteLimit(newLimit);
}
static size_t GetImageCacheTotalBytesUsed() {
return GetResourceCacheTotalBytesUsed();
}
static size_t GetImageCacheTotalByteLimit() {
return GetResourceCacheTotalByteLimit();
}
static size_t SetImageCacheTotalByteLimit(size_t newLimit) {
return SetResourceCacheTotalByteLimit(newLimit);
}
static size_t GetImageCacheSingleAllocationByteLimit() {
return GetResourceCacheSingleAllocationByteLimit();
}
static size_t SetImageCacheSingleAllocationByteLimit(size_t newLimit) {
return SetResourceCacheSingleAllocationByteLimit(newLimit);
}
#endif
/**
* Applications with command line options may pass optional state, such
* as cache sizes, here, for instance:
* font-cache-limit=12345678
*
* The flags format is name=value[;name=value...] with no spaces.
* This format is subject to change.
*/
static void SetFlags(const char* flags);
/**
* Return the max number of bytes that should be used by the thread-local
* font cache.
* If the cache needs to allocate more, it will purge previous entries.
* This max can be changed by calling SetFontCacheLimit().
*
* If this thread has never called SetTLSFontCacheLimit, or has called it
* with 0, then this thread is using the shared font cache. In that case,
* this function will always return 0, and the caller may want to call
* GetFontCacheLimit.
*/
static size_t GetTLSFontCacheLimit();
/**
* Specify the max number of bytes that should be used by the thread-local
* font cache. If this value is 0, then this thread will use the shared
* global font cache.
*/
static void SetTLSFontCacheLimit(size_t bytes);
private:
/** This is automatically called by SkGraphics::Init(), and must be
implemented by the host OS. This allows the host OS to register a callback
with the C++ runtime to call SkGraphics::FreeCaches()
*/
static void InstallNewHandler();
};
class SkAutoGraphics {
public:
SkAutoGraphics() {
SkGraphics::Init();
}
~SkAutoGraphics() {
SkGraphics::Term();
}
};
#endif
|
