1/*
2 * Copyright 2006 The Android Open Source Project
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#ifndef SkGraphics_DEFINED
9#define SkGraphics_DEFINED
10
11#include "SkTypes.h"
12
13class SK_API SkGraphics {
14public:
15    /**
16     *  Call this at process initialization time if your environment does not
17     *  permit static global initializers that execute code. Note that
18     *  Init() is not thread-safe.
19     */
20    static void Init();
21
22    /**
23     *  Call this to release any memory held privately, such as the font cache.
24     */
25    static void Term();
26
27    /**
28     *  Return the version numbers for the library. If the parameter is not
29     *  null, it is set to the version number.
30     */
31    static void GetVersion(int32_t* major, int32_t* minor, int32_t* patch);
32
33    /**
34     *  Return the max number of bytes that should be used by the font cache.
35     *  If the cache needs to allocate more, it will purge previous entries.
36     *  This max can be changed by calling SetFontCacheLimit().
37     */
38    static size_t GetFontCacheLimit();
39
40    /**
41     *  Specify the max number of bytes that should be used by the font cache.
42     *  If the cache needs to allocate more, it will purge previous entries.
43     *
44     *  This function returns the previous setting, as if GetFontCacheLimit()
45     *  had be called before the new limit was set.
46     */
47    static size_t SetFontCacheLimit(size_t bytes);
48
49    /**
50     *  Return the number of bytes currently used by the font cache.
51     */
52    static size_t GetFontCacheUsed();
53
54    /**
55     *  Return the number of entries in the font cache.
56     *  A cache "entry" is associated with each typeface + pointSize + matrix.
57     */
58    static int GetFontCacheCountUsed();
59
60    /**
61     *  Return the current limit to the number of entries in the font cache.
62     *  A cache "entry" is associated with each typeface + pointSize + matrix.
63     */
64    static int GetFontCacheCountLimit();
65
66    /**
67     *  Set the limit to the number of entries in the font cache, and return
68     *  the previous value. If this new value is lower than the previous,
69     *  it will automatically try to purge entries to meet the new limit.
70     */
71    static int SetFontCacheCountLimit(int count);
72
73    /**
74     *  For debugging purposes, this will attempt to purge the font cache. It
75     *  does not change the limit, but will cause subsequent font measures and
76     *  draws to be recreated, since they will no longer be in the cache.
77     */
78    static void PurgeFontCache();
79
80    /**
81     *  Scaling bitmaps with the kHigh_SkFilterQuality setting is
82     *  expensive, so the result is saved in the global Scaled Image
83     *  Cache.
84     *
85     *  This function returns the memory usage of the Scaled Image Cache.
86     */
87    static size_t GetResourceCacheTotalBytesUsed();
88
89    /**
90     *  These functions get/set the memory usage limit for the resource cache, used for temporary
91     *  bitmaps and other resources. Entries are purged from the cache when the memory useage
92     *  exceeds this limit.
93     */
94    static size_t GetResourceCacheTotalByteLimit();
95    static size_t SetResourceCacheTotalByteLimit(size_t newLimit);
96
97    /**
98     *  For debugging purposes, this will attempt to purge the resource cache. It
99     *  does not change the limit.
100     */
101    static void PurgeResourceCache();
102
103    /**
104     *  When the cachable entry is very lage (e.g. a large scaled bitmap), adding it to the cache
105     *  can cause most/all of the existing entries to be purged. To avoid the, the client can set
106     *  a limit for a single allocation. If a cacheable entry would have been cached, but its size
107     *  exceeds this limit, then we do not attempt to cache it at all.
108     *
109     *  Zero is the default value, meaning we always attempt to cache entries.
110     */
111    static size_t GetResourceCacheSingleAllocationByteLimit();
112    static size_t SetResourceCacheSingleAllocationByteLimit(size_t newLimit);
113
114    /**
115     *  Applications with command line options may pass optional state, such
116     *  as cache sizes, here, for instance:
117     *  font-cache-limit=12345678
118     *
119     *  The flags format is name=value[;name=value...] with no spaces.
120     *  This format is subject to change.
121     */
122    static void SetFlags(const char* flags);
123
124    /**
125     *  Return the max number of bytes that should be used by the thread-local
126     *  font cache.
127     *  If the cache needs to allocate more, it will purge previous entries.
128     *  This max can be changed by calling SetFontCacheLimit().
129     *
130     *  If this thread has never called SetTLSFontCacheLimit, or has called it
131     *  with 0, then this thread is using the shared font cache. In that case,
132     *  this function will always return 0, and the caller may want to call
133     *  GetFontCacheLimit.
134     */
135    static size_t GetTLSFontCacheLimit();
136
137    /**
138     *  Specify the max number of bytes that should be used by the thread-local
139     *  font cache. If this value is 0, then this thread will use the shared
140     *  global font cache.
141     */
142    static void SetTLSFontCacheLimit(size_t bytes);
143};
144
145class SkAutoGraphics {
146public:
147    SkAutoGraphics() {
148        SkGraphics::Init();
149    }
150    ~SkAutoGraphics() {
151        SkGraphics::Term();
152    }
153};
154
155#endif
156