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
|
/**
* @file lltexturecache.h
* @brief Object for managing texture cachees.
*
* $LicenseInfo:firstyear=2000&license=viewergpl$
*
* Copyright (c) 2000-2007, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlife.com/developers/opensource/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at http://secondlife.com/developers/opensource/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LLTEXTURECACHE_
#define LL_LLTEXTURECACHE_H
#include "lldir.h"
#include "llstl.h"
#include "llstring.h"
#include "lluuid.h"
#include "llworkerthread.h"
class LLTextureCacheWorker;
class LLTextureCache : public LLWorkerThread
{
friend class LLTextureCacheWorker;
friend class LLTextureCacheRemoteWorker;
friend class LLTextureCacheLocalFileWorker;
public:
class Responder : public LLResponder
{
public:
virtual void setData(U8* data, S32 datasize, S32 imagesize, S32 imageformat, BOOL imagelocal) = 0;
};
class ReadResponder : public Responder
{
public:
ReadResponder();
void setData(U8* data, S32 datasize, S32 imagesize, S32 imageformat, BOOL imagelocal);
void setImage(LLImageFormatted* image) { mFormattedImage = image; }
protected:
LLPointer<LLImageFormatted> mFormattedImage;
S32 mImageSize;
BOOL mImageLocal;
};
class WriteResponder : public Responder
{
void setData(U8* data, S32 datasize, S32 imagesize, S32 imageformat, BOOL imagelocal)
{
// not used
}
};
LLTextureCache(bool threaded);
~LLTextureCache();
/*virtual*/ S32 update(U32 max_time_ms);
void purgeCache(ELLPath location);
S64 initCache(ELLPath location, S64 maxsize, BOOL read_only);
handle_t readFromCache(const LLString& local_filename, const LLUUID& id, U32 priority, S32 offset, S32 size,
ReadResponder* responder);
handle_t readFromCache(const LLUUID& id, U32 priority, S32 offset, S32 size,
ReadResponder* responder);
bool readComplete(handle_t handle, bool abort);
handle_t writeToCache(const LLUUID& id, U32 priority, U8* data, S32 datasize, S32 imagesize,
WriteResponder* responder);
bool writeComplete(handle_t handle, bool abort = false);
void prioritizeWrite(handle_t handle);
void removeFromCache(const LLUUID& id);
// For LLTextureCacheWorker::Responder
LLTextureCacheWorker* getReader(handle_t handle);
LLTextureCacheWorker* getWriter(handle_t handle);
void lockWorkers() { mWorkersMutex.lock(); }
void unlockWorkers() { mWorkersMutex.unlock(); }
// debug
S32 getNumReads() { return mReaders.size(); }
S32 getNumWrites() { return mWriters.size(); }
protected:
// Accessed by LLTextureCacheWorker
apr_pool_t* getFileAPRPool() { return mFileAPRPool; }
bool appendToTextureEntryList(const LLUUID& id, S32 size);
std::string getLocalFileName(const LLUUID& id);
std::string getTextureFileName(const LLUUID& id);
void addCompleted(Responder* responder, bool success);
private:
void setDirNames(ELLPath location);
void readHeaderCache(apr_pool_t* poolp = NULL);
void purgeAllTextures(bool purge_directories);
void purgeTextures(bool validate);
S32 getHeaderCacheEntry(const LLUUID& id, bool touch, S32* imagesize = NULL);
bool removeHeaderCacheEntry(const LLUUID& id);
void lockHeaders() { mHeaderMutex.lock(); }
void unlockHeaders() { mHeaderMutex.unlock(); }
private:
// Internal
LLMutex mWorkersMutex;
LLMutex mHeaderMutex;
LLMutex mListMutex;
apr_pool_t* mFileAPRPool;
typedef std::map<handle_t, LLTextureCacheWorker*> handle_map_t;
handle_map_t mReaders;
handle_map_t mWriters;
typedef std::vector<handle_t> handle_list_t;
handle_list_t mPrioritizeWriteList;
typedef std::vector<std::pair<LLPointer<Responder>, bool> > responder_list_t;
responder_list_t mCompletedList;
BOOL mReadOnly;
// Entries
struct EntriesInfo
{
F32 mVersion;
U32 mEntries;
};
struct Entry
{
Entry() {}
Entry(const LLUUID& id, S32 size, U32 time) : mID(id), mSize(size), mTime(time) {}
LLUUID mID; // 128 bits
S32 mSize; // total size of image if known (NOT size cached)
U32 mTime; // seconds since 1/1/1970
};
// HEADERS (Include first mip)
std::string mHeaderEntriesFileName;
std::string mHeaderDataFileName;
EntriesInfo mHeaderEntriesInfo;
typedef std::map<S32,LLUUID> index_map_t;
index_map_t mLRU; // index, id; stored as a map for fast removal
typedef std::map<LLUUID,S32> id_map_t;
id_map_t mHeaderIDMap;
// BODIES (TEXTURES minus headers)
std::string mTexturesDirName;
std::string mTexturesDirEntriesFileName;
typedef std::map<LLUUID,S32> size_map_t;
size_map_t mTexturesSizeMap;
S64 mTexturesSizeTotal;
LLAtomic32<BOOL> mDoPurge;
// Statics
static F32 sHeaderCacheVersion;
static U32 sCacheMaxEntries;
static S64 sCacheMaxTexturesSize;
};
#endif // LL_LLTEXTURECACHE_H
|
